LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: block_comment
void block_comment(void) {
	int	n = 1;
	int	c, p = 0;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %r12d, %r12d
pushq $0x1
popq %rbx
leaq 0x1348b(%rip), %r14     # 0x1c180
movl %ebx, %r15d
movslq 0x13999(%rip), %rax     # 0x1c698
movq (%r14,%rax,8), %rdi
callq 0x3220
testl %r15d, %r15d
je 0x8d54
cmpl $0x0, 0x138a0(%rip)     # 0x1c5b4
jne 0x8d54
cmpl $0xa, %eax
je 0x8d33
cmpl $-0x1, %eax
je 0x8d5d
movl %eax, %ecx
xorl $0x2a, %ecx
movl %r12d, %edx
xorl $0x28, %edx
orl %ecx, %edx
movl %ebx, %ecx
jne 0x8d39
jmp 0x8d4c
incl 0x13897(%rip)           # 0x1c5d0
movl %eax, %edx
xorl $0x29, %edx
xorl $0x2a, %r12d
xorl %ecx, %ecx
orl %edx, %r12d
sete %cl
negl %ecx
addl %ecx, %r15d
movl %eax, %r12d
jmp 0x8cf8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb997(%rip), %rdi      # 0x146fb
pushq $-0x8
popq %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x33e4
// File: /workspace/github_c_makefile_star2_O2/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, 0x131fb(%rip) # imm = 0xFFFFFED1
jne 0x9548
movq 0x1310a(%rip), %rax     # 0x1c5e8
movq 0x130db(%rip), %rcx     # 0x1c5c0
movq 0x12c6c(%rip), %rdi     # 0x1c158
movq (%rcx,%rdi,8), %rcx
cmpb $0x3a, (%rax,%rcx,8)
jne 0x9548
movq 0x12c2b(%rip), %rsi     # 0x1c128
xorl %edx, %edx
callq 0x3613
movq %rax, 0x12c1d(%rip)     # 0x1c128
callq 0x8d74
movl %eax, 0x131ba(%rip)     # 0x1c6d0
cmpl $0xfffffed1, %eax       # imm = 0xFFFFFED1
jne 0x9558
movq 0x12c34(%rip), %rax     # 0x1c158
cmpq 0x131cd(%rip), %rax     # 0x1c6f8
jne 0x9558
pushq $0x1
popq %rdi
callq 0x3775
pushq $-0x1
popq %rsi
movq %rax, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3613
movl $0xffffff23, %edi       # imm = 0xFFFFFF23
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa25b
callq 0x973d
movq %rax, %rbx
movq %rax, 0x12ba9(%rip)     # 0x1c110
movq 0x12c02(%rip), %rax     # 0x1c170
movq (%rax,%rbx,8), %rdi
testq %rdi, %rdi
js 0x9584
movq 0x13062(%rip), %rax     # 0x1c5e0
testb $0x19, (%rax,%rdi)
je 0x95ad
pushq $-0x1
popq %rsi
xorl %edx, %edx
callq 0x3613
movq 0x1302b(%rip), %rcx     # 0x1c5c0
movq (%rcx,%rbx,8), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, %rbx
movq %rax, 0x12b63(%rip)     # 0x1c110
pushq $0x1
popq %rdi
callq 0x3775
movq 0x12bb4(%rip), %rcx     # 0x1c170
movq (%rcx,%rbx,8), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq 0x12fef(%rip), %rcx     # 0x1c5c0
movq 0x12b38(%rip), %rdx     # 0x1c110
movq (%rcx,%rdx,8), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
orq $-0x1, 0x12b22(%rip)    # 0x1c110
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb44e
movl 0x130c9(%rip), %ecx     # 0x1c6d0
addl $0x6d, %ecx
cmpl $0x2, %ecx
jae 0x968a
movq 0x12b12(%rip), %rsi     # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x12b01(%rip)     # 0x1c128
movl 0x130a2(%rip), %r14d    # 0x1c6d0
callq 0x8d74
movl %eax, 0x13097(%rip)     # 0x1c6d0
callq 0x95f5
pushq $-0x1
popq %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, %rbx
pushq $0x1
popq %rdi
callq 0x3775
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3613
cmpl $-0x6c, %r14d
leaq 0x130da(%rip), %rcx     # 0x1c748
leaq 0x130db(%rip), %rdx     # 0x1c750
cmoveq %rcx, %rdx
movq (%rdx), %rdi
movq %rax, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x3613
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $-0x1
popq %rbx
movq %rbx, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %r14
movq 0x12a78(%rip), %rsi     # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x12a67(%rip)     # 0x1c128
callq 0x95f5
movq 0x12aa3(%rip), %rcx     # 0x1c170
movq %rax, (%rcx,%r14,8)
cmpl $-0x65, 0x12ff8(%rip)   # 0x1c6d0
jne 0x9702
callq 0x8d74
movl %eax, 0x12feb(%rip)     # 0x1c6d0
movq %rbx, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3613
movq 0x12ec7(%rip), %rcx     # 0x1c5c0
movq %rax, (%rcx,%r14,8)
movq %rax, %r14
jmp 0x96c1
pushq $0x1
popq %rdi
callq 0x3775
movq 0x12eaf(%rip), %rcx     # 0x1c5c0
cmpq $-0x1, (%rcx,%rax,8)
je 0x972d
movq 0x13039(%rip), %rdi     # 0x1c758
movq %rax, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x3613
movq 0x12a3c(%rip), %rcx     # 0x1c170
movq (%rcx,%rax,8), %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xc1f3(%rip), %xmm0     # 0x15940
movaps %xmm0, -0x20(%rbp)
movaps 0xc1d8(%rip), %xmm0     # 0x15930
movaps %xmm0, -0x30(%rbp)
movaps 0xc1bd(%rip), %xmm0     # 0x15920
movaps %xmm0, -0x40(%rbp)
movb $0x0, -0x10(%rbp)
movl 0x12f5f(%rip), %ebx     # 0x1c6d0
leal 0x130(%rbx), %eax
cmpl $0x5, %eax
jae 0x97be
movq 0x129d5(%rip), %rdi     # 0x1c158
movq 0x1299e(%rip), %rsi     # 0x1c128
xorl %edx, %edx
callq 0x3613
movq %rax, 0x12990(%rip)     # 0x1c128
callq 0x8d74
movl %eax, 0x12f2d(%rip)     # 0x1c6d0
pushq $0x1
popq %rdi
callq 0x3775
pushq $-0x1
popq %rsi
movq %rax, %rdi
xorl %edx, %edx
addq $0x38, %rsp
popq %rbx
popq %rbp
jmp 0x3613
cmpl $-0x6a, %ebx
je 0x97e4
cmpl $-0x68, %ebx
je 0x97e4
cmpl $-0x67, %ebx
jne 0x9839
callq 0x8d74
movl %eax, 0x12ef8(%rip)     # 0x1c6d0
movq 0x12eb1(%rip), %rdi     # 0x1c690
pushq $-0x1
popq %rsi
jmp 0x97b1
callq 0x8d74
movl %eax, 0x12ee1(%rip)     # 0x1c6d0
xorl %edi, %edi
cmpl $-0x6a, %ebx
sete %dil
callq 0x9a86
movq 0x1296c(%rip), %rcx     # 0x1c170
movq (%rcx,%rax,8), %rdx
cmpq $-0x6, %rdx
je 0x9863
cmpq $-0x1, %rdx
je 0x9863
cmpl $-0x68, %ebx
jne 0x9863
movq 0x12da0(%rip), %rsi     # 0x1c5c0
cmpq $-0x1, (%rsi,%rdx,8)
jne 0x9863
cmpl $0x0, 0x12eb2(%rip)     # 0x1c6e0
jle 0x986a
leaq -0x40(%rbp), %rdi
pushq $-0x8
popq %rsi
jmp 0x985b
cmpl $0x0, 0x12d74(%rip)     # 0x1c5b4
jne 0x984d
callq 0x8d74
movl %eax, 0x12e83(%rip)     # 0x1c6d0
movq 0x12904(%rip), %rsi     # 0x1c158
leaq 0xaf37(%rip), %rdi      # 0x14792
callq 0x33e4
pushq $-0x5
popq %rax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
movq (%rcx,%rdx,8), %rdi
movq (%rsi,%rax,8), %rsi
jmp 0x97b1
// File: /workspace/github_c_makefile_star2_O2/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, %ebx
movl 0x12c4b(%rip), %eax     # 0x1c6e0
testl %eax, %eax
jne 0x9acb
pushq $-0x1
popq %rdi
movq %rdi, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x12c2b(%rip)     # 0x1c6d8
movq 0x12674(%rip), %rsi     # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x12663(%rip)     # 0x1c128
movl 0x12c15(%rip), %eax     # 0x1c6e0
incl %eax
movl %eax, 0x12c0d(%rip)     # 0x1c6e0
pushq $0x1
popq %rdi
movl %ebx, %esi
callq 0x9184
movq %rax, %r14
testl %ebx, %ebx
je 0x9af8
cmpq $-0x1, %r14
je 0x9af8
cmpq $-0x6, %r14
je 0x9af8
movq %r14, %rdi
callq 0x9b92
decl 0x12be2(%rip)           # 0x1c6e0
je 0x9b08
pushq $-0x1
popq %rsi
movq %r14, %rdi
jmp 0x9b87
pushq $0x1
popq %rdi
callq 0x3775
movq %rax, 0x12bc1(%rip)     # 0x1c6d8
movq 0x1260a(%rip), %rsi     # 0x1c128
movq %r14, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x125f9(%rip)     # 0x1c128
movq 0x12a8a(%rip), %rax     # 0x1c5c0
movq 0x12b9b(%rip), %rcx     # 0x1c6d8
movq (%rax,%rcx,8), %rsi
cmpq $-0x1, %rsi
je 0x9b5e
cmpq $-0x1, (%rax,%rsi,8)
je 0x9b63
movq 0x12b93(%rip), %rdi     # 0x1c6e8
xorl %edx, %edx
callq 0x3613
jmp 0x9b6e
pushq $-0x1
popq %rax
jmp 0x9b6e
movq 0x12606(%rip), %rax     # 0x1c170
movq (%rax,%rsi,8), %rax
movq %rax, 0x12b63(%rip)     # 0x1c6d8
pushq $0x1
popq %rdi
callq 0x3775
movq 0x12b54(%rip), %rsi     # 0x1c6d8
movq %rax, %rdi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x3613
// File: /workspace/github_c_makefile_star2_O2/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, %rax
movq %rdi, %rcx
cmpq $-0x1, %rcx
je 0x9bba
movq 0x12a37(%rip), %rdx     # 0x1c5e0
orb $0x8, (%rdx,%rcx)
movq 0x12a0c(%rip), %rdx     # 0x1c5c0
movq (%rdx,%rcx,8), %rcx
jmp 0x9b9c
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: pat_funapp
cell pat_funapp(int k) {
	cell	n, m, p, f, x;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
callq 0x973d
movq %rax, %r15
testl %ebx, %ebx
je 0x9d16
pushq $0x2
popq %r14
movl 0x12aea(%rip), %eax     # 0x1c6d0
leal 0x130(%rax), %ecx
cmpl $0x5, %ecx
jae 0x9c4a
movq 0x12560(%rip), %rdi     # 0x1c158
callq 0x8977
testl %eax, %eax
jne 0x9d16
cmpl $-0x67, 0x12ac4(%rip)   # 0x1c6d0
je 0x9d16
testq %r15, %r15
js 0x9c60
movq 0x129c2(%rip), %rax     # 0x1c5e0
testb $0x1, (%rax,%r15)
je 0x9c6e
movq 0x12544(%rip), %rax     # 0x1c170
movq (%rax,%r15,8), %rax
addq $0x1f, %rax
cmpq $0x9, %rax
ja 0x9c6e
movl $0x281, %ecx            # imm = 0x281
btq %rax, %rcx
jae 0x9c6e
jmp 0x9d16
cmpl $0xffffff24, %eax       # imm = 0xFFFFFF24
je 0x9bf1
cmpl $-0x68, %eax
je 0x9bf1
cmpl $-0x6a, %eax
je 0x9bf1
jmp 0x9d16
leaq 0x1(%r15), %rax
cmpq $-0x3, %rax
ja 0x9d16
movq 0x124b3(%rip), %rsi     # 0x1c128
movq %r15, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x124a2(%rip)     # 0x1c128
callq 0x973d
movq %rax, %r13
movq 0x124db(%rip), %rax     # 0x1c170
movq (%rax,%r13,8), %r12
movq 0x12488(%rip), %rsi     # 0x1c128
movq %r12, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x12477(%rip)     # 0x1c128
movq 0x12908(%rip), %rax     # 0x1c5c0
movq (%rax,%r15,8), %rbx
cmpq $-0x1, %rbx
jne 0x9ccd
movq 0x124a7(%rip), %rcx     # 0x1c170
movq (%rcx,%r15,8), %rbx
movq (%rax,%r13,8), %rdi
cmpq $-0x1, %rdi
jne 0x9ce2
movq 0x12492(%rip), %rax     # 0x1c170
movq (%rax,%r13,8), %rdi
pushq $-0x1
popq %rsi
xorl %edx, %edx
callq 0x3613
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq %r12, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %r15
movl %r14d, %edi
callq 0x3775
jmp 0x9be0
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x94c3
testq %rax, %rax
js 0xa469
movq 0x1218b(%rip), %rcx     # 0x1c5e0
testb $0x11, (%rcx,%rax)
jne 0xa469
movq 0x1215e(%rip), %rcx     # 0x1c5c0
cmpq $-0x1, (%rcx,%rax,8)
je 0xa477
pushq $-0x9
popq %rdi
movq %rax, %rsi
xorl %edx, %edx
popq %rbp
jmp 0x3613
movq 0x11cf2(%rip), %rcx     # 0x1c170
movq (%rcx,%rax,8), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movl %edi, %ebx
cmpl $0xffffff38, %edi       # imm = 0xFFFFFF38
jne 0xa7ba
movl %r14d, %edi
callq 0xb021
jmp 0xa7c7
movl $0xffffff38, %edi       # imm = 0xFFFFFF38
movl %r14d, %esi
callq 0xa795
pushq $-0x1
popq %r15
movq %rax, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %r12
movq 0x11946(%rip), %rsi     # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x11935(%rip)     # 0x1c128
cmpl %ebx, 0x11ed7(%rip)     # 0x1c6d0
jne 0xa850
callq 0x8d74
movl %eax, 0x11eca(%rip)     # 0x1c6d0
movq %r15, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %r13
movq 0x11da3(%rip), %rax     # 0x1c5c0
movq %r13, (%rax,%r12,8)
cmpl $0xffffff38, %ebx       # imm = 0xFFFFFF38
jne 0xa833
movl %r14d, %edi
callq 0xb021
jmp 0xa840
movl $0xffffff38, %edi       # imm = 0xFFFFFF38
movl %r14d, %esi
callq 0xa795
movq 0x11929(%rip), %rcx     # 0x1c170
movq %rax, (%rcx,%r13,8)
movq %r13, %r12
jmp 0xa7f3
pushq $0x1
popq %rdi
callq 0x3775
movq 0x11d61(%rip), %rcx     # 0x1c5c0
cmpq $-0x1, (%rcx,%rax,8)
je 0xa899
cmpl $0xffffff23, %ebx       # imm = 0xFFFFFF23
leaq 0x11e8d(%rip), %rcx     # 0x1c700
leaq 0x11e6e(%rip), %rdx     # 0x1c6e8
cmoveq %rcx, %rdx
movq (%rdx), %rdi
movq %rax, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3613
movq 0x118d0(%rip), %rcx     # 0x1c170
movq (%rcx,%rax,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: 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
pushq %rbx
pushq %rax
movq 0x11898(%rip), %rdi     # 0x1c158
movq 0x11861(%rip), %rsi     # 0x1c128
xorl %edx, %edx
callq 0x3613
movq %rax, 0x11853(%rip)     # 0x1c128
callq 0x8d74
movl %eax, 0x11df0(%rip)     # 0x1c6d0
callq 0x9877
testq %rax, %rax
js 0xa8fe
movq 0x11cef(%rip), %rcx     # 0x1c5e0
movb (%rcx,%rax), %cl
testb $0x10, %cl
jne 0xa923
testb $0x9, %cl
je 0xa931
pushq $0x1
popq %rdi
callq 0x3775
movq 0x1184b(%rip), %rsi     # 0x1c158
leaq 0x9eee(%rip), %rdi      # 0x14802
callq 0x33e4
pushq $-0x5
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x11846(%rip), %rcx     # 0x1c170
cmpq $-0x22, (%rcx,%rax,8)
jne 0xa8fe
movq %rax, 0x117d8(%rip)     # 0x1c110
pushq $0x1
popq %rdi
callq 0x3775
pushq $-0x1
popq %rbx
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3613
movq 0x117b9(%rip), %rdi     # 0x1c110
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
orq $-0x1, 0x117a7(%rip)    # 0x1c110
movq 0x11d80(%rip), %rdi     # 0x1c6f0
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3613
movq 0x11d82(%rip), %rdi     # 0x1c710
movq %rax, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3613
// File: /workspace/github_c_makefile_star2_O2/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 0x11d04(%rip), %ecx     # 0x1c6d0
leal 0xe2(%rcx), %eax
cmpl $0x12, %eax
ja 0xa9ef
leaq 0x96d2(%rip), %rcx      # 0x140b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl %edi, %edi
popq %rbp
jmp 0xb661
cmpl $-0x4, %ecx
jne 0xaa00
movabsq $-0x4, %rax
popq %rbp
retq
popq %rbp
jmp 0x95f5
popq %rbp
jmp 0xc4ef
xorl %edi, %edi
popq %rbp
jmp 0xb920
xorl %edi, %edi
jmp 0xaa30
popq %rbp
jmp 0xbb4c
movl $0x2, %edi
jmp 0xaa30
popq %rbp
jmp 0xbf7c
movl $0x1, %edi
popq %rbp
jmp 0xc2d2
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: let_expr
cell let_expr(void) {
	cell	d, x;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
callq 0x8d74
movl %eax, 0x11c88(%rip)     # 0x1c6d0
pushq $0x1
popq %rdi
callq 0xbe09
movq 0x116d1(%rip), %rsi     # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x116c0(%rip)     # 0x1c128
cmpl $0xffffff2b, 0x11c5e(%rip) # imm = 0xFFFFFF2B
jne 0xab00
callq 0x8d74
movl %eax, 0x11c4d(%rip)     # 0x1c6d0
callq 0x968f
movq 0x11699(%rip), %rsi     # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x11688(%rip)     # 0x1c128
cmpl $0xffffff32, 0x11c26(%rip) # imm = 0xFFFFFF32
jne 0xab11
callq 0x8d74
movl %eax, 0x11c19(%rip)     # 0x1c6d0
pushq $0x1
popq %r14
movl %r14d, %edi
callq 0x3775
pushq $-0x1
popq %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, %rbx
movl %r14d, %edi
callq 0x3775
movq 0x1168e(%rip), %rdx     # 0x1c170
movq (%rdx,%rax,8), %rsi
movq (%rdx,%rsi,8), %rdi
movq 0x11acf(%rip), %rcx     # 0x1c5c0
cmpq 0x11c70(%rip), %rdi     # 0x1c768
jne 0xab2d
leaq (%rcx,%rsi,8), %rdx
jmp 0xab35
pushq $0x1
popq %rdi
callq 0x3775
leaq 0x9e4a(%rip), %rdi      # 0x14959
jmp 0xab20
pushq $0x2
popq %rdi
callq 0x3775
leaq 0x9e4f(%rip), %rdi      # 0x1496f
pushq $-0x8
popq %rsi
callq 0x33e4
pushq $-0x5
popq %rax
jmp 0xab40
movq (%rcx,%rdi,8), %rsi
leaq (%rdx,%rsi,8), %rdx
movq (%rdx), %rdx
movq %rbx, (%rcx,%rdx,8)
movq (%rcx,%rax,8), %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: funapp
cell funapp(void) {
	cell	n, m;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
callq 0x9877
movq %rax, %r15
pushq $-0x1
popq %rbx
pushq $0x1
popq %r14
movl $0x281, %r12d           # imm = 0x281
movl 0x11b65(%rip), %eax     # 0x1c6d0
leal 0x130(%rax), %ecx
cmpl $0x5, %ecx
jae 0xabc7
movq 0x115db(%rip), %rdi     # 0x1c158
callq 0x8977
testl %eax, %eax
jne 0xac35
cmpl $-0x67, 0x11b3f(%rip)   # 0x1c6d0
je 0xac35
testq %r15, %r15
js 0xabe1
movq 0x11a3d(%rip), %rax     # 0x1c5e0
testb $0x1, (%rax,%r15)
je 0xabeb
movq 0x115bf(%rip), %rax     # 0x1c170
movq (%rax,%r15,8), %rax
addq $0x1f, %rax
cmpq $0x9, %rax
ja 0xabeb
btq %rax, %r12
jae 0xabeb
jmp 0xac35
cmpl $0xffffff21, %eax       # imm = 0xFFFFFF21
je 0xab76
cmpl $0xffffff24, %eax       # imm = 0xFFFFFF24
je 0xab76
cmpl $-0x68, %eax
je 0xab76
cmpl $-0x6a, %eax
je 0xab76
jmp 0xac35
leaq 0x1(%r15), %rax
cmpq $-0x3, %rax
ja 0xac35
movq 0x11536(%rip), %rsi     # 0x1c128
movq %r15, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x11525(%rip)     # 0x1c128
callq 0x9877
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %r15
movl %r14d, %edi
callq 0x3775
movq %rax, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %r15
jmp 0xab65
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: commit
void commit(char *s, int all) {
	int	tp = 0, ta = LEFT, sp = 0, sa;
	cell	n;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq -0x3c(%rbp), %r15
andl $0x0, (%r15)
movl %esi, %ebx
leaq -0x38(%rbp), %r12
movl $0x1, (%r12)
leaq -0x30(%rbp), %r14
andl $0x0, (%r14)
movq %r15, %rsi
movq %r12, %rdx
callq 0x88b3
movl (%r15), %r13d
movl (%r12), %eax
movq 0x114e7(%rip), %rcx     # 0x1c170
leaq -0x34(%rbp), %r15
xorl $0x2, %eax
movl %eax, -0x2c(%rbp)
pushq $-0x1
popq %r12
movq 0x1148a(%rip), %rax     # 0x1c128
movq (%rcx,%rax,8), %rax
cmpq $-0x1, %rax
je 0xadd8
movq 0x1190d(%rip), %rdx     # 0x1c5c0
movq (%rcx,%rax,8), %rax
movq (%rdx,%rax,8), %rdi
shlq $0x3, %rdi
addq 0x11922(%rip), %rdi     # 0x1c5e8
movq %r14, %rsi
movq %r15, %rdx
callq 0x88b3
testl %ebx, %ebx
jne 0xacf4
movl -0x30(%rbp), %ecx
movl %r13d, %eax
xorl %ecx, %eax
orl -0x2c(%rbp), %eax
sete %al
cmpl %ecx, %r13d
jg 0xadd8
testb %al, %al
jne 0xadd8
movq 0x11475(%rip), %rax     # 0x1c170
movq 0x118be(%rip), %rcx     # 0x1c5c0
movq 0x1141f(%rip), %rdx     # 0x1c128
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rcx
movq (%rax,%rcx,8), %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x3613
movq 0x1189a(%rip), %rcx     # 0x1c5c0
movq 0x11443(%rip), %rdx     # 0x1c170
movq 0x113f4(%rip), %rsi     # 0x1c128
movq (%rcx,%rsi,8), %rsi
movq (%rdx,%rsi,8), %rdi
movq (%rcx,%rdi,8), %rdi
movq %rdi, (%rdx,%rsi,8)
movq 0x113dd(%rip), %rsi     # 0x1c128
movq (%rcx,%rsi,8), %rcx
movq (%rdx,%rcx,8), %rcx
movq (%rdx,%rcx,8), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq 0x11988(%rip), %rdi     # 0x1c6f0
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x3613
movq 0x113ea(%rip), %rcx     # 0x1c170
movq 0x1139b(%rip), %rdx     # 0x1c128
movq (%rcx,%rdx,8), %rdx
movq (%rcx,%rdx,8), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq 0x1181a(%rip), %rdx     # 0x1c5c0
movq 0x113c3(%rip), %rcx     # 0x1c170
movq 0x11374(%rip), %rsi     # 0x1c128
movq (%rcx,%rsi,8), %rdi
movq (%rdx,%rdi,8), %rdi
movq %rdi, (%rcx,%rsi,8)
movq 0x11361(%rip), %rsi     # 0x1c128
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rdx
movq %rax, (%rcx,%rdx,8)
jmp 0xac97
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: apply_op
cell apply_op(int k) {
	cell	n;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebx
callq 0xade7
pushq $-0x1
popq %r14
pushq $0x1
popq %r15
cmpl $0xffffff36, 0x1168b(%rip) # imm = 0xFFFFFF36
jne 0xb098
movq 0x110da(%rip), %rsi     # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x110c9(%rip)     # 0x1c128
callq 0x8d74
movl %eax, 0x11666(%rip)     # 0x1c6d0
movl %ebx, %edi
callq 0xb021
movq %rax, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %r12
movl %r15d, %edi
callq 0x3775
movq %rax, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x3613
jmp 0xb03b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
pushq $0x1
popq %rsi
movl $0xffffff23, %edi       # imm = 0xFFFFFF23
callq 0xa795
movq %rax, %r14
cmpl $0xffffff2d, 0x1160e(%rip) # imm = 0xFFFFFF2D
jne 0xb21b
movq 0x11059(%rip), %rsi     # 0x1c128
movq %r14, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x11048(%rip)     # 0x1c128
callq 0x8d74
movl %eax, 0x115e5(%rip)     # 0x1c6d0
pushq $-0x1
popq %rbx
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3613
movq 0x1161e(%rip), %rdi     # 0x1c720
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3613
movq 0x11008(%rip), %rsi     # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x10ff7(%rip)     # 0x1c128
leaq 0x9f94(%rip), %rdi      # 0x150cc
callq 0xb223
movq %rax, %r14
movq 0x10fe1(%rip), %rsi     # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x10fd0(%rip)     # 0x1c128
xorl %edi, %edi
callq 0xa484
movq 0x115a2(%rip), %rdi     # 0x1c708
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3613
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq 0x11597(%rip), %rdi     # 0x1c728
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq 0x10fce(%rip), %rcx     # 0x1c170
movq 0x11417(%rip), %rdx     # 0x1c5c0
movq 0x10f78(%rip), %rsi     # 0x1c128
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3613
movq 0x11525(%rip), %rdi     # 0x1c708
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3613
movq 0x1152f(%rip), %rdi     # 0x1c730
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %rbx
pushq $0x3
popq %rdi
callq 0x3775
movq %rbx, %rax
jmp 0xb21e
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
movq 0x11979(%rip), %r12     # 0x1cbb8
leaq 0x9d39(%rip), %r14      # 0x14f7f
leaq -0xf0(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x31f0
movq 0x11951(%rip), %r12     # 0x1cbb8
incq %r12
movq %r12, 0x11947(%rip)     # 0x1cbb8
movq %r15, %rdi
callq 0x6955
cmpq $-0x1, %rax
jne 0xb24d
leaq -0xf0(%rbp), %rdi
callq 0x69ff
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: 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
pushq %rbx
pushq %rax
cmpl $0xffffff22, 0x11425(%rip) # imm = 0xFFFFFF22
jne 0xb30c
callq 0x8d74
movl %eax, 0x11418(%rip)     # 0x1c6d0
cmpl $0xfffffed1, %eax       # imm = 0xFFFFFED1
jne 0xb317
movq 0x11322(%rip), %rax     # 0x1c5e8
movq 0x112f3(%rip), %rcx     # 0x1c5c0
movq 0x10e84(%rip), %rdi     # 0x1c158
movq (%rcx,%rdi,8), %rcx
cmpb $0x3a, (%rax,%rcx,8)
jne 0xb317
pushq $-0x1
popq %rsi
xorl %edx, %edx
callq 0x3613
movq 0x11449(%rip), %rdi     # 0x1c738
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %rbx
callq 0x8d74
movl %eax, 0x113c9(%rip)     # 0x1c6d0
movq %rbx, %rax
jmp 0xb329
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xb0a1
leaq 0x9514(%rip), %rdi      # 0x14832
pushq $-0x8
popq %rsi
callq 0x33e4
pushq $-0x5
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
cmpl $0xffffff2c, 0x1138f(%rip) # imm = 0xFFFFFF2C
jne 0xb41d
callq 0x8d74
movl %eax, 0x1137e(%rip)     # 0x1c6d0
callq 0x95f5
cmpl $0xffffff20, 0x1136f(%rip) # imm = 0xFFFFFF20
jne 0xb426
movq 0x10dba(%rip), %rsi     # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x10da9(%rip)     # 0x1c128
callq 0x8d74
movl %eax, 0x11346(%rip)     # 0x1c6d0
callq 0x95f5
cmpl $0xffffff33, 0x11337(%rip) # imm = 0xFFFFFF33
jne 0xb42f
movq 0x10d82(%rip), %rsi     # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x10d71(%rip)     # 0x1c128
callq 0x8d74
movl %eax, 0x1130e(%rip)     # 0x1c6d0
callq 0x95f5
pushq $-0x1
popq %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, %rbx
pushq $0x1
popq %r14
movl %r14d, %edi
callq 0x3775
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %rbx
movl %r14d, %edi
callq 0x3775
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3613
movq 0x11331(%rip), %rdi     # 0x1c740
movq %rax, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x3613
popq %rbx
popq %r14
popq %rbp
jmp 0xb29b
leaq 0x9426(%rip), %rdi      # 0x14853
jmp 0xb43e
pushq $0x1
popq %rdi
callq 0x3775
leaq 0x942f(%rip), %rdi      # 0x1486d
pushq $-0x8
popq %rsi
callq 0x33e4
pushq $-0x5
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
cmpl $0xffffff35, 0x11274(%rip) # imm = 0xFFFFFF35
jne 0xb4f0
callq 0x8d74
movl %eax, 0x11263(%rip)     # 0x1c6d0
callq 0xb330
cmpl $0xffffff25, 0x11254(%rip) # imm = 0xFFFFFF25
jne 0xb4f6
movq 0x10ca3(%rip), %rsi     # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x10c92(%rip)     # 0x1c128
callq 0x8d74
movl %eax, 0x1122f(%rip)     # 0x1c6d0
xorl %edi, %edi
callq 0xa484
movq 0x11259(%rip), %rdi     # 0x1c708
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x10c50(%rip)     # 0x1c110
pushq $0x1
popq %rdi
callq 0x3775
pushq $-0x1
popq %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq 0x10c34(%rip), %rdi     # 0x1c110
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
orq $-0x1, 0x10c22(%rip)    # 0x1c110
jmp 0xb508
popq %rbp
jmp 0xb330
leaq 0x938a(%rip), %rdi      # 0x14887
pushq $-0x8
popq %rsi
callq 0x33e4
pushq $-0x5
popq %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: 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
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rbx, %rbx
js 0xb57c
movq 0x110c1(%rip), %rax     # 0x1c5e0
movb (%rax,%rbx), %al
testb $0x11, %al
jne 0xb543
movq 0x11093(%rip), %rax     # 0x1c5c0
movq (%rax,%rbx,8), %rdi
callq 0xb50a
movq 0x10c33(%rip), %rax     # 0x1c170
movq (%rax,%rbx,8), %rbx
jmp 0xb513
testb $0x10, %al
je 0xb57c
movq 0x10c22(%rip), %rax     # 0x1c170
cmpq $-0x22, (%rax,%rbx,8)
jne 0xb57c
movq 0x10bcc(%rip), %rcx     # 0x1c128
movq (%rax,%rcx,8), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3613
movq 0x10bff(%rip), %rcx     # 0x1c170
movq 0x10bb0(%rip), %rdx     # 0x1c128
movq %rax, (%rcx,%rdx,8)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10b8d(%rip), %rsi     # 0x1c128
pushq $-0x1
popq %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x10b78(%rip)     # 0x1c128
movq %r15, %rdi
callq 0xb50a
movq 0x10b69(%rip), %rax     # 0x1c128
shlq $0x3, %rax
addq 0x10ba6(%rip), %rax     # 0x1c170
pushq $0x8
popq %r15
movq (%rax), %r12
cmpq $-0x1, %r12
je 0xb64d
movq 0x10b92(%rip), %rax     # 0x1c170
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3613
movq 0x10b7d(%rip), %rcx     # 0x1c170
movq (%rcx,%r12,8), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq 0x11158(%rip), %rdi     # 0x1c760
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq 0x10b57(%rip), %rcx     # 0x1c170
movq %rax, (%rcx,%rbx,8)
movq 0x10f9c(%rip), %rcx     # 0x1c5c0
cmpq $-0x1, (%rcx,%r12,8)
je 0xb647
movq %r14, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x3613
movq 0x10f80(%rip), %rcx     # 0x1c5c0
movq %rax, (%rcx,%rbx,8)
movq %rax, %rbx
leaq (%rcx,%r12,8), %rax
jmp 0xb5ce
pushq $0x1
popq %rdi
callq 0x3775
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: decls
cell decls(int local) {
	cell	d, ds, new;
	char	*msg;

	msg = "expected declaration in 'let' or 'local'";
	ds = NIL;
	save(ds);
	for (;;) {
		switch (Token) {
		case TOK_VAL:	d = val_decl(local); break;
		case TOK_FUN:	d = fun_decl(local); break;
		default:	unsave(1);
				return error(msg, NOEXPR);
		}
		if (local) {
			if (ds == NIL) {
				ds = car(Stack) = d;
			}
			else {
				if (car(ds) == S_letrec) {
					set(cddr(ds), node(d, NIL));
				}
				else {
					set(cdadar(ds), node(d, NIL));
				}
				ds = d;
			}
		}
		else {
			if (ds == NIL) {
				set(ds, node(d, NIL));
				car(Stack) = ds;
			}
			else {
				set(cdr(ds), node(d, NIL));
			}
		}
		if (Token != TOK_SEMI)
			break;
		Token = scan();
	}
	if (!local) {
		ds = unsave(1);
		if (cdr(ds) == NIL)
			return car(ds);
		return node(S_begin, ds);
	}
	return node(ds, unsave(1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0x10308(%rip), %rsi     # 0x1c128
pushq $-0x1
popq %r12
movq %r12, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x102f3(%rip)     # 0x1c128
movl 0x10895(%rip), %eax     # 0x1c6d0
cmpl $0xffffff2e, %eax       # imm = 0xFFFFFF2E
je 0xbe56
cmpl $0xffffff1e, %eax       # imm = 0xFFFFFF1E
jne 0xbf19
movl %ebx, %edi
callq 0xb661
jmp 0xbe5d
movl %ebx, %edi
callq 0xb920
movq %rax, %r15
testl %ebx, %ebx
je 0xbe9b
movq 0x10305(%rip), %rax     # 0x1c170
cmpq $-0x1, %r12
je 0xbee1
movq (%rax,%r12,8), %r13
movq 0x108ec(%rip), %r14     # 0x1c768
movq %r15, %rdi
pushq $-0x1
popq %rsi
xorl %edx, %edx
callq 0x3613
movq 0x10730(%rip), %rcx     # 0x1c5c0
cmpq %r14, %r13
jne 0xbec1
movq (%rcx,%r12,8), %rdx
jmp 0xbed4
movq %r15, %rdi
pushq $-0x1
popq %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %r15
cmpq $-0x1, %r12
je 0xbeda
movq 0x10708(%rip), %rax     # 0x1c5c0
movq %r15, (%rax,%r12,8)
movq %r12, %r15
jmp 0xbeec
movq 0x102a8(%rip), %rdx     # 0x1c170
movq (%rdx,%r12,8), %rsi
movq (%rcx,%rsi,8), %rsi
movq (%rdx,%rsi,8), %rdx
movq %rax, (%rcx,%rdx,8)
jmp 0xbeec
movq 0x1028f(%rip), %rax     # 0x1c170
movq 0x10240(%rip), %rcx     # 0x1c128
movq %r15, (%rax,%rcx,8)
cmpl $-0x65, 0x107dd(%rip)   # 0x1c6d0
jne 0xbf08
callq 0x8d74
movl %eax, 0x107d0(%rip)     # 0x1c6d0
movq %r15, %r12
jmp 0xbe3b
pushq $0x1
popq %rdi
callq 0x3775
testl %ebx, %ebx
je 0xbf35
movq %r15, %rdi
jmp 0xbf4a
pushq $0x1
popq %rdi
callq 0x3775
leaq 0x8a08(%rip), %rdi      # 0x14930
pushq $-0x8
popq %rsi
callq 0x33e4
pushq $-0x5
popq %rax
jmp 0xbf6d
movq 0x10684(%rip), %rcx     # 0x1c5c0
cmpq $-0x1, (%rcx,%rax,8)
je 0xbf62
movq 0x1080e(%rip), %rdi     # 0x1c758
movq %rax, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3613
movq 0x10207(%rip), %rcx     # 0x1c170
movq (%rcx,%rax,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: 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
pushq %r14
pushq %rbx
callq 0x8d74
movl %eax, 0x10742(%rip)     # 0x1c6d0
pushq $0x1
popq %rdi
callq 0xbe09
movq 0x1018b(%rip), %rsi     # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x1017a(%rip)     # 0x1c128
cmpl $0xffffff2b, 0x10718(%rip) # imm = 0xFFFFFF2B
jne 0xc048
callq 0x8d74
movl %eax, 0x10707(%rip)     # 0x1c6d0
xorl %edi, %edi
callq 0xbe09
movq 0x10151(%rip), %rsi     # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x10140(%rip)     # 0x1c128
cmpl $0xffffff32, 0x106de(%rip) # imm = 0xFFFFFF32
jne 0xc059
callq 0x8d74
movl %eax, 0x106d1(%rip)     # 0x1c6d0
pushq $0x1
popq %r14
movl %r14d, %edi
callq 0x3775
pushq $-0x1
popq %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, %rbx
movl %r14d, %edi
callq 0x3775
movq 0x10146(%rip), %rdx     # 0x1c170
movq (%rdx,%rax,8), %rsi
movq (%rdx,%rsi,8), %rdi
movq 0x10587(%rip), %rcx     # 0x1c5c0
cmpq 0x10728(%rip), %rdi     # 0x1c768
jne 0xc075
leaq (%rcx,%rsi,8), %rdx
jmp 0xc07d
pushq $0x1
popq %rdi
callq 0x3775
leaq 0x892f(%rip), %rdi      # 0x14986
jmp 0xc068
pushq $0x2
popq %rdi
callq 0x3775
leaq 0x8936(%rip), %rdi      # 0x1499e
pushq $-0x8
popq %rsi
callq 0x33e4
pushq $-0x5
popq %rax
jmp 0xc088
movq (%rcx,%rdi,8), %rsi
leaq (%rdx,%rsi,8), %rdx
movq (%rdx), %rdx
movq %rbx, (%rcx,%rdx,8)
movq (%rcx,%rax,8), %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0x100a8(%rip), %rax     # 0x1c150
movq 0x10511(%rip), %r12     # 0x1c5c0
movq 0x100ba(%rip), %r13     # 0x1c170
movq 0x1052b(%rip), %rbx     # 0x1c5e8
movq (%r12,%rax,8), %rcx
cmpq $-0x1, %rcx
je 0xc120
movq %rax, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
leaq (,%rcx,8), %rax
addq %r13, %rax
movq (%rax), %r15
cmpq $-0x1, %r15
je 0xc107
movq (%r13,%r15,8), %rax
movq (%r13,%rax,8), %rax
movq (%r12,%rax,8), %rax
leaq (%rbx,%rax,8), %rdi
movq %r14, %rsi
callq 0x3110
testl %eax, %eax
je 0xc10d
leaq (%r12,%r15,8), %rax
jmp 0xc0da
movq -0x38(%rbp), %rax
jmp 0xc0bd
movq -0x30(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x1
popq %rax
jmp 0xc111
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq 0x1048e(%rip), %rbx     # 0x1c5c0
movq (%rbx,%rdi,8), %rdi
shlq $0x3, %rdi
addq 0x104a7(%rip), %rdi     # 0x1c5e8
callq 0xc08d
cmpq $-0x1, %rax
je 0xc176
movq 0x1001d(%rip), %rdx     # 0x1c170
movq (%rbx,%rax,8), %rcx
movq (%rdx,%rcx,8), %rsi
movq (%rbx,%rsi,8), %rsi
movq %rsi, (%rdx,%rcx,8)
movq (%rbx,%rax,8), %rcx
cmpq $-0x1, (%rdx,%rcx,8)
jne 0xc176
movq (%rbx,%rcx,8), %rcx
movq %rcx, (%rbx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: setfixity
void setfixity(cell op, char *refop, int a, int rel) {
	cell	p, n, new;

	p = locate_op(refop);
	n = make_integer(a);
	n = node(n, NIL);
	save(n);
	n = make_string("", strlen(symbol_name(op)));
	strcpy(string(n), symbol_name(op));
	n = node(n, unsave(1));
	if (rel == S_less) {
		n = node(n, NIL);
		set(cdr(p), node(n, cdr(p)));
	}
	else if (rel == S_equal) {
		p = cdr(p);
		set(car(p), node(n, car(p)));
	}
	else if (rel == S_greater) {
		n = node(n, NIL);
		p = cdr(p);
		set(cdr(p), node(n, cdr(p)));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r14d
movl %edx, %r12d
movq %rdi, %r15
movq %rsi, %rdi
callq 0xc08d
movq %rax, %rbx
movslq %r12d, %rdi
callq 0x35ed
pushq $-0x1
popq %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq 0xff70(%rip), %rsi      # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0xff5f(%rip)      # 0x1c128
movq 0x103f0(%rip), %rax     # 0x1c5c0
movq (%rax,%r15,8), %rdi
shlq $0x3, %rdi
addq 0x10409(%rip), %rdi     # 0x1c5e8
callq 0x30a0
leaq 0x96ed(%rip), %rdi      # 0x158d8
movl %eax, %esi
callq 0x729e
movq %rax, %r12
movq 0x103ec(%rip), %rax     # 0x1c5e8
movq 0x103bd(%rip), %rcx     # 0x1c5c0
movq (%rcx,%r12,8), %rdx
leaq (%rax,%rdx,8), %rdi
movq (%rcx,%r15,8), %rcx
leaq (%rax,%rcx,8), %rsi
callq 0x3060
pushq $0x1
popq %rdi
callq 0x3775
movq %r12, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movslq %r14d, %rcx
cmpq %rcx, 0x10541(%rip)     # 0x1c778
jne 0xc25d
pushq $-0x1
popq %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
leaq 0x10373(%rip), %r14     # 0x1c5c0
movq %rbx, %rcx
shlq $0x3, %rcx
addq 0x10365(%rip), %rcx     # 0x1c5c0
jmp 0xc2b5
cmpq %rcx, 0x10494(%rip)     # 0x1c6f8
jne 0xc289
movq 0x10353(%rip), %rcx     # 0x1c5c0
movq (%rcx,%rbx,8), %rbx
leaq 0xfef8(%rip), %r14      # 0x1c170
leaq (,%rbx,8), %rcx
addq 0xfee9(%rip), %rcx      # 0x1c170
jmp 0xc2b5
cmpq %rcx, 0x104f0(%rip)     # 0x1c780
jne 0xc2c9
pushq $-0x1
popq %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
leaq 0x1031a(%rip), %r14     # 0x1c5c0
movq 0x10313(%rip), %rcx     # 0x1c5c0
movq (%rcx,%rbx,8), %rbx
leaq (%rcx,%rbx,8), %rcx
movq (%rcx), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq (%r14), %rcx
movq %rax, (%rcx,%rbx,8)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: except_decl
cell except_decl(void) {
	cell	a, n, new;

	a = cons(NIL, NIL);
	save(a);
	for (;;) {
		Token = scan();
		if (Token != TOK_ID || !consname_p(Attr))
			return error("constructor name expected at", Attr);
		save(Attr);
		Exceptions = node(Attr, Exceptions);
		n = node(Attr, NIL);		/* (define exn exn) */
		n = node(Attr, n);
		n = node(S_define_type, n);
		car(a) = n;
		unsave(1);
		Token = scan();
		if (Token != TOK_AND)
			break;
		set(cdr(a), cons(NIL, NIL));
		a = cdr(a);
	}
	n = unsave(1);
	return cdr(n) == NIL? car(n): node(S_begin, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq $-0x1
popq %rbx
pushq $0x8
popq %r14
movq %rbx, %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x3613
movq %rax, %r15
movq 0xfc0f(%rip), %rsi      # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0xfbfe(%rip)      # 0x1c128
pushq $0x1
popq %r12
callq 0x8d74
movl %eax, 0x10197(%rip)     # 0x1c6d0
movq 0xfc18(%rip), %rcx      # 0x1c158
cmpl $0xfffffed1, %eax       # imm = 0xFFFFFED1
jne 0xc614
movq 0x10096(%rip), %rax     # 0x1c5e8
movq 0x10067(%rip), %rdx     # 0x1c5c0
movq (%rdx,%rcx,8), %rdx
cmpb $0x3a, (%rax,%rdx,8)
jne 0xc614
movq 0xfbba(%rip), %rsi      # 0x1c128
movq %rcx, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0xfba9(%rip)      # 0x1c128
movq 0xfbd2(%rip), %rdi      # 0x1c158
movq 0xfbd3(%rip), %rsi      # 0x1c160
xorl %edx, %edx
callq 0x3613
movq %rax, 0xfbc5(%rip)      # 0x1c160
movq 0xfbb6(%rip), %rdi      # 0x1c158
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3613
movq 0xfba5(%rip), %rdi      # 0x1c158
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq 0x101ac(%rip), %rdi     # 0x1c770
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq 0xfb9b(%rip), %rcx      # 0x1c170
movq %rax, (%rcx,%r15,8)
movl %r12d, %edi
callq 0x3775
callq 0x8d74
movl %eax, 0x100e4(%rip)     # 0x1c6d0
cmpl $0xffffff37, %eax       # imm = 0xFFFFFF37
jne 0xc62f
movq %rbx, %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0x3613
movq 0xffb8(%rip), %rcx      # 0x1c5c0
movq %rax, (%rcx,%r15,8)
movq %rax, %r15
jmp 0xc52e
leaq 0x82af(%rip), %rdi      # 0x148ca
movq %rcx, %rsi
callq 0x33e4
pushq $-0x5
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rdi
callq 0x3775
movq 0xff82(%rip), %rcx      # 0x1c5c0
cmpq $-0x1, (%rcx,%rax,8)
je 0xc65e
movq 0x1010c(%rip), %rdi     # 0x1c758
movq %rax, %rsi
xorl %edx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3613
movq 0xfb0b(%rip), %rcx      # 0x1c170
movq (%rcx,%rax,8), %rax
jmp 0xc626