LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0xc6ad
movq 0xff64(%rip), %rax      # 0x1c5e0
pushq $-0x1
popq %r8
movq 0xff39(%rip), %rcx      # 0x1c5c0
movq %rdi, %r9
cmpq $-0x1, %r9
je 0xc6a7
movq %r9, %rdx
testq %r9, %r9
js 0xc6b5
testb $0x11, (%rax,%rdx)
jne 0xc6b5
movq (%rcx,%rdx,8), %r9
movq %rdx, %r8
jmp 0xc68a
movq %rsi, (%rcx,%r8,8)
jmp 0xc6b0
movq %rsi, %rdi
movq %rdi, %rax
popq %rbp
retq
leaq 0x836c(%rip), %rdi      # 0x14a28
callq 0x39b6
// File: /workspace/github_c_makefile_star2_O2/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 0xc6fb
testq %rdi, %rdi
js 0xc6f9
pushq %rbp
movq %rsp, %rbp
movq 0xff07(%rip), %rcx      # 0x1c5e0
movb (%rcx,%rdi), %dl
testb $0x10, %dl
je 0xc6ef
movq 0xfa88(%rip), %rsi      # 0x1c170
cmpq $-0x22, (%rsi,%rdi,8)
je 0xc6f6
testb $0x11, %dl
je 0xc6ff
xorl %eax, %eax
popq %rbp
jmp 0xc6fb
xorl %eax, %eax
movzbl %al, %eax
retq
movq 0xfa6a(%rip), %rax      # 0x1c170
movq 0xfeb3(%rip), %rdx      # 0x1c5c0
testq %rdi, %rdi
js 0xc738
movb (%rcx,%rdi), %sil
testb $0x19, %sil
jne 0xc73e
movq (%rax,%rdi,8), %rsi
testq %rsi, %rsi
js 0xc6f4
testb $0x10, (%rcx,%rsi)
je 0xc6f4
cmpq $-0x22, (%rax,%rsi,8)
jne 0xc6f4
movq (%rdx,%rdi,8), %rdi
jmp 0xc70d
cmpq $-0x1, %rdi
jmp 0xc749
testb $0x10, %sil
je 0xc6f4
cmpq $-0x22, (%rax,%rdi,8)
sete %al
jmp 0xc6f6
// File: /workspace/github_c_makefile_star2_O2/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
cmpl $0x5, %edi
jge 0xc75e
movl $0x5, %eax
jmp 0xc7c4
cmpl $0xb, %edi
jae 0xc76a
movl $0xb, %eax
jmp 0xc7c4
cmpl $0x17, %edi
jae 0xc776
movl $0x17, %eax
jmp 0xc7c4
cmpl $0x2f, %edi
jae 0xc782
movl $0x2f, %eax
jmp 0xc7c4
cmpl $0x61, %edi
jae 0xc78e
movl $0x61, %eax
jmp 0xc7c4
movl $0xc7, %eax
cmpl $0xc7, %edi
jb 0xc7c4
movl $0x1f3, %eax            # imm = 0x1F3
cmpl $0x1f3, %edi            # imm = 0x1F3
jb 0xc7c4
movl $0x3e5, %eax            # imm = 0x3E5
cmpl $0x3e5, %edi            # imm = 0x3E5
jb 0xc7c4
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_O2/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 %r12
pushq %rbx
movq %rdi, %rbx
callq 0x46c4
movl %eax, %edi
callq 0xc74e
cmpq $-0x1, 0xf910(%rip)     # 0x1c0f8
je 0xc8a4
movl %eax, %r14d
leal (,%r14,8), %esi
pushq $-0x24
popq %rdi
callq 0x4037
movq 0xf968(%rip), %rsi      # 0x1c170
movq %rax, (%rsi,%rbx,8)
movq 0xfdd5(%rip), %rdx      # 0x1c5e8
movq 0xfda6(%rip), %r8       # 0x1c5c0
movq (%r8,%rax,8), %rax
leaq (%rdx,%rax,8), %rcx
movl %r14d, %eax
xorl %edi, %edi
cmpq %rdi, %rax
je 0xc836
orq $-0x1, (%rcx,%rdi,8)
incq %rdi
jmp 0xc827
leaq (%r8,%rbx,8), %rax
movq (%rax), %r12
cmpq $-0x1, %r12
je 0xc8a4
movq (%rsi,%r12,8), %rdi
movq (%rsi,%rdi,8), %rax
movq (%r8,%rax,8), %rax
leaq (%rdx,%rax,8), %rdx
xorl %eax, %eax
movsbl (%rdx), %esi
testl %esi, %esi
je 0xc866
imull $0x21, %eax, %eax
incq %rdx
xorl %esi, %eax
jmp 0xc855
xorl %edx, %edx
divl %r14d
movl %edx, %r15d
movq (%rcx,%r15,8), %rsi
xorl %edx, %edx
callq 0x3613
movq 0xfd68(%rip), %rdx      # 0x1c5e8
movq 0xfd39(%rip), %r8       # 0x1c5c0
movq 0xf8e2(%rip), %rsi      # 0x1c170
movq (%rsi,%rbx,8), %rcx
movq (%r8,%rcx,8), %rcx
leaq (%rdx,%rcx,8), %rcx
movq %rax, (%rcx,%r15,8)
leaq (%r8,%r12,8), %rax
jmp 0xc83a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3613
movq 0xfcfc(%rip), %rcx      # 0x1c5c0
movq (%rcx,%rbx,8), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq 0xfce7(%rip), %rcx      # 0x1c5c0
movq %rax, (%rcx,%rbx,8)
movq 0xfce4(%rip), %rax      # 0x1c5c8
cmpq $-0x3, (%rcx,%rax,8)
jne 0xc8f3
movq %rbx, %rdi
callq 0xc7c6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0xf7ff(%rip)      # 0x1c110
pushq $-0x1
popq %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %rbx
orq $-0x1, 0xf7da(%rip)     # 0x1c110
movq %r14, %rdi
callq 0x46c4
cmpl $0x5, %eax
jl 0xc96b
movq 0xf7de(%rip), %rsi      # 0x1c128
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0xf7cd(%rip)      # 0x1c128
movq %r14, %rdi
callq 0xc7c6
pushq $0x1
popq %rdi
callq 0x3775
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movabsq $-0x1, %rcx
cmpq $-0x1, %rsi
je 0xc9ff
pushq %rbp
movq %rsp, %rbp
movq 0xf7e2(%rip), %r8       # 0x1c170
movq (%r8,%rsi,8), %rax
cmpq $-0x1, %rax
je 0xc9fa
movq 0xfc49(%rip), %rdx      # 0x1c5e8
movq 0xfc1a(%rip), %rsi      # 0x1c5c0
movq (%rsi,%rax,8), %rax
leaq (%rdx,%rax,8), %r9
movq -0x8(%r9), %r10
addq $0x7, %r10
shrq $0x3, %r10
movq (%rsi,%rdi,8), %rax
leaq (%rdx,%rax,8), %rdx
xorl %eax, %eax
movsbl (%rdx), %r11d
testl %r11d, %r11d
je 0xc9d8
imull $0x21, %eax, %eax
incq %rdx
xorl %r11d, %eax
jmp 0xc9c4
xorl %edx, %edx
divl %r10d
leaq (%r9,%rdx,8), %rax
movq (%rax), %rdx
cmpq $-0x1, %rdx
je 0xc9fa
movq (%r8,%rdx,8), %rax
cmpq %rdi, (%r8,%rax,8)
je 0xc9fd
leaq (%rsi,%rdx,8), %rax
jmp 0xc9e1
movq %rcx, %rax
popq %rbp
retq
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rdx
movq 0xf74f(%rip), %rdi      # 0x1c170
movq 0xfb98(%rip), %r12      # 0x1c5c0
cmpq $-0x1, %rsi
je 0xca87
movq %rsi, -0x38(%rbp)
movq %rdi, %r15
movq (%rdi,%rsi,8), %r13
movq %rdx, %rbx
movq %rdx, %rdi
movq %r13, %rsi
callq 0xc973
cmpq $-0x1, %rax
jne 0xcb47
pushq $-0x1
popq %rax
cmpq $-0x1, %r13
movq %rbx, %rdx
movq %r15, %rdi
jne 0xca77
cmpq $-0x1, %rax
je 0xca7d
movq (%rdi,%rax,8), %r14
movq %rax, %r13
cmpq %rdx, (%rdi,%r14,8)
je 0xcb4a
movq (%r12,%r13,8), %rax
jmp 0xca60
movq -0x38(%rbp), %rsi
movq (%r12,%rsi,8), %rsi
jmp 0xca28
pushq $-0x1
popq %r14
cmpl $0x0, -0x2c(%rbp)
je 0xcb4a
cmpq %rdx, 0xfcf4(%rip)      # 0x1c790
leaq 0x7f9c(%rip), %rax      # 0x14a3f
leaq 0x7fa4(%rip), %rdi      # 0x14a4e
cmoveq %rax, %rdi
cmpq %rdx, 0xfc9b(%rip)      # 0x1c750
cmoveq %rax, %rdi
cmpq %rdx, 0xfc88(%rip)      # 0x1c748
cmoveq %rax, %rdi
cmpq %rdx, 0xfca5(%rip)      # 0x1c770
cmoveq %rax, %rdi
cmpq %rdx, 0xfc8a(%rip)      # 0x1c760
cmoveq %rax, %rdi
cmpq %rdx, 0xfc57(%rip)      # 0x1c738
cmoveq %rax, %rdi
cmpq %rdx, 0xfc9c(%rip)      # 0x1c788
cmoveq %rax, %rdi
cmpq %rdx, 0xfc71(%rip)      # 0x1c768
cmoveq %rax, %rdi
cmpq %rdx, 0xfc06(%rip)      # 0x1c708
cmoveq %rax, %rdi
cmpq %rdx, 0xfbf3(%rip)      # 0x1c700
cmoveq %rax, %rdi
cmpq %rdx, 0xfbd0(%rip)      # 0x1c6e8
cmoveq %rax, %rdi
cmpq %rdx, 0xfc1d(%rip)      # 0x1c740
cmoveq %rax, %rdi
cmpq %rdx, 0xfc2a(%rip)      # 0x1c758
cmoveq %rax, %rdi
cmpq %rdx, 0xfb6f(%rip)      # 0x1c6a8
cmoveq %rax, %rdi
movq %rdx, %rsi
callq 0x33e4
jmp 0xcb4a
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_O2/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 0xfa22(%rip), %rdx      # 0x1c5c0
movq (%rdx,%rbx,8), %rdi
cmpq $-0x1, %rdi
je 0xcbee
cmpq $-0x1, (%rdx,%rdi,8)
je 0xcbda
movl $0x2, (%rcx)
movl %eax, (%r8)
movq 0xf569(%rip), %rsi      # 0x1c128
xorl %edx, %edx
callq 0x3613
movq %rax, 0xf55b(%rip)      # 0x1c128
movq 0xf9ec(%rip), %rax      # 0x1c5c0
movq (%rax,%rbx,8), %rdi
jmp 0xcbe0
movl $0x1, (%rcx)
shlq $0x3, %rdi
addq 0xf585(%rip), %rdi      # 0x1c170
movq (%rdi), %rsi
movq %rsi, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf9b7(%rip), %rax      # 0x1c5c0
movq (%rax,%rdi,8), %r14
cmpq $-0x1, %r14
je 0xcc35
movq (%rax,%r14,8), %rcx
cmpq $-0x1, %rcx
je 0xcc35
movq (%rax,%rcx,8), %rcx
cmpq $-0x1, %rcx
je 0xcc35
cmpq $-0x1, (%rax,%rcx,8)
je 0xcc48
callq 0xcb74
jmp 0xcc3a
callq 0xcb5c
pushq $-0x5
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %rbx
movq %rsi, %r15
movq 0xf4d3(%rip), %rsi      # 0x1c128
movq %r14, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0xf4c2(%rip)      # 0x1c128
movl $0x2, (%r15)
movl $0x4, (%rbx)
movq 0xf4f6(%rip), %rax      # 0x1c170
movq (%rax,%r14,8), %rax
jmp 0xcc3d
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $-0x1
popq %rax
pushq $-0x5
popq %r14
cmpq $-0x1, %rbx
je 0xccb1
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq 0xf915(%rip), %rcx      # 0x1c5c0
movq (%rcx,%rbx,8), %rbx
jmp 0xcc91
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xf71e(%rip), %rax      # 0x1c5c0
movq (%rax,%rdi,8), %rcx
testq %rcx, %rcx
js 0xceb8
movq 0xf72e(%rip), %rdx      # 0x1c5e0
testb $0x19, (%rdx,%rcx)
je 0xcf34
movq %rbx, %rdi
callq 0xcb5c
movq 0xf6f9(%rip), %rax      # 0x1c5c0
movq (%rax,%rbx,8), %rcx
movq 0xf70e(%rip), %rdx      # 0x1c5e0
movq 0xf297(%rip), %r8       # 0x1c170
leaq (%r8,%rcx,8), %rdi
movq %rdi, %rsi
movq (%rsi), %r9
testq %r9, %r9
js 0xcf4d
testb $0x19, (%rdx,%r9)
jne 0xcf53
movq (%r8,%r9,8), %rsi
testq %rsi, %rsi
js 0xcf2b
testb $0x19, (%rdx,%rsi)
jne 0xcf2b
movq (%r8,%rsi,8), %r10
testq %r10, %r10
js 0xcf2b
testb $0x10, (%rdx,%r10)
je 0xcf2b
cmpq $-0x22, (%r8,%r10,8)
jne 0xcf2b
movq (%rax,%rsi,8), %r10
testq %r10, %r10
js 0xcf2b
testb $0x19, (%rdx,%r10)
jne 0xcf2b
leaq (%rax,%r9,8), %rsi
jmp 0xcee0
leaq 0x7b52(%rip), %rdi      # 0x14a84
jmp 0xcf5d
movq (%rax,%rcx,8), %rsi
testq %rsi, %rsi
js 0xceb8
testb $0x19, (%rdx,%rsi)
jne 0xceb8
jmp 0xced2
cmpq $-0x1, %r9
je 0xcf6a
leaq 0x7b41(%rip), %rdi      # 0x14a9b
movq %rbx, %rsi
callq 0x33e4
pushq $-0x5
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x1, (%r14)
movq (%rdi), %rdi
movq (%rax,%rcx,8), %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xccb6
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdi, %r15
movq 0xf62a(%rip), %rax      # 0x1c5c0
cmpq $-0x1, (%rax,%rdi,8)
je 0xd09c
pushq $-0x1
popq %rbx
movq %rbx, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %r14
movq 0xf16d(%rip), %rsi      # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0xf15c(%rip)      # 0x1c128
movq 0xf5ed(%rip), %rcx      # 0x1c5c0
leaq (%rcx,%r15,8), %rax
movq (%rax), %r12
movq 0xf18f(%rip), %rax      # 0x1c170
cmpq $-0x1, %r12
je 0xd0b0
movq (%rax,%r12,8), %r15
testq %r15, %r15
js 0xd08b
movq 0xf5e1(%rip), %rdx      # 0x1c5e0
testb $0x19, (%rdx,%r15)
jne 0xd08b
movq (%rcx,%r15,8), %rsi
cmpq $-0x1, %rsi
je 0xd08b
cmpq $-0x1, (%rcx,%rsi,8)
je 0xd05c
movq 0xf736(%rip), %rdi      # 0x1c758
xorl %edx, %edx
callq 0x3613
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3613
movq 0xf133(%rip), %rcx      # 0x1c170
movq (%rcx,%r15,8), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %r15
movq 0xf11b(%rip), %rax      # 0x1c170
movq 0xf564(%rip), %rcx      # 0x1c5c0
movq %r15, (%rax,%r14,8)
cmpq $-0x1, (%rcx,%r12,8)
je 0xd082
movq %rbx, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x3613
movq 0xf545(%rip), %rcx      # 0x1c5c0
movq %rax, (%rcx,%r14,8)
movq %rax, %r14
leaq (%rcx,%r12,8), %rax
jmp 0xcfd7
leaq 0x7a1e(%rip), %rdi      # 0x14ab0
movq %r15, %rsi
callq 0x33e4
jmp 0xd0a4
movq %r15, %rdi
callq 0xcb5c
pushq $-0x5
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0xf071(%rip), %rcx      # 0x1c128
movq (%rax,%rcx,8), %rdi
movq %rdi, %rsi
xorl %edx, %edx
callq 0x3613
movq 0xf03c(%rip), %rdi      # 0x1c108
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %rbx
pushq $0x1
popq %r14
movl %r14d, %edi
callq 0x3775
pushq $-0x1e
popq %rdi
movq %rbx, %rsi
movl %r14d, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3613
// File: /workspace/github_c_makefile_star2_O2/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 0xf4ba(%rip), %rcx      # 0x1c5c0
movq (%rcx,%rdi,8), %rax
cmpq $-0x1, %rax
je 0xd11e
cmpq $-0x1, (%rcx,%rax,8)
je 0xd128
callq 0xcb74
jmp 0xd123
callq 0xcb5c
pushq $-0x5
popq %rax
jmp 0xd133
movq 0xf041(%rip), %rcx      # 0x1c170
movq (%rcx,%rax,8), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x46c4
cmpl $0x2, %eax
jg 0xd184
movq %rbx, %rdi
callq 0xcb5c
jmp 0xd1f0
cmpl $0x3, %eax
jne 0xd1da
movq 0xefe0(%rip), %rax      # 0x1c170
movq 0xf429(%rip), %rcx      # 0x1c5c0
movq (%rcx,%rbx,8), %rcx
movq (%rax,%rcx,8), %rsi
testq %rsi, %rsi
js 0xd1e4
movq 0xf435(%rip), %rcx      # 0x1c5e0
testb $0x10, (%rcx,%rsi)
je 0xd1e4
cmpq $-0x22, (%rax,%rsi,8)
jne 0xd1e4
movq 0xef49(%rip), %rax      # 0x1c108
pushq $0x1
popq %rdx
movq %rsi, %rdi
movq %rax, %rsi
callq 0xca03
cmpl $0x0, 0xf3e0(%rip)      # 0x1c5b4
je 0xd1fe
pushq $-0x1
jmp 0xd1f2
movq %rbx, %rdi
callq 0xcb74
jmp 0xd1f0
leaq 0x78d8(%rip), %rdi      # 0x14ac3
callq 0x33e4
pushq $-0x5
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xef23(%rip), %rsi      # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0xef12(%rip)      # 0x1c128
movl $0x2, (%r15)
movl $0x5, (%r14)
movq 0xef45(%rip), %rax      # 0x1c170
movq 0xf38e(%rip), %rcx      # 0x1c5c0
movq (%rcx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
jmp 0xd1f3
// File: /workspace/github_c_makefile_star2_O2/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 0xeebd(%rip), %rdx      # 0x1c108
movq 0xf36e(%rip), %rcx      # 0x1c5c0
cmpq $-0x1, %rdx
je 0xd267
movq %rdx, %rax
movq (%rcx,%rdx,8), %rdx
cmpq $-0x1, %rdx
jne 0xd252
popq %rbp
retq
leaq 0x786c(%rip), %rdi      # 0x14ada
callq 0x39b6
// File: /workspace/github_c_makefile_star2_O2/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:
movabsq $-0x1, %rcx
cmpq $-0x1, %rsi
je 0xd2ab
pushq %rbp
movq %rsp, %rbp
movq 0xf332(%rip), %rdx      # 0x1c5c0
movq 0xeedb(%rip), %r8       # 0x1c170
movq (%rdx,%rsi,8), %rsi
cmpq $-0x1, %rsi
je 0xd2af
movq (%r8,%rsi,8), %rax
cmpq %rdi, (%r8,%rax,8)
jne 0xd295
jmp 0xd2b2
movq %rcx, %rax
retq
movq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
subq $0x18, %rsp
movq %rsi, %r12
movl %edi, %r14d
movq 0xee9e(%rip), %r13      # 0x1c170
movq 0xee5f(%rip), %rax      # 0x1c138
cmpq $0x1, (%r13,%rax,8)
jne 0xd303
testl %r14d, %r14d
leaq 0x7829(%rip), %rax      # 0x14b14
leaq 0x7803(%rip), %rdi      # 0x14af5
cmoveq %rax, %rdi
movq %r12, %rsi
callq 0x33e4
jmp 0xd420
movq %rcx, %rbx
movq %rdx, %r15
movq %r12, %rdi
callq 0x46c4
cmpl $0x2, %eax
jg 0xd323
movq %r12, %rdi
callq 0xcb5c
jmp 0xd420
cmpl $0x3, %eax
jne 0xd418
movq 0xf28d(%rip), %rax      # 0x1c5c0
movq (%rax,%r12,8), %rax
movq (%r13,%rax,8), %rsi
testq %rsi, %rsi
js 0xd436
movq 0xf294(%rip), %rax      # 0x1c5e0
testb $0x10, (%rax,%rsi)
je 0xd436
cmpq $-0x22, (%r13,%rsi,8)
jne 0xd436
movq 0xedbf(%rip), %rsi      # 0x1c128
pushq $-0x1
popq %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0xedae(%rip)      # 0x1c128
movq 0xedef(%rip), %rax      # 0x1c170
movq 0xf238(%rip), %rcx      # 0x1c5c0
movq (%rcx,%r12,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %r12
movq (%rax,%rdx,8), %rax
movq %rax, -0x30(%rbp)
callq 0xd240
movq 0xedc8(%rip), %r13      # 0x1c170
movq %rax, -0x40(%rbp)
movq (%r13,%rax,8), %rsi
movq -0x30(%rbp), %rdi
movq %rsi, -0x38(%rbp)
callq 0xd273
movq %r13, %rdx
cmpq $-0x1, %rax
jne 0xd3f8
pushq $-0x5
popq %rsi
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %r13
movq %r13, %rdx
callq 0xc8ad
movq 0xed8f(%rip), %rdx      # 0x1c170
movq -0x40(%rbp), %rax
movq %r13, (%rdx,%rax,8)
movq 0xf1d0(%rip), %rax      # 0x1c5c0
movq (%rax,%r13,8), %rax
movq (%rdx,%rax,8), %rax
movq 0xed29(%rip), %rcx      # 0x1c128
movq %rax, (%rdx,%rcx,8)
movl $0x2, (%r15)
cmpl $0x1, %r14d
pushq $0x6
popq %rax
sbbl $0x0, %eax
movl %eax, (%rbx)
jmp 0xd424
movq %r12, %rdi
callq 0xcb74
pushq $-0x5
popq %r12
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %r14d, %r14d
leaq 0x770c(%rip), %rax      # 0x14b4c
leaq 0x76e5(%rip), %rdi      # 0x14b2c
cmoveq %rax, %rdi
jmp 0xd2f9
// File: /workspace/github_c_makefile_star2_O2/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 0xf181(%rip), %rax      # 0x1c5e8
movq 0xf152(%rip), %rcx      # 0x1c5c0
movq (%rcx,%rdi,8), %rcx
leaq (%rax,%rcx,8), %rsi
cmpb $0x3a, (%rsi)
jne 0xd487
cmpb $0x3a, 0x1(%rsi)
jne 0xd487
cmpb $0x0, 0x2(%rsi)
je 0xd4d4
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 0x76b4(%rip), %rsi      # 0x14b6b
movl %ebx, %edx
xorl %eax, %eax
callq 0x31f0
movq %r14, %rdi
callq 0x69ff
addq $0x410, %rsp            # imm = 0x410
popq %rbx
popq %r14
popq %rbp
retq
movw $0x73, -0x41c(%rbp)
movl $0x6e6f6325, -0x420(%rbp) # imm = 0x6E6F6325
jmp 0xd496
// File: /workspace/github_c_makefile_star2_O2/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 %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movl %edi, %r12d
movq %rsi, %rdi
callq 0x46c4
cmpl $0x2, %eax
jg 0xdb16
movq %rbx, %rdi
callq 0xcb5c
pushq $-0x5
popq %rax
jmp 0xdb76
movq 0xec3b(%rip), %rdi      # 0x1c758
movq 0xea9c(%rip), %rax      # 0x1c5c0
movq (%rax,%rbx,8), %rcx
movq (%rax,%rcx,8), %rsi
pushq $0x8
popq %rdx
callq 0x3613
movq 0xe5ed(%rip), %rsi      # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0xe5dc(%rip)      # 0x1c128
movl $0x2, (%r15)
cmpl $0x1, %r12d
pushq $0xb
popq %rax
sbbl $0x0, %eax
movl %eax, (%r14)
movq 0xe609(%rip), %rax      # 0x1c170
movq 0xea52(%rip), %rcx      # 0x1c5c0
movq (%rcx,%rbx,8), %rcx
movq (%rax,%rcx,8), %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: apply_special
cell apply_special(cell x, int *pc, int *ps) {
	cell	sf;

	sf = car(x);
	if (sf == S_quote) return sf_quote(x);
	else if (sf == S_if) return sf_if(x, pc, ps);
	else if (sf == S_also) return sf_also(x, pc, ps);
	else if (sf == S_or) return sf_or(x, pc, ps);
	else if (sf == S_begin) return sf_begin(x, pc, ps);
	else if (sf == S_fn) return sf_fn(x);
	else if (sf == S_setb) return sf_setb(x, pc, ps);
	else if (sf == S_letrec) return sf_letrec(x, pc);
	else if (sf == S_define) return sf_define(0, x, pc, ps);
	else if (sf == S_raise) return sf_raise(x, pc, ps);
	else if (sf == S_from) return sf_redirect(0, x, pc, ps);
	else if (sf == S_to) return sf_redirect(1, x, pc, ps);
	else if (sf == S_define_type) return sf_define_type(x, pc);
	else if (sf == S_define_syntax) return sf_define(1, x, pc, ps);
	else fatal("internal: unknown special form");
	return UNDEFINED;
}

// Assembly:
movq %rdx, %r8
movq %rsi, %rcx
movq %rdi, %rdx
movq 0xe5e1(%rip), %rsi      # 0x1c170
movq (%rsi,%rdi,8), %rax
cmpq 0xeb0e(%rip), %rax      # 0x1c6a8
jne 0xdba4
movq %rdx, %rdi
jmp 0xd0fb
cmpq 0xeb95(%rip), %rax      # 0x1c740
jne 0xdbbb
movq %rdx, %rdi
movq %rcx, %rsi
movq %r8, %rdx
jmp 0xcbf8
cmpq 0xeb26(%rip), %rax      # 0x1c6e8
jne 0xdbcb
pushq $0x8
popq %rdi
pushq $-0x2
jmp 0xdbe9
cmpq 0xeb2e(%rip), %rax      # 0x1c700
jne 0xdbdb
pushq $0x9
popq %rdi
pushq $-0x3
jmp 0xdbe9
cmpq 0xeb76(%rip), %rax      # 0x1c758
jne 0xdbef
pushq $0x7
popq %rdi
pushq $-0x6
popq %rsi
jmp 0xcb8c
cmpq 0xeb12(%rip), %rax      # 0x1c708
jne 0xdc00
movq %rdx, %rdi
jmp 0xcf81
cmpq 0xeb81(%rip), %rax      # 0x1c788
jne 0xdc17
movq %rdx, %rdi
movq %rcx, %rsi
movq %r8, %rdx
jmp 0xd15d
cmpq 0xeb4a(%rip), %rax      # 0x1c768
jne 0xdc2b
movq %rdx, %rdi
movq %rcx, %rsi
jmp 0xce8e
cmpq 0xeb2e(%rip), %rax      # 0x1c760
jne 0xdc44
xorl %edi, %edi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
jmp 0xd2b4
cmpq 0xeaed(%rip), %rax      # 0x1c738
jne 0xdc6a
movl $0x2, (%rcx)
movl $0xc, (%r8)
movq 0xe95f(%rip), %rax      # 0x1c5c0
movq (%rax,%rdx,8), %rax
movq (%rsi,%rax,8), %rax
retq
cmpq 0xead7(%rip), %rax      # 0x1c748
jne 0xdc77
xorl %edi, %edi
jmp 0xdc83
cmpq 0xead2(%rip), %rax      # 0x1c750
jne 0xdc91
pushq $0x1
popq %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
jmp 0xdae5
cmpq 0xead8(%rip), %rax      # 0x1c770
jne 0xdca5
movq %rdx, %rdi
movq %rcx, %rsi
jmp 0xd897
cmpq 0xeae4(%rip), %rax      # 0x1c790
jne 0xdcb3
pushq $0x1
popq %rdi
jmp 0xdc36
pushq %rbp
movq %rsp, %rbp
leaq 0x6f43(%rip), %rdi      # 0x14c01
callq 0x39b6
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0xe910(%rip), %rax      # 0x1c5e8
movq 0xe8e1(%rip), %rcx      # 0x1c5c0
xorl %esi, %esi
movq 0xe488(%rip), %rdx      # 0x1c170
cmpq $-0x1, %rdi
je 0xdd06
movq (%rdx,%rdi,8), %r8
movq (%rcx,%r8,8), %r8
movl -0x8(%rax,%r8,8), %r8d
addl %r8d, %esi
decl %esi
movq (%rcx,%rdi,8), %rdi
jmp 0xdce8
leaq 0x7bcb(%rip), %rdi      # 0x158d8
callq 0x729e
movq %rax, %r14
movq 0xe8cc(%rip), %rax      # 0x1c5e8
movq 0xe89d(%rip), %rcx      # 0x1c5c0
movq (%rcx,%r14,8), %rdx
leaq (%rax,%rdx,8), %r15
xorl %edi, %edi
cmpq $-0x1, %rbx
je 0xdd85
movq 0xe436(%rip), %rdx      # 0x1c170
movq (%rdx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rcx
leaq (%rax,%rcx,8), %rsi
movslq -0x8(%rsi), %rdx
movslq %edi, %r12
leaq (%r15,%r12), %rdi
callq 0x3130
movq 0xe88b(%rip), %rax      # 0x1c5e8
movq 0xe85c(%rip), %rcx      # 0x1c5c0
movq 0xe405(%rip), %rdx      # 0x1c170
movq (%rdx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rdx
movq -0x8(%rax,%rdx,8), %rdx
leaq (%r12,%rdx), %rdi
decq %rdi
movq (%rcx,%rbx,8), %rbx
jmp 0xdd2d
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: 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:
movq 0xe3d8(%rip), %rdx      # 0x1c170
movq (%rdx,%rdi,8), %rax
movq 0xe81d(%rip), %rcx      # 0x1c5c0
movq (%rcx,%rdi,8), %rcx
movq (%rdx,%rcx,8), %rcx
cmpq $-0x1, %rax
je 0xde96
cmpq $-0x1, %rcx
je 0xde95
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
pushq $-0x1
popq %r15
pushq $0x8
popq %r12
movq %r15, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x3613
movq %rax, %r14
movq 0xe335(%rip), %rsi      # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0xe324(%rip)      # 0x1c128
movq %rbx, -0x38(%rbp)
leaq (,%rbx,8), %rcx
addq 0xe359(%rip), %rcx      # 0x1c170
leaq -0x40(%rbp), %r13
movq %r14, -0x30(%rbp)
movq (%rcx), %rbx
cmpq $-0x1, %rbx
je 0xde5d
movq 0xe341(%rip), %rax      # 0x1c170
movq (%rax,%rbx,8), %rcx
movq %rcx, (%rax,%r14,8)
movq %r15, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x3613
movq 0xe774(%rip), %rcx      # 0x1c5c0
leaq (%rcx,%r14,8), %r13
movq %rax, (%r13)
leaq (%rcx,%rbx,8), %rcx
movq %rax, %r14
jmp 0xde1f
pushq $0x1
popq %rdi
callq 0x3775
movq 0xe304(%rip), %rax      # 0x1c170
movq 0xe74d(%rip), %rcx      # 0x1c5c0
movq -0x38(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, (%r13)
movq -0x30(%rbp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq %rdi, %rsi
movq 0xe2cc(%rip), %rax      # 0x1c170
movq (%rax,%rdi,8), %rdx
movq 0xe711(%rip), %rcx      # 0x1c5c0
movq (%rcx,%rdi,8), %rcx
movq (%rax,%rcx,8), %rcx
testq %rdx, %rdx
js 0xded6
movq 0xe71d(%rip), %rdi      # 0x1c5e0
movb (%rdi,%rdx), %r8b
movl %r8d, %r9d
andb $0x19, %r9b
cmpb $0x8, %r9b
je 0xdedc
jmp 0xdf14
cmpq $-0x1, %rdx
jne 0xdf1a
testq %rcx, %rcx
js 0xdefe
movq 0xe6f8(%rip), %rdi      # 0x1c5e0
movb (%rdi,%rcx), %dil
andb $0x19, %dil
cmpb $0x8, %dil
jne 0xdf04
movq %rsi, %rdi
jmp 0xdd91
cmpq $-0x1, %rcx
je 0xdef6
testq %rdx, %rdx
js 0xdf1a
movq 0xe6d0(%rip), %rdi      # 0x1c5e0
movb (%rdi,%rdx), %r8b
testb $0x10, %r8b
jne 0xdf2f
pushq %rbp
movq %rsp, %rbp
leaq 0x6cfb(%rip), %rdi      # 0x14c20
callq 0x33e4
pushq $-0x5
popq %rax
popq %rbp
retq
cmpq $-0x21, (%rax,%rdx,8)
jne 0xdf1a
testq %rcx, %rcx
js 0xdf1a
testb $0x10, (%rdi,%rcx)
je 0xdf1a
cmpq $-0x21, (%rax,%rcx,8)
jne 0xdf1a
movq %rsi, %rdi
jmp 0xdcc3
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0xe20f(%rip), %rax      # 0x1c170
movq (%rax,%rdi,8), %rbx
testq %rbx, %rbx
js 0xdff0
movq 0xe66b(%rip), %rcx      # 0x1c5e0
testb $0x10, (%rcx,%rbx)
je 0xdff0
cmpq $-0x24, (%rax,%rbx,8)
jne 0xdff0
movq %rdi, %r14
movq 0xe65c(%rip), %rax      # 0x1c5e8
movq 0xe62d(%rip), %rcx      # 0x1c5c0
movq (%rcx,%rbx,8), %rcx
movq -0x8(%rax,%rcx,8), %rax
shlq $0x1d, %rax
movl $0xe0000000, %r15d      # imm = 0xE0000000
addq %rax, %r15
sarq $0x1d, %r15
andq $-0x8, %r15
pushq $-0x24
popq %rdi
movl %r15d, %esi
callq 0x4037
movq %rax, %rbx
movq 0xe622(%rip), %rax      # 0x1c5e8
movq 0xe5f3(%rip), %rcx      # 0x1c5c0
movq (%rcx,%rbx,8), %rdx
leaq (%rax,%rdx,8), %rdi
movq 0xe194(%rip), %rdx      # 0x1c170
movq (%rdx,%r14,8), %rdx
movq (%rcx,%rdx,8), %rcx
leaq (%rax,%rcx,8), %rsi
movq %r15, %rdx
callq 0x3130
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: pp_len
cell pp_len(cell x) {
	int	k = 0;

	if (string_p(car(x)))
		return make_integer(string_len(car(x))-1);
	if (vector_p(car(x)))
		return make_integer(vector_len(car(x)));
	if (!list_p(car(x)) && !tuple_p(car(x)))
		error("len: expected str/list/tuple/vec, got", car(x));
	for (x = car(x); x != NIL; x = cdr(x))
		k++;
	return make_integer(k);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xe162(%rip), %rax      # 0x1c170
movq (%rax,%rdi,8), %rsi
testq %rsi, %rsi
js 0xe02e
movq 0xe5c2(%rip), %rcx      # 0x1c5e0
movzbl (%rcx,%rsi), %ecx
testb $0x10, %cl
jne 0xe066
testb $0x11, %cl
je 0xe047
jmp 0xe034
cmpq $-0x1, %rsi
je 0xe047
leaq 0x6c08(%rip), %rdi      # 0x14c43
callq 0x33e4
movq 0xe129(%rip), %rax      # 0x1c170
leaq (%rax,%rbx,8), %rcx
movq 0xe56e(%rip), %rax      # 0x1c5c0
xorl %edi, %edi
movq (%rcx), %rcx
cmpq $-0x1, %rcx
je 0xe0af
leaq (%rax,%rcx,8), %rcx
incq %rdi
jmp 0xe054
cmpq $-0x21, (%rax,%rsi,8)
jne 0xe089
movq 0xe574(%rip), %rax      # 0x1c5e8
movq 0xe545(%rip), %rcx      # 0x1c5c0
movq (%rcx,%rsi,8), %rcx
movq -0x8(%rax,%rcx,8), %rdi
decq %rdi
jmp 0xe0af
cmpq $-0x24, (%rax,%rsi,8)
jne 0xe027
movq 0xe551(%rip), %rax      # 0x1c5e8
movq 0xe522(%rip), %rcx      # 0x1c5c0
movq (%rcx,%rsi,8), %rcx
movq -0x8(%rax,%rcx,8), %rdi
addq $0x7, %rdi
shrq $0x3, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x35ed
// File: /workspace/github_c_makefile_star2_O2/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
movq 0xe0ab(%rip), %rax      # 0x1c170
movq (%rax,%rdi,8), %rax
cmpq $-0x6, %rax
jne 0xe0d3
xorl %edi, %edi
jmp 0xe0ef
testq %rax, %rax
js 0xe0e5
movq 0xe501(%rip), %rcx      # 0x1c5e0
testb $0x19, (%rcx,%rax)
je 0xe0f5
movabsq $0x1, %rdi
popq %rbp
jmp 0x35ed
popq %rbp
jmp 0xdffe
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: pp_rev
cell pp_rev(cell x) {
	cell	n, m;
	int	k, i;
	char	*s, *d;

	if (list_p(car(x))) {
		m = NIL;
		for (n = car(x); n != NIL; n = cdr(n))
			m = cons(car(n), m);
		return m;
	}
	if (string_p(car(x))) {
		s = string(car(x));
		k = string_len(car(x))-1;
		m = make_string("", k);
		d = string(m);
		for (i=0; i<k; i++)
			d[i] = s[k-i-1];
		d[i] = 0;
		return m;
	}
	return error("rev: expected list/str, got", car(x));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0xe064(%rip), %rax      # 0x1c170
movq (%rax,%rdi,8), %rbx
testq %rbx, %rbx
js 0xe1a2
movq 0xe4c0(%rip), %rcx      # 0x1c5e0
movb (%rcx,%rbx), %cl
movl %ecx, %edx
andb $0x19, %dl
cmpb $0x8, %dl
je 0xe1c5
testb $0x10, %cl
je 0xe1a8
cmpq $-0x21, (%rax,%rbx,8)
jne 0xe1a8
movq 0xe4a4(%rip), %rax      # 0x1c5e8
movq 0xe475(%rip), %rcx      # 0x1c5c0
movq (%rcx,%rbx,8), %rcx
leaq (%rax,%rcx,8), %r14
movl -0x8(%r14), %r15d
leal -0x1(%r15), %ebx
leaq 0x7776(%rip), %rdi      # 0x158d8
movl %ebx, %esi
callq 0x729e
movq 0xe450(%rip), %rcx      # 0x1c5c0
movq (%rcx,%rax,8), %rcx
shlq $0x3, %rcx
addq 0xe469(%rip), %rcx      # 0x1c5e8
xorl %edx, %edx
testl %ebx, %ebx
cmovlel %edx, %ebx
addl $-0x2, %r15d
cmpq %rdx, %rbx
je 0xe1f5
movslq %r15d, %r15
movb (%r14,%r15), %sil
movb %sil, (%rcx,%rdx)
incq %rdx
decl %r15d
jmp 0xe18a
cmpq $-0x1, %rbx
je 0xe1c5
leaq 0x6aba(%rip), %rdi      # 0x14c69
movq %rbx, %rsi
callq 0x33e4
pushq $-0x5
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x1
popq %rax
pushq $0x8
popq %r14
cmpq $-0x1, %rbx
je 0xe1ba
movq 0xdf97(%rip), %rcx      # 0x1c170
movq (%rcx,%rbx,8), %rdi
movq %rax, %rsi
movl %r14d, %edx
callq 0x3613
movq 0xe3d1(%rip), %rcx      # 0x1c5c0
movq (%rcx,%rbx,8), %rbx
jmp 0xe1cc
movb $0x0, (%rcx,%rbx)
jmp 0xe1ba
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
subl %esi, %r14d
je 0xe905
movl %ecx, %ebx
movl %esi, %r12d
movq %rdi, %r13
pushq $-0x1
popq %rdi
movq %rdi, %rsi
movl %ecx, %edx
callq 0x3613
movq %rax, %r15
movq 0xd8a8(%rip), %rsi      # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0xd897(%rip)      # 0x1c128
shlq $0x3, %r13
addq 0xd8d4(%rip), %r13      # 0x1c170
movq 0xdd1d(%rip), %rcx      # 0x1c5c0
movq (%r13), %r13
subl $0x1, %r12d
jb 0xe8b3
leaq (%rcx,%r13,8), %r13
jmp 0xe8a3
pushq $-0x1
popq %r12
subl $0x1, %r14d
jb 0xe8ef
movq 0xd8ac(%rip), %rax      # 0x1c170
movq (%rax,%r13,8), %rdx
movq %rdx, (%rax,%r15,8)
jle 0xe8e9
movq %r12, %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x3613
movq 0xdcde(%rip), %rcx      # 0x1c5c0
movq %rax, (%rcx,%r15,8)
movq %rax, %r15
movq (%rcx,%r13,8), %r13
jmp 0xe8b7
pushq $0x1
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3775
pushq $-0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: pp_ref
cell pp_ref(cell x) {
	int	p, k, n;

	p = integer_value("ref", cadr(x));
	if (cons_p(car(x))) {
		for (n = car(x); n != NIL && p; n = cdr(n), p--)
			;
		if (n == NIL)
			return error("ref: index out of range", cadr(x));
		return car(n);
	}
	if (vector_p(car(x))) {
		k = vector_len(car(x))-1;
		if (p < 0 || p > k)
			return error("ref: index out of range", cadr(x));
		return vector(car(x))[p];
	}
	if (!string_p(car(x)))
		return error("ref: expected str/tuple/list/vec, got", car(x));
	k = string_len(car(x))-1;
	if (p < 0 || p >= k)
		return error("ref: index out of range", cadr(x));
	return make_char(string(car(x))[p]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xd663(%rip), %rax      # 0x1c170
movq 0xdaac(%rip), %rcx      # 0x1c5c0
movq (%rcx,%rdi,8), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x61df(%rip), %rdi      # 0x14d02
callq 0x41c5
movq 0xd641(%rip), %rcx      # 0x1c170
movq (%rcx,%rbx,8), %rsi
testq %rsi, %rsi
js 0xeb4c
movq 0xdaa1(%rip), %rdx      # 0x1c5e0
movb (%rdx,%rsi), %dl
testb $0x11, %dl
je 0xeb58
testb $0x10, %dl
jne 0xeb8e
leaq 0x61cb(%rip), %rdi      # 0x14d1e
jmp 0xec20
movq 0xda61(%rip), %rdx      # 0x1c5c0
addl $-0x1, %eax
setb %dil
cmpl $-0x1, %esi
je 0xeb79
testb %dil, %dil
je 0xeb79
movslq %esi, %rsi
movq (%rdx,%rsi,8), %rsi
jmp 0xeb5f
cmpl $-0x1, %esi
je 0xec11
movslq %esi, %rax
movq (%rcx,%rax,8), %rax
jmp 0xec28
cmpq $-0x24, (%rcx,%rsi,8)
jne 0xebcb
movq 0xda24(%rip), %rdx      # 0x1c5c0
testl %eax, %eax
js 0xec11
movq (%rdx,%rsi,8), %rsi
movq 0xda3d(%rip), %rdi      # 0x1c5e8
movq -0x8(%rdi,%rsi,8), %r8
addq $0x7, %r8
shrq $0x3, %r8
decl %r8d
cmpl %eax, %r8d
jl 0xec11
leaq (%rdi,%rsi,8), %rcx
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
jmp 0xeb85
cmpq $-0x21, (%rcx,%rsi,8)
jne 0xeb4c
movq 0xd9e3(%rip), %rdx      # 0x1c5c0
testl %eax, %eax
js 0xec11
movq (%rdx,%rsi,8), %rsi
movq 0xd9fc(%rip), %rdi      # 0x1c5e8
movl -0x8(%rdi,%rsi,8), %r8d
decl %r8d
cmpl %eax, %r8d
jle 0xec11
leaq (%rdi,%rsi,8), %rcx
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movsbl (%rcx,%rax), %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x7314
movq (%rdx,%rbx,8), %rax
movq (%rcx,%rax,8), %rsi
leaq 0x60e6(%rip), %rdi      # 0x14d06
callq 0x33e4
pushq $-0x5
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: pp_typecheck
cell pp_typecheck(cell x) {
	cell	cname, datum, type, ps, p;
	char	msg[TOKEN_LENGTH*2];

	cname = car(x);
	datum = cadr(x);
	ps = caddr(x);
	if (!tuple_p(ps) || !symbol_p(car(ps)))
		return error("type-check: bad type pattern", ps);
	type = car(ps);
	for (ps = cdr(ps); tuple_p(ps); ps = cdr(ps)) {
		p = car(ps);
		if (symbol_p(p) && p == datum)
			return datum;
		else if (p == S_cons && list_p(datum))
			return datum;
		else if (tuple_p(p) && tuple_p(datum) && car(p) == car(datum))
			return datum;
	}
	sprintf(msg, "%s: expected %s, got",
			string(cname), string(type));
	return error(msg, datum);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
movq 0xd280(%rip), %rcx      # 0x1c170
movq 0xd6c9(%rip), %rax      # 0x1c5c0
movq (%rax,%rdi,8), %r9
movq (%rax,%r9,8), %rdx
movq (%rcx,%rdx,8), %rsi
testq %rsi, %rsi
js 0xef15
movq 0xd6d1(%rip), %rdx      # 0x1c5e0
testb $0x19, (%rdx,%rsi)
je 0xef33
leaq 0x5e7d(%rip), %rdi      # 0x14d99
callq 0x33e4
pushq $-0x5
popq %rbx
movq %rbx, %rax
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r14
popq %rbp
retq
movq (%rcx,%rsi,8), %r8
testq %r8, %r8
js 0xef15
testb $0x10, (%rdx,%r8)
je 0xef15
cmpq $-0x22, (%rcx,%r8,8)
jne 0xef15
movq (%rcx,%rdi,8), %rdi
movq (%rcx,%r9,8), %rbx
movq 0xd737(%rip), %r10      # 0x1c690
pushq $-0x1
popq %r9
movq (%rax,%rsi,8), %rsi
testq %rsi, %rsi
js 0xefd8
testb $0x19, (%rdx,%rsi)
jne 0xefd8
movq (%rcx,%rsi,8), %r11
testq %r11, %r11
js 0xef88
testb $0x10, (%rdx,%r11)
je 0xef88
cmpq $-0x22, (%rcx,%r11,8)
jne 0xef88
cmpq %rbx, %r11
je 0xef24
cmpq %r10, %r11
jne 0xefa8
testq %rbx, %rbx
js 0xefa2
movb (%rdx,%rbx), %r14b
andb $0x19, %r14b
cmpb $0x8, %r14b
jne 0xefa8
jmp 0xef24
cmpq $-0x1, %rbx
je 0xf012
testq %r11, %r11
js 0xef5d
movzbl (%rdx,%r11), %r14d
testb $0x11, %r14b
jne 0xef5d
testb $0x8, %r14b
jne 0xef5d
testq %rbx, %rbx
js 0xef5d
testb $0x19, (%rdx,%rbx)
jne 0xef5d
movq (%rcx,%r11,8), %r11
cmpq (%rcx,%rbx,8), %r11
jne 0xef5d
jmp 0xef24
movq 0xd609(%rip), %rcx      # 0x1c5e8
movq (%rax,%rdi,8), %rdx
leaq (%rcx,%rdx,8), %rdx
movq (%rax,%r8,8), %rax
leaq (%rcx,%rax,8), %rcx
leaq 0x5dc0(%rip), %rsi      # 0x14db6
leaq -0x810(%rbp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x31f0
movq %r14, %rdi
movq %rbx, %rsi
jmp 0xef1c
movq %r9, %rbx
jmp 0xef24
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xd0fd(%rip), %rdi      # 0x1c128
pushq $-0x1
popq %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0x3613
movq 0xd0f0(%rip), %rdi      # 0x1c130
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq 0xd0e7(%rip), %rdi      # 0x1c138
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq 0xd0a6(%rip), %rdi      # 0x1c108
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
pushq $-0x25
popq %rdi
pushq $0x1
popq %rdx
movq %rax, %rsi
callq 0x3613
movq %rax, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3613
movq 0xd0e2(%rip), %rcx      # 0x1c170
movq (%rcx,%rbx,8), %rdi
movq %rax, %rsi
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x3613
// File: /workspace/github_c_makefile_star2_O2/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
movq 0xd515(%rip), %rax      # 0x1c5c0
movq (%rax,%rdi,8), %rcx
cmpq $-0x1, %rcx
je 0xf0c3
cmpq $-0x1, (%rax,%rcx,8)
je 0xf0cd
callq 0xcb74
jmp 0xf0c8
callq 0xcb5c
pushq $-0x5
popq %rax
jmp 0xf128
movq 0xd09c(%rip), %rcx      # 0x1c170
movq (%rcx,%rdi,8), %rdx
movq (%rax,%rdx,8), %rdx
movq (%rcx,%rdx,8), %rsi
movq %rsi, 0xd021(%rip)      # 0x1c108
movq (%rax,%rdx,8), %rsi
movq (%rcx,%rsi,8), %rsi
movq %rsi, 0xd042(%rip)      # 0x1c138
movq (%rax,%rdx,8), %rsi
movq (%rax,%rsi,8), %rsi
movq (%rcx,%rsi,8), %rsi
movq %rsi, 0xd027(%rip)      # 0x1c130
movq (%rax,%rdx,8), %rdx
movq (%rax,%rdx,8), %rdx
movq (%rax,%rdx,8), %rdx
movq (%rcx,%rdx,8), %rdx
movq %rdx, 0xd008(%rip)      # 0x1c128
movq (%rax,%rdi,8), %rax
movq (%rcx,%rax,8), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq 0xd03b(%rip), %rcx      # 0x1c170
movq (%rcx,%rdi,8), %rax
movq 0xd480(%rip), %rdx      # 0x1c5c0
movq (%rdx,%rdi,8), %rdx
movq (%rcx,%rdx,8), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq 0xd00f(%rip), %rsi      # 0x1c168
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0xcffe(%rip)      # 0x1c168
pushq $-0x6
popq %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0xcff2(%rip), %rax      # 0x1c168
cmpq $-0x1, %rax
je 0xf19a
movq 0xd43d(%rip), %rcx      # 0x1c5c0
movq (%rcx,%rax,8), %rax
movq %rax, 0xcfda(%rip)      # 0x1c168
movq 0xcfdb(%rip), %rax      # 0x1c170
movq (%rax,%rdi,8), %rax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x5c26(%rip), %rdi      # 0x14dcb
pushq $-0x8
popq %rsi
callq 0x33e4
pushq $-0x5
popq %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: eqv_p
int eqv_p(cell a, cell b) {
	if (a == b)
		return 1;
	if (char_p(a) && char_p(b) && char_value(a) == char_value(b))
		return 1;
	if (number_p(a) && number_p(b)) {
		if (real_p(a) != real_p(b))
			return 0;
		return real_equal_p(a, b);
	}
	return a == b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, %edx
cmpq %rsi, %rdi
jne 0xf1c7
movl %edx, %eax
jmp 0xf27f
xorl %eax, %eax
testq %rdi, %rdi
js 0xf27f
movq 0xd407(%rip), %r9       # 0x1c5e0
testb $0x1, (%r9,%rdi)
je 0xf27f
movq 0xcf85(%rip), %rcx      # 0x1c170
movq (%rcx,%rdi,8), %r8
cmpq $-0x16, %r8
setne %r10b
testq %rsi, %rsi
sets %r11b
orb %r10b, %r11b
je 0xf210
cmpq $-0x1f, %r8
jne 0xf23d
testq %rsi, %rsi
jns 0xf250
jmp 0xf27f
testb $0x1, (%r9,%rsi)
je 0xf239
cmpq $-0x16, (%rcx,%rsi,8)
jne 0xf239
movq 0xd39b(%rip), %rax      # 0x1c5c0
movq (%rax,%rdi,8), %rdi
movq (%rcx,%rdi,8), %rdi
movq (%rax,%rsi,8), %rsi
movl %edx, %eax
cmpq (%rcx,%rsi,8), %rdi
je 0xf27f
xorl %eax, %eax
jmp 0xf27f
testq %rsi, %rsi
sets %dl
cmpq $-0x18, %r8
setne %r10b
orb %dl, %r10b
jne 0xf27f
testb $0x1, (%r9,%rsi)
je 0xf27f
movq (%rcx,%rsi,8), %rcx
cmpq $-0x18, %rcx
je 0xf267
cmpq $-0x1f, %rcx
jne 0xf27f
cmpq $-0x1f, %r8
sete %dl
cmpq $-0x1f, %rcx
setne %cl
cmpb %cl, %dl
je 0xf27f
popq %rbp
jmp 0x5cd1
popq %rbp
retq