LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0xbd78
movq 0x1c8b6(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xbd78
movq 0x1c89f(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0xbd78
movq 0x1c888(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0xbd8b
cmpq $-0x1, -0x10(%rbp)
je 0xbd8b
movl $0x0, -0x4(%rbp)
jmp 0xbe99
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
je 0xbde8
cmpq $0x0, -0x18(%rbp)
jl 0xbdcf
movq 0x1c848(%rip), %rax     # 0x285f0
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xbdcf
movq 0x1c831(%rip), %rax     # 0x285f0
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xbdd1
jmp 0xbde8
jmp 0xbdd3
movq 0x1c7f6(%rip), %rax     # 0x285d0
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0xbd93
cmpq $-0x1, -0x18(%rbp)
jne 0xbdfb
movl $0x0, -0x4(%rbp)
jmp 0xbe99
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
jl 0xbe46
movq 0x1c7da(%rip), %rax     # 0x285f0
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
andl $0x1, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
jne 0xbe46
movq 0x1c7be(%rip), %rax     # 0x285f0
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xbe51
jmp 0xbe89
movq 0x1c328(%rip), %rax     # 0x28180
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3b70
leaq 0x14894(%rip), %rdi     # 0x20700
callq 0x3ab0
movq 0x1c758(%rip), %rax     # 0x285d0
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0xbe03
movq -0x18(%rbp), %rdi
callq 0x3b70
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x1, -0x34(%rbp)
movq 0x1bbee(%rip), %rax     # 0x28160
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
je 0xc668
movq 0x1bbf8(%rip), %rax     # 0x28180
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $-0x1, -0x30(%rbp)
je 0xc645
movq -0x10(%rbp), %rdi
movq 0x1c04e(%rip), %rsi     # 0x285f8
movq 0x1c01f(%rip), %rax     # 0x285d0
movq 0x1bbc8(%rip), %rcx     # 0x28180
movq 0x1bbc1(%rip), %rdx     # 0x28180
movq -0x30(%rbp), %r8
movq (%rdx,%r8,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x3120
cmpl $0x0, %eax
jne 0xc62b
movl -0x34(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq 0x1bb90(%rip), %rax     # 0x28180
movq 0x1bfd9(%rip), %rcx     # 0x285d0
movq 0x1bb82(%rip), %rdx     # 0x28180
movq -0x30(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x153bf(%rip), %rdi     # 0x219d4
callq 0x4960
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0xc66f
jmp 0xc62d
movq 0x1bf9c(%rip), %rax     # 0x285d0
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
jmp 0xc594
jmp 0xc647
movq 0x1bf82(%rip), %rax     # 0x285d0
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xc576
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl $0x1, -0x4(%rbp)
movl $0x0, -0xc(%rbp)
movslq 0x1baeb(%rip), %rcx     # 0x286a8
leaq 0x1b5cc(%rip), %rax     # 0x28190
movq (%rax,%rcx,8), %rdi
callq 0x3230
movl %eax, -0x8(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x4(%rbp)
movb %al, -0xd(%rbp)
je 0xcbec
movl 0x1b9e3(%rip), %eax     # 0x285c4
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0xd(%rbp)
movb -0xd(%rbp), %al
testb $0x1, %al
jne 0xcbf8
jmp 0xcc7f
cmpl $0xa, -0x8(%rbp)
jne 0xcc0f
movl 0x1b9dc(%rip), %eax     # 0x285e0
addl $0x1, %eax
movl %eax, 0x1b9d3(%rip)     # 0x285e0
jmp 0xcc2c
cmpl $-0x1, -0x8(%rbp)
jne 0xcc2a
leaq 0x13baa(%rip), %rdi     # 0x207c6
movq $-0x8, %rsi
callq 0x34b0
jmp 0xcc7f
jmp 0xcc2c
cmpl $0x2a, -0x8(%rbp)
jne 0xcc43
cmpl $0x28, -0xc(%rbp)
jne 0xcc43
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xcc5a
cmpl $0x29, -0x8(%rbp)
jne 0xcc58
cmpl $0x2a, -0xc(%rbp)
jne 0xcc58
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xcc5a
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
movslq 0x1ba41(%rip), %rcx     # 0x286a8
leaq 0x1b522(%rip), %rax     # 0x28190
movq (%rax,%rcx,8), %rdi
callq 0x3230
movl %eax, -0x8(%rbp)
jmp 0xcbd0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
cmpl $0xfffffed1, 0x1af8b(%rip) # imm = 0xFFFFFED1
jne 0xd90f
movq 0x1ae96(%rip), %rax     # 0x285f8
movq 0x1ae67(%rip), %rcx     # 0x285d0
movq 0x1a9f8(%rip), %rdx     # 0x28168
movq (%rcx,%rdx,8), %rcx
movsbl (%rax,%rcx,8), %eax
cmpl $0x3a, %eax
jne 0xd90f
movq 0x1a9e0(%rip), %rdi     # 0x28168
movq 0x1a9a9(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x1a99b(%rip)     # 0x28138
callq 0xcc90
movl %eax, 0x1af38(%rip)     # 0x286e0
cmpl $0xfffffed1, 0x1af2e(%rip) # imm = 0xFFFFFED1
jne 0xd7c8
movq 0x1a9ad(%rip), %rax     # 0x28168
cmpq 0x1af46(%rip), %rax     # 0x28708
je 0xd8ee
movl -0x4(%rbp), %edi
callq 0xdb10
movq %rax, -0x10(%rbp)
movq %rax, 0x1a945(%rip)     # 0x28120
movq 0x1a99e(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jl 0xd853
movq 0x1adfc(%rip), %rax     # 0x285f0
movq 0x1a985(%rip), %rcx     # 0x28180
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xd853
movq 0x1adda(%rip), %rax     # 0x285f0
movq 0x1a963(%rip), %rcx     # 0x28180
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movsbl (%rax,%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0xd853
movq 0x1adb8(%rip), %rax     # 0x285f0
movq 0x1a941(%rip), %rcx     # 0x28180
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movsbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xd899
movq 0x1a926(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq 0x1ad51(%rip), %rax     # 0x285d0
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq %rax, 0x1a887(%rip)     # 0x28120
movl $0x1, %edi
callq 0x3950
movq %rax, %rdi
movq 0x1a8d3(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0x1ad05(%rip), %rax     # 0x285d0
movq 0x1a84e(%rip), %rcx     # 0x28120
movq (%rax,%rcx,8), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq $-0x1, 0x1a834(%rip) # 0x28120
jmp 0xd90d
movl $0x1, %edi
callq 0x3950
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
jmp 0xd920
movl -0x4(%rbp), %esi
movl $0xffffff23, %edi       # imm = 0xFFFFFF23
callq 0xed60
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
callq 0x10780
movq %rax, -0x10(%rbp)
cmpl $-0x6c, 0x1ad98(%rip)   # 0x286e0
je 0xd957
cmpl $-0x6d, 0x1ad8f(%rip)   # 0x286e0
jne 0xd9f2
movq -0x10(%rbp), %rdi
movq 0x1a7d6(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x1a7c8(%rip)     # 0x28138
movl 0x1ad6a(%rip), %eax     # 0x286e0
movl %eax, -0x1c(%rbp)
callq 0xcc90
movl %eax, 0x1ad5c(%rip)     # 0x286e0
callq 0xd930
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movl $0x1, %edi
callq 0x3950
movq %rax, %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
cmpl $-0x6c, -0x1c(%rbp)
jne 0xd9d2
movq 0x1ad8c(%rip), %rax     # 0x28758
movq %rax, -0x28(%rbp)
jmp 0xd9dd
movq 0x1ad87(%rip), %rax     # 0x28760
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x8(%rbp)
jmp 0xd9fa
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq $-0x1, %rsi
xorl %edx, %edx
movq %rsi, %rdi
callq 0x3780
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq 0x1a700(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x1a6f2(%rip)     # 0x28138
callq 0xd930
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
movq 0x1a726(%rip), %rax     # 0x28180
movq -0x8(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
cmpl $-0x65, 0x1ac77(%rip)   # 0x286e0
je 0xda6d
jmp 0xdab5
callq 0xcc90
movl %eax, 0x1ac68(%rip)     # 0x286e0
movq $-0x1, %rsi
xorl %edx, %edx
movq %rsi, %rdi
callq 0x3780
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
movq 0x1ab38(%rip), %rax     # 0x285d0
movq -0x8(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x1ab29(%rip), %rax     # 0x285d0
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0xda46
movl $0x1, %edi
callq 0x3950
movq %rax, -0x10(%rbp)
movq 0x1ab06(%rip), %rax     # 0x285d0
movq -0x10(%rbp), %rcx
cmpq $-0x1, (%rax,%rcx,8)
jne 0xdaea
movq 0x1a6a4(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
jmp 0xdb00
movq 0x1ac77(%rip), %rdi     # 0x28768
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
cmpl $0x0, 0x1a6be(%rip)     # 0x286f0
jne 0xe068
movq $-0x1, %rsi
xorl %edx, %edx
movq %rsi, %rdi
callq 0x3780
movq %rax, 0x1a69c(%rip)     # 0x286e8
movq 0x1a695(%rip), %rdi     # 0x286e8
movq 0x1a0de(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x1a0d0(%rip)     # 0x28138
movl 0x1a682(%rip), %eax     # 0x286f0
addl $0x1, %eax
movl %eax, 0x1a679(%rip)     # 0x286f0
movl -0xc(%rbp), %esi
movl $0x1, %edi
callq 0xd260
movq %rax, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0xe0a5
cmpq $-0x1, -0x18(%rbp)
je 0xe0a5
cmpq $-0x6, -0x18(%rbp)
je 0xe0a5
movq -0x18(%rbp), %rdi
callq 0xe1c0
movl 0x1a645(%rip), %eax     # 0x286f0
addl $-0x1, %eax
movl %eax, 0x1a63c(%rip)     # 0x286f0
cmpl $0x0, 0x1a635(%rip)     # 0x286f0
jne 0xe19d
movl $0x1, %edi
callq 0x3950
movq %rax, 0x1a616(%rip)     # 0x286e8
movq -0x18(%rbp), %rdi
movq 0x1a05b(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x1a04d(%rip)     # 0x28138
movq 0x1a4de(%rip), %rax     # 0x285d0
movq 0x1a5ef(%rip), %rcx     # 0x286e8
cmpq $-0x1, (%rax,%rcx,8)
jne 0xe10d
movq $-0x1, 0x1a5dd(%rip) # 0x286e8
jmp 0xe17c
movq 0x1a4bc(%rip), %rax     # 0x285d0
movq 0x1a4b5(%rip), %rcx     # 0x285d0
movq 0x1a5c6(%rip), %rdx     # 0x286e8
movq (%rcx,%rdx,8), %rcx
cmpq $-0x1, (%rax,%rcx,8)
jne 0xe153
movq 0x1a04c(%rip), %rax     # 0x28180
movq 0x1a495(%rip), %rcx     # 0x285d0
movq 0x1a5a6(%rip), %rdx     # 0x286e8
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x1a597(%rip)     # 0x286e8
jmp 0xe17a
movq 0x1a59e(%rip), %rdi     # 0x286f8
movq 0x1a46f(%rip), %rax     # 0x285d0
movq 0x1a580(%rip), %rcx     # 0x286e8
movq (%rax,%rcx,8), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, 0x1a56e(%rip)     # 0x286e8
jmp 0xe17c
movl $0x1, %edi
callq 0x3950
movq %rax, %rdi
movq 0x1a558(%rip), %rsi     # 0x286e8
xorl %edx, %edx
callq 0x3780
movq %rax, -0x8(%rbp)
jmp 0xe1b3
movq -0x18(%rbp), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $-0x1, -0x10(%rbp)
je 0xe201
movq 0x1a412(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %edx
orl $0x8, %edx
movb %dl, (%rax,%rcx)
movq 0x1a3dd(%rip), %rax     # 0x285d0
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0xe1d0
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
xorl %edi, %edi
callq 0xd740
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0xf0ef
movq 0x1954f(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xf0ef
movq 0x19538(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0xf0ef
movq 0x19501(%rip), %rax     # 0x285d0
movq -0x10(%rbp), %rcx
cmpq $-0x1, (%rax,%rcx,8)
jne 0xf0ef
movq 0x1909f(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0xf105
movq -0x10(%rbp), %rsi
movq $-0x9, %rdi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
cmpl $0xffffff38, -0xc(%rbp) # imm = 0xFFFFFF38
jne 0xf555
movl -0x10(%rbp), %edi
callq 0x10240
movq %rax, -0x30(%rbp)
jmp 0xf566
movl -0x10(%rbp), %esi
movl $0xffffff38, %edi       # imm = 0xFFFFFF38
callq 0xf530
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq 0x18ba9(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x18b9b(%rip)     # 0x28138
movl 0x1913d(%rip), %eax     # 0x286e0
cmpl -0xc(%rbp), %eax
jne 0xf63a
callq 0xcc90
movl %eax, 0x19129(%rip)     # 0x286e0
movq $-0x1, %rsi
xorl %edx, %edx
movq %rsi, %rdi
callq 0x3780
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
movq 0x18ff9(%rip), %rax     # 0x285d0
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x18fea(%rip), %rax     # 0x285d0
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpl $0xffffff38, -0xc(%rbp) # imm = 0xFFFFFF38
jne 0xf609
movl -0x10(%rbp), %edi
callq 0x10240
movq %rax, -0x38(%rbp)
jmp 0xf61a
movl -0x10(%rbp), %esi
movl $0xffffff38, %edi       # imm = 0xFFFFFF38
callq 0xf530
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
movq 0x18b53(%rip), %rax     # 0x28180
movq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0xf59d
movl $0x1, %edi
callq 0x3950
movq %rax, -0x18(%rbp)
movq 0x18f81(%rip), %rax     # 0x285d0
movq -0x18(%rbp), %rcx
cmpq $-0x1, (%rax,%rcx,8)
jne 0xf66f
movq 0x18b1f(%rip), %rax     # 0x28180
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0xf6a3
cmpl $0xffffff23, -0xc(%rbp) # imm = 0xFFFFFF23
jne 0xf685
movq 0x19091(%rip), %rax     # 0x28710
movq %rax, -0x40(%rbp)
jmp 0xf690
movq 0x1906c(%rip), %rax     # 0x286f8
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq 0x18aa9(%rip), %rdi     # 0x28168
movq 0x18a72(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x18a64(%rip)     # 0x28138
callq 0xcc90
movl %eax, 0x19001(%rip)     # 0x286e0
callq 0xdd10
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0xf718
movq 0x18efa(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0xf718
movq 0x18a73(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
cmpq $-0x22, (%rax,%rcx,8)
je 0xf78a
cmpq $0x0, -0x10(%rbp)
jl 0xf764
movq 0x18eca(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0xf764
movq 0x18eb3(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0xf764
movq 0x18e9c(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xf78a
movl $0x1, %edi
callq 0x3950
movq 0x189f3(%rip), %rsi     # 0x28168
leaq 0x11151(%rip), %rdi     # 0x208cd
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0xf81f
movq -0x10(%rbp), %rax
movq %rax, 0x1898b(%rip)     # 0x28120
movl $0x1, %edi
callq 0x3950
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq 0x18965(%rip), %rdi     # 0x28120
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq $-0x1, 0x1894b(%rip) # 0x28120
movq 0x18f24(%rip), %rdi     # 0x28700
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq 0x18f18(%rip), %rdi     # 0x28720
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl 0x18e72(%rip), %eax     # 0x286e0
movl %eax, -0xc(%rbp)
subl $0xffffff1e, %eax       # imm = 0xFFFFFF1E
je 0xf8dc
jmp 0xf87a
movl -0xc(%rbp), %eax
subl $0xffffff1f, %eax       # imm = 0xFFFFFF1F
je 0xf8f6
jmp 0xf886
movl -0xc(%rbp), %eax
subl $0xffffff26, %eax       # imm = 0xFFFFFF26
je 0xf92c
jmp 0xf896
movl -0xc(%rbp), %eax
subl $0xffffff27, %eax       # imm = 0xFFFFFF27
je 0xf901
jmp 0xf8a2
movl -0xc(%rbp), %eax
subl $0xffffff29, %eax       # imm = 0xFFFFFF29
je 0xf91c
jmp 0xf8ae
movl -0xc(%rbp), %eax
subl $0xffffff2a, %eax       # imm = 0xFFFFFF2A
je 0xf90c
jmp 0xf8ba
movl -0xc(%rbp), %eax
subl $0xffffff2e, %eax       # imm = 0xFFFFFF2E
je 0xf8e9
jmp 0xf8c6
movl -0xc(%rbp), %eax
subl $0xffffff30, %eax       # imm = 0xFFFFFF30
je 0xf939
jmp 0xf8d2
movl -0xc(%rbp), %eax
subl $-0x4, %eax
je 0xf944
jmp 0xf94e
xorl %edi, %edi
callq 0x10ab0
movq %rax, -0x8(%rbp)
jmp 0xf957
xorl %edi, %edi
callq 0x10ed0
movq %rax, -0x8(%rbp)
jmp 0xf957
callq 0x111e0
movq %rax, -0x8(%rbp)
jmp 0xf957
callq 0x117f0
movq %rax, -0x8(%rbp)
jmp 0xf957
movl $0x1, %edi
callq 0x11da0
movq %rax, -0x8(%rbp)
jmp 0xf957
movl $0x2, %edi
callq 0x11da0
movq %rax, -0x8(%rbp)
jmp 0xf957
xorl %edi, %edi
callq 0x11da0
movq %rax, -0x8(%rbp)
jmp 0xf957
callq 0x120d0
movq %rax, -0x8(%rbp)
jmp 0xf957
movq $-0x4, -0x8(%rbp)
jmp 0xf957
callq 0xd930
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
callq 0xcc90
movl %eax, 0x18d5d(%rip)     # 0x286e0
movl $0x1, %edi
callq 0x11580
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0x1879c(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x1878e(%rip)     # 0x28138
cmpl $0xffffff2b, 0x18d2c(%rip) # imm = 0xFFFFFF2B
je 0xf9dc
movl $0x1, %edi
callq 0x3950
leaq 0x1105d(%rip), %rdi     # 0x20a24
movq $-0x8, %rsi
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0xfb18
callq 0xcc90
movl %eax, 0x18cf9(%rip)     # 0x286e0
callq 0xda10
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq 0x1873d(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x1872f(%rip)     # 0x28138
cmpl $0xffffff32, 0x18ccd(%rip) # imm = 0xFFFFFF32
je 0xfa3b
movl $0x2, %edi
callq 0x3950
leaq 0x11014(%rip), %rdi     # 0x20a3a
movq $-0x8, %rsi
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0xfb18
callq 0xcc90
movl %eax, 0x18c9a(%rip)     # 0x286e0
movl $0x1, %edi
callq 0x3950
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x18(%rbp)
movl $0x1, %edi
callq 0x3950
movq %rax, -0x10(%rbp)
movq 0x18701(%rip), %rax     # 0x28180
movq 0x186fa(%rip), %rcx     # 0x28180
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
cmpq 0x18cdf(%rip), %rax     # 0x28778
jne 0xfac6
movq -0x18(%rbp), %rdx
movq 0x18b2a(%rip), %rax     # 0x285d0
movq 0x18b23(%rip), %rcx     # 0x285d0
movq 0x186cc(%rip), %rsi     # 0x28180
movq -0x10(%rbp), %rdi
movq (%rsi,%rdi,8), %rsi
movq (%rcx,%rsi,8), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0xfb05
movq -0x18(%rbp), %rdx
movq 0x18aff(%rip), %rax     # 0x285d0
movq 0x186a8(%rip), %rcx     # 0x28180
movq 0x18af1(%rip), %rsi     # 0x285d0
movq 0x1869a(%rip), %rdi     # 0x28180
movq 0x18693(%rip), %r8      # 0x28180
movq -0x10(%rbp), %r9
movq (%r8,%r9,8), %r8
movq (%rdi,%r8,8), %rdi
movq (%rsi,%rdi,8), %rsi
movq (%rcx,%rsi,8), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x18ac4(%rip), %rax     # 0x285d0
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
callq 0xdd10
movq %rax, -0x8(%rbp)
cmpl $0xfffffed1, 0x18b95(%rip) # imm = 0xFFFFFED1
je 0xfbb0
cmpl $0xfffffed3, 0x18b89(%rip) # imm = 0xFFFFFED3
je 0xfbb0
cmpl $0xfffffed4, 0x18b7d(%rip) # imm = 0xFFFFFED4
je 0xfbb0
cmpl $0xfffffed2, 0x18b71(%rip) # imm = 0xFFFFFED2
je 0xfbb0
cmpl $0xfffffed0, 0x18b65(%rip) # imm = 0xFFFFFED0
je 0xfbb0
cmpl $-0x68, 0x18b5c(%rip)   # 0x286e0
je 0xfbb0
cmpl $-0x6a, 0x18b53(%rip)   # 0x286e0
je 0xfbb0
cmpl $0xffffff24, 0x18b47(%rip) # imm = 0xFFFFFF24
je 0xfbb0
xorl %eax, %eax
cmpl $0xffffff21, 0x18b39(%rip) # imm = 0xFFFFFF21
movb %al, -0x11(%rbp)
jne 0xfc84
movq 0x185b1(%rip), %rdi     # 0x28168
callq 0xc680
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
jne 0xfc84
xorl %eax, %eax
cmpl $-0x67, 0x18b0b(%rip)   # 0x286e0
movb %al, -0x11(%rbp)
je 0xfc84
cmpq $0x0, -0x8(%rbp)
jl 0xfc2a
movq 0x18a04(%rip), %rax     # 0x285f0
movq -0x8(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xfc2a
movq 0x1857d(%rip), %rcx     # 0x28180
movq -0x8(%rbp), %rdx
movb $0x1, %al
cmpq $-0x1f, (%rcx,%rdx,8)
movb %al, -0x12(%rbp)
je 0xfc7c
movq 0x18566(%rip), %rcx     # 0x28180
movq -0x8(%rbp), %rdx
movb $0x1, %al
cmpq $-0x18, (%rcx,%rdx,8)
movb %al, -0x12(%rbp)
je 0xfc7c
cmpq $0x0, -0x8(%rbp)
jl 0xfc5f
movq 0x189b8(%rip), %rax     # 0x285f0
movq -0x8(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xfc5f
movq 0x18531(%rip), %rcx     # 0x28180
movq -0x8(%rbp), %rdx
movb $0x1, %al
cmpq $-0x16, (%rcx,%rdx,8)
movb %al, -0x12(%rbp)
je 0xfc7c
movb $0x1, %al
cmpq $-0x2, -0x8(%rbp)
movb %al, -0x13(%rbp)
je 0xfc76
cmpq $-0x3, -0x8(%rbp)
sete %al
movb %al, -0x13(%rbp)
movb -0x13(%rbp), %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
xorb $-0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xfc8d
jmp 0xfce6
movq -0x8(%rbp), %rdi
movq 0x184a0(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x18492(%rip)     # 0x28138
callq 0xdd10
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movl $0x1, %edi
callq 0x3950
movq %rax, %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x8(%rbp)
jmp 0xfb41
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0xff20
movq %rax, -0x10(%rbp)
cmpl $0xffffff36, 0x1847f(%rip) # imm = 0xFFFFFF36
jne 0x102c7
movq -0x10(%rbp), %rdi
movq 0x17eca(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x17ebc(%rip)     # 0x28138
callq 0xcc90
movl %eax, 0x18459(%rip)     # 0x286e0
movl -0x4(%rbp), %edi
callq 0x10240
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movl $0x1, %edi
callq 0x3950
movq %rax, %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
jmp 0x10257
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: handle_expr
cell handle_expr(void) {
	cell	n, m, h, k;

	n = logop(TOK_OR, 1);
	if (Token == TOK_HANDLE) {
		save(n);
		Token = scan();
		h = node(n, NIL);		/* ((%unregister expr)) */
		h = node(S_unregister, h);
		h = node(h, NIL);
		save(h);
		k = gensym("k");
		save(k);
		m = match(0);			/* (%register k (fn match)) */ 
		m = node(S_fn, m);
		m = node(m, NIL);
		m = node(k, m);
		m = node(S_register, m);
		h = node(m, cadr(Stack));	/* body = (reg expr unreg) */
		h = node(k, h);			/* handler = (fn (k body)) */
		h = node(h, NIL);
		h = node(S_fn, h);
		h = node(h, NIL);
		h = node(S_callcc, h);		/* (call/cc handler) */
		unsave(3);
		n = h;
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0xffffff23, %edi       # imm = 0xFFFFFF23
movl $0x1, %esi
callq 0xf530
movq %rax, -0x8(%rbp)
cmpl $0xffffff2d, 0x183db(%rip) # imm = 0xFFFFFF2D
jne 0x104bc
movq -0x8(%rbp), %rdi
movq 0x17e22(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x17e14(%rip)     # 0x28138
callq 0xcc90
movl %eax, 0x183b1(%rip)     # 0x286e0
movq -0x8(%rbp), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x18(%rbp)
movq 0x183e4(%rip), %rdi     # 0x28730
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq 0x17dbc(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x17dae(%rip)     # 0x28138
leaq 0x10e34(%rip), %rdi     # 0x211c5
callq 0x104d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq 0x17d93(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x17d85(%rip)     # 0x28138
xorl %edi, %edi
callq 0xf110
movq %rax, -0x10(%rbp)
movq 0x18353(%rip), %rdi     # 0x28718
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq 0x18334(%rip), %rdi     # 0x28738
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0x17d62(%rip), %rax     # 0x28180
movq 0x181ab(%rip), %rcx     # 0x285d0
movq 0x17d0c(%rip), %rdx     # 0x28138
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x18(%rbp)
movq 0x182a9(%rip), %rdi     # 0x28718
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x18(%rbp)
movq 0x182a5(%rip), %rdi     # 0x28740
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x18(%rbp)
movl $0x3, %edi
callq 0x3950
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: gensym
cell gensym(char *prefix) {
	static long	g = 0;
	char		s[200];

	do {
		sprintf(s, "%s%ld", prefix, g);
		g++;
	} while (find_symbol(s) != NIL);
	return symbol_ref(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
leaq -0xd0(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq 0x186d7(%rip), %rcx     # 0x28bc8
leaq 0x10b80(%rip), %rsi     # 0x21078
movb $0x0, %al
callq 0x3200
movq 0x186c2(%rip), %rax     # 0x28bc8
addq $0x1, %rax
movq %rax, 0x186b7(%rip)     # 0x28bc8
leaq -0xd0(%rbp), %rdi
callq 0x9330
cmpq $-0x1, %rax
jne 0x104df
leaq -0xd0(%rbp), %rdi
callq 0x9420
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: raise_expr
cell raise_expr(void) {
	cell	n;

	if (Token == TOK_RAISE) {
		Token = scan();
		if (Token != TOK_ID || !consname_p(Attr))
			return error("exception expected after 'raise'",
					NOEXPR);
		n = node(Attr, NIL);
		n = node(S_raise, n);
		Token = scan();
		return n;
	}
	else {
		return handle_expr();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0xffffff22, 0x1818e(%rip) # imm = 0xFFFFFF22
jne 0x105ee
callq 0xcc90
movl %eax, 0x1817d(%rip)     # 0x286e0
cmpl $0xfffffed1, 0x18173(%rip) # imm = 0xFFFFFED1
jne 0x10591
movq 0x18082(%rip), %rax     # 0x285f8
movq 0x18053(%rip), %rcx     # 0x285d0
movq 0x17be4(%rip), %rdx     # 0x28168
movq (%rcx,%rdx,8), %rcx
movsbl (%rax,%rcx,8), %eax
cmpl $0x3a, %eax
je 0x105aa
leaq 0x10365(%rip), %rdi     # 0x208fd
movq $-0x8, %rsi
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0x105f7
movq 0x17bb7(%rip), %rdi     # 0x28168
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq 0x1817e(%rip), %rdi     # 0x28748
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
callq 0xcc90
movl %eax, 0x180fc(%rip)     # 0x286e0
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x105f7
callq 0x102e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: ifexpr
cell ifexpr(void) {
	cell	n, c, p, a;

	if (Token == TOK_IF) {
		Token = scan();
		c = expr();
		if (Token != TOK_THEN)
			return error("missing 'then' after 'if'", NOEXPR);
		save(c);
		Token = scan();
		p = expr();
		if (Token != TOK_ELSE) {
			unsave(1);
			return error("missing 'else' after 'if'", NOEXPR);
		}
		save(p);
		Token = scan();
		a = expr();
		n = node(a, NIL);
		n = node(unsave(1), n);
		n = node(unsave(1), n);
		n = node(S_if, n);
		return n;
	}
	else {
		return raise_expr();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
cmpl $0xffffff2c, 0x180be(%rip) # imm = 0xFFFFFF2C
jne 0x1075e
callq 0xcc90
movl %eax, 0x180ad(%rip)     # 0x286e0
callq 0xd930
movq %rax, -0x18(%rbp)
cmpl $0xffffff20, 0x1809a(%rip) # imm = 0xFFFFFF20
je 0x10664
leaq 0x102cf(%rip), %rdi     # 0x2091e
movq $-0x8, %rsi
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0x10767
movq -0x18(%rbp), %rdi
movq 0x17ac9(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x17abb(%rip)     # 0x28138
callq 0xcc90
movl %eax, 0x18058(%rip)     # 0x286e0
callq 0xd930
movq %rax, -0x20(%rbp)
cmpl $0xffffff33, 0x18045(%rip) # imm = 0xFFFFFF33
je 0x106c3
movl $0x1, %edi
callq 0x3950
leaq 0x1028a(%rip), %rdi     # 0x20938
movq $-0x8, %rsi
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0x10767
movq -0x20(%rbp), %rdi
movq 0x17a6a(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x17a5c(%rip)     # 0x28138
callq 0xcc90
movl %eax, 0x17ff9(%rip)     # 0x286e0
callq 0xd930
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movl $0x1, %edi
callq 0x3950
movq %rax, %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movl $0x1, %edi
callq 0x3950
movq %rax, %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq 0x1800b(%rip), %rdi     # 0x28750
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10767
callq 0x10540
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: case_expr
cell case_expr(void) {
	cell	n, x;

	if (Token == TOK_CASE) {
		Token = scan();
		x = ifexpr();
		if (Token != TOK_OF)
			return error("missing 'of' in 'case'", NOEXPR);
		save(x);
		Token = scan();
		n = match(0);
		n = node(S_fn, n);
		Tmp = n;
		n = node(unsave(1), NIL);
		n = node(Tmp, n);
		Tmp = NIL;
		return n;
	}
	else {
		return ifexpr();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
cmpl $0xffffff35, 0x17f4e(%rip) # imm = 0xFFFFFF35
jne 0x1086e
callq 0xcc90
movl %eax, 0x17f3d(%rip)     # 0x286e0
callq 0x10610
movq %rax, -0x18(%rbp)
cmpl $0xffffff25, 0x17f2a(%rip) # imm = 0xFFFFFF25
je 0x107d4
leaq 0x10193(%rip), %rdi     # 0x20952
movq $-0x8, %rsi
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0x10877
movq -0x18(%rbp), %rdi
movq 0x17959(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x1794b(%rip)     # 0x28138
callq 0xcc90
movl %eax, 0x17ee8(%rip)     # 0x286e0
xorl %edi, %edi
callq 0xf110
movq %rax, -0x10(%rbp)
movq 0x17f0e(%rip), %rdi     # 0x28718
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0x178fc(%rip)     # 0x28120
movl $0x1, %edi
callq 0x3950
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq 0x178d6(%rip), %rdi     # 0x28120
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq $-0x1, 0x178bc(%rip) # 0x28120
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10877
callq 0x10610
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: extract_vars
void extract_vars(cell n) {
	cell	new;

	if (cons_p(n)) {
		extract_vars(cdr(n));
		extract_vars(car(n));
		return;
	}
	if (symbol_p(n)) {
		set(car(Stack), node(n, car(Stack)));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jl 0x108fb
movq 0x17d46(%rip), %rax     # 0x285f0
movq -0x8(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x108fb
movq 0x17d2f(%rip), %rax     # 0x285f0
movq -0x8(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x108fb
movq 0x17cf8(%rip), %rax     # 0x285d0
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10890
movq 0x17894(%rip), %rax     # 0x28180
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x10890
jmp 0x10962
cmpq $0x0, -0x8(%rbp)
jl 0x10962
movq 0x17ce7(%rip), %rax     # 0x285f0
movq -0x8(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x10962
movq 0x17860(%rip), %rax     # 0x28180
movq -0x8(%rbp), %rcx
cmpq $-0x22, (%rax,%rcx,8)
jne 0x10962
movq -0x8(%rbp), %rdi
movq 0x1784a(%rip), %rax     # 0x28180
movq 0x177fb(%rip), %rcx     # 0x28138
movq (%rax,%rcx,8), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movq 0x17829(%rip), %rax     # 0x28180
movq 0x177da(%rip), %rcx     # 0x28138
movq %rdx, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: make_defines
cell make_defines(cell p, cell def) {
	cell	v, n, new;

	save(NIL);
	extract_vars(p);
	for (v = car(Stack); v != NIL; v = cdr(v)) {
		n = node(car(v), NIL);	/* (define x x) */
		n = node(car(v), n);
		n = node(S_define, n);
		car(def) = n;
		if (cdr(v) != NIL) {
			set(cdr(def), cons(NIL, NIL));
			def = cdr(def);
		}
	}
	unsave(1);
	return def;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x177b1(%rip), %rsi     # 0x28138
movq $-0x1, %rdi
xorl %edx, %edx
callq 0x3780
movq %rax, 0x1779c(%rip)     # 0x28138
movq -0x8(%rbp), %rdi
callq 0x10890
movq 0x177d4(%rip), %rax     # 0x28180
movq 0x17785(%rip), %rcx     # 0x28138
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
je 0x10a98
movq 0x177b3(%rip), %rax     # 0x28180
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x20(%rbp)
movq 0x17792(%rip), %rax     # 0x28180
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x20(%rbp)
movq 0x17d64(%rip), %rdi     # 0x28770
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
movq 0x1775a(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x17b9b(%rip), %rax     # 0x285d0
movq -0x18(%rbp), %rcx
cmpq $-0x1, (%rax,%rcx,8)
je 0x10a7e
movq $-0x1, %rsi
movl $0x8, %edx
movq %rsi, %rdi
callq 0x3780
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
movq 0x17b6d(%rip), %rax     # 0x285d0
movq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x17b5e(%rip), %rax     # 0x285d0
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0x10a80
movq 0x17b49(%rip), %rax     # 0x285d0
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0x109bb
movl $0x1, %edi
callq 0x3950
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: local_decl
cell local_decl(void) {
	cell	d, x;

	Token = scan();
	d = decls(1);
	save(d);
	if (Token != TOK_IN) {
		unsave(1);
		return error("missing 'in' in 'local'", NOEXPR);
	}
	Token = scan();
	x = decls(0);
	save(x);
	if (Token != TOK_END) {
		unsave(2);
		return error("missing 'end' in 'local'", 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
subq $0x20, %rsp
callq 0xcc90
movl %eax, 0x16edd(%rip)     # 0x286e0
movl $0x1, %edi
callq 0x11580
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0x1691c(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x1690e(%rip)     # 0x28138
cmpl $0xffffff2b, 0x16eac(%rip) # imm = 0xFFFFFF2B
je 0x1185c
movl $0x1, %edi
callq 0x3950
leaq 0xf20a(%rip), %rdi      # 0x20a51
movq $-0x8, %rsi
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0x1199a
callq 0xcc90
movl %eax, 0x16e79(%rip)     # 0x286e0
xorl %edi, %edi
callq 0x11580
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq 0x168bb(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x168ad(%rip)     # 0x28138
cmpl $0xffffff32, 0x16e4b(%rip) # imm = 0xFFFFFF32
je 0x118bd
movl $0x2, %edi
callq 0x3950
leaq 0xf1c1(%rip), %rdi      # 0x20a69
movq $-0x8, %rsi
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0x1199a
callq 0xcc90
movl %eax, 0x16e18(%rip)     # 0x286e0
movl $0x1, %edi
callq 0x3950
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x18(%rbp)
movl $0x1, %edi
callq 0x3950
movq %rax, -0x10(%rbp)
movq 0x1687f(%rip), %rax     # 0x28180
movq 0x16878(%rip), %rcx     # 0x28180
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
cmpq 0x16e5d(%rip), %rax     # 0x28778
jne 0x11948
movq -0x18(%rbp), %rdx
movq 0x16ca8(%rip), %rax     # 0x285d0
movq 0x16ca1(%rip), %rcx     # 0x285d0
movq 0x1684a(%rip), %rsi     # 0x28180
movq -0x10(%rbp), %rdi
movq (%rsi,%rdi,8), %rsi
movq (%rcx,%rsi,8), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x11987
movq -0x18(%rbp), %rdx
movq 0x16c7d(%rip), %rax     # 0x285d0
movq 0x16826(%rip), %rcx     # 0x28180
movq 0x16c6f(%rip), %rsi     # 0x285d0
movq 0x16818(%rip), %rdi     # 0x28180
movq 0x16811(%rip), %r8      # 0x28180
movq -0x10(%rbp), %r9
movq (%r8,%r9,8), %r8
movq (%rdi,%r8,8), %rdi
movq (%rsi,%rdi,8), %rsi
movq (%rcx,%rsi,8), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x16c42(%rip), %rax     # 0x285d0
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: locate_op
cell locate_op(char *s) {
	cell	p, pp, n;

	pp = Ops;
	for (p = cdr(Ops); p != NIL; p = cdr(p)) {
		for (n = car(p); n != NIL; n = cdr(n)) {
			if (!strcmp(string(caar(n)), s))
				break;
		}
		if (n != NIL)
			break;
		pp = p;
	}
	return p == NIL? NIL: pp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq 0x1679d(%rip), %rax     # 0x28160
movq %rax, -0x18(%rbp)
movq 0x16c02(%rip), %rax     # 0x285d0
movq 0x1678b(%rip), %rcx     # 0x28160
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
cmpq $-0x1, -0x10(%rbp)
je 0x11a85
movq 0x16791(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
je 0x11a5c
movq 0x16bef(%rip), %rdi     # 0x285f8
movq 0x16bc0(%rip), %rax     # 0x285d0
movq 0x16769(%rip), %rcx     # 0x28180
movq 0x16762(%rip), %rdx     # 0x28180
movq -0x20(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x3120
cmpl $0x0, %eax
jne 0x11a45
jmp 0x11a5c
jmp 0x11a47
movq 0x16b82(%rip), %rax     # 0x285d0
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
jmp 0x119fb
cmpq $-0x1, -0x20(%rbp)
je 0x11a65
jmp 0x11a85
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x16b5c(%rip), %rax     # 0x285d0
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0x119dd
cmpq $-0x1, -0x10(%rbp)
jne 0x11a99
movq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x11aa1
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: delfixity
void delfixity(cell op) {
	cell	p;

	p = locate_op(symbol_name(op));
	if (p == NIL)
		return;
	cadr(p) = cdadr(p);
	if (cadr(p) == NIL)
		cdr(p) = cddr(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x16b35(%rip), %rdi     # 0x285f8
movq 0x16b06(%rip), %rax     # 0x285d0
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
shlq $0x3, %rax
addq %rax, %rdi
callq 0x119b0
movq %rax, -0x10(%rbp)
cmpq $-0x1, -0x10(%rbp)
jne 0x11aee
jmp 0x11b73
movq 0x16adb(%rip), %rax     # 0x285d0
movq 0x16684(%rip), %rcx     # 0x28180
movq 0x16acd(%rip), %rdx     # 0x285d0
movq -0x10(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x16666(%rip), %rax     # 0x28180
movq 0x16aaf(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rsi
movq (%rcx,%rsi,8), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x1664c(%rip), %rax     # 0x28180
movq 0x16a95(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq $-0x1, (%rax,%rcx,8)
jne 0x11b73
movq 0x16a7f(%rip), %rax     # 0x285d0
movq 0x16a78(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x16a65(%rip), %rax     # 0x285d0
movq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)