LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq $-0x1, %rsi
movl $0x8, %edx
movq %rsi, %rdi
callq 0x3780
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0x1603d(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x1602f(%rip)     # 0x28138
callq 0xcc90
movl %eax, 0x165cc(%rip)     # 0x286e0
cmpl $0xfffffed1, 0x165c2(%rip) # imm = 0xFFFFFED1
jne 0x12142
movq 0x164d1(%rip), %rax     # 0x285f8
movq 0x164a2(%rip), %rcx     # 0x285d0
movq 0x16033(%rip), %rdx     # 0x28168
movq (%rcx,%rdx,8), %rcx
movsbl (%rax,%rcx,8), %eax
cmpl $0x3a, %eax
je 0x1215e
movq 0x1601f(%rip), %rsi     # 0x28168
leaq 0xe845(%rip), %rdi      # 0x20995
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0x122a7
movq 0x16003(%rip), %rdi     # 0x28168
movq 0x15fcc(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x15fbe(%rip)     # 0x28138
movq 0x15fe7(%rip), %rdi     # 0x28168
movq 0x15fe8(%rip), %rsi     # 0x28170
xorl %edx, %edx
callq 0x3780
movq %rax, 0x15fda(%rip)     # 0x28170
movq 0x15fcb(%rip), %rdi     # 0x28168
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x18(%rbp)
movq 0x15fb2(%rip), %rdi     # 0x28168
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x18(%rbp)
movq 0x165b4(%rip), %rdi     # 0x28780
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
movq 0x15f9a(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x1, %edi
callq 0x3950
callq 0xcc90
movl %eax, 0x164dd(%rip)     # 0x286e0
cmpl $0xffffff37, 0x164d3(%rip) # imm = 0xFFFFFF37
je 0x12211
jmp 0x12254
movq $-0x1, %rsi
movl $0x8, %edx
movq %rsi, %rdi
callq 0x3780
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
movq 0x1639c(%rip), %rax     # 0x285d0
movq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x1638d(%rip), %rax     # 0x285d0
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0x12109
movl $0x1, %edi
callq 0x3950
movq %rax, -0x18(%rbp)
movq 0x16367(%rip), %rax     # 0x285d0
movq -0x18(%rbp), %rcx
cmpq $-0x1, (%rax,%rcx,8)
jne 0x12289
movq 0x15f05(%rip), %rax     # 0x28180
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0x1229f
movq 0x164d8(%rip), %rdi     # 0x28768
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $-0x1, -0x28(%rbp)
cmpq $-0x1, -0x10(%rbp)
jne 0x122ec
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x12374
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
je 0x12359
cmpq $0x0, -0x20(%rbp)
jl 0x12330
movq 0x162e7(%rip), %rax     # 0x285f0
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x12330
movq 0x162d0(%rip), %rax     # 0x285f0
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x1233c
leaq 0xe7bc(%rip), %rdi      # 0x20af3
callq 0x3c70
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x16285(%rip), %rax     # 0x285d0
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
jmp 0x122f4
movq -0x18(%rbp), %rdx
movq 0x1626c(%rip), %rax     # 0x285d0
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $-0x1, -0x10(%rbp)
je 0x123bf
cmpq $0x0, -0x10(%rbp)
jl 0x123cb
movq 0x16253(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x123cb
movq 0x15dcc(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
cmpq $-0x22, (%rax,%rcx,8)
jne 0x123cb
movl $0x1, -0x4(%rbp)
jmp 0x12545
cmpq $0x0, -0x10(%rbp)
jl 0x12400
movq 0x16217(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x12400
movq 0x16200(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x1240c
movl $0x0, -0x4(%rbp)
jmp 0x12545
jmp 0x1240e
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x11(%rbp)
jl 0x1246f
movq 0x161cf(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
andl $0x1, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
jne 0x1246f
movq 0x161b3(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
andl $0x10, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
jne 0x1246f
movq 0x16197(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x12478
jmp 0x124ea
movq 0x15d01(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jl 0x124c9
movq 0x1615f(%rip), %rax     # 0x285f0
movq 0x15ce8(%rip), %rcx     # 0x28180
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movsbl (%rax,%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x124c9
movq 0x15ccd(%rip), %rax     # 0x28180
movq 0x15cc6(%rip), %rcx     # 0x28180
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq $-0x22, (%rax,%rcx,8)
je 0x124d2
movl $0x0, -0x4(%rbp)
jmp 0x12545
movq 0x160f7(%rip), %rax     # 0x285d0
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0x1240e
movb $0x1, %al
cmpq $-0x1, -0x10(%rbp)
movb %al, -0x12(%rbp)
je 0x1253a
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x13(%rbp)
jl 0x12534
movq 0x160e7(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
andl $0x10, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x13(%rbp)
je 0x12534
movq 0x15c5b(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
cmpq $-0x22, (%rax,%rcx,8)
sete %al
movb %al, -0x13(%rbp)
movb -0x13(%rbp), %al
movb %al, -0x12(%rbp)
movb -0x12(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %edi, -0x8(%rbp)
cmpl $0x5, -0x8(%rbp)
jge 0x12569
movl $0x5, -0x4(%rbp)
jmp 0x125f4
cmpl $0xb, -0x8(%rbp)
jge 0x12578
movl $0xb, -0x4(%rbp)
jmp 0x125f4
cmpl $0x17, -0x8(%rbp)
jge 0x12587
movl $0x17, -0x4(%rbp)
jmp 0x125f4
cmpl $0x2f, -0x8(%rbp)
jge 0x12596
movl $0x2f, -0x4(%rbp)
jmp 0x125f4
cmpl $0x61, -0x8(%rbp)
jge 0x125a5
movl $0x61, -0x4(%rbp)
jmp 0x125f4
cmpl $0xc7, -0x8(%rbp)
jge 0x125b7
movl $0xc7, -0x4(%rbp)
jmp 0x125f4
cmpl $0x1f3, -0x8(%rbp)      # imm = 0x1F3
jge 0x125c9
movl $0x1f3, -0x4(%rbp)      # imm = 0x1F3
jmp 0x125f4
cmpl $0x3e5, -0x8(%rbp)      # imm = 0x3E5
jge 0x125db
movl $0x3e5, -0x4(%rbp)      # imm = 0x3E5
jmp 0x125f4
cmpl $0x26f5, -0x8(%rbp)     # imm = 0x26F5
jge 0x125ed
movl $0x26f5, -0x4(%rbp)     # imm = 0x26F5
jmp 0x125f4
movl $0x4e1d, -0x4(%rbp)     # imm = 0x4E1D
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq 0x15dae(%rip), %rax     # 0x285d0
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
movq 0x15d90(%rip), %rax     # 0x285d0
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x15d81(%rip), %rax     # 0x285d0
movq 0x15d82(%rip), %rcx     # 0x285d8
cmpq $-0x3, (%rax,%rcx,8)
jne 0x12866
movq -0x18(%rbp), %rdi
callq 0x12600
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0x15895(%rip)     # 0x28120
movq -0x8(%rbp), %rsi
movq $-0x1, %rdi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x18(%rbp)
movq $-0x1, 0x15861(%rip) # 0x28120
movq -0x8(%rbp), %rdi
callq 0x5160
cmpl $0x5, %eax
jl 0x128f9
movq -0x18(%rbp), %rdi
movq 0x15860(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x15852(%rip)     # 0x28138
movq -0x8(%rbp), %rdi
callq 0x12600
movl $0x1, %edi
callq 0x3950
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
je 0x12935
movq 0x15856(%rip), %rax     # 0x28180
movq -0x18(%rbp), %rcx
cmpq $-0x1, (%rax,%rcx,8)
jne 0x12942
movq $-0x1, -0x8(%rbp)
jmp 0x12a7a
movq 0x15caf(%rip), %rax     # 0x285f8
movq 0x15c80(%rip), %rcx     # 0x285d0
movq 0x15829(%rip), %rdx     # 0x28180
movq -0x18(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq 0x15c83(%rip), %rax     # 0x285f8
movq 0x15c54(%rip), %rcx     # 0x285d0
movq 0x157fd(%rip), %rdx     # 0x28180
movq -0x18(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
subq $0x1, %rax
shrq $0x3, %rax
addq $0x3, %rax
subq $0x3, %rax
movl %eax, -0x30(%rbp)
movq 0x15c43(%rip), %rax     # 0x285f8
movq 0x15c14(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rax
cmpb $0x0, (%rax)
je 0x12a01
movl -0x2c(%rbp), %eax
shll $0x5, %eax
addl -0x2c(%rbp), %eax
movq -0x38(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x38(%rbp)
movsbl (%rcx), %ecx
xorl %ecx, %eax
movl %eax, -0x2c(%rbp)
jmp 0x129d6
jmp 0x12a03
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x2c(%rbp), %eax
xorl %edx, %edx
divl -0x30(%rbp)
movq -0x40(%rbp), %rax
movl %edx, %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
je 0x12a72
movq 0x15751(%rip), %rax     # 0x28180
movq 0x1574a(%rip), %rcx     # 0x28180
movq -0x28(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
cmpq -0x10(%rbp), %rax
jne 0x12a5d
movq 0x15731(%rip), %rax     # 0x28180
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x12a7a
movq 0x15b6c(%rip), %rax     # 0x285d0
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0x12a21
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpq $-0x1, -0x18(%rbp)
je 0x12b5e
movq 0x156db(%rip), %rax     # 0x28180
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x12910
movq %rax, -0x30(%rbp)
cmpq $-0x1, -0x30(%rbp)
je 0x12ad6
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x12c61
cmpq $-0x1, -0x28(%rbp)
je 0x12af0
movq 0x15aec(%rip), %rax     # 0x285d0
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0x12af2
cmpq $-0x1, -0x28(%rbp)
je 0x12b46
movq -0x10(%rbp), %rax
movq 0x1567c(%rip), %rcx     # 0x28180
movq 0x15675(%rip), %rdx     # 0x28180
movq -0x28(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
cmpq (%rcx,%rdx,8), %rax
jne 0x12b31
movq 0x15660(%rip), %rax     # 0x28180
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x12c61
movq 0x15a98(%rip), %rax     # 0x285d0
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0x12af2
movq 0x15a83(%rip), %rax     # 0x285d0
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0x12a93
cmpl $0x0, -0x1c(%rbp)
jne 0x12b71
movq $-0x1, -0x8(%rbp)
jmp 0x12c61
movq -0x10(%rbp), %rax
cmpq 0x15b3c(%rip), %rax     # 0x286b8
je 0x12c37
movq -0x10(%rbp), %rax
cmpq 0x15bdb(%rip), %rax     # 0x28768
je 0x12c37
movq -0x10(%rbp), %rax
cmpq 0x15bb2(%rip), %rax     # 0x28750
je 0x12c37
movq -0x10(%rbp), %rax
cmpq 0x15b49(%rip), %rax     # 0x286f8
je 0x12c37
movq -0x10(%rbp), %rax
cmpq 0x15b50(%rip), %rax     # 0x28710
je 0x12c37
movq -0x10(%rbp), %rax
cmpq 0x15b4b(%rip), %rax     # 0x28718
je 0x12c37
movq -0x10(%rbp), %rax
cmpq 0x15b9e(%rip), %rax     # 0x28778
je 0x12c37
movq -0x10(%rbp), %rax
cmpq 0x15bb1(%rip), %rax     # 0x28798
je 0x12c37
movq -0x10(%rbp), %rax
cmpq 0x15b54(%rip), %rax     # 0x28748
je 0x12c37
movq -0x10(%rbp), %rax
cmpq 0x15b6f(%rip), %rax     # 0x28770
je 0x12c37
movq -0x10(%rbp), %rax
cmpq 0x15b72(%rip), %rax     # 0x28780
je 0x12c37
movq -0x10(%rbp), %rax
cmpq 0x15b3d(%rip), %rax     # 0x28758
je 0x12c37
movq -0x10(%rbp), %rax
cmpq 0x15b38(%rip), %rax     # 0x28760
je 0x12c37
movq -0x10(%rbp), %rax
cmpq 0x15b6b(%rip), %rax     # 0x287a0
jne 0x12c49
movq -0x10(%rbp), %rsi
leaq 0xdec8(%rip), %rdi      # 0x20b0a
callq 0x34b0
jmp 0x12c59
movq -0x10(%rbp), %rsi
leaq 0xdec5(%rip), %rdi      # 0x20b19
callq 0x34b0
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq 0x158de(%rip), %rax     # 0x285d0
movq -0x20(%rbp), %rcx
cmpq $-0x1, (%rax,%rcx,8)
jne 0x12d0a
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x12da6
movq 0x158bf(%rip), %rax     # 0x285d0
movq 0x158b8(%rip), %rcx     # 0x285d0
movq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq $-0x1, (%rax,%rcx,8)
jne 0x12d51
movq -0x28(%rbp), %rax
movl $0x1, (%rax)
movq 0x15448(%rip), %rax     # 0x28180
movq 0x15891(%rip), %rcx     # 0x285d0
movq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x12da6
movq -0x28(%rbp), %rax
movl $0x2, (%rax)
movl -0xc(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, (%rax)
movq 0x15865(%rip), %rax     # 0x285d0
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x153be(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x153b0(%rip)     # 0x28138
movq 0x153f1(%rip), %rax     # 0x28180
movq 0x1583a(%rip), %rcx     # 0x285d0
movq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq 0x15805(%rip), %rax     # 0x285d0
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
je 0x12e0d
movq 0x157eb(%rip), %rax     # 0x285d0
movq -0x28(%rbp), %rcx
cmpq $-0x1, (%rax,%rcx,8)
je 0x12e0d
movq 0x157d9(%rip), %rax     # 0x285d0
movq 0x157d2(%rip), %rcx     # 0x285d0
movq -0x28(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq $-0x1, (%rax,%rcx,8)
jne 0x12e1c
movq -0x10(%rbp), %rdi
callq 0x12c70
movq %rax, -0x8(%rbp)
jmp 0x12e93
movq 0x157ad(%rip), %rax     # 0x285d0
movq 0x157a6(%rip), %rcx     # 0x285d0
movq 0x1579f(%rip), %rdx     # 0x285d0
movq -0x28(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq $-0x1, (%rax,%rcx,8)
je 0x12e53
movq -0x10(%rbp), %rdi
callq 0x12ca0
movq %rax, -0x8(%rbp)
jmp 0x12e93
movq -0x28(%rbp), %rdi
movq 0x152da(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x152cc(%rip)     # 0x28138
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
movq -0x20(%rbp), %rax
movl $0x4, (%rax)
movq 0x152f9(%rip), %rax     # 0x28180
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $-0x1, -0x10(%rbp)
cmpq $-0x1, -0x8(%rbp)
je 0x12ee6
movq -0x10(%rbp), %rsi
movq $-0x5, %rdi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq 0x156f8(%rip), %rax     # 0x285d0
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x12eb4
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq 0x14d8d(%rip), %rax     # 0x285d0
movq -0x10(%rbp), %rcx
cmpq $-0x1, (%rax,%rcx,8)
jne 0x1385d
movq -0x10(%rbp), %rdi
callq 0x12c70
movq %rax, -0x8(%rbp)
jmp 0x138a7
movq 0x14d6c(%rip), %rax     # 0x285d0
movq 0x14d65(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq $-0x1, (%rax,%rcx,8)
je 0x13889
movq -0x10(%rbp), %rdi
callq 0x12ca0
movq %rax, -0x8(%rbp)
jmp 0x138a7
movq 0x148f0(%rip), %rax     # 0x28180
movq 0x14d39(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5160
movl %eax, -0x2c(%rbp)
cmpl $0x3, -0x2c(%rbp)
jge 0x13938
movq -0x10(%rbp), %rdi
callq 0x12c70
movq %rax, -0x8(%rbp)
jmp 0x13a8b
cmpl $0x3, -0x2c(%rbp)
jle 0x13950
movq -0x10(%rbp), %rdi
callq 0x12ca0
movq %rax, -0x8(%rbp)
jmp 0x13a8b
movq 0x14829(%rip), %rax     # 0x28180
movq 0x14c72(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq $0x0, (%rax,%rcx,8)
jl 0x139c2
movq 0x14c7c(%rip), %rax     # 0x285f0
movq 0x14805(%rip), %rcx     # 0x28180
movq 0x14c4e(%rip), %rdx     # 0x285d0
movq -0x10(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
movsbl (%rax,%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x139c2
movq 0x147df(%rip), %rax     # 0x28180
movq 0x147d8(%rip), %rcx     # 0x28180
movq 0x14c21(%rip), %rdx     # 0x285d0
movq -0x10(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq $-0x22, (%rax,%rcx,8)
je 0x139f1
movq 0x147b7(%rip), %rax     # 0x28180
movq 0x14c00(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0xd1ab(%rip), %rdi      # 0x20b8e
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0x13a8b
movq 0x14788(%rip), %rax     # 0x28180
movq 0x14bd1(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x14706(%rip), %rsi     # 0x28118
movl $0x1, %edx
callq 0x12a80
movq %rax, -0x28(%rbp)
movl 0x14b9e(%rip), %eax     # 0x285c4
cmpl $0x0, %eax
je 0x13a35
movq $-0x1, -0x8(%rbp)
jmp 0x13a8b
movq -0x28(%rbp), %rdi
movq 0x146f8(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x146ea(%rip)     # 0x28138
movq -0x18(%rbp), %rax
movl $0x2, (%rax)
movq -0x20(%rbp), %rax
movl $0x5, (%rax)
movq 0x14717(%rip), %rax     # 0x28180
movq 0x14b60(%rip), %rcx     # 0x285d0
movq 0x14b59(%rip), %rdx     # 0x285d0
movq -0x10(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: 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
subq $0x10, %rsp
movq 0x14669(%rip), %rax     # 0x28118
movq %rax, -0x8(%rbp)
xorl %eax, %eax
cmpq $-0x1, -0x8(%rbp)
movb %al, -0x9(%rbp)
je 0x13ad5
movq 0x14b0a(%rip), %rax     # 0x285d0
movq -0x8(%rbp), %rcx
cmpq $-0x1, (%rax,%rcx,8)
setne %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x13ade
jmp 0x13af5
jmp 0x13ae0
movq 0x14ae9(%rip), %rax     # 0x285d0
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x13ab3
cmpq $-0x1, -0x8(%rbp)
jne 0x13b08
leaq 0xd0a2(%rip), %rdi      # 0x20ba5
callq 0x3c70
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: 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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
jne 0x13b3d
movq $-0x1, -0x8(%rbp)
jmp 0x13ba9
movq 0x14a8c(%rip), %rax     # 0x285d0
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x18(%rbp)
je 0x13ba1
movq -0x10(%rbp), %rax
movq 0x1461e(%rip), %rcx     # 0x28180
movq 0x14617(%rip), %rdx     # 0x28180
movq -0x18(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
cmpq (%rcx,%rdx,8), %rax
jne 0x13b8c
movq 0x14602(%rip), %rax     # 0x28180
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x13ba9
movq 0x14a3d(%rip), %rax     # 0x285d0
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0x13b50
movq $-0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x147af(%rip), %rdi     # 0x285f8
movq 0x14780(%rip), %rax     # 0x285d0
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
shlq $0x3, %rax
addq %rax, %rdi
leaq 0xc40f(%rip), %rsi      # 0x20275
callq 0x3120
cmpl $0x0, %eax
jne 0x13e85
leaq -0x420(%rbp), %rdi
leaq 0xcdb2(%rip), %rsi      # 0x20c30
callq 0x3060
jmp 0x13eb2
leaq -0x420(%rbp), %rdi
movq 0x14765(%rip), %rsi     # 0x285f8
movq 0x14736(%rip), %rax     # 0x285d0
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
shlq $0x3, %rax
addq %rax, %rsi
addq $0x1, %rsi
callq 0x3060
leaq -0x420(%rbp), %rdi
callq 0x30a0
leaq -0x420(%rbp), %rdi
addq %rax, %rdi
movl -0xc(%rbp), %edx
leaq 0xcd64(%rip), %rsi      # 0x20c36
movb $0x0, %al
callq 0x3200
leaq -0x420(%rbp), %rdi
callq 0x9420
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5160
movl %eax, -0x2c(%rbp)
cmpl $0x3, -0x2c(%rbp)
jge 0x14a3b
movq -0x18(%rbp), %rdi
callq 0x12c70
movq %rax, -0x8(%rbp)
jmp 0x14abf
movq 0x13d26(%rip), %rdi     # 0x28768
movq 0x13b87(%rip), %rax     # 0x285d0
movq 0x13b80(%rip), %rcx     # 0x285d0
movq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rsi
movl $0x8, %edx
callq 0x3780
movq %rax, %rdi
movq 0x136c8(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x136ba(%rip)     # 0x28138
movq -0x20(%rbp), %rax
movl $0x2, (%rax)
movl -0xc(%rbp), %edx
movl $0xa, %ecx
movl $0xb, %eax
cmpl $0x0, %edx
cmovnel %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq 0x136d8(%rip), %rax     # 0x28180
movq 0x13b21(%rip), %rcx     # 0x285d0
movq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: append_str
cell append_str(cell x) {
	cell	p, n;
	int	k, m;
	char	*s;

	k = 0;
	for (p = x; p != NIL; p = cdr(p))
		k += string_len(car(p))-1;
	n = make_string("", k);
	s = string(n);
	k = 0;
	for (p = x; p != NIL; p = cdr(p)) {
		m = string_len(car(p));
		memcpy(&s[k], string(car(p)), m);
		k += string_len(car(p))-1;
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $-0x1, -0x10(%rbp)
je 0x14dde
movq 0x1385f(%rip), %rax     # 0x285f8
movq 0x13830(%rip), %rcx     # 0x285d0
movq 0x133d9(%rip), %rdx     # 0x28180
movq -0x10(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rcx
subq $0x1, %rcx
movslq -0x1c(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x1c(%rbp)
movq 0x13800(%rip), %rax     # 0x285d0
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0x14d8b
movl -0x1c(%rbp), %esi
leaq 0xcbec(%rip), %rdi      # 0x219d4
callq 0xa160
movq %rax, -0x18(%rbp)
movq 0x13800(%rip), %rax     # 0x285f8
movq 0x137d1(%rip), %rcx     # 0x285d0
movq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $-0x1, -0x10(%rbp)
je 0x14ee3
movq 0x137c5(%rip), %rax     # 0x285f8
movq 0x13796(%rip), %rcx     # 0x285d0
movq 0x1333f(%rip), %rdx     # 0x28180
movq -0x10(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movl %eax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rax
addq %rax, %rdi
movq 0x1378e(%rip), %rsi     # 0x285f8
movq 0x1375f(%rip), %rax     # 0x285d0
movq 0x13308(%rip), %rcx     # 0x28180
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
shlq $0x3, %rax
addq %rax, %rsi
movslq -0x20(%rbp), %rdx
callq 0x3140
movq 0x1375d(%rip), %rax     # 0x285f8
movq 0x1372e(%rip), %rcx     # 0x285d0
movq 0x132d7(%rip), %rdx     # 0x28180
movq -0x10(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rcx
subq $0x1, %rcx
movslq -0x1c(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x1c(%rbp)
movq 0x136fe(%rip), %rax     # 0x285d0
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0x14e21
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: append_list
cell append_list(cell x) {
	cell	new, n, p, a, *pa;

	if (car(x) == NIL)
		return cadr(x);
	if (cadr(x) == NIL)
		return car(x);
	a = n = cons(NIL, NIL);
	pa = &a;
	save(n);
	for (p = car(x); p != NIL; p = cdr(p)) {
		car(a) = car(p);
		set(cdr(a), cons(NIL, NIL));
		pa = &cdr(a);
		a = cdr(a);
	}
	unsave(1);
	*pa = cadr(x);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq 0x1327d(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
cmpq $-0x1, (%rax,%rcx,8)
jne 0x14f31
movq 0x1326b(%rip), %rax     # 0x28180
movq 0x136b4(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x1507e
movq 0x13248(%rip), %rax     # 0x28180
movq 0x13691(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq $-0x1, (%rax,%rcx,8)
jne 0x14f66
movq 0x1322b(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x1507e
movq $-0x1, %rsi
movl $0x8, %edx
movq %rsi, %rdi
callq 0x3780
movq %rax, -0x20(%rbp)
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
movq 0x131a3(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x13195(%rip)     # 0x28138
movq 0x131d6(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
je 0x1504b
movq 0x131b8(%rip), %rax     # 0x28180
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x131a9(%rip), %rax     # 0x28180
movq -0x30(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq $-0x1, %rsi
movl $0x8, %edx
movq %rsi, %rdi
callq 0x3780
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
movq 0x135ce(%rip), %rax     # 0x285d0
movq -0x30(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x135bf(%rip), %rax     # 0x285d0
movq -0x30(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq 0x135a9(%rip), %rax     # 0x285d0
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq 0x13596(%rip), %rax     # 0x285d0
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
jmp 0x14fb6
movl $0x1, %edi
callq 0x3950
movq 0x13124(%rip), %rax     # 0x28180
movq 0x1356d(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: pp_append
cell pp_append(cell x) {
	cell	n1, n2;

	n1 = car(x);
	n2 = cadr(x);
	if (list_p(n1) && list_p(n2))
		return append_list(x);
	if (string_p(n1) && string_p(n2))
		return append_str(x);
	return error("@: expected tuple of str/list, got", x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x130dd(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq 0x130ca(%rip), %rax     # 0x28180
movq 0x13513(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0x15119
movq 0x13515(%rip), %rax     # 0x285f0
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x15119
movq 0x134fe(%rip), %rax     # 0x285f0
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x15119
movq 0x134e7(%rip), %rax     # 0x285f0
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x15120
cmpq $-0x1, -0x18(%rbp)
jne 0x15185
cmpq $0x0, -0x20(%rbp)
jl 0x1516c
movq 0x134c2(%rip), %rax     # 0x285f0
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x1516c
movq 0x134ab(%rip), %rax     # 0x285f0
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x1516c
movq 0x13494(%rip), %rax     # 0x285f0
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x15173
cmpq $-0x1, -0x20(%rbp)
jne 0x15185
movq -0x10(%rbp), %rdi
callq 0x14ef0
movq %rax, -0x8(%rbp)
jmp 0x15208
cmpq $0x0, -0x18(%rbp)
jl 0x151f4
movq 0x1345d(%rip), %rax     # 0x285f0
movq -0x18(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x151f4
movq 0x12fd6(%rip), %rax     # 0x28180
movq -0x18(%rbp), %rcx
cmpq $-0x21, (%rax,%rcx,8)
jne 0x151f4
cmpq $0x0, -0x20(%rbp)
jl 0x151f4
movq 0x1342d(%rip), %rax     # 0x285f0
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x151f4
movq 0x12fa6(%rip), %rax     # 0x28180
movq -0x20(%rbp), %rcx
cmpq $-0x21, (%rax,%rcx,8)
jne 0x151f4
movq -0x10(%rbp), %rdi
callq 0x14d70
movq %rax, -0x8(%rbp)
jmp 0x15208
movq -0x10(%rbp), %rsi
leaq 0xbaec(%rip), %rdi      # 0x20ceb
callq 0x34b0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: pp_clone
cell pp_clone(cell x) {
	cell	v;
	int	k;

	if (vector_p(car(x))) {
		k = vector_len(car(x));
		v = new_vec(T_VECTOR, k * sizeof(cell));
		memcpy(vector(v), vector(car(x)), k * sizeof(cell));
		return v;
	}
	else {
		return car(x);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x12f4d(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jl 0x1533f
movq 0x133a7(%rip), %rax     # 0x285f0
movq 0x12f30(%rip), %rcx     # 0x28180
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movsbl (%rax,%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x1533f
movq 0x12f11(%rip), %rax     # 0x28180
movq 0x12f0a(%rip), %rcx     # 0x28180
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq $-0x24, (%rax,%rcx,8)
jne 0x1533f
movq 0x13368(%rip), %rax     # 0x285f8
movq 0x13339(%rip), %rcx     # 0x285d0
movq 0x12ee2(%rip), %rdx     # 0x28180
movq -0x10(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
addq $0x8, %rax
subq $0x1, %rax
shrq $0x3, %rax
addq $0x3, %rax
subq $0x3, %rax
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
shlq $0x3, %rax
movl %eax, %esi
movq $-0x24, %rdi
callq 0x4790
movq %rax, -0x18(%rbp)
movq 0x1330e(%rip), %rdi     # 0x285f8
movq 0x132df(%rip), %rax     # 0x285d0
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x132f1(%rip), %rsi     # 0x285f8
movq 0x132c2(%rip), %rax     # 0x285d0
movq 0x12e6b(%rip), %rcx     # 0x28180
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
shlq $0x3, %rax
addq %rax, %rsi
movslq -0x1c(%rbp), %rdx
shlq $0x3, %rdx
callq 0x3140
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x15352
movq 0x12e3a(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: pp_order
cell pp_order(cell x) {
	if (car(x) == UNIT)
		return make_integer(0);
	if (tuple_p(car(x)))
		return pp_len(x);
	return make_integer(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq 0x12b4d(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
cmpq $-0x6, (%rax,%rcx,8)
jne 0x15650
xorl %eax, %eax
movl %eax, %edi
callq 0x3740
movq %rax, -0x8(%rbp)
jmp 0x156e5
movq 0x12b29(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jl 0x156d7
movq 0x12f87(%rip), %rax     # 0x285f0
movq 0x12b10(%rip), %rcx     # 0x28180
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x156d7
movq 0x12f65(%rip), %rax     # 0x285f0
movq 0x12aee(%rip), %rcx     # 0x28180
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movsbl (%rax,%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x156d7
movq 0x12f43(%rip), %rax     # 0x285f0
movq 0x12acc(%rip), %rcx     # 0x28180
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movsbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x156d7
movq -0x10(%rbp), %rdi
callq 0x15360
movq %rax, -0x8(%rbp)
jmp 0x156e5
movl $0x1, %edi
callq 0x3740
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: sublis
cell sublis(cell x, int p0, int pn, int tag) {
	cell	p, a, new;

	pn -= p0;
	if (pn == 0)
		return NIL;
	a = node3(NIL, NIL, tag);
	save(a);
	for (p = car(x); p0; p = cdr(p), p0--)
		;
	for (; pn; p = cdr(p), pn--) {
		car(a) = car(p);
		if (pn > 1) {
			set(cdr(a), node3(NIL, NIL, tag));
			a = cdr(a);
		}
	}
	return unsave(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x14(%rbp), %ecx
movl -0x18(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x16893
movq $-0x1, -0x8(%rbp)
jmp 0x16998
movl -0x1c(%rbp), %edx
movq $-0x1, %rsi
movq %rsi, %rdi
callq 0x3780
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq 0x11884(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x11876(%rip)     # 0x28138
movq 0x118b7(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x168fb
jmp 0x168dd
movq 0x11cec(%rip), %rax     # 0x285d0
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x168d5
jmp 0x168fd
cmpl $0x0, -0x18(%rbp)
je 0x1698a
movq 0x11872(%rip), %rax     # 0x28180
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x11863(%rip), %rax     # 0x28180
movq -0x30(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
cmpl $0x1, -0x18(%rbp)
jle 0x16967
movl -0x1c(%rbp), %edx
movq $-0x1, %rsi
movq %rsi, %rdi
callq 0x3780
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdx
movq 0x11c84(%rip), %rax     # 0x285d0
movq -0x30(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x11c75(%rip), %rax     # 0x285d0
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
jmp 0x16969
movq 0x11c60(%rip), %rax     # 0x285d0
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x168fd
movl $0x1, %edi
callq 0x3950
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: pp_call_cc
cell pp_call_cc(cell x) {
	cell	cc, n;

	cc = node(Stack, NIL);
	cc = node(Stack_bottom, cc);
	cc = node(State_stack, cc);
	cc = node(Environment, cc);
	cc = new_atom(T_CONTINUATION, cc);
	n = node(cc, NIL);
	n = node(car(x), n);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x10545(%rip), %rdi     # 0x28138
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq 0x10534(%rip), %rdi     # 0x28140
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq 0x10526(%rip), %rdi     # 0x28148
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq 0x104e0(%rip), %rdi     # 0x28118
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq $-0x25, %rdi
movl $0x1, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x18(%rbp)
movq 0x10503(%rip), %rax     # 0x28180
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: resume
cell resume(cell x) {
	cell	cc;

	if (cdr(x) == NIL)
		return too_few_args(x);
	if (cddr(x) != NIL)
		return too_many_args(x);
	cc = cdar(x);
	Environment = car(cc);
	State_stack = cadr(cc);
	Stack_bottom = caddr(cc);
	Stack = cadddr(cc);
	return cadr(x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x1091d(%rip), %rax     # 0x285d0
movq -0x10(%rbp), %rcx
cmpq $-0x1, (%rax,%rcx,8)
jne 0x17cd0
movq -0x10(%rbp), %rdi
callq 0x12c70
movq %rax, -0x8(%rbp)
jmp 0x17dd5
movq 0x108f9(%rip), %rax     # 0x285d0
movq 0x108f2(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq $-0x1, (%rax,%rcx,8)
je 0x17cff
movq -0x10(%rbp), %rdi
callq 0x12ca0
movq %rax, -0x8(%rbp)
jmp 0x17dd5
movq 0x108ca(%rip), %rax     # 0x285d0
movq 0x10473(%rip), %rcx     # 0x28180
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq 0x1045c(%rip), %rax     # 0x28180
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x103e5(%rip)     # 0x28118
movq 0x10446(%rip), %rax     # 0x28180
movq 0x1088f(%rip), %rcx     # 0x285d0
movq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x103f4(%rip)     # 0x28148
movq 0x10425(%rip), %rax     # 0x28180
movq 0x1086e(%rip), %rcx     # 0x285d0
movq 0x10867(%rip), %rdx     # 0x285d0
movq -0x18(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x103c0(%rip)     # 0x28140
movq 0x103f9(%rip), %rax     # 0x28180
movq 0x10842(%rip), %rcx     # 0x285d0
movq 0x1083b(%rip), %rdx     # 0x285d0
movq 0x10834(%rip), %rsi     # 0x285d0
movq -0x18(%rbp), %rdi
movq (%rsi,%rdi,8), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10381(%rip)     # 0x28138
movq 0x103c2(%rip), %rax     # 0x28180
movq 0x1080b(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: pp_registerb
cell pp_registerb(cell x) {
	cell	n;

	n = node(car(x), cadr(x));
	Exnstack = node(n, Exnstack);
	return UNIT;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x1038d(%rip), %rax     # 0x28180
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x1037e(%rip), %rax     # 0x28180
movq 0x107c7(%rip), %rcx     # 0x285d0
movq -0x8(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0x1034d(%rip), %rsi     # 0x28178
xorl %edx, %edx
callq 0x3780
movq %rax, 0x1033f(%rip)     # 0x28178
movq $-0x6, %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: pp_unregisterb
cell pp_unregisterb(cell x) {
	if (Exnstack == NIL)
		return error("internal error: no handlers registered",
			NOEXPR);
	Exnstack = cdr(Exnstack);
	return car(x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $-0x1, 0x10314(%rip)    # 0x28178
jne 0x17e7f
leaq 0x9029(%rip), %rdi      # 0x20e96
movq $-0x8, %rsi
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0x17eab
movq 0x1074a(%rip), %rax     # 0x285d0
movq 0x102eb(%rip), %rcx     # 0x28178
movq (%rax,%rcx,8), %rax
movq %rax, 0x102e0(%rip)     # 0x28178
movq 0x102e1(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: assqv
int assqv(char *who, int v, cell x, cell a) {
	cell	p;
	char	buf[64];

	for (p = a; p != NIL; p = cdr(p)) {
		if (!list_p(car(p))) {
			sprintf(buf, "%s: bad element in alist", who);
			return error(buf, p);
		}
		if (!v && x == caar(p))
			return car(p);
		if (v && eqv_p(x, caar(p)))
			return car(p);
	}
	return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $-0x1, -0x30(%rbp)
je 0x182a5
movq 0x1001f(%rip), %rax     # 0x28180
movq -0x30(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jl 0x181d2
movq 0x1047d(%rip), %rax     # 0x285f0
movq 0x10006(%rip), %rcx     # 0x28180
movq -0x30(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x181d2
movq 0x1045b(%rip), %rax     # 0x285f0
movq 0xffe4(%rip), %rcx      # 0x28180
movq -0x30(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movsbl (%rax,%rcx), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x181d2
movq 0x10439(%rip), %rax     # 0x285f0
movq 0xffc2(%rip), %rcx      # 0x28180
movq -0x30(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movsbl (%rax,%rcx), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x1820f
movq 0xffa7(%rip), %rax      # 0x28180
movq -0x30(%rbp), %rcx
cmpq $-0x1, (%rax,%rcx,8)
je 0x1820f
leaq -0x70(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x8cca(%rip), %rsi      # 0x20ebd
movb $0x0, %al
callq 0x3200
leaq -0x70(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x34b0
movl %eax, -0x4(%rbp)
jmp 0x182ac
cmpl $0x0, -0x14(%rbp)
jne 0x18249
movq -0x20(%rbp), %rax
movq 0xff60(%rip), %rcx      # 0x28180
movq 0xff59(%rip), %rdx      # 0x28180
movq -0x30(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
cmpq (%rcx,%rdx,8), %rax
jne 0x18249
movq 0xff44(%rip), %rax      # 0x28180
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, -0x4(%rbp)
jmp 0x182ac
cmpl $0x0, -0x14(%rbp)
je 0x1828b
movq -0x20(%rbp), %rdi
movq 0xff26(%rip), %rax      # 0x28180
movq 0xff1f(%rip), %rcx      # 0x28180
movq -0x30(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x17ec0
cmpl $0x0, %eax
je 0x1828b
movq 0xff02(%rip), %rax      # 0x28180
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, -0x4(%rbp)
jmp 0x182ac
jmp 0x1828d
movq 0x1033c(%rip), %rax     # 0x285d0
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
jmp 0x1814f
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)