LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0xb668
movq %rax, %rbx
cmpl $0xffffff2d, 0x126f9(%rip) # imm = 0xFFFFFF2D
jne 0xc13e
movq 0x12144(%rip), %rsi     # 0x1e128
movq %rbx, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x12133(%rip)     # 0x1e128
callq 0x9ac4
movl %eax, 0x126d0(%rip)     # 0x1e6d0
movq %rbx, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x12708(%rip), %rdi     # 0x1e720
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x120ee(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x120dd(%rip)     # 0x1e128
leaq 0xb07a(%rip), %rdi      # 0x170cc
callq 0xc148
movq %rax, %rbx
movq 0x120c7(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x120b6(%rip)     # 0x1e128
xorl %edi, %edi
callq 0xb317
movq 0x12688(%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 0x12679(%rip), %rdi     # 0x1e728
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x120b0(%rip), %rcx     # 0x1e170
movq 0x124f9(%rip), %rdx     # 0x1e5c0
movq 0x1205a(%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 0x12603(%rip), %rdi     # 0x1e708
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x12609(%rip), %rdi     # 0x1e730
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
movl $0x3, %edi
callq 0x384f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x12a54(%rip), %r12     # 0x1ebb8
leaq 0xae14(%rip), %r14      # 0x16f7f
leaq -0xf0(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x31f0
movq 0x12a2c(%rip), %r12     # 0x1ebb8
incq %r12
movq %r12, 0x12a22(%rip)     # 0x1ebb8
movq %r15, %rdi
callq 0x715b
cmpq $-0x1, %rax
jne 0xc172
leaq -0xf0(%rbp), %rdi
callq 0x720e
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: 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, 0x12500(%rip) # imm = 0xFFFFFF22
jne 0xc235
callq 0x9ac4
movl %eax, 0x124f3(%rip)     # 0x1e6d0
cmpl $0xfffffed1, %eax       # imm = 0xFFFFFED1
jne 0xc240
movq 0x123fd(%rip), %rax     # 0x1e5e8
movq 0x123ce(%rip), %rcx     # 0x1e5c0
movq 0x11f5f(%rip), %rdi     # 0x1e158
movq (%rcx,%rdi,8), %rcx
cmpb $0x3a, (%rax,%rcx,8)
jne 0xc240
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x12520(%rip), %rdi     # 0x1e738
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
callq 0x9ac4
movl %eax, 0x124a0(%rip)     # 0x1e6d0
movq %rbx, %rax
jmp 0xc25a
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xbfb5
leaq 0xa5eb(%rip), %rdi      # 0x16832
movq $-0x8, %rsi
callq 0x33eb
movq $-0x5, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x1245f(%rip) # imm = 0xFFFFFF2C
jne 0xc353
callq 0x9ac4
movl %eax, 0x1244e(%rip)     # 0x1e6d0
callq 0xa3ad
cmpl $0xffffff20, 0x1243f(%rip) # imm = 0xFFFFFF20
jne 0xc35e
movq 0x11e8a(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x11e79(%rip)     # 0x1e128
callq 0x9ac4
movl %eax, 0x12416(%rip)     # 0x1e6d0
callq 0xa3ad
cmpl $0xffffff33, 0x12407(%rip) # imm = 0xFFFFFF33
jne 0xc367
movq 0x11e52(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x11e41(%rip)     # 0x1e128
callq 0x9ac4
movl %eax, 0x123de(%rip)     # 0x1e6d0
callq 0xa3ad
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
movl $0x1, %edi
callq 0x384f
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
movl $0x1, %edi
callq 0x384f
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x123fd(%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 0xc1c0
leaq 0xa4ee(%rip), %rdi      # 0x16853
jmp 0xc378
movl $0x1, %edi
callq 0x384f
leaq 0xa4f5(%rip), %rdi      # 0x1686d
movq $-0x8, %rsi
callq 0x33eb
movq $-0x5, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x12330(%rip) # imm = 0xFFFFFF35
jne 0xc441
callq 0x9ac4
movl %eax, 0x1231f(%rip)     # 0x1e6d0
callq 0xc261
cmpl $0xffffff25, 0x12310(%rip) # imm = 0xFFFFFF25
jne 0xc447
movq 0x11d5b(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x11d4a(%rip)     # 0x1e128
callq 0x9ac4
movl %eax, 0x122e7(%rip)     # 0x1e6d0
xorl %edi, %edi
callq 0xb317
movq 0x12311(%rip), %rdi     # 0x1e708
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x11d08(%rip)     # 0x1e110
movl $0x1, %edi
callq 0x384f
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x11ce6(%rip), %rdi     # 0x1e110
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq $-0x1, 0x11cd1(%rip) # 0x1e110
jmp 0xc461
popq %rbp
jmp 0xc261
leaq 0xa439(%rip), %rdi      # 0x16887
movq $-0x8, %rsi
callq 0x33eb
movq $-0x5, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdi, %rdi
js 0xc4e0
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x12168(%rip), %rax     # 0x1e5e0
movb (%rax,%rbx), %al
testb $0x11, %al
jne 0xc4a1
movq 0x1213a(%rip), %rax     # 0x1e5c0
movq (%rax,%rbx,8), %rdi
callq 0xc463
movq 0x11cda(%rip), %rax     # 0x1e170
movq (%rax,%rbx,8), %rbx
testq %rbx, %rbx
jns 0xc471
jmp 0xc4da
testb $0x10, %al
je 0xc4da
movq 0x11cc4(%rip), %rax     # 0x1e170
cmpq $-0x22, (%rax,%rbx,8)
jne 0xc4da
movq 0x11c6e(%rip), %rcx     # 0x1e128
movq (%rax,%rcx,8), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x36e8
movq 0x11ca1(%rip), %rcx     # 0x1e170
movq 0x11c52(%rip), %rdx     # 0x1e128
movq %rax, (%rcx,%rdx,8)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x11c30(%rip), %rsi     # 0x1e128
movq $-0x1, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x11c1b(%rip)     # 0x1e128
movq %r14, %rdi
callq 0xc463
movq 0x11c54(%rip), %rax     # 0x1e170
movq 0x11c05(%rip), %rcx     # 0x1e128
movq (%rax,%rcx,8), %r15
cmpq $-0x1, %r15
je 0xc5c2
movq (%rax,%r15,8), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x11c26(%rip), %rcx     # 0x1e170
movq (%rcx,%r15,8), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x12201(%rip), %rdi     # 0x1e760
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x11c00(%rip), %rcx     # 0x1e170
movq %rax, (%rcx,%rbx,8)
movq 0x12045(%rip), %rax     # 0x1e5c0
cmpq $-0x1, (%rax,%r15,8)
je 0xc5c2
movq $-0x1, %rdi
movq $-0x1, %rsi
movl $0x8, %edx
callq 0x36e8
movq %rax, %r14
movq 0x1201c(%rip), %rcx     # 0x1e5c0
movq %rax, (%rcx,%rbx,8)
movq 0x11bc1(%rip), %rax     # 0x1e170
movq (%rcx,%r15,8), %r15
movq %r14, %rbx
cmpq $-0x1, %r15
jne 0xc531
jmp 0xc5c5
movq %rbx, %r14
movl $0x1, %edi
callq 0x384f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x112a8(%rip), %rsi     # 0x1e128
movq $-0x1, %r15
movq $-0x1, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x1128c(%rip)     # 0x1e128
movl 0x1182e(%rip), %eax     # 0x1e6d0
cmpl $0xffffff2e, %eax       # imm = 0xFFFFFF2E
je 0xcebd
cmpl $0xffffff1e, %eax       # imm = 0xFFFFFF1E
jne 0xcf8a
movl %ebx, %edi
callq 0xc5dd
jmp 0xcec4
movl %ebx, %edi
callq 0xc911
movq %rax, %r14
testl %ebx, %ebx
je 0xcf06
movq 0x1129e(%rip), %rax     # 0x1e170
cmpq $-0x1, %r15
je 0xcf50
movq (%rax,%r15,8), %r12
movq 0x11885(%rip), %r13     # 0x1e768
movq %r14, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x116c5(%rip), %rcx     # 0x1e5c0
cmpq %r13, %r12
jne 0xcf30
movq (%rcx,%r15,8), %rdx
jmp 0xcf43
movq %r14, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %r14
cmpq $-0x1, %r15
je 0xcf49
movq 0x11699(%rip), %rax     # 0x1e5c0
movq %r14, (%rax,%r15,8)
movq %r15, %r14
jmp 0xcf5b
movq 0x11239(%rip), %rdx     # 0x1e170
movq (%rdx,%r15,8), %rsi
movq (%rcx,%rsi,8), %rsi
movq (%rdx,%rsi,8), %rdx
movq %rax, (%rcx,%rdx,8)
jmp 0xcf5b
movq 0x11220(%rip), %rax     # 0x1e170
movq 0x111d1(%rip), %rcx     # 0x1e128
movq %r14, (%rax,%rcx,8)
cmpl $-0x65, 0x1176e(%rip)   # 0x1e6d0
jne 0xcf77
callq 0x9ac4
movl %eax, 0x11761(%rip)     # 0x1e6d0
movq %r14, %r15
jmp 0xcea2
movl $0x1, %edi
callq 0x384f
testl %ebx, %ebx
je 0xcfb0
movq %r14, %rdi
jmp 0xcfc5
movl $0x1, %edi
callq 0x384f
leaq 0x9995(%rip), %rdi      # 0x16930
movq $-0x8, %rsi
callq 0x33eb
movq $-0x5, %rax
jmp 0xcfe8
movq 0x11609(%rip), %rcx     # 0x1e5c0
cmpq $-0x1, (%rcx,%rax,8)
je 0xcfdd
movq 0x11793(%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 0x1118c(%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_O3/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 0x9ac4
movl %eax, 0x116c8(%rip)     # 0x1e6d0
movl $0x1, %edi
callq 0xce69
movq 0x1110f(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x110fe(%rip)     # 0x1e128
cmpl $0xffffff2b, 0x1169c(%rip) # imm = 0xFFFFFF2B
jne 0xd0c8
callq 0x9ac4
movl %eax, 0x1168b(%rip)     # 0x1e6d0
xorl %edi, %edi
callq 0xce69
movq 0x110d5(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x110c4(%rip)     # 0x1e128
cmpl $0xffffff32, 0x11662(%rip) # imm = 0xFFFFFF32
jne 0xd0db
callq 0x9ac4
movl %eax, 0x11655(%rip)     # 0x1e6d0
movl $0x1, %edi
callq 0x384f
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
movl $0x1, %edi
callq 0x384f
movq 0x110c6(%rip), %rdx     # 0x1e170
movq (%rdx,%rax,8), %rsi
movq (%rdx,%rsi,8), %rdi
movq 0x11507(%rip), %rcx     # 0x1e5c0
cmpq 0x116a8(%rip), %rdi     # 0x1e768
jne 0xd101
leaq (%rcx,%rsi,8), %rdx
jmp 0xd109
movl $0x1, %edi
callq 0x384f
leaq 0x98ad(%rip), %rdi      # 0x16986
jmp 0xd0ec
movl $0x2, %edi
callq 0x384f
leaq 0x98b2(%rip), %rdi      # 0x1699e
movq $-0x8, %rsi
callq 0x33eb
movq $-0x5, %rax
jmp 0xd114
movq (%rcx,%rdi,8), %rsi
leaq (%rdx,%rsi,8), %rdx
movq (%rdx), %rdx
movq %rbx, (%rcx,%rdx,8)
movq (%rcx,%rax,8), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: 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 0x1101d(%rip), %rdx     # 0x1e150
movq 0x11486(%rip), %r15     # 0x1e5c0
movq (%r15,%rdx,8), %rcx
movq $-0x1, %rax
cmpq $-0x1, %rcx
je 0xd1ae
movq %rdi, %r14
movq 0x1101b(%rip), %r13     # 0x1e170
movq 0x1148c(%rip), %rbx     # 0x1e5e8
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq (%r13,%rcx,8), %r12
cmpq $-0x1, %r12
je 0xd193
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 0xd1aa
movq (%r15,%r12,8), %r12
jmp 0xd169
movq -0x38(%rbp), %rdx
movq (%r15,%rdx,8), %rcx
cmpq $-0x1, %rcx
jne 0xd15c
movq $-0x1, %rax
jmp 0xd1ae
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_O3/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 0x113f6(%rip), %rbx     # 0x1e5c0
movq (%rbx,%rdi,8), %rdi
shlq $0x3, %rdi
addq 0x1140f(%rip), %rdi     # 0x1e5e8
callq 0xd11b
cmpq $-0x1, %rax
je 0xd20e
movq 0x10f85(%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 0xd20e
movq (%rbx,%rcx,8), %rcx
movq %rcx, (%rbx,%rax,8)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xd11b
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 0x10eb1(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x10ea0(%rip)     # 0x1e128
movq 0x11331(%rip), %rax     # 0x1e5c0
movq (%rax,%r15,8), %rdi
shlq $0x3, %rdi
addq 0x1134a(%rip), %rdi     # 0x1e5e8
callq 0x30a0
movq %rax, %r13
incl %r13d
movq $-0x21, %rdi
movl %r13d, %esi
callq 0x416e
movq %rax, %r12
movq 0x112fe(%rip), %rax     # 0x1e5c0
movq (%rax,%r12,8), %rdi
shlq $0x3, %rdi
addq 0x11317(%rip), %rdi     # 0x1e5e8
movslq %r13d, %rdx
xorl %esi, %esi
callq 0x30d0
movq 0x11306(%rip), %rax     # 0x1e5e8
movq 0x112d7(%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 0x384f
movq %r12, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movslq %r14d, %rcx
cmpq %rcx, 0x11459(%rip)     # 0x1e778
jne 0xd349
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
leaq 0x11287(%rip), %r14     # 0x1e5c0
movq %rbx, %rcx
shlq $0x3, %rcx
addq 0x11279(%rip), %rcx     # 0x1e5c0
jmp 0xd3a5
cmpq %rcx, 0x113a8(%rip)     # 0x1e6f8
jne 0xd375
movq 0x11267(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rbx,8), %rbx
leaq 0x10e0c(%rip), %r14     # 0x1e170
leaq (,%rbx,8), %rcx
addq 0x10dfd(%rip), %rcx     # 0x1e170
jmp 0xd3a5
cmpq %rcx, 0x11404(%rip)     # 0x1e780
jne 0xd3b9
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
leaq 0x1122a(%rip), %r14     # 0x1e5c0
movq 0x11223(%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_O3/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 0x10b00(%rip), %rsi     # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x10aef(%rip)     # 0x1e128
callq 0x9ac4
movl %eax, 0x1108c(%rip)     # 0x1e6d0
cmpl $0xfffffed1, %eax       # imm = 0xFFFFFED1
jne 0xd73a
movq 0x10f92(%rip), %rax     # 0x1e5e8
movq 0x10f63(%rip), %rcx     # 0x1e5c0
movq 0x10af4(%rip), %rdi     # 0x1e158
movq (%rcx,%rdi,8), %rcx
cmpb $0x3a, (%rax,%rcx,8)
jne 0xd73a
movq 0x10aaf(%rip), %rsi     # 0x1e128
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x10aa1(%rip)     # 0x1e128
movq 0x10aca(%rip), %rdi     # 0x1e158
movq 0x10acb(%rip), %rsi     # 0x1e160
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x10abd(%rip)     # 0x1e160
movq 0x10aae(%rip), %rdi     # 0x1e158
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x10a99(%rip), %rdi     # 0x1e158
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x110a0(%rip), %rdi     # 0x1e770
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x10a8f(%rip), %rcx     # 0x1e170
movq %rax, (%rcx,%rbx,8)
movl $0x1, %edi
callq 0x384f
callq 0x9ac4
movl %eax, 0x10fd6(%rip)     # 0x1e6d0
cmpl $0xffffff37, %eax       # imm = 0xFFFFFF37
jne 0xd759
movq $-0x1, %rdi
movq $-0x1, %rsi
movl $0x8, %edx
callq 0x36e8
movq %rax, %r14
movq 0x10e9d(%rip), %rax     # 0x1e5c0
movq %r14, (%rax,%rbx,8)
callq 0x9ac4
movl %eax, 0x10f9e(%rip)     # 0x1e6d0
movq %r14, %rbx
jmp 0xd644
movq 0x10a17(%rip), %rsi     # 0x1e158
leaq 0x9182(%rip), %rdi      # 0x168ca
callq 0x33eb
movq $-0x5, %rax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x1, %edi
callq 0x384f
movq 0x10e56(%rip), %rcx     # 0x1e5c0
cmpq $-0x1, (%rcx,%rax,8)
je 0xd786
movq 0x10fe0(%rip), %rdi     # 0x1e758
movq %rax, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x36e8
movq 0x109e3(%rip), %rcx     # 0x1e170
movq (%rcx,%rax,8), %rax
jmp 0xd754
// File: /workspace/github_c_makefile_star2_O3/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 0xd7cd
movq 0x10e3c(%rip), %rcx     # 0x1e5e0
movq 0x10e15(%rip), %rax     # 0x1e5c0
movq %rdi, %r8
testq %r8, %r8
js 0xd7d5
movq %r8, %rdx
testb $0x11, (%rcx,%r8)
jne 0xd7d5
movq (%rax,%rdx,8), %r8
cmpq $-0x1, %r8
jne 0xd7ae
movq %rsi, (%rax,%rdx,8)
jmp 0xd7d0
movq %rsi, %rdi
movq %rdi, %rax
popq %rbp
retq
leaq 0x924c(%rip), %rdi      # 0x16a28
callq 0x3ab4
// File: /workspace/github_c_makefile_star2_O3/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:
movb $0x1, %al
cmpq $-0x1, %rdi
je 0xd81b
testq %rdi, %rdi
js 0xd819
pushq %rbp
movq %rsp, %rbp
movq 0x10de7(%rip), %rcx     # 0x1e5e0
movb (%rcx,%rdi), %dl
testb $0x10, %dl
je 0xd80f
movq 0x10968(%rip), %rsi     # 0x1e170
cmpq $-0x22, (%rsi,%rdi,8)
je 0xd816
testb $0x11, %dl
je 0xd81f
xorl %eax, %eax
popq %rbp
jmp 0xd81b
xorl %eax, %eax
movzbl %al, %eax
retq
movq 0x1094a(%rip), %rax     # 0x1e170
movq 0x10d93(%rip), %rdx     # 0x1e5c0
movb (%rcx,%rdi), %sil
testb $0x19, %sil
jne 0xd85c
movq (%rax,%rdi,8), %rsi
testq %rsi, %rsi
js 0xd814
testb $0x10, (%rcx,%rsi)
je 0xd814
cmpq $-0x22, (%rax,%rsi,8)
jne 0xd814
movq (%rdx,%rdi,8), %rdi
testq %rdi, %rdi
jns 0xd82d
cmpq $-0x1, %rdi
jmp 0xd867
testb $0x10, %sil
je 0xd814
cmpq $-0x22, (%rax,%rdi,8)
sete %al
jmp 0xd816
// File: /workspace/github_c_makefile_star2_O3/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 0xd8d8
movl $0xb, %eax
cmpl $0xb, %edi
jb 0xd8d8
movl $0x17, %eax
cmpl $0x17, %edi
jb 0xd8d8
movl $0x2f, %eax
cmpl $0x2f, %edi
jb 0xd8d8
movl $0x61, %eax
cmpl $0x61, %edi
jb 0xd8d8
movl $0xc7, %eax
cmpl $0xc7, %edi
jb 0xd8d8
movl $0x1f3, %eax            # imm = 0x1F3
cmpl $0x1f3, %edi            # imm = 0x1F3
jb 0xd8d8
movl $0x3e5, %eax            # imm = 0x3E5
cmpl $0x3e5, %edi            # imm = 0x3E5
jb 0xd8d8
movl $0x26f5, %ecx           # imm = 0x26F5
cmpl %ecx, %edi
movl $0x4e1d, %eax           # imm = 0x4E1D
cmovbl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
subq $0x18, %rsp
movq %rdi, %rcx
cmpq $-0x1, %rdi
je 0xd90e
xorl %edi, %edi
movq 0x10cc3(%rip), %rax     # 0x1e5c0
movq %rcx, %rbx
incl %edi
movq (%rax,%rcx,8), %rcx
cmpq $-0x1, %rcx
jne 0xd900
jmp 0xd913
movq %rcx, %rbx
xorl %edi, %edi
callq 0xd86c
movq %rax, -0x38(%rbp)
cmpq $-0x1, 0x107d4(%rip)    # 0x1e0f8
je 0xda07
movq -0x38(%rbp), %rax
leal (,%rax,8), %esi
movq %rsi, -0x30(%rbp)
movq $-0x24, %rdi
callq 0x416e
movq 0x10824(%rip), %r14     # 0x1e170
movq %rbx, %r13
movq %rax, (%r14,%rbx,8)
movq 0x10c8e(%rip), %rbx     # 0x1e5e8
movq 0x10c5f(%rip), %r15     # 0x1e5c0
movq (%r15,%rax,8), %rax
leaq (%rbx,%rax,8), %r12
movq %r12, %rdi
movl $0xff, %esi
movq -0x30(%rbp), %rdx
callq 0x30d0
movq %r13, -0x30(%rbp)
movq (%r15,%r13,8), %r13
cmpq $-0x1, %r13
je 0xda07
movq %r12, %r8
movq (%r14,%r13,8), %rdi
movq (%r14,%rdi,8), %rax
movq (%r15,%rax,8), %rdx
movb (%rbx,%rdx,8), %cl
movl $0x0, %eax
testb %cl, %cl
je 0xd9c1
leaq (%rbx,%rdx,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 0xd9ac
xorl %edx, %edx
divl -0x38(%rbp)
movl %edx, %r12d
movq (%r8,%r12,8), %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x10c0d(%rip), %rbx     # 0x1e5e8
movq 0x10bde(%rip), %r15     # 0x1e5c0
movq 0x10787(%rip), %r14     # 0x1e170
movq -0x30(%rbp), %rcx
movq (%r14,%rcx,8), %rcx
movq (%r15,%rcx,8), %rcx
leaq (%rbx,%rcx,8), %r8
movq %rax, (%r8,%r12,8)
movq (%r15,%r13,8), %r13
cmpq $-0x1, %r13
jne 0xd98b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: 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 0x10b93(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rbx,8), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq 0x10b7e(%rip), %rcx     # 0x1e5c0
movq %rax, (%rcx,%rbx,8)
movq 0x10b7b(%rip), %rax     # 0x1e5c8
cmpq $-0x3, (%rcx,%rax,8)
jne 0xda5c
movq %rbx, %rdi
callq 0xd8da
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x10696(%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, 0x1066a(%rip) # 0x1e110
cmpq $-0x1, %r14
je 0xdaf6
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq 0x10b08(%rip), %rcx     # 0x1e5c0
movq %r14, %rdx
movq (%rcx,%rdx,8), %rdx
incl %eax
cmpq $-0x1, %rdx
jne 0xdabb
cmpl $0x4, %eax
jb 0xdaf6
movq 0x10655(%rip), %rsi     # 0x1e128
movq %rbx, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x10644(%rip)     # 0x1e128
movq %r14, %rdi
callq 0xd8da
movl $0x1, %edi
callq 0x384f
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xdb6c
pushq %rbp
movq %rsp, %rbp
movq 0x10661(%rip), %rcx     # 0x1e170
movq (%rcx,%rsi,8), %rdx
cmpq $-0x1, %rdx
je 0xdb95
movq 0x10ac8(%rip), %rax     # 0x1e5e8
movq 0x10a99(%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 0xdb74
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 0xdb50
jmp 0xdb76
movq $-0x1, %rax
retq
xorl %eax, %eax
xorl %edx, %edx
divl %r9d
movq (%r8,%rdx,8), %rdx
cmpq $-0x1, %rdx
je 0xdb95
movq (%rcx,%rdx,8), %rax
cmpq %rdi, (%rcx,%rax,8)
je 0xdb9c
movq (%rsi,%rdx,8), %rdx
jmp 0xdb7f
movq $-0x1, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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, %rcx
cmpq $-0x1, %rsi
je 0xdc1e
movq 0x105ae(%rip), %r15     # 0x1e170
movq 0x109f7(%rip), %rbx     # 0x1e5c0
movq %rsi, -0x38(%rbp)
movq (%r15,%rsi,8), %r13
movq %rcx, %r12
movq %rcx, %rdi
movq %r13, %rsi
callq 0xdafe
cmpq $-0x1, %rax
jne 0xdce1
cmpq $-0x1, %r13
movq %r12, %rcx
je 0xdc10
movq (%rbx,%r13,8), %rax
cmpq $-0x1, %rax
je 0xdc10
movq (%r15,%rax,8), %r14
cmpq %rcx, (%r15,%r14,8)
je 0xdce4
movq (%rbx,%rax,8), %rax
jmp 0xdbf6
movq -0x38(%rbp), %rsi
movq (%rbx,%rsi,8), %rsi
cmpq $-0x1, %rsi
jne 0xdbc9
movq $-0x1, %r14
cmpl $0x0, -0x2c(%rbp)
je 0xdce4
cmpq %rcx, 0x10b5a(%rip)     # 0x1e790
leaq 0x8e02(%rip), %rax      # 0x16a3f
leaq 0x8e0a(%rip), %rdi      # 0x16a4e
cmoveq %rax, %rdi
cmpq %rcx, 0x10b01(%rip)     # 0x1e750
cmoveq %rax, %rdi
cmpq %rcx, 0x10aee(%rip)     # 0x1e748
cmoveq %rax, %rdi
cmpq %rcx, 0x10b0b(%rip)     # 0x1e770
cmoveq %rax, %rdi
cmpq %rcx, 0x10af0(%rip)     # 0x1e760
cmoveq %rax, %rdi
cmpq %rcx, 0x10abd(%rip)     # 0x1e738
cmoveq %rax, %rdi
cmpq %rcx, 0x10b02(%rip)     # 0x1e788
cmoveq %rax, %rdi
cmpq %rcx, 0x10ad7(%rip)     # 0x1e768
cmoveq %rax, %rdi
cmpq %rcx, 0x10a6c(%rip)     # 0x1e708
cmoveq %rax, %rdi
cmpq %rcx, 0x10a59(%rip)     # 0x1e700
cmoveq %rax, %rdi
cmpq %rcx, 0x10a36(%rip)     # 0x1e6e8
cmoveq %rax, %rdi
cmpq %rcx, 0x10a83(%rip)     # 0x1e740
cmoveq %rax, %rdi
cmpq %rcx, 0x10a90(%rip)     # 0x1e758
cmoveq %rax, %rdi
cmpq %rcx, 0x109d5(%rip)     # 0x1e6a8
cmoveq %rax, %rdi
movq %rcx, %rsi
callq 0x33eb
jmp 0xdce4
movq %rax, %r14
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: 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 0x10880(%rip), %rdx     # 0x1e5c0
movq (%rdx,%rbx,8), %rdi
cmpq $-0x1, %rdi
je 0xdd90
cmpq $-0x1, (%rdx,%rdi,8)
je 0xdd7c
movl $0x2, (%rcx)
movl %eax, (%r8)
movq 0x103c7(%rip), %rsi     # 0x1e128
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x103b9(%rip)     # 0x1e128
movq 0x1084a(%rip), %rax     # 0x1e5c0
movq (%rax,%rbx,8), %rdi
jmp 0xdd82
movl $0x1, (%rcx)
shlq $0x3, %rdi
addq 0x103e3(%rip), %rdi     # 0x1e170
movq (%rdi), %rsi
movq %rsi, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1080f(%rip), %rax     # 0x1e5c0
movq (%rax,%rdi,8), %r14
cmpq $-0x1, %r14
je 0xdddf
movq (%rax,%r14,8), %rcx
cmpq $-0x1, %rcx
je 0xdddf
movq (%rax,%rcx,8), %rcx
cmpq $-0x1, %rcx
je 0xdddf
cmpq $-0x1, (%rax,%rcx,8)
je 0xddfd
leaq 0x8c94(%rip), %rdi      # 0x16a71
jmp 0xdde6
leaq 0x8c79(%rip), %rdi      # 0x16a5f
callq 0x33eb
movq $-0x5, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %rbx
movq 0x10321(%rip), %rsi     # 0x1e128
movq %r14, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0x10310(%rip)     # 0x1e128
movl $0x2, (%r15)
movl $0x4, (%rbx)
movq 0x10344(%rip), %rax     # 0x1e170
movq (%rax,%r14,8), %rax
jmp 0xddf2
// File: /workspace/github_c_makefile_star2_O3/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 0xde71
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 0x10760(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rbx,8), %rbx
cmpq $-0x1, %rbx
jne 0xde48
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq $-0x1, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x10502(%rip), %rax     # 0x1e5c0
movq (%rax,%rdi,8), %rcx
testq %rcx, %rcx
js 0xe0d8
movq 0x10512(%rip), %rdx     # 0x1e5e0
testb $0x19, (%rdx,%rcx)
je 0xe180
leaq 0x8980(%rip), %rdi      # 0x16a5f
movq %rbx, %rsi
callq 0x33eb
movq 0x104d2(%rip), %rax     # 0x1e5c0
movq (%rax,%rbx,8), %rcx
movq 0x10077(%rip), %rdx     # 0x1e170
movq (%rdx,%rcx,8), %rdi
movq %rdi, %r8
testq %rdi, %rdi
js 0xe156
movq 0x104d4(%rip), %r9      # 0x1e5e0
movq %rdi, %r8
testb $0x19, (%r9,%r8)
jne 0xe15c
movq (%rdx,%r8,8), %rsi
testq %rsi, %rsi
js 0xe168
testb $0x19, (%r9,%rsi)
jne 0xe168
movq (%rdx,%rsi,8), %r10
testq %r10, %r10
js 0xe168
testb $0x10, (%r9,%r10)
je 0xe168
cmpq $-0x22, (%rdx,%r10,8)
jne 0xe168
movq (%rax,%rsi,8), %r10
testq %r10, %r10
js 0xe168
testb $0x19, (%r9,%r10)
jne 0xe168
movq (%rax,%r8,8), %r8
testq %r8, %r8
jns 0xe10f
cmpq $-0x1, %r8
je 0xe19c
leaq 0x8938(%rip), %rdi      # 0x16a9b
movq %rbx, %rsi
jmp 0xe16f
leaq 0x8915(%rip), %rdi      # 0x16a84
callq 0x33eb
movq $-0x5, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq (%rax,%rcx,8), %rsi
testq %rsi, %rsi
js 0xe0d8
testb $0x19, (%rdx,%rsi)
jne 0xe0d8
jmp 0xe0f2
movl $0x1, (%r14)
movq (%rax,%rcx,8), %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xde79
// File: /workspace/github_c_makefile_star2_O3/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 0x103fc(%rip), %rax     # 0x1e5c0
cmpq $-0x1, (%rax,%rdi,8)
je 0xe328
movq $-0x1, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
movq 0xff3a(%rip), %rsi      # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0xff29(%rip)      # 0x1e128
movq 0x103ba(%rip), %rdx     # 0x1e5c0
movq (%rdx,%r14,8), %r15
movq 0xff5f(%rip), %rcx      # 0x1e170
cmpq $-0x1, %r15
je 0xe2de
movq (%rcx,%r15,8), %r14
testq %r14, %r14
js 0xe331
movq 0x103b1(%rip), %rax     # 0x1e5e0
testb $0x19, (%rax,%r14)
jne 0xe331
movq (%rdx,%r14,8), %rsi
cmpq $-0x1, %rsi
je 0xe331
cmpq $-0x1, (%rdx,%rsi,8)
je 0xe294
movq 0x10502(%rip), %rdi     # 0x1e758
xorl %edx, %edx
callq 0x36e8
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0xfefb(%rip), %rcx      # 0x1e170
movq (%rcx,%r14,8), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %r14
movq 0xfee3(%rip), %rcx      # 0x1e170
movq 0x1032c(%rip), %rdx     # 0x1e5c0
movq %r14, (%rcx,%rbx,8)
cmpq $-0x1, (%rdx,%r15,8)
je 0xe2d7
movq $-0x1, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0x10305(%rip), %rdx     # 0x1e5c0
movq %rax, (%rdx,%rbx,8)
movq 0xfeaa(%rip), %rcx      # 0x1e170
movq (%rdx,%r15,8), %r15
movq %rax, %rbx
cmpq $-0x1, %r15
jne 0xe21b
movq 0xfe4a(%rip), %rax      # 0x1e128
movq (%rcx,%rax,8), %rdi
movq %rdi, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0xfe15(%rip), %rdi      # 0x1e108
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq %rax, %rbx
movl $0x1, %edi
callq 0x384f
movq $-0x1e, %rdi
movq %rbx, %rsi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x36e8
leaq 0x8730(%rip), %rdi      # 0x16a5f
jmp 0xe338
leaq 0x8778(%rip), %rdi      # 0x16ab0
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_O3/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 0x10260(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rdi,8), %rax
cmpq $-0x1, %rax
je 0xe37a
cmpq $-0x1, (%rcx,%rax,8)
je 0xe38f
leaq 0x86f9(%rip), %rdi      # 0x16a71
jmp 0xe381
leaq 0x86de(%rip), %rdi      # 0x16a5f
callq 0x33eb
movq $-0x5, %rax
jmp 0xe39a
movq 0xfdda(%rip), %rcx      # 0x1e170
movq (%rcx,%rax,8), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: sf_setb
cell sf_setb(cell x, int *pc, int *ps) {
	cell	n;
	int	k;

	k = length(x);
	if (k < 3) return too_few_args(x);
	if (k > 3) return too_many_args(x);
	if (!symbol_p(cadr(x)))
		return error("setb: expected id, got", cadr(x));
	n = lookup(cadr(x), Environment, 1);
	if (Error_flag)
		return NIL;
	save(n);
	*pc = 2;
	*ps = EV_SET_VAL;
	return caddr(x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $-0x1, %rdi
je 0xe3fd
movq %rdx, %r14
movq %rsi, %r15
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq 0x101d7(%rip), %rax     # 0x1e5c0
movq %rbx, %rdx
movq (%rax,%rdx,8), %rdx
incl %ecx
cmpq $-0x1, %rdx
jne 0xe3ec
cmpl $0x1, %ecx
ja 0xe41e
leaq 0x865b(%rip), %rdi      # 0x16a5f
movq %rbx, %rsi
callq 0x33eb
movq $-0x5, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x2, %ecx
jne 0xe4bf
movq 0xfd42(%rip), %rcx      # 0x1e170
movq (%rax,%rbx,8), %rax
movq (%rcx,%rax,8), %rsi
testq %rsi, %rsi
js 0xe4cb
movq 0x1019a(%rip), %rax     # 0x1e5e0
testb $0x10, (%rax,%rsi)
je 0xe4cb
cmpq $-0x22, (%rcx,%rsi,8)
jne 0xe4cb
movq 0xfcae(%rip), %rax      # 0x1e108
movq %rsi, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0xdb9e
movq %rax, %rdi
movq $-0x1, %rax
cmpl $0x0, 0x10139(%rip)     # 0x1e5b4
jne 0xe413
movq 0xfca4(%rip), %rsi      # 0x1e128
xorl %edx, %edx
callq 0x36e8
movq %rax, 0xfc96(%rip)      # 0x1e128
movl $0x2, (%r15)
movl $0x5, (%r14)
movq 0xfcc9(%rip), %rax      # 0x1e170
movq 0x10112(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
jmp 0xe413
leaq 0x85ab(%rip), %rdi      # 0x16a71
jmp 0xe404
leaq 0x85f1(%rip), %rdi      # 0x16ac3
jmp 0xe407
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: root_env
cell root_env(void) {
	cell	e;

	for (e = Environment; e != NIL && cdr(e) != NIL; e = cdr(e))
		;
	if (e == NIL)
		fatal("no root environment? oops!");
	return e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xfc26(%rip), %rdx      # 0x1e108
movq 0x100d7(%rip), %rcx     # 0x1e5c0
cmpq $-0x1, %rdx
je 0xe4fe
movq %rdx, %rax
movq (%rcx,%rdx,8), %rdx
cmpq $-0x1, %rdx
jne 0xe4e9
popq %rbp
retq
leaq 0x85d5(%rip), %rdi      # 0x16ada
callq 0x3ab4
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: find_local_variable
cell find_local_variable(cell v, cell e) {
	if (e == NIL)
		return NIL;
	e = cdr(e);
	while (e != NIL) {
		if (v == caar(e))
			return car(e);
		e = cdr(e);
	}
	return NIL;
}

// Assembly:
cmpq $-0x1, %rsi
je 0xe538
pushq %rbp
movq %rsp, %rbp
movq 0x100a5(%rip), %rcx     # 0x1e5c0
movq 0xfc4e(%rip), %rdx      # 0x1e170
movq (%rcx,%rsi,8), %rsi
cmpq $-0x1, %rsi
je 0xe540
movq (%rdx,%rsi,8), %rax
cmpq %rdi, (%rdx,%rax,8)
jne 0xe522
jmp 0xe547
movq $-0x1, %rax
retq
movq $-0x1, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: sf_define
cell sf_define(int syntax, cell x, int *pc, int *ps) {
	cell	v, a, n, new, e;
	int	k;

	if (car(State_stack) == EV_ARGS)
		return error(syntax?
				"define_syntax: invalid context":
				"define: invalid context",
				x);
	k = length(x);
	if (k < 3)
		return too_few_args(x);
	if (k > 3)
		return too_many_args(x);
	if (!symbol_p(cadr(x)))
		return error(syntax?
				"define_syntax: expected id, got":
				"define: expected id, got",
				cadr(x));
	save(NIL);
	a = caddr(x);
	n = cadr(x);
	e = root_env();
	v = find_local_variable(n, car(e));
	if (v == NIL) {
		set(car(e), extend(n, UNDEFINED, car(e)));
		v = cadar(e);
	}
	car(Stack) = binding_box(v);
	*pc = 2;
	if (syntax)
		*ps = EV_MACRO;
	else
		*ps = EV_SET_VAL;
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r12
movl %edi, %r14d
movq 0xfc09(%rip), %rax      # 0x1e170
movq 0xfbca(%rip), %rcx      # 0x1e138
cmpq $0x1, (%rax,%rcx,8)
jne 0xe58c
testl %r14d, %r14d
leaq 0x8595(%rip), %rax      # 0x16b14
leaq 0x856f(%rip), %rdi      # 0x16af5
cmoveq %rax, %rdi
jmp 0xe5bc
cmpq $-0x1, %r12
je 0xe5b5
movq %rdx, %r15
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movq 0x1001f(%rip), %rcx     # 0x1e5c0
movq %r12, %rsi
movq (%rcx,%rsi,8), %rsi
incl %edx
cmpq $-0x1, %rsi
jne 0xe5a4
cmpl $0x1, %edx
ja 0xe5dd
leaq 0x84a3(%rip), %rdi      # 0x16a5f
movq %r12, %rsi
callq 0x33eb
movq $-0x5, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x2, %edx
jne 0xe6e5
movq (%rcx,%r12,8), %rcx
movq (%rax,%rcx,8), %rsi
testq %rsi, %rsi
js 0xe6f1
movq 0xffe2(%rip), %rcx      # 0x1e5e0
testb $0x10, (%rcx,%rsi)
je 0xe6f1
cmpq $-0x22, (%rax,%rsi,8)
jne 0xe6f1
movq 0xfb0e(%rip), %rsi      # 0x1e128
movq $-0x1, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0xfaf9(%rip)      # 0x1e128
movq 0xfb3a(%rip), %rcx      # 0x1e170
movq 0xff83(%rip), %r9       # 0x1e5c0
movq (%r9,%r12,8), %rsi
movq (%r9,%rsi,8), %rdi
movq (%rcx,%rdi,8), %r12
movq (%rcx,%rsi,8), %rdi
movq 0xfab4(%rip), %rsi      # 0x1e108
cmpq $-0x1, %rsi
je 0xe70b
movq %rsi, %r13
movq (%r9,%rsi,8), %rsi
cmpq $-0x1, %rsi
jne 0xe654
movq (%rcx,%r13,8), %rdx
cmpq $-0x1, %rdx
je 0xe692
movq %rdx, %r8
movq (%r9,%r8,8), %r8
cmpq $-0x1, %r8
je 0xe692
movq (%rcx,%r8,8), %rsi
cmpq %rdi, (%rcx,%rsi,8)
jne 0xe678
cmpq $-0x1, %rsi
jne 0xe6c7
movq $-0x5, %rsi
movq %rdx, -0x30(%rbp)
callq 0xda16
movq 0xfac7(%rip), %rcx      # 0x1e170
movq -0x30(%rbp), %rdx
movq %rdx, (%rcx,%r13,8)
movq 0xff08(%rip), %rax      # 0x1e5c0
movq (%rax,%rdx,8), %rax
movq (%rcx,%rax,8), %rsi
movq 0xfa61(%rip), %rax      # 0x1e128
movq %rsi, (%rcx,%rax,8)
movl $0x2, (%r15)
cmpl $0x1, %r14d
movl $0x6, %eax
sbbl $0x0, %eax
movl %eax, (%rbx)
jmp 0xe5cb
leaq 0x8385(%rip), %rdi      # 0x16a71
jmp 0xe5bc
testl %r14d, %r14d
leaq 0x8451(%rip), %rax      # 0x16b4c
leaq 0x842a(%rip), %rdi      # 0x16b2c
cmoveq %rax, %rdi
jmp 0xe5bf
leaq 0x83c8(%rip), %rdi      # 0x16ada
callq 0x3ab4
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: a_name
cell a_name(cell n, int id) {
	char	s[TOKEN_LENGTH+10];

	if (!strcmp(string(n), "::"))
		strcpy(s, "%cons");
	else
		strcpy(s, string(n)+1);
	sprintf(&s[strlen(s)], ":%d", id);
	return symbol_ref(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x410, %rsp            # imm = 0x410
movl %esi, %ebx
movq 0xfeba(%rip), %rax      # 0x1e5e8
movq 0xfe8b(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rdi,8), %rcx
leaq (%rax,%rcx,8), %rsi
cmpb $0x3a, (%rsi)
jne 0xe74e
cmpb $0x3a, 0x1(%rsi)
jne 0xe74e
cmpb $0x0, 0x2(%rsi)
je 0xe79b
incq %rsi
leaq -0x420(%rbp), %rdi
callq 0x3060
leaq -0x420(%rbp), %r14
movq %r14, %rdi
callq 0x30a0
leaq (%rax,%rbp), %rdi
addq $-0x420, %rdi           # imm = 0xFBE0
leaq 0x83ed(%rip), %rsi      # 0x16b6b
movl %ebx, %edx
xorl %eax, %eax
callq 0x31f0
movq %r14, %rdi
callq 0x720e
addq $0x410, %rsp            # imm = 0x410
popq %rbx
popq %r14
popq %rbp
retq
movw $0x73, -0x41c(%rbp)
movl $0x6e6f6325, -0x420(%rbp) # imm = 0x6E6F6325
jmp 0xe75d
// File: /workspace/github_c_makefile_star2_O3/azhai[P]mlite/mlite.c
// Function: sf_redirect
cell sf_redirect(int out, cell x, int *pc, int *ps) {
	int	k;

	k = length(x);
	if (k < 3) return too_few_args(x);
	save(cons(S_begin, cddr(x)));
	*pc = 2;
	*ps = out? EV_OUTPUT: EV_INPUT;
	return cadr(x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
cmpq $-0x1, %rsi
je 0xee4d
movq %rcx, %r14
movq %rdx, %r15
movl %edi, %r12d
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq 0xf787(%rip), %rax      # 0x1e5c0
movq %rbx, %rdx
movq (%rax,%rdx,8), %rdx
incl %ecx
cmpq $-0x1, %rdx
jne 0xee3c
cmpl $0x1, %ecx
ja 0xee65
leaq 0x7c0b(%rip), %rdi      # 0x16a5f
movq %rbx, %rsi
callq 0x33eb
movq $-0x5, %rax
jmp 0xeec2
movq 0xf8ec(%rip), %rdi      # 0x1e758
movq (%rax,%rbx,8), %rcx
movq (%rax,%rcx,8), %rsi
movl $0x8, %edx
callq 0x36e8
movq 0xf2a3(%rip), %rsi      # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0xf292(%rip)      # 0x1e128
movl $0x2, (%r15)
cmpl $0x1, %r12d
movl $0xb, %eax
sbbl $0x0, %eax
movl %eax, (%r14)
movq 0xf2bd(%rip), %rax      # 0x1e170
movq 0xf706(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rbx,8), %rcx
movq (%rax,%rcx,8), %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq