LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addl %edx, %r14d
testl %ecx, %ecx
je 0x85d1
leaq 0xdbe8(%rip), %rdi      # 0x161b4
callq 0x3964
testl %r14d, %r14d
jg 0x860a
leaq 0xe00f(%rip), %rdi      # 0x165ec
callq 0x3964
testl %r14d, %r14d
jns 0x860a
leaq 0xdbd4(%rip), %rdi      # 0x161c2
callq 0x3964
leaq 0xdff2(%rip), %r15      # 0x165ec
movl %r14d, %r12d
movq %r15, %rdi
callq 0x3964
incl %r12d
jne 0x85fd
cmpq $-0x1, %rbx
je 0x869c
xorl %edx, %edx
leaq -0x2c(%rbp), %r15
movl %r14d, %r12d
movq 0x15b4c(%rip), %rax     # 0x1e170
movq (%rax,%rbx,8), %rax
movq %rax, %rsi
negq %rsi
cmovsq %rax, %rsi
movq %r15, %rdi
callq 0x8468
movq %r15, %rdi
callq 0x30a0
subl %eax, %r12d
setns %al
testl %r14d, %r14d
sets %cl
orb %al, %cl
jne 0x8679
movl %r14d, %eax
leaq (%rax,%rbp), %rdi
addq $-0x2b, %rdi
leaq (%rax,%rbp), %r14
addq $-0x2c, %r14
movl $0x1, %edx
subl %r12d, %edx
movq %r14, %rsi
callq 0x31a0
movb $0x2e, (%r14)
movq %r15, %rdi
callq 0x3964
movq 0x15f38(%rip), %rax     # 0x1e5c0
movq (%rax,%rbx,8), %rbx
movl $0x9, %edx
movl %r12d, %r14d
cmpq $-0x1, %rbx
jne 0x861d
jmp 0x869f
movl %r14d, %r12d
testl %r12d, %r12d
js 0x86cd
je 0x86c1
incl %r12d
leaq 0xdf3c(%rip), %rbx      # 0x165ec
movq %rbx, %rdi
callq 0x3964
decl %r12d
cmpl $0x1, %r12d
ja 0x86b0
leaq 0xdf23(%rip), %rdi      # 0x165eb
callq 0x3964
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: 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
movq $-0x18, %rdi
movl $0x1, %edx
callq 0x36e8
movq %rax, %rdi
callq 0x4dca
movq %rax, %r15
movq 0x15eb1(%rip), %rax     # 0x1e5c0
movq (%rax,%r15,8), %rsi
leaq 0xded4(%rip), %rdi      # 0x165ee
callq 0x432f
movq 0x15a4a(%rip), %rcx     # 0x1e170
movq (%rcx,%r15,8), %r15
cmpl $0x5, %eax
jl 0x8789
movq 0x159f2(%rip), %rsi     # 0x1e128
movq %r15, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x159e1(%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 %r15, %rdi
movq %rax, %rsi
callq 0x472e
movq %rax, %r15
movl $0x1, %edi
callq 0x384f
movq 0x15e30(%rip), %rax     # 0x1e5c0
movq (%rax,%r15,8), %rdx
incq %r14
movl %ebx, %edi
movq %r14, %rsi
callq 0x5768
leaq 0xde46(%rip), %rsi      # 0x165ee
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x580e
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
subq $0x18, %rsp
xorl %ebx, %ebx
testq %rdi, %rdi
js 0x8a72
movq 0x15bcf(%rip), %rax     # 0x1e5e0
testb $0x1, (%rax,%rdi)
je 0x8a72
movq 0x15752(%rip), %rax     # 0x1e170
cmpq $-0x18, (%rax,%rdi,8)
jne 0x8a72
movq 0x15b94(%rip), %rax     # 0x1e5c0
movq (%rax,%rdi,8), %r15
movl $0x1, %ebx
cmpq $-0x1, %r15
je 0x8a72
xorl %edx, %edx
leaq -0x23(%rbp), %r14
movq 0x15728(%rip), %rax     # 0x1e170
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x8468
movq %r14, %rdi
callq 0x3964
movq 0x15b5d(%rip), %rax     # 0x1e5c0
movq (%rax,%r15,8), %r15
movl $0x9, %edx
cmpq $-0x1, %r15
jne 0x8a41
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x156e4(%rip), %rax     # 0x1e170
movq (%rax,%rdi,8), %rcx
xorl %eax, %eax
cmpq 0x15c0f(%rip), %rcx     # 0x1e6a8
jne 0x8ae4
movq %rdi, %rbx
movq 0x15b1b(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rdi,8), %rdx
cmpq $-0x1, %rdx
je 0x8ae4
cmpq $-0x1, (%rcx,%rdx,8)
jne 0x8ae4
leaq 0xdadd(%rip), %rdi      # 0x1659a
callq 0x3964
movq 0x156a7(%rip), %rax     # 0x1e170
movq 0x15af0(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rbx,8), %rcx
movq (%rax,%rcx,8), %rdi
xorl %esi, %esi
callq 0x9124
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8bf1
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x15ad2(%rip), %rcx     # 0x1e5e0
testb $0x1, (%rcx,%rdi)
je 0x8be3
movq 0x15651(%rip), %rcx     # 0x1e170
cmpq $-0x1e, (%rcx,%r14,8)
jne 0x8be3
leaq 0xdac3(%rip), %rdi      # 0x165f4
callq 0x3964
movq 0x15633(%rip), %rax     # 0x1e170
movq 0x15a7c(%rip), %rcx     # 0x1e5c0
movq (%rcx,%r14,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rbx
movl $0x1, %eax
cmpq $-0x1, %rbx
je 0x8be3
leaq 0xecb2(%rip), %r13      # 0x17818
leaq 0xda8a(%rip), %r14      # 0x165f7
movq %rbx, %r12
cmpq %rbx, %r12
movq %r14, %rdi
cmoveq %r13, %rdi
callq 0x3964
movq 0x155ea(%rip), %rax     # 0x1e170
movq (%rax,%r12,8), %rcx
movq (%rax,%rcx,8), %r15
testq %r15, %r15
js 0x8bc3
movq 0x15a46(%rip), %rcx     # 0x1e5e0
testb $0x19, (%rcx,%r15)
jne 0x8bc3
cmpq $-0x9, (%rax,%r15,8)
jne 0x8bc3
movq 0x15a11(%rip), %rcx     # 0x1e5c0
movq (%rcx,%r15,8), %rcx
movq (%rax,%rcx,8), %r15
leaq 0xdf35(%rip), %rdi      # 0x16af3
callq 0x3964
movq %r15, %rdi
xorl %esi, %esi
callq 0x9124
movq 0x159ec(%rip), %rax     # 0x1e5c0
movq (%rax,%r12,8), %r12
cmpq $-0x1, %r12
jne 0x8b70
movl $0x1, %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: 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 %ebx, %ebx
testq %rdi, %rdi
js 0x8cfa
movq %rdi, %r14
movq 0x15995(%rip), %rax     # 0x1e5e0
testb $0x1, (%rax,%rdi)
je 0x8cfa
movq 0x15514(%rip), %rax     # 0x1e170
cmpq $-0x16, (%rax,%r14,8)
jne 0x8cfa
cmpl $0x0, 0x15a52(%rip)     # 0x1e6c0
je 0x8c91
movq 0x15949(%rip), %rcx     # 0x1e5c0
movq (%rcx,%r14,8), %rcx
movq (%rax,%rcx,8), %rax
leaq -0x11(%rbp), %rdi
movb %al, (%rdi)
movl $0x1, %esi
callq 0x38b8
jmp 0x8ce0
leaq 0xd972(%rip), %rdi      # 0x1660a
callq 0x3964
movq 0x154cc(%rip), %rax     # 0x1e170
movl 0x15a16(%rip), %ecx     # 0x1e6c0
movq 0x1590f(%rip), %rdx     # 0x1e5c0
movq (%rdx,%r14,8), %rdx
movq (%rax,%rdx,8), %rax
testl %ecx, %ecx
jne 0x8ccb
cmpl $0x20, %eax
jne 0x8ccb
leaq 0xe357(%rip), %rdi      # 0x17020
jmp 0x8cdb
testl %ecx, %ecx
jne 0x8c7f
cmpl $0xa, %eax
jne 0x8c7f
leaq 0xd7ee(%rip), %rdi      # 0x164c9
callq 0x3964
movl $0x1, %ebx
cmpl $0x0, 0x159d4(%rip)     # 0x1e6c0
jne 0x8cfa
leaq 0xd916(%rip), %rdi      # 0x1660b
callq 0x3964
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8dda
movq %rdi, %r14
movq 0x158b8(%rip), %rax     # 0x1e5e0
testb $0x10, (%rax,%rdi)
je 0x8dda
movq 0x15437(%rip), %rax     # 0x1e170
cmpq $-0x21, (%rax,%r14,8)
jne 0x8dda
cmpl $0x0, 0x15975(%rip)     # 0x1e6c0
jne 0x8d59
leaq 0xd8b7(%rip), %rdi      # 0x1660b
callq 0x3964
movq 0x15888(%rip), %rax     # 0x1e5e8
movq 0x15859(%rip), %rcx     # 0x1e5c0
movq (%rcx,%r14,8), %rdx
movl -0x8(%rax,%rdx,8), %ecx
decl %ecx
je 0x8dc0
leaq (%rax,%rdx,8), %r15
movl %ecx, %r12d
xorl %r13d, %r13d
leaq 0xd889(%rip), %rbx      # 0x1660d
leaq -0x29(%rbp), %r14
movzbl (%r15,%r13), %eax
movb %al, -0x29(%rbp)
cmpl $0x0, 0x15929(%rip)     # 0x1e6c0
jne 0x8dab
cmpl $0x5c, %eax
je 0x8da3
cmpl $0x22, %eax
jne 0x8dab
movq %rbx, %rdi
callq 0x3964
movq %r14, %rdi
movl $0x1, %esi
callq 0x38b8
incq %r13
cmpl %r13d, %r12d
jne 0x8d88
movl $0x1, %ebx
cmpl $0x0, 0x158f4(%rip)     # 0x1e6c0
jne 0x8dda
leaq 0xd836(%rip), %rdi      # 0x1660b
callq 0x3964
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_O3/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 0x8e63
movq 0x157d9(%rip), %rax     # 0x1e5e0
testb $0x10, (%rax,%rdi)
je 0x8e63
movq 0x1535c(%rip), %rax     # 0x1e170
cmpq $-0x22, (%rax,%rdi,8)
jne 0x8e63
movq 0x157c6(%rip), %rax     # 0x1e5e8
movq 0x15797(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rdi,8), %rdx
movl -0x8(%rax,%rdx,8), %ecx
movb $0x0, -0x29(%rbp)
movl $0x1, %ebx
decl %ecx
je 0x8e63
leaq (%rax,%rdx,8), %r15
movl %ecx, %r12d
xorl %r13d, %r13d
leaq -0x2a(%rbp), %r14
movb (%r15,%r13), %al
movb %al, -0x2a(%rbp)
movq %r14, %rdi
callq 0x3964
incq %r13
cmpl %r13d, %r12d
jne 0x8e4c
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_O3/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 0x8eec
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x15755(%rip), %rcx     # 0x1e5e0
testb $0x1, (%rcx,%rdi)
je 0x8ee6
movq 0x152d8(%rip), %rcx     # 0x1e170
cmpq $-0x1d, (%rcx,%rbx,8)
jne 0x8ee6
leaq 0xd769(%rip), %rdi      # 0x1660f
callq 0x3964
movq 0x15816(%rip), %rax     # 0x1e6c8
movq 0x152b7(%rip), %rcx     # 0x1e170
movq 0x15700(%rip), %rdx     # 0x1e5c0
movq (%rdx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rcx
leaq (%rcx,%rcx,4), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3964
leaq 0xd2c5(%rip), %rdi      # 0x161a1
callq 0x3964
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x8fc0
movq 0x1569a(%rip), %rax     # 0x1e5e0
testb $0x10, (%rax,%rdi)
je 0x8fc0
movq 0x1521d(%rip), %rax     # 0x1e170
cmpq $-0x24, (%rax,%rdi,8)
jne 0x8fc0
movq 0x15687(%rip), %rax     # 0x1e5e8
movq 0x15658(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rdi,8), %rcx
movq -0x8(%rax,%rcx,8), %r15
addq $0x7, %r15
shrq $0x3, %r15
movl $0x1, %ebx
testl %r15d, %r15d
je 0x8fc0
leaq (%rax,%rcx,8), %r12
movq (%r12), %rdi
xorl %esi, %esi
callq 0x9124
cmpl $0x1, %r15d
je 0x8fc0
movl $0x1, %r13d
leaq 0xd67e(%rip), %r14      # 0x16623
movq %r14, %rdi
callq 0x3964
movq (%r12,%r13,8), %rdi
xorl %esi, %esi
callq 0x9124
incq %r13
cmpl %r13d, %r15d
jne 0x8fa5
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_O3/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 0x904f
movq 0x15601(%rip), %rcx     # 0x1e5e0
movb (%rcx,%rdi), %cl
notb %cl
testb $0x21, %cl
jne 0x904f
movq 0x15180(%rip), %rcx     # 0x1e170
movq (%rcx,%rdi,8), %rdx
cmpq $-0x17, %rdx
je 0x9009
cmpq $-0x19, %rdx
jne 0x904f
leaq 0xd62d(%rip), %rdx      # 0x16634
jmp 0x9010
leaq 0xe459(%rip), %rdx      # 0x17469
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
movq 0x155a0(%rip), %rax     # 0x1e5c0
movq (%rax,%rdi,8), %rax
movl (%rcx,%rax,8), %ecx
leaq 0xd5f8(%rip), %rsi      # 0x16626
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x31f0
movq %rbx, %rdi
callq 0x3964
movl $0x1, %eax
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
xorl %eax, %eax
testq %rdi, %rdi
js 0x90f3
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x15574(%rip), %rcx     # 0x1e5e0
movb (%rcx,%rdi), %cl
andb $0x19, %cl
cmpb $0x8, %cl
jne 0x90ef
movq 0x15562(%rip), %rcx     # 0x1e5e0
movq 0x1553b(%rip), %rsi     # 0x1e5c0
movq %rbx, %rdx
testb $0x11, (%rcx,%rdx)
jne 0x909d
movq (%rsi,%rdx,8), %rdx
testq %rdx, %rdx
jns 0x9088
cmpq $-0x1, %rdx
je 0x90ef
testq %rbx, %rbx
js 0x90e0
leaq 0xd58f(%rip), %r14      # 0x16638
movq 0x15530(%rip), %rax     # 0x1e5e0
testb $0x11, (%rax,%rbx)
jne 0x90e0
movq 0x150b3(%rip), %rax     # 0x1e170
movq (%rax,%rbx,8), %rdi
xorl %esi, %esi
callq 0x9124
movq %r14, %rdi
callq 0x3964
movq 0x154e9(%rip), %rax     # 0x1e5c0
movq (%rax,%rbx,8), %rbx
testq %rbx, %rbx
jns 0x90a9
movq %rbx, %rdi
xorl %esi, %esi
callq 0x9124
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x18, %rsp
movq $-0x1, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
movq 0x14d38(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x14d27(%rip)     # 0x1e128
cmpl $0x0, 0x13d30(%rip)     # 0x1d138
je 0x95bd
leaq 0x13d1b(%rip), %r15     # 0x1d130
movq %rbx, -0x38(%rbp)
movq $-0x1, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x14cf3(%rip), %rsi     # 0x1e128
movq %rax, -0x30(%rbp)
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x14cde(%rip)     # 0x1e128
movq %r15, %rbx
movq %r15, -0x40(%rbp)
movq %rbx, %r14
cmpq %r15, %r14
je 0x9467
movl 0x8(%r14), %eax
cmpl -0x8(%r14), %eax
jne 0x956c
movslq 0xc(%r14), %rdi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x18, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %r15
movq 0x14c7d(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x14c6c(%rip)     # 0x1e128
movq (%r14), %r12
movq %r12, %rdi
callq 0x30a0
movq %rax, %r13
incl %r13d
movq $-0x21, %rdi
movl %r13d, %esi
callq 0x416e
movq %rax, %rbx
movq 0x150da(%rip), %rax     # 0x1e5c0
movq (%rax,%rbx,8), %rdi
shlq $0x3, %rdi
addq 0x150f3(%rip), %rdi     # 0x1e5e8
movslq %r13d, %rdx
movq %r12, %rsi
callq 0x3050
movl $0x1, %edi
callq 0x384f
movq %rbx, %rdi
movq %r15, %rsi
movq -0x40(%rbp), %r15
xorl %edx, %edx
callq 0x36e8
movq 0x14c4e(%rip), %rcx     # 0x1e170
movq -0x30(%rbp), %rdx
movq %rax, (%rcx,%rdx,8)
movl 0x8(%r14), %eax
leaq 0x10(%r14), %rbx
cmpl 0x18(%r14), %eax
movq %rbx, %r14
jne 0x9454
movq $-0x1, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x15065(%rip), %rcx     # 0x1e5c0
movq -0x30(%rbp), %rdx
movq %rax, (%rcx,%rdx,8)
movq %rax, -0x30(%rbp)
jmp 0x9451
movl $0x1, %edi
callq 0x384f
movq 0x14bf3(%rip), %rcx     # 0x1e170
movq -0x38(%rbp), %rbx
movq %rax, (%rcx,%rbx,8)
cmpl $0x0, 0x8(%r14)
je 0x95bd
movq $-0x1, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x15018(%rip), %rcx     # 0x1e5c0
movq %rax, (%rcx,%rbx,8)
cmpl $0x0, 0x8(%r14)
movq %r14, %r15
movq %rax, %rbx
jne 0x9415
movl $0x1, %edi
callq 0x384f
movq %rax, 0x14b82(%rip)     # 0x1e150
addq $0x18, %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: 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 %rdi, -0x50(%rbp)
movq 0x14b57(%rip), %rcx     # 0x1e150
xorl %eax, %eax
cmpq $-0x1, %rcx
je 0x969a
movq %rsi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movq 0x14b5c(%rip), %rbx     # 0x1e170
movq 0x14fcd(%rip), %r14     # 0x1e5e8
movl $0x1, %eax
movq 0x14f99(%rip), %r15     # 0x1e5c0
movl %eax, -0x2c(%rbp)
movq %rcx, -0x48(%rbp)
movq (%rbx,%rcx,8), %r13
cmpq $-0x1, %r13
je 0x965b
movq (%rbx,%r13,8), %r12
movq (%rbx,%r12,8), %rax
movq (%r15,%rax,8), %rax
leaq (%r14,%rax,8), %rsi
movq -0x50(%rbp), %rdi
callq 0x3110
testl %eax, %eax
je 0x9672
movq (%r15,%r13,8), %r13
jmp 0x9632
movl -0x2c(%rbp), %eax
incl %eax
movq -0x48(%rbp), %rcx
movq (%r15,%rcx,8), %rcx
cmpq $-0x1, %rcx
jne 0x9627
xorl %eax, %eax
jmp 0x969a
movq -0x38(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
movq (%r15,%r12,8), %rax
movq (%rbx,%rax,8), %rsi
leaq 0xe24e(%rip), %rdi      # 0x178d8
callq 0x432f
movq -0x40(%rbp), %rcx
movl %eax, (%rcx)
movl $0x1, %eax
addq $0x28, %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: block_comment
void block_comment(void) {
	int	n = 1;
	int	c, p = 0;

	c = read_c();
	while (n && !Error_flag) {
		if (c == '\n')
			Line_no++;
		else if (c == EOF) {
			error("missing '*)' in comment", NOEXPR);
			return;
		}
		if (c == '*' && p == '(')
			n++;
		else if (c == ')' && p == '*')
			n--;
		p = c;
		c = read_c();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movslq 0x14c6e(%rip), %rax     # 0x1e698
leaq 0x1474f(%rip), %r14     # 0x1e180
movq (%r14,%rax,8), %rdi
callq 0x3220
movl %eax, %ebx
movl $0x1, %r15d
xorl %ecx, %ecx
cmpl $0x0, 0x14b69(%rip)     # 0x1e5b4
jne 0x9aa0
cmpl $0xa, %ebx
je 0x9a6d
cmpl $-0x1, %ebx
je 0x9aa9
movl %ebx, %eax
xorl $0x2a, %eax
movl %ecx, %edx
xorl $0x28, %edx
movl $0x1, %r12d
orl %eax, %edx
jne 0x9a73
jmp 0x9a87
incl 0x14b5d(%rip)           # 0x1e5d0
movl %ebx, %eax
xorl $0x29, %eax
xorl $0x2a, %ecx
xorl %r12d, %r12d
orl %eax, %ecx
sete %r12b
negl %r12d
movslq 0x14c0a(%rip), %rax     # 0x1e698
movq (%r14,%rax,8), %rdi
callq 0x3220
movl %ebx, %ecx
movl %eax, %ebx
addl %r12d, %r15d
jne 0x9a44
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xcc4b(%rip), %rdi      # 0x166fb
movq $-0x8, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x33eb
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: x_pattern
cell x_pattern(int k) {
	cell	n, m;

	if (Token == TOK_ID && consname_p(Attr)) {
		save(Attr);
		Token = scan();
		if (Token != TOK_ID || Attr != S_equal) {
			Tmp = n = pat_primary(k);
			if (!tuple_p(pat(n))) { 
				m = node(pat(n), NIL);
				Tmp = n = node(m, opr(n));
			}
			n = node(unsave(1), pat(n));
			n = node(n, opr(Tmp));
			Tmp = NIL;
		}
		else {
			n = node(unsave(1), NIL);
		}
	}
	else {
		n = pat_logop(TOK_OR, k);
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %esi
cmpl $0xfffffed1, 0x14452(%rip) # imm = 0xFFFFFED1
jne 0xa2f7
movq 0x14361(%rip), %rax     # 0x1e5e8
movq 0x14332(%rip), %rcx     # 0x1e5c0
movq 0x13ec3(%rip), %rdi     # 0x1e158
movq (%rcx,%rdi,8), %rcx
cmpb $0x3a, (%rax,%rcx,8)
jne 0xa2f7
movq 0x13e82(%rip), %rsi     # 0x1e128
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x13e74(%rip)     # 0x1e128
callq 0x9ac4
movl %eax, 0x14411(%rip)     # 0x1e6d0
cmpl $0xfffffed1, %eax       # imm = 0xFFFFFED1
jne 0xa307
movq 0x13e8b(%rip), %rax     # 0x1e158
cmpq 0x14424(%rip), %rax     # 0x1e6f8
jne 0xa307
movl $0x1, %edi
callq 0x384f
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x36e8
movl $0xffffff23, %edi       # imm = 0xFFFFFF23
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xb0e8
callq 0xa528
movq %rax, %rbx
movq %rax, 0x13dfa(%rip)     # 0x1e110
movq 0x13e53(%rip), %rax     # 0x1e170
movq (%rax,%rbx,8), %rdi
testq %rdi, %rdi
js 0xa333
movq 0x142b3(%rip), %rax     # 0x1e5e0
testb $0x19, (%rax,%rdi)
je 0xa360
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x14278(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rbx,8), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
movq %rax, 0x13db0(%rip)     # 0x1e110
movl $0x1, %edi
callq 0x384f
movq 0x13dff(%rip), %rcx     # 0x1e170
movq (%rcx,%rbx,8), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq 0x1423a(%rip), %rcx     # 0x1e5c0
movq 0x13d83(%rip), %rdx     # 0x1e110
movq (%rcx,%rdx,8), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq $-0x1, 0x13d6a(%rip) # 0x1e110
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: expr
cell expr(void) {
	cell	n, m;
	int	t;

	n = case_expr();
	if (Token == TOK_FROM || Token == TOK_TO) {
		save(n);
		t = Token;
		Token = scan();
		m = expr();
		n = node(m, NIL);
		n = node(unsave(1), n);
		return node(t == TOK_FROM? S_from: S_to, n);
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
callq 0xc392
movl 0x14311(%rip), %ecx     # 0x1e6d0
addl $0x6d, %ecx
cmpl $0x2, %ecx
jae 0xa44c
movq 0x13d56(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x13d45(%rip)     # 0x1e128
movl 0x142e6(%rip), %r14d    # 0x1e6d0
callq 0x9ac4
movl %eax, 0x142db(%rip)     # 0x1e6d0
callq 0xa3ad
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
movl $0x1, %edi
callq 0x384f
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x36e8
cmpl $-0x6c, %r14d
leaq 0x14318(%rip), %rcx     # 0x1e748
leaq 0x14319(%rip), %rdx     # 0x1e750
cmoveq %rcx, %rdx
movq (%rdx), %rdi
movq %rax, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x36e8
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: sequence
cell sequence(void) {
	cell	s, n, new;

	s = node(NIL, NIL);
	save(s);
	for (;;) {
		set(car(s), expr());
		if (Token != TOK_SEMI)
			break;
		Token = scan();
		set(cdr(s), node(NIL, NIL));
		s = cdr(s);
	}
	n = unsave(1);
	return cdr(n) == NIL? car(n): node(S_begin, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq $-0x1, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
movq 0x13cb1(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x13ca0(%rip)     # 0x1e128
callq 0xa3ad
movq 0x13cdc(%rip), %rcx     # 0x1e170
movq %rax, (%rcx,%rbx,8)
cmpl $-0x65, 0x14231(%rip)   # 0x1e6d0
jne 0xa4eb
callq 0x9ac4
movl %eax, 0x14224(%rip)     # 0x1e6d0
movq $-0x1, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %r14
movq 0x140f5(%rip), %rax     # 0x1e5c0
movq %r14, (%rax,%rbx,8)
callq 0xa3ad
movq 0x13c95(%rip), %rcx     # 0x1e170
movq %rax, (%rcx,%r14,8)
cmpl $-0x65, 0x141ea(%rip)   # 0x1e6d0
movq %r14, %rbx
je 0xa4a1
movl $0x1, %edi
callq 0x384f
movq 0x140c4(%rip), %rcx     # 0x1e5c0
cmpq $-0x1, (%rcx,%rax,8)
je 0xa518
movq 0x1424e(%rip), %rdi     # 0x1e758
movq %rax, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x36e8
movq 0x13c51(%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: pat_primary
cell pat_primary(int k) {
	int	t;
	cell	n;
	char	msg[] = "grouping not allowed in patterns; this is a bug!";

	switch(Token) {
	case TOK_ID:
	case TOK_STR:
	case TOK_NUM:
	case TOK_CHR:
	case TOK_BOOL:
		save(Attr);
		Token = scan();
		return node(unsave(1), NIL);
	case TOK_CONS:
		Token = scan();
		return node(S_cons, NIL);
	case TOK_LPAREN:
	case TOK_LBRACK:
		t = Token;
		Token = scan();
		n = pat_list(t == TOK_LBRACK);
		if (pat(n) == NIL || pat(n) == UNIT)
			return n;
		if (t == TOK_LPAREN && cdr(pat(n)) == NIL) {
			if (Guard_lev > 0)
				return error(msg, NOEXPR);
			return node(car(pat(n)), opr(n));
		}
		return n;
	default:
		if (!Error_flag)
			Token = scan();
		return error("syntax error at", Attr);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x38, %rsp
movaps 0xd408(%rip), %xmm0     # 0x17940
movaps %xmm0, -0x20(%rbp)
movaps 0xd3ed(%rip), %xmm0     # 0x17930
movaps %xmm0, -0x30(%rbp)
movaps 0xd3d2(%rip), %xmm0     # 0x17920
movaps %xmm0, -0x40(%rbp)
movb $0x0, -0x10(%rbp)
movl 0x14174(%rip), %ebx     # 0x1e6d0
cmpl $-0x6b, %ebx
jg 0xa5b8
addl $0x130, %ebx            # imm = 0x130
cmpl $0x5, %ebx
jae 0xa634
movq 0x13be1(%rip), %rdi     # 0x1e158
movq 0x13baa(%rip), %rsi     # 0x1e128
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x13b9c(%rip)     # 0x1e128
callq 0x9ac4
movl %eax, 0x14139(%rip)     # 0x1e6d0
movl $0x1, %edi
callq 0x384f
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
addq $0x38, %rsp
popq %rbx
popq %rbp
jmp 0x36e8
cmpl $-0x6a, %ebx
je 0xa5db
cmpl $-0x68, %ebx
je 0xa5db
cmpl $-0x67, %ebx
jne 0xa634
callq 0x9ac4
movl %eax, 0x140fe(%rip)     # 0x1e6d0
movq 0x140b7(%rip), %rdi     # 0x1e690
jmp 0xa5a4
callq 0x9ac4
movl %eax, 0x140ea(%rip)     # 0x1e6d0
xorl %edi, %edi
cmpl $-0x6a, %ebx
sete %dil
callq 0xa8b2
movq 0x13b75(%rip), %rcx     # 0x1e170
movq (%rcx,%rax,8), %rdx
cmpq $-0x6, %rdx
je 0xa662
cmpq $-0x1, %rdx
je 0xa662
cmpl $-0x68, %ebx
jne 0xa662
movq 0x13fa9(%rip), %rsi     # 0x1e5c0
cmpq $-0x1, (%rsi,%rdx,8)
jne 0xa662
cmpl $0x0, 0x140bb(%rip)     # 0x1e6e0
jle 0xa669
leaq -0x40(%rbp), %rdi
movq $-0x8, %rsi
jmp 0xa656
cmpl $0x0, 0x13f79(%rip)     # 0x1e5b4
jne 0xa648
callq 0x9ac4
movl %eax, 0x14088(%rip)     # 0x1e6d0
movq 0x13b09(%rip), %rsi     # 0x1e158
leaq 0xc13c(%rip), %rdi      # 0x16792
callq 0x33eb
movq $-0x5, %rax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
movq (%rcx,%rdx,8), %rdi
movq (%rsi,%rax,8), %rsi
jmp 0xa5ab
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: pat_list
cell pat_list(int lst) {
	cell	n;

	if (Guard_lev == 0) {
		Guard_ops = node(NIL, NIL);
		save(Guard_ops);
	}
	Guard_lev++;
	n = list(1, lst);
	if (lst && n != NIL && n != UNIT)
		pp_list(n);
	Guard_lev--;
	if (Guard_lev == 0) {
		Guard_ops = unsave(1);
		save(n);
		if (cdr(Guard_ops) == NIL)
			Guard_ops = NIL;
		else if (cddr(Guard_ops) == NIL)
			Guard_ops = cadr(Guard_ops);
		else
			Guard_ops = node(S_also, cdr(Guard_ops));
		return node(unsave(1), Guard_ops);
	}
	return node(n, NIL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %r14d
movl 0x13e1e(%rip), %eax     # 0x1e6e0
testl %eax, %eax
jne 0xa900
movq $-0x1, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x13df6(%rip)     # 0x1e6d8
movq 0x1383f(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x1382e(%rip)     # 0x1e128
movl 0x13de0(%rip), %eax     # 0x1e6e0
incl %eax
movl %eax, 0x13dd8(%rip)     # 0x1e6e0
movl $0x1, %edi
movl %r14d, %esi
callq 0x9efa
movq %rax, %rbx
testl %r14d, %r14d
je 0xa948
cmpq $-0x1, %rbx
je 0xa948
cmpq $-0x6, %rbx
je 0xa948
movq %rbx, %rax
movq 0x13cad(%rip), %rcx     # 0x1e5e0
orb $0x8, (%rcx,%rax)
movq 0x13c82(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rax,8), %rax
cmpq $-0x1, %rax
jne 0xa92c
decl 0x13d92(%rip)           # 0x1e6e0
je 0xa95f
movq %rbx, %rdi
movq $-0x1, %rsi
jmp 0xa9e6
movl $0x1, %edi
callq 0x384f
movq %rax, 0x13d68(%rip)     # 0x1e6d8
movq 0x137b1(%rip), %rsi     # 0x1e128
movq %rbx, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x137a0(%rip)     # 0x1e128
movq 0x13c31(%rip), %rax     # 0x1e5c0
movq 0x13d42(%rip), %rcx     # 0x1e6d8
movq (%rax,%rcx,8), %rsi
cmpq $-0x1, %rsi
je 0xa9b7
cmpq $-0x1, (%rax,%rsi,8)
je 0xa9c0
movq 0x13d3a(%rip), %rdi     # 0x1e6e8
xorl %edx, %edx
callq 0x36e8
jmp 0xa9cb
movq $-0x1, %rax
jmp 0xa9cb
movq 0x137a9(%rip), %rax     # 0x1e170
movq (%rax,%rsi,8), %rax
movq %rax, 0x13d06(%rip)     # 0x1e6d8
movl $0x1, %edi
callq 0x384f
movq 0x13cf5(%rip), %rsi     # 0x1e6d8
movq %rax, %rdi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x36e8
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: pp_list
cell pp_list(cell x) {
	cell	p;

	for (p = x; p != NIL; p = cdr(p)) {
		Tag[p] |= LIST_TAG;
	}
	return x;
}

// Assembly:
movq %rdi, %rax
cmpq $-0x1, %rdi
je 0xaa1e
pushq %rbp
movq %rsp, %rbp
movq %rax, %rcx
movq 0x13bd8(%rip), %rdx     # 0x1e5e0
orb $0x8, (%rdx,%rcx)
movq 0x13bad(%rip), %rdx     # 0x1e5c0
movq (%rdx,%rcx,8), %rcx
cmpq $-0x1, %rcx
jne 0xaa01
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: pat_funapp
cell pat_funapp(int k) {
	cell	n, m, p, f, x;

	n = pat_primary(k);
	if (!k)
		return n;
	while (	(Token == TOK_ID || Token == TOK_STR || Token == TOK_NUM ||
		 Token == TOK_CHR || Token == TOK_BOOL ||
		 Token == TOK_LPAREN || Token == TOK_LBRACK ||
		 Token == TOK_OP)
		&&
		!is_binop(Attr) && Token != TOK_CONS
		&&
		is_fun(n)
	) {
		save(n);
		m = pat_primary(k);
		p = pat(m);
		save(p);
		f = opr(n) == NIL? pat(n): opr(n);
		x = opr(m) == NIL? pat(m): opr(m);
		n = node(x, NIL);
		n = node(f, n);
		n = node(p, n);
		unsave(2);
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %r14d
callq 0xa528
movq %rax, %rbx
testl %r14d, %r14d
je 0xab87
movl $0x281, %r13d           # imm = 0x281
movl 0x13c83(%rip), %eax     # 0x1e6d0
cmpl $0xffffff23, %eax       # imm = 0xFFFFFF23
jg 0xaab5
addl $0x130, %eax            # imm = 0x130
cmpl $0x5, %eax
jae 0xab87
movq 0x136ef(%rip), %rdi     # 0x1e158
callq 0x96a9
testl %eax, %eax
jne 0xab87
cmpl $-0x67, 0x13c53(%rip)   # 0x1e6d0
je 0xab87
testq %rbx, %rbx
js 0xaacb
movq 0x13b51(%rip), %rax     # 0x1e5e0
testb $0x1, (%rax,%rbx)
je 0xaad9
movq 0x136d4(%rip), %rax     # 0x1e170
movq (%rax,%rbx,8), %rax
addq $0x1f, %rax
cmpq $0x9, %rax
ja 0xaad9
btq %rax, %r13
jae 0xaad9
jmp 0xab87
cmpl $0xffffff24, %eax       # imm = 0xFFFFFF24
je 0xaa62
cmpl $-0x68, %eax
je 0xaa62
cmpl $-0x6a, %eax
je 0xaa62
jmp 0xab87
leaq 0x1(%rbx), %rax
cmpq $-0x3, %rax
ja 0xab87
movq 0x13648(%rip), %rsi     # 0x1e128
movq %rbx, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x13637(%rip)     # 0x1e128
callq 0xa528
movq %rax, %r15
movq 0x13670(%rip), %rax     # 0x1e170
movq (%rax,%r15,8), %r14
movq 0x1361d(%rip), %rsi     # 0x1e128
movq %r14, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x1360c(%rip)     # 0x1e128
movq 0x13a9d(%rip), %rax     # 0x1e5c0
movq (%rax,%rbx,8), %r12
cmpq $-0x1, %r12
jne 0xab38
movq 0x1363c(%rip), %rcx     # 0x1e170
movq (%rcx,%rbx,8), %r12
movq (%rax,%r15,8), %rdi
cmpq $-0x1, %rdi
jne 0xab4d
movq 0x13627(%rip), %rax     # 0x1e170
movq (%rax,%r15,8), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %r12, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
movl $0x2, %edi
callq 0x384f
jmp 0xaa47
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: pattern
cell pattern(void) {
	cell	n;

	n = x_pattern(0);
	if (cons_p(n) && cdr(n) == NIL)
		return car(n);
	return node(GUARD, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %edi, %edi
callq 0xa26c
testq %rax, %rax
js 0xb2f8
movq 0x132fc(%rip), %rcx     # 0x1e5e0
testb $0x11, (%rcx,%rax)
jne 0xb2f8
movq 0x132cf(%rip), %rcx     # 0x1e5c0
cmpq $-0x1, (%rcx,%rax,8)
je 0xb30a
movq $-0x9, %rdi
movq %rax, %rsi
xorl %edx, %edx
popq %rbp
jmp 0x36e8
movq 0x12e5f(%rip), %rcx     # 0x1e170
movq (%rcx,%rax,8), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: logop
cell logop(int op, int k) {
	cell	n, a, new;

	n = op == TOK_ALSO? apply_op(k): logop(TOK_ALSO, k);
	a = node(n, NIL);
	save(a);
	while (Token == op) {
		Token = scan();
		set(cdr(a), node(NIL, NIL));
		a = cdr(a);
		set(car(a), op == TOK_ALSO? apply_op(k): logop(TOK_ALSO, k));
	}
	n = unsave(1);
	if (cdr(n) == NIL)
		return car(n);
	return node(op==TOK_OR? S_or: S_also, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r14d
movl %edi, %ebx
cmpl $0xffffff38, %edi       # imm = 0xFFFFFF38
jne 0xb68a
movl %r14d, %edi
callq 0xbf3f
jmp 0xb697
movl $0xffffff38, %edi       # imm = 0xFFFFFF38
movl %r14d, %esi
callq 0xb668
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %r15
movq 0x12a76(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x12a65(%rip)     # 0x1e128
cmpl %ebx, 0x13007(%rip)     # 0x1e6d0
jne 0xb728
callq 0x9ac4
movl %eax, 0x12ffa(%rip)     # 0x1e6d0
movq $-0x1, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %r12
movq 0x12ecb(%rip), %rax     # 0x1e5c0
movq %r12, (%rax,%r15,8)
cmpl $0xffffff38, %ebx       # imm = 0xFFFFFF38
jne 0xb70b
movl %r14d, %edi
callq 0xbf3f
jmp 0xb718
movl $0xffffff38, %edi       # imm = 0xFFFFFF38
movl %r14d, %esi
callq 0xb668
movq 0x12a51(%rip), %rcx     # 0x1e170
movq %rax, (%rcx,%r12,8)
movq %r12, %r15
jmp 0xb6c3
movl $0x1, %edi
callq 0x384f
movq 0x12e87(%rip), %rcx     # 0x1e5c0
cmpq $-0x1, (%rcx,%rax,8)
je 0xb76d
cmpl $0xffffff23, %ebx       # imm = 0xFFFFFF23
leaq 0x12fb3(%rip), %rcx     # 0x1e700
leaq 0x12f94(%rip), %rdx     # 0x1e6e8
cmoveq %rcx, %rdx
movq (%rdx), %rdi
movq %rax, %rsi
xorl %edx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x36e8
movq 0x129fc(%rip), %rcx     # 0x1e170
movq (%rcx,%rax,8), %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: tuple_ref
cell tuple_ref(void) {
	cell	n;

	save(Attr);
	Token = scan();
	n = primary();
	if (!symbol_p(n) && !tuple_p(n)) {
		unsave(1);
		return error("bad object after '#n'", Attr);
	}
	Tmp = n;
	n = node(unsave(1), NIL);
	n = node(Tmp, n);
	Tmp = NIL;
	n = node(S_tuple, n);
	n = node(n, NIL);
	n = node(S_ref, n);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x129cc(%rip), %rdi     # 0x1e158
movq 0x12995(%rip), %rsi     # 0x1e128
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x12987(%rip)     # 0x1e128
callq 0x9ac4
movl %eax, 0x12f24(%rip)     # 0x1e6d0
callq 0xa676
testq %rax, %rax
js 0xb7ca
movq 0x12e23(%rip), %rcx     # 0x1e5e0
movb (%rcx,%rax), %cl
testb $0x10, %cl
jne 0xb7f0
testb $0x9, %cl
je 0xb7fe
movl $0x1, %edi
callq 0x384f
movq 0x1297d(%rip), %rsi     # 0x1e158
leaq 0xb020(%rip), %rdi      # 0x16802
callq 0x33eb
movq $-0x5, %rax
popq %rbp
retq
movq 0x12979(%rip), %rcx     # 0x1e170
cmpq $-0x22, (%rcx,%rax,8)
jne 0xb7ca
movq %rax, 0x1290b(%rip)     # 0x1e110
movl $0x1, %edi
callq 0x384f
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x128e9(%rip), %rdi     # 0x1e110
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq $-0x1, 0x128d4(%rip) # 0x1e110
movq 0x12ead(%rip), %rdi     # 0x1e6f0
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x12eab(%rip), %rdi     # 0x1e710
movq %rax, %rsi
xorl %edx, %edx
popq %rbp
jmp 0x36e8
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: prog
cell prog(void) {
	switch (Token) {
	case TOK_VAL:		return val_decl(0);
	case TOK_FUN:		return fun_decl(0);
	case TOK_TYPE:		return type_decl();
	case TOK_LOCAL:		return local_decl();
	case TOK_INFIX:		return infix_decl(LEFT);
	case TOK_INFIXR:	return infix_decl(RIGHT);
	case TOK_NONFIX:	return infix_decl(NONE);
	case TOK_EXCEPTION:	return except_decl();
	case END_OF_FILE:	return END_OF_FILE;
	default:		return expr();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x12e15(%rip), %ecx     # 0x1e6d0
leal 0xe2(%rcx), %eax
cmpl $0x12, %eax
ja 0xb8de
leaq 0xa7e3(%rip), %rcx      # 0x160b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl %edi, %edi
popq %rbp
jmp 0xc5dd
cmpl $-0x4, %ecx
jne 0xb8ec
movq $-0x4, %rax
popq %rbp
retq
popq %rbp
jmp 0xa3ad
popq %rbp
jmp 0xd5ff
xorl %edi, %edi
popq %rbp
jmp 0xc911
xorl %edi, %edi
jmp 0xb91c
popq %rbp
jmp 0xcb79
movl $0x2, %edi
jmp 0xb91c
popq %rbp
jmp 0xcff7
movl $0x1, %edi
popq %rbp
jmp 0xd3c8
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: let_expr
cell let_expr(void) {
	cell	d, x;

	Token = scan();
	d = decls(1);
	save(d);
	if (Token != TOK_IN) {
		unsave(1);
		return error("missing 'in' in 'let'", NOEXPR);
	}
	Token = scan();
	x = sequence();
	save(x);
	if (Token != TOK_END) {
		unsave(2);
		return error("missing 'end' in 'let'", NOEXPR);
	}
	Token = scan();
	x = unsave(1);
	x = node(x, NIL);
	d = unsave(1);
	if (caar(d) == S_letrec)
		cddar(d) = x;
	else
		cdadar(car(d)) = x;
	return cdr(d);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x9ac4
movl %eax, 0x12d9d(%rip)     # 0x1e6d0
movl $0x1, %edi
callq 0xce69
movq 0x127e4(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x127d3(%rip)     # 0x1e128
cmpl $0xffffff2b, 0x12d71(%rip) # imm = 0xFFFFFF2B
jne 0xb9f1
callq 0x9ac4
movl %eax, 0x12d60(%rip)     # 0x1e6d0
callq 0xa451
movq 0x127ac(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x1279b(%rip)     # 0x1e128
cmpl $0xffffff32, 0x12d39(%rip) # imm = 0xFFFFFF32
jne 0xba04
callq 0x9ac4
movl %eax, 0x12d2c(%rip)     # 0x1e6d0
movl $0x1, %edi
callq 0x384f
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
movl $0x1, %edi
callq 0x384f
movq 0x1279d(%rip), %rdx     # 0x1e170
movq (%rdx,%rax,8), %rsi
movq (%rdx,%rsi,8), %rdi
movq 0x12bde(%rip), %rcx     # 0x1e5c0
cmpq 0x12d7f(%rip), %rdi     # 0x1e768
jne 0xba2a
leaq (%rcx,%rsi,8), %rdx
jmp 0xba32
movl $0x1, %edi
callq 0x384f
leaq 0xaf57(%rip), %rdi      # 0x16959
jmp 0xba15
movl $0x2, %edi
callq 0x384f
leaq 0xaf5a(%rip), %rdi      # 0x1696f
movq $-0x8, %rsi
callq 0x33eb
movq $-0x5, %rax
jmp 0xba3d
movq (%rcx,%rdi,8), %rsi
leaq (%rdx,%rsi,8), %rdx
movq (%rdx), %rdx
movq %rbx, (%rcx,%rdx,8)
movq (%rcx,%rax,8), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: funapp
cell funapp(void) {
	cell	n, m;

	n = primary();
	while (	(Token == TOK_ID || Token == TOK_STR || Token == TOK_NUM ||
		 Token == TOK_CHR || Token == TOK_BOOL ||
		 Token == TOK_LPAREN || Token == TOK_LBRACK ||
		 Token == TOK_OP || Token == TOK_REF)
		&&
		!is_binop(Attr) && Token != TOK_CONS
		&&
		is_fun(n)
	) {
		save(n);
		m = primary();
		m = node(m, NIL);
		n = node(unsave(1), m);
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
callq 0xa676
movq %rax, %rbx
movl $0x281, %r14d           # imm = 0x281
movl 0x12c71(%rip), %eax     # 0x1e6d0
cmpl $0xffffff20, %eax       # imm = 0xFFFFFF20
jg 0xbac7
addl $0x130, %eax            # imm = 0x130
cmpl $0x5, %eax
jae 0xbb48
movq 0x126dd(%rip), %rdi     # 0x1e158
callq 0x96a9
testl %eax, %eax
jne 0xbb48
cmpl $-0x67, 0x12c41(%rip)   # 0x1e6d0
je 0xbb48
testq %rbx, %rbx
js 0xbadc
movq 0x12b3f(%rip), %rax     # 0x1e5e0
testb $0x1, (%rax,%rbx)
je 0xbae6
movq 0x126c2(%rip), %rax     # 0x1e170
movq (%rax,%rbx,8), %rax
addq $0x1f, %rax
cmpq $0x9, %rax
ja 0xbae6
btq %rax, %r14
jae 0xbae6
jmp 0xbb48
cmpl $-0x6b, %eax
jg 0xbb36
cmpl $0xffffff21, %eax       # imm = 0xFFFFFF21
je 0xba74
cmpl $0xffffff24, %eax       # imm = 0xFFFFFF24
je 0xba74
jmp 0xbb48
leaq 0x1(%rbx), %rax
cmpq $-0x3, %rax
ja 0xbb48
movq 0x1263b(%rip), %rsi     # 0x1e128
movq %rbx, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x1262a(%rip)     # 0x1e128
callq 0xa676
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
movl $0x1, %edi
callq 0x384f
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
jmp 0xba59
cmpl $-0x68, %eax
je 0xba74
cmpl $-0x6a, %eax
je 0xba74
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: commit
void commit(char *s, int all) {
	int	tp = 0, ta = LEFT, sp = 0, sa;
	cell	n;

	find_binop(s, &tp, &ta);
	while (inf_ops() != NIL) {
		find_binop(symbol_name(inf_first_op()), &sp, &sa);
		if (!all && (tp > sp || (tp == sp && ta == RIGHT)))
			break;
		n = node(inf_first_arg(), NIL);	/* (op (tuple arg1 arg2)) */
		inf_args() = inf_other_args();	/* also remove arg2 */
		n = node(inf_first_arg(), n);	/* now other arg */
		n = node(S_tuple, n);
		n = node(n, NIL);
		n = node(inf_first_op(), n);
		inf_ops() = inf_other_ops();	/* remove op */
		inf_first_arg() = n;		/* replace arg1 */
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
xorl %eax, %eax
leaq -0x34(%rbp), %rsi
movl %eax, (%rsi)
leaq -0x30(%rbp), %rdx
movl $0x1, (%rdx)
movl %eax, -0x2c(%rbp)
callq 0x95dd
movq 0x125ec(%rip), %rcx     # 0x1e170
movq 0x1259d(%rip), %rax     # 0x1e128
movq (%rcx,%rax,8), %rax
cmpq $-0x1, %rax
je 0xbcf1
movl -0x34(%rbp), %r12d
movl -0x30(%rbp), %r13d
movq 0x12a18(%rip), %rdx     # 0x1e5c0
leaq -0x2c(%rbp), %r14
leaq -0x38(%rbp), %r15
xorl $0x2, %r13d
movq (%rcx,%rax,8), %rax
movq (%rdx,%rax,8), %rdi
shlq $0x3, %rdi
addq 0x12a21(%rip), %rdi     # 0x1e5e8
movq %r14, %rsi
movq %r15, %rdx
callq 0x95dd
testl %ebx, %ebx
jne 0xbbf5
movl -0x2c(%rbp), %ecx
movl %r12d, %eax
xorl %ecx, %eax
orl %r13d, %eax
sete %al
cmpl %ecx, %r12d
jg 0xbcf1
testb %al, %al
jne 0xbcf1
movq 0x12574(%rip), %rax     # 0x1e170
movq 0x129bd(%rip), %rcx     # 0x1e5c0
movq 0x1251e(%rip), %rdx     # 0x1e128
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rcx
movq (%rax,%rcx,8), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x12995(%rip), %rcx     # 0x1e5c0
movq 0x1253e(%rip), %rdx     # 0x1e170
movq 0x124ef(%rip), %rsi     # 0x1e128
movq (%rcx,%rsi,8), %rsi
movq (%rdx,%rsi,8), %rdi
movq (%rcx,%rdi,8), %rdi
movq %rdi, (%rdx,%rsi,8)
movq 0x124d8(%rip), %rsi     # 0x1e128
movq (%rcx,%rsi,8), %rcx
movq (%rdx,%rcx,8), %rcx
movq (%rdx,%rcx,8), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x12a83(%rip), %rdi     # 0x1e6f0
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x124e1(%rip), %rcx     # 0x1e170
movq 0x12492(%rip), %rdx     # 0x1e128
movq (%rcx,%rdx,8), %rdx
movq (%rcx,%rdx,8), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x12911(%rip), %rdx     # 0x1e5c0
movq 0x124ba(%rip), %rcx     # 0x1e170
movq 0x1246b(%rip), %rsi     # 0x1e128
movq (%rcx,%rsi,8), %rdi
movq (%rdx,%rdi,8), %rdi
movq %rdi, (%rcx,%rsi,8)
movq 0x12458(%rip), %rsi     # 0x1e128
movq (%rdx,%rsi,8), %rsi
movq (%rcx,%rsi,8), %rsi
movq %rax, (%rcx,%rsi,8)
movq 0x12445(%rip), %rax     # 0x1e128
movq (%rcx,%rax,8), %rax
cmpq $-0x1, %rax
jne 0xbbb4
addq $0x18, %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: apply_op
cell apply_op(int k) {
	cell	n;

	n = infix(k);
	while (Token == TOK_APPLY) {
		save(n);
		Token = scan();
		n = apply_op(k);
		n = node(n, NIL);
		n = node(unsave(1), n);
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
callq 0xbd00
cmpl $0xffffff36, 0x12779(%rip) # imm = 0xFFFFFF36
jne 0xbfb0
movq 0x121c8(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x121b7(%rip)     # 0x1e128
callq 0x9ac4
movl %eax, 0x12754(%rip)     # 0x1e6d0
movl %ebx, %edi
callq 0xbf3f
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %r14
movl $0x1, %edi
callq 0x384f
movq %rax, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x36e8
jmp 0xbf4d
popq %rbx
popq %r14
popq %rbp
retq