LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
movq 0x16cdd(%rip), %rax     # 0x1c5c0
movq (%rax,%rdi,8), %rcx
movq (%rax,%rcx,8), %r13
movq (%rax,%r13,8), %r15
movq %r15, %rdi
callq 0x52d5
testl %r12d, %r12d
je 0x5927
subl %eax, %r12d
movslq %r12d, %rax
movq 0x16867(%rip), %rcx     # 0x1c170
movq (%rcx,%r13,8), %rcx
subq %rbx, %rcx
cmpq %rax, %rcx
jle 0x5927
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x54ca
pushq $-0x18
popq %rdi
pushq $0x1
popq %rdx
movq %rax, %rsi
callq 0x3613
movq %rax, %r15
movq 0x167e1(%rip), %rsi     # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x167d0(%rip)     # 0x1c128
movq 0x16811(%rip), %rax     # 0x1c170
movq 0x16c5a(%rip), %rcx     # 0x1c5c0
movq (%rcx,%r14,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %r12
movq %r12, %r13
cmpq %rbx, %r13
jle 0x599e
movq %r15, %rdi
xorl %esi, %esi
callq 0x4986
movq %rax, %r15
movq 0x167e2(%rip), %rax     # 0x1c170
movq 0x16793(%rip), %rcx     # 0x1c128
movq %r15, (%rax,%rcx,8)
decq %r13
jmp 0x5975
cmpq %rbx, %r12
cmovlq %r12, %rbx
pushq $0x1
popq %rdi
callq 0x3775
movq 0x167bc(%rip), %rax     # 0x1c170
movq 0x16c05(%rip), %rcx     # 0x1c5c0
movq (%rcx,%r14,8), %rdx
movl (%rax,%rdx,8), %edi
movq (%rcx,%r15,8), %rdx
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x529a
// File: /workspace/github_c_makefile_star2_O2/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 0x16780(%rip), %rax     # 0x1c170
movq 0x16bc9(%rip), %rdx     # 0x1c5c0
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 0x5a2a
pushq $0x48
popq %rdx
movq %rcx, %rdi
callq 0x58c5
movq %rax, (%r14)
jmp 0x5a3a
jle 0x5a3a
pushq $0x48
popq %rdx
movq %rax, %rsi
callq 0x58c5
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x63ed
movq 0x16211(%rip), %rax     # 0x1c5e0
testb $0x1, (%rax,%rsi)
movq 0x15d96(%rip), %rax     # 0x1c170
je 0x63f4
cmpq $-0x18, (%rax,%rsi,8)
jne 0x63f4
movq %rsi, %rdi
callq 0x426f
jmp 0x6416
movq 0x15d7c(%rip), %rax     # 0x1c170
movq 0x161c5(%rip), %rcx     # 0x1c5c0
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 0x529a
movq %rax, %r14
movq 0x15d08(%rip), %rsi     # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x15cf7(%rip)     # 0x1c128
movq %rbx, %rdi
movq %r14, %rsi
callq 0x604b
movq %rax, %rbx
pushq $0x1
popq %rdi
callq 0x3775
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
js 0x64ce
movq 0x16171(%rip), %rax     # 0x1c5e0
testb $0x1, (%rax,%r14)
je 0x64ce
movq 0x15cf3(%rip), %rcx     # 0x1c170
movq (%rcx,%r14,8), %rdx
cmpq $-0x18, %rdx
setne %sil
testq %rbx, %rbx
sets %dil
orb %sil, %dil
je 0x649d
cmpq $-0x18, %rdx
je 0x64c3
jmp 0x64ce
testb $0x1, (%rax,%rbx)
je 0x64c3
cmpq $-0x18, (%rcx,%rbx,8)
jne 0x64c3
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4ba4
movq %r14, %rdi
callq 0x5580
movq %rax, %r14
movq 0x15c53(%rip), %rsi     # 0x1c128
movq %r14, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x15c42(%rip)     # 0x1c128
testq %rbx, %rbx
js 0x6518
movq 0x160ee(%rip), %rcx     # 0x1c5e0
testb $0x1, (%rcx,%rbx)
je 0x6518
movq 0x15c71(%rip), %rcx     # 0x1c170
cmpq $-0x18, (%rcx,%rbx,8)
jne 0x6518
movq %rbx, %rdi
callq 0x5580
movq %rax, %rbx
movq 0x15c10(%rip), %rax     # 0x1c128
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x15bfc(%rip)     # 0x1c128
movq 0x15c3d(%rip), %rax     # 0x1c170
movq 0x16086(%rip), %rcx     # 0x1c5c0
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
pushq $-0x18
popq %r12
pushq $0x1
popq %rdx
movq %r12, %rdi
callq 0x3613
movq %rax, %r13
movq 0x15bf9(%rip), %rax     # 0x1c170
movq 0x16042(%rip), %rcx     # 0x1c5c0
movq 0x15ba3(%rip), %rdx     # 0x1c128
movq (%rcx,%rdx,8), %rdx
movq %r13, (%rax,%rdx,8)
movq (%rcx,%rbx,8), %rax
movq (%rcx,%rax,8), %rax
movq (%rcx,%rax,8), %rsi
movq %r12, %rdi
pushq $0x1
popq %rdx
callq 0x3613
movq 0x15bc5(%rip), %rcx     # 0x1c170
movq 0x15b76(%rip), %rdx     # 0x1c128
movq %rax, (%rcx,%rdx,8)
movq %r13, %rdi
movq %rax, %rsi
callq 0x4ba4
movq %rax, %rbx
pushq $0x2
popq %rdi
callq 0x3775
andl $0x1, %r14d
movq 0x15fe9(%rip), %rax     # 0x1c5c0
movq (%rax,%rbx,8), %rdx
movl %r14d, %edi
movq %r15, %rsi
callq 0x529a
leaq 0xee77(%rip), %rsi      # 0x15464
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5321
// File: /workspace/github_c_makefile_star2_O2/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 0x158e8(%rip), %rcx     # 0x1c170
movq 0x15d31(%rip), %rax     # 0x1c5c0
movq (%rax,%rdi,8), %rsi
movq (%rax,%rsi,8), %rdx
pushq $-0x1
popq %rbx
cmpq $0x0, (%rcx,%rdx,8)
js 0x6904
testb $0x1, (%rcx,%rsi,8)
jne 0x68ac
xorl %r14d, %r14d
jmp 0x68c3
movq (%rax,%rdx,8), %rdx
movb $0x1, %r14b
cmpq $0x0, (%rcx,%rdx,8)
jne 0x68c3
cmpq $-0x1, (%rax,%rdx,8)
setne %r14b
xorl %esi, %esi
xorl %edx, %edx
callq 0x58c5
cmpq $-0x1, %rax
je 0x6904
movq 0x15ce7(%rip), %rcx     # 0x1c5c0
movq (%rcx,%rax,8), %rax
movq (%rcx,%rax,8), %rax
movq (%rcx,%rax,8), %rsi
pushq $-0x18
popq %rdi
pushq $0x1
popq %rdx
callq 0x3613
movq %rax, %rbx
testb %r14b, %r14b
je 0x6904
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x426f
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x15c7a(%rip), %r15     # 0x1c5e8
movq 0x15c4b(%rip), %r12     # 0x1c5c0
leaq 0x15784(%rip), %rax     # 0x1c100
movq 0x157ed(%rip), %r13     # 0x1c170
movq (%rax), %rbx
cmpq $-0x1, %rbx
je 0x69ac
movq (%r13,%rbx,8), %r14
movq (%r12,%r14,8), %rax
leaq (%r15,%rax,8), %rdi
movq -0x30(%rbp), %rsi
callq 0x3110
testl %eax, %eax
je 0x69b0
leaq (%r12,%rbx,8), %rax
jmp 0x6983
pushq $-0x1
popq %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_O2/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
pushq $-0x22
popq %rdi
callq 0x4037
movq %rax, %r14
movq 0x15be0(%rip), %rax     # 0x1c5c0
movq (%rax,%r14,8), %rdi
shlq $0x3, %rdi
addq 0x15bf9(%rip), %rdi     # 0x1c5e8
movq %rbx, %rsi
callq 0x3060
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
callq 0x6955
cmpq $-0x1, %rax
jne 0x6a48
movq %rbx, %rdi
callq 0x30a0
movq %rbx, %rdi
movl %eax, %esi
callq 0x69c2
movq 0x156d4(%rip), %rsi     # 0x1c100
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x156c3(%rip)     # 0x1c100
movq 0x1572c(%rip), %rcx     # 0x1c170
movq (%rcx,%rax,8), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x1
popq %r13
cmpl $0x2b, %eax
je 0x6ffe
cmpl $0x2d, %eax
jne 0x7001
pushq $-0x1
popq %r13
incq %rdi
movb (%rdi), %al
movq %rdi, %rbx
cmpb $0x30, %al
jne 0x7015
leaq 0x1(%rbx), %rdi
movb 0x1(%rbx), %al
testb %al, %al
jne 0x7003
movq %rbx, %rdi
callq 0x30a0
movq %rax, %r14
pushq $-0x1
popq %r15
testl %r14d, %r14d
je 0x7066
cmpl $0x9, %r14d
pushq $0x9
popq %rax
cmovll %r14d, %eax
subl %eax, %r14d
movslq %r14d, %r12
leaq (%rbx,%r12), %rdi
callq 0x31b0
movb $0x0, (%rbx,%r12)
testl %r12d, %r12d
pushq $0x1
popq %rdi
cmoveq %r13, %rdi
imulq %rax, %rdi
movq %r15, %rsi
pushq $0x1
popq %rdx
callq 0x3613
movq %rax, %r15
jmp 0x7024
pushq $-0x18
popq %rdi
pushq $0x1
popq %rdx
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3613
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: 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
pushq $-0x21
popq %rdi
movl %ebx, %esi
callq 0x4037
movq %rax, %r15
movq 0x152fd(%rip), %rax     # 0x1c5c0
movq (%rax,%r15,8), %rdi
shlq $0x3, %rdi
addq 0x15316(%rip), %rdi     # 0x1c5e8
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_O2/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 0x730e
cmpl $0x65, %ecx
je 0x7308
cmpl $0x2e, %ecx
je 0x7308
incq %rax
jmp 0x72f2
popq %rbp
jmp 0x7082
popq %rbp
jmp 0x6fdb
// File: /workspace/github_c_makefile_star2_O2/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 0x737a
testl %eax, %eax
je 0x737a
incq %r12
cmpl %eax, %r15d
je 0x7352
xorl %ecx, %ecx
cmpl %eax, %r15d
setg %cl
pushq $-0x1
popq %rax
cmovgel %ecx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, %rbx
movq %rdi, %r14
movl %edx, %r12d
xorl %r13d, %r13d
xorl %r15d, %r15d
movl %r15d, %eax
cmpl %r13d, %r12d
je 0x73d5
movsbl (%r14,%r13), %edi
callq 0x3140
movl %eax, %r15d
movsbl (%rbx,%r13), %edi
callq 0x3140
incq %r13
cmpl %eax, %r15d
je 0x73ae
xorl %ecx, %ecx
cmpl %eax, %r15d
setg %cl
pushq $-0x1
popq %rax
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_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
xorl %ebx, %ebx
leaq 0x14d71(%rip), %r15     # 0x1c180
pushq $0x1
popq %r12
xorl %r13d, %r13d
xorl %r14d, %r14d
movslq 0x15278(%rip), %rax     # 0x1c698
movq (%r15,%rax,8), %rdi
callq 0x3220
cmpl $0x22, %eax
sete %dl
movl %r13d, %ecx
xorb $0x1, %cl
movslq %ebx, %rsi
testb %cl, %dl
jne 0x748f
cmpl $-0x1, %eax
je 0x74bc
cmpl $0x0, 0x1516c(%rip)     # 0x1c5b4
jne 0x748f
cmpl $0x3fe, %ebx            # imm = 0x3FE
jge 0x74c5
testb $0x1, %r13b
je 0x746f
cmpl $0x22, %eax
je 0x746f
cmpl $0x5c, %eax
je 0x746f
incl %ebx
movb $0x5c, -0x430(%rbp,%rsi)
movl %r12d, %r14d
movslq %ebx, %rbx
movb %al, -0x430(%rbp,%rbx)
cmpl $0x5c, %eax
sete %r13b
andb %cl, %r13b
movl %r13d, %eax
xorb $0x1, %al
movzbl %al, %eax
addl %eax, %ebx
jmp 0x7419
movb $0x0, -0x430(%rbp,%rsi)
leaq -0x430(%rbp), %rdi
callq 0x729e
movq %rax, %rbx
testl %r14d, %r14d
je 0x74d7
leaq 0xcfcf(%rip), %rdi      # 0x14481
movq %rbx, %rsi
callq 0x33e4
jmp 0x74d7
leaq 0xcf88(%rip), %rdi      # 0x1444b
jmp 0x74cc
leaq 0xcf9d(%rip), %rdi      # 0x14469
pushq $-0x8
popq %rsi
callq 0x33e4
pushq $-0x5
popq %rbx
movq %rbx, %rax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: 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 0x1519e(%rip), %rax     # 0x1c698
leaq 0x14c7f(%rip), %rcx     # 0x1c180
movq (%rcx,%rax,8), %rdi
callq 0x3220
cmpl $0x22, %eax
jne 0x75a4
callq 0x73f2
movq %rax, %rbx
movq 0x1509e(%rip), %rax     # 0x1c5c0
movq (%rax,%rbx,8), %r14
shlq $0x3, %r14
addq 0x150b7(%rip), %r14     # 0x1c5e8
leaq 0xcf87(%rip), %rsi      # 0x144bf
movq %r14, %rdi
callq 0x3110
testl %eax, %eax
je 0x75bb
leaq 0xcf7e(%rip), %rsi      # 0x144c9
movq %r14, %rdi
callq 0x3110
testl %eax, %eax
je 0x75bf
leaq 0xdf3d(%rip), %rsi      # 0x1549b
movq %r14, %rdi
callq 0x3110
testl %eax, %eax
je 0x75c3
leaq 0xdaaf(%rip), %rsi      # 0x15020
movq %r14, %rdi
callq 0x3110
testl %eax, %eax
je 0x75c7
leaq 0xcf4d(%rip), %rsi      # 0x144d1
movq %r14, %rdi
callq 0x3110
testl %eax, %eax
je 0x75cb
movq %r14, %rdi
callq 0x30a0
cmpq $0x1, %rax
jne 0x75d7
movsbl (%r14), %edi
jmp 0x75ce
leaq 0xcef8(%rip), %rdi      # 0x144a3
pushq $-0x8
popq %rsi
callq 0x33e4
pushq $-0x5
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x5c
jmp 0x75cd
pushq $0xa
jmp 0x75cd
pushq $0x22
jmp 0x75cd
pushq $0x20
jmp 0x75cd
pushq $0x9
popq %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7314
leaq 0xcef7(%rip), %rdi      # 0x144d5
movq %rbx, %rsi
jmp 0x75ae
// File: /workspace/github_c_makefile_star2_O2/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 0x7634
leaq 0xcedb(%rip), %rsi      # 0x144ee
leaq -0xa0(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x31f0
movq %r14, %rdi
callq 0x35ed
movq %r15, %rdi
jmp 0x763f
movl %r15d, %edi
callq 0x7314
movq %rbx, %rdi
movq %rax, %rsi
callq 0x33e4
pushq $-0x5
popq %rax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x14b02(%rip), %r12     # 0x1c180
movq (%r14), %rax
movslq %ebx, %rcx
movzwl (%rax,%rcx,2), %eax
btl $0xb, %eax
jb 0x769d
cmpl $0x2e, %ebx
je 0x769d
cmpl $0x7e, %ebx
je 0x769d
cmpl $0x65, %ebx
jne 0x76e7
cmpq $0x3fe, %r15            # imm = 0x3FE
je 0x76c5
movb %bl, -0x420(%rbp,%r15)
incq %r15
movslq 0x14fe0(%rip), %rax     # 0x1c698
movq (%r12,%rax,8), %rdi
callq 0x3220
movl %eax, %ebx
jmp 0x767e
leaq 0xce2b(%rip), %rdi      # 0x144f7
pushq $-0x8
popq %rsi
callq 0x33e4
pushq $-0x5
popq %rax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb $0x0, -0x420(%rbp,%r15)
movslq 0x14fa1(%rip), %rax     # 0x1c698
movq (%r12,%rax,8), %rsi
movl %ebx, %edi
callq 0x3170
leaq -0x420(%rbp), %rdi
callq 0x72eb
jmp 0x76d7
// File: /workspace/github_c_makefile_star2_O2/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 0x14a3a(%rip), %r13     # 0x1c180
movq (%r15), %rax
movslq %r14d, %rcx
movzwl (%rax,%rcx,2), %eax
btl $0xa, %eax
jb 0x7765
leal -0x27(%r14), %ecx
cmpl $0x38, %ecx
ja 0x7793
btq %rcx, %rbx
jae 0x7793
cmpq $0x3fe, %r12            # imm = 0x3FE
je 0x780a
movb %r14b, -0x430(%rbp,%r12)
incq %r12
movslq 0x14f14(%rip), %rax     # 0x1c698
movq (%r13,%rax,8), %rdi
callq 0x3220
movl %eax, %r14d
jmp 0x7746
cmpl $0x0, -0x2c(%rbp)
setne %cl
cmpl $0x21, %r14d
sete %dl
btl $0xb, %eax
jb 0x7765
andb %dl, %cl
jne 0x7765
movb $0x0, -0x430(%rbp,%r12)
movslq 0x14edd(%rip), %rax     # 0x1c698
movq (%r13,%rax,8), %rsi
movl %r14d, %edi
callq 0x3170
leaq 0xcd55(%rip), %rsi      # 0x14524
leaq -0x430(%rbp), %rdi
pushq $0x5
popq %rdx
callq 0x3180
testl %eax, %eax
je 0x782e
leaq 0xcd40(%rip), %rsi      # 0x14529
leaq -0x430(%rbp), %rdi
pushq $0x6
popq %rdx
callq 0x3180
testl %eax, %eax
je 0x7832
leaq -0x430(%rbp), %rdi
callq 0x69ff
jmp 0x781c
leaq 0xccff(%rip), %rdi      # 0x14510
pushq $-0x8
popq %rsi
callq 0x33e4
pushq $-0x5
popq %rax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x2
jmp 0x781b
pushq $-0x3
jmp 0x781b
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
movl %edi, %r14d
xorl %r12d, %r12d
leaq 0xccd8(%rip), %rbx      # 0x1452f
pushq $0x10
popq %r15
leaq 0x1491e(%rip), %r13     # 0x1c180
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0x30f0
testq %rax, %rax
je 0x789f
cmpq $0x3fe, %r12            # imm = 0x3FE
je 0x78ca
movb %r14b, -0x430(%rbp,%r12)
incq %r12
movslq 0x14e08(%rip), %rax     # 0x1c698
movq (%r13,%rax,8), %rdi
callq 0x3220
movl %eax, %r14d
jmp 0x7862
movb $0x0, -0x430(%rbp,%r12)
movslq 0x14de9(%rip), %rax     # 0x1c698
movq (%r13,%rax,8), %rsi
movl %r14d, %edi
callq 0x3170
leaq -0x430(%rbp), %rdi
callq 0x69ff
jmp 0x78dc
leaq 0xcc6e(%rip), %rdi      # 0x1453f
pushq $-0x8
popq %rsi
callq 0x33e4
pushq $-0x5
popq %rax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: xread
cell xread(void) {
	if (Streams[Instream] == NULL)
		return error("instream is not open", NOEXPR);
	Level = 0;
	return read_form();
}

// Assembly:
movslq 0x14d64(%rip), %rax     # 0x1c698
leaq 0x14845(%rip), %rcx     # 0x1c180
cmpq $0x0, (%rcx,%rax,8)
je 0x794e
andl $0x0, 0x14d37(%rip)     # 0x1c680
jmp 0x6cb2
pushq %rbp
movq %rsp, %rbp
leaq 0xcc68(%rip), %rdi      # 0x145c1
pushq $-0x8
popq %rsi
callq 0x33e4
pushq $-0x5
popq %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movl %edx, %r8d
movq %rsi, %rcx
movq %rdi, %rbx
movq %rsi, %rax
negq %rax
cmovsq %rsi, %rax
movq %rsi, %rdi
sarq $0x3f, %rdi
leaq -0xa(%rbp), %rsi
movb $0x0, 0x1(%rsi)
xorl %r9d, %r9d
pushq $0xa
popq %r10
testq %rax, %rax
setne %dl
testl %r9d, %r9d
sete %r11b
orb %dl, %r11b
je 0x79c2
cmpl $0x26, %r9d
je 0x7a00
xorl %edx, %edx
divq %r10
incl %r9d
orb $0x30, %dl
movb %dl, (%rsi)
decq %rsi
jmp 0x7998
addl %r8d, %edi
cmpl %edi, %r9d
jge 0x79db
cmpl $0x26, %r9d
ja 0x79db
incl %r9d
movb $0x30, (%rsi)
decq %rsi
jmp 0x79c5
testq %rcx, %rcx
js 0x79e5
incq %rsi
jmp 0x79ee
cmpl $0x27, %r9d
jae 0x7a00
movb $0x2d, (%rsi)
movq %rbx, %rdi
callq 0x3060
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
leaq 0xcbcf(%rip), %rdi      # 0x145d6
callq 0x39b6
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: print_expanded_real
void print_expanded_real(cell m, cell e, int n_digits, int neg) {
	char	buf[DIGITS_PER_WORD+3];
	int	k, first;
	int	dp_offset, old_offset;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addl %edx, %ebx
testl %ecx, %ecx
je 0x7a35
leaq 0xc784(%rip), %rdi      # 0x141b4
callq 0x3873
testl %ebx, %ebx
jg 0x7a55
leaq 0xcbac(%rip), %rdi      # 0x145ec
callq 0x3873
testl %ebx, %ebx
jns 0x7a55
leaq 0xc772(%rip), %rdi      # 0x141c2
callq 0x3873
leaq 0xcb90(%rip), %r15      # 0x145ec
movl %ebx, %r12d
testl %r12d, %r12d
jns 0x7a71
movq %r15, %rdi
callq 0x3873
incl %r12d
jmp 0x7a5f
xorl %edx, %edx
leaq -0x34(%rbp), %r15
pushq $0x9
popq %r13
cmpq $-0x1, %r14
je 0x7af5
movq 0x146e8(%rip), %rax     # 0x1c170
movq (%rax,%r14,8), %rax
movq %rax, %rsi
negq %rsi
cmovsq %rax, %rsi
movq %r15, %rdi
callq 0x7966
movq %r15, %rdi
callq 0x30a0
movl %ebx, %r12d
subl %eax, %r12d
setns %al
testl %ebx, %ebx
sets %cl
orb %al, %cl
jne 0x7ada
movl %ebx, %eax
leaq (%rax,%rbp), %rdi
addq $-0x33, %rdi
leaq -0x34(%rbp,%rax), %rbx
pushq $0x1
popq %rax
movl %eax, %edx
subl %r12d, %edx
movq %rbx, %rsi
callq 0x31a0
movb $0x2e, (%rbx)
movq %r15, %rdi
callq 0x3873
movq 0x14ad7(%rip), %rax     # 0x1c5c0
movq (%rax,%r14,8), %r14
movl %r13d, %edx
movl %r12d, %ebx
jmp 0x7a7b
testl %ebx, %ebx
js 0x7b1c
leaq 0xcaec(%rip), %r14      # 0x145ec
testl %ebx, %ebx
jle 0x7b10
movq %r14, %rdi
callq 0x3873
decl %ebx
jmp 0x7b00
leaq 0xcad4(%rip), %rdi      # 0x145eb
callq 0x3873
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: round_last
cell round_last(cell m, cell e, int n_digits, int flags) {
	cell	one;
	int	r;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rsi, %r14
movq %rdi, %rsi
pushq $-0x18
popq %rdi
pushq $0x1
popq %rdx
callq 0x3613
movq %rax, %rdi
callq 0x4a81
movq %rax, %r15
movq 0x14a66(%rip), %rax     # 0x1c5c0
movq (%rax,%r15,8), %rsi
leaq 0xca89(%rip), %rdi      # 0x145ee
callq 0x41c5
movq 0x145ff(%rip), %rcx     # 0x1c170
movq (%rcx,%r15,8), %r15
cmpl $0x5, %eax
jl 0x7bb0
movq 0x145a7(%rip), %rsi     # 0x1c128
movq %r15, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x14596(%rip)     # 0x1c128
pushq $0x1
popq %rdi
callq 0x35ed
movq %r15, %rdi
movq %rax, %rsi
callq 0x44fe
movq %rax, %r15
pushq $0x1
popq %rdi
callq 0x3775
movq 0x14a09(%rip), %rax     # 0x1c5c0
movq (%rax,%r15,8), %rdx
incq %r14
movl %ebx, %edi
movq %r14, %rsi
callq 0x529a
leaq 0xca1f(%rip), %rsi      # 0x145ee
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5321
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: print_real
int print_real(cell n) {
	int	n_digits;
	cell	m, e;
	char	buf[DIGITS_PER_WORD+2];

	if (!real_p(n))
		return 0;
	m = x_real_mantissa(n);
	n_digits = count_digits(m);
	e = x_real_exponent(n);
	if (n_digits == MANTISSA_SIZE && e < 0) {
		print_real(round_last(m, e, n_digits, x_real_flags(n)));
		return 1;
	}
	if (e+n_digits > -4 && e+n_digits <= 6) {
		print_expanded_real(m, e, n_digits, x_real_negative_flag(n));
		return 1;
	}
	if (x_real_negative_flag(n))
		pr("-");
	ntoa(buf, car(m), 0);
	pr_raw(buf, 1);
	pr(".");
	pr(buf[1] || cdr(m) != NIL? &buf[1]: "0");
	m = cdr(m);
	while (m != NIL) {
		pr(ntoa(buf, car(m), DIGITS_PER_WORD));
		m = cdr(m);
	}
	pr("e");
	if (e+n_digits-1 >= 0)
		pr("+");
	pr(ntoa(buf, e+n_digits-1, 0));
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %r15d, %r15d
testq %rdi, %rdi
js 0x7d75
movq 0x149db(%rip), %rax     # 0x1c5e0
testb $0x1, (%rax,%rdi)
je 0x7d75
movq 0x1455a(%rip), %r13     # 0x1c170
cmpq $-0x1f, (%r13,%rdi,8)
jne 0x7d75
movq 0x14997(%rip), %rax     # 0x1c5c0
movq (%rax,%rdi,8), %r15
movq (%rax,%r15,8), %rbx
movq (%rax,%rbx,8), %r14
movq %r14, %rdi
callq 0x52d5
movq %rax, %r12
movq (%r13,%rbx,8), %rbx
cmpq $0x24, %rax
sete %al
testq %rbx, %rbx
sets %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x7c73
movl (%r13,%r15,8), %ecx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7b2b
movq %rax, %rdi
callq 0x7be1
jmp 0x7c97
leaq (%rbx,%r12), %rax
addq $0x3, %rax
movq (%r13,%r15,8), %rcx
cmpq $0x9, %rax
ja 0x7ca0
andl $0x1, %ecx
movq %r14, %rdi
movq %rbx, %rsi
movl %r12d, %edx
callq 0x7a0c
pushq $0x1
popq %r15
jmp 0x7d75
testb $0x1, %cl
je 0x7cb8
leaq 0xc508(%rip), %rdi      # 0x141b4
callq 0x3873
movq 0x144b8(%rip), %r13     # 0x1c170
movq (%r13,%r14,8), %rsi
leaq -0x33(%rbp), %r13
movq %r13, %rdi
xorl %edx, %edx
callq 0x7966
pushq $0x1
popq %r15
movq %r13, %rdi
movl %r15d, %esi
callq 0x37d7
leaq 0xc4e1(%rip), %rdi      # 0x141c2
callq 0x3873
cmpb $0x0, 0x1(%r13)
jne 0x7cff
movq 0x148cc(%rip), %rax     # 0x1c5c0
cmpq $-0x1, (%rax,%r14,8)
je 0x7d87
leaq -0x32(%rbp), %rdi
addq %r12, %rbx
pushq $0x9
popq %r12
callq 0x3873
movq 0x148aa(%rip), %rax     # 0x1c5c0
movq (%rax,%r14,8), %r14
cmpq $-0x1, %r14
je 0x7d3b
movq 0x14449(%rip), %rax     # 0x1c170
movq (%rax,%r14,8), %rsi
movq %r13, %rdi
movl %r12d, %edx
callq 0x7966
movq %r13, %rdi
jmp 0x7d0a
leaq 0xd2e2(%rip), %rdi      # 0x15024
callq 0x3873
leaq -0x1(%rbx), %r14
testq %rbx, %rbx
jle 0x7d5c
leaq 0xc45b(%rip), %rdi      # 0x141b2
callq 0x3873
leaq -0x33(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x7966
movq %rbx, %rdi
callq 0x3873
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc85e(%rip), %rdi      # 0x145ec
jmp 0x7d03
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: print_integer
int print_integer(cell n) {
	int	first;
	char	buf[DIGITS_PER_WORD+2];

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
xorl %ebx, %ebx
testq %rdi, %rdi
js 0x7e05
movq %rdi, %r14
movq 0x1482d(%rip), %rax     # 0x1c5e0
testb $0x1, (%rax,%rdi)
je 0x7e05
movq 0x143b0(%rip), %rax     # 0x1c170
cmpq $-0x18, (%rax,%r14,8)
jne 0x7e05
xorl %edx, %edx
pushq $0x1
popq %rbx
leaq -0x2b(%rbp), %r15
pushq $0x9
popq %r12
movq 0x147e5(%rip), %rax     # 0x1c5c0
movq (%rax,%r14,8), %r14
cmpq $-0x1, %r14
je 0x7e05
movq 0x14384(%rip), %rax     # 0x1c170
movq (%rax,%r14,8), %rsi
movq %r15, %rdi
callq 0x7966
movq %r15, %rdi
callq 0x3873
movl %r12d, %edx
jmp 0x7dd4
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: print_quoted
int print_quoted(cell n) {
	if (	car(n) == S_quote &&
		cdr(n) != NIL &&
		cddr(n) == NIL
	) {
		pr("'");
		print_form(cadr(n));
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x1434f(%rip), %rax     # 0x1c170
movq (%rax,%rdi,8), %rcx
xorl %eax, %eax
cmpq 0x1487a(%rip), %rcx     # 0x1c6a8
jne 0x7e75
movq %rdi, %rbx
movq 0x14786(%rip), %rcx     # 0x1c5c0
movq (%rcx,%rdi,8), %rdx
cmpq $-0x1, %rdx
je 0x7e75
cmpq $-0x1, (%rcx,%rdx,8)
jne 0x7e75
leaq 0xc748(%rip), %rdi      # 0x1459a
callq 0x3873
movq 0x14312(%rip), %rax     # 0x1c170
movq 0x1475b(%rip), %rcx     # 0x1c5c0
movq (%rcx,%rbx,8), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x38e1
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: print_fun
int print_fun(cell n) {
	cell	p, c;

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

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
js 0x7f71
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x14741(%rip), %rcx     # 0x1c5e0
testb $0x1, (%rcx,%rdi)
je 0x7f63
movq 0x142c0(%rip), %rcx     # 0x1c170
cmpq $-0x1e, (%rcx,%r14,8)
jne 0x7f63
leaq 0xc732(%rip), %rdi      # 0x145f4
callq 0x3873
movq 0x142a2(%rip), %rax     # 0x1c170
movq 0x146eb(%rip), %rcx     # 0x1c5c0
movq (%rcx,%r14,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rbx
leaq 0xd930(%rip), %r13      # 0x15818
leaq 0xc708(%rip), %r14      # 0x145f7
movq %rbx, %r12
cmpq $-0x1, %r12
je 0x7f60
cmpq %rbx, %r12
movq %r14, %rdi
cmoveq %r13, %rdi
callq 0x3873
movq 0x14262(%rip), %rax     # 0x1c170
movq (%rax,%r12,8), %rcx
movq (%rax,%rcx,8), %r15
testq %r15, %r15
js 0x7f4b
movq 0x146be(%rip), %rcx     # 0x1c5e0
testb $0x19, (%rcx,%r15)
jne 0x7f4b
cmpq $-0x9, (%rax,%r15,8)
jne 0x7f4b
movq 0x14689(%rip), %rcx     # 0x1c5c0
movq (%rcx,%r15,8), %rcx
movq (%rax,%rcx,8), %r15
leaq 0xcbad(%rip), %rdi      # 0x14af3
callq 0x3873
movq %r15, %rdi
callq 0x38e1
movq 0x14666(%rip), %rax     # 0x1c5c0
movq (%rax,%r12,8), %r12
jmp 0x7ef2
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: print_char
int print_char(cell n) {
	char	b[1];
	int	c;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
xorl %r14d, %r14d
testq %rdi, %rdi
js 0x8072
movq %rdi, %rbx
movq 0x14616(%rip), %rax     # 0x1c5e0
testb $0x1, (%rax,%rdi)
je 0x8072
movq 0x14195(%rip), %rcx     # 0x1c170
cmpq $-0x16, (%rcx,%rbx,8)
jne 0x8072
cmpl $0x0, 0x146d3(%rip)     # 0x1c6c0
je 0x7ff3
xorl %eax, %eax
jmp 0x8010
leaq 0xc610(%rip), %rdi      # 0x1460a
callq 0x3873
movq 0x1416a(%rip), %rcx     # 0x1c170
cmpl $0x0, 0x146b3(%rip)     # 0x1c6c0
sete %al
movq 0x145a9(%rip), %rdx     # 0x1c5c0
movq (%rdx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rcx
testb %al, %al
je 0x8031
cmpl $0x20, %ecx
jne 0x8031
leaq 0xcff1(%rip), %rdi      # 0x15020
jmp 0x8044
cmpl $0xa, %ecx
sete %dl
andb %dl, %al
cmpb $0x1, %al
jne 0x804b
leaq 0xc485(%rip), %rdi      # 0x144c9
callq 0x3873
jmp 0x8059
leaq -0x11(%rbp), %rdi
movb %cl, (%rdi)
pushq $0x1
popq %rsi
callq 0x37d7
pushq $0x1
popq %r14
cmpl $0x0, 0x1465c(%rip)     # 0x1c6c0
jne 0x8072
leaq 0xc59e(%rip), %rdi      # 0x1460b
callq 0x3873
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: print_string
int print_string(cell n) {
	char	b[1];
	int	k;
	char	*s;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
js 0x814a
movq %rdi, %r14
movq 0x1453f(%rip), %rax     # 0x1c5e0
testb $0x10, (%rax,%rdi)
je 0x814a
movq 0x140be(%rip), %rax     # 0x1c170
cmpq $-0x21, (%rax,%r14,8)
jne 0x814a
cmpl $0x0, 0x145fc(%rip)     # 0x1c6c0
jne 0x80d2
leaq 0xc53e(%rip), %rdi      # 0x1460b
callq 0x3873
movq 0x1450f(%rip), %rax     # 0x1c5e8
movq 0x144e0(%rip), %rcx     # 0x1c5c0
movq (%rcx,%r14,8), %rcx
leaq (%rax,%rcx,8), %r12
movl -0x8(%r12), %r13d
decl %r13d
xorl %r14d, %r14d
leaq -0x29(%rbp), %r15
pushq $0x1
popq %rbx
cmpl %r14d, %r13d
je 0x8135
movzbl (%r12,%r14), %eax
movb %al, -0x29(%rbp)
cmpl $0x0, 0x145b2(%rip)     # 0x1c6c0
jne 0x8126
cmpl $0x5c, %eax
je 0x811a
cmpl $0x22, %eax
jne 0x8126
leaq 0xc4ec(%rip), %rdi      # 0x1460d
callq 0x3873
movq %r15, %rdi
movl %ebx, %esi
callq 0x37d7
incq %r14
jmp 0x80fa
cmpl $0x0, 0x14584(%rip)     # 0x1c6c0
jne 0x814a
leaq 0xc4c6(%rip), %rdi      # 0x1460b
callq 0x3873
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: print_symbol
int print_symbol(cell n) {
	char	b[2];
	int	k;
	char	*s;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
js 0x81d0
movq 0x14469(%rip), %rax     # 0x1c5e0
testb $0x10, (%rax,%rdi)
je 0x81d0
movq 0x13fec(%rip), %rax     # 0x1c170
cmpq $-0x22, (%rax,%rdi,8)
jne 0x81d0
movq 0x14456(%rip), %rax     # 0x1c5e8
movq 0x14427(%rip), %rcx     # 0x1c5c0
movq (%rcx,%rdi,8), %rcx
leaq (%rax,%rcx,8), %r15
movl -0x8(%r15), %r12d
leaq -0x2a(%rbp), %r14
movb $0x0, 0x1(%r14)
decl %r12d
xorl %r13d, %r13d
pushq $0x1
popq %rbx
cmpl %r13d, %r12d
je 0x81d0
movb (%r15,%r13), %al
movb %al, -0x2a(%rbp)
movq %r14, %rdi
callq 0x3873
incq %r13
jmp 0x81b7
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: print_primitive
int print_primitive(cell n) {
	PRIM	*p;

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

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
js 0x8254
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x143e8(%rip), %rcx     # 0x1c5e0
testb $0x1, (%rcx,%rdi)
je 0x824e
movq 0x13f6b(%rip), %rcx     # 0x1c170
cmpq $-0x1d, (%rcx,%rbx,8)
jne 0x824e
leaq 0xc3fc(%rip), %rdi      # 0x1460f
callq 0x3873
movq 0x144a9(%rip), %rax     # 0x1c6c8
movq 0x13f4a(%rip), %rcx     # 0x1c170
movq 0x14393(%rip), %rdx     # 0x1c5c0
movq (%rdx,%rbx,8), %rdx
imulq $0x28, (%rcx,%rdx,8), %rcx
movq (%rax,%rcx), %rdi
callq 0x3873
leaq 0xbf5b(%rip), %rdi      # 0x141a1
callq 0x3873
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: print_vector
int print_vector(cell n) {
	cell	*p;
	int	k;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
testq %rdi, %rdi
js 0x830d
movq 0x14338(%rip), %rax     # 0x1c5e0
testb $0x10, (%rax,%rdi)
je 0x830d
movq 0x13ebb(%rip), %rax     # 0x1c170
cmpq $-0x24, (%rax,%rdi,8)
jne 0x830d
movq 0x14325(%rip), %rax     # 0x1c5e8
movq 0x142f6(%rip), %rcx     # 0x1c5c0
movq (%rcx,%rdi,8), %rcx
leaq (%rax,%rcx,8), %r15
movq -0x8(%r15), %r12
addq $0x7, %r12
shrq $0x3, %r12
leaq -0x1(%r12), %r13
xorl %r14d, %r14d
pushq $0x1
popq %rbx
cmpl %r14d, %r12d
je 0x830d
movq (%r15,%r14,8), %rdi
callq 0x38e1
cmpl %r14d, %r13d
je 0x8308
leaq 0xc320(%rip), %rdi      # 0x14623
callq 0x3873
incq %r14
jmp 0x82e9
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: print_stream
int print_stream(cell n) {
	char	buf[100];

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

// Assembly:
xorl %eax, %eax
testq %rdi, %rdi
js 0x839a
movq 0x142b4(%rip), %rcx     # 0x1c5e0
movb (%rcx,%rdi), %cl
notb %cl
testb $0x21, %cl
jne 0x839a
movq 0x13e33(%rip), %rcx     # 0x1c170
movq (%rcx,%rdi,8), %rdx
cmpq $-0x17, %rdx
je 0x8356
cmpq $-0x19, %rdx
jne 0x839a
leaq 0xc2e0(%rip), %rdx      # 0x14634
jmp 0x835d
leaq 0xd10c(%rip), %rdx      # 0x15469
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
movq 0x14253(%rip), %rax     # 0x1c5c0
movq (%rax,%rdi,8), %rax
movl (%rcx,%rax,8), %ecx
leaq 0xc2ab(%rip), %rsi      # 0x14626
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x31f0
movq %rbx, %rdi
callq 0x3873
pushq $0x1
popq %rax
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: print_cons
int print_cons(cell n) {
	cell	p;

	if (!list_p(n))
		return 0;
	for (p = n; p != NIL; p = cdr(p))
		if (atom_p(p))
			break;
	if (p == NIL)
		return 0;
	for (p = n; !atom_p(p); p = cdr(p)) {
		print_form(car(p));
		pr(" :: ");
	}
	print_form(p);
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
js 0x83be
movq 0x1422f(%rip), %rax     # 0x1c5e0
movb (%rax,%rbx), %cl
andb $0x19, %cl
cmpb $0x8, %cl
je 0x83cb
jmp 0x842a
cmpq $-0x1, %rbx
jne 0x842a
movq 0x14215(%rip), %rax     # 0x1c5e0
movq 0x141ee(%rip), %rdx     # 0x1c5c0
movq %rbx, %rcx
testq %rcx, %rcx
js 0x83e6
testb $0x11, (%rax,%rcx)
jne 0x83ec
movq (%rdx,%rcx,8), %rcx
jmp 0x83d5
cmpq $-0x1, %rcx
je 0x842a
leaq 0xc245(%rip), %r14      # 0x14638
testq %rbx, %rbx
js 0x842e
movq 0x141e1(%rip), %rax     # 0x1c5e0
testb $0x11, (%rax,%rbx)
jne 0x842e
movq 0x13d64(%rip), %rax     # 0x1c170
movq (%rax,%rbx,8), %rdi
callq 0x38e1
movq %r14, %rdi
callq 0x3873
movq 0x1419c(%rip), %rax     # 0x1c5c0
movq (%rax,%rbx,8), %rbx
jmp 0x83f3
xorl %eax, %eax
jmp 0x8439
movq %rbx, %rdi
callq 0x38e1
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: init_ops
void init_ops(void) {
	cell		n, s, a, ops, new;
	int		k;
	operator	*p, *q;

	ops = node(NIL, NIL);
	save(ops);
	q = Op_init;
	for (p = q; p->prec;) {
		a = node(NIL, NIL);
		save(a);
		while (p == q || p->prec == (p-1)->prec) {
			n = node(make_integer(p->assoc), NIL);
			save(n);
			k = strlen(p->name);
			s = make_string(p->name, k);
			unsave(1);
			n = node(s, n);
			car(a) = n;
			if (p->prec == (p+1)->prec) {
				set(cdr(a), node(NIL, NIL));
				a = cdr(a);
			}
			p++;
		}
		q = p;
		car(ops) = unsave(1);
		if (p->prec) {
			set(cdr(ops), node(NIL, NIL));
			ops = cdr(ops);
		}
	}
	Ops = unsave(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
pushq $-0x1
popq %rdi
movq %rdi, %rsi
xorl %edx, %edx
callq 0x3613
movq 0x139e1(%rip), %rsi     # 0x1c128
movq %rax, -0x30(%rbp)
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x139cc(%rip)     # 0x1c128
leaq 0x129cd(%rip), %rbx     # 0x1b130
movq %rbx, %r15
cmpl $0x0, 0x8(%r15)
je 0x8895
pushq $-0x1
popq %rdi
movq %rdi, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %r12
movq 0x139a0(%rip), %rsi     # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x1398f(%rip)     # 0x1c128
movq %r15, %r14
movq %r14, %rbx
cmpq %r15, %rbx
je 0x87b0
movl 0x8(%rbx), %eax
cmpl -0x8(%rbx), %eax
jne 0x884c
movslq 0xc(%rbx), %rdi
callq 0x35ed
movq %rax, %rdi
pushq $-0x1
popq %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %r13
movq 0x13958(%rip), %rsi     # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x13947(%rip)     # 0x1c128
movq (%rbx), %r14
movq %r14, %rdi
callq 0x30a0
movq %r14, %rdi
movl %eax, %esi
callq 0x729e
movq %rax, %r14
pushq $0x1
popq %rdi
callq 0x3775
movq %r14, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x3613
movq 0x1395b(%rip), %rcx     # 0x1c170
movq %rax, (%rcx,%r12,8)
movl 0x8(%rbx), %eax
leaq 0x10(%rbx), %r14
cmpl 0x18(%rbx), %eax
movq %r14, %rbx
jne 0x879f
pushq $-0x1
popq %rdi
movq %rdi, %rsi
xorl %edx, %edx
callq 0x3613
movq 0x13d80(%rip), %rcx     # 0x1c5c0
movq %rax, (%rcx,%r12,8)
movq %rax, %r12
jmp 0x879c
pushq $0x1
popq %rdi
callq 0x3775
movq 0x13915(%rip), %rcx     # 0x1c170
movq -0x30(%rbp), %rdx
movq %rax, (%rcx,%rdx,8)
cmpl $0x0, 0x8(%rbx)
movq %rbx, %r15
je 0x8766
pushq $-0x1
popq %rdi
movq %rdi, %rsi
xorl %edx, %edx
callq 0x3613
movq 0x13d3c(%rip), %rcx     # 0x1c5c0
movq -0x30(%rbp), %rdx
movq %rax, (%rcx,%rdx,8)
movq %rax, -0x30(%rbp)
jmp 0x8763
pushq $0x1
popq %rdi
callq 0x3775
movq %rax, 0x138ac(%rip)     # 0x1c150
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: find_binop
int find_binop(char *s, int *pp, int *ap) {
	cell	lev, op;
	int	prec;

	prec = 1;
	for (lev = Ops; lev != NIL; lev = cdr(lev), prec++) {
		for (op = car(lev); op != NIL; op = cdr(op)) {
			if (!strcmp(s, string(caar(op)))) {
				*pp = prec;
				*ap = integer_value("", cadar(op));
				return 1;
			}
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, -0x40(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdi, -0x50(%rbp)
movq 0x13899(%rip), %r12     # 0x1c170
movq 0x13d0a(%rip), %rbx     # 0x1c5e8
pushq $0x1
popq %rcx
leaq 0x13868(%rip), %rax     # 0x1c150
movq 0x13cd1(%rip), %r14     # 0x1c5c0
movq (%rax), %rax
cmpq $-0x1, %rax
je 0x8973
movl %ecx, -0x2c(%rbp)
movq %rax, -0x48(%rbp)
leaq (%r12,%rax,8), %rax
movq (%rax), %r13
cmpq $-0x1, %r13
je 0x892f
movq (%r12,%r13,8), %r15
movq (%r12,%r15,8), %rax
movq (%r14,%rax,8), %rax
leaq (%rbx,%rax,8), %rsi
movq -0x50(%rbp), %rdi
callq 0x3110
testl %eax, %eax
je 0x893e
leaq (%r14,%r13,8), %rax
jmp 0x8903
movq -0x48(%rbp), %rax
leaq (%r14,%rax,8), %rax
movl -0x2c(%rbp), %ecx
incl %ecx
jmp 0x88ef
movq -0x38(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
movq (%r14,%r15,8), %rax
movq (%r12,%rax,8), %rsi
leaq 0xcf82(%rip), %rdi      # 0x158d8
callq 0x41c5
movq -0x40(%rbp), %rcx
movl %eax, (%rcx)
pushq $0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x8964