LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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, 0x19966(%rip)     # 0x1e110
movq 0x19977(%rip), %rsi     # 0x1e128
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x19969(%rip)     # 0x1e128
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x19955(%rip)     # 0x1e128
movq $-0x1, 0x19932(%rip) # 0x1e110
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4993
movq %rax, %rbx
movl $0x2, %edi
callq 0x384f
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1995d(%rip), %rcx     # 0x1e170
movq 0x19da6(%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 0x4921
testq %rcx, %rcx
sets %cl
testq %r12, %r12
setns %dl
xorl %r14d, %r14d
testb %cl, %dl
jne 0x4921
xorl %ecx, %ecx
movl $0x0, %edx
cmpq $-0x1, %rdi
je 0x487f
xorl %edx, %edx
movq %rdi, %rsi
incl %edx
movq (%rax,%rsi,8), %rsi
cmpq $-0x1, %rsi
jne 0x4873
cmpq $-0x1, %rbx
je 0x4896
xorl %ecx, %ecx
movq %rbx, %rsi
incl %ecx
movq (%rax,%rsi,8), %rsi
cmpq $-0x1, %rsi
jne 0x488a
cmpl %ecx, %edx
jge 0x48a6
xorl %r14d, %r14d
testq %r12, %r12
setns %r14b
jmp 0x4921
jg 0x491a
movq %rbx, 0x19861(%rip)     # 0x1e110
callq 0x4392
movq %rax, %r15
movq 0x1986a(%rip), %rsi     # 0x1e128
xorl %r14d, %r14d
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x19856(%rip)     # 0x1e128
movq %rbx, %rdi
callq 0x4392
movq %rax, %rbx
movl $0x1, %edi
callq 0x384f
movq $-0x1, 0x1981e(%rip) # 0x1e110
movq 0x19cc7(%rip), %rax     # 0x1e5c0
movq 0x19870(%rip), %rcx     # 0x1e170
movq (%rax,%r15,8), %r15
cmpq $-0x1, %r15
je 0x4921
movq (%rax,%rbx,8), %rbx
movq (%rcx,%rbx,8), %rdx
cmpq %rdx, (%rcx,%r15,8)
jl 0x489a
jle 0x4900
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_O3/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 0x494e
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movq 0x19c80(%rip), %rcx     # 0x1e5c0
incl %eax
movq (%rcx,%rdi,8), %rdi
cmpq $-0x1, %rdi
jne 0x4940
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x19c64(%rip), %rax     # 0x1e5c0
movq 0x1980d(%rip), %rcx     # 0x1e170
movq (%rax,%rsi,8), %rsi
movq (%rax,%rdi,8), %rdi
cmpq $-0x1, %rdi
je 0x4985
cmpq $-0x1, %rsi
je 0x4985
movq (%rcx,%rdi,8), %rdx
cmpq (%rcx,%rsi,8), %rdx
je 0x4963
xorl %eax, %eax
jmp 0x4991
andq %rsi, %rdi
xorl %eax, %eax
cmpq $-0x1, %rdi
sete %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x19901(%rip), %rax     # 0x1e5c0
movq (%rax,%rdi,8), %rdi
callq 0x4418
movq %rax, %r15
movq 0x19456(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x19445(%rip)     # 0x1e128
movq $-0x1, %rbx
movq $-0x1, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x19426(%rip)     # 0x1e128
cmpq $-0x1, %r15
je 0x4d8c
movq 0x1945d(%rip), %rax     # 0x1e170
movabsq $-0x543388ee7b9e3103, %r12 # imm = 0xABCC77118461CEFD
movq (%rax,%r15,8), %rcx
movslq %r14d, %rsi
cmpq $0x5f5e100, %rcx        # imm = 0x5F5E100
jl 0x4d4e
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 0x4d59
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 0x19400(%rip), %rax     # 0x1e170
movq 0x193b1(%rip), %rcx     # 0x1e128
movq %rbx, (%rax,%rcx,8)
movq 0x1983e(%rip), %rcx     # 0x1e5c0
movq (%rcx,%r15,8), %r15
cmpq $-0x1, %r15
jne 0x4d1d
testl %r14d, %r14d
je 0x4da4
movslq %r14d, %rdi
movq %rbx, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rax, %rbx
movl $0x2, %edi
callq 0x384f
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_O3/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 0x197e1(%rip), %rax     # 0x1e5c0
movq (%rax,%rdi,8), %r15
movq 0x1933e(%rip), %rsi     # 0x1e128
xorl %ebx, %ebx
movq %r15, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x1932b(%rip)     # 0x1e128
movq $-0x1, %r12
movq $-0x1, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x1930c(%rip)     # 0x1e128
cmpq $-0x1, %r15
je 0x4ee3
movq $-0x1, %r14
movq 0x1933c(%rip), %rax     # 0x1e170
xorl %ebx, %ebx
movabsq $0x6666666666666667, %r12 # imm = 0x6666666666666667
movabsq $0x5f5e10000000000, %r13 # imm = 0x5F5E10000000000
movq %rbx, %rdi
imulq %r13, %rdi
movq (%rax,%r15,8), %rbx
movq %rbx, %rax
imulq %r12
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 %r14, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rax, %r14
movq 0x192de(%rip), %rax     # 0x1e170
movq 0x1928f(%rip), %rcx     # 0x1e128
movq %r14, (%rax,%rcx,8)
movq 0x1971c(%rip), %rcx     # 0x1e5c0
movq (%rcx,%r15,8), %r15
cmpq $-0x1, %r15
jne 0x4e4a
movq $-0x1, %r12
cmpq $-0x1, %r14
je 0x4ee3
movq 0x192ae(%rip), %rax     # 0x1e170
movq (%rax,%r14,8), %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rax, %r12
movq 0x196e3(%rip), %rax     # 0x1e5c0
movq (%rax,%r14,8), %r14
jmp 0x4eb5
movq 0x19286(%rip), %rax     # 0x1e170
cmpq $0x0, (%rax,%r12,8)
jne 0x4f04
movq 0x196c8(%rip), %rax     # 0x1e5c0
movq (%rax,%r12,8), %rax
cmpq $-0x1, %rax
cmovneq %rax, %r12
movq $-0x18, %rdi
movq %r12, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rax, %r14
movq 0x1924e(%rip), %rax     # 0x1e170
movq 0x191ff(%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 0x384f
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_O3/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 0x191db(%rip), %rax     # 0x1e170
movq 0x19624(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rdi,8), %rdx
movq (%rcx,%rsi,8), %rcx
movq (%rax,%rcx,8), %r12
xorq (%rax,%rdx,8), %r12
callq 0x4392
movq %rax, %rbx
movq 0x1916d(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x1915c(%rip)     # 0x1e128
movq %r14, %rdi
callq 0x4392
movq %rax, %r14
movq 0x1914a(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x19139(%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 0x19108(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x190f7(%rip)     # 0x1e128
movq 0x19138(%rip), %rcx     # 0x1e170
movq 0x19581(%rip), %rax     # 0x1e5c0
movq (%rax,%rbx,8), %rdx
cmpq $0x0, (%rcx,%rdx,8)
jne 0x5055
cmpq $-0x1, (%rax,%rdx,8)
je 0x50f4
cmpl $0x0, 0x19558(%rip)     # 0x1e5b4
jne 0x50f4
movq %rbx, %rdi
callq 0x4dca
movq 0x190ff(%rip), %rcx     # 0x1e170
movq 0x19548(%rip), %rdx     # 0x1e5c0
movq (%rdx,%rax,8), %rsi
movq (%rdx,%rsi,8), %rsi
movq (%rcx,%rsi,8), %r13
movq (%rcx,%rax,8), %rbx
movq 0x19099(%rip), %rax     # 0x1e128
movq (%rdx,%rax,8), %rax
movq (%rdx,%rax,8), %rax
movq %rbx, (%rcx,%rax,8)
testq %r13, %r13
je 0x50c5
movq %r15, %rdi
movq %r14, %rsi
callq 0x472e
movq %rax, %r15
movq 0x190bb(%rip), %rax     # 0x1e170
movq 0x1906c(%rip), %rcx     # 0x1e128
movq %r15, (%rax,%rcx,8)
decq %r13
jne 0x50a0
movq %r14, %rdi
xorl %esi, %esi
callq 0x4caa
movq %rax, %r14
movq 0x19097(%rip), %rcx     # 0x1e170
movq 0x194e0(%rip), %rax     # 0x1e5c0
movq 0x19041(%rip), %rdx     # 0x1e128
movq (%rax,%rdx,8), %rdx
movq %r14, (%rcx,%rdx,8)
jmp 0x503f
testq %r12, %r12
jns 0x5104
movq %r15, %rdi
callq 0x43d9
movq %rax, %r15
movl $0x3, %edi
callq 0x384f
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_O3/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 0x18fed(%rip), %rsi     # 0x1e128
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x18fdf(%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 0x18fab(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x18f9a(%rip)     # 0x1e128
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x18f86(%rip)     # 0x1e128
movq %r15, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x18f72(%rip)     # 0x1e128
movq %r14, %rdi
movq %rbx, %rsi
callq 0x47fe
testl %eax, %eax
je 0x5265
movq %r14, %r12
movq %r15, %r13
movq 0x18f9a(%rip), %rax     # 0x1e170
movq 0x193e3(%rip), %rcx     # 0x1e5c0
movq 0x18f44(%rip), %rdx     # 0x1e128
movq (%rcx,%rdx,8), %rdx
movq (%rcx,%rdx,8), %rdx
movq (%rcx,%rdx,8), %rdx
movq %r14, (%rax,%rdx,8)
movq 0x18f2d(%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 0x4caa
movq %rax, %r14
movq 0x18f55(%rip), %rax     # 0x1e170
movq 0x1939e(%rip), %rcx     # 0x1e5c0
movq 0x18eff(%rip), %rdx     # 0x1e128
movq (%rcx,%rdx,8), %rcx
movq %r14, (%rax,%rcx,8)
movq %r15, %rdi
xorl %esi, %esi
callq 0x4caa
movq %rax, %r15
movq 0x18f2b(%rip), %rax     # 0x1e170
movq 0x18edc(%rip), %rcx     # 0x1e128
movq %r15, (%rax,%rcx,8)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x47fe
testl %eax, %eax
jne 0x51c9
jmp 0x526b
movq %r14, %r12
movq %r15, %r13
movl $0x4, %edi
callq 0x384f
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_O3/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 0x18a97(%rip), %rdx     # 0x1e170
movq 0x18ee0(%rip), %rax     # 0x1e5c0
movq (%rax,%rbx,8), %rcx
cmpq $0x0, (%rdx,%rcx,8)
jne 0x56f2
cmpq $-0x1, (%rax,%rcx,8)
je 0x5750
movq %rbx, 0x18a17(%rip)     # 0x1e110
movq 0x18a28(%rip), %rsi     # 0x1e128
movq %r14, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x18a17(%rip)     # 0x1e128
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x18a03(%rip)     # 0x1e128
movq $-0x1, 0x189e0(%rip) # 0x1e110
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5290
movq %rax, %rbx
movl $0x2, %edi
callq 0x384f
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rdi, %rsi
leaq 0x10bfe(%rip), %rdi     # 0x16358
callq 0x33eb
movq $-0x5, %rax
jmp 0x574b
// File: /workspace/github_c_makefile_star2_O3/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 0x189bf(%rip), %rax     # 0x1e170
movq (%rax,%rdi,8), %rcx
xorl %esi, %esi
testq %rcx, %rcx
je 0x57e9
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 0x57c6
pushq %rbp
movq %rsp, %rbp
movq 0x18dcc(%rip), %rcx     # 0x1e5c0
movl %esi, %eax
cmpq $0x1, %rax
adcq $-0x9, %rax
movq (%rcx,%rdi,8), %rdi
addq $0x9, %rax
cmpq $-0x1, %rdi
jne 0x57fe
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5b2b
movq %rdi, %r14
movq 0x18b5c(%rip), %rax     # 0x1e5e0
movsbl (%rax,%rdi), %edx
movq $-0x1, %rdi
movq $-0x1, %rsi
callq 0x36e8
movq %rax, %rbx
movq 0x18683(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x18672(%rip)     # 0x1e128
movq 0x18b03(%rip), %rax     # 0x1e5c0
movq 0x186ac(%rip), %rcx     # 0x1e170
movq (%rcx,%r14,8), %rdx
movq %rdx, (%rcx,%rbx,8)
movq (%rax,%r14,8), %r14
cmpq $-0x1, %r14
je 0x5b1f
movq %rbx, %r15
movq 0x18b00(%rip), %rax     # 0x1e5e0
movsbl (%rax,%r14), %edx
movq $-0x1, %rdi
movq $-0x1, %rsi
callq 0x36e8
movq 0x18ac1(%rip), %rcx     # 0x1e5c0
movq %rax, (%rcx,%r15,8)
movq 0x18666(%rip), %rdx     # 0x1e170
movq (%rdx,%r14,8), %rsi
movq %rsi, (%rdx,%rax,8)
movq (%rcx,%r14,8), %r14
movq %rax, %r15
cmpq $-0x1, %r14
jne 0x5ad9
movl $0x1, %edi
callq 0x384f
jmp 0x5b32
movq $-0x1, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: 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 0x5a66
movq %rax, %rdi
movq 0x18613(%rip), %r9      # 0x1e170
movq 0x18a5c(%rip), %r10     # 0x1e5c0
movq (%r10,%rax,8), %rax
movq (%r9,%rax,8), %rcx
movq %rcx, %rdx
negq %rdx
cmovsq %rcx, %rdx
movq %rdx, (%r9,%rax,8)
movq (%r10,%rdi,8), %rcx
cmpq $-0x1, %rcx
je 0x5c3c
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rcx, %rdx
movq (%r10,%rdx,8), %rdx
incl %eax
cmpq $-0x1, %rdx
jne 0x5b90
xorl %esi, %esi
cmpl $0x4, %eax
jb 0x5c45
movq (%r9,%rcx,8), %r8
testq %r8, %r8
je 0x5bdf
xorl %esi, %esi
movabsq $0x6666666666666667, %r11 # imm = 0x6666666666666667
movq %r8, %rax
imulq %r11
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x2, %rdx
addq %rax, %rdx
incl %esi
addq $0x9, %r8
cmpq $0x12, %r8
movq %rdx, %r8
ja 0x5bbc
xorl %eax, %eax
cmpl $0x1, %esi
sbbl %esi, %eax
movq %rcx, %rdx
movq (%r10,%rdx,8), %rdx
addl $-0x9, %eax
cmpq $-0x1, %rdx
jne 0x5be9
movl $0xfffffff7, %r14d      # imm = 0xFFFFFFF7
subl %eax, %r14d
cmpl $0x25, %r14d
jl 0x5c43
movl $0xffffffd3, %r15d      # imm = 0xFFFFFFD3
subl %eax, %r15d
movl $0x24, %r12d
callq 0x4dca
movq 0x18550(%rip), %r9      # 0x1e170
movq (%r9,%rax,8), %rdi
incl %r12d
cmpl %r12d, %r14d
jne 0x5c14
movq 0x1898d(%rip), %r10     # 0x1e5c0
movq (%r10,%rdi,8), %rcx
movl %r15d, %esi
jmp 0x5c45
movq $-0x1, %rcx
xorl %esi, %esi
movq (%r10,%rbx,8), %rax
movq (%r9,%rax,8), %rdi
shrq $0x3f, %rdi
movq %rcx, %rdx
callq 0x5768
movq %rax, %rdi
xorl %esi, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x580e
// File: /workspace/github_c_makefile_star2_O3/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 0x5e41
movq 0x187b9(%rip), %rax     # 0x1e5e0
testb $0x1, (%rax,%rdi)
movq 0x1833e(%rip), %rcx     # 0x1e170
je 0x5e48
cmpq $-0x18, (%rcx,%rdi,8)
jne 0x5e48
popq %rbp
jmp 0x4392
movq 0x18328(%rip), %rcx     # 0x1e170
movq 0x18771(%rip), %rsi     # 0x1e5c0
movq (%rsi,%rdi,8), %rdx
movq (%rcx,%rdx,8), %rax
testb $0x1, %al
jne 0x5e60
movq %rdi, %rax
popq %rbp
retq
movq (%rsi,%rdx,8), %r8
movq (%rsi,%r8,8), %rdx
cmpq $0x0, (%rcx,%rdx,8)
jne 0x5e76
cmpq $-0x1, (%rsi,%rdx,8)
je 0x5e5b
andl $-0x2, %eax
movq (%rcx,%r8,8), %rsi
movl %eax, %edi
popq %rbp
jmp 0x5768
// File: /workspace/github_c_makefile_star2_O3/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 0x1827f(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x1826e(%rip)     # 0x1e128
movq %rbx, %rdi
callq 0x4dca
movq 0x182a7(%rip), %rcx     # 0x1e170
movq (%rcx,%rax,8), %rbx
movl $0x1, %edi
callq 0x384f
movq 0x186e2(%rip), %rax     # 0x1e5c0
movq (%rax,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x186bd(%rip), %r10     # 0x1e5c0
movq (%r10,%rdi,8), %rax
movq (%r10,%rax,8), %r8
movq (%r10,%r8,8), %rdi
movq 0x1825a(%rip), %r9      # 0x1e170
movq (%r9,%rdi,8), %rsi
xorl %r11d, %r11d
testq %rsi, %rsi
je 0x5f50
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 0x5f2c
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 0x5f68
testl %ecx, %ecx
je 0x5f96
movq (%r9,%r8,8), %rcx
subq %r14, %rcx
cmpq %rax, %rcx
jle 0x5f96
movq $-0x1, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x5a66
movq $-0x18, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rax, %r15
movq 0x1816f(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x1815e(%rip)     # 0x1e128
movq 0x1819f(%rip), %rax     # 0x1e170
movq 0x185e8(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %r12
cmpq %r14, %r12
jle 0x6013
movq %r15, %rdi
xorl %esi, %esi
callq 0x4caa
movq %rax, %r15
movq 0x18173(%rip), %rax     # 0x1e170
movq 0x18124(%rip), %rcx     # 0x1e128
movq %r15, (%rax,%rcx,8)
decq %r12
cmpq %r14, %r12
jg 0x5fe9
movq %r14, %r12
movl $0x1, %edi
callq 0x384f
movq 0x1814c(%rip), %rax     # 0x1e170
movq 0x18595(%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 0x5768
// File: /workspace/github_c_makefile_star2_O3/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 0x18116(%rip), %rax     # 0x1e170
movq 0x1855f(%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 0x6096
movq %rcx, %rdi
movl $0x48, %edx
callq 0x5ee9
movq %rax, (%r14)
jmp 0x60a8
jle 0x60a8
movq %rax, %rsi
movl $0x48, %edx
callq 0x5ee9
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6b3e
movq 0x17ac0(%rip), %rax     # 0x1e5e0
testb $0x1, (%rax,%rsi)
movq 0x17645(%rip), %rax     # 0x1e170
je 0x6b45
cmpq $-0x18, (%rax,%rsi,8)
jne 0x6b45
movq %rsi, %rdi
callq 0x43d9
jmp 0x6b67
movq 0x1762b(%rip), %rax     # 0x1e170
movq 0x17a74(%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 0x5768
movq %rax, %r14
movq 0x175b7(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x175a6(%rip)     # 0x1e128
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6784
movq %rax, %rbx
movl $0x1, %edi
callq 0x384f
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x6c18
movq 0x17a21(%rip), %rax     # 0x1e5e0
testb $0x1, (%rax,%r14)
je 0x6c18
movq 0x175a3(%rip), %rcx     # 0x1e170
movq (%rcx,%r14,8), %rdx
cmpq $-0x18, %rdx
setne %sil
testq %rbx, %rbx
sets %dil
orb %sil, %dil
je 0x6bed
cmpq $-0x18, %rdx
je 0x6c0d
jmp 0x6c18
testb $0x1, (%rax,%rbx)
je 0x6c0d
cmpq $-0x18, (%rcx,%rbx,8)
jne 0x6c0d
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x4f7d
movq %r14, %rdi
callq 0x5b40
movq %rax, %r14
movq 0x17509(%rip), %rsi     # 0x1e128
movq %r14, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x174f8(%rip)     # 0x1e128
testq %rbx, %rbx
js 0x6c62
movq 0x179a4(%rip), %rcx     # 0x1e5e0
testb $0x1, (%rcx,%rbx)
je 0x6c62
movq 0x17527(%rip), %rcx     # 0x1e170
cmpq $-0x18, (%rcx,%rbx,8)
jne 0x6c62
movq %rbx, %rdi
callq 0x5b40
movq %rax, %rbx
movq 0x174c6(%rip), %rax     # 0x1e128
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x174b2(%rip)     # 0x1e128
movq 0x174f3(%rip), %rax     # 0x1e170
movq 0x1793c(%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 0x174ad(%rip), %rax     # 0x1e170
movq 0x178f6(%rip), %rcx     # 0x1e5c0
movq 0x17457(%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 0x17473(%rip), %rcx     # 0x1e170
movq 0x17424(%rip), %rdx     # 0x1e128
movq %rax, (%rcx,%rdx,8)
movq %r12, %rdi
movq %rax, %rsi
callq 0x4f7d
movq %rax, %rbx
movl $0x2, %edi
callq 0x384f
andl $0x1, %r14d
movq 0x17895(%rip), %rax     # 0x1e5c0
movq (%rax,%rbx,8), %rdx
movl %r14d, %edi
movq %r15, %rsi
callq 0x5768
leaq 0x10723(%rip), %rsi     # 0x17464
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x580e
// File: /workspace/github_c_makefile_star2_O3/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 0x170ee(%rip), %rcx     # 0x1e170
movq 0x17537(%rip), %rax     # 0x1e5c0
movq (%rax,%rdi,8), %rsi
movq (%rax,%rsi,8), %rdx
movq $-0x1, %rbx
cmpq $0x0, (%rcx,%rdx,8)
js 0x7108
testb $0x1, (%rcx,%rsi,8)
jne 0x70aa
xorl %r14d, %r14d
jmp 0x70c1
movq (%rax,%rdx,8), %rdx
movb $0x1, %r14b
cmpq $0x0, (%rcx,%rdx,8)
jne 0x70c1
cmpq $-0x1, (%rax,%rdx,8)
setne %r14b
xorl %esi, %esi
xorl %edx, %edx
callq 0x5ee9
cmpq $-0x1, %rax
je 0x7108
movq 0x174e9(%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 0x7108
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x43d9
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x16f8c(%rip), %r15     # 0x1e100
cmpq $-0x1, %r15
je 0x71b4
movq 0x17467(%rip), %r12     # 0x1e5e8
movq 0x17438(%rip), %r13     # 0x1e5c0
movq 0x16fe1(%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 0x71bb
movq (%r13,%r15,8), %r15
cmpq $-0x1, %r15
jne 0x718f
movq $-0x1, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: 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 0x416e
movq %rax, %r14
movq 0x173d1(%rip), %rax     # 0x1e5c0
movq (%rax,%r14,8), %rdi
shlq $0x3, %rdi
addq 0x173ea(%rip), %rdi     # 0x1e5e8
movq %rbx, %rsi
callq 0x3060
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x715b
cmpq $-0x1, %rax
jne 0x727e
movq %rbx, %rdi
callq 0x30a0
leal 0x1(%rax), %esi
movq $-0x22, %rdi
callq 0x416e
movq %rax, %r14
movq 0x1737c(%rip), %rax     # 0x1e5c0
movq (%rax,%r14,8), %rdi
shlq $0x3, %rdi
addq 0x17395(%rip), %rdi     # 0x1e5e8
movq %rbx, %rsi
callq 0x3060
movq 0x16e9e(%rip), %rsi     # 0x1e100
movq %r14, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x16e8d(%rip)     # 0x1e100
movq 0x16ef6(%rip), %rcx     # 0x1e170
movq (%rcx,%rax,8), %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x78eb
cmpl $0x2d, %eax
jne 0x78ee
incq %rdi
movq $-0x1, %r12
jmp 0x78ee
incq %rdi
movb (%rdi), %al
movq %rdi, %rbx
cmpb $0x30, %al
jne 0x7902
leaq 0x1(%rbx), %rdi
movb 0x1(%rbx), %al
testb %al, %al
jne 0x78f0
movq %rbx, %rdi
callq 0x30a0
movq %rax, %r14
movq $-0x1, %r15
testl %r14d, %r14d
je 0x795f
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 0x7919
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_O3/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 0x416e
movq %rax, %r15
movq 0x1691a(%rip), %rax     # 0x1e5c0
movq (%rax,%r15,8), %rdi
shlq $0x3, %rdi
addq 0x16933(%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_O3/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 0x7cf1
cmpl $0x65, %ecx
je 0x7ceb
cmpl $0x2e, %ecx
je 0x7ceb
incq %rax
jmp 0x7cd5
popq %rbp
jmp 0x7981
popq %rbp
jmp 0x78be
// File: /workspace/github_c_makefile_star2_O3/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 0x7d61
testl %eax, %eax
je 0x7d61
incq %r12
cmpl %eax, %r15d
je 0x7d39
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_O3/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 0x7dc1
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r12d
xorl %r13d, %r13d
movsbl (%r14,%r13), %edi
callq 0x3140
movl %eax, %r15d
movsbl (%rbx,%r13), %edi
callq 0x3140
cmpl %eax, %r15d
jne 0x7dc6
incq %r13
movl %r15d, %eax
cmpl %r13d, %r12d
jne 0x7d98
jmp 0x7dc6
xorl %eax, %eax
xorl %r15d, %r15d
xorl %ecx, %ecx
cmpl %eax, %r15d
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_O3/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 0x1689a(%rip), %rax     # 0x1e698
leaq 0x1637b(%rip), %r14     # 0x1e180
movq (%r14,%rax,8), %rdi
callq 0x3220
cmpl $0x22, %eax
jne 0x7e1d
movb $0x1, %r15b
xorl %ebx, %ebx
jmp 0x7ea8
xorl %r15d, %r15d
xorl %r12d, %r12d
xorl %ebx, %ebx
cmpl $-0x1, %eax
je 0x7f04
cmpl $0x0, 0x1677f(%rip)     # 0x1e5b4
jne 0x7ea1
cmpl $0x3fe, %ebx            # imm = 0x3FE
jge 0x7f0d
testb $0x1, %r12b
je 0x7e66
cmpl $0x22, %eax
je 0x7e66
cmpl $0x5c, %eax
je 0x7e66
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 0x1680a(%rip), %rax     # 0x1e698
movq (%r14,%rax,8), %rdi
callq 0x3220
cmpl $0x22, %eax
jne 0x7e25
testb %r12b, %r12b
jne 0x7e25
testl %r15d, %r15d
sete %r15b
movslq %ebx, %r14
movb $0x0, -0x430(%rbp,%r14)
incl %r14d
movq $-0x21, %rdi
movl %r14d, %esi
callq 0x416e
movq %rax, %rbx
movq 0x166f0(%rip), %rax     # 0x1e5c0
movq (%rax,%rbx,8), %rdi
shlq $0x3, %rdi
addq 0x16709(%rip), %rdi     # 0x1e5e8
movslq %r14d, %rdx
leaq -0x430(%rbp), %rsi
callq 0x3050
testb %r15b, %r15b
jne 0x7f27
leaq 0xe587(%rip), %rdi      # 0x16481
movq %rbx, %rsi
callq 0x33eb
jmp 0x7f27
leaq 0xe540(%rip), %rdi      # 0x1644b
jmp 0x7f14
leaq 0xe555(%rip), %rdi      # 0x16469
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_O3/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 0x16750(%rip), %rax     # 0x1e698
leaq 0x16231(%rip), %rcx     # 0x1e180
movq (%rcx,%rax,8), %rdi
callq 0x3220
cmpl $0x22, %eax
jne 0x7ff2
callq 0x7de5
movq %rax, %rbx
movq 0x16650(%rip), %rax     # 0x1e5c0
movq (%rax,%rbx,8), %r14
shlq $0x3, %r14
addq 0x16669(%rip), %r14     # 0x1e5e8
leaq 0xe539(%rip), %rsi      # 0x164bf
movq %r14, %rdi
callq 0x3110
testl %eax, %eax
je 0x8011
leaq 0xe530(%rip), %rsi      # 0x164c9
movq %r14, %rdi
callq 0x3110
testl %eax, %eax
je 0x8018
leaq 0xf4ef(%rip), %rsi      # 0x1749b
movq %r14, %rdi
callq 0x3110
testl %eax, %eax
je 0x801f
leaq 0xf061(%rip), %rsi      # 0x17020
movq %r14, %rdi
callq 0x3110
testl %eax, %eax
je 0x8026
leaq 0xe4ff(%rip), %rsi      # 0x164d1
movq %r14, %rdi
callq 0x3110
testl %eax, %eax
je 0x802d
movq %r14, %rdi
callq 0x30a0
cmpq $0x1, %rax
jne 0x805b
movzbl (%r14), %edi
jmp 0x8032
leaq 0xe4aa(%rip), %rdi      # 0x164a3
movq $-0x8, %rsi
callq 0x33eb
movq $-0x5, %rax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x5c, %edi
jmp 0x8032
movl $0xa, %edi
jmp 0x8032
movl $0x22, %edi
jmp 0x8032
movl $0x20, %edi
jmp 0x8032
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 0xe473(%rip), %rdi      # 0x164d5
movq %rbx, %rsi
jmp 0x8000
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movl %esi, %r15d
movq %rdi, %rbx
callq 0x3230
movq (%rax), %rax
movslq %r15d, %r14
testb $0x40, 0x1(%rax,%r14,2)
jne 0x80d8
leaq 0xe457(%rip), %rsi      # 0x164ee
leaq -0xa0(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x31f0
movq %r14, %rdi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x18, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x36e8
movq %r15, %rdi
jmp 0x8104
movzbl %r15b, %edi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x16, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x33eb
movq $-0x5, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movl %edi, %ebx
xorl %r15d, %r15d
callq 0x3230
movq %rax, %r14
leaq 0x16039(%rip), %r12     # 0x1e180
movq (%r14), %rax
movslq %ebx, %rcx
movzwl (%rax,%rcx,2), %eax
btl $0xb, %eax
jb 0x8166
cmpl $0x2e, %ebx
je 0x8166
cmpl $0x7e, %ebx
je 0x8166
cmpl $0x65, %ebx
jne 0x81b8
cmpq $0x3fe, %r15            # imm = 0x3FE
je 0x818e
movb %bl, -0x420(%rbp,%r15)
incq %r15
movslq 0x16517(%rip), %rax     # 0x1e698
movq (%r12,%rax,8), %rdi
callq 0x3220
movl %eax, %ebx
jmp 0x8147
leaq 0xe362(%rip), %rdi      # 0x164f7
movq $-0x8, %rsi
callq 0x33eb
movq $-0x5, %rax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb $0x0, -0x420(%rbp,%r15)
movslq 0x164d0(%rip), %rax     # 0x1e698
movq (%r12,%rax,8), %rsi
movl %ebx, %edi
callq 0x3170
leaq -0x420(%rbp), %rdi
callq 0x7cce
jmp 0x81a8
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movl %esi, -0x2c(%rbp)
movl %edi, %r14d
xorl %r12d, %r12d
callq 0x3230
movq %rax, %r15
movabsq $0x100000000080001, %rbx # imm = 0x100000000080001
leaq 0x15f69(%rip), %r13     # 0x1e180
movq (%r15), %rax
movslq %r14d, %rcx
movzwl (%rax,%rcx,2), %eax
btl $0xa, %eax
jb 0x8236
leal -0x27(%r14), %ecx
cmpl $0x38, %ecx
ja 0x8264
btq %rcx, %rbx
jae 0x8264
cmpq $0x3fe, %r12            # imm = 0x3FE
je 0x82d6
movb %r14b, -0x430(%rbp,%r12)
incq %r12
movslq 0x16443(%rip), %rax     # 0x1e698
movq (%r13,%rax,8), %rdi
callq 0x3220
movl %eax, %r14d
jmp 0x8217
cmpl $0x0, -0x2c(%rbp)
setne %cl
cmpl $0x21, %r14d
sete %dl
btl $0xb, %eax
jb 0x8236
andb %dl, %cl
jne 0x8236
movb $0x0, -0x430(%rbp,%r12)
movslq 0x1640c(%rip), %rax     # 0x1e698
movq (%r13,%rax,8), %rsi
movl %r14d, %edi
callq 0x3170
movl $0x65757274, %eax       # imm = 0x65757274
xorl -0x430(%rbp), %eax
movzbl -0x42c(%rbp), %ecx
orl %eax, %ecx
je 0x8302
movl $0x736c6166, %eax       # imm = 0x736C6166
xorl -0x430(%rbp), %eax
movzwl -0x42c(%rbp), %ecx
xorl $0x65, %ecx
orl %eax, %ecx
je 0x830b
leaq -0x430(%rbp), %rdi
callq 0x720e
jmp 0x82f0
leaq 0xe233(%rip), %rdi      # 0x16510
movq $-0x8, %rsi
callq 0x33eb
movq $-0x5, %rax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq $-0x2, %rax
jmp 0x82f0
movq $-0x3, %rax
jmp 0x82f0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movl %edi, %ebx
leaq 0xe200(%rip), %rdi      # 0x1652f
movl $0x10, %edx
movl %ebx, %esi
callq 0x30f0
xorl %r15d, %r15d
testq %rax, %rax
je 0x838b
leaq 0x15e36(%rip), %r12     # 0x1e180
leaq 0xe1de(%rip), %r14      # 0x1652f
cmpq $0x3fe, %r15            # imm = 0x3FE
je 0x83bb
movb %bl, -0x420(%rbp,%r15)
incq %r15
movslq 0x1632c(%rip), %rax     # 0x1e698
movq (%r12,%rax,8), %rdi
callq 0x3220
movl %eax, %ebx
movl $0x10, %edx
movq %r14, %rdi
movl %eax, %esi
callq 0x30f0
testq %rax, %rax
jne 0x8351
movb $0x0, -0x420(%rbp,%r15)
movslq 0x162fd(%rip), %rax     # 0x1e698
leaq 0x15dde(%rip), %rcx     # 0x1e180
movq (%rcx,%rax,8), %rsi
movl %ebx, %edi
callq 0x3170
leaq -0x420(%rbp), %rdi
callq 0x720e
jmp 0x83d5
leaq 0xe17d(%rip), %rdi      # 0x1653f
movq $-0x8, %rsi
callq 0x33eb
movq $-0x5, %rax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movslq 0x1626d(%rip), %rax     # 0x1e698
leaq 0x15d4e(%rip), %rcx     # 0x1e180
cmpq $0x0, (%rcx,%rax,8)
je 0x8448
movl $0x0, 0x1623d(%rip)     # 0x1e680
jmp 0x754a
pushq %rbp
movq %rsp, %rbp
leaq 0xe16e(%rip), %rdi      # 0x165c1
movq $-0x8, %rsi
callq 0x33eb
movq $-0x5, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r11
movq %rdi, %rbx
movq %rsi, %rcx
negq %rcx
cmovsq %rsi, %rcx
movq %rsi, %rax
sarq $0x3f, %rax
movb $0x0, -0x49(%rbp)
leal (%rax,%rdx), %r9d
leal (%rax,%rdx), %r8d
decl %r8d
movl $0x1, %r12d
movl $0x26, %r15d
xorl %edi, %edi
movabsq $-0x3333333333333333, %rsi # imm = 0xCCCCCCCCCCCCCCCD
movl %r8d, %r13d
cmpl $0x26, %edi
je 0x859d
movq %rcx, %rax
mulq %rsi
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %ecx, %r10d
subl %eax, %r10d
orb $0x30, %r10b
movb %r10b, -0x70(%rbp,%r15)
incq %rdi
decl %r13d
decq %r15
incl %r12d
cmpq $0x9, %rcx
movq %rdx, %rcx
ja 0x84ba
leaq -0x70(%rbp), %rsi
subq %rdi, %rsi
cmpl %r9d, %edi
jge 0x856e
movq %rbx, -0x40(%rbp)
movl $0x26, %ebx
subq %rdi, %rbx
movl %r8d, %r14d
subq %rdi, %r14
movl $0x26, %edx
subl %edi, %edx
subl %edi, %r8d
cmpq %rdx, %r8
cmovbq %r8, %rdx
leaq 0x26(%rsi), %rax
movq %rax, -0x30(%rbp)
subq %rdx, %rsi
addq $0x26, %rsi
incq %rdx
movq %rsi, %rdi
movl $0x30, %esi
movq %r11, -0x38(%rbp)
callq 0x30d0
movq -0x38(%rbp), %r11
cmpl %ebx, %r14d
cmovbl %r14d, %ebx
cmpl %r15d, %r13d
cmovbl %r13d, %r15d
addl %r12d, %r15d
movq -0x30(%rbp), %rsi
subq %rbx, %rsi
movq -0x40(%rbp), %rbx
movl %r15d, %edi
jmp 0x8572
addq $0x27, %rsi
testq %r11, %r11
jns 0x8583
cmpl $0x27, %edi
jae 0x859d
movb $0x2d, -0x1(%rsi)
decq %rsi
movq %rbx, %rdi
callq 0x3060
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xe032(%rip), %rdi      # 0x165d6
callq 0x3ab4