LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: let_expr
cell let_expr(void) {
	cell	d, x;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x9c07
movl %eax, 0x12c43(%rip)     # 0x1e6d0
movl $0x1, %edi
callq 0xcfd1
movq 0x1268a(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x12679(%rip)     # 0x1e128
cmpl $0xffffff2b, 0x12c17(%rip) # imm = 0xFFFFFF2B
jne 0xbb4b
callq 0x9c07
movl %eax, 0x12c06(%rip)     # 0x1e6d0
callq 0xa5a1
movq 0x12652(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x12641(%rip)     # 0x1e128
cmpl $0xffffff32, 0x12bdf(%rip) # imm = 0xFFFFFF32
jne 0xbb5e
callq 0x9c07
movl %eax, 0x12bd2(%rip)     # 0x1e6d0
movl $0x1, %edi
callq 0x3851
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
movl $0x1, %edi
callq 0x3851
movq 0x12643(%rip), %rdx     # 0x1e170
movq (%rdx,%rax,8), %rsi
movq (%rdx,%rsi,8), %rdi
movq 0x12a84(%rip), %rcx     # 0x1e5c0
cmpq 0x12c25(%rip), %rdi     # 0x1e768
jne 0xbb84
leaq (%rcx,%rsi,8), %rdx
jmp 0xbb8c
movl $0x1, %edi
callq 0x3851
leaq 0xae18(%rip), %rdi      # 0x16974
jmp 0xbb6f
movl $0x2, %edi
callq 0x3851
leaq 0xae1b(%rip), %rdi      # 0x1698a
movq $-0x8, %rsi
callq 0x33eb
movq $-0x5, %rax
jmp 0xbb9e
movq (%rcx,%rdi,8), %rsi
leaq (%rdx,%rsi,8), %rdx
movq (%rdx), %rdx
movq %rbx, (%rcx,%rdx,8)
movq 0x12a26(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rax,8), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
callq 0xa7c6
movq %rax, %rbx
movl 0x12b17(%rip), %eax     # 0x1e6d0
cmpl $0xffffff20, %eax       # imm = 0xFFFFFF20
jg 0xbc88
addl $0x130, %eax            # imm = 0x130
cmpl $0x5, %eax
jae 0xbccb
movq 0x1257f(%rip), %rdi     # 0x1e158
callq 0x97a0
testl %eax, %eax
jne 0xbccb
cmpl $-0x67, 0x12ae3(%rip)   # 0x1e6d0
je 0xbccb
testq %rbx, %rbx
js 0xbc2d
movq 0x129e1(%rip), %rax     # 0x1e5e0
movb (%rax,%rbx), %al
testb $0x1, %al
je 0xbc2d
movq 0x12563(%rip), %rcx     # 0x1e170
movq (%rcx,%rbx,8), %rcx
cmpq $-0x1f, %rcx
je 0xbccb
cmpq $-0x18, %rcx
je 0xbccb
testb $0x1, %al
jne 0xbcb9
leaq 0x1(%rbx), %rax
cmpq $-0x3, %rax
ja 0xbccb
movq 0x124e6(%rip), %rsi     # 0x1e128
movq %rbx, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x124d5(%rip)     # 0x1e128
callq 0xa7c6
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
movl $0x1, %edi
callq 0x3851
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x36e8
jmp 0xbbb0
cmpl $-0x6b, %eax
jg 0xbca5
cmpl $0xffffff21, %eax       # imm = 0xFFFFFF21
je 0xbbd2
cmpl $0xffffff24, %eax       # imm = 0xFFFFFF24
je 0xbbd2
jmp 0xbccb
cmpl $-0x68, %eax
je 0xbbd2
cmpl $-0x6a, %eax
je 0xbbd2
jmp 0xbccb
movq 0x124b0(%rip), %rax     # 0x1e170
cmpq $-0x16, (%rax,%rbx,8)
jne 0xbc3b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: commit
void commit(char *s, int all) {
	int	tp = 0, ta = LEFT, sp = 0, sa;
	cell	n;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
xorl %eax, %eax
leaq -0x34(%rbp), %rsi
movl %eax, (%rsi)
leaq -0x30(%rbp), %rdx
movl $0x1, (%rdx)
movl %eax, -0x2c(%rbp)
callq 0x96d4
movq 0x12467(%rip), %rax     # 0x1e170
movq 0x12418(%rip), %rcx     # 0x1e128
movq (%rax,%rcx,8), %rcx
cmpq $-0x1, %rcx
je 0xbe7d
movl -0x34(%rbp), %r12d
movl -0x30(%rbp), %r13d
leaq -0x2c(%rbp), %r14
leaq -0x38(%rbp), %r15
xorl $0x2, %r13d
movq 0x12887(%rip), %rdx     # 0x1e5c0
movq (%rax,%rcx,8), %rax
movq (%rdx,%rax,8), %rdi
shlq $0x3, %rdi
addq 0x1289c(%rip), %rdi     # 0x1e5e8
movq %r14, %rsi
movq %r15, %rdx
callq 0x96d4
testl %ebx, %ebx
jne 0xbd7a
movl -0x2c(%rbp), %ecx
movl %r12d, %eax
xorl %ecx, %eax
orl %r13d, %eax
sete %al
cmpl %ecx, %r12d
jg 0xbe7d
testb %al, %al
jne 0xbe7d
movq 0x123ef(%rip), %rax     # 0x1e170
movq 0x12838(%rip), %rcx     # 0x1e5c0
movq 0x12399(%rip), %rdx     # 0x1e128
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rcx
movq (%rax,%rcx,8), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x12810(%rip), %rcx     # 0x1e5c0
movq 0x123b9(%rip), %rdx     # 0x1e170
movq 0x1236a(%rip), %rsi     # 0x1e128
movq (%rcx,%rsi,8), %rsi
movq (%rdx,%rsi,8), %rdi
movq (%rcx,%rdi,8), %rdi
movq %rdi, (%rdx,%rsi,8)
movq 0x12353(%rip), %rsi     # 0x1e128
movq (%rcx,%rsi,8), %rcx
movq (%rdx,%rcx,8), %rcx
movq (%rdx,%rcx,8), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x128fe(%rip), %rdi     # 0x1e6f0
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x1235c(%rip), %rcx     # 0x1e170
movq 0x1230d(%rip), %rdx     # 0x1e128
movq (%rcx,%rdx,8), %rdx
movq (%rcx,%rdx,8), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x1278c(%rip), %rcx     # 0x1e5c0
movq 0x12335(%rip), %rdx     # 0x1e170
movq 0x122e6(%rip), %rsi     # 0x1e128
movq (%rdx,%rsi,8), %rdi
movq (%rcx,%rdi,8), %rdi
movq %rdi, (%rdx,%rsi,8)
movq 0x122d3(%rip), %rsi     # 0x1e128
movq (%rcx,%rsi,8), %rcx
movq (%rdx,%rcx,8), %rcx
movq %rax, (%rdx,%rcx,8)
movq 0x12308(%rip), %rax     # 0x1e170
movq 0x122b9(%rip), %rcx     # 0x1e128
movq (%rax,%rcx,8), %rcx
cmpq $-0x1, %rcx
jne 0xbd32
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: apply_op
cell apply_op(int k) {
	cell	n;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
callq 0xbe8c
cmpl $0xffffff36, 0x125ef(%rip) # imm = 0xFFFFFF36
jne 0xc13a
movq 0x1203e(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x1202d(%rip)     # 0x1e128
callq 0x9c07
movl %eax, 0x125ca(%rip)     # 0x1e6d0
movl %ebx, %edi
callq 0xc0c9
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %r14
movl $0x1, %edi
callq 0x3851
movq %rax, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x36e8
jmp 0xc0d7
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movl $0xffffff23, %edi       # imm = 0xFFFFFF23
movl $0x1, %esi
callq 0xb7c2
movq %rax, %rbx
cmpl $0xffffff2d, 0x1256f(%rip) # imm = 0xFFFFFF2D
jne 0xc2c8
movq 0x11fba(%rip), %rsi     # 0x1e128
movq %rbx, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x11fa9(%rip)     # 0x1e128
callq 0x9c07
movl %eax, 0x12546(%rip)     # 0x1e6d0
movq %rbx, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x1257e(%rip), %rdi     # 0x1e720
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x11f64(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x11f53(%rip)     # 0x1e128
leaq 0xaf0b(%rip), %rdi      # 0x170e7
callq 0xc2d2
movq %rax, %rbx
movq 0x11f3d(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x11f2c(%rip)     # 0x1e128
xorl %edi, %edi
callq 0xb478
movq 0x124fe(%rip), %rdi     # 0x1e708
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x124ef(%rip), %rdi     # 0x1e728
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x11f26(%rip), %rcx     # 0x1e170
movq 0x1236f(%rip), %rdx     # 0x1e5c0
movq 0x11ed0(%rip), %rsi     # 0x1e128
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x12479(%rip), %rdi     # 0x1e708
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x1247f(%rip), %rdi     # 0x1e730
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
movl $0x3, %edi
callq 0x3851
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
leaq 0xacae(%rip), %r14      # 0x16f9a
leaq -0xe0(%rbp), %r15
movq 0x128be(%rip), %rcx     # 0x1ebb8
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x31f0
incq 0x128a7(%rip)           # 0x1ebb8
movq %r15, %rdi
callq 0x71eb
cmpq $-0x1, %rax
jne 0xc2f3
leaq -0xe0(%rbp), %rdi
callq 0x729e
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x12387(%rip) # imm = 0xFFFFFF22
jne 0xc3ae
callq 0x9c07
movl %eax, 0x1237a(%rip)     # 0x1e6d0
cmpl $0xfffffed1, %eax       # imm = 0xFFFFFED1
jne 0xc3b9
movq 0x12284(%rip), %rax     # 0x1e5e8
movq 0x12255(%rip), %rcx     # 0x1e5c0
movq 0x11de6(%rip), %rdi     # 0x1e158
movq (%rcx,%rdi,8), %rcx
cmpb $0x3a, (%rax,%rcx,8)
jne 0xc3b9
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x123a7(%rip), %rdi     # 0x1e738
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
callq 0x9c07
movl %eax, 0x12327(%rip)     # 0x1e6d0
movq %rbx, %rax
jmp 0xc3d3
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc13f
leaq 0xa48d(%rip), %rdi      # 0x1684d
movq $-0x8, %rsi
callq 0x33eb
movq $-0x5, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
cmpl $0xffffff2c, 0x122e6(%rip) # imm = 0xFFFFFF2C
jne 0xc4cc
callq 0x9c07
movl %eax, 0x122d5(%rip)     # 0x1e6d0
callq 0xa4fd
cmpl $0xffffff20, 0x122c6(%rip) # imm = 0xFFFFFF20
jne 0xc4d7
movq 0x11d11(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x11d00(%rip)     # 0x1e128
callq 0x9c07
movl %eax, 0x1229d(%rip)     # 0x1e6d0
callq 0xa4fd
cmpl $0xffffff33, 0x1228e(%rip) # imm = 0xFFFFFF33
jne 0xc4e0
movq 0x11cd9(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x11cc8(%rip)     # 0x1e128
callq 0x9c07
movl %eax, 0x12265(%rip)     # 0x1e6d0
callq 0xa4fd
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
movl $0x1, %edi
callq 0x3851
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
movl $0x1, %edi
callq 0x3851
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x12284(%rip), %rdi     # 0x1e740
movq %rax, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x36e8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc339
leaq 0xa390(%rip), %rdi      # 0x1686e
jmp 0xc4f1
movl $0x1, %edi
callq 0x3851
leaq 0xa397(%rip), %rdi      # 0x16888
movq $-0x8, %rsi
callq 0x33eb
movq $-0x5, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x121b7(%rip) # imm = 0xFFFFFF35
jne 0xc5ba
callq 0x9c07
movl %eax, 0x121a6(%rip)     # 0x1e6d0
callq 0xc3da
cmpl $0xffffff25, 0x12197(%rip) # imm = 0xFFFFFF25
jne 0xc5c0
movq 0x11be2(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x11bd1(%rip)     # 0x1e128
callq 0x9c07
movl %eax, 0x1216e(%rip)     # 0x1e6d0
xorl %edi, %edi
callq 0xb478
movq 0x12198(%rip), %rdi     # 0x1e708
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x11b8f(%rip)     # 0x1e110
movl $0x1, %edi
callq 0x3851
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x11b6d(%rip), %rdi     # 0x1e110
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq $-0x1, 0x11b58(%rip) # 0x1e110
jmp 0xc5da
popq %rbp
jmp 0xc3da
leaq 0xa2db(%rip), %rdi      # 0x168a2
movq $-0x8, %rsi
callq 0x33eb
movq $-0x5, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc64e
movq 0x11fef(%rip), %rax     # 0x1e5e0
movb (%rax,%rbx), %al
testb $0x11, %al
jne 0xc615
movq 0x11fc1(%rip), %rax     # 0x1e5c0
movq (%rax,%rbx,8), %rdi
callq 0xc5dc
movq 0x11b61(%rip), %rax     # 0x1e170
movq (%rax,%rbx,8), %rbx
jmp 0xc5e5
testb $0x10, %al
je 0xc64e
movq 0x11b50(%rip), %rax     # 0x1e170
cmpq $-0x22, (%rax,%rbx,8)
jne 0xc64e
movq 0x11afa(%rip), %rcx     # 0x1e128
movq (%rax,%rcx,8), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x36e8
movq 0x11b2d(%rip), %rcx     # 0x1e170
movq 0x11ade(%rip), %rdx     # 0x1e128
movq %rax, (%rcx,%rdx,8)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x11abf(%rip), %rsi     # 0x1e128
movq $-0x1, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x11aaa(%rip)     # 0x1e128
movq %r14, %rdi
callq 0xc5dc
movq 0x11ae3(%rip), %rax     # 0x1e170
movq 0x11a94(%rip), %rcx     # 0x1e128
movq (%rax,%rcx,8), %r14
cmpq $-0x1, %r14
je 0xc730
movq 0x11ac7(%rip), %rax     # 0x1e170
movq (%rax,%r14,8), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x11aae(%rip), %rcx     # 0x1e170
movq (%rcx,%r14,8), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x12089(%rip), %rdi     # 0x1e760
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x11a88(%rip), %rcx     # 0x1e170
movq %rax, (%rcx,%rbx,8)
movq 0x11ecd(%rip), %rax     # 0x1e5c0
cmpq $-0x1, (%rax,%r14,8)
je 0xc720
movq $-0x1, %rdi
movq $-0x1, %rsi
movl $0x8, %edx
callq 0x36e8
movq 0x11ea7(%rip), %rcx     # 0x1e5c0
movq %rax, (%rcx,%rbx,8)
movq %rax, %rbx
movq 0x11e99(%rip), %rax     # 0x1e5c0
movq (%rax,%r14,8), %r14
jmp 0xc698
movl $0x1, %edi
callq 0x3851
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x11140(%rip), %rsi     # 0x1e128
movq $-0x1, %r15
movq $-0x1, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x11124(%rip)     # 0x1e128
movl 0x116c6(%rip), %eax     # 0x1e6d0
cmpl $0xffffff2e, %eax       # imm = 0xFFFFFF2E
je 0xd025
cmpl $0xffffff1e, %eax       # imm = 0xFFFFFF1E
jne 0xd0f2
movl %ebx, %edi
callq 0xc742
jmp 0xd02c
movl %ebx, %edi
callq 0xca76
movq %rax, %r14
testl %ebx, %ebx
je 0xd06e
movq 0x11136(%rip), %rax     # 0x1e170
cmpq $-0x1, %r15
je 0xd0b8
movq (%rax,%r15,8), %r12
movq 0x1171d(%rip), %r13     # 0x1e768
movq %r14, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x1155d(%rip), %rcx     # 0x1e5c0
cmpq %r13, %r12
jne 0xd098
movq (%rcx,%r15,8), %rdx
jmp 0xd0ab
movq %r14, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %r14
cmpq $-0x1, %r15
je 0xd0b1
movq 0x11531(%rip), %rax     # 0x1e5c0
movq %r14, (%rax,%r15,8)
movq %r15, %r14
jmp 0xd0c3
movq 0x110d1(%rip), %rdx     # 0x1e170
movq (%rdx,%r15,8), %rsi
movq (%rcx,%rsi,8), %rsi
movq (%rdx,%rsi,8), %rdx
movq %rax, (%rcx,%rdx,8)
jmp 0xd0c3
movq 0x110b8(%rip), %rax     # 0x1e170
movq 0x11069(%rip), %rcx     # 0x1e128
movq %r14, (%rax,%rcx,8)
cmpl $-0x65, 0x11606(%rip)   # 0x1e6d0
jne 0xd0df
callq 0x9c07
movl %eax, 0x115f9(%rip)     # 0x1e6d0
movq %r14, %r15
jmp 0xd004
movl $0x1, %edi
callq 0x3851
testl %ebx, %ebx
je 0xd118
movq %r14, %rdi
jmp 0xd12d
movl $0x1, %edi
callq 0x3851
leaq 0x9848(%rip), %rdi      # 0x1694b
movq $-0x8, %rsi
callq 0x33eb
movq $-0x5, %rax
jmp 0xd150
movq 0x114a1(%rip), %rcx     # 0x1e5c0
cmpq $-0x1, (%rcx,%rax,8)
je 0xd145
movq 0x1162b(%rip), %rdi     # 0x1e758
movq %rax, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x36e8
movq 0x11024(%rip), %rcx     # 0x1e170
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_O1/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 %rbx
pushq %rax
callq 0x9c07
movl %eax, 0x11560(%rip)     # 0x1e6d0
movl $0x1, %edi
callq 0xcfd1
movq 0x10fa7(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x10f96(%rip)     # 0x1e128
cmpl $0xffffff2b, 0x11534(%rip) # imm = 0xFFFFFF2B
jne 0xd230
callq 0x9c07
movl %eax, 0x11523(%rip)     # 0x1e6d0
xorl %edi, %edi
callq 0xcfd1
movq 0x10f6d(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x10f5c(%rip)     # 0x1e128
cmpl $0xffffff32, 0x114fa(%rip) # imm = 0xFFFFFF32
jne 0xd243
callq 0x9c07
movl %eax, 0x114ed(%rip)     # 0x1e6d0
movl $0x1, %edi
callq 0x3851
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
movl $0x1, %edi
callq 0x3851
movq 0x10f5e(%rip), %rdx     # 0x1e170
movq (%rdx,%rax,8), %rsi
movq (%rdx,%rsi,8), %rdi
movq 0x1139f(%rip), %rcx     # 0x1e5c0
cmpq 0x11540(%rip), %rdi     # 0x1e768
jne 0xd269
leaq (%rcx,%rsi,8), %rdx
jmp 0xd271
movl $0x1, %edi
callq 0x3851
leaq 0x9760(%rip), %rdi      # 0x169a1
jmp 0xd254
movl $0x2, %edi
callq 0x3851
leaq 0x9765(%rip), %rdi      # 0x169b9
movq $-0x8, %rsi
callq 0x33eb
movq $-0x5, %rax
jmp 0xd283
movq (%rcx,%rdi,8), %rsi
leaq (%rdx,%rsi,8), %rdx
movq (%rdx), %rdx
movq %rbx, (%rcx,%rdx,8)
movq 0x11341(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rax,8), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10eae(%rip), %rdx     # 0x1e150
movq 0x11317(%rip), %r15     # 0x1e5c0
movq (%r15,%rdx,8), %rcx
movq $-0x1, %rax
cmpq $-0x1, %rcx
je 0xd31d
movq %rdi, %r14
movq 0x10eac(%rip), %r13     # 0x1e170
movq 0x1131d(%rip), %rbx     # 0x1e5e8
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq (%r13,%rcx,8), %r12
cmpq $-0x1, %r12
je 0xd302
movq (%r13,%r12,8), %rax
movq (%r13,%rax,8), %rax
movq (%r15,%rax,8), %rax
leaq (%rbx,%rax,8), %rdi
movq %r14, %rsi
callq 0x3110
testl %eax, %eax
je 0xd319
movq (%r15,%r12,8), %r12
jmp 0xd2d8
movq -0x38(%rbp), %rdx
movq (%r15,%rdx,8), %rcx
cmpq $-0x1, %rcx
jne 0xd2cb
movq $-0x1, %rax
jmp 0xd31d
movq -0x30(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: 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 0x11287(%rip), %rbx     # 0x1e5c0
movq (%rbx,%rdi,8), %rdi
shlq $0x3, %rdi
addq 0x112a0(%rip), %rdi     # 0x1e5e8
callq 0xd28a
cmpq $-0x1, %rax
je 0xd37d
movq 0x10e16(%rip), %rdx     # 0x1e170
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 0xd37d
movq (%rbx,%rcx,8), %rcx
movq %rcx, (%rbx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r14d
movl %edx, %r12d
movq %rdi, %r15
movq %rsi, %rdi
callq 0xd28a
movq %rax, %rbx
movslq %r12d, %rdi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x18, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x10d42(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x10d31(%rip)     # 0x1e128
movq 0x111c2(%rip), %rax     # 0x1e5c0
movq (%rax,%r15,8), %rdi
shlq $0x3, %rdi
addq 0x111db(%rip), %rdi     # 0x1e5e8
callq 0x30a0
movq %rax, %r13
incl %r13d
movq $-0x21, %rdi
movl %r13d, %esi
callq 0x417e
movq %rax, %r12
movq 0x1118f(%rip), %rax     # 0x1e5c0
movq (%rax,%r12,8), %rdi
shlq $0x3, %rdi
addq 0x111a8(%rip), %rdi     # 0x1e5e8
movslq %r13d, %rdx
xorl %esi, %esi
callq 0x30d0
movq 0x11197(%rip), %rax     # 0x1e5e8
movq 0x11168(%rip), %rcx     # 0x1e5c0
movq (%rcx,%r12,8), %rdx
leaq (%rax,%rdx,8), %rdi
movq (%rcx,%r15,8), %rcx
leaq (%rax,%rcx,8), %rsi
callq 0x3060
movl $0x1, %edi
callq 0x3851
movq %r12, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movslq %r14d, %rcx
cmpq %rcx, 0x112ea(%rip)     # 0x1e778
jne 0xd4b8
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
leaq 0x11118(%rip), %r14     # 0x1e5c0
movq %rbx, %rcx
shlq $0x3, %rcx
addq 0x1110a(%rip), %rcx     # 0x1e5c0
jmp 0xd514
cmpq %rcx, 0x11239(%rip)     # 0x1e6f8
jne 0xd4e4
movq 0x110f8(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rbx,8), %rbx
leaq 0x10c9d(%rip), %r14     # 0x1e170
leaq (,%rbx,8), %rcx
addq 0x10c8e(%rip), %rcx     # 0x1e170
jmp 0xd514
cmpq %rcx, 0x11295(%rip)     # 0x1e780
jne 0xd528
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
leaq 0x110bb(%rip), %r14     # 0x1e5c0
movq 0x110b4(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rbx,8), %rbx
leaq (%rcx,%rbx,8), %rcx
movq (%rcx), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq (%r14), %rcx
movq %rax, (%rcx,%rbx,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: 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 %r14
pushq %rbx
movq $-0x1, %rdi
movq $-0x1, %rsi
movl $0x8, %edx
callq 0x36e8
movq %rax, %rbx
movq 0x1099c(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x1098b(%rip)     # 0x1e128
callq 0x9c07
movl %eax, 0x10f28(%rip)     # 0x1e6d0
cmpl $0xfffffed1, %eax       # imm = 0xFFFFFED1
jne 0xd89e
movq 0x10e2e(%rip), %rax     # 0x1e5e8
movq 0x10dff(%rip), %rcx     # 0x1e5c0
movq 0x10990(%rip), %rdi     # 0x1e158
movq (%rcx,%rdi,8), %rcx
cmpb $0x3a, (%rax,%rcx,8)
jne 0xd89e
movq 0x1094b(%rip), %rsi     # 0x1e128
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x1093d(%rip)     # 0x1e128
movq 0x10966(%rip), %rdi     # 0x1e158
movq 0x10967(%rip), %rsi     # 0x1e160
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x10959(%rip)     # 0x1e160
movq 0x1094a(%rip), %rdi     # 0x1e158
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x10935(%rip), %rdi     # 0x1e158
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x10f3c(%rip), %rdi     # 0x1e770
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x1092b(%rip), %rcx     # 0x1e170
movq %rax, (%rcx,%rbx,8)
movl $0x1, %edi
callq 0x3851
callq 0x9c07
movl %eax, 0x10e72(%rip)     # 0x1e6d0
cmpl $0xffffff37, %eax       # imm = 0xFFFFFF37
jne 0xd8bd
movq $-0x1, %rdi
movq $-0x1, %rsi
movl $0x8, %edx
callq 0x36e8
movq %rax, %r14
movq 0x10d39(%rip), %rax     # 0x1e5c0
movq %r14, (%rax,%rbx,8)
callq 0x9c07
movl %eax, 0x10e3a(%rip)     # 0x1e6d0
movq %r14, %rbx
jmp 0xd7a8
movq 0x108b3(%rip), %rsi     # 0x1e158
leaq 0x9039(%rip), %rdi      # 0x168e5
callq 0x33eb
movq $-0x5, %rax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x1, %edi
callq 0x3851
movq 0x10cf2(%rip), %rcx     # 0x1e5c0
cmpq $-0x1, (%rcx,%rax,8)
je 0xd8ea
movq 0x10e7c(%rip), %rdi     # 0x1e758
movq %rax, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x36e8
movq 0x1087f(%rip), %rcx     # 0x1e170
movq (%rcx,%rax,8), %rax
jmp 0xd8b8
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: append_b
cell append_b(cell a, cell b) {
	cell	p, last = NIL;

	if (a == NIL)
		return b;
	p = a;
	while (p != NIL) {
		if (atom_p(p))
			fatal("append!: improper list");
		last = p;
		p = cdr(p);
	}
	cdr(last) = b;
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $-0x1, %rdi
je 0xd938
movq 0x10cd8(%rip), %rax     # 0x1e5e0
movq 0x10cb1(%rip), %rcx     # 0x1e5c0
movq %rdi, %r8
testq %r8, %r8
js 0xd940
movq %r8, %rdx
testb $0x11, (%rax,%r8)
jne 0xd940
movq (%rcx,%rdx,8), %r8
cmpq $-0x1, %r8
jne 0xd912
movq 0x10c8e(%rip), %rax     # 0x1e5c0
movq %rsi, (%rax,%rdx,8)
jmp 0xd93b
movq %rsi, %rdi
movq %rdi, %rax
popq %rbp
retq
leaq 0x90fc(%rip), %rdi      # 0x16a43
callq 0x3ab5
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: argument_list_p
int argument_list_p(cell n) {
	if (n == NIL || symbol_p(n))
		return 1;
	if (atom_p(n))
		return 0;
	while (tuple_p(n)) {
		if (!symbol_p(car(n)))
			return 0;
		n = cdr(n);
	}
	return n == NIL || symbol_p(n);
}

// Assembly:
cmpq $-0x1, %rdi
je 0xd985
testq %rdi, %rdi
js 0xd989
pushq %rbp
movq %rsp, %rbp
movq 0x10c7e(%rip), %rax     # 0x1e5e0
movb (%rax,%rdi), %dl
testb $0x10, %dl
je 0xd97b
movq 0x107ff(%rip), %rcx     # 0x1e170
cmpq $-0x22, (%rcx,%rdi,8)
sete %cl
je 0xd982
testb $0x11, %dl
je 0xd98f
xorl %ecx, %ecx
popq %rbp
jmp 0xd98b
movb $0x1, %cl
jmp 0xd98b
xorl %ecx, %ecx
movzbl %cl, %eax
retq
testb $0x19, (%rax,%rdi)
je 0xd9ba
xorl %esi, %esi
cmpq $-0x1, %rdi
sete %cl
testb %sil, %sil
jne 0xd982
testb $0x10, (%rax,%rdi)
je 0xd980
movq 0x107c0(%rip), %rax     # 0x1e170
cmpq $-0x22, (%rax,%rdi,8)
sete %cl
jmp 0xd982
movq 0x107af(%rip), %rcx     # 0x1e170
movq 0x10bf8(%rip), %rdx     # 0x1e5c0
movq (%rcx,%rdi,8), %rsi
testq %rsi, %rsi
js 0xd980
testb $0x10, (%rax,%rsi)
je 0xd980
cmpq $-0x22, (%rcx,%rsi,8)
jne 0xd980
movq (%rdx,%rdi,8), %rdi
movq %rdi, %rsi
shrq $0x3f, %rsi
testq %rdi, %rdi
js 0xd997
testb $0x19, (%rax,%rdi)
je 0xd9c8
jmp 0xd997
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: hash_size
int hash_size(int n) {
	if (n < 5) return 5;
	if (n < 11) return 11;
	if (n < 23) return 23;
	if (n < 47) return 47;
	if (n < 97) return 97;
	if (n < 199) return 199;
	if (n < 499) return 499;
	if (n < 997) return 997;
	if (n < 9973) return 9973;
	return 19997;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x5, %eax
cmpl $0x5, %edi
jl 0xda62
movl $0xb, %eax
cmpl $0xb, %edi
jl 0xda62
movl $0x17, %eax
cmpl $0x17, %edi
jl 0xda62
movl $0x2f, %eax
cmpl $0x2f, %edi
jl 0xda62
movl $0x61, %eax
cmpl $0x61, %edi
jl 0xda62
movl $0xc7, %eax
cmpl $0xc7, %edi
jl 0xda62
movl $0x1f3, %eax            # imm = 0x1F3
cmpl $0x1f3, %edi            # imm = 0x1F3
jl 0xda62
movl $0x3e5, %eax            # imm = 0x3E5
cmpl $0x3e5, %edi            # imm = 0x3E5
jl 0xda62
movl $0x26f5, %ecx           # imm = 0x26F5
cmpl %ecx, %edi
movl $0x4e1d, %eax           # imm = 0x4E1D
cmovll %ecx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: rehash
void rehash(cell e) {
	unsigned int	i;
	cell		p, *v, new;
	unsigned int	h, k = hash_size(length(e));
	char		*s;

	if (Program == NIL || k < HASH_THRESHOLD)
		return;
	set(car(e), new_vec(T_VECTOR, k * sizeof(cell)));
	v = vector(car(e));
	for (i=0; i<k; i++)
		v[i] = NIL;
	p = cdr(e);
	while (p != NIL) {
		s = symbol_name(caar(p));
		h = 0;
		hash(s, h);
		new = node(car(p), v[h%k]);
		v = vector(car(e));
		v[h%k] = new;
		p = cdr(p);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $-0x1, %rdi
je 0xda95
xorl %edi, %edi
movq 0x10b3c(%rip), %rax     # 0x1e5c0
movq %rbx, %rcx
incl %edi
movq (%rax,%rcx,8), %rcx
cmpq $-0x1, %rcx
jne 0xda87
jmp 0xda97
xorl %edi, %edi
callq 0xd9f6
cmpq $-0x1, 0x10654(%rip)    # 0x1e0f8
je 0xdb91
movl %eax, %r14d
leal (,%r14,8), %r12d
movq $-0x24, %rdi
movl %r12d, %esi
callq 0x417e
movq 0x106a5(%rip), %rcx     # 0x1e170
movq %rax, (%rcx,%rbx,8)
movq 0x10aea(%rip), %r13     # 0x1e5c0
movq (%r13,%rax,8), %r15
shlq $0x3, %r15
addq 0x10b02(%rip), %r15     # 0x1e5e8
movq %r15, %rdi
movl $0xff, %esi
movq %r12, %rdx
callq 0x30d0
movq (%r13,%rbx,8), %r13
cmpq $-0x1, %r13
je 0xdb91
movq 0x10adc(%rip), %rdx     # 0x1e5e8
movq 0x10aad(%rip), %rax     # 0x1e5c0
movq 0x10656(%rip), %rcx     # 0x1e170
movq (%rcx,%r13,8), %rdi
movq (%rcx,%rdi,8), %rcx
movq (%rax,%rcx,8), %rsi
movb (%rdx,%rsi,8), %cl
movl $0x0, %eax
testb %cl, %cl
je 0xdb50
leaq (%rdx,%rsi,8), %rdx
incq %rdx
xorl %eax, %eax
movl %eax, %esi
shll $0x5, %esi
addl %eax, %esi
movsbl %cl, %eax
xorl %esi, %eax
movb (%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0xdb3b
xorl %edx, %edx
divl %r14d
movl %edx, %r12d
movq (%r15,%r12,8), %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x10a56(%rip), %rcx     # 0x1e5c0
movq 0x105ff(%rip), %rdx     # 0x1e170
movq (%rdx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %r15
shlq $0x3, %r15
addq 0x10a64(%rip), %r15     # 0x1e5e8
movq %rax, (%r15,%r12,8)
movq (%rcx,%r13,8), %r13
jmp 0xdafb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: extend
cell extend(cell v, cell a, cell e) {
	cell	n, new;

	n = make_binding(v, a);
	set(cdr(e), node(n, cdr(e)));
	if (box_value(S_loading) == FALSE)
		rehash(e);
	return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
xorl %edx, %edx
callq 0x36e8
movq 0x10a09(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rbx,8), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq 0x109f4(%rip), %rcx     # 0x1e5c0
movq %rax, (%rcx,%rbx,8)
movq 0x109f1(%rip), %rax     # 0x1e5c8
cmpq $-0x3, (%rcx,%rax,8)
jne 0xdbe6
movq %rbx, %rdi
callq 0xda64
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: make_env
cell make_env(cell rib, cell env) {
	cell	e;

	Tmp = env;
	rib = node(NIL, rib);
	e = node(rib, env);
	Tmp = NIL;
	if (length(rib) >= HASH_THRESHOLD) {
		save(e);
		rehash(rib);
		unsave(1);
	}
	return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rsi
movq %rbx, 0x1050c(%rip)     # 0x1e110
movq $-0x1, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
movq $-0x1, 0x104e0(%rip) # 0x1e110
cmpq $-0x1, %r14
je 0xdc80
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq 0x1097e(%rip), %rcx     # 0x1e5c0
movq %r14, %rdx
movq (%rcx,%rdx,8), %rdx
incl %eax
cmpq $-0x1, %rdx
jne 0xdc45
cmpl $0x4, %eax
jb 0xdc80
movq 0x104cb(%rip), %rsi     # 0x1e128
movq %rbx, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x104ba(%rip)     # 0x1e128
movq %r14, %rdi
callq 0xda64
movl $0x1, %edi
callq 0x3851
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: try_hash
cell try_hash(cell v, cell e) {
	cell		*hv, p;
	unsigned int	h, k;
	char		*s;

	if (e == NIL || car(e) == NIL)
		return NIL;
	hv = vector(car(e));
	k = vector_len(car(e));
	s = symbol_name(v);
	hash(s, h);
	p = hv[h%k];
	while (p != NIL) {
		if (caar(p) == v)
			return car(p);
		p = cdr(p);
	}
	return NIL;
}

// Assembly:
cmpq $-0x1, %rsi
je 0xdcf6
pushq %rbp
movq %rsp, %rbp
movq 0x104d7(%rip), %rcx     # 0x1e170
movq (%rcx,%rsi,8), %rdx
cmpq $-0x1, %rdx
je 0xdd1f
movq 0x1093e(%rip), %rax     # 0x1e5e8
movq 0x1090f(%rip), %rsi     # 0x1e5c0
movq (%rsi,%rdx,8), %rdx
leaq (%rax,%rdx,8), %r8
movq -0x8(%r8), %r9
addq $0x7, %r9
shrq $0x3, %r9
movq (%rsi,%rdi,8), %r10
movb (%rax,%r10,8), %dl
testb %dl, %dl
je 0xdcfe
leaq (%rax,%r10,8), %r10
incq %r10
xorl %eax, %eax
movl %eax, %r11d
shll $0x5, %r11d
addl %eax, %r11d
movsbl %dl, %eax
xorl %r11d, %eax
movb (%r10), %dl
incq %r10
testb %dl, %dl
jne 0xdcda
jmp 0xdd00
movq $-0x1, %rax
retq
xorl %eax, %eax
xorl %edx, %edx
divl %r9d
movq (%r8,%rdx,8), %rdx
cmpq $-0x1, %rdx
je 0xdd1f
movq (%rcx,%rdx,8), %rax
cmpq %rdi, (%rcx,%rax,8)
je 0xdd26
movq (%rsi,%rdx,8), %rdx
jmp 0xdd09
movq $-0x1, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: lookup
cell lookup(cell v, cell env, int req) {
	cell	e, n;

	while (env != NIL) {
		e = car(env);
		n = try_hash(v, e);
		if (n != NIL)
			return n;
		if (e != NIL)
			e = cdr(e);	/* skip over hash table */
		while (e != NIL) {
			if (v == caar(e))
				return car(e);
			e = cdr(e);
		}
		env = cdr(env);
	}
	if (!req)
		return NIL;
	if (special_p(v))
		error("invalid syntax", v);
	else
		error("symbol not bound", v);
	return NIL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, -0x2c(%rbp)
movq %rdi, %rbx
cmpq $-0x1, %rsi
je 0xddab
movq 0x10424(%rip), %r15     # 0x1e170
movq 0x1086d(%rip), %r12     # 0x1e5c0
movq %rsi, -0x38(%rbp)
movq (%r15,%rsi,8), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0xdc88
cmpq $-0x1, %rax
jne 0xde7e
cmpq $-0x1, %r13
je 0xdd7c
movq (%r12,%r13,8), %rax
jmp 0xdd97
movq $-0x1, %rax
jmp 0xdd97
movq (%r15,%rax,8), %r14
cmpq %rbx, (%r15,%r14,8)
je 0xde6c
movq (%r12,%rax,8), %rax
cmpq $-0x1, %rax
jne 0xdd85
movq -0x38(%rbp), %rsi
movq (%r12,%rsi,8), %rsi
cmpq $-0x1, %rsi
jne 0xdd53
movq $-0x1, %r14
cmpl $0x0, -0x2c(%rbp)
je 0xde6c
cmpq %rbx, 0x109cd(%rip)     # 0x1e790
leaq 0x8c90(%rip), %rax      # 0x16a5a
leaq 0x8c98(%rip), %rdi      # 0x16a69
cmoveq %rax, %rdi
cmpq %rbx, 0x10974(%rip)     # 0x1e750
cmoveq %rax, %rdi
cmpq %rbx, 0x10961(%rip)     # 0x1e748
cmoveq %rax, %rdi
cmpq %rbx, 0x1097e(%rip)     # 0x1e770
cmoveq %rax, %rdi
cmpq %rbx, 0x10963(%rip)     # 0x1e760
cmoveq %rax, %rdi
cmpq %rbx, 0x10930(%rip)     # 0x1e738
cmoveq %rax, %rdi
cmpq %rbx, 0x10975(%rip)     # 0x1e788
cmoveq %rax, %rdi
cmpq %rbx, 0x1094a(%rip)     # 0x1e768
cmoveq %rax, %rdi
cmpq %rbx, 0x108df(%rip)     # 0x1e708
cmoveq %rax, %rdi
cmpq %rbx, 0x108cc(%rip)     # 0x1e700
cmoveq %rax, %rdi
cmpq %rbx, 0x108a9(%rip)     # 0x1e6e8
cmoveq %rax, %rdi
cmpq %rbx, 0x108f6(%rip)     # 0x1e740
cmoveq %rax, %rdi
cmpq %rbx, 0x10903(%rip)     # 0x1e758
cmoveq %rax, %rdi
cmpq %rbx, 0x10848(%rip)     # 0x1e6a8
cmoveq %rax, %rdi
movq %rbx, %rsi
callq 0x33eb
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xde6c
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: make_sequence
cell make_sequence(int state, cell neutral, cell x, int *pc, int *ps) {
	if (cdr(x) == NIL) {
		return neutral;
	}
	else if (cddr(x) == NIL) {
		*pc = 1;
		return cadr(x);
	}
	else {
		*pc = 2;
		*ps = state;
		save(cdr(x));
		return cadr(x);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %edi, %eax
movq 0x106f3(%rip), %rdx     # 0x1e5c0
movq (%rdx,%rbx,8), %rdi
cmpq $-0x1, %rdi
je 0xdf1d
cmpq $-0x1, (%rdx,%rdi,8)
je 0xdf09
movl $0x2, (%rcx)
movl %eax, (%r8)
movq 0x1023a(%rip), %rsi     # 0x1e128
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x1022c(%rip)     # 0x1e128
movq 0x106bd(%rip), %rax     # 0x1e5c0
movq (%rax,%rbx,8), %rdi
jmp 0xdf0f
movl $0x1, (%rcx)
shlq $0x3, %rdi
addq 0x10256(%rip), %rdi     # 0x1e170
movq (%rdi), %rsi
movq %rsi, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: sf_if
cell sf_if(cell x, int *pc, int *ps) {
	cell	m;

	m = cdr(x);
	if (m == NIL || cdr(m) == NIL || cddr(m) == NIL)
		return too_few_args(x);
	if (cdddr(m) != NIL)
		return too_many_args(x);
	save(m);
	*pc = 2;
	*ps = EV_IF_PRED;
	return car(m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rsi
movq 0x10682(%rip), %rax     # 0x1e5c0
movq (%rax,%rdi,8), %r14
cmpq $-0x1, %r14
je 0xdf6c
movq (%rax,%r14,8), %rcx
cmpq $-0x1, %rcx
je 0xdf6c
movq (%rax,%rcx,8), %rcx
cmpq $-0x1, %rcx
je 0xdf6c
cmpq $-0x1, (%rax,%rcx,8)
je 0xdf8a
leaq 0x8b22(%rip), %rdi      # 0x16a8c
jmp 0xdf73
leaq 0x8b07(%rip), %rdi      # 0x16a7a
callq 0x33eb
movq $-0x5, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %rbx
movq 0x10194(%rip), %rsi     # 0x1e128
movq %r14, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x10183(%rip)     # 0x1e128
movl $0x2, (%r15)
movl $0x4, (%rbx)
movq 0x101b7(%rip), %rax     # 0x1e170
movq (%rax,%r14,8), %rax
jmp 0xdf7f
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: make_undefineds
cell make_undefineds(cell x) {
	cell	n;

	n = NIL;
	while (x != NIL) {
		n = node(UNDEFINED, n);
		x = cdr(x);
	}
	return n;
}

// Assembly:
cmpq $-0x1, %rdi
je 0xdffe
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $-0x1, %rax
movq $-0x5, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x105d3(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rbx,8), %rbx
cmpq $-0x1, %rbx
jne 0xdfd5
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq $-0x1, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: sf_letrec
cell sf_letrec(cell x, int *pc) {
	cell	p;

	if (!tuple_p(cdr(x)) || !tuple_p(cddr(x)))
		too_few_args(x);
	for (p = cadr(x); tuple_p(p); p = cdr(p)) {
		if (	!tuple_p(car(p)) ||
			!symbol_p(caar(p)) ||
			!tuple_p(cdar(p))
		)
			return error("letrec: malformed case", car(p));
	}
	if (p != NIL)
		return error("letrec: suntax error", x);
	*pc = 1;
	return make_recursive_fns(cadr(x), cddr(x));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10375(%rip), %rax     # 0x1e5c0
movq (%rax,%rdi,8), %rcx
testq %rcx, %rcx
js 0xe265
movq 0x10385(%rip), %rdx     # 0x1e5e0
testb $0x19, (%rdx,%rcx)
je 0xe307
leaq 0x880e(%rip), %rdi      # 0x16a7a
movq %rbx, %rsi
callq 0x33eb
movq 0xfef5(%rip), %rax      # 0x1e170
movq 0x1033e(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rbx,8), %rdx
movq (%rax,%rdx,8), %rdi
testq %rdi, %rdi
js 0xe2dd
movq 0x1034a(%rip), %r8      # 0x1e5e0
testb $0x19, (%r8,%rdi)
jne 0xe2dd
movq (%rax,%rdi,8), %rsi
testq %rsi, %rsi
js 0xe2ef
testb $0x19, (%r8,%rsi)
jne 0xe2ef
movq (%rax,%rsi,8), %r9
testq %r9, %r9
js 0xe2ef
testb $0x10, (%r8,%r9)
je 0xe2ef
cmpq $-0x22, (%rax,%r9,8)
jne 0xe2ef
movq (%rcx,%rsi,8), %r9
testq %r9, %r9
js 0xe2ef
testb $0x19, (%r8,%r9)
jne 0xe2ef
movq (%rcx,%rdi,8), %rdi
testq %rdi, %rdi
jns 0xe296
cmpq $-0x1, %rdi
je 0xe323
leaq 0x87cc(%rip), %rdi      # 0x16ab6
movq %rbx, %rsi
jmp 0xe2f6
leaq 0x87a9(%rip), %rdi      # 0x16a9f
callq 0x33eb
movq $-0x5, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq (%rax,%rcx,8), %rax
testq %rax, %rax
js 0xe265
testb $0x19, (%rdx,%rax)
jne 0xe265
jmp 0xe274
movl $0x1, (%r14)
movq (%rax,%rdx,8), %rdi
movq (%rcx,%rdx,8), %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xe006
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: sf_fn
cell sf_fn(cell x) {
	cell	n, a, cas, new;

	if (cdr(x) == NIL)
		return too_few_args(x);
	a = node(NIL, NIL);
	save(a);
	for (x = cdr(x); x != NIL; x = cdr(x)) {
		cas = car(x);
		if (!tuple_p(cas) || cdr(cas) == NIL)
			return error("fn: malformed case", cas);
		if (cddr(cas) != NIL) {
			n = node(S_begin, cdr(cas));
			n = node(n, NIL);
			n = node(car(cas), n);
			cas = n;
		}
		car(a) = cas;
		if (cdr(x) != NIL) {
			set(cdr(a), node(NIL, NIL));
			a = cdr(a);
		}
	}
	n = node(car(Stack), car(Stack));
	n = node(Environment, n);
	unsave(1);
	return new_atom(T_FUNCTION, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x10271(%rip), %rax     # 0x1e5c0
cmpq $-0x1, (%rax,%rdi,8)
je 0xe464
movq $-0x1, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
movq 0xfdaf(%rip), %rsi      # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0xfd9e(%rip)      # 0x1e128
movq 0x1022f(%rip), %rax     # 0x1e5c0
movq (%rax,%r14,8), %r15
cmpq $-0x1, %r15
je 0xe46d
movq 0xfdca(%rip), %rax      # 0x1e170
movq (%rax,%r15,8), %r14
testq %r14, %r14
js 0xe4c5
movq 0x10226(%rip), %rax     # 0x1e5e0
testb $0x19, (%rax,%r14)
jne 0xe4c5
movq 0x101f4(%rip), %rax     # 0x1e5c0
movq (%rax,%r14,8), %rsi
cmpq $-0x1, %rsi
je 0xe4c5
cmpq $-0x1, (%rax,%rsi,8)
je 0xe418
movq 0x10370(%rip), %rdi     # 0x1e758
xorl %edx, %edx
callq 0x36e8
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0xfd69(%rip), %rcx      # 0x1e170
movq (%rcx,%r14,8), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %r14
movq 0xfd51(%rip), %rax      # 0x1e170
movq %r14, (%rax,%rbx,8)
movq 0x10196(%rip), %rax     # 0x1e5c0
cmpq $-0x1, (%rax,%r15,8)
je 0xe454
movq $-0x1, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x10173(%rip), %rcx     # 0x1e5c0
movq %rax, (%rcx,%rbx,8)
movq %rax, %rbx
movq 0x10165(%rip), %rax     # 0x1e5c0
movq (%rax,%r15,8), %r15
jmp 0xe395
leaq 0x860f(%rip), %rdi      # 0x16a7a
jmp 0xe4cc
movq 0xfcfc(%rip), %rax      # 0x1e170
movq 0xfcad(%rip), %rcx      # 0x1e128
movq (%rax,%rcx,8), %rdi
movq %rdi, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0xfc78(%rip), %rdi      # 0x1e108
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
movl $0x1, %edi
callq 0x3851
movq $-0x1e, %rdi
movq %rbx, %rsi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x36e8
leaq 0x85ff(%rip), %rdi      # 0x16acb
movq %r14, %rsi
callq 0x33eb
movq $-0x5, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: sf_quote
cell sf_quote(cell x) {
	if (cdr(x) == NIL)
		return too_few_args(x);
	if (cddr(x) != NIL)
		return too_many_args(x);
	return cadr(x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rsi
movq 0x100cc(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rdi,8), %rax
cmpq $-0x1, %rax
je 0xe50e
cmpq $-0x1, (%rcx,%rax,8)
je 0xe523
leaq 0x8580(%rip), %rdi      # 0x16a8c
jmp 0xe515
leaq 0x8565(%rip), %rdi      # 0x16a7a
callq 0x33eb
movq $-0x5, %rax
jmp 0xe52e
movq 0xfc46(%rip), %rcx      # 0x1e170
movq (%rcx,%rax,8), %rax
popq %rbp
retq