LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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
xorl %eax, %eax
cmpq $-0x1, %rdi
je 0xe589
movq 0x10046(%rip), %rcx     # 0x1e5c0
movq %rbx, %rdx
incl %eax
movq (%rcx,%rdx,8), %rdx
cmpq $-0x1, %rdx
jne 0xe57d
cmpl $0x2, %eax
jg 0xe59a
leaq 0x84e5(%rip), %rdi      # 0x16a7a
jmp 0xe646
cmpl $0x3, %eax
jne 0xe63f
movq 0xfbc6(%rip), %rax      # 0x1e170
movq 0x1000f(%rip), %rcx     # 0x1e5c0
movq (%rcx,%rbx,8), %rcx
movq (%rax,%rcx,8), %rsi
testq %rsi, %rsi
js 0xe64b
movq 0x10017(%rip), %rcx     # 0x1e5e0
testb $0x10, (%rcx,%rsi)
je 0xe64b
cmpq $-0x22, (%rax,%rsi,8)
jne 0xe64b
movq 0xfb2b(%rip), %rax      # 0x1e108
movq %rsi, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0xdd28
movq %rax, %rdi
movq $-0x1, %rax
cmpl $0x0, 0xffb6(%rip)      # 0x1e5b4
jne 0xe65e
movq 0xfb21(%rip), %rsi      # 0x1e128
xorl %edx, %edx
callq 0x36e8
movq %rax, 0xfb13(%rip)      # 0x1e128
movl $0x2, (%r15)
movl $0x5, (%r14)
movq 0xfb46(%rip), %rax      # 0x1e170
movq 0xff8f(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
jmp 0xe65e
leaq 0x8446(%rip), %rdi      # 0x16a8c
movq %rbx, %rsi
jmp 0xe652
leaq 0x848c(%rip), %rdi      # 0x16ade
callq 0x33eb
movq $-0x5, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: 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 0xfa94(%rip), %rdx      # 0x1e108
movq 0xff45(%rip), %rcx      # 0x1e5c0
cmpq $-0x1, %rdx
je 0xe690
movq %rdx, %rax
movq (%rcx,%rdx,8), %rdx
cmpq $-0x1, %rdx
jne 0xe67b
popq %rbp
retq
leaq 0x845e(%rip), %rdi      # 0x16af5
callq 0x3ab5
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: find_local_variable
cell find_local_variable(cell v, cell e) {
	if (e == NIL)
		return NIL;
	e = cdr(e);
	while (e != NIL) {
		if (v == caar(e))
			return car(e);
		e = cdr(e);
	}
	return NIL;
}

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r12
movl %edi, %r14d
movq 0xfa77(%rip), %rax      # 0x1e170
movq 0xfa38(%rip), %rcx      # 0x1e138
cmpq $0x1, (%rax,%rcx,8)
jne 0xe721
testl %r14d, %r14d
leaq 0x841e(%rip), %rax      # 0x16b2f
leaq 0x83f8(%rip), %rdi      # 0x16b10
cmoveq %rax, %rdi
jmp 0xe812
movq %rdx, %r15
xorl %ecx, %ecx
cmpq $-0x1, %r12
je 0xe742
movq 0xfe8d(%rip), %rdx      # 0x1e5c0
movq %r12, %rsi
incl %ecx
movq (%rdx,%rsi,8), %rsi
cmpq $-0x1, %rsi
jne 0xe736
cmpl $0x2, %ecx
jg 0xe753
leaq 0x832c(%rip), %rdi      # 0x16a7a
jmp 0xe812
cmpl $0x3, %ecx
jne 0xe80b
movq 0xfe5d(%rip), %rcx      # 0x1e5c0
movq (%rcx,%r12,8), %rcx
movq (%rax,%rcx,8), %rsi
testq %rsi, %rsi
js 0xe833
movq 0xfe65(%rip), %rcx      # 0x1e5e0
testb $0x10, (%rcx,%rsi)
je 0xe833
cmpq $-0x22, (%rax,%rsi,8)
jne 0xe833
movq 0xf991(%rip), %rsi      # 0x1e128
movq $-0x1, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0xf97c(%rip)      # 0x1e128
movq 0xf9bd(%rip), %rax      # 0x1e170
movq 0xfe06(%rip), %rcx      # 0x1e5c0
movq (%rcx,%r12,8), %rdx
movq (%rcx,%rdx,8), %rsi
movq (%rax,%rsi,8), %r12
movq (%rax,%rdx,8), %rdi
movq 0xf937(%rip), %rdx      # 0x1e108
cmpq $-0x1, %rdx
je 0xe8b1
movq %rdx, %r13
movq (%rcx,%rdx,8), %rdx
cmpq $-0x1, %rdx
jne 0xe7d1
movq (%rax,%r13,8), %rdx
cmpq $-0x1, %rdx
je 0xe84a
movq %rdx, %rsi
movq (%rcx,%rsi,8), %rsi
cmpq $-0x1, %rsi
je 0xe84a
movq (%rax,%rsi,8), %r8
cmpq %rdi, (%rax,%r8,8)
jne 0xe7f5
jmp 0xe851
leaq 0x827a(%rip), %rdi      # 0x16a8c
movq %r12, %rsi
callq 0x33eb
movq $-0x5, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %r14d, %r14d
leaq 0x832a(%rip), %rax      # 0x16b67
leaq 0x8303(%rip), %rdi      # 0x16b47
cmoveq %rax, %rdi
jmp 0xe815
movq $-0x1, %r8
cmpq $-0x1, %r8
jne 0xe885
movq $-0x5, %rsi
movq %rdx, -0x30(%rbp)
callq 0xdba0
movq 0xf902(%rip), %rax      # 0x1e170
movq -0x30(%rbp), %rdx
movq %rdx, (%rax,%r13,8)
movq 0xfd43(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %r8
movq 0xf8e4(%rip), %rax      # 0x1e170
movq 0xf895(%rip), %rcx      # 0x1e128
movq %r8, (%rax,%rcx,8)
movl $0x2, (%r15)
cmpl $0x1, %r14d
movl $0x6, %eax
sbbl $0x0, %eax
movl %eax, (%rbx)
jmp 0xe821
leaq 0x823d(%rip), %rdi      # 0x16af5
callq 0x3ab5
// File: /workspace/github_c_makefile_star2_O1/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 0xfcec(%rip), %rax      # 0x1e5c0
movq (%rax,%rdi,8), %r14
shlq $0x3, %r14
addq 0xfd05(%rip), %r14      # 0x1e5e8
leaq 0x78db(%rip), %rsi      # 0x161c5
movq %r14, %rdi
callq 0x3110
testl %eax, %eax
je 0xe90a
incq %r14
leaq -0x420(%rbp), %rdi
movq %r14, %rsi
callq 0x3060
jmp 0xe91d
movw $0x73, -0x41c(%rbp)
movl $0x6e6f6325, -0x420(%rbp) # imm = 0x6E6F6325
leaq -0x420(%rbp), %r14
movq %r14, %rdi
callq 0x30a0
leaq (%rax,%rbp), %rdi
addq $-0x420, %rdi           # imm = 0xFBE0
leaq 0x8248(%rip), %rsi      # 0x16b86
movl %ebx, %edx
xorl %eax, %eax
callq 0x31f0
movq %r14, %rdi
callq 0x729e
addq $0x410, %rsp            # imm = 0x410
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: sf_redirect
cell sf_redirect(int out, cell x, int *pc, int *ps) {
	int	k;

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
cmpq $-0x1, %rsi
je 0xf009
movq %rcx, %r14
movq %rdx, %r15
movl %edi, %r12d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq 0xf5cb(%rip), %rcx      # 0x1e5c0
movq %rbx, %rdx
movq (%rcx,%rdx,8), %rdx
incl %eax
cmpq $-0x1, %rdx
jne 0xeff8
cmpl $0x1, %eax
ja 0xf021
leaq 0x7a6a(%rip), %rdi      # 0x16a7a
movq %rbx, %rsi
callq 0x33eb
movq $-0x5, %rax
jmp 0xf085
movq 0xf730(%rip), %rdi      # 0x1e758
movq 0xf591(%rip), %rax      # 0x1e5c0
movq (%rax,%rbx,8), %rcx
movq (%rax,%rcx,8), %rsi
movl $0x8, %edx
callq 0x36e8
movq 0xf0e0(%rip), %rsi      # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0xf0cf(%rip)      # 0x1e128
movl $0x2, (%r15)
cmpl $0x1, %r12d
movl $0xb, %eax
sbbl $0x0, %eax
movl %eax, (%r14)
movq 0xf0fa(%rip), %rax      # 0x1e170
movq 0xf543(%rip), %rcx      # 0x1e5c0
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_O1/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 0xf0d2(%rip), %rsi      # 0x1e170
movq (%rsi,%rdi,8), %rax
cmpq 0xf5ff(%rip), %rax      # 0x1e6a8
jne 0xf0b3
movq %rdx, %rdi
jmp 0xe4e6
cmpq 0xf686(%rip), %rax      # 0x1e740
jne 0xf0ca
movq %rdx, %rdi
movq %rcx, %rsi
movq %r8, %rdx
jmp 0xdf27
cmpq 0xf617(%rip), %rax      # 0x1e6e8
jne 0xf0e4
movl $0x8, %edi
movq $-0x2, %rsi
jmp 0xdebb
cmpq 0xf615(%rip), %rax      # 0x1e700
jne 0xf0fe
movl $0x9, %edi
movq $-0x3, %rsi
jmp 0xdebb
cmpq 0xf653(%rip), %rax      # 0x1e758
jne 0xf118
movl $0x7, %edi
movq $-0x6, %rsi
jmp 0xdebb
cmpq 0xf5e9(%rip), %rax      # 0x1e708
jne 0xf129
movq %rdx, %rdi
jmp 0xe33b
cmpq 0xf658(%rip), %rax      # 0x1e788
jne 0xf140
movq %rdx, %rdi
movq %rcx, %rsi
movq %r8, %rdx
jmp 0xe558
cmpq 0xf621(%rip), %rax      # 0x1e768
jne 0xf154
movq %rdx, %rdi
movq %rcx, %rsi
jmp 0xe237
cmpq 0xf605(%rip), %rax      # 0x1e760
jne 0xf16d
xorl %edi, %edi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
jmp 0xe6db
cmpq 0xf5c4(%rip), %rax      # 0x1e738
jne 0xf193
movl $0x2, (%rcx)
movl $0xc, (%r8)
movq 0xf436(%rip), %rax      # 0x1e5c0
movq (%rax,%rdx,8), %rax
movq (%rsi,%rax,8), %rax
retq
cmpq 0xf5ae(%rip), %rax      # 0x1e748
jne 0xf1a0
xorl %edi, %edi
jmp 0xf1ae
cmpq 0xf5a9(%rip), %rax      # 0x1e750
jne 0xf1bc
movl $0x1, %edi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
jmp 0xefcc
cmpq 0xf5ad(%rip), %rax      # 0x1e770
jne 0xf1d0
movq %rdx, %rdi
movq %rcx, %rsi
jmp 0xed46
cmpq 0xf5b9(%rip), %rax      # 0x1e790
jne 0xf1e3
movl $0x1, %edi
jmp 0xf15f
pushq %rbp
movq %rsp, %rbp
leaq 0x7a2e(%rip), %rdi      # 0x16c1c
callq 0x3ab5
// File: /workspace/github_c_makefile_star2_O1/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
cmpq $-0x1, %rdi
je 0xf247
movq 0xf3da(%rip), %rax      # 0x1e5e8
movq 0xf3ab(%rip), %rcx      # 0x1e5c0
xorl %r8d, %r8d
movq 0xef51(%rip), %rdx      # 0x1e170
movq %rbx, %rsi
movl %r8d, %r15d
movq (%rdx,%rsi,8), %rdi
movq (%rcx,%rdi,8), %rdi
movl -0x8(%rax,%rdi,8), %edi
leal (%r15,%rdi), %r8d
decl %r8d
movq (%rcx,%rsi,8), %rsi
cmpq $-0x1, %rsi
jne 0xf222
addl %edi, %r15d
jmp 0xf24d
movl $0x1, %r15d
movq $-0x21, %rdi
movl %r15d, %esi
callq 0x417e
movq %rax, %r14
movq 0xf35a(%rip), %rax      # 0x1e5c0
movq (%rax,%r14,8), %rdi
shlq $0x3, %rdi
addq 0xf373(%rip), %rdi      # 0x1e5e8
movslq %r15d, %rdx
xorl %esi, %esi
callq 0x30d0
cmpq $-0x1, %rbx
je 0xf300
movq 0xf334(%rip), %rax      # 0x1e5c0
movq (%rax,%r14,8), %r15
shlq $0x3, %r15
addq 0xf34d(%rip), %r15      # 0x1e5e8
xorl %eax, %eax
movq 0xf344(%rip), %rcx      # 0x1e5e8
movq 0xf315(%rip), %rdx      # 0x1e5c0
movq 0xeebe(%rip), %rsi      # 0x1e170
movq (%rsi,%rbx,8), %rsi
movq (%rdx,%rsi,8), %rdx
leaq (%rcx,%rdx,8), %rsi
movslq -0x8(%rsi), %rdx
movslq %eax, %r12
leaq (%r15,%r12), %rdi
callq 0x3130
movq 0xf313(%rip), %rax      # 0x1e5e8
movq 0xf2e4(%rip), %rcx      # 0x1e5c0
movq 0xee8d(%rip), %rdx      # 0x1e170
movq (%rdx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rdx
movq -0x8(%rax,%rdx,8), %rax
addq %r12, %rax
decq %rax
movq (%rcx,%rbx,8), %rbx
cmpq $-0x1, %rbx
jne 0xf29d
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq 0xee4e(%rip), %rax      # 0x1e170
movq (%rax,%rdi,8), %r14
movq 0xf293(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rdi,8), %rcx
movq (%rax,%rcx,8), %rax
cmpq $-0x1, %r14
je 0xf3dc
cmpq $-0x1, %rax
je 0xf40f
movq %rdi, %rbx
movq $-0x1, %rdi
movq $-0x1, %rsi
movl $0x8, %edx
callq 0x36e8
movq %rax, %r14
movq %rax, -0x28(%rbp)
movq 0xedb6(%rip), %rsi      # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0xeda5(%rip)      # 0x1e128
movq 0xede6(%rip), %rax      # 0x1e170
movq (%rax,%rbx,8), %r15
cmpq $-0x1, %r15
je 0xf3e1
movq %r14, %rax
movq %rax, %r12
movq 0xedcf(%rip), %rax      # 0x1e170
movq (%rax,%r15,8), %rcx
movq %rcx, (%rax,%r12,8)
movq $-0x1, %rdi
movq $-0x1, %rsi
movl $0x8, %edx
callq 0x36e8
movq 0xf1f8(%rip), %rcx      # 0x1e5c0
movq %rax, (%rcx,%r12,8)
movq (%rcx,%r15,8), %r15
cmpq $-0x1, %r15
jne 0xf397
leaq (%rcx,%r12,8), %r15
jmp 0xf3e8
movq %rax, %r14
jmp 0xf40f
leaq -0x28(%rbp), %r15
movq %r14, %rax
movq %rax, -0x28(%rbp)
movl $0x1, %edi
callq 0x3851
movq 0xed73(%rip), %rax      # 0x1e170
movq 0xf1bc(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rbx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, (%r15)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xed47(%rip), %rax      # 0x1e170
movq (%rax,%rdi,8), %rdx
movq 0xf18c(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rdi,8), %rcx
movq (%rax,%rcx,8), %rcx
testq %rdx, %rdx
js 0xf452
movq 0xf198(%rip), %rdi      # 0x1e5e0
movzbl (%rdi,%rdx), %edi
testb $0x11, %dil
je 0xf45a
cmpq $-0x1, %rdx
jne 0xf47c
jmp 0xf460
testb $0x8, %dil
je 0xf47c
testq %rcx, %rcx
js 0xf476
movq 0xf174(%rip), %rdi      # 0x1e5e0
movzbl (%rdi,%rcx), %edi
testb $0x11, %dil
je 0xf4c8
cmpq $-0x1, %rcx
je 0xf4ce
testq %rdx, %rdx
js 0xf48e
movq 0xf158(%rip), %rdi      # 0x1e5e0
testb $0x10, (%rdi,%rdx)
jne 0xf4a7
pushq %rbp
movq %rsp, %rbp
leaq 0x77a2(%rip), %rdi      # 0x16c3b
callq 0x33eb
movq $-0x5, %rax
popq %rbp
retq
cmpq $-0x21, (%rax,%rdx,8)
jne 0xf48e
testq %rcx, %rcx
js 0xf48e
testb $0x10, (%rdi,%rcx)
je 0xf48e
cmpq $-0x21, (%rax,%rcx,8)
jne 0xf48e
movq %rsi, %rdi
jmp 0xf1f3
testb $0x8, %dil
je 0xf47c
movq %rsi, %rdi
jmp 0xf30c
// File: /workspace/github_c_makefile_star2_O1/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 0xec89(%rip), %rax      # 0x1e170
movq (%rax,%rdi,8), %rbx
testq %rbx, %rbx
js 0xf57a
movq 0xf0e5(%rip), %rcx      # 0x1e5e0
testb $0x10, (%rcx,%rbx)
je 0xf57a
cmpq $-0x24, (%rax,%rbx,8)
jne 0xf57a
movq %rdi, %r14
movq 0xf0d6(%rip), %rax      # 0x1e5e8
movq 0xf0a7(%rip), %rcx      # 0x1e5c0
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
movq $-0x24, %rdi
movl %r15d, %esi
callq 0x417e
movq %rax, %rbx
movq 0xf098(%rip), %rax      # 0x1e5e8
movq 0xf069(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rbx,8), %rdx
leaq (%rax,%rdx,8), %rdi
movq 0xec0a(%rip), %rdx      # 0x1e170
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_O1/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 0xebd8(%rip), %rax      # 0x1e170
movq (%rax,%rdi,8), %rsi
testq %rsi, %rsi
js 0xf629
movq 0xf034(%rip), %rcx      # 0x1e5e0
testb $0x10, (%rcx,%rsi)
je 0xf5d8
cmpq $-0x21, (%rax,%rsi,8)
jne 0xf5d8
movq 0xf028(%rip), %rax      # 0x1e5e8
movq 0xeff9(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rsi,8), %rcx
movq -0x8(%rax,%rcx,8), %rdi
decq %rdi
jmp 0xf678
testq %rsi, %rsi
js 0xf629
movq 0xeffc(%rip), %rcx      # 0x1e5e0
testb $0x10, (%rcx,%rsi)
je 0xf612
cmpq $-0x24, (%rax,%rsi,8)
jne 0xf612
movq 0xeff0(%rip), %rax      # 0x1e5e8
movq 0xefc1(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rsi,8), %rcx
movq -0x8(%rax,%rcx,8), %rdi
addq $0x7, %rdi
shrq $0x3, %rdi
jmp 0xf678
testq %rsi, %rsi
js 0xf629
movq 0xefc2(%rip), %rax      # 0x1e5e0
movb (%rax,%rsi), %al
andb $0x19, %al
cmpb $0x8, %al
jne 0xf62f
jmp 0xf64d
cmpq $-0x1, %rsi
je 0xf64d
testq %rsi, %rsi
js 0xf641
movq 0xefa5(%rip), %rax      # 0x1e5e0
testb $0x19, (%rax,%rsi)
je 0xf64d
leaq 0x7616(%rip), %rdi      # 0x16c5e
callq 0x33eb
movq 0xeb1c(%rip), %rax      # 0x1e170
movq (%rax,%rbx,8), %rax
cmpq $-0x1, %rax
je 0xf676
movq 0xef5b(%rip), %rcx      # 0x1e5c0
xorl %edi, %edi
movq (%rcx,%rax,8), %rax
incq %rdi
cmpq $-0x1, %rax
jne 0xf667
jmp 0xf678
xorl %edi, %edi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x18, %rdi
movq %rax, %rsi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x36e8
// File: /workspace/github_c_makefile_star2_O1/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 0xeac2(%rip), %rax      # 0x1e170
movq (%rax,%rdi,8), %rax
cmpq $-0x6, %rax
jne 0xf6bc
xorl %edi, %edi
jmp 0xf6d3
testq %rax, %rax
js 0xf6ce
movq 0xef18(%rip), %rcx      # 0x1e5e0
testb $0x19, (%rcx,%rax)
je 0xf6f9
movl $0x1, %edi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x18, %rdi
movq %rax, %rsi
movl $0x1, %edx
popq %rbp
jmp 0x36e8
popq %rbp
jmp 0xf588
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xea5c(%rip), %rax      # 0x1e170
movq (%rax,%rdi,8), %rsi
testq %rsi, %rsi
js 0xf76c
movq 0xeebc(%rip), %rcx      # 0x1e5e0
movb (%rcx,%rsi), %cl
andb $0x19, %cl
cmpb $0x8, %cl
jne 0xf772
movq (%rax,%rdi,8), %r14
movq $-0x1, %rbx
cmpq $-0x1, %r14
je 0xf83e
movq 0xea25(%rip), %rax      # 0x1e170
movq (%rax,%r14,8), %rdi
movq %rbx, %rsi
movl $0x8, %edx
callq 0x36e8
movq %rax, %rbx
movq 0xee5a(%rip), %rax      # 0x1e5c0
movq (%rax,%r14,8), %r14
jmp 0xf73a
cmpq $-0x1, %rsi
je 0xf72f
testq %rsi, %rsi
js 0xf82b
movq 0xee5e(%rip), %rcx      # 0x1e5e0
testb $0x10, (%rcx,%rsi)
je 0xf82b
cmpq $-0x21, (%rax,%rsi,8)
jne 0xf82b
movq 0xee4a(%rip), %r15      # 0x1e5e8
movq 0xee1b(%rip), %rax      # 0x1e5c0
movq (%rax,%rsi,8), %r12
movq -0x8(%r15,%r12,8), %r14
leal -0x1(%r14), %r13d
movq $-0x21, %rdi
movl %r14d, %esi
callq 0x417e
movq %rax, %rbx
movq 0xedf5(%rip), %rax      # 0x1e5c0
movq (%rax,%rbx,8), %rdi
shlq $0x3, %rdi
addq 0xee0e(%rip), %rdi      # 0x1e5e8
movslq %r14d, %rdx
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x30d0
movq 0xedd2(%rip), %rax      # 0x1e5c0
movq (%rax,%rbx,8), %rax
shlq $0x3, %rax
addq 0xedeb(%rip), %rax      # 0x1e5e8
testl %r13d, %r13d
jle 0xf824
movl %r13d, %ecx
leaq (%rcx,%r12,8), %rdx
addq %r15, %rdx
decq %rdx
xorl %r14d, %r14d
movb (%rdx), %sil
movb %sil, (%rax,%r14)
incq %r14
decq %rdx
cmpq %r14, %rcx
jne 0xf812
movb $0x0, (%rax,%r14)
jmp 0xf83e
leaq 0x7452(%rip), %rdi      # 0x16c84
callq 0x33eb
movq $-0x5, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: 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 0xffba
movl %ecx, %ebx
movl %esi, %r12d
movq %rdi, %r13
movq $-0x1, %rdi
movq $-0x1, %rsi
movl %ecx, %edx
callq 0x36e8
movq %rax, %r15
movq 0xe1ff(%rip), %rsi      # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0xe1ee(%rip)      # 0x1e128
movq 0xe22f(%rip), %rax      # 0x1e170
movq (%rax,%r13,8), %r13
testl %r12d, %r12d
je 0xff5a
movq 0xe66f(%rip), %rax      # 0x1e5c0
movq (%rax,%r13,8), %r13
decl %r12d
jne 0xff51
movq 0xe20f(%rip), %rax      # 0x1e170
movq (%rax,%r13,8), %rcx
movq %rcx, (%rax,%r15,8)
cmpl $0x2, %r14d
jl 0xff92
movq $-0x1, %rdi
movq $-0x1, %rsi
movl %ebx, %edx
callq 0x36e8
movq 0xe635(%rip), %rcx      # 0x1e5c0
movq %rax, (%rcx,%r15,8)
movq %rax, %r15
movq 0xe627(%rip), %rax      # 0x1e5c0
movq (%rax,%r13,8), %r13
decl %r14d
jne 0xff5a
movl $0x1, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3851
movq $-0x1, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: 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 0xdf21(%rip), %rax      # 0x1e170
movq 0xe36a(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rdi,8), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x6ab8(%rip), %rdi      # 0x16d1d
callq 0x4341
movq 0xdeff(%rip), %rcx      # 0x1e170
movq (%rcx,%rbx,8), %rsi
testq %rsi, %rsi
js 0x1039d
movq 0xe35b(%rip), %rdx      # 0x1e5e0
testb $0x11, (%rdx,%rsi)
je 0x102ea
testq %rsi, %rsi
js 0x1039d
movq 0xe345(%rip), %rdx      # 0x1e5e0
testb $0x10, (%rdx,%rsi)
je 0x10329
cmpq $-0x24, (%rcx,%rsi,8)
jne 0x10329
movq 0xe30d(%rip), %rdx      # 0x1e5c0
testl %eax, %eax
js 0x103c4
movq (%rdx,%rsi,8), %rsi
movq 0xe322(%rip), %rdi      # 0x1e5e8
movq -0x8(%rdi,%rsi,8), %r8
addq $0x7, %r8
shrq $0x3, %r8
decl %r8d
cmpl %eax, %r8d
jl 0x103c4
leaq (%rdi,%rsi,8), %rcx
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
jmp 0x10320
cmpl $-0x1, %esi
je 0x10314
testl %eax, %eax
je 0x10314
movq 0xe2c6(%rip), %rdx      # 0x1e5c0
decl %eax
movslq %esi, %rsi
movq (%rdx,%rsi,8), %rsi
addl $-0x1, %eax
setb %dil
cmpl $-0x1, %esi
je 0x10314
testb %dil, %dil
jne 0x102fc
cmpl $-0x1, %esi
je 0x103b7
movslq %esi, %rax
movq (%rcx,%rax,8), %rax
jmp 0x103b0
testq %rsi, %rsi
js 0x1039d
movq 0xe2ab(%rip), %rdx      # 0x1e5e0
testb $0x10, (%rdx,%rsi)
je 0x1039d
cmpq $-0x21, (%rcx,%rsi,8)
jne 0x1039d
movq 0xe277(%rip), %rdx      # 0x1e5c0
testl %eax, %eax
js 0x103c4
movq (%rdx,%rsi,8), %rsi
movq 0xe290(%rip), %rdi      # 0x1e5e8
movl -0x8(%rdi,%rsi,8), %r8d
decl %r8d
cmpl %eax, %r8d
jle 0x103c4
leaq (%rdi,%rsi,8), %rcx
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movzbl (%rcx,%rax), %edi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x16, %rdi
movq %rax, %rsi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x36e8
leaq 0x6995(%rip), %rdi      # 0x16d39
callq 0x33eb
movq $-0x5, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0xe202(%rip), %rax      # 0x1e5c0
movq (%rax,%rbx,8), %rax
jmp 0x103c8
movq (%rdx,%rbx,8), %rax
movq (%rcx,%rax,8), %rsi
leaq 0x694e(%rip), %rdi      # 0x16d21
jmp 0x103a4
// File: /workspace/github_c_makefile_star2_O1/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 0xda8f(%rip), %rcx      # 0x1e170
movq 0xded8(%rip), %rax      # 0x1e5c0
movq (%rax,%rdi,8), %r9
movq (%rax,%r9,8), %rdx
movq (%rcx,%rdx,8), %rsi
testq %rsi, %rsi
js 0x10706
movq 0xdee0(%rip), %rdx      # 0x1e5e0
testb $0x19, (%rdx,%rsi)
je 0x10728
leaq 0x66a7(%rip), %rdi      # 0x16db4
callq 0x33eb
movq $-0x5, %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 0x10706
testb $0x10, (%rdx,%r8)
je 0x10706
cmpq $-0x22, (%rcx,%r8,8)
jne 0x10706
movq (%rcx,%rdi,8), %rdi
movq (%rcx,%r9,8), %rbx
movq (%rax,%rsi,8), %rsi
testq %rsi, %rsi
js 0x107e6
movq 0xdf35(%rip), %r9       # 0x1e690
testb $0x19, (%rdx,%rsi)
jne 0x107e6
movq (%rcx,%rsi,8), %r10
testq %r10, %r10
js 0x10781
testb $0x10, (%rdx,%r10)
je 0x10781
cmpq $-0x22, (%rcx,%r10,8)
jne 0x10781
cmpq %rbx, %r10
je 0x10719
cmpq %r9, %r10
jne 0x107ab
testq %rbx, %rbx
js 0x10796
movzbl (%rdx,%rbx), %r11d
testb $0x11, %r11b
je 0x107a1
cmpq $-0x1, %rbx
jne 0x107ab
jmp 0x10719
testb $0x8, %r11b
jne 0x10719
testq %r10, %r10
js 0x107bb
movzbl (%rdx,%r10), %r11d
testb $0x11, %r11b
je 0x107c6
movq (%rax,%rsi,8), %rsi
testq %rsi, %rsi
jns 0x1075b
jmp 0x107e6
testb $0x8, %r11b
jne 0x107bb
testq %rbx, %rbx
js 0x107bb
testb $0x19, (%rdx,%rbx)
jne 0x107bb
movq (%rcx,%r10,8), %r10
cmpq (%rcx,%rbx,8), %r10
jne 0x107bb
jmp 0x10719
movq 0xddfb(%rip), %rcx      # 0x1e5e8
movq (%rax,%rdi,8), %rdx
leaq (%rcx,%rdx,8), %rdx
movq (%rax,%r8,8), %rax
leaq (%rcx,%rax,8), %rcx
leaq 0x65cd(%rip), %rsi      # 0x16dd1
leaq -0x810(%rbp), %r14
movq %r14, %rdi
xorl %eax, %eax
callq 0x31f0
movq %r14, %rdi
movq %rbx, %rsi
jmp 0x1070d
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movq %rdi, %rbx
movq 0xd8f8(%rip), %rdi      # 0x1e128
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0xd8eb(%rip), %rdi      # 0x1e130
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0xd8e2(%rip), %rdi      # 0x1e138
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0xd8a1(%rip), %rdi      # 0x1e108
movq %rax, %rsi
xorl %edx, %edx
callq 0x36e8
movq $-0x25, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rax, %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x36e8
movq 0xd8d3(%rip), %rcx      # 0x1e170
movq (%rcx,%rbx,8), %rdi
movq %rax, %rsi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x36e8
// File: /workspace/github_c_makefile_star2_O1/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 %rdi, %rsi
movq 0xdd01(%rip), %rax      # 0x1e5c0
movq (%rax,%rdi,8), %rcx
cmpq $-0x1, %rcx
je 0x108d9
cmpq $-0x1, (%rax,%rcx,8)
je 0x108ee
leaq 0x61b5(%rip), %rdi      # 0x16a8c
jmp 0x108e0
leaq 0x619a(%rip), %rdi      # 0x16a7a
callq 0x33eb
movq $-0x5, %rax
jmp 0x10949
movq 0xd87b(%rip), %rcx      # 0x1e170
movq (%rcx,%rsi,8), %rdx
movq (%rax,%rdx,8), %rdx
movq (%rcx,%rdx,8), %rdi
movq %rdi, 0xd800(%rip)      # 0x1e108
movq (%rax,%rdx,8), %rdi
movq (%rcx,%rdi,8), %rdi
movq %rdi, 0xd821(%rip)      # 0x1e138
movq (%rax,%rdx,8), %rdi
movq (%rax,%rdi,8), %rdi
movq (%rcx,%rdi,8), %rdi
movq %rdi, 0xd806(%rip)      # 0x1e130
movq (%rax,%rdx,8), %rdx
movq (%rax,%rdx,8), %rdx
movq (%rax,%rdx,8), %rdx
movq (%rcx,%rdx,8), %rdx
movq %rdx, 0xd7e7(%rip)      # 0x1e128
movq (%rax,%rsi,8), %rax
movq (%rcx,%rax,8), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd81a(%rip), %rcx      # 0x1e170
movq (%rcx,%rdi,8), %rax
movq 0xdc5f(%rip), %rdx      # 0x1e5c0
movq (%rdx,%rdi,8), %rdx
movq (%rcx,%rdx,8), %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq 0xd7ee(%rip), %rsi      # 0x1e168
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0xd7dd(%rip)      # 0x1e168
movq $-0x6, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd7cd(%rip), %rax      # 0x1e168
cmpq $-0x1, %rax
je 0x109bf
movq 0xdc18(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rax,8), %rax
movq %rax, 0xd7b5(%rip)      # 0x1e168
movq 0xd7b6(%rip), %rax      # 0x1e170
movq (%rax,%rdi,8), %rax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x641c(%rip), %rdi      # 0x16de6
movq $-0x8, %rsi
callq 0x33eb
movq $-0x5, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, %eax
cmpq %rsi, %rdi
je 0x10ac8
testq %rdi, %rdi
js 0x10ac6
movq 0xdbdf(%rip), %rcx      # 0x1e5e0
movb (%rcx,%rdi), %dl
testb $0x1, %dl
je 0x10ac6
testq %rsi, %rsi
js 0x10a58
movq 0xd757(%rip), %rax      # 0x1e170
cmpq $-0x16, (%rax,%rdi,8)
jne 0x10a58
testb $0x1, (%rcx,%rsi)
je 0x10a58
cmpq $-0x16, (%rax,%rsi,8)
jne 0x10a58
movq 0xdb8c(%rip), %r9       # 0x1e5c0
movq (%r9,%rdi,8), %r8
movq (%rax,%r8,8), %r8
movq (%r9,%rsi,8), %r9
movq (%rax,%r9,8), %r9
xorl %eax, %eax
cmpq %r9, %r8
sete %al
testb $0x1, %dl
je 0x10ac8
cmpq %r9, %r8
jne 0x10a5d
jmp 0x10ac8
testb $0x1, %dl
je 0x10ac6
movq 0xd70c(%rip), %rdx      # 0x1e170
movq (%rdx,%rdi,8), %rax
cmpq $-0x1f, %rax
jne 0x10a75
testq %rsi, %rsi
jns 0x10a89
jmp 0x10ac6
cmpq $-0x18, %rax
setne %r8b
testq %rsi, %rsi
sets %r9b
orb %r8b, %r9b
jne 0x10ac6
testb $0x1, (%rcx,%rsi)
je 0x10ac6
movq (%rdx,%rsi,8), %rcx
cmpq $-0x18, %rcx
je 0x10a9f
cmpq $-0x1f, %rcx
jne 0x10ac6
cmpq $-0x1f, %rax
sete %dl
testq %rsi, %rsi
sets %al
cmpq $-0x1f, %rcx
setne %cl
orb %al, %cl
movl $0x0, %eax
cmpb %cl, %dl
je 0x10ac8
xorl %edx, %edx
popq %rbp
jmp 0x60c9
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl $0xfffffffd, %r14d      # imm = 0xFFFFFFFD
cmpq $-0x1, %rcx
je 0x10ba6
movq %rcx, %rbx
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, %r15
movq 0xd657(%rip), %rcx      # 0x1e170
movq (%rcx,%rbx,8), %rax
testq %rax, %rax
js 0x10b36
movq 0xdab7(%rip), %rdx      # 0x1e5e0
movb (%rdx,%rax), %dl
andb $0x19, %dl
cmpb $0x8, %dl
je 0x10b3c
jmp 0x10b6b
cmpq $-0x1, %rax
jne 0x10b6b
movq (%rcx,%rax,8), %rsi
testl %r13d, %r13d
je 0x10b53
movq %r12, %rdi
callq 0x109df
testl %eax, %eax
je 0x10b58
jmp 0x10b96
cmpq %r12, %rsi
je 0x10ba3
movq 0xda61(%rip), %rax      # 0x1e5c0
movq (%rax,%rbx,8), %rbx
cmpq $-0x1, %rbx
jne 0x10b12
jmp 0x10ba6
leaq 0x629b(%rip), %rsi      # 0x16e0d
leaq -0x70(%rbp), %r14
movq %r14, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x31f0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x33eb
movl $0xfffffffb, %r14d      # imm = 0xFFFFFFFB
jmp 0x10ba6
movq 0xd5d3(%rip), %rax      # 0x1e170
movl (%rax,%rbx,8), %r14d
jmp 0x10ba6
movl %eax, %r14d
movl %r14d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: limit
cell limit(char *msg, int(*pred)(cell,cell), cell x) {
	cell	k;

	if (pred(car(x), cadr(x)))
		k = car(x);
	else
		k = cadr(x);
	if (!real_p(car(x)) && !real_p(cadr(x)))
		return k;
	if (integer_p(k))
		return bignum_to_real(k);
	return k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %rax
movq 0xd537(%rip), %rcx      # 0x1e170
movq (%rcx,%rdx,8), %rdi
movq 0xd97c(%rip), %rdx      # 0x1e5c0
movq (%rdx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rsi
callq *%rax
movq 0xd51b(%rip), %rcx      # 0x1e170
movq %rbx, %rdx
testl %eax, %eax
jne 0x10c67
movq 0xd95d(%rip), %rax      # 0x1e5c0
movq (%rax,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rax
movq 0xd4fe(%rip), %rcx      # 0x1e170
movq (%rcx,%rbx,8), %rdx
testq %rdx, %rdx
js 0x10c8f
movq 0xd95e(%rip), %rsi      # 0x1e5e0
testb $0x1, (%rsi,%rdx)
je 0x10c8f
cmpq $-0x1f, (%rcx,%rdx,8)
je 0x10cb7
movq 0xd92a(%rip), %rdx      # 0x1e5c0
movq (%rdx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rdx
testq %rdx, %rdx
js 0x10cde
movq 0xd936(%rip), %rsi      # 0x1e5e0
testb $0x1, (%rsi,%rdx)
je 0x10cde
cmpq $-0x1f, (%rcx,%rdx,8)
jne 0x10cde
testq %rax, %rax
js 0x10cde
movq 0xd91d(%rip), %rdx      # 0x1e5e0
testb $0x1, (%rdx,%rax)
je 0x10cde
cmpq $-0x18, (%rcx,%rax,8)
jne 0x10cde
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5b51
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: pp_floor
cell pp_floor(cell x) {
	cell	n, m, e;

	x = car(x);
	if (integer_p(x))
		return x;
	e = x_real_exponent(x);
	if (e >= 0)
		return real_to_bignum(x);
	m = new_atom(T_INTEGER, x_real_mantissa(x));
	save(m);
	while (e < 0) {
		m = bignum_shift_right(m);
		m = car(m);
		car(Stack) = m;
		e++;
	}
	if (x_real_negative_p(x)) {
		/* sign not in mantissa! */
		m = bignum_add(m, make_integer(1));
	}
	unsave(1);
	n = make_real(x_real_flags(x), e, cdr(m));
	return real_to_bignum(n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0xd47a(%rip), %rax      # 0x1e170
movq (%rax,%rdi,8), %rbx
testq %rbx, %rbx
js 0x10d21
movq 0xd8da(%rip), %rcx      # 0x1e5e0
testb $0x1, (%rcx,%rbx)
je 0x10d21
cmpq $-0x18, (%rax,%rbx,8)
jne 0x10d21
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xd898(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rdx
movq (%rax,%rdx,8), %r15
testq %r15, %r15
jns 0x10e23
movq (%rcx,%rdx,8), %rsi
movq $-0x18, %rdi
movl $0x1, %edx
callq 0x36e8
movq %rax, %r14
movq 0xd3cc(%rip), %rsi      # 0x1e128
movq %rax, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0xd3bb(%rip)      # 0x1e128
movq %r14, %rdi
callq 0x4dd6
movq 0xd3f4(%rip), %rcx      # 0x1e170
movq (%rcx,%rax,8), %r14
movq 0xd3a1(%rip), %rax      # 0x1e128
movq %r14, (%rcx,%rax,8)
incq %r15
jne 0x10d6d
movq 0xd3d9(%rip), %rcx      # 0x1e170
movq 0xd822(%rip), %rax      # 0x1e5c0
movq (%rax,%rbx,8), %rdx
testb $0x1, (%rcx,%rdx,8)
je 0x10df6
movq (%rax,%rdx,8), %rdx
movq (%rax,%rdx,8), %rdx
cmpq $0x0, (%rcx,%rdx,8)
jne 0x10dbe
cmpq $-0x1, (%rax,%rdx,8)
je 0x10df6
movl $0x1, %edi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x18, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x36e8
movq %r14, %rdi
movq %rax, %rsi
callq 0x473d
movq %rax, %r14
movl $0x1, %edi
callq 0x3851
movq 0xd369(%rip), %rax      # 0x1e170
movq 0xd7b2(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rbx,8), %rdx
movl (%rax,%rdx,8), %edi
movq (%rcx,%r14,8), %rdx
xorl %esi, %esi
callq 0x5778
movq %rax, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x70f8
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: pp_real_mant
cell pp_real_mant(cell x) {
	cell	m;

	if (integer_p(car(x)))
		return car(x);
	m = new_atom(T_INTEGER, x_real_mantissa(car(x)));
	if (x_real_negative_p(car(x)))
		m = bignum_negate(m);
	return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xd1d1(%rip), %rcx      # 0x1e170
movq (%rcx,%rdi,8), %rax
testq %rax, %rax
js 0x10fbc
movq 0xd631(%rip), %rdx      # 0x1e5e0
testb $0x1, (%rdx,%rax)
je 0x10fbc
cmpq $-0x18, (%rcx,%rax,8)
je 0x10ffc
movq 0xd5fd(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rax,8), %rax
movq (%rcx,%rax,8), %rax
movq (%rcx,%rax,8), %rsi
movq $-0x18, %rdi
movl $0x1, %edx
callq 0x36e8
movq 0xd189(%rip), %rdx      # 0x1e170
movq 0xd5d2(%rip), %rcx      # 0x1e5c0
movq (%rdx,%rbx,8), %rsi
movq (%rcx,%rsi,8), %rsi
testb $0x1, (%rdx,%rsi,8)
jne 0x11003
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq (%rcx,%rsi,8), %rsi
movq (%rcx,%rsi,8), %rsi
cmpq $0x0, (%rdx,%rsi,8)
jne 0x11019
cmpq $-0x1, (%rcx,%rsi,8)
je 0x10ffc
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x43eb
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: pp_chr
cell pp_chr(cell x) {
	cell	n;

	n = integer_value("chr", car(x));
	if (n < 0 || n > 255)
		return error("chr: argument value out of range", car(x));
	return make_char(n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xd031(%rip), %rax      # 0x1e170
movq (%rax,%rdi,8), %rsi
leaq 0x5cdc(%rip), %rdi      # 0x16e26
callq 0x4341
cmpq $0x100, %rax            # imm = 0x100
jb 0x1117c
movq 0xd012(%rip), %rax      # 0x1e170
movq (%rax,%rbx,8), %rsi
leaq 0x5cc1(%rip), %rdi      # 0x16e2a
callq 0x33eb
movq $-0x5, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rdi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x16, %rdi
movq %rax, %rsi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x36e8
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: implode
cell implode(char *who, cell x) {
	cell	n;
	int	k = length(x);
	char	*s;
	char	buf[100];

	n = make_string("", k);
	s = string(n);
	while (x != NIL) {
		if (!char_p(car(x))) {
			sprintf(buf, "%s: expected list of char,"
					" got list containing",
				who);
			return error(buf, car(x));
		}
		*s++ = cadar(x);
		x = cdr(x);
	}
	*s = 0;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %r12d
cmpq $-0x1, %rsi
je 0x11207
movq 0xd3c9(%rip), %rax      # 0x1e5c0
movq %rbx, %rcx
movq (%rax,%rcx,8), %rcx
incl %r12d
cmpq $-0x1, %rcx
jne 0x111fa
movq $-0x21, %rdi
movl %r12d, %esi
callq 0x417e
movq %rax, %r15
movq 0xd3a0(%rip), %rax      # 0x1e5c0
movq (%rax,%r15,8), %rdi
shlq $0x3, %rdi
addq 0xd3b9(%rip), %rdi      # 0x1e5e8
movslq %r12d, %rdx
xorl %esi, %esi
callq 0x30d0
movq 0xd380(%rip), %rax      # 0x1e5c0
movq (%rax,%r15,8), %rax
shlq $0x3, %rax
addq 0xd399(%rip), %rax      # 0x1e5e8
cmpq $-0x1, %rbx
je 0x11299
movq 0xcf14(%rip), %rcx      # 0x1e170
movq (%rcx,%rbx,8), %rdx
testq %rdx, %rdx
js 0x1129e
movq 0xd374(%rip), %rsi      # 0x1e5e0
testb $0x1, (%rsi,%rdx)
je 0x1129e
cmpq $-0x16, (%rcx,%rdx,8)
jne 0x1129e
movq 0xd340(%rip), %rsi      # 0x1e5c0
movq (%rsi,%rdx,8), %rdx
movb (%rcx,%rdx,8), %cl
movb %cl, (%rax)
incq %rax
movq 0xd32d(%rip), %rcx      # 0x1e5c0
movq (%rcx,%rbx,8), %rbx
jmp 0x1124f
movb $0x0, (%rax)
jmp 0x112d3
leaq 0x5ba6(%rip), %rsi      # 0x16e4b
leaq -0x90(%rbp), %r15
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x31f0
movq 0xceb0(%rip), %rax      # 0x1e170
movq (%rax,%rbx,8), %rsi
movq %r15, %rdi
callq 0x33eb
movq $-0x5, %r15
movq %r15, %rax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: pp_explode
cell pp_explode(cell x) {
	char	*s;
	cell	n, a, new;
	int	k, i;

	k = string_len(car(x));
	n = NIL;
	a = NIL;
	for (i=0; i<k-1; i++) {
		s = string(car(x));
		if (n == NIL) {
			n = a = cons(make_char(s[i]), NIL);
			save(n);
		}
		else {
			set(cdr(a), cons(make_char(s[i]), NIL));
			a = cdr(a);
		}
	}
	if (n != NIL)
		unsave(1);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xd2d4(%rip), %rax      # 0x1e5e8
movq 0xd2a5(%rip), %rcx      # 0x1e5c0
movq 0xce4e(%rip), %rdx      # 0x1e170
movq %rdi, -0x30(%rbp)
movq (%rdx,%rdi,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq -0x8(%rax,%rcx,8), %r12
movq $-0x1, %r14
cmpl $0x2, %r12d
jl 0x113f5
decl %r12d
xorl %r13d, %r13d
movq $-0x1, %rbx
movq 0xd268(%rip), %rax      # 0x1e5c0
movq 0xce11(%rip), %rcx      # 0x1e170
movq -0x30(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
shlq $0x3, %rax
addq 0xd272(%rip), %rax      # 0x1e5e8
movzbl (%r13,%rax), %edi
movq $-0x1, %rsi
movl $0x1, %edx
callq 0x36e8
movq $-0x16, %rdi
movq %rax, %rsi
movl $0x1, %edx
callq 0x36e8
movq %rax, %rdi
movq $-0x1, %rsi
movl $0x8, %edx
callq 0x36e8
movq %rax, %r15
cmpq $-0x1, %r14
je 0x113cb
movq 0xd1fb(%rip), %rax      # 0x1e5c0
movq %r15, (%rax,%rbx,8)
jmp 0x113e6
movq 0xcd56(%rip), %rsi      # 0x1e128
movq %r15, %rdi
xorl %edx, %edx
callq 0x36e8
movq %rax, 0xcd45(%rip)      # 0x1e128
movq %r15, %r14
incq %r13
movq %r15, %rbx
cmpq %r13, %r12
jne 0x11351
cmpq $-0x1, %r14
je 0x11405
movl $0x1, %edi
callq 0x3851
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: pp_newstr
cell pp_newstr(cell x) {
	cell	n;
	int	k;
	char	*s;

	k = integer_value("string", car(x));
	if (k < 0)
		return error("string: got negative length", x);
	n = make_string("", k);
	s = string(n);
	memset(s, char_value(cadr(x)), k);
	s[k] = 0;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0xcae0(%rip), %rax      # 0x1e170
movq (%rax,%rdi,8), %rsi
leaq 0x4e19(%rip), %rdi      # 0x164b4
callq 0x4341
movq %rax, %rbx
testl %ebx, %ebx
js 0x11721
leal 0x1(%rbx), %r12d
movq $-0x21, %rdi
movl %r12d, %esi
callq 0x417e
movq %rax, %r15
movq 0xcefc(%rip), %rax      # 0x1e5c0
movq (%rax,%r15,8), %rdi
shlq $0x3, %rdi
addq 0xcf15(%rip), %rdi      # 0x1e5e8
xorl %esi, %esi
movq %r12, %rdx
callq 0x30d0
movq 0xcedc(%rip), %rax      # 0x1e5c0
movq (%rax,%r15,8), %r12
shlq $0x3, %r12
addq 0xcef5(%rip), %r12      # 0x1e5e8
movq 0xca76(%rip), %rcx      # 0x1e170
movq (%rax,%r14,8), %rdx
movq (%rcx,%rdx,8), %rdx
movq (%rax,%rdx,8), %rax
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
movl (%rcx,%rax,8), %esi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x30d0
movb $0x0, (%rbx,%r12)
jmp 0x11737
leaq 0x575a(%rip), %rdi      # 0x16e82
movq %r14, %rsi
callq 0x33eb
movq $-0x5, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/azhai[P]mlite/mlite.c
// Function: pp_newvec
cell pp_newvec(cell x) {
	int	i, k;
	cell	n, *v, m;

	k = integer_value("newvec", car(x));
	if (k < 0)
		return error("newvec: got negative length", car(x));
	n = new_vec(T_VECTOR, k * sizeof(cell));
	v = vector(n);
	m = cadr(x);
	for (i=0; i<k; i++)
		v[i] = m;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0xca1c(%rip), %rax      # 0x1e170
movq (%rax,%rdi,8), %rsi
leaq 0x573f(%rip), %rdi      # 0x16e9e
callq 0x4341
movq %rax, %rbx
testl %ebx, %ebx
js 0x117bd
leal (,%rbx,8), %esi
movq $-0x24, %rdi
callq 0x417e
testl %ebx, %ebx
je 0x117db
movq 0xce37(%rip), %rdx      # 0x1e5c0
movq (%rdx,%rax,8), %rcx
shlq $0x3, %rcx
addq 0xce50(%rip), %rcx      # 0x1e5e8
movq 0xc9d1(%rip), %rsi      # 0x1e170
movq (%rdx,%r14,8), %rdx
movq (%rsi,%rdx,8), %rdx
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
xorl %esi, %esi
movq %rdx, (%rcx,%rsi,8)
incq %rsi
cmpq %rsi, %rbx
jne 0x117af
jmp 0x117db
movq 0xc9ac(%rip), %rax      # 0x1e170
movq (%rax,%r14,8), %rsi
leaq 0x56d6(%rip), %rdi      # 0x16ea5
callq 0x33eb
movq $-0x5, %rax
popq %rbx
popq %r14
popq %rbp
retq