LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: gc
int gc(void) {
	int	i, k;
	char	buf[100];

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
cmpl $0x0, 0x1a712(%rip)     # 0x1e620
je 0x3f1c
leaq 0x1a70d(%rip), %rdi     # 0x1e624
callq 0x334f
xorl %eax, %eax
leaq 0x1a6db(%rip), %r14     # 0x1e600
movb (%rax,%r14), %cl
movl %ecx, %edx
andb $0x3f, %dl
movl %ecx, %esi
orb $0x40, %sil
testb %cl, %cl
movzbl %sil, %ecx
movzbl %dl, %edx
cmovsl %ecx, %edx
movb %dl, (%rax,%r14)
incq %rax
cmpq $0x20, %rax
jne 0x3f25
movq 0x1933c(%rip), %rax     # 0x1d290
testq %rax, %rax
je 0x3f74
leaq 0x19338(%rip), %rbx     # 0x1d298
movq (%rax), %rdi
callq 0x3cb0
movq (%rbx), %rax
addq $0x8, %rbx
testq %rax, %rax
jne 0x3f60
movq $-0x1, 0x1a6b9(%rip) # 0x1e638
cmpl $0x0, 0x1a64e(%rip)     # 0x1e5d4
jle 0x3fcf
xorl %eax, %eax
xorl %ebx, %ebx
movq 0x1a64d(%rip), %rcx     # 0x1e5e0
movb (%rcx,%rax), %dl
testb $0x2, %dl
jne 0x3fb8
movq 0x1a696(%rip), %rcx     # 0x1e638
movq 0x1a617(%rip), %rdx     # 0x1e5c0
movq %rcx, (%rdx,%rax,8)
movq %rax, 0x1a684(%rip)     # 0x1e638
incl %ebx
jmp 0x3fbe
andb $-0x3, %dl
movb %dl, (%rcx,%rax)
incq %rax
movslq 0x1a60c(%rip), %rcx     # 0x1e5d4
cmpq %rcx, %rax
jl 0x3f8c
jmp 0x3fd1
xorl %ebx, %ebx
leaq 0x1a1a8(%rip), %r15     # 0x1e180
xorl %r12d, %r12d
testb $0x40, (%r12,%r14)
jne 0x3ff6
movq (%r15), %rdi
testq %rdi, %rdi
je 0x3ff6
callq 0x3090
movq $0x0, (%r15)
incq %r12
addq $0x8, %r15
cmpq $0x20, %r12
jne 0x3fdb
cmpl $0x2, 0x1a0e6(%rip)     # 0x1e0f0
jl 0x403a
leaq 0x12228(%rip), %rsi     # 0x1623b
leaq -0x90(%rbp), %r14
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x31f0
movq %r14, %rdi
callq 0x3965
leaq 0x138c0(%rip), %rdi     # 0x178f5
callq 0x3965
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: unmark_vectors
void unmark_vectors(void) {
	int	p, k, link;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
callq 0x4049
callq 0x3ef8
movq 0x1a5ce(%rip), %rbx     # 0x1e678
testq %rbx, %rbx
jle 0x4128
xorl %eax, %eax
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x1a52a(%rip), %rcx     # 0x1e5e8
movslq 0x10(%rcx,%rax,8), %r12
addq $0x7, %r12
shrq $0x3, %r12
addl $0x3, %r12d
cmpq $-0x1, (%rcx,%rax,8)
je 0x4111
cmpl %r14d, %r15d
je 0x410e
leaq (%rcx,%rax,8), %rsi
movslq %r15d, %rbx
leaq (%rcx,%rbx,8), %rdi
movslq %r12d, %rdx
shlq $0x3, %rdx
callq 0x31a0
leal 0x3(%r15), %eax
cltq
movq 0x1a4c1(%rip), %rcx     # 0x1e5c0
movq 0x1a4e2(%rip), %rdx     # 0x1e5e8
movq (%rdx,%rbx,8), %rdx
movq %rax, (%rcx,%rdx,8)
addl %r12d, %r15d
addl %r14d, %r12d
movslq %r12d, %rax
movq 0x1a55a(%rip), %rbx     # 0x1e678
movl %r12d, %r14d
cmpq %rax, %rbx
jg 0x40b7
jmp 0x412b
xorl %r15d, %r15d
subl %r15d, %ebx
cmpl $0x2, 0x19fbb(%rip)     # 0x1e0f0
jl 0x4165
leaq 0x12187(%rip), %rsi     # 0x162c5
leaq -0x90(%rbp), %r14
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x31f0
movq %r14, %rdi
callq 0x3965
leaq 0x13795(%rip), %rdi     # 0x178f5
callq 0x3965
movslq %r15d, %rax
movq %rax, 0x1a509(%rip)     # 0x1e678
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: integer_value
cell integer_value(char *src, cell x) {
	char	msg[100];

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, 0x199bf(%rip)     # 0x1e110
movq 0x199d0(%rip), %rsi     # 0x1e128
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x199c2(%rip)     # 0x1e128
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x199ae(%rip)     # 0x1e128
movq $-0x1, 0x1998b(%rip) # 0x1e110
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4478
movq %rax, %rbx
movl $0x2, %edi
callq 0x3851
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: bignum_subtract
cell bignum_subtract(cell a, cell b) {
	Tmp = b;
	save(a);
	save(b);
	Tmp = NIL;
	a = x_bignum_subtract(a, b);
	unsave(2);
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, 0x19957(%rip)     # 0x1e110
movq 0x19968(%rip), %rsi     # 0x1e128
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x1995a(%rip)     # 0x1e128
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x19946(%rip)     # 0x1e128
movq $-0x1, 0x19923(%rip) # 0x1e110
movq %r14, %rdi
movq %rbx, %rsi
callq 0x49a2
movq %rax, %rbx
movl $0x2, %edi
callq 0x3851
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: bignum_less_p
int bignum_less_p(cell a, cell b) {
	int	ka, kb, neg_a, neg_b;

	neg_a = x_bignum_negative_p(a);
	neg_b = x_bignum_negative_p(b);
	if (neg_a && !neg_b) return 1;
	if (!neg_a && neg_b) return 0;
	ka = length(a);
	kb = length(b);
	if (ka < kb) return neg_a? 0: 1;
	if (ka > kb) return neg_a? 1: 0;
	Tmp = b;
	a = bignum_abs(a);
	save(a);
	b = bignum_abs(b);
	unsave(1);
	Tmp = NIL;
	a = cdr(a);
	b = cdr(b);
	while (a != NIL) {
		if (car(a) < car(b)) return neg_a? 0: 1;
		if (car(a) > car(b)) return neg_a? 1: 0;
		a = cdr(a);
		b = cdr(b);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq 0x1994e(%rip), %rcx     # 0x1e170
movq 0x19d97(%rip), %rax     # 0x1e5c0
movq (%rax,%rdi,8), %rdx
movq (%rcx,%rdx,8), %r12
testq %r12, %r12
setns %dl
movq (%rax,%rsi,8), %rsi
movq (%rcx,%rsi,8), %rcx
testq %rcx, %rcx
sets %sil
orb %dl, %sil
movl $0x1, %r14d
cmpb $0x1, %sil
jne 0x4930
testq %rcx, %rcx
sets %cl
testq %r12, %r12
setns %dl
xorl %r14d, %r14d
testb %cl, %dl
jne 0x4930
xorl %ecx, %ecx
movl $0x0, %edx
cmpq $-0x1, %rdi
je 0x488e
xorl %edx, %edx
movq %rdi, %rsi
incl %edx
movq (%rax,%rsi,8), %rsi
cmpq $-0x1, %rsi
jne 0x4882
cmpq $-0x1, %rbx
je 0x48a5
xorl %ecx, %ecx
movq %rbx, %rsi
incl %ecx
movq (%rax,%rsi,8), %rsi
cmpq $-0x1, %rsi
jne 0x4899
cmpl %ecx, %edx
jge 0x48b5
xorl %r14d, %r14d
testq %r12, %r12
setns %r14b
jmp 0x4930
jg 0x4929
movq %rbx, 0x19852(%rip)     # 0x1e110
callq 0x43a4
movq %rax, %r15
movq 0x1985b(%rip), %rsi     # 0x1e128
xorl %r14d, %r14d
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x19847(%rip)     # 0x1e128
movq %rbx, %rdi
callq 0x43a4
movq %rax, %rbx
movl $0x1, %edi
callq 0x3851
movq $-0x1, 0x1980f(%rip) # 0x1e110
movq 0x19cb8(%rip), %rax     # 0x1e5c0
movq 0x19861(%rip), %rcx     # 0x1e170
movq (%rax,%r15,8), %r15
cmpq $-0x1, %r15
je 0x4930
movq (%rax,%rbx,8), %rbx
movq (%rcx,%rbx,8), %rdx
cmpq %rdx, (%rcx,%r15,8)
jl 0x48a9
jle 0x490f
shrq $0x3f, %r12
movl %r12d, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: length
int length(cell n) {
	int	k = 0;

	while (n != NIL) {
		k++;
		n = cdr(n);
	}
	return k;
}

// Assembly:
cmpq $-0x1, %rdi
je 0x495d
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movq 0x19c71(%rip), %rcx     # 0x1e5c0
incl %eax
movq (%rcx,%rdi,8), %rdi
cmpq $-0x1, %rdi
jne 0x494f
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: bignum_equal_p
int bignum_equal_p(cell a, cell b) {
	a = cdr(a);
	b = cdr(b);
	while (a != NIL && b != NIL) {
		if (car(a) != car(b))
			return 0;
		a = cdr(a);
		b = cdr(b);
	}
	return a == NIL && b == NIL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x19c55(%rip), %rax     # 0x1e5c0
movq 0x197fe(%rip), %rcx     # 0x1e170
movq (%rax,%rsi,8), %rsi
movq (%rax,%rdi,8), %rdi
cmpq $-0x1, %rdi
je 0x4994
cmpq $-0x1, %rsi
je 0x4994
movq (%rcx,%rdi,8), %rdx
cmpq (%rcx,%rsi,8), %rdx
je 0x4972
xorl %eax, %eax
jmp 0x49a0
andq %rsi, %rdi
xorl %eax, %eax
cmpq $-0x1, %rdi
sete %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: bignum_shift_left
cell bignum_shift_left(cell a, int fill) {
	cell	r, c, result;
	int	carry;

	a = reverse_segments(cdr(a));
	save(a);
	carry = fill;
	result = NIL;
	save(result);
	while (a != NIL) {
		if (car(a) >= INT_SEG_LIMIT/10) {
			c = car(a) / (INT_SEG_LIMIT/10);
			r = car(a) % (INT_SEG_LIMIT/10) * 10;
			r += carry;
			carry = c;
		}
		else {
			r = car(a) * 10 + carry;
			carry = 0;
		}
		result = new_atom(r, result);
		car(Stack) = result;
		a = cdr(a);
	}
	if (carry)
		result = new_atom(carry, result);
	unsave(2);
	return new_atom(T_INTEGER, result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movq 0x198f5(%rip), %rax     # 0x1e5c0
movq (%rax,%rdi,8), %rdi
callq 0x442a
movq %rax, %r15
movq 0x1944a(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x19439(%rip)     # 0x1e128
movq $-0x1, %rbx
movq $-0x1, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x1941a(%rip)     # 0x1e128
cmpq $-0x1, %r15
je 0x4d98
movabsq $-0x543388ee7b9e3103, %r12 # imm = 0xABCC77118461CEFD
movq 0x19447(%rip), %rax     # 0x1e170
movq (%rax,%r15,8), %rcx
movslq %r14d, %rsi
cmpq $0x5f5e100, %rcx        # imm = 0x5F5E100
jl 0x4d5a
movq %rcx, %rax
mulq %r12
movq %rdx, %r14
shrq $0x1a, %r14
imulq $0x5f5e100, %r14, %rax  # imm = 0x5F5E100
subq %rax, %rcx
leaq (%rcx,%rcx,4), %rax
leaq (%rsi,%rax,2), %rdi
jmp 0x4d65
leaq (%rcx,%rcx,4), %rax
leaq (%rsi,%rax,2), %rdi
xorl %r14d, %r14d
movq %rbx, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rax, %rbx
movq 0x193f4(%rip), %rax     # 0x1e170
movq 0x193a5(%rip), %rcx     # 0x1e128
movq %rbx, (%rax,%rcx,8)
movq 0x19832(%rip), %rax     # 0x1e5c0
movq (%rax,%r15,8), %r15
cmpq $-0x1, %r15
jne 0x4d22
testl %r14d, %r14d
je 0x4db0
movslq %r14d, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rax, %rbx
movl $0x2, %edi
callq 0x3851
movq $-0x18, %rdi
movq %rbx, %rsi
movl $0x1, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x36e8
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: bignum_shift_right
cell bignum_shift_right(cell a) {
	cell	r, c, result;
	int	carry;

	a = cdr(a);
	save(a);
	carry = 0;
	result = NIL;
	save(result);
	while (a != NIL) {
		c = car(a) % 10;
		r = car(a) / 10;
		r += carry * (INT_SEG_LIMIT/10);
		carry = c;
		result = new_atom(r, result);
		car(Stack) = result;
		a = cdr(a);
	}
	result = reverse_segments(result);
	if (car(result) == 0 && cdr(result) != NIL)
		result = cdr(result);
	result = new_atom(T_INTEGER, result);
	car(Stack) = result;
	carry = make_integer(carry);
	unsave(2);
	return node(result, carry);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x197d5(%rip), %rax     # 0x1e5c0
movq (%rax,%rdi,8), %r12
movq 0x19332(%rip), %rsi     # 0x1e128
xorl %ebx, %ebx
movq %r12, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x1931f(%rip)     # 0x1e128
movq $-0x1, %r14
movq $-0x1, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x19300(%rip)     # 0x1e128
movq $-0x1, %r15
cmpq $-0x1, %r12
je 0x4eba
xorl %edi, %edi
movabsq $0x5f5e10000000000, %r13 # imm = 0x5F5E10000000000
imulq %r13, %rdi
movq 0x19320(%rip), %rax     # 0x1e170
movq (%rax,%r12,8), %rbx
movq %rbx, %rax
movabsq $0x6666666666666667, %rcx # imm = 0x6666666666666667
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x2, %rdx
addq %rdx, %rax
leaq (%rax,%rax), %rcx
leaq (%rcx,%rcx,4), %rcx
subq %rcx, %rbx
sarq $0x20, %rdi
addq %rax, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rax, %r15
movq 0x192d5(%rip), %rax     # 0x1e170
movq 0x19286(%rip), %rcx     # 0x1e128
movq %r15, (%rax,%rcx,8)
movq 0x19713(%rip), %rax     # 0x1e5c0
movq (%rax,%r12,8), %r12
movq %rbx, %rdi
cmpq $-0x1, %r12
jne 0x4e45
cmpq $-0x1, %r15
je 0x4ef3
movq $-0x1, %r14
movq 0x192a2(%rip), %rax     # 0x1e170
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rax, %r14
movq 0x196d7(%rip), %rax     # 0x1e5c0
movq (%rax,%r15,8), %r15
cmpq $-0x1, %r15
jne 0x4ec7
movq 0x19276(%rip), %rax     # 0x1e170
cmpq $0x0, (%rax,%r14,8)
jne 0x4f14
movq 0x196b8(%rip), %rax     # 0x1e5c0
movq (%rax,%r14,8), %rax
cmpq $-0x1, %rax
cmovneq %rax, %r14
movq $-0x18, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rax, %r14
movq 0x1923e(%rip), %rax     # 0x1e170
movq 0x191ef(%rip), %rcx     # 0x1e128
movq %r14, (%rax,%rcx,8)
movq %rbx, %rdi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x18, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rax, %rbx
movl $0x2, %edi
callq 0x3851
movslq %ebx, %rsi
movq %r14, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x36e8
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: bignum_multiply
cell bignum_multiply(cell a, cell b) {
	int	neg;
	cell	r, i, result;

	neg = x_bignum_negative_p(a) != x_bignum_negative_p(b);
	a = bignum_abs(a);
	save(a);
	b = bignum_abs(b);
	save(b);
	result = make_integer(0);
	save(result);
	while (!x_bignum_zero_p(a)) {
		if (Error_flag)
			break;
		r = bignum_shift_right(a);
		i = caddr(r);
		a = car(r);
		caddr(Stack) = a;
		while (i) {
			result = bignum_add(result, b);
			car(Stack) = result;
			i--;
		}
		b = bignum_shift_left(b, 0);
		cadr(Stack) = b;
	}
	if (neg)
		result = bignum_negate(result);
	unsave(3);
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x191cb(%rip), %rax     # 0x1e170
movq 0x19614(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rdi,8), %rdx
movq (%rcx,%rsi,8), %rcx
movq (%rax,%rcx,8), %r12
xorq (%rax,%rdx,8), %r12
callq 0x43a4
movq %rax, %rbx
movq 0x1915d(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x1914c(%rip)     # 0x1e128
movq %r14, %rdi
callq 0x43a4
movq %rax, %r14
movq 0x1913a(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x19129(%rip)     # 0x1e128
xorl %edi, %edi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x18, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rax, %r15
movq 0x190f8(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x190e7(%rip)     # 0x1e128
movq 0x19128(%rip), %rdx     # 0x1e170
movq 0x19571(%rip), %rax     # 0x1e5c0
movq (%rax,%rbx,8), %rcx
cmpq $0x0, (%rdx,%rcx,8)
jne 0x5065
cmpq $-0x1, (%rax,%rcx,8)
je 0x5104
cmpl $0x0, 0x19548(%rip)     # 0x1e5b4
jne 0x5104
movq %rbx, %rdi
callq 0x4dd6
movq 0x190ef(%rip), %rcx     # 0x1e170
movq 0x19538(%rip), %rdx     # 0x1e5c0
movq (%rdx,%rax,8), %rsi
movq (%rdx,%rsi,8), %rsi
movq (%rcx,%rsi,8), %r13
movq (%rcx,%rax,8), %rbx
movq 0x19089(%rip), %rax     # 0x1e128
movq (%rdx,%rax,8), %rax
movq (%rdx,%rax,8), %rax
movq %rbx, (%rcx,%rax,8)
testq %r13, %r13
je 0x50d5
movq %r15, %rdi
movq %r14, %rsi
callq 0x473d
movq %rax, %r15
movq 0x190ab(%rip), %rax     # 0x1e170
movq 0x1905c(%rip), %rcx     # 0x1e128
movq %r15, (%rax,%rcx,8)
decq %r13
jne 0x50b0
movq %r14, %rdi
xorl %esi, %esi
callq 0x4cb6
movq %rax, %r14
movq 0x19087(%rip), %rax     # 0x1e170
movq 0x194d0(%rip), %rcx     # 0x1e5c0
movq 0x19031(%rip), %rdx     # 0x1e128
movq (%rcx,%rdx,8), %rcx
movq %r14, (%rax,%rcx,8)
jmp 0x5041
testq %r12, %r12
jns 0x5114
movq %r15, %rdi
callq 0x43eb
movq %rax, %r15
movl $0x3, %edi
callq 0x3851
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: bignum_equalize
cell bignum_equalize(cell a, cell b) {
	cell	r, f, r0, f0;

	r0 = a;
	save(r0);
	f0 = make_integer(1);
	save(f0);
	r = r0;
	save(r);
	f = f0;
	save(f);
	while (bignum_less_p(r, b)) {
		cadddr(Stack) = r0 = r;
		caddr(Stack) = f0 = f;
		r = bignum_shift_left(r, 0);
		cadr(Stack) = r;
		f = bignum_shift_left(f, 0);
		car(Stack) = f;
	}
	unsave(4);
	return node(r0, f0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18fdd(%rip), %rsi     # 0x1e128
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x18fcf(%rip)     # 0x1e128
movl $0x1, %edi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x18, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rax, %r15
movq 0x18f9b(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x18f8a(%rip)     # 0x1e128
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x18f76(%rip)     # 0x1e128
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x18f62(%rip)     # 0x1e128
movq %r14, %rdi
movq %rbx, %rsi
callq 0x480d
testl %eax, %eax
je 0x5275
movq %r14, %r12
movq %r15, %r13
movq 0x18f8a(%rip), %rax     # 0x1e170
movq 0x193d3(%rip), %rcx     # 0x1e5c0
movq 0x18f34(%rip), %rdx     # 0x1e128
movq (%rcx,%rdx,8), %rdx
movq (%rcx,%rdx,8), %rdx
movq (%rcx,%rdx,8), %rdx
movq %r14, (%rax,%rdx,8)
movq 0x18f1d(%rip), %rdx     # 0x1e128
movq (%rcx,%rdx,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq %r15, (%rax,%rcx,8)
movq %r14, %rdi
xorl %esi, %esi
callq 0x4cb6
movq %rax, %r14
movq 0x18f45(%rip), %rax     # 0x1e170
movq 0x1938e(%rip), %rcx     # 0x1e5c0
movq 0x18eef(%rip), %rdx     # 0x1e128
movq (%rcx,%rdx,8), %rcx
movq %r14, (%rax,%rcx,8)
movq %r15, %rdi
xorl %esi, %esi
callq 0x4cb6
movq %rax, %r15
movq 0x18f1b(%rip), %rax     # 0x1e170
movq 0x18ecc(%rip), %rcx     # 0x1e128
movq %r15, (%rax,%rcx,8)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x480d
testl %eax, %eax
jne 0x51d9
jmp 0x527b
movq %r14, %r12
movq %r15, %r13
movl $0x4, %edi
callq 0x3851
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x36e8
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: bignum_divide
cell bignum_divide(cell x, cell a, cell b) {
	if (x_bignum_zero_p(b))
		return error("divide by zero", x);
	Tmp = b;
	save(a);
	save(b);
	Tmp = NIL;
	a = x_bignum_divide(a, b);
	unsave(2);
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq 0x18a87(%rip), %rdx     # 0x1e170
movq 0x18ed0(%rip), %rax     # 0x1e5c0
movq (%rax,%rbx,8), %rcx
cmpq $0x0, (%rdx,%rcx,8)
jne 0x5702
cmpq $-0x1, (%rax,%rcx,8)
je 0x5760
movq %rbx, 0x18a07(%rip)     # 0x1e110
movq 0x18a18(%rip), %rsi     # 0x1e128
movq %r14, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x18a07(%rip)     # 0x1e128
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x189f3(%rip)     # 0x1e128
movq $-0x1, 0x189d0(%rip) # 0x1e110
movq %r14, %rdi
movq %rbx, %rsi
callq 0x52a0
movq %rax, %rbx
movl $0x2, %edi
callq 0x3851
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rdi, %rsi
leaq 0x10c06(%rip), %rdi     # 0x16370
callq 0x33eb
movq $-0x5, %rax
jmp 0x575b
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: make_real
cell make_real(int flags, cell exp, cell mant) {
	cell	n;

	n = new_atom(exp, mant);
	n = new_atom(flags, n);
	return new_atom(T_REAL, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movq %rsi, %rdi
movq %rdx, %rsi
movl $0x1, %edx
callq 0x36e8
movslq %ebx, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x1f, %rdi
movq %rax, %rsi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x36e8
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: count_digits
cell count_digits(cell m) {
	int	k = 0;
	cell	x;

	x = car(m);
	k = 0;
	while (x != 0) {
		x /= 10;
		k++;
	}
	k = k==0? 1: k;
	m = cdr(m);
	while (m != NIL) {
		k += DIGITS_PER_WORD;
		m = cdr(m);
	}
	return k;
}

// Assembly:
movq 0x189af(%rip), %rax     # 0x1e170
movq (%rax,%rdi,8), %rcx
xorl %esi, %esi
testq %rcx, %rcx
je 0x57f9
movabsq $0x6666666666666667, %r8 # imm = 0x6666666666666667
movq %rcx, %rax
imulq %r8
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x2, %rdx
addq %rax, %rdx
incl %esi
addq $0x9, %rcx
cmpq $0x12, %rcx
movq %rdx, %rcx
ja 0x57d6
pushq %rbp
movq %rsp, %rbp
movq 0x18dbc(%rip), %rcx     # 0x1e5c0
movl %esi, %eax
cmpq $0x1, %rax
adcq $-0x9, %rax
movq (%rcx,%rdi,8), %rdi
addq $0x9, %rax
cmpq $-0x1, %rdi
jne 0x580e
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: flat_copy
cell flat_copy(cell n) {
	cell	a, m, new;

	if (n == NIL)
		return NIL;
	m = node3(NIL, NIL, Tag[n]);
	save(m);
	a = m;
	while (n != NIL) {
		car(a) = car(n);
		n = cdr(n);
		if (n != NIL) {
			set(cdr(a), node3(NIL, NIL, Tag[n]))
			a = cdr(a);
		}
	}
	unsave(1);
	return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $-0x1, %rdi
je 0x5b3c
movq %rdi, %rbx
movq 0x18b37(%rip), %rax     # 0x1e5e0
movsbl (%rax,%rdi), %edx
movq $-0x1, %rdi
movq $-0x1, %rsi
callq 0x36e8
movq %rax, %r14
movq 0x1865e(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x1864d(%rip)     # 0x1e128
movq %r14, %r15
movq 0x1868b(%rip), %rax     # 0x1e170
movq (%rax,%rbx,8), %rcx
movq %rcx, (%rax,%r15,8)
movq 0x18acc(%rip), %rax     # 0x1e5c0
movq (%rax,%rbx,8), %rbx
cmpq $-0x1, %rbx
je 0x5b2a
movq 0x18adb(%rip), %rax     # 0x1e5e0
movsbl (%rax,%rbx), %edx
movq $-0x1, %rdi
movq $-0x1, %rsi
callq 0x36e8
movq 0x18a9d(%rip), %rcx     # 0x1e5c0
movq %rax, (%rcx,%r15,8)
movq %rax, %r15
cmpq $-0x1, %rbx
jne 0x5ade
movl $0x1, %edi
callq 0x3851
jmp 0x5b43
movq $-0x1, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: bignum_to_real
cell bignum_to_real(cell a) {
	int	e, flags, d;
	cell	m, n;

	m = flat_copy(a);
	cadr(m) = labs(cadr(m));
	e = 0;
	if (length(cdr(m)) > MANTISSA_SEGMENTS) {
		d = count_digits(cdr(m));
		while (d > MANTISSA_SIZE) {
			m = bignum_shift_right(m);
			m = car(m);
			e++;
			d--;
		}
	}
	flags = x_bignum_negative_p(a)? REAL_NEGATIVE: 0;
	n = make_real(flags, e, cdr(m));
	return real_normalize(n, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x5a8b
movq %rax, %rdi
movq 0x18602(%rip), %rax     # 0x1e170
movq 0x18a4b(%rip), %r8      # 0x1e5c0
movq (%r8,%rdi,8), %rcx
movq (%rax,%rcx,8), %rdx
movq %rdx, %rsi
negq %rsi
cmovsq %rdx, %rsi
movq %rsi, (%rax,%rcx,8)
movq (%r8,%rdi,8), %r9
cmpq $-0x1, %r9
je 0x5c3f
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %r9, %rdx
movq (%r8,%rdx,8), %rdx
incl %ecx
cmpq $-0x1, %rdx
jne 0x5ba1
xorl %esi, %esi
cmpl $0x4, %ecx
jb 0x5c41
movq (%rax,%r9,8), %rcx
testq %rcx, %rcx
je 0x5bf0
xorl %esi, %esi
movabsq $0x6666666666666667, %r10 # imm = 0x6666666666666667
movq %rcx, %rax
imulq %r10
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x2, %rdx
addq %rax, %rdx
incl %esi
addq $0x9, %rcx
cmpq $0x12, %rcx
movq %rdx, %rcx
ja 0x5bcd
xorl %eax, %eax
cmpl $0x1, %esi
sbbl %esi, %eax
movq (%r8,%r9,8), %r9
addl $-0x9, %eax
cmpq $-0x1, %r9
jne 0x5bf7
movl $0xfffffff7, %r14d      # imm = 0xFFFFFFF7
subl %eax, %r14d
cmpl $0x25, %r14d
jl 0x5c3f
movl $0xffffffd3, %r15d      # imm = 0xFFFFFFD3
subl %eax, %r15d
movl $0x24, %r12d
callq 0x4dd6
movq 0x18542(%rip), %rcx     # 0x1e170
movq (%rcx,%rax,8), %rdi
incl %r12d
cmpl %r12d, %r14d
jne 0x5c22
movl %r15d, %esi
jmp 0x5c41
xorl %esi, %esi
movq 0x18528(%rip), %rax     # 0x1e170
movq 0x18971(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rbx,8), %rdx
movq (%rax,%rdx,8), %rax
shrq $0x3f, %rax
movq (%rcx,%rdi,8), %rdx
movl %eax, %edi
callq 0x5778
movq %rax, %rdi
xorl %esi, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x581e
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: real_abs
cell real_abs(cell a) {
	if (integer_p(a))
		return bignum_abs(a);
	if (x_real_negative_p(a))
		return x_real_negate(a);
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
js 0x5e5d
movq 0x1879d(%rip), %rax     # 0x1e5e0
testb $0x1, (%rax,%rdi)
je 0x5e5d
movq 0x18320(%rip), %rax     # 0x1e170
cmpq $-0x18, (%rax,%rdi,8)
jne 0x5e5d
popq %rbp
jmp 0x43a4
movq 0x1830c(%rip), %rcx     # 0x1e170
movq 0x18755(%rip), %rsi     # 0x1e5c0
movq (%rsi,%rdi,8), %rdx
movq (%rcx,%rdx,8), %rax
testb $0x1, %al
jne 0x5e7c
movq %rdi, %rax
popq %rbp
retq
movq (%rsi,%rdx,8), %r8
movq (%rsi,%r8,8), %rdx
cmpq $0x0, (%rcx,%rdx,8)
jne 0x5e92
cmpq $-0x1, (%rsi,%rdx,8)
je 0x5e77
andl $-0x2, %eax
movq (%rcx,%r8,8), %rsi
movl %eax, %edi
popq %rbp
jmp 0x5778
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: shift_mantissa
cell shift_mantissa(cell m) {
	m = new_atom(T_INTEGER, m);
	save(m);
	m = bignum_shift_right(m);
	m = car(m);
	unsave(1);
	return cdr(m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rsi
movq $-0x18, %rdi
movl $0x1, %edx
callq 0x36e8
movq %rax, %rbx
movq 0x18263(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x18252(%rip)     # 0x1e128
movq %rbx, %rdi
callq 0x4dd6
movq 0x1828b(%rip), %rcx     # 0x1e170
movq (%rcx,%rax,8), %rbx
movl $0x1, %edi
callq 0x3851
movq 0x186c6(%rip), %rax     # 0x1e5c0
movq (%rax,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: scale_mantissa
cell scale_mantissa(cell r, cell desired_e, int max_size) {
	int	dgs;
	cell	n, e;

	dgs = count_digits(x_real_mantissa(r));
	if (max_size && (max_size - dgs < x_real_exponent(r) - desired_e))
		return NIL;
	n = new_atom(T_INTEGER, flat_copy(x_real_mantissa(r)));
	save(n);
	e = x_real_exponent(r);
	while (e > desired_e) {
		n = bignum_shift_left(n, 0);
		car(Stack) = n;
		e--;
	}
	unsave(1);
	return make_real(x_real_flags(r), e, cdr(n));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ecx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x186a1(%rip), %r10     # 0x1e5c0
movq (%r10,%rdi,8), %rax
movq (%r10,%rax,8), %r8
movq (%r10,%r8,8), %rdi
movq 0x1823e(%rip), %r9      # 0x1e170
movq (%r9,%rdi,8), %rsi
xorl %r11d, %r11d
testq %rsi, %rsi
je 0x5f6c
movabsq $0x6666666666666667, %r15 # imm = 0x6666666666666667
movq %rsi, %rax
imulq %r15
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x2, %rdx
addq %rax, %rdx
incl %r11d
addq $0x9, %rsi
cmpq $0x12, %rsi
movq %rdx, %rsi
ja 0x5f48
cmpl $0x1, %r11d
adcl $0x0, %r11d
movslq %ecx, %rax
movslq %r11d, %rdx
subq %rdx, %rax
addq $0x9, %rax
movq %rdi, %rdx
movq (%r10,%rdx,8), %rdx
addq $-0x9, %rax
cmpq $-0x1, %rdx
jne 0x5f84
testl %ecx, %ecx
je 0x5fb2
movq (%r9,%r8,8), %rcx
subq %r14, %rcx
cmpq %rax, %rcx
jle 0x5fb2
movq $-0x1, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x5a8b
movq $-0x18, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rax, %r15
movq 0x18153(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x18142(%rip)     # 0x1e128
movq 0x18183(%rip), %rax     # 0x1e170
movq 0x185cc(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %r12
cmpq %r14, %r12
jle 0x602f
movq %r15, %rdi
xorl %esi, %esi
callq 0x4cb6
movq %rax, %r15
movq 0x18157(%rip), %rax     # 0x1e170
movq 0x18108(%rip), %rcx     # 0x1e128
movq %r15, (%rax,%rcx,8)
decq %r12
cmpq %r14, %r12
jg 0x6005
movq %r14, %r12
movl $0x1, %edi
callq 0x3851
movq 0x18130(%rip), %rax     # 0x1e170
movq 0x18579(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rbx,8), %rdx
movl (%rax,%rdx,8), %edi
movq (%rcx,%r15,8), %rdx
movq %r12, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5778
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: autoscale
void autoscale(cell *pa, cell *pb) {
	if (x_real_exponent(*pa) < x_real_exponent(*pb)) {
		*pb = scale_mantissa(*pb, x_real_exponent(*pa),
					MANTISSA_SIZE*2);
		return;
	}
	if (x_real_exponent(*pa) > x_real_exponent(*pb)) {
		*pa = scale_mantissa(*pa, x_real_exponent(*pb),
					MANTISSA_SIZE*2);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x180fa(%rip), %rax     # 0x1e170
movq 0x18543(%rip), %rdx     # 0x1e5c0
movq (%rdi), %rdi
movq (%rdx,%rdi,8), %rcx
movq (%rdx,%rcx,8), %rcx
movq (%rax,%rcx,8), %rsi
movq (%r14), %rcx
movq (%rdx,%rcx,8), %r8
movq (%rdx,%r8,8), %rdx
movq (%rax,%rdx,8), %rax
cmpq %rax, %rsi
jge 0x60b2
movq %rcx, %rdi
movl $0x48, %edx
callq 0x5f05
movq %rax, (%r14)
jmp 0x60c4
jle 0x60c4
movq %rax, %rsi
movl $0x48, %edx
callq 0x5f05
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: real_subtract
cell real_subtract(cell a, cell b) {
	cell	r;

	if (integer_p(b))
		b = bignum_negate(b);
	else
		b = x_real_negate(b);
	save(b);
	r = real_add(a, b);
	unsave(1);
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
js 0x6bc9
movq 0x17a35(%rip), %rax     # 0x1e5e0
testb $0x1, (%rax,%rsi)
je 0x6bc9
movq 0x175b8(%rip), %rax     # 0x1e170
cmpq $-0x18, (%rax,%rsi,8)
jne 0x6bc9
movq %rsi, %rdi
callq 0x43eb
jmp 0x6bf2
movq 0x175a0(%rip), %rax     # 0x1e170
movq 0x179e9(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rsi,8), %rdx
movl (%rax,%rdx,8), %edi
xorl $0x1, %edi
movq (%rcx,%rdx,8), %rdx
movq (%rax,%rdx,8), %rsi
movq (%rcx,%rdx,8), %rdx
callq 0x5778
movq %rax, %r14
movq 0x1752c(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x1751b(%rip)     # 0x1e128
movq %rbx, %rdi
movq %r14, %rsi
callq 0x67e5
movq %rax, %rbx
movl $0x1, %edi
callq 0x3851
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: real_multiply
cell real_multiply(cell a, cell b) {
	cell	r, m, e, ma, mb, ea, eb, neg;

	if (integer_p(a) && integer_p(b))
		return bignum_multiply(a, b);
	if (integer_p(a))
		a = bignum_to_real(a);
	save(a);
	if (integer_p(b))
		b = bignum_to_real(b);
	save(b);
	neg = x_real_negative_flag(a) != x_real_negative_flag(b);
	ea = x_real_exponent(a);
	eb = x_real_exponent(b);
	ma = new_atom(T_INTEGER, x_real_mantissa(a));
	cadr(Stack) = ma;
	mb = new_atom(T_INTEGER, x_real_mantissa(b));
	car(Stack) = mb;
	e = ea + eb;
	m = bignum_multiply(ma, mb);
	unsave(2);
	r = make_real(neg? REAL_NEGATIVE: 0, e, cdr(m));
	return real_normalize(r, "*");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
js 0x6ca2
movq 0x17996(%rip), %rcx     # 0x1e5e0
movb (%rcx,%r14), %al
testb $0x1, %al
je 0x6ca2
testq %rbx, %rbx
js 0x6c85
movq 0x17512(%rip), %rdx     # 0x1e170
cmpq $-0x18, (%rdx,%r14,8)
jne 0x6c85
testb $0x1, (%rcx,%rbx)
je 0x6c85
cmpq $-0x18, (%rdx,%rbx,8)
jne 0x6c85
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4f8d
testb $0x1, %al
je 0x6ca2
movq 0x174e0(%rip), %rax     # 0x1e170
cmpq $-0x18, (%rax,%r14,8)
jne 0x6ca2
movq %r14, %rdi
callq 0x5b51
movq %rax, %r14
movq 0x1747f(%rip), %rsi     # 0x1e128
movq %r14, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x1746e(%rip)     # 0x1e128
testq %rbx, %rbx
js 0x6ce5
movq 0x1791a(%rip), %rax     # 0x1e5e0
testb $0x1, (%rax,%rbx)
je 0x6ce5
movq 0x1749d(%rip), %rax     # 0x1e170
cmpq $-0x18, (%rax,%rbx,8)
jne 0x6ce5
movq %rbx, %rdi
callq 0x5b51
movq %rax, %rbx
movq 0x1743c(%rip), %rsi     # 0x1e128
movq %rbx, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x1742b(%rip)     # 0x1e128
movq 0x1746c(%rip), %rax     # 0x1e170
movq 0x178b5(%rip), %rcx     # 0x1e5c0
movq (%rcx,%r14,8), %rdx
movq (%rcx,%rbx,8), %rsi
movl (%rax,%rsi,8), %r14d
xorl (%rax,%rdx,8), %r14d
movq (%rcx,%rdx,8), %rdx
movq (%rcx,%rsi,8), %rsi
movq (%rax,%rsi,8), %r15
movq (%rcx,%rdx,8), %rsi
addq (%rax,%rdx,8), %r15
movq $-0x18, %rdi
movl $0x1, %edx
callq 0x36e8
movq %rax, %r12
movq 0x17426(%rip), %rax     # 0x1e170
movq 0x1786f(%rip), %rcx     # 0x1e5c0
movq 0x173d0(%rip), %rdx     # 0x1e128
movq (%rcx,%rdx,8), %rdx
movq %r12, (%rax,%rdx,8)
movq (%rcx,%rbx,8), %rax
movq (%rcx,%rax,8), %rax
movq (%rcx,%rax,8), %rsi
movq $-0x18, %rdi
movl $0x1, %edx
callq 0x36e8
movq 0x173ec(%rip), %rcx     # 0x1e170
movq 0x1739d(%rip), %rdx     # 0x1e128
movq %rax, (%rcx,%rdx,8)
movq %r12, %rdi
movq %rax, %rsi
callq 0x4f8d
movq %rax, %rbx
movl $0x2, %edi
callq 0x3851
andl $0x1, %r14d
movq 0x1780e(%rip), %rax     # 0x1e5c0
movq (%rax,%rbx,8), %rdx
movl %r14d, %edi
movq %r15, %rsi
callq 0x5778
leaq 0x106b7(%rip), %rsi     # 0x1747f
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x581e
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq 0x1706a(%rip), %rcx     # 0x1e170
movq 0x174b3(%rip), %rax     # 0x1e5c0
movq (%rax,%rdi,8), %rsi
movq (%rax,%rsi,8), %rdx
movq $-0x1, %rbx
cmpq $0x0, (%rcx,%rdx,8)
js 0x718c
testb $0x1, (%rcx,%rsi,8)
jne 0x712e
xorl %r14d, %r14d
jmp 0x7145
movq (%rax,%rdx,8), %rdx
movb $0x1, %r14b
cmpq $0x0, (%rcx,%rdx,8)
jne 0x7145
cmpq $-0x1, (%rax,%rdx,8)
setne %r14b
xorl %esi, %esi
xorl %edx, %edx
callq 0x5f05
cmpq $-0x1, %rax
je 0x718c
movq 0x17465(%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 %rax, %rbx
testb %r14b, %r14b
je 0x718c
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x43eb
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %rbx
pushq %rax
testq %rdi, %rdi
js 0x71ad
movq 0x1743a(%rip), %rax     # 0x1e5e0
movb (%rax,%rdi), %al
testb $0x1, %al
jne 0x71b9
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x16fb0(%rip), %rcx     # 0x1e170
movl $0x1, %ebx
cmpq $-0x18, (%rcx,%rdi,8)
je 0x71af
testb $0x1, %al
je 0x71ad
movq 0x16f99(%rip), %rax     # 0x1e170
cmpq $-0x1f, (%rax,%rdi,8)
jne 0x71ad
callq 0x70f8
cmpq $-0x1, %rax
jne 0x71af
jmp 0x71ad
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, -0x30(%rbp)
movq 0x16efc(%rip), %r15     # 0x1e100
cmpq $-0x1, %r15
je 0x7244
movq 0x173d7(%rip), %r12     # 0x1e5e8
movq 0x173a8(%rip), %r13     # 0x1e5c0
movq 0x16f51(%rip), %rbx     # 0x1e170
movq (%rbx,%r15,8), %r14
movq (%r13,%r14,8), %rax
leaq (%r12,%rax,8), %rdi
movq -0x30(%rbp), %rsi
callq 0x3110
testl %eax, %eax
je 0x724b
movq (%r13,%r15,8), %r15
cmpq $-0x1, %r15
jne 0x721f
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_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
incl %esi
movq $-0x22, %rdi
callq 0x417e
movq %rax, %r14
movq 0x17341(%rip), %rax     # 0x1e5c0
movq (%rax,%r14,8), %rdi
shlq $0x3, %rdi
addq 0x1735a(%rip), %rdi     # 0x1e5e8
movq %rbx, %rsi
callq 0x3060
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x71eb
cmpq $-0x1, %rax
jne 0x730e
movq %rbx, %rdi
callq 0x30a0
leal 0x1(%rax), %esi
movq $-0x22, %rdi
callq 0x417e
movq %rax, %r14
movq 0x172ec(%rip), %rax     # 0x1e5c0
movq (%rax,%r14,8), %rdi
shlq $0x3, %rdi
addq 0x17305(%rip), %rdi     # 0x1e5e8
movq %rbx, %rsi
callq 0x3060
movq 0x16e0e(%rip), %rsi     # 0x1e100
movq %r14, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x16dfd(%rip)     # 0x1e100
movq 0x16e66(%rip), %rcx     # 0x1e170
movq (%rcx,%rax,8), %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movzbl (%rdi), %eax
movl $0x1, %r12d
cmpl $0x2b, %eax
je 0x7981
cmpl $0x2d, %eax
jne 0x7984
incq %rdi
movq $-0x1, %r12
jmp 0x7984
incq %rdi
movq %rdi, %rbx
cmpb $0x30, (%rdi)
jne 0x7996
leaq 0x1(%rbx), %rdi
cmpb $0x0, 0x1(%rbx)
jne 0x7984
movq %rbx, %rdi
callq 0x30a0
movq %rax, %r14
movq $-0x1, %r15
testl %r14d, %r14d
je 0x79f3
cmpl $0x9, %r14d
movl $0x9, %eax
cmovll %r14d, %eax
subl %eax, %r14d
movslq %r14d, %r13
leaq (%rbx,%r13), %rdi
callq 0x31b0
movb $0x0, (%rbx,%r13)
testl %r13d, %r13d
movl $0x1, %edi
cmoveq %r12, %rdi
imulq %rax, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rax, %r15
testl %r13d, %r13d
jne 0x79ad
movq $-0x18, %rdi
movq %r15, %rsi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x36e8
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
incl %ebx
movq $-0x21, %rdi
movl %ebx, %esi
callq 0x417e
movq %rax, %r15
movq 0x16886(%rip), %rax     # 0x1e5c0
movq (%rax,%r15,8), %rdi
shlq $0x3, %rdi
addq 0x1689f(%rip), %rdi     # 0x1e5e8
movslq %ebx, %rdx
movq %r14, %rsi
callq 0x3050
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdi, %rax
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0x7d85
cmpl $0x65, %ecx
je 0x7d7f
cmpl $0x2e, %ecx
je 0x7d7f
incq %rax
jmp 0x7d69
popq %rbp
jmp 0x7a15
popq %rbp
jmp 0x7954
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
movsbl (%r14,%r12), %edi
callq 0x3140
movl %eax, %r15d
movsbl (%rbx,%r12), %edi
callq 0x3140
testl %r15d, %r15d
je 0x7df5
testl %eax, %eax
je 0x7df5
incq %r12
cmpl %eax, %r15d
je 0x7dcd
xorl %ecx, %ecx
cmpl %eax, %r15d
setg %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovgel %ecx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edx, %edx
je 0x7e57
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
decl %ebx
xorl %r13d, %r13d
movsbl (%r15,%r13), %edi
callq 0x3140
movl %eax, %r12d
movsbl (%r14,%r13), %edi
callq 0x3140
cmpl %eax, %r12d
jne 0x7e5c
leaq 0x1(%r13), %rcx
cmpl %r13d, %ebx
movq %rcx, %r13
jne 0x7e2d
jmp 0x7e5c
xorl %eax, %eax
xorl %r12d, %r12d
xorl %ecx, %ecx
cmpl %eax, %r12d
setg %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovgel %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x410, %rsp            # imm = 0x410
movslq 0x16804(%rip), %rax     # 0x1e698
leaq 0x162e5(%rip), %r14     # 0x1e180
movq (%r14,%rax,8), %rdi
callq 0x3220
cmpl $0x22, %eax
jne 0x7eb3
movb $0x1, %r15b
xorl %ebx, %ebx
jmp 0x7f3e
xorl %r15d, %r15d
xorl %r12d, %r12d
xorl %ebx, %ebx
cmpl $-0x1, %eax
je 0x7f9a
cmpl $0x0, 0x166e9(%rip)     # 0x1e5b4
jne 0x7f37
cmpl $0x3fe, %ebx            # imm = 0x3FE
jge 0x7fa3
testb $0x1, %r12b
je 0x7efc
cmpl $0x22, %eax
je 0x7efc
cmpl $0x5c, %eax
je 0x7efc
movslq %ebx, %rcx
incl %ebx
movb $0x5c, -0x430(%rbp,%rcx)
movl $0x1, %r15d
movslq %ebx, %rbx
movb %al, -0x430(%rbp,%rbx)
cmpl $0x5c, %eax
sete %al
xorb $0x1, %r12b
andb %al, %r12b
movl %r12d, %eax
xorb $0x1, %al
movzbl %al, %eax
addl %eax, %ebx
movslq 0x16774(%rip), %rax     # 0x1e698
movq (%r14,%rax,8), %rdi
callq 0x3220
cmpl $0x22, %eax
jne 0x7ebb
testb %r12b, %r12b
jne 0x7ebb
testl %r15d, %r15d
sete %r15b
movslq %ebx, %r14
movb $0x0, -0x430(%rbp,%r14)
incl %r14d
movq $-0x21, %rdi
movl %r14d, %esi
callq 0x417e
movq %rax, %rbx
movq 0x1665a(%rip), %rax     # 0x1e5c0
movq (%rax,%rbx,8), %rdi
shlq $0x3, %rdi
addq 0x16673(%rip), %rdi     # 0x1e5e8
movslq %r14d, %rdx
leaq -0x430(%rbp), %rsi
callq 0x3050
testb %r15b, %r15b
jne 0x7fbd
leaq 0xe509(%rip), %rdi      # 0x16499
movq %rbx, %rsi
callq 0x33eb
jmp 0x7fbd
leaq 0xe4c2(%rip), %rdi      # 0x16463
jmp 0x7faa
leaq 0xe4d7(%rip), %rdi      # 0x16481
movq $-0x8, %rsi
callq 0x33eb
movq $-0x5, %rbx
movq %rbx, %rax
addq $0x410, %rsp            # imm = 0x410
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r14
pushq %rbx
movslq 0x166ba(%rip), %rax     # 0x1e698
leaq 0x1619b(%rip), %rcx     # 0x1e180
movq (%rcx,%rax,8), %rdi
callq 0x3220
cmpl $0x22, %eax
jne 0x8088
callq 0x7e7b
movq %rax, %rbx
movq 0x165ba(%rip), %rax     # 0x1e5c0
movq (%rax,%rbx,8), %r14
shlq $0x3, %r14
addq 0x165d3(%rip), %r14     # 0x1e5e8
leaq 0xe4bb(%rip), %rsi      # 0x164d7
movq %r14, %rdi
callq 0x3110
testl %eax, %eax
je 0x80a7
leaq 0xe4b2(%rip), %rsi      # 0x164e1
movq %r14, %rdi
callq 0x3110
testl %eax, %eax
je 0x80ae
leaq 0xf474(%rip), %rsi      # 0x174b6
movq %r14, %rdi
callq 0x3110
testl %eax, %eax
je 0x80b5
leaq 0xefe6(%rip), %rsi      # 0x1703b
movq %r14, %rdi
callq 0x3110
testl %eax, %eax
je 0x80bc
leaq 0xe481(%rip), %rsi      # 0x164e9
movq %r14, %rdi
callq 0x3110
testl %eax, %eax
je 0x80c3
movq %r14, %rdi
callq 0x30a0
cmpq $0x1, %rax
jne 0x80f1
movzbl (%r14), %edi
jmp 0x80c8
leaq 0xe42c(%rip), %rdi      # 0x164bb
movq $-0x8, %rsi
callq 0x33eb
movq $-0x5, %rax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x5c, %edi
jmp 0x80c8
movl $0xa, %edi
jmp 0x80c8
movl $0x22, %edi
jmp 0x80c8
movl $0x20, %edi
jmp 0x80c8
movl $0x9, %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
leaq 0xe3f5(%rip), %rdi      # 0x164ed
movq %rbx, %rsi
jmp 0x8096