LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: error
cell error(char *msg, cell expr) {
	int	os;
	char	buf[100];

	if (Error_flag)
		return UNDEFINED;
	os = Outstream;
	Outstream = Quiet_mode? 2: 1;
	Error_flag = 1;
	pr("error: ");
	if (box_value(S_loading) == TRUE) {
		if (File_list != NIL) {
			print_form(car(File_list));
			pr(": ");
		}
		sprintf(buf, "%d: ", Line_no);
		pr(buf);
	}
	pr(msg);
	if (expr != NOEXPR) {
		pr(": ");
		Error_flag = 0;
		print_error_form(expr);
		Error_flag = 1;
	}
	nl();
	print_calltrace();
	Outstream = os;
	if (Quiet_mode)
		bye(1);
	return UNDEFINED;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
cmpl $0x0, 0x191ba(%rip)     # 0x1c5b4
jne 0x34f1
movq %rsi, %rbx
movq %rdi, %r14
movl 0x18e73(%rip), %r12d    # 0x1c280
cmpl $0x1, 0x191a4(%rip)     # 0x1c5b8
pushq $0x2
popq %rax
sbbl $0x0, %eax
movl %eax, 0x18e60(%rip)     # 0x1c280
movl $0x1, 0x1918a(%rip)     # 0x1c5b4
leaq 0x10db5(%rip), %rdi     # 0x141e6
callq 0x3873
movq 0x19183(%rip), %rax     # 0x1c5c0
movq 0x19184(%rip), %rcx     # 0x1c5c8
cmpq $-0x2, (%rax,%rcx,8)
jne 0x349a
movq 0x18cf6(%rip), %rax     # 0x1c148
cmpq $-0x1, %rax
je 0x3474
movq 0x18d11(%rip), %rcx     # 0x1c170
movq (%rcx,%rax,8), %rdi
callq 0x38e1
leaq 0x111cb(%rip), %rdi     # 0x1463a
callq 0x3873
movl 0x19156(%rip), %edx     # 0x1c5d0
leaq 0x10d6d(%rip), %rsi     # 0x141ee
leaq -0x90(%rbp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x31f0
movq %r15, %rdi
callq 0x3873
movq %r14, %rdi
callq 0x3873
cmpq $-0x8, %rbx
je 0x34d0
leaq 0x1118b(%rip), %rdi     # 0x1463a
callq 0x3873
movl $0x0, 0x190f6(%rip)     # 0x1c5b4
movq %rbx, %rdi
callq 0x38be
movl $0x1, 0x190e4(%rip)     # 0x1c5b4
leaq 0x12400(%rip), %rdi     # 0x158d7
callq 0x3873
callq 0x38ed
movl %r12d, 0x18d98(%rip)    # 0x1c280
cmpl $0x0, 0x190c9(%rip)     # 0x1c5b8
jne 0x3501
pushq $-0x5
popq %rax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rdi
callq 0x3200
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: counter_to_list
cell counter_to_list(struct counter *c) {
	cell	n, m;

	n = make_integer(c->n);
	n = node(n, NIL);
	save(n);
	m = make_integer(c->n1k);
	n = node(m, n);
	car(Stack) = n;
	m = make_integer(c->n1m);
	n = node(m, n);
	car(Stack) = n;
	m = make_integer(c->n1g);
	n = node(m, n);
	car(Stack) = n;
	m = make_integer(c->n1t);
	n = node(m, n);
	unsave(1);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq (%rdi), %rdi
callq 0x35ed
pushq $-0x1
popq %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, %r14
movq 0x18bf6(%rip), %rsi     # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x18be5(%rip)     # 0x1c128
movslq 0x4(%rbx), %rdi
callq 0x35ed
movq %rax, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %r14
movq 0x18c0d(%rip), %rax     # 0x1c170
movq 0x18bbe(%rip), %rcx     # 0x1c128
movq %r14, (%rax,%rcx,8)
movslq 0x8(%rbx), %rdi
callq 0x35ed
movq %rax, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %r14
movq 0x18be2(%rip), %rax     # 0x1c170
movq 0x18b93(%rip), %rcx     # 0x1c128
movq %r14, (%rax,%rcx,8)
movslq 0xc(%rbx), %rdi
callq 0x35ed
movq %rax, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %r14
movq 0x18bb7(%rip), %rax     # 0x1c170
movq 0x18b68(%rip), %rcx     # 0x1c128
movq %r14, (%rax,%rcx,8)
movslq 0x10(%rbx), %rdi
callq 0x35ed
movq %rax, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, %rbx
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: node3
cell node3(cell pcar, cell pcdr, int ptag) {
	cell	n;
	int	k;
	char	buf[100];

	if (Run_stats) {
		count(&Nodes);
		if (Cons_stats)
			count(&Conses);
	}
	if (Free_list == NIL) {
		if (ptag == 0)
			Tmp_car = pcar;
		if (ptag != VECTOR_TAG && ptag != STREAM_TAG)
			Tmp_cdr = pcdr;
		k = gc();
		/*
		 * Performance increases dramatically if we
		 * do not wait for the pool to run dry.
		 * In fact, don't even let it come close to that.
		 */
		if (k < Cons_pool_size / 2) {
			if (	Memory_limit_kn &&
				Cons_pool_size + Cons_segment_size
					> Memory_limit_kn
			) {
				error("hit memory limit", NOEXPR);
			}
			else {
				new_cons_segment();
				if (Verbose_GC) {
					sprintf(buf,
						"GC: new segment,"
						 " nodes = %d,"
						 " next segment = %d",
						Cons_pool_size,
						Cons_segment_size);
					pr(buf); nl();
				}
				gc();
			}
		}
		Tmp_car = Tmp_cdr = NIL;
	}
	if (Free_list == NIL)
		fatal("cons3: failed to recover from low memory condition");
	n = Free_list;
	Free_list = cdr(Free_list);
	car(n) = pcar;
	cdr(n) = pcdr;
	Tag[n] = ptag;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x0, 0x18fef(%rip)     # 0x1c620
je 0x3654
leaq 0x19006(%rip), %rdi     # 0x1c640
callq 0x334c
cmpl $0x0, 0x1900e(%rip)     # 0x1c654
je 0x3654
leaq 0x19009(%rip), %rdi     # 0x1c658
callq 0x334c
movq 0x18fdd(%rip), %rax     # 0x1c638
cmpq $-0x1, %rax
jne 0x3731
cmpl $0x20, %ebx
je 0x3681
cmpl $0x10, %ebx
je 0x3681
testl %ebx, %ebx
jne 0x367a
movq %r15, 0x18a9e(%rip)     # 0x1c118
movq %r14, 0x18a9f(%rip)     # 0x1c120
callq 0x3dd2
movl %eax, %esi
movslq 0x18f45(%rip), %rcx     # 0x1c5d4
pushq $0x2
popq %rdi
movl %ecx, %eax
cltd
idivl %edi
cmpl %eax, %esi
jge 0x3712
movq 0x18fce(%rip), %rax     # 0x1c670
testq %rax, %rax
je 0x36c7
movslq 0x18f2a(%rip), %rdx     # 0x1c5d8
addq %rcx, %rdx
cmpq %rdx, %rax
jge 0x36c7
leaq 0x10b7d(%rip), %rdi     # 0x1423a
pushq $-0x8
popq %rsi
callq 0x33e4
jmp 0x3712
callq 0x3a00
cmpl $0x0, 0x18a1d(%rip)     # 0x1c0f0
je 0x370d
movl 0x18ef9(%rip), %edx     # 0x1c5d4
movl 0x18ef7(%rip), %ecx     # 0x1c5d8
leaq 0x10b63(%rip), %rsi     # 0x1424b
leaq -0x90(%rbp), %r12
movq %r12, %rdi
xorl %eax, %eax
callq 0x31f0
movq %r12, %rdi
callq 0x3873
leaq 0x121cf(%rip), %rdi     # 0x158d7
callq 0x3873
callq 0x3dd2
orq $-0x1, 0x18a06(%rip)    # 0x1c120
orq $-0x1, 0x189f6(%rip)    # 0x1c118
movq 0x18f0f(%rip), %rax     # 0x1c638
pushq $-0x1
popq %rcx
cmpq %rcx, %rax
je 0x3769
movq 0x18e88(%rip), %rcx     # 0x1c5c0
movq (%rcx,%rax,8), %rdx
movq %rdx, 0x18ef5(%rip)     # 0x1c638
movq 0x18a26(%rip), %rdx     # 0x1c170
movq %r15, (%rdx,%rax,8)
movq %r14, (%rcx,%rax,8)
movq 0x18e87(%rip), %rcx     # 0x1c5e0
movb %bl, (%rcx,%rax)
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10b0a(%rip), %rdi     # 0x1427a
callq 0x39b6
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: unsave
cell unsave(int k) {
	cell	n = NIL; /*LINT*/

	while (k) {
		if (Stack == NIL)
			fatal("unsave: stack underflow");
		n = car(Stack);
		Stack = cdr(Stack);
		k--;
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x189a8(%rip), %rcx     # 0x1c128
movq 0x189e9(%rip), %rdx     # 0x1c170
pushq $-0x1
popq %rax
movq 0x18e2f(%rip), %rsi     # 0x1c5c0
subl $0x1, %edi
jb 0x37ad
cmpq $-0x1, %rcx
je 0x37af
movq (%rdx,%rcx,8), %rax
movq (%rsi,%rcx,8), %rcx
movq %rcx, 0x1897d(%rip)     # 0x1c128
jmp 0x3791
popq %rbp
retq
leaq 0x10b6d(%rip), %rdi     # 0x14323
callq 0x39b6
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: pr_raw
void pr_raw(char *s, int k) {
	if (Printer_limit && Printer_count > Printer_limit) {
		if (Printer_limit > 0)
			fwrite("...", 1, 3, Streams[Outstream]);
		Printer_limit = -1;
		return;
	}
	fwrite(s, 1, k, Streams[Outstream]);
	if (Outstream == 1 && s[k-1] == '\n')
		flush();
	Printer_count += k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x18a98(%rip), %eax     # 0x1c284
testl %eax, %eax
je 0x3829
cmpl %eax, 0x18a92(%rip)     # 0x1c288
jle 0x3829
testl %eax, %eax
jle 0x3820
movslq 0x18a7d(%rip), %rax     # 0x1c280
leaq 0x18976(%rip), %rcx     # 0x1c180
movq (%rcx,%rax,8), %rcx
leaq 0x109ab(%rip), %rdi     # 0x141c0
pushq $0x1
popq %rsi
pushq $0x3
popq %rdx
callq 0x3210
orl $-0x1, 0x18a5d(%rip)    # 0x1c284
jmp 0x3868
movslq %ebx, %r15
movslq 0x18a4d(%rip), %rax     # 0x1c280
leaq 0x18946(%rip), %rcx     # 0x1c180
movq (%rcx,%rax,8), %rcx
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x3210
cmpl $0x1, 0x18a2d(%rip)     # 0x1c280
jne 0x3862
cmpb $0xa, -0x1(%r14,%r15)
jne 0x3862
callq 0x37bb
addl %ebx, 0x18a20(%rip)     # 0x1c288
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: pr
void pr(char *s) {
	if (Streams[Outstream] == NULL)
		error("outstream is not open", NOEXPR);
	else
		pr_raw(s, strlen(s));
}

// Assembly:
movslq 0x18a06(%rip), %rax     # 0x1c280
leaq 0x188ff(%rip), %rcx     # 0x1c180
cmpq $0x0, (%rcx,%rax,8)
je 0x38a6
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x30a0
movq %rbx, %rdi
movl %eax, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x37d7
leaq 0x10917(%rip), %rdi     # 0x141c4
pushq $-0x8
popq %rsi
jmp 0x33e4
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: print_error_form
void print_error_form(cell n) {
	Printer_limit = 50;
	Printer_count = 0;
	print_form(n);
	Printer_limit = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x32, 0x189b8(%rip)    # 0x1c284
andl $0x0, 0x189b5(%rip)     # 0x1c288
callq 0x38e1
andl $0x0, 0x189a5(%rip)     # 0x1c284
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: print_calltrace
void print_calltrace(void) {
	int	i, j;

	for (i=0; i<Proc_max; i++)
		if (Called_procedures[i] != NIL)
			break;
	if (i == Proc_max)
		return;
	pr("call trace:");
	i = Proc_ptr;
	for (j=0; j<Proc_max; j++) {
		if (i >= Proc_max)
			i = 0;
		if (Called_procedures[i] != NIL) {
			pr(" ");
			print_form(Called_procedures[i]);
		}
		i++;
	}
	nl();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x1898b(%rip), %eax     # 0x1c28c
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %ecx
cmovgl %eax, %ecx
leaq 0x1897c(%rip), %rsi     # 0x1c290
cmpq %rdx, %rcx
je 0x392a
cmpq $-0x1, (%rsi)
jne 0x3928
incq %rdx
addq $0x8, %rsi
jmp 0x3914
movl %edx, %ecx
cmpl %eax, %ecx
jne 0x393d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10896(%rip), %rdi     # 0x141da
callq 0x3873
movl 0x18c60(%rip), %r14d    # 0x1c5b0
xorl %r15d, %r15d
movl 0x18933(%rip), %eax     # 0x1c28c
leaq 0x18930(%rip), %r12     # 0x1c290
xorl %r13d, %r13d
cmpl %eax, %r13d
jge 0x399c
cmpl %eax, %r14d
cmovgel %r15d, %r14d
movslq %r14d, %rbx
cmpq $-0x1, (%r12,%rbx,8)
je 0x3994
leaq 0x11e98(%rip), %rdi     # 0x15818
callq 0x3873
movq (%r12,%rbx,8), %rdi
callq 0x38e1
movl 0x188f8(%rip), %eax     # 0x1c28c
incl %r14d
incl %r13d
jmp 0x3963
leaq 0x11f34(%rip), %rdi     # 0x158d7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3873
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: fatal
void fatal(char *msg) {
	Outstream = Quiet_mode? 2: 1;
	pr("fatal ");
	Error_flag = 0;
	error(msg, NOEXPR);
	bye(2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x1, 0x18bf1(%rip)     # 0x1c5b8
pushq $0x2
popq %r14
movl %r14d, %eax
sbbl $0x0, %eax
movl %eax, 0x188a9(%rip)     # 0x1c280
leaq 0x10815(%rip), %rdi     # 0x141f3
callq 0x3873
movl $0x0, 0x18bc7(%rip)     # 0x1c5b4
pushq $-0x8
popq %rsi
movq %rbx, %rdi
callq 0x33e4
movl %r14d, %edi
callq 0x3200
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: new_cons_segment
void new_cons_segment(void) {
	Car = realloc(Car, sizeof(cell) * (Cons_pool_size+Cons_segment_size));
	Cdr = realloc(Cdr, sizeof(cell) * (Cons_pool_size+Cons_segment_size));
	Tag = realloc(Tag, Cons_pool_size + Cons_segment_size);
	if (Car == NULL || Cdr == NULL || Tag == NULL)
		fatal("new_cons_segment: out of physical memory");
	memset(&car(Cons_pool_size), 0, Cons_segment_size * sizeof(cell));
	memset(&cdr(Cons_pool_size), 0, Cons_segment_size * sizeof(cell));
	memset(&Tag[Cons_pool_size], 0, Cons_segment_size);
	Cons_pool_size += Cons_segment_size;
	Cons_segment_size = Cons_segment_size * 3 / 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x18765(%rip), %rdi     # 0x1c170
movslq 0x18bc2(%rip), %rax     # 0x1c5d4
movslq 0x18bbf(%rip), %rsi     # 0x1c5d8
addq %rax, %rsi
shlq $0x3, %rsi
callq 0x3190
movq %rax, 0x18744(%rip)     # 0x1c170
movq 0x18b8d(%rip), %rdi     # 0x1c5c0
movslq 0x18b9a(%rip), %rax     # 0x1c5d4
movslq 0x18b97(%rip), %rsi     # 0x1c5d8
addq %rax, %rsi
shlq $0x3, %rsi
callq 0x3190
movq %rax, 0x18b6c(%rip)     # 0x1c5c0
movq 0x18b85(%rip), %rdi     # 0x1c5e0
movslq 0x18b72(%rip), %rax     # 0x1c5d4
movslq 0x18b6f(%rip), %rsi     # 0x1c5d8
addq %rax, %rsi
callq 0x3190
movq %rax, 0x18b68(%rip)     # 0x1c5e0
testq %rax, %rax
je 0x3b15
movq 0x186e8(%rip), %rax     # 0x1c170
testq %rax, %rax
je 0x3b15
cmpq $0x0, 0x18b27(%rip)     # 0x1c5c0
je 0x3b15
movslq 0x18b32(%rip), %rcx     # 0x1c5d4
leaq (%rax,%rcx,8), %rdi
movslq 0x18b2b(%rip), %rdx     # 0x1c5d8
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x30d0
movslq 0x18b15(%rip), %rdi     # 0x1c5d4
shlq $0x3, %rdi
addq 0x18af6(%rip), %rdi     # 0x1c5c0
movslq 0x18b07(%rip), %rdx     # 0x1c5d8
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x30d0
movslq 0x18af1(%rip), %rdi     # 0x1c5d4
addq 0x18af6(%rip), %rdi     # 0x1c5e0
movslq 0x18ae7(%rip), %rdx     # 0x1c5d8
xorl %esi, %esi
callq 0x30d0
movl 0x18ada(%rip), %eax     # 0x1c5d8
addl %eax, 0x18ad0(%rip)     # 0x1c5d4
leal (%rax,%rax,2), %eax
pushq $0x2
popq %rcx
cltd
idivl %ecx
movl %eax, 0x18ac5(%rip)     # 0x1c5d8
popq %rbp
retq
leaq 0x106de(%rip), %rdi     # 0x141fa
callq 0x39b6
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: new_vec_segment
void new_vec_segment(void) {
	Vectors = realloc(Vectors, sizeof(cell) *
			(Vec_pool_size + Vec_segment_size));
	if (Vectors == NULL)
		fatal("out of physical memory");
	memset(&Vectors[Vec_pool_size], 0, Vec_segment_size * sizeof(cell));
	Vec_pool_size += Vec_segment_size;
	Vec_segment_size = Vec_segment_size * 3 / 2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x18ab9(%rip), %rdi     # 0x1c5e8
movslq 0x18aba(%rip), %rax     # 0x1c5f0
movslq 0x18ab7(%rip), %rsi     # 0x1c5f4
addq %rax, %rsi
shlq $0x3, %rsi
callq 0x3190
movq %rax, 0x18a98(%rip)     # 0x1c5e8
testq %rax, %rax
je 0x3b94
movslq 0x18a94(%rip), %rbx     # 0x1c5f0
leaq (%rax,%rbx,8), %rdi
movslq 0x18a8d(%rip), %r14     # 0x1c5f4
movq %r14, %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x30d0
leal (%rbx,%r14), %eax
movl %eax, 0x18a71(%rip)     # 0x1c5f0
leal (%r14,%r14,2), %eax
pushq $0x2
popq %rcx
cltd
idivl %ecx
movl %eax, 0x18a65(%rip)     # 0x1c5f4
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1188e(%rip), %rdi     # 0x15429
callq 0x39b6
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: gc
int gc(void) {
	int	i, k;
	char	buf[100];

	if (Run_stats)
		count(&Collections);
	for (i=0; i<MAX_STREAMS; i++)
		if (Stream_flags[i] & LOCK_TAG)
			Stream_flags[i] |= USED_TAG;
		else
			Stream_flags[i] &= ~USED_TAG;
	for (i=0; GC_root[i] != NULL; i++)
		mark(GC_root[i][0]);
	k = 0;
	Free_list = NIL;
	for (i=0; i<Cons_pool_size; i++) {
		if (!(Tag[i] & MARK_TAG)) {
			cdr(i) = Free_list;
			Free_list = i;
			k++;
		}
		else {
			Tag[i] &= ~MARK_TAG;
		}
	}
	for (i=0; i<MAX_STREAMS; i++) {
		if (!(Stream_flags[i] & USED_TAG) && Streams[i] != NULL) {
			fclose(Streams[i]);
			Streams[i] = NULL;
		}
	}
	if (Verbose_GC > 1) {
		sprintf(buf, "GC: %d nodes reclaimed", k);
		pr(buf); nl();
	}
	return k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
cmpl $0x0, 0x18838(%rip)     # 0x1c620
je 0x3df6
leaq 0x18833(%rip), %rdi     # 0x1c624
callq 0x334c
xorl %eax, %eax
leaq 0x18801(%rip), %r14     # 0x1c600
cmpq $0x20, %rax
je 0x3e29
movb (%rax,%r14), %cl
movl %ecx, %edx
andb $0x3f, %dl
movl %ecx, %esi
orb $0x40, %sil
testb %cl, %cl
movzbl %sil, %ecx
movzbl %dl, %edx
cmovsl %ecx, %edx
movb %dl, (%rax,%r14)
incq %rax
jmp 0x3dff
leaq 0x17460(%rip), %rbx     # 0x1b290
movq (%rbx), %rax
testq %rax, %rax
je 0x3e46
movq (%rax), %rdi
callq 0x3ba0
addq $0x8, %rbx
jmp 0x3e30
orq $-0x1, 0x187ea(%rip)    # 0x1c638
xorl %eax, %eax
movl 0x1877e(%rip), %ecx     # 0x1c5d4
xorl %ebx, %ebx
movslq %ecx, %rdx
cmpq %rdx, %rax
jge 0x3ea1
movq 0x18779(%rip), %rdx     # 0x1c5e0
movb (%rdx,%rax), %sil
testb $0x2, %sil
jne 0x3e8e
movq 0x187c0(%rip), %rdx     # 0x1c638
movq 0x18741(%rip), %rsi     # 0x1c5c0
movq %rdx, (%rsi,%rax,8)
movq %rax, 0x187ae(%rip)     # 0x1c638
incl %ebx
jmp 0x3e9c
andb $-0x3, %sil
movb %sil, (%rdx,%rax)
movl 0x18738(%rip), %ecx     # 0x1c5d4
incq %rax
jmp 0x3e58
leaq 0x182d8(%rip), %r15     # 0x1c180
xorl %r12d, %r12d
cmpq $0x20, %r12
je 0x3ed2
testb $0x40, (%r12,%r14)
jne 0x3ec9
movq (%r15), %rdi
testq %rdi, %rdi
je 0x3ec9
callq 0x3090
andq $0x0, (%r15)
incq %r12
addq $0x8, %r15
jmp 0x3eab
cmpl $0x2, 0x18217(%rip)     # 0x1c0f0
jl 0x3f09
leaq 0x10341(%rip), %rsi     # 0x14223
leaq -0x90(%rbp), %r14
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x31f0
movq %r14, %rdi
callq 0x3873
leaq 0x119d3(%rip), %rdi     # 0x158d7
callq 0x3873
movl %ebx, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: unmark_vectors
void unmark_vectors(void) {
	int	p, k, link;

	p = 0;
	while (p < Free_vecs) {
		link = p;
		k = Vectors[p + RAW_VECTOR_SIZE];
		p += vector_size(k);
		Vectors[link] = NIL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %edx, %edx
movq 0x186c3(%rip), %rax     # 0x1c5e8
movslq %edx, %rcx
cmpq %rcx, 0x18749(%rip)     # 0x1c678
jle 0x3f4a
movslq 0x10(%rax,%rcx,8), %rdx
addq $0x7, %rdx
shrq $0x3, %rdx
addl %ecx, %edx
addl $0x3, %edx
orq $-0x1, (%rax,%rcx,8)
jmp 0x3f25
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: gcv
int gcv(void) {
	int	v, k, to, from;
	char	buf[100];

	unmark_vectors();
	gc();		/* re-mark live vectors */
	to = from = 0;
	while (from < Free_vecs) {
		v = Vectors[from + RAW_VECTOR_SIZE];
		k = vector_size(v);
		if (Vectors[from + RAW_VECTOR_LINK] != NIL) {
			if (to != from) {
				memmove(&Vectors[to], &Vectors[from],
					k * sizeof(cell));
				cdr(Vectors[to + RAW_VECTOR_LINK]) =
					to + RAW_VECTOR_DATA;
			}
			to += k;
		}
		from += k;
	}
	k = Free_vecs - to;
	if (Verbose_GC > 1) {
		sprintf(buf, "GC: gcv: %d cells reclaimed", k);
		pr(buf); nl();
	}
	Free_vecs = to;
	return k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
callq 0x3f18
callq 0x3dd2
xorl %r14d, %r14d
movq 0x18707(%rip), %rbx     # 0x1c678
xorl %r12d, %r12d
movslq %r12d, %rax
movslq %r14d, %r15
cmpq %rax, %rbx
jle 0x3fe5
movq 0x18662(%rip), %rcx     # 0x1c5e8
movslq 0x10(%rcx,%rax,8), %r13
addq $0x7, %r13
shrq $0x3, %r13
addl $0x3, %r13d
cmpq $-0x1, (%rcx,%rax,8)
je 0x3fdd
cmpl %r12d, %r14d
je 0x3fda
leaq (%rcx,%rax,8), %rsi
leaq (%rcx,%r15,8), %rdi
movslq %r13d, %rdx
shlq $0x3, %rdx
callq 0x31a0
leal 0x3(%r14), %eax
cltq
movq 0x185fc(%rip), %rcx     # 0x1c5c0
movq 0x1861d(%rip), %rdx     # 0x1c5e8
movq (%rdx,%r15,8), %rdx
movq %rax, (%rcx,%rdx,8)
movq 0x1869e(%rip), %rbx     # 0x1c678
addl %r13d, %r14d
addl %r12d, %r13d
movl %r13d, %r12d
jmp 0x3f74
subl %r14d, %ebx
cmpl $0x2, 0x18101(%rip)     # 0x1c0f0
jl 0x401f
leaq 0x102b5(%rip), %rsi     # 0x142ad
leaq -0x90(%rbp), %r14
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x31f0
movq %r14, %rdi
callq 0x3873
leaq 0x118bd(%rip), %rdi     # 0x158d7
callq 0x3873
movq %r15, 0x18652(%rip)     # 0x1c678
movl %ebx, %eax
addq $0x68, %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: new_vec
cell new_vec(cell type, int size) {
	cell	n;
	int	v, wsize;
	char	buf[100];

	wsize = vector_size(size);
	if (Free_vecs + wsize >= Vec_pool_size) {
		gcv();
		while (	Free_vecs + wsize >=
			Vec_pool_size - Vec_pool_size / 2
		) {
			if (	Memory_limit_kn &&
				Vec_pool_size + Vec_segment_size
					> Memory_limit_kn
			) {
				error("hit memory limit", NOEXPR);
				break;
			}
			else {
				new_vec_segment();
				gcv();
				if (Verbose_GC) {
					sprintf(buf,
						"GC: new_vec: new segment,"
						 " cells = %d",
						Vec_pool_size);
					pr(buf); nl();
				}
			}
		}
	}
	if (Free_vecs + wsize >= Vec_pool_size)
		fatal("new_vec: failed to recover from low memory condition");
	v = Free_vecs;
	Free_vecs += wsize;
	n = node3(type, v + RAW_VECTOR_DATA, VECTOR_TAG);
	Vectors[v + RAW_VECTOR_LINK] = n;
	Vectors[v + RAW_VECTOR_INDEX] = 0;
	Vectors[v + RAW_VECTOR_SIZE] = size;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movslq %esi, %r14
movq 0x18626(%rip), %r13     # 0x1c678
movq %r14, %rax
shlq $0x1d, %rax
movabsq $0x3e0000000, %rbx      # imm = 0x3E0000000
addq %rax, %rbx
sarq $0x20, %rbx
leaq (%rbx,%r13), %rsi
movslq 0x1857b(%rip), %rcx     # 0x1c5f0
cmpq %rcx, %rsi
jl 0x4141
movq %rdi, -0x30(%rbp)
movq %r14, -0x38(%rbp)
callq 0x3f4c
pushq $-0x2
popq %r14
leaq -0xa0(%rbp), %r15
leaq 0x1183a(%rip), %r12     # 0x158d7
movq 0x185d4(%rip), %r13     # 0x1c678
leaq (%rbx,%r13), %rsi
movl 0x18542(%rip), %ecx     # 0x1c5f0
movl %ecx, %eax
cltd
idivl %r14d
addl %ecx, %eax
cltq
cmpq %rax, %rsi
jl 0x4139
movq 0x185ac(%rip), %rax     # 0x1c670
testq %rax, %rax
je 0x40db
movslq %ecx, %rcx
movslq 0x18521(%rip), %rdx     # 0x1c5f4
addq %rcx, %rdx
cmpq %rdx, %rax
jl 0x4117
callq 0x3b21
callq 0x3f4c
cmpl $0x0, 0x18004(%rip)     # 0x1c0f0
je 0x409d
movl 0x184fc(%rip), %edx     # 0x1c5f0
movq %r15, %rdi
leaq 0x101cb(%rip), %rsi     # 0x142c9
xorl %eax, %eax
callq 0x31f0
movq %r15, %rdi
callq 0x3873
movq %r12, %rdi
callq 0x3873
jmp 0x409d
leaq 0x1011c(%rip), %rdi     # 0x1423a
pushq $-0x8
popq %rsi
callq 0x33e4
movq 0x1854b(%rip), %r13     # 0x1c678
movl 0x184bd(%rip), %ecx     # 0x1c5f0
addq %r13, %rbx
movq %rbx, %rsi
movq -0x38(%rbp), %r14
movq -0x30(%rbp), %rdi
movslq %ecx, %rax
cmpq %rax, %rsi
jge 0x41b9
movq %rsi, 0x18528(%rip)     # 0x1c678
shlq $0x20, %r13
movabsq $0x300000000, %rsi      # imm = 0x300000000
addq %r13, %rsi
sarq $0x20, %rsi
pushq $0x10
popq %rdx
callq 0x3613
movq 0x18474(%rip), %rcx     # 0x1c5e8
movq %r13, %rdx
sarq $0x1d, %rdx
movq %rax, (%rcx,%rdx)
movabsq $0x100000000, %rdx      # imm = 0x100000000
addq %r13, %rdx
sarq $0x1d, %rdx
andq $0x0, (%rcx,%rdx)
movabsq $0x200000000, %rdx      # imm = 0x200000000
addq %r13, %rdx
sarq $0x1d, %rdx
movq %r14, (%rcx,%rdx)
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1012e(%rip), %rdi     # 0x142ee
callq 0x39b6
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: integer_value
cell integer_value(char *src, cell x) {
	char	msg[100];

	if (cddr(x) != NIL) {
		sprintf(msg, "%s: integer argument too big", src);
		error(msg, x);
		return 0;
	}
	return cadr(x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq 0x183e7(%rip), %rcx     # 0x1c5c0
movq (%rcx,%rsi,8), %rax
cmpq $-0x1, (%rcx,%rax,8)
je 0x420f
movq %rsi, %rbx
movq %rdi, %rdx
leaq 0x1014a(%rip), %rsi     # 0x1433b
xorl %r14d, %r14d
leaq -0x80(%rbp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x31f0
movq %r15, %rdi
movq %rbx, %rsi
callq 0x33e4
jmp 0x421a
movq 0x17f5a(%rip), %rcx     # 0x1c170
movq (%rcx,%rax,8), %r14
movq %r14, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: reverse_segments
cell reverse_segments(cell n) {
	cell	m;

	m = NIL;
	while (n != NIL) {
		m = new_atom(car(n), m);
		n = cdr(n);
	}
	return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $-0x1
popq %rax
pushq $0x1
popq %r14
cmpq $-0x1, %rbx
je 0x42e8
movq 0x17ea4(%rip), %rcx     # 0x1c170
movq (%rcx,%rbx,8), %rdi
movq %rax, %rsi
movl %r14d, %edx
callq 0x3613
movq 0x182de(%rip), %rcx     # 0x1c5c0
movq (%rcx,%rbx,8), %rbx
jmp 0x42bf
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: bignum_add
cell bignum_add(cell a, cell b) {
	Tmp = b;
	save(a);
	save(b);
	Tmp = NIL;
	a = x_bignum_add(a, b);
	unsave(2);
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, 0x17bfe(%rip)     # 0x1c110
movq 0x17c0f(%rip), %rsi     # 0x1c128
xorl %edx, %edx
callq 0x3613
movq %rax, 0x17c01(%rip)     # 0x1c128
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x17bed(%rip)     # 0x1c128
orq $-0x1, 0x17bcd(%rip)    # 0x1c110
movq %r14, %rdi
movq %rbx, %rsi
callq 0x42ed
movq %rax, %rbx
pushq $0x2
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: bignum_subtract
cell bignum_subtract(cell a, cell b) {
	Tmp = b;
	save(a);
	save(b);
	Tmp = NIL;
	a = x_bignum_subtract(a, b);
	unsave(2);
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, 0x17b9b(%rip)     # 0x1c110
movq 0x17bac(%rip), %rsi     # 0x1c128
xorl %edx, %edx
callq 0x3613
movq %rax, 0x17b9e(%rip)     # 0x1c128
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x17b8a(%rip)     # 0x1c128
orq $-0x1, 0x17b6a(%rip)    # 0x1c110
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4723
movq %rax, %rbx
pushq $0x2
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: bignum_less_p
int bignum_less_p(cell a, cell b) {
	int	ka, kb, neg_a, neg_b;

	neg_a = x_bignum_negative_p(a);
	neg_b = x_bignum_negative_p(b);
	if (neg_a && !neg_b) return 1;
	if (!neg_a && neg_b) return 0;
	ka = length(a);
	kb = length(b);
	if (ka < kb) return neg_a? 0: 1;
	if (ka > kb) return neg_a? 1: 0;
	Tmp = b;
	a = bignum_abs(a);
	save(a);
	b = bignum_abs(b);
	unsave(1);
	Tmp = NIL;
	a = cdr(a);
	b = cdr(b);
	while (a != NIL) {
		if (car(a) < car(b)) return neg_a? 0: 1;
		if (car(a) > car(b)) return neg_a? 1: 0;
		a = cdr(a);
		b = cdr(b);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x17b9a(%rip), %rax     # 0x1c170
movq 0x17fe3(%rip), %rcx     # 0x1c5c0
movq (%rcx,%rdi,8), %rdx
movq (%rax,%rdx,8), %r12
testq %r12, %r12
setns %dl
movq (%rcx,%rsi,8), %rcx
movq (%rax,%rcx,8), %rax
testq %rax, %rax
sets %cl
orb %dl, %cl
cmpb $0x1, %cl
jne 0x4635
testq %rax, %rax
sets %al
testq %r12, %r12
setns %cl
xorl %ebx, %ebx
testb %al, %cl
jne 0x4638
movq %rsi, %r14
movq %rdi, %r15
callq 0x46c4
movl %eax, %ebx
movq %r14, %rdi
callq 0x46c4
cmpl %eax, %ebx
jge 0x4643
xorl %ebx, %ebx
testq %r12, %r12
setns %bl
jmp 0x4638
pushq $0x1
popq %rbx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jg 0x46b8
movq %r14, 0x17ac4(%rip)     # 0x1c110
movq %r15, %rdi
callq 0x4228
movq %rax, %r15
movq 0x17aca(%rip), %rsi     # 0x1c128
xorl %ebx, %ebx
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x17ab7(%rip)     # 0x1c128
movq %r14, %rdi
callq 0x4228
movq %rax, %r14
pushq $0x1
popq %rdi
callq 0x3775
orq $-0x1, 0x17a84(%rip)    # 0x1c110
movq 0x17f2d(%rip), %rax     # 0x1c5c0
movq 0x17ad6(%rip), %rcx     # 0x1c170
movq (%rax,%r15,8), %r15
cmpq $-0x1, %r15
je 0x4638
movq (%rax,%r14,8), %r14
movq (%rcx,%r14,8), %rdx
cmpq %rdx, (%rcx,%r15,8)
jl 0x462b
jle 0x469a
shrq $0x3f, %r12
movl %r12d, %ebx
jmp 0x4638
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: length
int length(cell n) {
	int	k = 0;

	while (n != NIL) {
		k++;
		n = cdr(n);
	}
	return k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movq 0x17eef(%rip), %rcx     # 0x1c5c0
cmpq $-0x1, %rdi
je 0x46df
incl %eax
movq (%rcx,%rdi,8), %rdi
jmp 0x46d1
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: bignum_equal_p
int bignum_equal_p(cell a, cell b) {
	a = cdr(a);
	b = cdr(b);
	while (a != NIL && b != NIL) {
		if (car(a) != car(b))
			return 0;
		a = cdr(a);
		b = cdr(b);
	}
	return a == NIL && b == NIL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x17ed4(%rip), %rax     # 0x1c5c0
movq 0x17a7d(%rip), %rcx     # 0x1c170
movq (%rax,%rsi,8), %rsi
movq (%rax,%rdi,8), %rdi
cmpq $-0x1, %rdi
je 0x4715
cmpq $-0x1, %rsi
je 0x4715
movq (%rcx,%rdi,8), %rdx
cmpq (%rcx,%rsi,8), %rdx
je 0x46f3
xorl %eax, %eax
jmp 0x4721
andq %rsi, %rdi
xorl %eax, %eax
cmpq $-0x1, %rdi
sete %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: bignum_shift_left
cell bignum_shift_left(cell a, int fill) {
	cell	r, c, result;
	int	carry;

	a = reverse_segments(cdr(a));
	save(a);
	carry = fill;
	result = NIL;
	save(result);
	while (a != NIL) {
		if (car(a) >= INT_SEG_LIMIT/10) {
			c = car(a) / (INT_SEG_LIMIT/10);
			r = car(a) % (INT_SEG_LIMIT/10) * 10;
			r += carry;
			carry = c;
		}
		else {
			r = car(a) * 10 + carry;
			carry = 0;
		}
		result = new_atom(r, result);
		car(Stack) = result;
		a = cdr(a);
	}
	if (carry)
		result = new_atom(carry, result);
	unsave(2);
	return new_atom(T_INTEGER, result);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r15d
movq 0x17c22(%rip), %rax     # 0x1c5c0
movq (%rax,%rdi,8), %rdi
callq 0x42ae
movq %rax, %r14
movq 0x17777(%rip), %rsi     # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x17766(%rip)     # 0x1c128
pushq $-0x1
popq %rbx
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x1774f(%rip)     # 0x1c128
movl $0x5f5e100, %r13d       # imm = 0x5F5E100
pushq $0x1
popq %r12
movslq %r15d, %rdi
cmpq $-0x1, %r14
je 0x4a4a
movq 0x1777d(%rip), %rax     # 0x1c170
movq (%rax,%r14,8), %rax
cmpq $0x5f5e100, %rax        # imm = 0x5F5E100
jl 0x4a10
xorl %edx, %edx
divq %r13
movq %rax, %r15
imulq $0xa, %rdx, %rax
addq %rdi, %rax
jmp 0x4a1a
imulq $0xa, %rax, %rax
addq %rdi, %rax
xorl %r15d, %r15d
movq %rax, %rdi
movq %rbx, %rsi
movl %r12d, %edx
callq 0x3613
movq %rax, %rbx
movq 0x1773e(%rip), %rax     # 0x1c170
movq 0x176ef(%rip), %rcx     # 0x1c128
movq %rbx, (%rax,%rcx,8)
movq 0x17b7c(%rip), %rax     # 0x1c5c0
movq (%rax,%r14,8), %r14
jmp 0x49e3
testl %r15d, %r15d
je 0x4a5d
pushq $0x1
popq %rdx
movq %rbx, %rsi
callq 0x3613
movq %rax, %rbx
pushq $0x2
popq %rdi
callq 0x3775
pushq $-0x18
popq %rdi
pushq $0x1
popq %rdx
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3613
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: bignum_shift_right
cell bignum_shift_right(cell a) {
	cell	r, c, result;
	int	carry;

	a = cdr(a);
	save(a);
	carry = 0;
	result = NIL;
	save(result);
	while (a != NIL) {
		c = car(a) % 10;
		r = car(a) / 10;
		r += carry * (INT_SEG_LIMIT/10);
		carry = c;
		result = new_atom(r, result);
		car(Stack) = result;
		a = cdr(a);
	}
	result = reverse_segments(result);
	if (car(result) == 0 && cdr(result) != NIL)
		result = cdr(result);
	result = new_atom(T_INTEGER, result);
	car(Stack) = result;
	carry = make_integer(carry);
	unsave(2);
	return node(result, carry);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x17b2a(%rip), %rax     # 0x1c5c0
movq (%rax,%rdi,8), %rbx
movq 0x17687(%rip), %rsi     # 0x1c128
xorl %r13d, %r13d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x17673(%rip)     # 0x1c128
pushq $-0x1
popq %r14
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x1765b(%rip)     # 0x1c128
pushq $0x1
popq %r15
cmpq $-0x1, %rbx
je 0x4b2a
movq 0x17692(%rip), %rax     # 0x1c170
movq (%rax,%rbx,8), %rax
cqto
pushq $0xa
popq %rcx
idivq %rcx
movq %rdx, %r12
imull $0x5f5e100, %r13d, %ecx # imm = 0x5F5E100
movslq %ecx, %rdi
addq %rax, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x3613
movq %rax, %r14
movq 0x17661(%rip), %rax     # 0x1c170
movq 0x17612(%rip), %rcx     # 0x1c128
movq %r14, (%rax,%rcx,8)
movq 0x17a9f(%rip), %rax     # 0x1c5c0
movq (%rax,%rbx,8), %rbx
movl %r12d, %r13d
jmp 0x4ad1
movq %r14, %rdi
callq 0x42ae
movq 0x17637(%rip), %rcx     # 0x1c170
cmpq $0x0, (%rcx,%rax,8)
jne 0x4b53
movq 0x17a79(%rip), %rcx     # 0x1c5c0
movq (%rcx,%rax,8), %rcx
cmpq $-0x1, %rcx
cmovneq %rcx, %rax
pushq $-0x18
popq %rdi
pushq $0x1
popq %rdx
movq %rax, %rsi
callq 0x3613
movq %rax, %rbx
movq 0x17605(%rip), %rax     # 0x1c170
movq 0x175b6(%rip), %rcx     # 0x1c128
movq %rbx, (%rax,%rcx,8)
movslq %r13d, %rdi
callq 0x35ed
movq %rax, %r14
pushq $0x2
popq %rdi
callq 0x3775
movslq %r14d, %rsi
movq %rbx, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3613
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: bignum_multiply
cell bignum_multiply(cell a, cell b) {
	int	neg;
	cell	r, i, result;

	neg = x_bignum_negative_p(a) != x_bignum_negative_p(b);
	a = bignum_abs(a);
	save(a);
	b = bignum_abs(b);
	save(b);
	result = make_integer(0);
	save(result);
	while (!x_bignum_zero_p(a)) {
		if (Error_flag)
			break;
		r = bignum_shift_right(a);
		i = caddr(r);
		a = car(r);
		caddr(Stack) = a;
		while (i) {
			result = bignum_add(result, b);
			car(Stack) = result;
			i--;
		}
		b = bignum_shift_left(b, 0);
		cadr(Stack) = b;
	}
	if (neg)
		result = bignum_negate(result);
	unsave(3);
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x175b4(%rip), %rax     # 0x1c170
movq 0x179fd(%rip), %rcx     # 0x1c5c0
movq (%rcx,%rdi,8), %rdx
movq (%rcx,%rsi,8), %rcx
movq (%rax,%rcx,8), %r12
xorq (%rax,%rdx,8), %r12
callq 0x4228
movq %rax, %rbx
movq 0x17546(%rip), %rsi     # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x17535(%rip)     # 0x1c128
movq %r14, %rdi
callq 0x4228
movq %rax, %r15
movq 0x17523(%rip), %rsi     # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x17512(%rip)     # 0x1c128
xorl %edi, %edi
callq 0x35ed
movq %rax, %r14
movq 0x17501(%rip), %rsi     # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x174f0(%rip)     # 0x1c128
movq 0x17531(%rip), %rcx     # 0x1c170
movq 0x1797a(%rip), %rax     # 0x1c5c0
movq (%rax,%rbx,8), %rdx
cmpq $0x0, (%rcx,%rdx,8)
jne 0x4c5c
cmpq $-0x1, (%rax,%rdx,8)
je 0x4cf9
cmpl $0x0, 0x17951(%rip)     # 0x1c5b4
jne 0x4cf9
movq %rbx, %rdi
callq 0x4a81
movq 0x174f8(%rip), %rcx     # 0x1c170
movq 0x17941(%rip), %rdx     # 0x1c5c0
movq (%rdx,%rax,8), %rsi
movq (%rdx,%rsi,8), %rsi
movq (%rcx,%rsi,8), %r13
movq (%rcx,%rax,8), %rbx
movq 0x17492(%rip), %rax     # 0x1c128
movq (%rdx,%rax,8), %rax
movq (%rdx,%rax,8), %rax
movq %rbx, (%rcx,%rax,8)
subq $0x1, %r13
jb 0x4cca
movq %r14, %rdi
movq %r15, %rsi
callq 0x44fe
movq %rax, %r14
movq 0x174b3(%rip), %rax     # 0x1c170
movq 0x17464(%rip), %rcx     # 0x1c128
movq %r14, (%rax,%rcx,8)
jmp 0x4ca2
movq %r15, %rdi
xorl %esi, %esi
callq 0x4986
movq %rax, %r15
movq 0x17492(%rip), %rcx     # 0x1c170
movq 0x178db(%rip), %rax     # 0x1c5c0
movq 0x1743c(%rip), %rdx     # 0x1c128
movq (%rax,%rdx,8), %rdx
movq %r15, (%rcx,%rdx,8)
jmp 0x4c46
testq %r12, %r12
jns 0x4d09
movq %r14, %rdi
callq 0x426f
movq %rax, %r14
pushq $0x3
popq %rdi
callq 0x3775
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_O2/azhai[P]mlite/mlite.c
// Function: bignum_equalize
cell bignum_equalize(cell a, cell b) {
	cell	r, f, r0, f0;

	r0 = a;
	save(r0);
	f0 = make_integer(1);
	save(f0);
	r = r0;
	save(r);
	f = f0;
	save(f);
	while (bignum_less_p(r, b)) {
		cadddr(Stack) = r0 = r;
		caddr(Stack) = f0 = f;
		r = bignum_shift_left(r, 0);
		cadr(Stack) = r;
		f = bignum_shift_left(f, 0);
		car(Stack) = f;
	}
	unsave(4);
	return node(r0, f0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %r14
movq 0x173e6(%rip), %rsi     # 0x1c128
xorl %edx, %edx
callq 0x3613
movq %rax, 0x173d8(%rip)     # 0x1c128
pushq $0x1
popq %rdi
callq 0x35ed
movq %rax, %r13
movq 0x173c6(%rip), %rsi     # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x173b5(%rip)     # 0x1c128
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x173a1(%rip)     # 0x1c128
movq %r13, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x1738d(%rip)     # 0x1c128
movq %r14, -0x30(%rbp)
movq %r13, %rbx
movq %r13, %r15
movq %r14, %r12
movq %r14, %rdi
movq -0x38(%rbp), %rsi
callq 0x45c4
testl %eax, %eax
je 0x4e49
movq 0x173ad(%rip), %rax     # 0x1c170
movq 0x177f6(%rip), %rcx     # 0x1c5c0
movq 0x17357(%rip), %rdx     # 0x1c128
movq (%rcx,%rdx,8), %rdx
movq (%rcx,%rdx,8), %rdx
movq (%rcx,%rdx,8), %rdx
movq %r12, (%rax,%rdx,8)
movq 0x17340(%rip), %rdx     # 0x1c128
movq (%rcx,%rdx,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq %r15, (%rax,%rcx,8)
movq %r12, %rdi
xorl %esi, %esi
callq 0x4986
movq %rax, %r14
movq 0x17368(%rip), %rax     # 0x1c170
movq 0x177b1(%rip), %rcx     # 0x1c5c0
movq 0x17312(%rip), %rdx     # 0x1c128
movq (%rcx,%rdx,8), %rcx
movq %r14, (%rax,%rcx,8)
movq %r15, %rdi
xorl %esi, %esi
callq 0x4986
movq %rax, %r13
movq 0x1733e(%rip), %rax     # 0x1c170
movq 0x172ef(%rip), %rcx     # 0x1c128
movq %r13, (%rax,%rcx,8)
movq %r12, -0x30(%rbp)
movq %r15, %rbx
jmp 0x4da2
pushq $0x4
popq %rdi
callq 0x3775
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3613
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: bignum_divide
cell bignum_divide(cell x, cell a, cell b) {
	if (x_bignum_zero_p(b))
		return error("divide by zero", x);
	Tmp = b;
	save(a);
	save(b);
	Tmp = NIL;
	a = x_bignum_divide(a, b);
	unsave(2);
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq 0x16f5c(%rip), %rdx     # 0x1c170
movq 0x173a5(%rip), %rax     # 0x1c5c0
movq (%rax,%rbx,8), %rcx
cmpq $0x0, (%rdx,%rcx,8)
jne 0x522d
cmpq $-0x1, (%rax,%rcx,8)
je 0x5286
movq %rbx, 0x16edc(%rip)     # 0x1c110
movq 0x16eed(%rip), %rsi     # 0x1c128
movq %r14, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x16edc(%rip)     # 0x1c128
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x16ec8(%rip)     # 0x1c128
orq $-0x1, 0x16ea8(%rip)    # 0x1c110
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4e6d
movq %rax, %rbx
pushq $0x2
popq %rdi
callq 0x3775
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rdi, %rsi
leaq 0xf0c8(%rip), %rdi      # 0x14358
callq 0x33e4
pushq $-0x5
popq %rax
jmp 0x5281
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: make_real
cell make_real(int flags, cell exp, cell mant) {
	cell	n;

	n = new_atom(exp, mant);
	n = new_atom(flags, n);
	return new_atom(T_REAL, n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
pushq $0x1
popq %r14
movq %rsi, %rdi
movq %rdx, %rsi
movl %r14d, %edx
callq 0x3613
movslq %ebx, %rdi
movq %rax, %rsi
movl %r14d, %edx
callq 0x3613
pushq $-0x1f
popq %rdi
movq %rax, %rsi
movl %r14d, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x3613
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: count_digits
cell count_digits(cell m) {
	int	k = 0;
	cell	x;

	x = car(m);
	k = 0;
	while (x != 0) {
		x /= 10;
		k++;
	}
	k = k==0? 1: k;
	m = cdr(m);
	while (m != NIL) {
		k += DIGITS_PER_WORD;
		m = cdr(m);
	}
	return k;
}

// Assembly:
movq 0x16e94(%rip), %rax     # 0x1c170
movq (%rax,%rdi,8), %rax
xorl %ecx, %ecx
movabsq $0xa, %rsi
testq %rax, %rax
je 0x52fb
cqto
idivq %rsi
incq %rcx
jmp 0x52ec
pushq %rbp
movq %rsp, %rbp
movq 0x172ba(%rip), %rax     # 0x1c5c0
cmpq $0x1, %rcx
adcq $-0x9, %rcx
movq (%rax,%rdi,8), %rdi
addq $0x9, %rcx
cmpq $-0x1, %rdi
jne 0x530e
movq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: real_normalize
cell real_normalize(cell x, char *who) {
	cell	m, e, r;
	int	dgs;
	char	buf[50];

	save(x);
	e = x_real_exponent(x);
	m = new_atom(T_INTEGER, x_real_mantissa(x));
	save(m);
	dgs = count_digits(cdr(m));
	while (dgs > MANTISSA_SIZE) {
		r = bignum_shift_right(m);
		m = car(r);
		car(Stack) = m;
		dgs--;
		e++;
	}
	while (!x_bignum_zero_p(m)) {
		r = bignum_shift_right(m);
		if (!x_bignum_zero_p(cdr(r)))
			break;
		m = car(r);
		car(Stack) = m;
		e++;
	}
	if (x_bignum_zero_p(m))
		e = 0;
	r = new_atom(e, NIL);
	unsave(2);
	if (count_digits(r) > DIGITS_PER_WORD) {
		sprintf(buf, "%s: real number overflow",
			who? who: "internal");
		error(buf, NOEXPR);
	}
	return make_real(x_real_flags(x), e, cdr(m));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x16de9(%rip), %rsi     # 0x1c128
xorl %edx, %edx
callq 0x3613
movq %rax, 0x16ddb(%rip)     # 0x1c128
movq 0x16e1c(%rip), %rax     # 0x1c170
movq 0x17265(%rip), %rcx     # 0x1c5c0
movq (%rcx,%rbx,8), %rdx
movq (%rcx,%rdx,8), %rdx
movq (%rax,%rdx,8), %r14
movq (%rcx,%rdx,8), %rsi
pushq $-0x18
popq %rdi
pushq $0x1
popq %rdx
callq 0x3613
movq %rax, %r12
movq 0x16da8(%rip), %rsi     # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x16d97(%rip)     # 0x1c128
movq 0x17228(%rip), %rax     # 0x1c5c0
movq (%rax,%r12,8), %rdi
callq 0x52d5
movq %rax, %r13
cmpl $0x24, %r13d
jle 0x53d0
movq %r12, %rdi
callq 0x4a81
movq 0x16db7(%rip), %rcx     # 0x1c170
movq (%rcx,%rax,8), %r12
movq 0x16d64(%rip), %rax     # 0x1c128
movq %r12, (%rcx,%rax,8)
decl %r13d
incq %r14
jmp 0x53a4
movq 0x16d99(%rip), %rdx     # 0x1c170
movq 0x171e2(%rip), %rcx     # 0x1c5c0
movq (%rcx,%r12,8), %rax
cmpq $0x0, (%rdx,%rax,8)
jne 0x53f0
cmpq $-0x1, (%rcx,%rax,8)
je 0x5430
movq %r12, %rdi
callq 0x4a81
movq 0x16d71(%rip), %rdx     # 0x1c170
movq 0x171ba(%rip), %rcx     # 0x1c5c0
movq (%rcx,%rax,8), %rsi
movq (%rcx,%rsi,8), %rsi
cmpq $0x0, (%rdx,%rsi,8)
jne 0x5430
cmpq $-0x1, (%rcx,%rsi,8)
jne 0x5430
movq (%rdx,%rax,8), %r12
movq 0x16d01(%rip), %rax     # 0x1c128
movq %r12, (%rdx,%rax,8)
incq %r14
jmp 0x53de
movq (%rcx,%r12,8), %rax
cmpq $0x0, (%rdx,%rax,8)
jne 0x5446
xorl %edx, %edx
cmpq $-0x1, (%rcx,%rax,8)
cmoveq %rdx, %r14
pushq $-0x1
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x3613
movq %rax, %r13
pushq $0x2
popq %rdi
callq 0x3775
movq %r13, %rdi
callq 0x52d5
cmpq $0xa, %rax
jl 0x549b
testq %r15, %r15
leaq 0xef09(%rip), %rdx      # 0x14380
cmovneq %r15, %rdx
leaq 0xeee5(%rip), %rsi      # 0x14367
leaq -0x60(%rbp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x31f0
pushq $-0x8
popq %rsi
movq %r15, %rdi
callq 0x33e4
movq 0x16cce(%rip), %rax     # 0x1c170
movq 0x17117(%rip), %rcx     # 0x1c5c0
movq (%rcx,%rbx,8), %rdx
movl (%rax,%rdx,8), %edi
movq (%rcx,%r12,8), %rdx
movq %r14, %rsi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x529a
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: flat_copy
cell flat_copy(cell n) {
	cell	a, m, new;

	if (n == NIL)
		return NIL;
	m = node3(NIL, NIL, Tag[n]);
	save(m);
	a = m;
	while (n != NIL) {
		car(a) = car(n);
		n = cdr(n);
		if (n != NIL) {
			set(cdr(a), node3(NIL, NIL, Tag[n]))
			a = cdr(a);
		}
	}
	unsave(1);
	return m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpq $-0x1, %rdi
je 0x5570
movq %rdi, %rbx
movq 0x170f7(%rip), %rax     # 0x1c5e0
movsbl (%rax,%rdi), %edx
pushq $-0x1
popq %r15
movq %r15, %rdi
movq %r15, %rsi
callq 0x3613
movq %rax, %r14
movq 0x16c22(%rip), %rsi     # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x16c11(%rip)     # 0x1c128
movq %r14, %r12
movq 0x16c4f(%rip), %rax     # 0x1c170
movq 0x17098(%rip), %rcx     # 0x1c5c0
cmpq $-0x1, %rbx
je 0x5566
movq (%rax,%rbx,8), %rdx
movq %rdx, (%rax,%r12,8)
movq (%rcx,%rbx,8), %rbx
cmpq $-0x1, %rbx
je 0x5528
movq 0x17099(%rip), %rax     # 0x1c5e0
movsbl (%rax,%rbx), %edx
movq %r15, %rdi
movq %r15, %rsi
callq 0x3613
movq 0x17063(%rip), %rcx     # 0x1c5c0
movq %rax, (%rcx,%r12,8)
movq %rax, %r12
jmp 0x551a
pushq $0x1
popq %rdi
callq 0x3775
jmp 0x5574
pushq $-0x1
popq %r14
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: bignum_to_real
cell bignum_to_real(cell a) {
	int	e, flags, d;
	cell	m, n;

	m = flat_copy(a);
	cadr(m) = labs(cadr(m));
	e = 0;
	if (length(cdr(m)) > MANTISSA_SEGMENTS) {
		d = count_digits(cdr(m));
		while (d > MANTISSA_SIZE) {
			m = bignum_shift_right(m);
			m = car(m);
			e++;
			d--;
		}
	}
	flags = x_bignum_negative_p(a)? REAL_NEGATIVE: 0;
	n = make_real(flags, e, cdr(m));
	return real_normalize(n, NULL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, -0x30(%rbp)
callq 0x54ca
movq %rax, %r15
movq 0x16bcf(%rip), %r13     # 0x1c170
movq 0x17018(%rip), %rbx     # 0x1c5c0
movq (%rbx,%rax,8), %rax
movq (%r13,%rax,8), %rcx
movq %rcx, %rdx
negq %rdx
cmovsq %rcx, %rdx
movq %rdx, (%r13,%rax,8)
movq (%rbx,%r15,8), %r12
movq %r12, %rdi
callq 0x46c4
cmpl $0x5, %eax
jl 0x5611
movq %r12, %rdi
callq 0x52d5
movq %rax, %r12
xorl %r14d, %r14d
leal (%r12,%r14), %eax
cmpl $0x25, %eax
jl 0x5601
movq %r15, %rdi
callq 0x4a81
movq 0x16b79(%rip), %r13     # 0x1c170
movq (%r13,%rax,8), %r15
decq %r14
jmp 0x55df
movq 0x16fb8(%rip), %rbx     # 0x1c5c0
movq (%rbx,%r15,8), %r12
negq %r14
jmp 0x5614
xorl %r14d, %r14d
movq -0x30(%rbp), %rax
movq (%rbx,%rax,8), %rax
movq (%r13,%rax,8), %rdi
shrq $0x3f, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x529a
movq %rax, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5321
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: real_abs
cell real_abs(cell a) {
	if (integer_p(a))
		return bignum_abs(a);
	if (x_real_negative_p(a))
		return x_real_negate(a);
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
js 0x5825
movq 0x16dd5(%rip), %rax     # 0x1c5e0
testb $0x1, (%rax,%rdi)
movq 0x1695a(%rip), %rcx     # 0x1c170
je 0x582c
cmpq $-0x18, (%rcx,%rdi,8)
jne 0x582c
popq %rbp
jmp 0x4228
movq 0x16944(%rip), %rcx     # 0x1c170
movq 0x16d8d(%rip), %rsi     # 0x1c5c0
movq (%rsi,%rdi,8), %rdx
movq (%rcx,%rdx,8), %rax
testb $0x1, %al
jne 0x5844
movq %rdi, %rax
popq %rbp
retq
movq (%rsi,%rdx,8), %r8
movq (%rsi,%r8,8), %rdx
cmpq $0x0, (%rcx,%rdx,8)
jne 0x585a
cmpq $-0x1, (%rsi,%rdx,8)
je 0x583f
andl $-0x2, %eax
movq (%rcx,%r8,8), %rsi
movl %eax, %edi
popq %rbp
jmp 0x529a
// File: /workspace/github_c_makefile_star2_O2/azhai[P]mlite/mlite.c
// Function: shift_mantissa
cell shift_mantissa(cell m) {
	m = new_atom(T_INTEGER, m);
	save(m);
	m = bignum_shift_right(m);
	m = car(m);
	unsave(1);
	return cdr(m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rsi
pushq $-0x18
popq %rdi
pushq $0x1
popq %rbx
movl %ebx, %edx
callq 0x3613
movq %rax, %r14
movq 0x1689e(%rip), %rsi     # 0x1c128
movq %rax, %rdi
xorl %edx, %edx
callq 0x3613
movq %rax, 0x1688d(%rip)     # 0x1c128
movq %r14, %rdi
callq 0x4a81
movq 0x168c6(%rip), %rcx     # 0x1c170
movq (%rcx,%rax,8), %r14
movl %ebx, %edi
callq 0x3775
movq 0x16d04(%rip), %rax     # 0x1c5c0
movq (%rax,%r14,8), %rax
popq %rbx
popq %r14
popq %rbp
retq