LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl 0x250fb(%rip), %eax     # 0x285c4
cmpl $0x0, %eax
je 0x34db
movq $-0x5, -0x8(%rbp)
jmp 0x35e7
movl 0x24daf(%rip), %eax     # 0x28290
movl %eax, -0x1c(%rbp)
movl 0x250de(%rip), %edx     # 0x285c8
movl $0x1, %eax
movl $0x2, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x24d90(%rip)     # 0x28290
movl $0x1, 0x250ba(%rip)     # 0x285c4
leaq 0x1cd9d(%rip), %rdi     # 0x202ae
callq 0x3ab0
movq 0x250b3(%rip), %rax     # 0x285d0
movq 0x250b4(%rip), %rcx     # 0x285d8
cmpq $-0x2, (%rax,%rcx,8)
jne 0x3579
cmpq $-0x1, 0x24c25(%rip)    # 0x28158
je 0x3558
movq 0x24c44(%rip), %rax     # 0x28180
movq 0x24c15(%rip), %rcx     # 0x28158
movq (%rax,%rcx,8), %rdi
callq 0x3b70
leaq 0x1d1af(%rip), %rdi     # 0x20702
callq 0x3ab0
leaq -0x80(%rbp), %rdi
movl 0x2507e(%rip), %edx     # 0x285e0
leaq 0x1cd4d(%rip), %rsi     # 0x202b6
movb $0x0, %al
callq 0x3200
leaq -0x80(%rbp), %rdi
callq 0x3ab0
movq -0x10(%rbp), %rdi
callq 0x3ab0
cmpq $-0x8, -0x18(%rbp)
je 0x35b2
leaq 0x1d172(%rip), %rdi     # 0x20702
callq 0x3ab0
movl $0x0, 0x25025(%rip)     # 0x285c4
movq -0x18(%rbp), %rdi
callq 0x3b30
movl $0x1, 0x25012(%rip)     # 0x285c4
leaq 0x1e41a(%rip), %rdi     # 0x219d3
callq 0x3ab0
callq 0x3b90
movl -0x1c(%rbp), %eax
movl %eax, 0x24cc4(%rip)     # 0x28290
cmpl $0x0, 0x24ff5(%rip)     # 0x285c8
je 0x35df
movl $0x1, %edi
callq 0x3b10
movq $-0x5, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movslq (%rax), %rdi
callq 0x3740
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq $-0x1, %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0x24afb(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x24aed(%rip)     # 0x28138
movq -0x8(%rbp), %rax
movslq 0x4(%rax), %rdi
callq 0x3740
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movq 0x24b06(%rip), %rax     # 0x28180
movq 0x24ab7(%rip), %rcx     # 0x28138
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq 0x8(%rax), %rdi
callq 0x3740
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movq 0x24acc(%rip), %rax     # 0x28180
movq 0x24a7d(%rip), %rcx     # 0x28138
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq 0xc(%rax), %rdi
callq 0x3740
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movq 0x24a92(%rip), %rax     # 0x28180
movq 0x24a43(%rip), %rcx     # 0x28138
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq 0x10(%rax), %rdi
callq 0x3740
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movl $0x1, %edi
callq 0x3950
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: 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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq $-0x1, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x39b9
cmpq $-0x1, 0x247c7(%rip)    # 0x28138
jne 0x397f
leaq 0x1ca71(%rip), %rdi     # 0x203eb
callq 0x3c70
movq 0x247fa(%rip), %rax     # 0x28180
movq 0x247ab(%rip), %rcx     # 0x28138
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq 0x24c34(%rip), %rax     # 0x285d0
movq 0x24795(%rip), %rcx     # 0x28138
movq (%rax,%rcx,8), %rax
movq %rax, 0x2478a(%rip)     # 0x28138
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3963
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, 0x2488e(%rip)     # 0x28294
je 0x3a53
movl 0x2488a(%rip), %eax     # 0x28298
cmpl 0x24880(%rip), %eax     # 0x28294
jle 0x3a53
cmpl $0x0, 0x24877(%rip)     # 0x28294
jle 0x3a47
movslq 0x2486a(%rip), %rcx     # 0x28290
leaq 0x24763(%rip), %rax     # 0x28190
movq (%rax,%rcx,8), %rcx
leaq 0x1c850(%rip), %rdi     # 0x20288
movl $0x1, %esi
movl $0x3, %edx
callq 0x3220
movl $0xffffffff, 0x24843(%rip) # imm = 0xFFFFFFFF
jmp 0x3aaa
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rdx
movslq 0x2482e(%rip), %rcx     # 0x28290
leaq 0x24727(%rip), %rax     # 0x28190
movq (%rax,%rcx,8), %rcx
movl $0x1, %esi
callq 0x3220
cmpl $0x1, 0x24812(%rip)     # 0x28290
jne 0x3a9b
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x3a9b
callq 0x39d0
movl -0xc(%rbp), %eax
addl 0x247f4(%rip), %eax     # 0x28298
movl %eax, 0x247ee(%rip)     # 0x28298
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movslq 0x247cd(%rip), %rcx     # 0x28290
leaq 0x246c6(%rip), %rax     # 0x28190
cmpq $0x0, (%rax,%rcx,8)
jne 0x3ae6
leaq 0x1c7b4(%rip), %rdi     # 0x2028c
movq $-0x8, %rsi
callq 0x34b0
jmp 0x3b02
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30a0
movq -0x10(%rbp), %rdi
movl %eax, %esi
callq 0x39f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x32, 0x2474e(%rip)    # 0x28294
movl $0x0, 0x24748(%rip)     # 0x28298
movq -0x8(%rbp), %rdi
callq 0x3b70
movl $0x0, 0x24731(%rip)     # 0x28294
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x246f4(%rip), %eax     # 0x2829c
jge 0x3bcb
movslq -0x4(%rbp), %rcx
leaq 0x246eb(%rip), %rax     # 0x282a0
cmpq $-0x1, (%rax,%rcx,8)
je 0x3bbe
jmp 0x3bcb
jmp 0x3bc0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3b9f
movl -0x4(%rbp), %eax
cmpl 0x246c8(%rip), %eax     # 0x2829c
jne 0x3bdb
jmp 0x3c66
leaq 0x1c6c0(%rip), %rdi     # 0x202a2
callq 0x3ab0
movl 0x249d3(%rip), %eax     # 0x285c0
movl %eax, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x2469c(%rip), %eax     # 0x2829c
jge 0x3c5a
movl -0x4(%rbp), %eax
cmpl 0x24691(%rip), %eax     # 0x2829c
jl 0x3c14
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x24681(%rip), %rax     # 0x282a0
cmpq $-0x1, (%rax,%rcx,8)
je 0x3c46
leaq 0x1dce4(%rip), %rdi     # 0x21911
callq 0x3ab0
movslq -0x4(%rbp), %rcx
leaq 0x24663(%rip), %rax     # 0x282a0
movq (%rax,%rcx,8), %rdi
callq 0x3b70
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x3bf7
leaq 0x1dd72(%rip), %rdi     # 0x219d3
callq 0x3ab0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl 0x24946(%rip), %edx     # 0x285c8
movl $0x1, %eax
movl $0x2, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x245f8(%rip)     # 0x28290
leaq 0x1c61c(%rip), %rdi     # 0x202bb
callq 0x3ab0
movl $0x0, 0x24916(%rip)     # 0x285c4
movq -0x8(%rbp), %rdi
movq $-0x8, %rsi
callq 0x34b0
movl $0x2, %edi
callq 0x3b10
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 0x244a5(%rip), %rdi     # 0x28180
movl 0x24903(%rip), %eax     # 0x285e4
addl 0x24901(%rip), %eax     # 0x285e8
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x3190
movq %rax, 0x24486(%rip)     # 0x28180
movq 0x248cf(%rip), %rdi     # 0x285d0
movl 0x248dd(%rip), %eax     # 0x285e4
addl 0x248db(%rip), %eax     # 0x285e8
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x3190
movq %rax, 0x248b0(%rip)     # 0x285d0
movq 0x248c9(%rip), %rdi     # 0x285f0
movl 0x248b7(%rip), %eax     # 0x285e4
addl 0x248b5(%rip), %eax     # 0x285e8
movslq %eax, %rsi
callq 0x3190
movq %rax, 0x248ae(%rip)     # 0x285f0
cmpq $0x0, 0x24436(%rip)     # 0x28180
je 0x3d60
cmpq $0x0, 0x2487c(%rip)     # 0x285d0
je 0x3d60
cmpq $0x0, 0x24892(%rip)     # 0x285f0
jne 0x3d6c
leaq 0x1c55b(%rip), %rdi     # 0x202c2
callq 0x3c70
movq 0x2440d(%rip), %rdi     # 0x28180
movslq 0x2486a(%rip), %rax     # 0x285e4
shlq $0x3, %rax
addq %rax, %rdi
movslq 0x24860(%rip), %rdx     # 0x285e8
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x30e0
movq 0x24836(%rip), %rdi     # 0x285d0
movslq 0x24843(%rip), %rax     # 0x285e4
shlq $0x3, %rax
addq %rax, %rdi
movslq 0x24839(%rip), %rdx     # 0x285e8
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x30e0
movq 0x2482f(%rip), %rdi     # 0x285f0
movslq 0x2481c(%rip), %rax     # 0x285e4
addq %rax, %rdi
movslq 0x24816(%rip), %rdx     # 0x285e8
xorl %esi, %esi
callq 0x30e0
movl 0x24809(%rip), %eax     # 0x285e8
addl 0x247ff(%rip), %eax     # 0x285e4
movl %eax, 0x247f9(%rip)     # 0x285e4
imull $0x3, 0x247f6(%rip), %eax # 0x285e8
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x247e8(%rip)     # 0x285e8
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq 0x247dd(%rip), %rdi     # 0x285f8
movl 0x247df(%rip), %eax     # 0x28600
addl 0x247dd(%rip), %eax     # 0x28604
movslq %eax, %rsi
shlq $0x3, %rsi
callq 0x3190
movq %rax, 0x247be(%rip)     # 0x285f8
cmpq $0x0, 0x247b6(%rip)     # 0x285f8
jne 0x3e50
leaq 0x1d6d7(%rip), %rdi     # 0x21522
callq 0x3c70
movq 0x247a1(%rip), %rdi     # 0x285f8
movslq 0x247a2(%rip), %rax     # 0x28600
shlq $0x3, %rax
addq %rax, %rdi
movslq 0x24798(%rip), %rdx     # 0x28604
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x30e0
movl 0x24787(%rip), %eax     # 0x28604
addl 0x2477d(%rip), %eax     # 0x28600
movl %eax, 0x24777(%rip)     # 0x28600
imull $0x3, 0x24774(%rip), %eax # 0x28604
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x24766(%rip)     # 0x28604
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movl $0x0, -0x4(%rbp)
movslq -0x4(%rbp), %rax
cmpq 0x240a2(%rip), %rax     # 0x28688
jge 0x4638
movl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
movq 0x24003(%rip), %rax     # 0x285f8
movl -0x4(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl %eax, -0x8(%rbp)
movslq -0x8(%rbp), %rcx
addq $0x8, %rcx
subq $0x1, %rcx
shrq $0x3, %rcx
addq $0x3, %rcx
movslq -0x4(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x4(%rbp)
movq 0x23fce(%rip), %rax     # 0x285f8
movslq -0xc(%rbp), %rcx
movq $-0x1, (%rax,%rcx,8)
jmp 0x45db
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x80, %rsp
callq 0x45d0
callq 0x43d0
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0x10(%rbp), %rax
cmpq 0x2401a(%rip), %rax     # 0x28688
jge 0x4731
movq 0x23f7d(%rip), %rax     # 0x285f8
movl -0x10(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl %eax, -0x4(%rbp)
movslq -0x4(%rbp), %rax
addq $0x8, %rax
subq $0x1, %rax
shrq $0x3, %rax
addq $0x3, %rax
movl %eax, -0x8(%rbp)
movq 0x23f4f(%rip), %rax     # 0x285f8
movl -0x10(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
cmpq $-0x1, (%rax,%rcx,8)
je 0x4723
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
je 0x471a
movq 0x23f30(%rip), %rdi     # 0x285f8
movslq -0xc(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x23f1e(%rip), %rsi     # 0x285f8
movslq -0x10(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movslq -0x8(%rbp), %rdx
shlq $0x3, %rdx
callq 0x31a0
movl -0xc(%rbp), %eax
addl $0x3, %eax
movslq %eax, %rdx
movq 0x23ece(%rip), %rax     # 0x285d0
movq 0x23eef(%rip), %rcx     # 0x285f8
movl -0xc(%rbp), %esi
addl $0x0, %esi
movslq %esi, %rsi
movq (%rcx,%rsi,8), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x8(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x4663
movq 0x23f50(%rip), %rax     # 0x28688
movslq -0xc(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x8(%rbp)
cmpl $0x1, 0x239b7(%rip)     # 0x28100
jle 0x4775
leaq -0x80(%rbp), %rdi
movl -0x8(%rbp), %edx
leaq 0x1bc1c(%rip), %rsi     # 0x20375
movb $0x0, %al
callq 0x3200
leaq -0x80(%rbp), %rdi
callq 0x3ab0
leaq 0x1d263(%rip), %rdi     # 0x219d3
callq 0x3ab0
movslq -0xc(%rbp), %rax
movq %rax, 0x23f08(%rip)     # 0x28688
movl -0x8(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq 0x23c56(%rip), %rax     # 0x285d0
movq 0x23c4f(%rip), %rcx     # 0x285d0
movq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq $-0x1, (%rax,%rcx,8)
je 0x49bd
leaq -0x80(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x1ba64(%rip), %rsi     # 0x20403
movb $0x0, %al
callq 0x3200
leaq -0x80(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x34b0
movq $0x0, -0x8(%rbp)
jmp 0x49db
movq 0x237bc(%rip), %rax     # 0x28180
movq 0x23c05(%rip), %rcx     # 0x285d0
movq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: bignum_negate
cell bignum_negate(cell a) {
	cell	n;

	n = new_atom(-cadr(a), cddr(a));
	n = new_atom(T_INTEGER, n);
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x236fd(%rip), %rax     # 0x28180
movq 0x23b46(%rip), %rcx     # 0x285d0
movq -0x8(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
xorl %edx, %edx
movl %edx, %edi
subq (%rax,%rcx,8), %rdi
movq 0x23b2f(%rip), %rax     # 0x285d0
movq 0x23b28(%rip), %rcx     # 0x285d0
movq -0x8(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rsi
movl $0x1, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq $-0x18, %rdi
movl $0x1, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $-0x1, -0x10(%rbp)
cmpq $-0x1, -0x8(%rbp)
je 0x4b41
movq 0x2366e(%rip), %rax     # 0x28180
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x3780
movq %rax, -0x10(%rbp)
movq 0x23a9d(%rip), %rax     # 0x285d0
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x4b04
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0x232b5(%rip)     # 0x28120
movq -0x8(%rbp), %rdi
movq 0x232c2(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x232b4(%rip)     # 0x28138
movq -0x10(%rbp), %rdi
movq 0x232a9(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x2329b(%rip)     # 0x28138
movq $-0x1, 0x23278(%rip) # 0x28120
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4b50
movq %rax, -0x8(%rbp)
movl $0x2, %edi
callq 0x3950
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0x23235(%rip)     # 0x28120
movq -0x8(%rbp), %rdi
movq 0x23242(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x23234(%rip)     # 0x28138
movq -0x10(%rbp), %rdi
movq 0x23229(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x2321b(%rip)     # 0x28138
movq $-0x1, 0x231f8(%rip) # 0x28120
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x5270
movq %rax, -0x8(%rbp)
movl $0x2, %edi
callq 0x3950
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $-0x1, -0x8(%rbp)
je 0x5194
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq 0x2344a(%rip), %rax     # 0x285d0
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x516f
movl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq 0x2341d(%rip), %rax     # 0x285d0
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq 0x2340a(%rip), %rax     # 0x285d0
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $-0x1, -0x10(%rbp)
movb %al, -0x19(%rbp)
je 0x51e9
cmpq $-0x1, -0x18(%rbp)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x51f2
jmp 0x5243
movq 0x22f87(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x22f78(%rip), %rcx     # 0x28180
movq -0x18(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
je 0x521b
movl $0x0, -0x4(%rbp)
jmp 0x5265
movq 0x233ae(%rip), %rax     # 0x285d0
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq 0x2339b(%rip), %rax     # 0x285d0
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0x51d2
xorl %eax, %eax
cmpq $-0x1, -0x10(%rbp)
movb %al, -0x1a(%rbp)
jne 0x525a
cmpq $-0x1, -0x18(%rbp)
sete %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq 0x22fea(%rip), %rax     # 0x285d0
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x4af0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq 0x22b36(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x22b28(%rip)     # 0x28138
movl -0xc(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq $-0x1, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq 0x22b0f(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x22b01(%rip)     # 0x28138
cmpq $-0x1, -0x8(%rbp)
je 0x5710
movq 0x22b37(%rip), %rax     # 0x28180
movq -0x8(%rbp), %rcx
cmpq $0x5f5e100, (%rax,%rcx,8) # imm = 0x5F5E100
jl 0x56aa
movq 0x22b22(%rip), %rax     # 0x28180
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x5f5e100, %ecx        # imm = 0x5F5E100
cqto
idivq %rcx
movq %rax, -0x20(%rbp)
movq 0x22b05(%rip), %rax     # 0x28180
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x5f5e100, %ecx        # imm = 0x5F5E100
cqto
idivq %rcx
imulq $0xa, %rdx, %rax
movq %rax, -0x18(%rbp)
movslq -0x2c(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movl %eax, -0x2c(%rbp)
jmp 0x56cc
movq 0x22acf(%rip), %rax     # 0x28180
movq -0x8(%rbp), %rcx
imulq $0xa, (%rax,%rcx,8), %rax
movslq -0x2c(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0x3780
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
movq 0x22a93(%rip), %rax     # 0x28180
movq 0x22a44(%rip), %rcx     # 0x28138
movq %rdx, (%rax,%rcx,8)
movq 0x22ed1(%rip), %rax     # 0x285d0
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x5637
cmpl $0x0, -0x2c(%rbp)
je 0x572c
movslq -0x2c(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl $0x1, %edx
callq 0x3780
movq %rax, -0x28(%rbp)
movl $0x2, %edi
callq 0x3950
movq -0x28(%rbp), %rsi
movq $-0x18, %rdi
movl $0x1, %edx
callq 0x3780
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq 0x22e5d(%rip), %rax     # 0x285d0
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq 0x229ae(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x229a0(%rip)     # 0x28138
movl $0x0, -0x24(%rbp)
movq $-0x1, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq 0x22986(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x22978(%rip)     # 0x28138
cmpq $-0x1, -0x8(%rbp)
je 0x5863
movq 0x229ae(%rip), %rax     # 0x28180
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rdx, -0x18(%rbp)
movq 0x22991(%rip), %rax     # 0x28180
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x10(%rbp)
movslq -0x24(%rbp), %rax
imulq $0x5f5e100, %rax, %rax  # imm = 0x5F5E100
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0x3780
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
movq 0x22940(%rip), %rax     # 0x28180
movq 0x228f1(%rip), %rcx     # 0x28138
movq %rdx, (%rax,%rcx,8)
movq 0x22d7e(%rip), %rax     # 0x285d0
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x57c0
movq -0x20(%rbp), %rdi
callq 0x4af0
movq %rax, -0x20(%rbp)
movq 0x22909(%rip), %rax     # 0x28180
movq -0x20(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x58a7
movq 0x22d47(%rip), %rax     # 0x285d0
movq -0x20(%rbp), %rcx
cmpq $-0x1, (%rax,%rcx,8)
je 0x58a7
movq 0x22d35(%rip), %rax     # 0x285d0
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movq $-0x18, %rdi
movl $0x1, %edx
callq 0x3780
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
movq 0x228b5(%rip), %rax     # 0x28180
movq 0x22866(%rip), %rcx     # 0x28138
movq %rdx, (%rax,%rcx,8)
movslq -0x24(%rbp), %rdi
callq 0x3740
movl %eax, -0x24(%rbp)
movl $0x2, %edi
callq 0x3950
movq -0x20(%rbp), %rdi
movslq -0x24(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq 0x225b5(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x225a7(%rip)     # 0x28138
movl $0x1, %edi
callq 0x3740
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq 0x2258e(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x22580(%rip)     # 0x28138
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq 0x2256d(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x2255f(%rip)     # 0x28138
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq 0x2254c(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x2253e(%rip)     # 0x28138
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x4f50
cmpl $0x0, %eax
je 0x5cd5
movq -0x18(%rbp), %rdx
movq %rdx, -0x28(%rbp)
movq 0x22561(%rip), %rax     # 0x28180
movq 0x229aa(%rip), %rcx     # 0x285d0
movq 0x229a3(%rip), %rsi     # 0x285d0
movq 0x2299c(%rip), %rdi     # 0x285d0
movq 0x224fd(%rip), %r8      # 0x28138
movq (%rdi,%r8,8), %rdi
movq (%rsi,%rdi,8), %rsi
movq (%rcx,%rsi,8), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rdx
movq %rdx, -0x30(%rbp)
movq 0x22526(%rip), %rax     # 0x28180
movq 0x2296f(%rip), %rcx     # 0x285d0
movq 0x22968(%rip), %rsi     # 0x285d0
movq 0x224c9(%rip), %rdi     # 0x28138
movq (%rsi,%rdi,8), %rsi
movq (%rcx,%rsi,8), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x55d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
movq 0x224eb(%rip), %rax     # 0x28180
movq 0x22934(%rip), %rcx     # 0x285d0
movq 0x22495(%rip), %rsi     # 0x28138
movq (%rcx,%rsi,8), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x55d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdx
movq 0x224bb(%rip), %rax     # 0x28180
movq 0x2246c(%rip), %rcx     # 0x28138
movq %rdx, (%rax,%rcx,8)
jmp 0x5bfa
movl $0x4, %edi
callq 0x3950
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0x3780
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq 0x21ef5(%rip), %rax     # 0x28180
movq 0x2233e(%rip), %rcx     # 0x285d0
movq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x62d4
movq 0x22328(%rip), %rax     # 0x285d0
movq 0x22321(%rip), %rcx     # 0x285d0
movq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq $-0x1, (%rax,%rcx,8)
jne 0x62d4
movq -0x10(%rbp), %rsi
leaq 0x1a157(%rip), %rdi     # 0x20420
callq 0x34b0
movq %rax, -0x8(%rbp)
jmp 0x633f
movq -0x20(%rbp), %rax
movq %rax, 0x21e41(%rip)     # 0x28120
movq -0x18(%rbp), %rdi
movq 0x21e4e(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x21e40(%rip)     # 0x28138
movq -0x20(%rbp), %rdi
movq 0x21e35(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x21e27(%rip)     # 0x28138
movq $-0x1, 0x21e04(%rip) # 0x28120
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x5d00
movq %rax, -0x18(%rbp)
movl $0x2, %edi
callq 0x3950
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: 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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x3780
movq %rax, -0x20(%rbp)
movslq -0x4(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl $0x1, %edx
callq 0x3780
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movq $-0x1f, %rdi
movl $0x1, %edx
callq 0x3780
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq 0x21dba(%rip), %rax     # 0x28180
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x63fd
movq -0x18(%rbp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x63d9
cmpl $0x0, -0xc(%rbp)
jne 0x640d
movl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6413
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0xc(%rbp)
movq 0x221b0(%rip), %rax     # 0x285d0
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
cmpq $-0x1, -0x8(%rbp)
je 0x6451
movl -0xc(%rbp), %eax
addl $0x9, %eax
movl %eax, -0xc(%rbp)
movq 0x2218d(%rip), %rax     # 0x285d0
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x642c
movslq -0xc(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $-0x1, -0x10(%rbp)
jne 0x6780
movq $-0x1, -0x8(%rbp)
jmp 0x6865
movq 0x21e69(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %edx
movq $-0x1, %rsi
movq %rsi, %rdi
callq 0x3780
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq 0x2198b(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x2197d(%rip)     # 0x28138
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $-0x1, -0x10(%rbp)
je 0x6853
movq 0x219ab(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x2199c(%rip), %rax     # 0x28180
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x21ddd(%rip), %rax     # 0x285d0
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
cmpq $-0x1, -0x10(%rbp)
je 0x684e
movq 0x21de3(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %edx
movq $-0x1, %rsi
movq %rsi, %rdi
callq 0x3780
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
movq 0x21d9d(%rip), %rax     # 0x285d0
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x21d8e(%rip), %rax     # 0x285d0
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0x67c3
movl $0x1, %edi
callq 0x3950
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6760
movq %rax, -0x20(%rbp)
movq 0x218f0(%rip), %rax     # 0x28180
movq 0x21d39(%rip), %rcx     # 0x285d0
movq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rdx
movq %rdx, %rax
negq %rax
cmovnsq %rax, %rdx
movq 0x218cc(%rip), %rax     # 0x28180
movq 0x21d15(%rip), %rcx     # 0x285d0
movq -0x20(%rbp), %rsi
movq (%rcx,%rsi,8), %rcx
movq %rdx, (%rax,%rcx,8)
movl $0x0, -0xc(%rbp)
movq 0x21cfb(%rip), %rax     # 0x285d0
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x5160
cmpl $0x4, %eax
jle 0x693a
movq 0x21ce2(%rip), %rax     # 0x285d0
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x63b0
movl %eax, -0x14(%rbp)
cmpl $0x24, -0x14(%rbp)
jle 0x6938
movq -0x20(%rbp), %rdi
callq 0x5760
movq %rax, -0x20(%rbp)
movq 0x21868(%rip), %rax     # 0x28180
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x68fe
jmp 0x693a
movq 0x2183f(%rip), %rax     # 0x28180
movq 0x21c88(%rip), %rcx     # 0x285d0
movq -0x8(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovll %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %edi
movslq -0xc(%rbp), %rsi
movq 0x21c5d(%rip), %rax     # 0x285d0
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x6350
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6460
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0x6ebe
movq 0x21766(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x6ebe
movq 0x212df(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
cmpq $-0x18, (%rax,%rcx,8)
jne 0x6ebe
movq -0x10(%rbp), %rdi
callq 0x49f0
movq %rax, -0x8(%rbp)
jmp 0x701d
movq 0x212bb(%rip), %rax     # 0x28180
movq 0x21704(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x7015
movq 0x21293(%rip), %rax     # 0x28180
movq 0x216dc(%rip), %rcx     # 0x285d0
movq 0x216d5(%rip), %rdx     # 0x285d0
movq 0x216ce(%rip), %rsi     # 0x285d0
movq -0x10(%rbp), %rdi
movq (%rsi,%rdi,8), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x6f50
movq 0x216b0(%rip), %rax     # 0x285d0
movq 0x216a9(%rip), %rcx     # 0x285d0
movq 0x216a2(%rip), %rdx     # 0x285d0
movq 0x2169b(%rip), %rsi     # 0x285d0
movq -0x10(%rbp), %rdi
movq (%rsi,%rdi,8), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
cmpq $-0x1, (%rax,%rcx,8)
je 0x7015
movq 0x21229(%rip), %rax     # 0x28180
movq 0x21672(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x6f98
movq 0x21205(%rip), %rax     # 0x28180
movq 0x2164e(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
andq $-0x2, %rax
movq %rax, -0x18(%rbp)
jmp 0x6fba
movq 0x211e1(%rip), %rax     # 0x28180
movq 0x2162a(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
orq $0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl %eax, %edi
movq 0x211b9(%rip), %rax     # 0x28180
movq 0x21602(%rip), %rcx     # 0x285d0
movq 0x215fb(%rip), %rdx     # 0x285d0
movq -0x10(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x215e4(%rip), %rax     # 0x285d0
movq 0x215dd(%rip), %rcx     # 0x285d0
movq 0x215d6(%rip), %rdx     # 0x285d0
movq -0x10(%rbp), %r8
movq (%rdx,%r8,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x6350
movq %rax, -0x8(%rbp)
jmp 0x701d
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq $-0x18, %rdi
movl $0x1, %edx
callq 0x3780
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq 0x210d8(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x210ca(%rip)     # 0x28138
movq -0x8(%rbp), %rdi
callq 0x5760
movq %rax, -0x8(%rbp)
movq 0x210fe(%rip), %rax     # 0x28180
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movl $0x1, %edi
callq 0x3950
movq 0x21531(%rip), %rax     # 0x285d0
movq -0x8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: scale_mantissa
cell scale_mantissa(cell r, cell desired_e, int max_size) {
	int	dgs;
	cell	n, e;

	dgs = count_digits(x_real_mantissa(r));
	if (max_size && (max_size - dgs < x_real_exponent(r) - desired_e))
		return NIL;
	n = new_atom(T_INTEGER, flat_copy(x_real_mantissa(r)));
	save(n);
	e = x_real_exponent(r);
	while (e > desired_e) {
		n = bignum_shift_left(n, 0);
		car(Stack) = n;
		e--;
	}
	unsave(1);
	return make_real(x_real_flags(r), e, cdr(n));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq 0x21506(%rip), %rax     # 0x285d0
movq 0x214ff(%rip), %rcx     # 0x285d0
movq 0x214f8(%rip), %rdx     # 0x285d0
movq -0x10(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x63b0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x7139
movl -0x1c(%rbp), %eax
subl -0x20(%rbp), %eax
cltq
movq 0x2107b(%rip), %rcx     # 0x28180
movq 0x214c4(%rip), %rdx     # 0x285d0
movq 0x214bd(%rip), %rsi     # 0x285d0
movq -0x10(%rbp), %rdi
movq (%rsi,%rdi,8), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
subq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jge 0x7139
movq $-0x1, -0x8(%rbp)
jmp 0x723c
movq 0x21490(%rip), %rax     # 0x285d0
movq 0x21489(%rip), %rcx     # 0x285d0
movq 0x21482(%rip), %rdx     # 0x285d0
movq -0x10(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x6760
movq %rax, %rsi
movq $-0x18, %rdi
movl $0x1, %edx
callq 0x3780
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq 0x20fb2(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x20fa4(%rip)     # 0x28138
movq 0x20fe5(%rip), %rax     # 0x28180
movq 0x2142e(%rip), %rcx     # 0x285d0
movq 0x21427(%rip), %rdx     # 0x285d0
movq -0x10(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq -0x18(%rbp), %rax
jle 0x71fa
movq -0x28(%rbp), %rdi
xorl %esi, %esi
callq 0x55d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdx
movq 0x20f9f(%rip), %rax     # 0x28180
movq 0x20f50(%rip), %rcx     # 0x28138
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x71bd
movl $0x1, %edi
callq 0x3950
movq 0x20f75(%rip), %rax     # 0x28180
movq 0x213be(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %edi
movq -0x30(%rbp), %rsi
movq 0x213a5(%rip), %rax     # 0x285d0
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x6350
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: autoscale
void autoscale(cell *pa, cell *pb) {
	if (x_real_exponent(*pa) < x_real_exponent(*pb)) {
		*pb = scale_mantissa(*pb, x_real_exponent(*pa),
					MANTISSA_SIZE*2);
		return;
	}
	if (x_real_exponent(*pa) > x_real_exponent(*pb)) {
		*pa = scale_mantissa(*pa, x_real_exponent(*pb),
					MANTISSA_SIZE*2);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x20f19(%rip), %rax     # 0x28180
movq 0x21362(%rip), %rcx     # 0x285d0
movq 0x2135b(%rip), %rdx     # 0x285d0
movq -0x8(%rbp), %rsi
movq (%rsi), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20ef1(%rip), %rcx     # 0x28180
movq 0x2133a(%rip), %rdx     # 0x285d0
movq 0x21333(%rip), %rsi     # 0x285d0
movq -0x10(%rbp), %rdi
movq (%rdi), %rdi
movq (%rsi,%rdi,8), %rsi
movq (%rdx,%rsi,8), %rdx
cmpq (%rcx,%rdx,8), %rax
jge 0x72fa
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq 0x20ec0(%rip), %rax     # 0x28180
movq 0x21309(%rip), %rcx     # 0x285d0
movq 0x21302(%rip), %rdx     # 0x285d0
movq -0x8(%rbp), %rsi
movq (%rsi), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rsi
movl $0x48, %edx
callq 0x70b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x738f
movq 0x20e7f(%rip), %rax     # 0x28180
movq 0x212c8(%rip), %rcx     # 0x285d0
movq 0x212c1(%rip), %rdx     # 0x285d0
movq -0x8(%rbp), %rsi
movq (%rsi), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
movq 0x20e57(%rip), %rcx     # 0x28180
movq 0x212a0(%rip), %rdx     # 0x285d0
movq 0x21299(%rip), %rsi     # 0x285d0
movq -0x10(%rbp), %rdi
movq (%rdi), %rdi
movq (%rsi,%rdi,8), %rsi
movq (%rdx,%rsi,8), %rdx
cmpq (%rcx,%rdx,8), %rax
jle 0x738f
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq 0x20e26(%rip), %rax     # 0x28180
movq 0x2126f(%rip), %rcx     # 0x285d0
movq 0x21268(%rip), %rdx     # 0x285d0
movq -0x10(%rbp), %rsi
movq (%rsi), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rsi
movl $0x48, %edx
callq 0x70b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/azhai[P]mlite/mlite.c
// Function: real_subtract
cell real_subtract(cell a, cell b) {
	cell	r;

	if (integer_p(b))
		b = bignum_negate(b);
	else
		b = x_real_negate(b);
	save(b);
	r = real_add(a, b);
	unsave(1);
	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0x8912
movq 0x1fd12(%rip), %rax     # 0x285f0
movq -0x10(%rbp), %rcx
movsbl (%rax,%rcx), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x8912
movq 0x1f88b(%rip), %rax     # 0x28180
movq -0x10(%rbp), %rcx
cmpq $-0x18, (%rax,%rcx,8)
jne 0x8912
movq -0x10(%rbp), %rdi
callq 0x4a70
movq %rax, -0x10(%rbp)
jmp 0x89d5
movq 0x1f867(%rip), %rax     # 0x28180
movq 0x1fcb0(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x895a
movq 0x1f843(%rip), %rax     # 0x28180
movq 0x1fc8c(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
andq $-0x2, %rax
movq %rax, -0x20(%rbp)
jmp 0x897c
movq 0x1f81f(%rip), %rax     # 0x28180
movq 0x1fc68(%rip), %rcx     # 0x285d0
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rax
orq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl %eax, %edi
movq 0x1f7f7(%rip), %rax     # 0x28180
movq 0x1fc40(%rip), %rcx     # 0x285d0
movq 0x1fc39(%rip), %rdx     # 0x285d0
movq -0x10(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x1fc22(%rip), %rax     # 0x285d0
movq 0x1fc1b(%rip), %rcx     # 0x285d0
movq 0x1fc14(%rip), %rdx     # 0x285d0
movq -0x10(%rbp), %r8
movq (%rdx,%r8,8), %rdx
movq (%rcx,%rdx,8), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x6350
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq 0x1f758(%rip), %rsi     # 0x28138
xorl %edx, %edx
callq 0x3780
movq %rax, 0x1f74a(%rip)     # 0x28138
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x82a0
movq %rax, -0x18(%rbp)
movl $0x1, %edi
callq 0x3950
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)