LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x816e
leaq 0xe3d9(%rip), %rsi      # 0x16506
leaq -0xa0(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x31f0
movq %r14, %rdi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x18, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x36e8
movq %r15, %rdi
jmp 0x819a
movzbl %r15b, %edi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x16, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rbx, %rdi
movq %rax, %rsi
callq 0x33eb
movq $-0x5, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x15fa3(%rip), %r12     # 0x1e180
movq (%r14), %rax
movslq %ebx, %rcx
movzwl (%rax,%rcx,2), %eax
btl $0xb, %eax
jb 0x81fc
cmpl $0x2e, %ebx
je 0x81fc
cmpl $0x7e, %ebx
je 0x81fc
cmpl $0x65, %ebx
jne 0x824e
cmpq $0x3fe, %r15            # imm = 0x3FE
je 0x8224
movb %bl, -0x420(%rbp,%r15)
incq %r15
movslq 0x16481(%rip), %rax     # 0x1e698
movq (%r12,%rax,8), %rdi
callq 0x3220
movl %eax, %ebx
jmp 0x81dd
leaq 0xe2e4(%rip), %rdi      # 0x1650f
movq $-0x8, %rsi
callq 0x33eb
movq $-0x5, %rax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb $0x0, -0x420(%rbp,%r15)
movslq 0x1643a(%rip), %rax     # 0x1e698
movq (%r12,%rax,8), %rsi
movl %ebx, %edi
callq 0x3170
leaq -0x420(%rbp), %rdi
callq 0x7d62
jmp 0x823e
// File: /workspace/github_c_makefile_star2_O1/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 0x15ed3(%rip), %r13     # 0x1e180
movq (%r15), %rax
movslq %r14d, %rcx
movzwl (%rax,%rcx,2), %eax
btl $0xa, %eax
jb 0x82cc
leal -0x27(%r14), %ecx
cmpl $0x38, %ecx
ja 0x82fa
btq %rcx, %rbx
jae 0x82fa
cmpq $0x3fe, %r12            # imm = 0x3FE
je 0x836c
movb %r14b, -0x430(%rbp,%r12)
incq %r12
movslq 0x163ad(%rip), %rax     # 0x1e698
movq (%r13,%rax,8), %rdi
callq 0x3220
movl %eax, %r14d
jmp 0x82ad
cmpl $0x0, -0x2c(%rbp)
setne %cl
cmpl $0x21, %r14d
sete %dl
btl $0xb, %eax
jb 0x82cc
andb %dl, %cl
jne 0x82cc
movb $0x0, -0x430(%rbp,%r12)
movslq 0x16376(%rip), %rax     # 0x1e698
movq (%r13,%rax,8), %rsi
movl %r14d, %edi
callq 0x3170
movl $0x65757274, %eax       # imm = 0x65757274
xorl -0x430(%rbp), %eax
movzbl -0x42c(%rbp), %ecx
orl %eax, %ecx
je 0x8398
movl $0x736c6166, %eax       # imm = 0x736C6166
xorl -0x430(%rbp), %eax
movzwl -0x42c(%rbp), %ecx
xorl $0x65, %ecx
orl %eax, %ecx
je 0x83a1
leaq -0x430(%rbp), %rdi
callq 0x729e
jmp 0x8386
leaq 0xe1b5(%rip), %rdi      # 0x16528
movq $-0x8, %rsi
callq 0x33eb
movq $-0x5, %rax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq $-0x2, %rax
jmp 0x8386
movq $-0x3, %rax
jmp 0x8386
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: read_opsym
cell read_opsym(int c) {
	char	s[TOKEN_LENGTH];
	int	i;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movl %edi, %ebx
leaq 0xe182(%rip), %rdi      # 0x16547
movl $0x10, %edx
movl %ebx, %esi
callq 0x30f0
xorl %r15d, %r15d
testq %rax, %rax
je 0x8421
leaq 0x15da0(%rip), %r12     # 0x1e180
leaq 0xe160(%rip), %r14      # 0x16547
cmpq $0x3fe, %r15            # imm = 0x3FE
je 0x8451
movb %bl, -0x420(%rbp,%r15)
incq %r15
movslq 0x16296(%rip), %rax     # 0x1e698
movq (%r12,%rax,8), %rdi
callq 0x3220
movl %eax, %ebx
movl $0x10, %edx
movq %r14, %rdi
movl %eax, %esi
callq 0x30f0
testq %rax, %rax
jne 0x83e7
movb $0x0, -0x420(%rbp,%r15)
movslq 0x16267(%rip), %rax     # 0x1e698
leaq 0x15d48(%rip), %rcx     # 0x1e180
movq (%rcx,%rax,8), %rsi
movl %ebx, %edi
callq 0x3170
leaq -0x420(%rbp), %rdi
callq 0x729e
jmp 0x846b
leaq 0xe0ff(%rip), %rdi      # 0x16557
movq $-0x8, %rsi
callq 0x33eb
movq $-0x5, %rax
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x161d7(%rip), %rax     # 0x1e698
leaq 0x15cb8(%rip), %rcx     # 0x1e180
cmpq $0x0, (%rcx,%rax,8)
je 0x84de
movl $0x0, 0x161a7(%rip)     # 0x1e680
jmp 0x75e0
pushq %rbp
movq %rsp, %rbp
leaq 0xe0f0(%rip), %rdi      # 0x165d9
movq $-0x8, %rsi
callq 0x33eb
movq $-0x5, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: ntoa
char *ntoa(char *b, cell x, int w) {
	char	buf[40];
	int	i = 0, neg = 0;
	char	*p = &buf[sizeof(buf)-1];

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ecx
movq %rsi, %r14
movq %rdi, %rbx
negq %rsi
cmovsq %r14, %rsi
movq %r14, %r9
sarq $0x3f, %r9
movb $0x0, -0x49(%rbp)
leal (%rcx,%r9), %r8d
decl %r8d
movl $0x1, %r12d
movl $0x26, %r15d
xorl %edi, %edi
movabsq $-0x3333333333333333, %r10 # imm = 0xCCCCCCCCCCCCCCCD
movl %r8d, %r13d
cmpl $0x26, %edi
je 0x8631
movq %rsi, %rax
mulq %r10
shrq $0x3, %rdx
leal (%rdx,%rdx), %eax
leal (%rax,%rax,4), %eax
movl %esi, %r11d
subl %eax, %r11d
orb $0x30, %r11b
movb %r11b, -0x70(%rbp,%r15)
incq %rdi
decl %r13d
decq %r15
incl %r12d
cmpq $0x9, %rsi
movq %rdx, %rsi
ja 0x854b
addl %ecx, %r9d
leaq -0x70(%rbp), %rsi
subq %rdi, %rsi
cmpl %r9d, %edi
jge 0x8602
movq %rbx, -0x40(%rbp)
movl $0x26, %ebx
subq %rdi, %rbx
movq %r14, -0x38(%rbp)
movl %r8d, %r14d
subq %rdi, %r14
movl $0x26, %edx
subl %edi, %edx
subl %edi, %r8d
cmpq %rdx, %r8
cmovbq %r8, %rdx
leaq 0x26(%rsi), %rax
movq %rax, -0x30(%rbp)
subq %rdx, %rsi
addq $0x26, %rsi
incq %rdx
movq %rsi, %rdi
movl $0x30, %esi
callq 0x30d0
cmpl %ebx, %r14d
cmovbl %r14d, %ebx
movq -0x38(%rbp), %r14
cmpl %r15d, %r13d
cmovbl %r13d, %r15d
addl %r12d, %r15d
movq -0x30(%rbp), %rsi
subq %rbx, %rsi
movq -0x40(%rbp), %rbx
movl %r15d, %edi
jmp 0x8606
addq $0x27, %rsi
testq %r14, %r14
jns 0x8617
cmpl $0x27, %edi
jae 0x8631
movb $0x2d, -0x1(%rsi)
decq %rsi
movq %rbx, %rdi
callq 0x3060
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xdfb6(%rip), %rdi      # 0x165ee
callq 0x3ab5
// File: /workspace/github_c_makefile_star2_O1/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 0x8665
leaq 0xdb6c(%rip), %rdi      # 0x161cc
callq 0x3965
testl %r14d, %r14d
jg 0x8676
leaq 0xdf93(%rip), %rdi      # 0x16604
callq 0x3965
testl %r14d, %r14d
jns 0x8687
leaq 0xdb58(%rip), %rdi      # 0x161da
callq 0x3965
testl %r14d, %r14d
jns 0x86a3
leaq 0xdf71(%rip), %r15      # 0x16604
movl %r14d, %r12d
movq %r15, %rdi
callq 0x3965
incl %r12d
jne 0x8696
cmpq $-0x1, %rbx
je 0x8735
xorl %edx, %edx
leaq -0x2c(%rbp), %r15
movl %r14d, %r12d
movq 0x15ab3(%rip), %rax     # 0x1e170
movq (%rax,%rbx,8), %rax
movq %rax, %rsi
negq %rsi
cmovsq %rax, %rsi
movq %r15, %rdi
callq 0x84fe
movq %r15, %rdi
callq 0x30a0
subl %eax, %r12d
setns %al
testl %r14d, %r14d
sets %cl
orb %al, %cl
jne 0x8712
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 0x3965
movq 0x15e9f(%rip), %rax     # 0x1e5c0
movq (%rax,%rbx,8), %rbx
movl $0x9, %edx
movl %r12d, %r14d
cmpq $-0x1, %rbx
jne 0x86b6
jmp 0x8738
movl %r14d, %r12d
testl %r12d, %r12d
js 0x8766
je 0x875a
incl %r12d
leaq 0xdebb(%rip), %rbx      # 0x16604
movq %rbx, %rdi
callq 0x3965
decl %r12d
cmpl $0x1, %r12d
jg 0x8749
leaq 0xdea2(%rip), %rdi      # 0x16603
callq 0x3965
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: 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 0x4dd6
movq %rax, %r15
movq 0x15e18(%rip), %rax     # 0x1e5c0
movq (%rax,%r15,8), %rsi
leaq 0xde53(%rip), %rdi      # 0x16606
callq 0x4341
movq 0x159b1(%rip), %rcx     # 0x1e170
movq (%rcx,%r15,8), %r15
cmpl $0x5, %eax
jl 0x8822
movq 0x15959(%rip), %rsi     # 0x1e128
movq %r15, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x15948(%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 0x473d
movq %rax, %r15
movl $0x1, %edi
callq 0x3851
movq 0x15d97(%rip), %rax     # 0x1e5c0
movq (%rax,%r15,8), %rdx
incq %r14
movl %ebx, %edi
movq %r14, %rsi
callq 0x5778
leaq 0xddc5(%rip), %rsi      # 0x16606
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x581e
// File: /workspace/github_c_makefile_star2_O1/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 0x8b07
movq 0x15b3a(%rip), %rax     # 0x1e5e0
testb $0x1, (%rax,%rdi)
je 0x8b07
movq 0x156bd(%rip), %rax     # 0x1e170
cmpq $-0x18, (%rax,%rdi,8)
jne 0x8b07
movq 0x15aff(%rip), %rax     # 0x1e5c0
movq (%rax,%rdi,8), %r15
movl $0x1, %ebx
cmpq $-0x1, %r15
je 0x8b07
xorl %edx, %edx
leaq -0x23(%rbp), %r14
movq 0x15693(%rip), %rax     # 0x1e170
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x84fe
movq %r14, %rdi
callq 0x3965
movq 0x15ac8(%rip), %rax     # 0x1e5c0
movq (%rax,%r15,8), %r15
movl $0x9, %edx
cmpq $-0x1, %r15
jne 0x8ad6
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1564f(%rip), %rax     # 0x1e170
movq (%rax,%rdi,8), %rcx
xorl %eax, %eax
cmpq 0x15b7a(%rip), %rcx     # 0x1e6a8
jne 0x8b79
movq %rdi, %rbx
movq 0x15a86(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rdi,8), %rdx
cmpq $-0x1, %rdx
je 0x8b79
cmpq $-0x1, (%rcx,%rdx,8)
jne 0x8b79
leaq 0xda60(%rip), %rdi      # 0x165b2
callq 0x3965
movq 0x15612(%rip), %rax     # 0x1e170
movq 0x15a5b(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rbx,8), %rcx
movq (%rax,%rcx,8), %rdi
xorl %esi, %esi
callq 0x91f0
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8c86
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x15a3d(%rip), %rcx     # 0x1e5e0
testb $0x1, (%rcx,%rdi)
je 0x8c78
movq 0x155bc(%rip), %rcx     # 0x1e170
cmpq $-0x1e, (%rcx,%r14,8)
jne 0x8c78
leaq 0xda46(%rip), %rdi      # 0x1660c
callq 0x3965
movq 0x1559e(%rip), %rax     # 0x1e170
movq 0x159e7(%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 0x8c78
leaq 0xec38(%rip), %r13      # 0x17833
leaq 0xda0d(%rip), %r14      # 0x1660f
movq %rbx, %r12
cmpq %rbx, %r12
movq %r14, %rdi
cmoveq %r13, %rdi
callq 0x3965
movq 0x15555(%rip), %rax     # 0x1e170
movq (%rax,%r12,8), %rcx
movq (%rax,%rcx,8), %r15
testq %r15, %r15
js 0x8c58
movq 0x159b1(%rip), %rcx     # 0x1e5e0
testb $0x19, (%rcx,%r15)
jne 0x8c58
cmpq $-0x9, (%rax,%r15,8)
jne 0x8c58
movq 0x1597c(%rip), %rcx     # 0x1e5c0
movq (%rcx,%r15,8), %rcx
movq (%rax,%rcx,8), %r15
leaq 0xdebb(%rip), %rdi      # 0x16b0e
callq 0x3965
movq %r15, %rdi
xorl %esi, %esi
callq 0x91f0
movq 0x15957(%rip), %rax     # 0x1e5c0
movq (%rax,%r12,8), %r12
cmpq $-0x1, %r12
jne 0x8c05
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_O1/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 0x8d80
movq %rdi, %r14
movq 0x15900(%rip), %rax     # 0x1e5e0
testb $0x1, (%rax,%rdi)
je 0x8d80
movq 0x1547f(%rip), %rax     # 0x1e170
cmpq $-0x16, (%rax,%r14,8)
jne 0x8d80
cmpl $0x0, 0x159bd(%rip)     # 0x1e6c0
jne 0x8d11
leaq 0xd916(%rip), %rdi      # 0x16622
callq 0x3965
movq 0x15458(%rip), %rax     # 0x1e170
movq 0x158a1(%rip), %rcx     # 0x1e5c0
movq (%rcx,%r14,8), %rcx
movq (%rax,%rcx,8), %rax
movl 0x15993(%rip), %ecx     # 0x1e6c0
testl %ecx, %ecx
jne 0x8d3f
cmpl $0x20, %eax
jne 0x8d3f
leaq 0xe2fe(%rip), %rdi      # 0x1703b
jmp 0x8d4f
testl %ecx, %ecx
jne 0x8d56
cmpl $0xa, %eax
jne 0x8d56
leaq 0xd792(%rip), %rdi      # 0x164e1
callq 0x3965
jmp 0x8d66
leaq -0x11(%rbp), %rdi
movb %al, (%rdi)
movl $0x1, %esi
callq 0x38ba
movl $0x1, %ebx
cmpl $0x0, 0x1594e(%rip)     # 0x1e6c0
jne 0x8d80
leaq 0xd8a8(%rip), %rdi      # 0x16623
callq 0x3965
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8e60
movq %rdi, %r14
movq 0x15832(%rip), %rax     # 0x1e5e0
testb $0x10, (%rax,%rdi)
je 0x8e60
movq 0x153b1(%rip), %rax     # 0x1e170
cmpq $-0x21, (%rax,%r14,8)
jne 0x8e60
cmpl $0x0, 0x158ef(%rip)     # 0x1e6c0
jne 0x8ddf
leaq 0xd849(%rip), %rdi      # 0x16623
callq 0x3965
movq 0x15802(%rip), %rax     # 0x1e5e8
movq 0x157d3(%rip), %rcx     # 0x1e5c0
movq (%rcx,%r14,8), %rdx
movl -0x8(%rax,%rdx,8), %ecx
decl %ecx
je 0x8e46
leaq (%rax,%rdx,8), %r15
movl %ecx, %r12d
xorl %r13d, %r13d
leaq 0xd81b(%rip), %rbx      # 0x16625
leaq -0x29(%rbp), %r14
movzbl (%r15,%r13), %eax
movb %al, -0x29(%rbp)
cmpl $0x0, 0x158a3(%rip)     # 0x1e6c0
jne 0x8e31
cmpl $0x5c, %eax
je 0x8e29
cmpl $0x22, %eax
jne 0x8e31
movq %rbx, %rdi
callq 0x3965
movq %r14, %rdi
movl $0x1, %esi
callq 0x38ba
incq %r13
cmpl %r13d, %r12d
jne 0x8e0e
movl $0x1, %ebx
cmpl $0x0, 0x1586e(%rip)     # 0x1e6c0
jne 0x8e60
leaq 0xd7c8(%rip), %rdi      # 0x16623
callq 0x3965
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_O1/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 0x8ee9
movq 0x15753(%rip), %rax     # 0x1e5e0
testb $0x10, (%rax,%rdi)
je 0x8ee9
movq 0x152d6(%rip), %rax     # 0x1e170
cmpq $-0x22, (%rax,%rdi,8)
jne 0x8ee9
movq 0x15740(%rip), %rax     # 0x1e5e8
movq 0x15711(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rdi,8), %rdx
movl -0x8(%rax,%rdx,8), %ecx
movb $0x0, -0x29(%rbp)
movl $0x1, %ebx
decl %ecx
je 0x8ee9
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 0x3965
incq %r13
cmpl %r13d, %r12d
jne 0x8ed2
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_O1/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 0x8f72
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x156cf(%rip), %rcx     # 0x1e5e0
testb $0x1, (%rcx,%rdi)
je 0x8f6c
movq 0x15252(%rip), %rcx     # 0x1e170
cmpq $-0x1d, (%rcx,%rbx,8)
jne 0x8f6c
leaq 0xd6fb(%rip), %rdi      # 0x16627
callq 0x3965
movq 0x15790(%rip), %rax     # 0x1e6c8
movq 0x15231(%rip), %rcx     # 0x1e170
movq 0x1567a(%rip), %rdx     # 0x1e5c0
movq (%rdx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rcx
leaq (%rcx,%rcx,4), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3965
leaq 0xd257(%rip), %rdi      # 0x161b9
callq 0x3965
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9046
movq 0x15614(%rip), %rax     # 0x1e5e0
testb $0x10, (%rax,%rdi)
je 0x9046
movq 0x15197(%rip), %rax     # 0x1e170
cmpq $-0x24, (%rax,%rdi,8)
jne 0x9046
movq 0x15601(%rip), %rax     # 0x1e5e8
movq 0x155d2(%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 0x9046
leaq (%rax,%rcx,8), %r12
movq (%r12), %rdi
xorl %esi, %esi
callq 0x91f0
cmpl $0x1, %r15d
je 0x9046
movl $0x1, %r13d
leaq 0xd610(%rip), %r14      # 0x1663b
movq %r14, %rdi
callq 0x3965
movq (%r12,%r13,8), %rdi
xorl %esi, %esi
callq 0x91f0
incq %r13
cmpl %r13d, %r15d
jne 0x902b
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_O1/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 0x90b6
movq 0x1557b(%rip), %rcx     # 0x1e5e0
movb (%rcx,%rdi), %cl
andb $0x21, %cl
cmpb $0x21, %cl
jne 0x90b6
movq 0x150f9(%rip), %rdx     # 0x1e170
cmpq $-0x17, (%rdx,%rdi,8)
jne 0x90a3
cmpb $0x21, %cl
jne 0x90b7
movq 0x150e6(%rip), %rax     # 0x1e170
cmpq $-0x17, (%rax,%rdi,8)
leaq 0xe3ee(%rip), %rax      # 0x17484
leaq 0xd5af(%rip), %rdx      # 0x1664c
cmoveq %rax, %rdx
jmp 0x90be
cmpb $0x21, %cl
jne 0x90b6
movq 0x150c1(%rip), %rdx     # 0x1e170
cmpq $-0x19, (%rdx,%rdi,8)
je 0x907e
retq
leaq 0xd58e(%rip), %rdx      # 0x1664c
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x68, %rsp
movq 0x150a2(%rip), %rax     # 0x1e170
movq 0x154eb(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rdi,8), %rcx
movl (%rax,%rcx,8), %ecx
leaq 0xd55b(%rip), %rsi      # 0x1663e
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x31f0
movq %rbx, %rdi
callq 0x3965
movl $0x1, %eax
addq $0x68, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9123
movq 0x154c5(%rip), %rax     # 0x1e5e0
movzbl (%rax,%rbx), %eax
testb $0x11, %al
je 0x912f
cmpq $-0x1, %rbx
jne 0x91b9
jmp 0x9137
testb $0x8, %al
je 0x91b9
movq %rbx, %rax
testq %rbx, %rbx
js 0x915f
movq 0x1549a(%rip), %rcx     # 0x1e5e0
movq 0x15473(%rip), %rdx     # 0x1e5c0
movq %rbx, %rax
testb $0x11, (%rcx,%rax)
jne 0x915f
movq (%rdx,%rax,8), %rax
testq %rax, %rax
jns 0x9150
cmpq $-0x1, %rax
je 0x91b9
testq %rbx, %rbx
js 0x91a8
leaq 0xd4df(%rip), %r14      # 0x16650
movq 0x15468(%rip), %rax     # 0x1e5e0
testb $0x11, (%rax,%rbx)
jne 0x91a8
movq 0x14feb(%rip), %rax     # 0x1e170
movq (%rax,%rbx,8), %rdi
xorl %esi, %esi
callq 0x91f0
movq %r14, %rdi
callq 0x3965
movq 0x15421(%rip), %rax     # 0x1e5c0
movq (%rax,%rbx,8), %rbx
testq %rbx, %rbx
jns 0x9171
movq %rbx, %rdi
xorl %esi, %esi
callq 0x91f0
movl $0x1, %eax
jmp 0x91bb
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x14c3b(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x14c2a(%rip)     # 0x1e128
cmpl $0x0, 0x13c33(%rip)     # 0x1d138
je 0x96b4
leaq 0x13c1e(%rip), %r14     # 0x1d130
movq %rbx, -0x38(%rbp)
movq $-0x1, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x14bf6(%rip), %rsi     # 0x1e128
movq %rax, -0x30(%rbp)
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x14be1(%rip)     # 0x1e128
movq %r14, -0x40(%rbp)
movq %r14, %rbx
movq %rbx, %r14
cmpq -0x40(%rbp), %r14
je 0x9565
movl 0x8(%r14), %eax
cmpl -0x8(%r14), %eax
jne 0x9666
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 0x14b7f(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x14b6e(%rip)     # 0x1e128
movq (%r14), %r12
movq %r12, %rdi
callq 0x30a0
movq %rax, %r13
incl %r13d
movq $-0x21, %rdi
movl %r13d, %esi
callq 0x417e
movq %rax, %rbx
movq 0x14fdc(%rip), %rax     # 0x1e5c0
movq (%rax,%rbx,8), %rdi
shlq $0x3, %rdi
addq 0x14ff5(%rip), %rdi     # 0x1e5e8
movslq %r13d, %rdx
movq %r12, %rsi
callq 0x3050
movl $0x1, %edi
callq 0x3851
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x14b54(%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 0x9551
movq $-0x1, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x14f6b(%rip), %rcx     # 0x1e5c0
movq -0x30(%rbp), %rdx
movq %rax, (%rcx,%rdx,8)
movq %rax, -0x30(%rbp)
jmp 0x954e
movl $0x1, %edi
callq 0x3851
movq 0x14af9(%rip), %rcx     # 0x1e170
movq -0x38(%rbp), %rbx
movq %rax, (%rcx,%rbx,8)
cmpl $0x0, 0x8(%r14)
je 0x96a9
movq $-0x1, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x14f1e(%rip), %rcx     # 0x1e5c0
movq %rax, (%rcx,%rbx,8)
movq %rax, %rbx
cmpl $0x0, 0x8(%r14)
jne 0x9512
movl $0x1, %edi
callq 0x3851
movq %rax, 0x14a8b(%rip)     # 0x1e150
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: 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 0x14a60(%rip), %rcx     # 0x1e150
xorl %eax, %eax
cmpq $-0x1, %rcx
je 0x9791
movq %rsi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
movq 0x14a65(%rip), %rbx     # 0x1e170
movq 0x14ed6(%rip), %r14     # 0x1e5e8
movl $0x1, %eax
movq 0x14ea2(%rip), %r15     # 0x1e5c0
movl %eax, -0x2c(%rbp)
movq %rcx, -0x48(%rbp)
movq (%rbx,%rcx,8), %r13
cmpq $-0x1, %r13
je 0x9752
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 0x9769
movq (%r15,%r13,8), %r13
jmp 0x9729
movl -0x2c(%rbp), %eax
incl %eax
movq -0x48(%rbp), %rcx
movq (%r15,%rcx,8), %rcx
cmpq $-0x1, %rcx
jne 0x971e
xorl %eax, %eax
jmp 0x9791
movq -0x38(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
movq (%r15,%r12,8), %rax
movq (%rbx,%rax,8), %rsi
leaq 0xe175(%rip), %rdi      # 0x178f6
callq 0x4341
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_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movslq 0x14b39(%rip), %rax     # 0x1e698
leaq 0x1461a(%rip), %r14     # 0x1e180
movq (%r14,%rax,8), %rdi
callq 0x3220
movl %eax, %ebx
movl $0x1, %r15d
xorl %ecx, %ecx
movl $0x1, %r12d
cmpl $0x0, 0x14a2e(%rip)     # 0x1e5b4
jne 0x9bd7
cmpl $0xa, %ebx
je 0x9b94
cmpl $-0x1, %ebx
jne 0x9b9a
jmp 0x9be6
incl 0x14a36(%rip)           # 0x1e5d0
movl %ebx, %eax
xorl $0x2a, %eax
movl %ecx, %edx
xorl $0x28, %edx
movl %ebx, %esi
xorl $0x29, %esi
xorl $0x2a, %ecx
xorl %r13d, %r13d
orl %esi, %ecx
sete %r13b
negl %r13d
orl %eax, %edx
cmovel %r15d, %r13d
movslq 0x14ad3(%rip), %rax     # 0x1e698
movq (%r14,%rax,8), %rdi
callq 0x3220
movl %ebx, %ecx
movl %eax, %ebx
addl %r13d, %r12d
jne 0x9b7f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xcb29(%rip), %rdi      # 0x16716
movq $-0x8, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x33eb
// File: /workspace/github_c_makefile_star2_O1/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, 0x14302(%rip) # imm = 0xFFFFFED1
jne 0xa447
movq 0x14211(%rip), %rax     # 0x1e5e8
movq 0x141e2(%rip), %rcx     # 0x1e5c0
movq 0x13d73(%rip), %rdi     # 0x1e158
movq (%rcx,%rdi,8), %rcx
cmpb $0x3a, (%rax,%rcx,8)
jne 0xa447
movq 0x13d32(%rip), %rsi     # 0x1e128
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x13d24(%rip)     # 0x1e128
callq 0x9c07
movl %eax, 0x142c1(%rip)     # 0x1e6d0
cmpl $0xfffffed1, %eax       # imm = 0xFFFFFED1
jne 0xa457
movq 0x13d3b(%rip), %rax     # 0x1e158
cmpq 0x142d4(%rip), %rax     # 0x1e6f8
jne 0xa457
movl $0x1, %edi
callq 0x3851
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 0xb249
callq 0xa678
movq %rax, %rbx
movq %rax, 0x13caa(%rip)     # 0x1e110
movq 0x13d03(%rip), %rax     # 0x1e170
movq (%rax,%rbx,8), %rdi
testq %rdi, %rdi
js 0xa483
movq 0x14163(%rip), %rax     # 0x1e5e0
testb $0x19, (%rax,%rdi)
je 0xa4b0
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x14128(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rbx,8), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
movq %rax, 0x13c60(%rip)     # 0x1e110
movl $0x1, %edi
callq 0x3851
movq 0x13caf(%rip), %rcx     # 0x1e170
movq (%rcx,%rbx,8), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq 0x140ea(%rip), %rcx     # 0x1e5c0
movq 0x13c33(%rip), %rdx     # 0x1e110
movq (%rcx,%rdx,8), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq $-0x1, 0x13c1a(%rip) # 0x1e110
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc50b
movl 0x141c1(%rip), %ecx     # 0x1e6d0
addl $0x6d, %ecx
cmpl $0x2, %ecx
jae 0xa59c
movq 0x13c06(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x13bf5(%rip)     # 0x1e128
movl 0x14196(%rip), %r14d    # 0x1e6d0
callq 0x9c07
movl %eax, 0x1418b(%rip)     # 0x1e6d0
callq 0xa4fd
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
movl $0x1, %edi
callq 0x3851
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x36e8
cmpl $-0x6c, %r14d
leaq 0x141c8(%rip), %rcx     # 0x1e748
leaq 0x141c9(%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_O1/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 0x13b61(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x13b50(%rip)     # 0x1e128
callq 0xa4fd
movq 0x13b8c(%rip), %rcx     # 0x1e170
movq %rax, (%rcx,%rbx,8)
cmpl $-0x65, 0x140e1(%rip)   # 0x1e6d0
jne 0xa63b
callq 0x9c07
movl %eax, 0x140d4(%rip)     # 0x1e6d0
movq $-0x1, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %r14
movq 0x13fa5(%rip), %rax     # 0x1e5c0
movq %r14, (%rax,%rbx,8)
callq 0xa4fd
movq 0x13b45(%rip), %rcx     # 0x1e170
movq %rax, (%rcx,%r14,8)
cmpl $-0x65, 0x1409a(%rip)   # 0x1e6d0
movq %r14, %rbx
je 0xa5f1
movl $0x1, %edi
callq 0x3851
movq 0x13f74(%rip), %rcx     # 0x1e5c0
cmpq $-0x1, (%rcx,%rax,8)
je 0xa668
movq 0x140fe(%rip), %rdi     # 0x1e758
movq %rax, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x36e8
movq 0x13b01(%rip), %rcx     # 0x1e170
movq (%rcx,%rax,8), %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: 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 0xd2d8(%rip), %xmm0     # 0x17960
movaps %xmm0, -0x20(%rbp)
movaps 0xd2bd(%rip), %xmm0     # 0x17950
movaps %xmm0, -0x30(%rbp)
movaps 0xd2a2(%rip), %xmm0     # 0x17940
movaps %xmm0, -0x40(%rbp)
movb $0x0, -0x10(%rbp)
movl 0x14024(%rip), %ebx     # 0x1e6d0
cmpl $-0x6b, %ebx
jg 0xa708
addl $0x130, %ebx            # imm = 0x130
cmpl $0x5, %ebx
jae 0xa784
movq 0x13a91(%rip), %rdi     # 0x1e158
movq 0x13a5a(%rip), %rsi     # 0x1e128
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x13a4c(%rip)     # 0x1e128
callq 0x9c07
movl %eax, 0x13fe9(%rip)     # 0x1e6d0
movl $0x1, %edi
callq 0x3851
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
addq $0x38, %rsp
popq %rbx
popq %rbp
jmp 0x36e8
cmpl $-0x6a, %ebx
je 0xa72b
cmpl $-0x68, %ebx
je 0xa72b
cmpl $-0x67, %ebx
jne 0xa784
callq 0x9c07
movl %eax, 0x13fae(%rip)     # 0x1e6d0
movq 0x13f67(%rip), %rdi     # 0x1e690
jmp 0xa6f4
callq 0x9c07
movl %eax, 0x13f9a(%rip)     # 0x1e6d0
xorl %edi, %edi
cmpl $-0x6a, %ebx
sete %dil
callq 0xa9ff
movq 0x13a25(%rip), %rcx     # 0x1e170
movq (%rcx,%rax,8), %rdx
cmpq $-0x6, %rdx
je 0xa7b2
cmpq $-0x1, %rdx
je 0xa7b2
cmpl $-0x68, %ebx
jne 0xa7b2
movq 0x13e59(%rip), %rsi     # 0x1e5c0
cmpq $-0x1, (%rsi,%rdx,8)
jne 0xa7b2
cmpl $0x0, 0x13f6b(%rip)     # 0x1e6e0
jle 0xa7b9
leaq -0x40(%rbp), %rdi
movq $-0x8, %rsi
jmp 0xa7a6
cmpl $0x0, 0x13e29(%rip)     # 0x1e5b4
jne 0xa798
callq 0x9c07
movl %eax, 0x13f38(%rip)     # 0x1e6d0
movq 0x139b9(%rip), %rsi     # 0x1e158
leaq 0xc007(%rip), %rdi      # 0x167ad
callq 0x33eb
movq $-0x5, %rax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
movq (%rcx,%rdx,8), %rdi
movq (%rsi,%rax,8), %rsi
jmp 0xa6fb
// File: /workspace/github_c_makefile_star2_O1/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
cmpl $0x0, 0x13cd0(%rip)     # 0x1e6e0
jne 0xaa46
movq $-0x1, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x13caa(%rip)     # 0x1e6d8
movq 0x136f3(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x136e2(%rip)     # 0x1e128
incl 0x13c94(%rip)           # 0x1e6e0
movl $0x1, %edi
movl %r14d, %esi
callq 0xa02b
movq %rax, %rbx
testl %r14d, %r14d
je 0xaa8c
cmpq $-0x1, %rbx
je 0xaa8c
cmpq $-0x6, %rbx
je 0xaa8c
movq %rbx, %rax
movq 0x13b69(%rip), %rcx     # 0x1e5e0
orb $0x8, (%rcx,%rax)
movq 0x13b3e(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rax,8), %rax
cmpq $-0x1, %rax
jne 0xaa70
decl 0x13c4e(%rip)           # 0x1e6e0
je 0xaaa3
movq %rbx, %rdi
movq $-0x1, %rsi
jmp 0xab2a
movl $0x1, %edi
callq 0x3851
movq %rax, 0x13c24(%rip)     # 0x1e6d8
movq 0x1366d(%rip), %rsi     # 0x1e128
movq %rbx, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x1365c(%rip)     # 0x1e128
movq 0x13aed(%rip), %rax     # 0x1e5c0
movq 0x13bfe(%rip), %rcx     # 0x1e6d8
movq (%rax,%rcx,8), %rsi
cmpq $-0x1, %rsi
je 0xaafb
cmpq $-0x1, (%rax,%rsi,8)
je 0xab04
movq 0x13bf6(%rip), %rdi     # 0x1e6e8
xorl %edx, %edx
callq 0x36e8
jmp 0xab0f
movq $-0x1, %rax
jmp 0xab0f
movq 0x13665(%rip), %rax     # 0x1e170
movq (%rax,%rsi,8), %rax
movq %rax, 0x13bc2(%rip)     # 0x1e6d8
movl $0x1, %edi
callq 0x3851
movq 0x13bb1(%rip), %rsi     # 0x1e6d8
movq %rax, %rdi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x36e8
// File: /workspace/github_c_makefile_star2_O1/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 0xab62
pushq %rbp
movq %rsp, %rbp
movq %rax, %rcx
movq 0x13a94(%rip), %rdx     # 0x1e5e0
orb $0x8, (%rdx,%rcx)
movq 0x13a69(%rip), %rdx     # 0x1e5c0
movq (%rdx,%rcx,8), %rcx
cmpq $-0x1, %rcx
jne 0xab45
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
movl %edi, %r14d
callq 0xa678
movq %rax, %rbx
testl %r14d, %r14d
je 0xace9
movl 0x13b48(%rip), %eax     # 0x1e6d0
cmpl $0xffffff23, %eax       # imm = 0xFFFFFF23
jg 0xacb8
addl $0x130, %eax            # imm = 0x130
cmpl $0x5, %eax
jae 0xace9
movq 0x135b0(%rip), %rdi     # 0x1e158
callq 0x97a0
testl %eax, %eax
jne 0xace9
cmpl $-0x67, 0x13b14(%rip)   # 0x1e6d0
je 0xace9
testq %rbx, %rbx
js 0xabfc
movq 0x13a12(%rip), %rax     # 0x1e5e0
movb (%rax,%rbx), %al
testb $0x1, %al
je 0xabfc
movq 0x13594(%rip), %rcx     # 0x1e170
movq (%rcx,%rbx,8), %rcx
cmpq $-0x1f, %rcx
je 0xace9
cmpq $-0x18, %rcx
je 0xace9
testb $0x1, %al
jne 0xacd7
leaq 0x1(%rbx), %rax
cmpq $-0x3, %rax
ja 0xace9
movq 0x13517(%rip), %rsi     # 0x1e128
movq %rbx, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x13506(%rip)     # 0x1e128
callq 0xa678
movq %rax, %r15
movq 0x1353f(%rip), %rax     # 0x1e170
movq (%rax,%r15,8), %r14
movq 0x134ec(%rip), %rsi     # 0x1e128
movq %r14, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x134db(%rip)     # 0x1e128
movq 0x1396c(%rip), %rax     # 0x1e5c0
movq (%rax,%rbx,8), %r12
cmpq $-0x1, %r12
jne 0xac69
movq 0x1350b(%rip), %rcx     # 0x1e170
movq (%rcx,%rbx,8), %r12
movq (%rax,%r15,8), %rdi
cmpq $-0x1, %rdi
jne 0xac7e
movq 0x134f6(%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 0x3851
jmp 0xab82
cmpl $0xffffff24, %eax       # imm = 0xFFFFFF24
je 0xaba1
cmpl $-0x68, %eax
je 0xaba1
cmpl $-0x6a, %eax
je 0xaba1
jmp 0xace9
movq 0x13492(%rip), %rax     # 0x1e170
cmpq $-0x16, (%rax,%rbx,8)
jne 0xac0a
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa3bc
testq %rax, %rax
js 0xb459
movq 0x1319b(%rip), %rcx     # 0x1e5e0
testb $0x11, (%rcx,%rax)
jne 0xb459
movq 0x1316e(%rip), %rcx     # 0x1e5c0
cmpq $-0x1, (%rcx,%rax,8)
je 0xb46b
movq $-0x9, %rdi
movq %rax, %rsi
xorl %edx, %edx
popq %rbp
jmp 0x36e8
movq 0x12cfe(%rip), %rcx     # 0x1e170
movq (%rcx,%rax,8), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb7e4
movl %r14d, %edi
callq 0xc0c9
jmp 0xb7f1
movl $0xffffff38, %edi       # imm = 0xFFFFFF38
movl %r14d, %esi
callq 0xb7c2
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %r15
movq 0x1291c(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x1290b(%rip)     # 0x1e128
cmpl %ebx, 0x12ead(%rip)     # 0x1e6d0
jne 0xb882
callq 0x9c07
movl %eax, 0x12ea0(%rip)     # 0x1e6d0
movq $-0x1, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %r12
movq 0x12d71(%rip), %rax     # 0x1e5c0
movq %r12, (%rax,%r15,8)
cmpl $0xffffff38, %ebx       # imm = 0xFFFFFF38
jne 0xb865
movl %r14d, %edi
callq 0xc0c9
jmp 0xb872
movl $0xffffff38, %edi       # imm = 0xFFFFFF38
movl %r14d, %esi
callq 0xb7c2
movq 0x128f7(%rip), %rcx     # 0x1e170
movq %rax, (%rcx,%r12,8)
movq %r12, %r15
jmp 0xb81d
movl $0x1, %edi
callq 0x3851
movq 0x12d2d(%rip), %rcx     # 0x1e5c0
cmpq $-0x1, (%rcx,%rax,8)
je 0xb8c7
cmpl $0xffffff23, %ebx       # imm = 0xFFFFFF23
leaq 0x12e59(%rip), %rcx     # 0x1e700
leaq 0x12e3a(%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 0x128a2(%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_O1/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 0x12872(%rip), %rdi     # 0x1e158
movq 0x1283b(%rip), %rsi     # 0x1e128
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x1282d(%rip)     # 0x1e128
callq 0x9c07
movl %eax, 0x12dca(%rip)     # 0x1e6d0
callq 0xa7c6
testq %rax, %rax
js 0xb924
movq 0x12cc9(%rip), %rcx     # 0x1e5e0
movb (%rcx,%rax), %cl
testb $0x10, %cl
jne 0xb94a
testb $0x9, %cl
je 0xb958
movl $0x1, %edi
callq 0x3851
movq 0x12823(%rip), %rsi     # 0x1e158
leaq 0xaee1(%rip), %rdi      # 0x1681d
callq 0x33eb
movq $-0x5, %rax
popq %rbp
retq
movq 0x1281f(%rip), %rcx     # 0x1e170
cmpq $-0x22, (%rcx,%rax,8)
jne 0xb924
movq %rax, 0x127b1(%rip)     # 0x1e110
movl $0x1, %edi
callq 0x3851
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x1278f(%rip), %rdi     # 0x1e110
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq $-0x1, 0x1277a(%rip) # 0x1e110
movq 0x12d53(%rip), %rdi     # 0x1e6f0
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x12d51(%rip), %rdi     # 0x1e710
movq %rax, %rsi
xorl %edx, %edx
popq %rbp
jmp 0x36e8
// File: /workspace/github_c_makefile_star2_O1/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 0x12cbb(%rip), %ecx     # 0x1e6d0
leal 0xe2(%rcx), %eax
cmpl $0x12, %eax
ja 0xba38
leaq 0xa689(%rip), %rcx      # 0x160b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl %edi, %edi
popq %rbp
jmp 0xc742
cmpl $-0x4, %ecx
jne 0xba46
movq $-0x4, %rax
popq %rbp
retq
popq %rbp
jmp 0xa4fd
popq %rbp
jmp 0xd763
xorl %edi, %edi
popq %rbp
jmp 0xca76
xorl %edi, %edi
jmp 0xba76
popq %rbp
jmp 0xccde
movl $0x2, %edi
jmp 0xba76
popq %rbp
jmp 0xd15f
movl $0x1, %edi
popq %rbp
jmp 0xd537