LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: sinfunc_sum
void
sinfunc_sum(struct atom *p1)
{
	struct atom *p2, *p3;
	p2 = cdr(p1);
	while (iscons(p2)) {
		push_integer(2);
		push(car(p2));
		multiply();
		push_symbol(PI);
		divide();
		p3 = pop();
		if (isinteger(p3)) {
			push(p1);
			push(car(p2));
			subtract();
			p3 = pop();
			push(p3);
			sinfunc();
			push(car(p2));
			cosfunc();
			multiply();
			push(p3);
			cosfunc();
			push(car(p2));
			sinfunc();
			multiply();
			add();
			return;
		}
		p2 = cdr(p2);
	}
	push_symbol(SIN);
	push(p1);
	list(2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rax
leaq 0x219c6(%rip), %r14     # 0x40a00
cmovneq %r14, %rax
movq (%rax), %r15
cmpb $0x1, 0x10(%r15)
jne 0x1f0d8
leaq 0x10(%r15), %r12
movl $0x2, %edi
callq 0xacbe
cmpb $0x1, 0x10(%r15)
movq %r14, %rax
cmoveq %r15, %rax
movq (%rax), %rdi
callq 0x8b01
movl $0x2, %edi
callq 0xa8bb
movq 0x21fd1(%rip), %rdi     # 0x41050
callq 0x8b01
movq 0xf2365(%rip), %rdi     # 0x1113f0
callq 0x8b01
callq 0xa234
movl $0x2, %edi
callq 0xa8bb
callq 0x8b78
cmpb $0x4, 0x10(%rax)
jne 0x1f0b9
movq 0x8(%rax), %rax
cmpl $0x1, -0x4(%rax)
jne 0x1f0b9
cmpl $0x1, (%rax)
je 0x1f0fe
addq $0x8, %r15
cmpb $0x1, (%r12)
cmovneq %r14, %r15
movq (%r15), %r15
leaq 0x10(%r15), %r12
cmpb $0x1, 0x10(%r15)
je 0x1f050
movq 0x228e1(%rip), %rdi     # 0x419c0
callq 0x8b01
movq %rbx, %rdi
callq 0x8b01
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8ad9
movq %rbx, %rdi
callq 0x8b01
cmpb $0x1, (%r12)
movq %r14, %rax
cmoveq %r15, %rax
movq (%rax), %rdi
callq 0x8b01
movq 0xf22cf(%rip), %rdi     # 0x1113f0
callq 0x8b01
movl $0x2, %edi
callq 0xa8bb
movl $0x2, %edi
callq 0xa975
callq 0x8b78
movq %rax, %rbx
movq %rax, %rdi
callq 0x8b01
callq 0xfade
cmpb $0x1, (%r12)
movq %r14, %rax
cmoveq %r15, %rax
movq (%rax), %rdi
callq 0x8b01
callq 0xf2ab
movl $0x2, %edi
callq 0xa8bb
movq %rbx, %rdi
callq 0x8b01
callq 0xf2ab
cmpb $0x1, (%r12)
cmoveq %r15, %r14
movq (%r14), %rdi
callq 0x8b01
callq 0xfade
movl $0x2, %edi
callq 0xa8bb
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa975
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: tanfunc_sum
void
tanfunc_sum(struct atom *p1)
{
	struct atom *p2, *p3;
	p2 = cdr(p1);
	while (iscons(p2)) {
		push(car(p2));
		push_symbol(PI);
		divide();
		p3 = pop();
		if (isinteger(p3)) {
			push(p1);
			push(car(p2));
			subtract();
			tanfunc();
			return;
		}
		p2 = cdr(p2);
	}
	push_symbol(TAN);
	push(p1);
	list(2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rax
leaq 0x20db7(%rip), %r14     # 0x40a00
cmovneq %r14, %rax
movq (%rax), %r15
cmpb $0x1, 0x10(%r15)
jne 0x1fca9
leaq 0x10(%r15), %r12
movq (%r15), %rdi
callq 0x8b01
movq 0x213e6(%rip), %rdi     # 0x41050
callq 0x8b01
callq 0xd9a4
callq 0x8b78
cmpb $0x4, 0x10(%rax)
jne 0x1fc8e
movq 0x8(%rax), %rax
cmpl $0x1, -0x4(%rax)
jne 0x1fc8e
cmpl $0x1, (%rax)
je 0x1fccf
addq $0x8, %r15
cmpb $0x1, (%r12)
cmovneq %r14, %r15
movq (%r15), %r15
leaq 0x10(%r15), %r12
cmpb $0x1, 0x10(%r15)
je 0x1fc5b
movq 0x22020(%rip), %rdi     # 0x41cd0
callq 0x8b01
movq %rbx, %rdi
callq 0x8b01
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8ad9
movq %rbx, %rdi
callq 0x8b01
cmpb $0x1, (%r12)
cmoveq %r15, %r14
movq (%r14), %rdi
callq 0x8b01
callq 0xba6d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1f82a
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: tanhfunc
void
tanhfunc(void)
{
	int i, n;
	double d;
	struct atom *p1;

	p1 = pop();

	if (istensor(p1)) {
		p1 = copy_tensor(p1);
		n = p1->u.tensor->nelem;
		for (i = 0; i < n; i++) {
			push(p1->u.tensor->elem[i]);
			tanhfunc();
			p1->u.tensor->elem[i] = pop();
		}
		push(p1);
		return;
	}

	if (isdouble(p1)) {
		push(p1);
		d = pop_double();
		d = tanh(d);
		push_double(d);
		return;
	}

	if (isdoublez(p1)) {
		push(p1);
		sinhfunc();
		push(p1);
		coshfunc();
		divide();
		return;
	}

	if (iszero(p1)) {
		push_integer(0);
		return;
	}

	// tanh(-x) = -tanh(x)

	if (isnegativeterm(p1)) {
		push(p1);
		negate();
		tanhfunc();
		negate();
		return;
	}

	if (car(p1) == symbol(ARCTANH)) {
		push(cadr(p1));
		return;
	}

	push_symbol(TANH);
	push(p1);
	list(2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x8b78
movq %rax, %rbx
movzbl 0x10(%rax), %r14d
cmpl $0x5, %r14d
je 0x1fd9c
cmpl $0x7, %r14d
jne 0x1fdd7
movq %rbx, %rdi
callq 0x953d
movq %rax, %rbx
movq (%rax), %rax
movslq 0x64(%rax), %r14
testq %r14, %r14
jle 0x1fd97
xorl %r15d, %r15d
movq (%rbx), %rax
movq 0x68(%rax,%r15,8), %rdi
callq 0x8b01
callq 0x1fd2f
callq 0x8b78
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x1fd70
movq %rbx, %rdi
jmp 0x1fdc8
movq %rbx, %rdi
callq 0x8b01
callq 0x9086
callq 0x7310
movsd %xmm0, -0x20(%rbp)
callq 0x74ec
movb $0x5, 0x10(%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8b01
movq %rbx, %rdi
callq 0xc3a9
movq %rbx, %rdi
testl %eax, %eax
je 0x1fe0c
callq 0x8b01
callq 0x11c53
movq %rbx, %rdi
callq 0x8b01
callq 0x10069
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xd9a4
callq 0xaece
testl %eax, %eax
je 0x1fe1e
movq 0x1e324(%rip), %rdi     # 0x3e140
jmp 0x1fdc8
movq %rbx, %rdi
callq 0xa813
testl %eax, %eax
je 0x1fe6d
movq %rbx, %rdi
callq 0x8b01
movq 0xf15b7(%rip), %rdi     # 0x1113f0
callq 0x8b01
movl $0x2, %edi
callq 0xa8bb
callq 0x1fd2f
movq 0xf159c(%rip), %rdi     # 0x1113f0
callq 0x8b01
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa8bb
cmpb $0x1, %r14b
leaq 0x20b88(%rip), %rax     # 0x40a00
movq %rax, %rcx
cmoveq %rbx, %rcx
movq (%rcx), %rcx
cmpq 0x1e317(%rip), %rcx     # 0x3e1a0
je 0x1feb3
movq 0x21e46(%rip), %rdi     # 0x41cd8
callq 0x8b01
movq %rbx, %rdi
callq 0x8b01
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8ad9
addq $0x8, %rbx
cmpb $0x1, %r14b
cmovneq %rax, %rbx
movq (%rbx), %rcx
cmpb $0x1, 0x10(%rcx)
cmoveq %rcx, %rax
movq (%rax), %rdi
jmp 0x1fdc8
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: promote_tensor
void
promote_tensor(void)
{
	int i, j, k, ndim1, ndim2, nelem1, nelem2;
	struct atom *p1, *p2, *p3;

	p1 = pop();

	if (!istensor(p1)) {
		push(p1);
		return;
	}

	ndim1 = p1->u.tensor->ndim;
	nelem1 = p1->u.tensor->nelem;

	// check

	p2 = p1->u.tensor->elem[0];

	for (i = 1; i < nelem1; i++) {
		p3 = p1->u.tensor->elem[i];
		if (!compatible_dimensions(p2, p3))
			stopf("tensor dimensions");
	}

	if (!istensor(p2)) {
		push(p1);
		return; // all elements are scalars
	}

	ndim2 = p2->u.tensor->ndim;
	nelem2 = p2->u.tensor->nelem;

	if (ndim1 + ndim2 > MAXDIM)
		stopf("rank exceeds max");

	// alloc

	p3 = alloc_tensor(nelem1 * nelem2);

	// merge dimensions

	k = 0;

	for (i = 0; i < ndim1; i++)
		p3->u.tensor->dim[k++] = p1->u.tensor->dim[i];

	for (i = 0; i < ndim2; i++)
		p3->u.tensor->dim[k++] = p2->u.tensor->dim[i];

	p3->u.tensor->ndim = ndim1 + ndim2;

	// merge elements

	k = 0;

	for (i = 0; i < nelem1; i++) {
		p2 = p1->u.tensor->elem[i];
		for (j = 0; j < nelem2; j++)
			p3->u.tensor->elem[k++] = p2->u.tensor->elem[j];
	}

	push(p3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
callq 0x8b78
movq %rax, %rbx
cmpb $0x7, 0x10(%rax)
jne 0x2033e
movq (%rbx), %rax
movl (%rax), %ecx
movq %rcx, -0x38(%rbp)
movslq 0x64(%rax), %rcx
movq 0x68(%rax), %r14
movq %rcx, -0x40(%rbp)
cmpq $0x2, %rcx
jl 0x2026b
movq (%rbx), %r15
movq -0x40(%rbp), %rax
leaq -0x1(%rax), %r12
xorl %r13d, %r13d
movq 0x70(%r15,%r13,8), %rsi
movq %r14, %rdi
callq 0xae52
testl %eax, %eax
je 0x20354
incq %r13
cmpq %r13, %r12
jne 0x2024e
cmpb $0x7, 0x10(%r14)
jne 0x2033e
movq (%r14), %rax
movl (%rax), %r15d
movq -0x38(%rbp), %rcx
addl %r15d, %ecx
movl %ecx, -0x2c(%rbp)
cmpl $0x19, %ecx
jge 0x20360
movl 0x64(%rax), %r12d
movl %r12d, %edi
movq -0x40(%rbp), %r13
imull %r13d, %edi
callq 0x7850
movq -0x38(%rbp), %rdi
xorl %ecx, %ecx
testl %edi, %edi
jle 0x202c3
movq (%rbx), %rdx
movl 0x4(%rdx,%rcx,4), %edx
movq (%rax), %rsi
movl %edx, 0x4(%rsi,%rcx,4)
incq %rcx
cmpq %rcx, %rdi
jne 0x202ad
testl %r15d, %r15d
jle 0x202ea
leaq 0x4(,%rcx,4), %rcx
xorl %edx, %edx
movq (%r14), %rsi
movl 0x4(%rsi,%rdx,4), %esi
movq (%rax), %rdi
addq %rcx, %rdi
movl %esi, (%rdi,%rdx,4)
incq %rdx
cmpq %rdx, %r15
jne 0x202d2
movq (%rax), %rcx
movl -0x2c(%rbp), %edx
movl %edx, (%rcx)
testl %r13d, %r13d
jle 0x20339
xorl %ecx, %ecx
xorl %edx, %edx
testl %r12d, %r12d
jle 0x20331
movq (%rbx), %rsi
movq 0x68(%rsi,%rcx,8), %rsi
movslq %edx, %rdi
leaq 0x68(,%rdi,8), %r8
xorl %edi, %edi
movq (%rsi), %r9
movq 0x68(%r9,%rdi,8), %r9
movq (%rax), %r10
addq %r8, %r10
movq %r9, (%r10,%rdi,8)
incq %rdi
cmpq %rdi, %r12
jne 0x20315
addl %edi, %edx
incq %rcx
cmpq %r13, %rcx
jne 0x202fb
movq %rax, %rdi
jmp 0x20341
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8b01
leaq 0x5f46(%rip), %rdi      # 0x262a1
callq 0x77c8
leaq 0x6082(%rip), %rdi      # 0x263e9
callq 0x77c8
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_test
void
eval_test(struct atom *p1)
{
	struct atom *p2;
	p1 = cdr(p1);
	while (iscons(p1)) {
		if (!iscons(cdr(p1))) {
			push(car(p1)); // default case
			evalf();
			return;
		}
		push(car(p1));
		evalp();
		p2 = pop();
		if (!iszero(p2)) {
			push(cadr(p1));
			evalf();
			return;
		}
		p1 = cddr(p1);
	}
	push_symbol(NIL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rax
leaq 0x2067a(%rip), %rbx     # 0x40a00
cmovneq %rbx, %rax
movq (%rax), %r14
cmpb $0x1, 0x10(%r14)
jne 0x203ef
leaq 0x10(%r14), %r15
movq (%r14), %rdi
movq 0x8(%r14), %rax
movb 0x10(%rax), %r12b
callq 0x8b01
cmpb $0x1, %r12b
jne 0x20412
addq $0x8, %r14
callq 0x9ae6
callq 0x8b78
movq %rax, %rdi
callq 0xaece
cmpb $0x1, (%r15)
cmovneq %rbx, %r14
movq (%r14), %rcx
movb 0x10(%rcx), %dl
testl %eax, %eax
je 0x20403
addq $0x8, %rcx
cmpb $0x1, %dl
cmovneq %rbx, %rcx
movq (%rcx), %r14
leaq 0x10(%r14), %r15
cmpb $0x1, 0x10(%r14)
je 0x20398
movq 0x2060a(%rip), %rdi     # 0x40a00
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8b01
cmpb $0x1, %dl
cmoveq %rcx, %rbx
movq (%rbx), %rdi
callq 0x8b01
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x95e2
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_testeq
void
eval_testeq(struct atom *p1)
{
	push(cadr(p1));
	evalf();
	push(caddr(p1));
	evalf();
	subtract();
	simplify();
	p1 = pop();
	if (iszero(p1))
		push_integer(1);
	else
		push_integer(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
cmpb $0x1, 0x10(%rdi)
leaq 0x205c5(%rip), %r14     # 0x40a00
movq %r14, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rax
movq (%rax), %rdi
callq 0x8b01
callq 0x95e2
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %r15
movq (%r15), %rax
movb 0x10(%rax), %cl
addq $0x8, %rax
cmpb $0x1, %cl
movq %r14, %rdx
cmoveq %rax, %rdx
movq (%rdx), %rdx
cmpb $0x1, 0x10(%rdx)
jne 0x20490
cmpb $0x1, %cl
leaq 0x20577(%rip), %rcx     # 0x40a00
cmoveq %rax, %rcx
movq (%rcx), %r14
movq (%r14), %rdi
callq 0x8b01
callq 0x95e2
callq 0xba6d
callq 0x1ea91
callq 0x8b78
movq %rax, %rdi
callq 0xaece
testl %eax, %eax
leaq 0x1dc83(%rip), %rax     # 0x3e140
leaq 0xe6614(%rip), %rcx     # 0x106ad8
cmoveq %rax, %rcx
movq (%rcx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8b01
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: cmp_args
int
cmp_args(struct atom *p1)
{
	push(cadr(p1));
	evalf();
	push(caddr(p1));
	evalf();
	subtract();
	floatfunc();
	p1 = pop();
	if (iszero(p1))
		return 0;
	if (!isnum(p1))
		stopf("arithmetic comparison: not a number");
	if (isnegativenumber(p1))
		return -1;
	else
		return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
cmpb $0x1, 0x10(%rdi)
leaq 0x204e4(%rip), %r14     # 0x40a00
movq %r14, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rax
movq (%rax), %rdi
callq 0x8b01
callq 0x95e2
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %r15
movq (%r15), %rax
movb 0x10(%rax), %cl
addq $0x8, %rax
cmpb $0x1, %cl
movq %r14, %rdx
cmoveq %rax, %rdx
movq (%rdx), %rdx
cmpb $0x1, 0x10(%rdx)
jne 0x20571
cmpb $0x1, %cl
leaq 0x20496(%rip), %rcx     # 0x40a00
cmoveq %rax, %rcx
movq (%rcx), %r14
movq (%r14), %rdi
callq 0x8b01
callq 0x95e2
callq 0xba6d
callq 0xa7fa
callq 0x8b78
movq %rax, %rbx
movq %rax, %rdi
callq 0xaece
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x205d7
movb 0x10(%rbx), %al
andb $-0x2, %al
cmpb $0x4, %al
jne 0x205e2
movzbl 0x10(%rbx), %eax
cmpl $0x5, %eax
je 0x205c0
cmpl $0x4, %eax
jne 0x205cd
cmpb $0x1, 0x12(%rbx)
sete %al
jmp 0x205cf
xorpd %xmm0, %xmm0
ucomisd (%rbx), %xmm0
seta %al
jmp 0x205cf
xorl %eax, %eax
movzbl %al, %eax
negl %eax
orl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa56f(%rip), %rdi      # 0x2ab58
callq 0x77c8
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: tgammafunc
void
tgammafunc(void)
{
	int i, n;
	double d;
	struct atom *p1, *p2;

	p1 = pop();

	if (istensor(p1)) {
		p1 = copy_tensor(p1);
		n = p1->u.tensor->nelem;
		for (i = 0; i < n; i++) {
			push(p1->u.tensor->elem[i]);
			tgammafunc();
			p1->u.tensor->elem[i] = pop();
		}
		push(p1);
		return;
	}

	push(p1);
	floatfunc();
	p2 = pop();

	if (isnum(p2)) {
		push(p2);
		d = pop_double();
		d = tgamma(d);
		push_double(d);
		return;
	}

	push_symbol(TGAMMA);
	push(p1);
	list(2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x8b78
movq %rax, %rbx
cmpb $0x7, 0x10(%rax)
jne 0x206f3
movq %rbx, %rdi
callq 0x953d
movq %rax, %rbx
movq (%rax), %rax
movslq 0x64(%rax), %r14
testq %r14, %r14
jle 0x206ee
xorl %r15d, %r15d
movq (%rbx), %rax
movq 0x68(%rax,%r15,8), %rdi
callq 0x8b01
callq 0x20695
callq 0x8b78
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x206c7
movq %rbx, %rdi
jmp 0x2073c
movq %rbx, %rdi
callq 0x8b01
callq 0xa7fa
callq 0x8b78
movb 0x10(%rax), %cl
andb $-0x2, %cl
cmpb $0x4, %cl
jne 0x2074b
movq %rax, %rdi
callq 0x8b01
callq 0x9086
callq 0x71d0
movsd %xmm0, -0x20(%rbp)
callq 0x74ec
movb $0x5, 0x10(%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8b01
movq 0x215c6(%rip), %rdi     # 0x41d18
callq 0x8b01
movq %rbx, %rdi
callq 0x8b01
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8ad9
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_transpose
void
eval_transpose(struct atom *p1)
{
	int m, n;
	struct atom *p2;

	push(cadr(p1));
	evalf();
	p2 = pop();
	push(p2);

	if (!istensor(p2) || p2->u.tensor->ndim < 2)
		return;

	p1 = cddr(p1);

	if (!iscons(p1)) {
		transpose(1, 2);
		return;
	}

	while (iscons(p1)) {

		push(car(p1));
		evalf();
		n = pop_integer();

		push(cadr(p1));
		evalf();
		m = pop_integer();

		transpose(n, m);

		p1 = cddr(p1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r12
cmpb $0x1, 0x10(%rdi)
leaq 0x20270(%rip), %r15     # 0x40a00
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x8b01
callq 0x95e2
callq 0x8b78
movq %rax, %r14
movq %rax, %rdi
callq 0x8b01
cmpb $0x7, 0x10(%r14)
jne 0x207ce
movq (%r14), %rax
cmpl $0x2, (%rax)
jge 0x207d7
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x1, 0x10(%rbx)
cmovneq %r15, %r12
movq (%r12), %rax
leaq 0x8(%rax), %rcx
cmpb $0x1, 0x10(%rax)
cmovneq %r15, %rcx
movq (%rcx), %r14
cmpb $0x1, 0x10(%r14)
jne 0x20868
cmpb $0x1, 0x10(%r14)
jne 0x207ce
movq (%r14), %rdi
callq 0x8b01
callq 0x95e2
callq 0xeb5b
cmpb $0x1, 0x10(%r14)
leaq 0x8(%r14), %r12
movq %r15, %rcx
cmoveq %r12, %rcx
movq (%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
movl %eax, %ebx
cmovneq %r15, %rcx
movq (%rcx), %rdi
callq 0x8b01
callq 0x95e2
callq 0xeb5b
movl %ebx, %edi
movl %eax, %esi
callq 0x2087f
cmpb $0x1, 0x10(%r14)
cmovneq %r15, %r12
movq (%r12), %rax
leaq 0x8(%rax), %rcx
cmpb $0x1, 0x10(%rax)
cmovneq %r15, %rcx
movq (%rcx), %r14
jmp 0x207f9
movl $0x1, %edi
movl $0x2, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2087f
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_unit
void
eval_unit(struct atom *p1)
{
	int i, j, n;

	push(cadr(p1));
	evalf();

	n = pop_integer();

	if (n < 1)
		stopf("unit: index err");

	if (n == 1) {
		push_integer(1);
		return;
	}

	p1 = alloc_matrix(n, n);

	for (i = 0; i < n; i++)
		for (j = 0; j < n; j++)
			if (i == j)
				p1->u.tensor->elem[n * i + j] = one;
			else
				p1->u.tensor->elem[n * i + j] = zero;

	push(p1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rax
leaq 0x1ff94(%rip), %rcx     # 0x40a00
cmovneq %rcx, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %rcx
movq (%rcx), %rdi
callq 0x8b01
callq 0x95e2
callq 0xeb5b
testl %eax, %eax
jle 0x20b1e
movl %eax, %ebx
cmpl $0x1, %eax
jne 0x20aa5
movq 0xe6035(%rip), %rdi     # 0x106ad8
jmp 0x20b13
movl %ebx, %edi
imull %ebx, %edi
callq 0x7850
movq (%rax), %rcx
movl $0x2, (%rcx)
movq (%rax), %rcx
movl %ebx, 0x4(%rcx)
movq (%rax), %rcx
movl %ebx, 0x8(%rcx)
movl %ebx, %ecx
leaq (,%rcx,8), %rdx
movl $0x68, %esi
xorl %edi, %edi
leaq 0xe5ffc(%rip), %r8      # 0x106ad8
leaq 0x1d65d(%rip), %r9      # 0x3e140
xorl %r10d, %r10d
cmpq %r10, %rdi
movq %r9, %r11
cmoveq %r8, %r11
movq (%r11), %r11
movq (%rax), %rbx
addq %rsi, %rbx
movq %r11, (%rbx,%r10,8)
incq %r10
cmpq %r10, %rcx
jne 0x20ae6
incq %rdi
addq %rdx, %rsi
cmpq %rcx, %rdi
jne 0x20ae3
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8b01
leaq 0xa06e(%rip), %rdi      # 0x2ab93
callq 0x77c8
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_zero
void
eval_zero(struct atom *p1)
{
	int h, i, m, n;

	p1 = cdr(p1);
	h = tos;
	m = 1;

	while (iscons(p1)) {
		push(car(p1));
		evalf();
		dupl();
		n = pop_integer();
		if (n < 2)
			stopf("zero: dim err");
		m *= n;
		p1 = cdr(p1);
	}

	n = tos - h;

	if (n == 0) {
		push_integer(0); // scalar zero
		return;
	}

	if (n > MAXDIM)
		stopf("zero: rank err");

	p1 = alloc_tensor(m);

	for (i = 0; i < m; i++)
		p1->u.tensor->elem[i] = zero;

	// dim info

	p1->u.tensor->ndim = n;

	for (i = 0; i < n; i++)
		p1->u.tensor->dim[n - i - 1] = pop_integer();

	push(p1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x8(%rdi), %rax
cmpb $0x1, 0x10(%rdi)
leaq 0x1feb9(%rip), %r12     # 0x40a00
cmovneq %r12, %rax
movl 0x19767(%rip), %ecx     # 0x3a2b8
movl %ecx, -0x2c(%rbp)
movq (%rax), %r13
movl $0x1, %ebx
cmpb $0x1, 0x10(%r13)
jne 0x20bb9
leaq 0x10(%r13), %r15
movq (%r13), %rdi
callq 0x8b01
callq 0x95e2
callq 0x8b78
movq %rax, %r14
movq %rax, %rdi
callq 0x8b01
movq %r14, %rdi
callq 0x8b01
callq 0xeb5b
cmpl $0x1, %eax
jle 0x20c32
imull %eax, %ebx
addq $0x8, %r13
cmpb $0x1, (%r15)
cmovneq %r12, %r13
movq (%r13), %r13
leaq 0x10(%r13), %r15
cmpb $0x1, 0x10(%r13)
je 0x20b67
movl 0x196f8(%rip), %r15d    # 0x3a2b8
subl -0x2c(%rbp), %r15d
jne 0x20bcf
movq 0x1d573(%rip), %rdi     # 0x3e140
jmp 0x20c1f
cmpl $0x19, %r15d
jge 0x20c3e
movl %ebx, %edi
callq 0x7850
movq %rax, %r14
testl %ebx, %ebx
jle 0x20bfe
movl %ebx, %eax
xorl %ecx, %ecx
movq 0x1d552(%rip), %rdx     # 0x3e140
movq (%r14), %rsi
movq %rdx, 0x68(%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x20be7
movq (%r14), %rax
movl %r15d, (%rax)
testl %r15d, %r15d
jle 0x20c1c
movl %r15d, %ebx
callq 0xeb5b
movq (%r14), %rcx
movl %eax, (%rcx,%rbx,4)
decq %rbx
jne 0x20c0c
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8b01
leaq 0x9f6a(%rip), %rdi      # 0x2aba3
callq 0x77c8
leaq 0x9f6c(%rip), %rdi      # 0x2abb1
callq 0x77c8
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: factor_bignum
void
factor_bignum(uint32_t *N, struct atom *M)
{
	int h, i, n;
	struct atom *BASE, *EXPO;

	// greater than 31 bits?

	if (MLENGTH(N) > 1 || N[0] > 0x7fffffff) {
		push_bignum(MPLUS, mcopy(N), mint(1));
		if (isplusone(M))
			return;
		push_symbol(POWER);
		swap();
		push(M);
		list(3);
		return;
	}

	h = tos;

	n = N[0];

	factor_int(n);

	n = (tos - h) / 2; // number of factors on stack

	for (i = 0; i < n; i++) {

		BASE = stack[h + 2 * i + 0];
		EXPO = stack[h + 2 * i + 1];

		push(EXPO);
		push(M);
		multiply();
		EXPO = pop();

		if (isplusone(EXPO)) {
			stack[h + i] = BASE;
			continue;
		}

		push_symbol(POWER);
		push(BASE);
		push(EXPO);
		list(3);
		stack[h + i] = pop();
	}

	tos = h + n; // pop all
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
cmpl $0x1, -0x4(%rdi)
jg 0x20d47
movl (%rdi), %eax
testl %eax, %eax
js 0x20d47
movslq 0x1963f(%rip), %rbx     # 0x3a2b8
movl %eax, %edi
callq 0x1d3c5
movl 0x19632(%rip), %eax     # 0x3a2b8
movq %rbx, -0x38(%rbp)
subl %ebx, %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movl %ecx, -0x2c(%rbp)
cmpl $0x2, %eax
jl 0x20d39
movl -0x2c(%rbp), %r12d
leaq 0x22914(%rip), %rax     # 0x435c0
movq -0x38(%rbp), %rcx
leaq (%rax,%rcx,8), %r13
xorl %ebx, %ebx
movq %r15, -0x40(%rbp)
movq (%r13,%rbx,2), %r14
movq 0x8(%r13,%rbx,2), %rdi
callq 0x8b01
movq %r15, %rdi
callq 0x8b01
movl $0x2, %edi
callq 0xa8bb
callq 0x8b78
movq %rax, %r15
movq %rax, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0xcb82
testl %eax, %eax
jne 0x20d27
movq 0x225b0(%rip), %rdi     # 0x432b0
callq 0x8b01
movq %r14, %rdi
callq 0x8b01
movq %r15, %rdi
callq 0x8b01
movl $0x3, %edi
callq 0x8ad9
callq 0x8b78
movq %rax, %r14
movq %r14, (%r13,%rbx)
addq $0x8, %rbx
decq %r12
movq -0x40(%rbp), %r15
jne 0x20cba
movl -0x2c(%rbp), %eax
addl -0x38(%rbp), %eax
movl %eax, 0x19573(%rip)     # 0x3a2b8
jmp 0x20d7c
callq 0x7e34
movq %rax, %r14
movl $0x1, %edi
callq 0x7ad5
xorl %edi, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0xb9f7
movq %r15, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0xcb82
testl %eax, %eax
je 0x20d8b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2251e(%rip), %rdi     # 0x432b0
callq 0x8b01
callq 0xad38
movq %r15, %rdi
callq 0x8b01
movl $0x3, %edi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8ad9
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_putw
void
fmt_putw(uint32_t w)
{
	uint8_t buf[4];
	if (w == 0)
		w = ' ';
	buf[0] = w >> 24;
	buf[1] = w >> 16;
	buf[2] = w >> 8;
	buf[3] = w;
	if (buf[1])
		outbuf_putc(buf[1]);
	if (buf[2])
		outbuf_putc(buf[2]);
	outbuf_putc(buf[3]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testl %edi, %edi
movl $0x20, %ebx
cmovnel %edi, %ebx
testl $0xff0000, %ebx         # imm = 0xFF0000
je 0x21723
movl %ebx, %eax
shrl $0x10, %eax
movzbl %al, %edi
callq 0x15d29
testl $0xff00, %ebx           # imm = 0xFF00
je 0x21738
movl %ebx, %eax
shrl $0x8, %eax
movzbl %al, %edi
callq 0x15d29
movzbl %bl, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x15d29
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_args
void
fmt_args(struct atom *p)
{
	int t;

	p = cdr(p);

	if (!iscons(p)) {
		fmt_roman_char('(');
		fmt_roman_char(')');
		return;
	}

	t = tos;

	fmt_expr(car(p));

	p = cdr(p);

	while (iscons(p)) {
		fmt_roman_char(',');
		fmt_expr(car(p));
		p = cdr(p);
	}

	fmt_update_list(t);

	fmt_update_subexpr();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rax
leaq 0x1f2a1(%rip), %r14     # 0x40a00
cmovneq %r14, %rax
movq (%rax), %r15
cmpb $0x1, 0x10(%r15)
jne 0x217c3
movl 0x18b45(%rip), %ebx     # 0x3a2b8
movq (%r15), %rdi
callq 0x2188f
leaq 0x8(%r15), %rax
cmpb $0x1, 0x10(%r15)
cmovneq %r14, %rax
movq (%rax), %r15
cmpb $0x1, 0x10(%r15)
jne 0x217ad
movl $0x2c, %edi
callq 0x217e1
cmpb $0x1, 0x10(%r15)
movq %r14, %rax
cmoveq %r15, %rax
movq (%rax), %rdi
jmp 0x21776
movl %ebx, %edi
callq 0x2191c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21b50
movl $0x28, %edi
callq 0x217e1
movl $0x29, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x217e1
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_roman_char
void
fmt_roman_char(int c)
{
	int d, h, w;

	h = 1;
	d = 0;
	w = 1;

	push_double(EMIT_CHAR);
	push_double(h);
	push_double(d);
	push_double(w);
	push_double(c);

	list(5);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
callq 0x74ec
movb $0x5, %r14b
movb %r14b, 0x10(%rax)
movabsq $0x4000000000000000, %rcx # imm = 0x4000000000000000
movq %rcx, (%rax)
movq %rax, %rdi
callq 0x8b01
callq 0x74ec
movb %r14b, 0x10(%rax)
movabsq $0x3ff0000000000000, %r15 # imm = 0x3FF0000000000000
movq %r15, (%rax)
movq %rax, %rdi
callq 0x8b01
callq 0x74ec
movb %r14b, 0x10(%rax)
movq $0x0, (%rax)
movq %rax, %rdi
callq 0x8b01
callq 0x74ec
movb %r14b, 0x10(%rax)
movq %r15, (%rax)
movq %rax, %rdi
callq 0x8b01
cvtsi2sd %ebx, %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x74ec
movb %r14b, 0x10(%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rax, %rdi
callq 0x8b01
movl $0x5, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8ad9
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_expr
void
fmt_expr(struct atom *p)
{
	if (isnegativeterm(p) || (car(p) == symbol(ADD) && isnegativeterm(cadr(p))))
		fmt_roman_char(MINUS_SIGN);

	if (car(p) == symbol(ADD))
		fmt_expr_nib(p);
	else
		fmt_term(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0xa813
leaq 0x1f15b(%rip), %r14     # 0x40a00
testl %eax, %eax
je 0x218b5
movl $0xe28892, %edi         # imm = 0xE28892
callq 0x217e1
jmp 0x218cd
movb 0x10(%rbx), %al
cmpb $0x1, %al
movq %r14, %rcx
cmoveq %rbx, %rcx
movq (%rcx), %rcx
cmpq 0x219d5(%rip), %rcx     # 0x432a0
je 0x218f9
cmpb $0x1, 0x10(%rbx)
cmoveq %rbx, %r14
movq (%r14), %rax
cmpq 0x219c1(%rip), %rax     # 0x432a0
je 0x218ed
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x22787
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x226df
leaq 0x8(%rbx), %rcx
cmpb $0x1, %al
cmovneq %r14, %rcx
movq (%rcx), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rax
movq (%rax), %rdi
callq 0xa813
testl %eax, %eax
jne 0x218a9
jmp 0x218cd
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_update_subexpr
void
fmt_update_subexpr(void)
{
	int d, h, w;
	struct atom *p1;

	p1 = pop();

	h = HEIGHT(p1);
	d = DEPTH(p1);
	w = WIDTH(p1);

	// delimiters have vertical symmetry (h - m == d + m, m = 1/2)

	if (h > 1 || d > 0) {
		h = MAX(h, d + 1) + 1; // plus extra
		d = h - 1; // by symmetry
	}

	w += 2;

	push_double(EMIT_SUBEXPR);
	push_double(h);
	push_double(d);
	push_double(w);
	push(p1);

	list(5);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x8b78
movq %rax, %rbx
addq $0x8, %rax
cmpb $0x1, 0x10(%rbx)
leaq 0x1ee8b(%rip), %rdx     # 0x40a00
cmovneq %rdx, %rax
movq (%rax), %rdi
movb 0x10(%rdi), %cl
leaq 0x8(%rdi), %rax
cmpb $0x1, %cl
cmovneq %rdx, %rdi
movq %rdx, %rsi
cmoveq %rax, %rsi
movq (%rsi), %rsi
cmpb $0x1, 0x10(%rsi)
movq %rdx, %rsi
jne 0x21bae
cmpb $0x1, %cl
leaq 0x1ee59(%rip), %rsi     # 0x40a00
cmoveq %rax, %rsi
movq (%rsi), %rsi
movq (%rdi), %rdi
cmpb $0x1, %cl
movq %rdx, %r8
cmoveq %rax, %r8
movq (%r8), %r8
cmpb $0x1, 0x10(%r8)
movq %rdx, %r8
jne 0x21bdd
cmpb $0x1, %cl
leaq 0x1ee2e(%rip), %r8      # 0x40a00
cmoveq %rax, %r8
movq (%r8), %r8
addq $0x8, %r8
cvttsd2si (%rdi), %r14d
movq (%rsi), %rsi
movq (%r8), %rdi
cmpb $0x1, 0x10(%rdi)
jne 0x21c20
cmpb $0x1, %cl
leaq 0x1ee08(%rip), %rdx     # 0x40a00
movq %rdx, %rdi
cmoveq %rax, %rdi
movq (%rdi), %rdi
cmpb $0x1, 0x10(%rdi)
jne 0x21c1d
cmpb $0x1, %cl
leaq 0x1edee(%rip), %rcx     # 0x40a00
cmoveq %rax, %rcx
movq (%rcx), %rdx
addq $0x8, %rdx
movq (%rdx), %rdx
cvttsd2si (%rsi), %r15d
movq (%rdx), %rax
movsd (%rax), %xmm0
cmpl $0x1, %r14d
jg 0x21c37
testl %r15d, %r15d
jle 0x21c45
incl %r15d
cmpl %r14d, %r15d
cmovlel %r14d, %r15d
leal 0x1(%r15), %r14d
cvttsd2si %xmm0, %r12d
addl $0x2, %r12d
callq 0x74ec
movb $0x5, %r13b
movb %r13b, 0x10(%rax)
movabsq $0x4018000000000000, %rcx # imm = 0x4018000000000000
movq %rcx, (%rax)
movq %rax, %rdi
callq 0x8b01
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x74ec
movb %r13b, 0x10(%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rax, %rdi
callq 0x8b01
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x74ec
movb %r13b, 0x10(%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rax, %rdi
callq 0x8b01
xorps %xmm0, %xmm0
cvtsi2sd %r12d, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x74ec
movb %r13b, 0x10(%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rax, %rdi
callq 0x8b01
movq %rbx, %rdi
callq 0x8b01
movl $0x5, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8ad9
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_base
void
fmt_base(struct atom *p)
{
	if (isnegativenumber(p) || isfraction(p) || isdouble(p) || car(p) == symbol(ADD) || car(p) == symbol(MULTIPLY) || car(p) == symbol(POWER))
		fmt_subexpr(p);
	else
		fmt_expr(p);
}

// Assembly:
movzbl 0x10(%rdi), %eax
movq %rdi, %rcx
cmpl $0x1, %eax
je 0x21d67
cmpl $0x5, %eax
je 0x21d23
cmpl $0x4, %eax
jne 0x21d60
cmpb $0x1, 0x12(%rdi)
sete %cl
jmp 0x21d2e
xorpd %xmm0, %xmm0
ucomisd (%rdi), %xmm0
seta %cl
testb %cl, %cl
jne 0x21d9a
movq %rdi, %rcx
cmpl $0x1, %eax
je 0x21d67
cmpl $0x5, %eax
je 0x21d9a
cmpl $0x4, %eax
jne 0x21d60
movq 0x8(%rdi), %rcx
cmpl $0x1, -0x4(%rcx)
jne 0x21d9a
cmpl $0x1, (%rcx)
jne 0x21d9a
movq %rdi, %rcx
cmpl $0x1, %eax
je 0x21d67
cmpl $0x5, %eax
je 0x21d9a
leaq 0x1ec99(%rip), %rcx     # 0x40a00
movq (%rcx), %rcx
cmpq 0x2152f(%rip), %rcx     # 0x432a0
je 0x21d9a
cmpl $0x1, %eax
leaq 0x1ec83(%rip), %rax     # 0x40a00
cmoveq %rdi, %rax
movq (%rax), %rax
cmpq 0x2151d(%rip), %rax     # 0x432a8
je 0x21d9a
cmpq 0x2151c(%rip), %rax     # 0x432b0
jne 0x2188f
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0x18512(%rip), %ebx     # 0x3a2b8
callq 0x2188f
movl %ebx, %edi
callq 0x2191c
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21b50
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_denominators
void
fmt_denominators(struct atom *p)
{
	int n, t;
	char *s;
	struct atom *q;

	t = tos;
	n = count_denominators(p);
	p = cdr(p);

	while (iscons(p)) {

		q = car(p);
		p = cdr(p);

		if (!isdenominator(q))
			continue;

		if (tos > t)
			fmt_space();

		if (isrational(q)) {
			s = mstr(q->u.q.b);
			fmt_roman_string(s);
			continue;
		}

		if (isminusone(caddr(q))) {
			q = cadr(q);
			if (car(q) == symbol(ADD) && n == 1)
				fmt_expr(q); // parens not needed
			else
				fmt_factor(q);
		} else {
			fmt_base(cadr(q));
			fmt_numeric_exponent(caddr(q)); // sign is not emitted
		}
	}

	fmt_update_list(t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl 0x184c1(%rip), %eax     # 0x3a2b8
movl %eax, -0x2c(%rbp)
callq 0x9223
cmpb $0x1, 0x10(%r14)
leaq 0x8(%r14), %rcx
leaq 0x1ebf1(%rip), %r12     # 0x40a00
cmovneq %r12, %rcx
movl %eax, -0x30(%rbp)
movq (%rcx), %r13
cmpb $0x1, 0x10(%r13)
jne 0x21f84
movq (%r13), %r15
movq 0x8(%r13), %r13
movq %r15, %rdi
callq 0x9267
testl %eax, %eax
je 0x21e19
movl -0x2c(%rbp), %eax
cmpl %eax, 0x18477(%rip)     # 0x3a2b8
jle 0x21e48
callq 0x21f9a
movzbl 0x10(%r15), %r14d
cmpl $0x1, %r14d
je 0x21e85
movq %r12, %rax
cmpl $0x4, %r14d
jne 0x21e89
movq 0x8(%r15), %rdi
callq 0x7d27
movq %rax, %r15
movb (%rax), %al
testb %al, %al
je 0x21e19
incq %r15
movsbl %al, %edi
callq 0x217e1
movb (%r15), %al
incq %r15
testb %al, %al
jne 0x21e71
jmp 0x21e19
leaq 0x8(%r15), %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %r12, %rax
jne 0x21ea8
leaq 0x8(%r15), %rax
cmpb $0x1, %r14b
cmovneq %r12, %rax
movq (%rax), %rax
addq $0x8, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %r12, %rax
jne 0x21ed2
leaq 0x8(%r15), %rax
cmpb $0x1, %r14b
cmovneq %r12, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
leaq 0x8(%rax), %rax
cmovneq %r12, %rax
movq (%rax), %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0xcb82
leaq 0x8(%r15), %rbx
cmpb $0x1, %r14b
movq %r12, %rcx
cmoveq %rbx, %rcx
movq (%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
cmovneq %r12, %rcx
movq (%rcx), %rdi
testl %eax, %eax
je 0x21f35
cmpl $0x1, -0x30(%rbp)
sete %al
cmpb $0x1, 0x10(%rdi)
movq %r12, %rcx
cmoveq %rdi, %rcx
movq (%rcx), %rcx
cmpq 0x2137f(%rip), %rcx     # 0x432a0
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x21f7a
callq 0x2188f
jmp 0x21e19
callq 0x21d04
cmpb $0x1, 0x10(%r15)
cmovneq %r12, %rbx
movq (%rbx), %rax
movb 0x10(%rax), %cl
addq $0x8, %rax
cmpb $0x1, %cl
movq %r12, %rdx
cmoveq %rax, %rdx
movq (%rdx), %rdx
cmpb $0x1, 0x10(%rdx)
movq %r12, %rdx
jne 0x21f6d
cmpb $0x1, %cl
cmovneq %r12, %rax
movq (%rax), %rdx
movq (%rdx), %rdi
callq 0x22110
jmp 0x21e19
callq 0x2203d
jmp 0x21e19
movl -0x2c(%rbp), %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2191c
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_space
void
fmt_space(void)
{
	push_double(EMIT_SPACE);
	push_double(0);
	push_double(0);
	push_double(1);

	list(4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x74ec
movb $0x5, %bl
movb %bl, 0x10(%rax)
movabsq $0x3ff0000000000000, %r14 # imm = 0x3FF0000000000000
movq %r14, (%rax)
movq %rax, %rdi
callq 0x8b01
callq 0x74ec
movb %bl, 0x10(%rax)
xorl %r15d, %r15d
movq %r15, (%rax)
movq %rax, %rdi
callq 0x8b01
callq 0x74ec
movb %bl, 0x10(%rax)
movq %r15, (%rax)
movq %rax, %rdi
callq 0x8b01
callq 0x74ec
movb %bl, 0x10(%rax)
movq %r14, (%rax)
movq %rax, %rdi
callq 0x8b01
movl $0x4, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8ad9
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_factor
void
fmt_factor(struct atom *p)
{
	if (isrational(p)) {
		fmt_rational(p);
		return;
	}

	if (isdouble(p)) {
		fmt_double(p);
		return;
	}

	if (issymbol(p)) {
		fmt_symbol(p);
		return;
	}

	if (isstr(p)) {
		fmt_string(p);
		return;
	}

	if (istensor(p)) {
		fmt_tensor(p);
		return;
	}

	if (iscons(p)) {
		if (car(p) == symbol(POWER))
			fmt_power(p);
		else if (car(p) == symbol(ADD) || car(p) == symbol(MULTIPLY))
			fmt_subexpr(p);
		else
			fmt_function(p);
		return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movzbl 0x10(%rdi), %eax
leal -0x1(%rax), %ecx
cmpl $0x6, %ecx
ja 0x220cb
leaq 0x405a(%rip), %rdx      # 0x260b0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x228a2
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x227d1
movq (%rdi), %rcx
cmpq 0x21231(%rip), %rcx     # 0x432b0
je 0x220e8
cmpb $0x1, %al
leaq 0x1e976(%rip), %rax     # 0x40a00
cmoveq %rdi, %rax
movq (%rax), %rax
cmpq 0x21208(%rip), %rax     # 0x432a0
je 0x220f3
cmpq 0x21207(%rip), %rax     # 0x432a8
je 0x220f3
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x22b6c
movq (%rdi), %rbx
movb (%rbx), %al
testb %al, %al
je 0x220cb
incq %rbx
movsbl %al, %edi
callq 0x217e1
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x220ba
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x229a4
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x221bb
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x229c7
movl 0x181bf(%rip), %ebx     # 0x3a2b8
callq 0x2188f
movl %ebx, %edi
callq 0x2191c
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21b50
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_numeric_exponent
void
fmt_numeric_exponent(struct atom *p)
{
	int t;
	char *s;

	fmt_level++;

	t = tos;

	if (isrational(p)) {
		s = mstr(p->u.q.a);
		fmt_roman_string(s);
		if (!MEQUAL(p->u.q.b, 1)) {
			fmt_roman_char('/');
			s = mstr(p->u.q.b);
			fmt_roman_string(s);
		}
	} else
		fmt_double(p);

	fmt_update_list(t);

	fmt_level--;

	fmt_update_superscript();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
incl 0xef2d8(%rip)           # 0x1113f8
movq %rdi, %r14
movl 0x1818f(%rip), %ebx     # 0x3a2b8
cmpb $0x4, 0x10(%rdi)
jne 0x22197
movq (%r14), %rdi
callq 0x7d27
movq %rax, %r15
movb (%rax), %al
testb %al, %al
je 0x22155
incq %r15
movsbl %al, %edi
callq 0x217e1
movb (%r15), %al
incq %r15
testb %al, %al
jne 0x22143
movq 0x8(%r14), %rax
cmpl $0x1, -0x4(%rax)
jne 0x22164
cmpl $0x1, (%rax)
je 0x2219f
movl $0x2f, %edi
callq 0x217e1
movq 0x8(%r14), %rdi
callq 0x7d27
movq %rax, %r14
movb (%rax), %al
testb %al, %al
je 0x2219f
incq %r14
movsbl %al, %edi
callq 0x217e1
movb (%r14), %al
incq %r14
testb %al, %al
jne 0x22183
jmp 0x2219f
movq %r14, %rdi
callq 0x221bb
movl %ebx, %edi
callq 0x2191c
decl 0xef24c(%rip)           # 0x1113f8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x222b3
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_double
void
fmt_double(struct atom *p)
{
	int t;
	char *s;

	snprintf(strbuf, STRBUFLEN, "%g", fabs(p->u.d));

	s = strbuf;

	while (*s && *s != 'E' && *s != 'e')
		fmt_roman_char(*s++);

	if (!*s)
		return;

	s++;

	fmt_roman_char(MULTIPLY_SIGN);

	fmt_roman_string("10");

	// superscripted exponent

	fmt_level++;

	t = tos;

	// sign of exponent

	if (*s == '+')
		s++;
	else if (*s == '-') {
		fmt_roman_char(MINUS_SIGN);
		s++;
	}

	// skip leading zeroes in exponent

	while (*s == '0')
		s++;

	fmt_roman_string(s);

	fmt_update_list(t);

	fmt_level--;

	fmt_update_superscript();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movsd (%rdi), %xmm0
andps 0x3f2f(%rip), %xmm0     # 0x26100
leaq 0xef738(%rip), %rdi     # 0x111910
leaq 0x41d4(%rip), %rdx      # 0x263b3
movl $0x3e8, %esi            # imm = 0x3E8
movb $0x1, %al
callq 0x7100
leaq 0xef71f(%rip), %r14     # 0x111911
movzbl -0x1(%r14), %eax
testl %eax, %eax
je 0x222aa
cmpl $0x45, %eax
je 0x22216
cmpl $0x65, %eax
je 0x22216
movsbl %al, %edi
callq 0x217e1
incq %r14
jmp 0x221f2
movl $0xc397, %edi           # imm = 0xC397
callq 0x217e1
movb $0x31, %al
xorl %r15d, %r15d
leaq 0x494b(%rip), %rbx      # 0x26b77
leaq 0x1(%r15), %r12
movsbl %al, %edi
callq 0x217e1
movb 0x1(%r15,%rbx), %al
movq %r12, %r15
cmpq $0x2, %r12
jne 0x2222c
incl 0xef1ac(%rip)           # 0x1113f8
movl 0x18066(%rip), %ebx     # 0x3a2b8
movzbl (%r14), %eax
cmpl $0x2b, %eax
je 0x2226a
cmpl $0x2d, %eax
jne 0x2226d
movl $0xe28892, %edi         # imm = 0xE28892
callq 0x217e1
incq %r14
incq %r14
movzbl -0x1(%r14), %eax
cmpl $0x30, %eax
je 0x2226d
testl %eax, %eax
je 0x22290
movsbl %al, %edi
callq 0x217e1
movb (%r14), %al
incq %r14
testb %al, %al
jne 0x2227e
movl %ebx, %edi
callq 0x2191c
decl 0xef15b(%rip)           # 0x1113f8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x222b3
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_exponent
void
fmt_exponent(struct atom *p)
{
	if (isnum(p) && !isnegativenumber(p)) {
		fmt_numeric_exponent(p); // sign is not emitted
		return;
	}

	fmt_level++;
	fmt_list(p);
	fmt_level--;

	fmt_update_superscript();
}

// Assembly:
movzbl 0x10(%rdi), %eax
movl %eax, %ecx
andb $-0x2, %cl
cmpb $0x4, %cl
jne 0x226ab
cmpl $0x5, %eax
je 0x2269c
cmpl $0x4, %eax
jne 0x22110
cmpb $0x1, 0x12(%rdi)
sete %al
jmp 0x226a7
xorpd %xmm0, %xmm0
ucomisd (%rdi), %xmm0
seta %al
testb %al, %al
je 0x226da
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
incl 0xeed41(%rip)           # 0x1113f8
movl 0x17bfb(%rip), %ebx     # 0x3a2b8
callq 0x2188f
movl %ebx, %edi
callq 0x2191c
decl 0xeed29(%rip)           # 0x1113f8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x222b3
jmp 0x22110
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_expr_nib
void
fmt_expr_nib(struct atom *p)
{
	p = cdr(p);
	fmt_term(car(p));
	p = cdr(p);
	while (iscons(p)) {
		if (isnegativeterm(car(p)))
			fmt_infix_operator(MINUS_SIGN);
		else
			fmt_infix_operator(PLUS_SIGN);
		fmt_term(car(p));
		p = cdr(p);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rax
leaq 0x1e307(%rip), %r14     # 0x40a00
cmovneq %r14, %rax
movq (%rax), %rbx
cmpb $0x1, 0x10(%rbx)
movq %r14, %rax
cmoveq %rbx, %rax
movq (%rax), %rdi
callq 0x22787
leaq 0x8(%rbx), %rax
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %rax
movq (%rax), %r15
cmpb $0x1, 0x10(%r15)
jne 0x2277e
movl $0x2b, %r12d
movq (%r15), %rdi
callq 0xa813
movl %eax, %ebx
callq 0x21f9a
testl %ebx, %ebx
movl $0xe28892, %edi         # imm = 0xE28892
cmovel %r12d, %edi
callq 0x217e1
callq 0x21f9a
cmpb $0x1, 0x10(%r15)
movq %r14, %rax
cmoveq %r15, %rax
movq (%rax), %rdi
callq 0x22787
leaq 0x8(%r15), %rax
cmpb $0x1, 0x10(%r15)
cmovneq %r14, %rax
movq (%rax), %r15
cmpb $0x1, 0x10(%r15)
je 0x2272f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_rational
void
fmt_rational(struct atom *p)
{
	int t;
	char *s;

	if (MEQUAL(p->u.q.b, 1)) {
		s = mstr(p->u.q.a);
		fmt_roman_string(s);
		return;
	}

	fmt_level++;

	t = tos;
	s = mstr(p->u.q.a);
	fmt_roman_string(s);
	fmt_update_list(t);

	t = tos;
	s = mstr(p->u.q.b);
	fmt_roman_string(s);
	fmt_update_list(t);

	fmt_level--;

	fmt_update_fraction();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpl $0x1, -0x4(%rax)
jne 0x2281d
cmpl $0x1, (%rax)
jne 0x2281d
movq (%rbx), %rdi
callq 0x7d27
movq %rax, %rbx
movb (%rax), %al
testb %al, %al
je 0x22812
incq %rbx
movsbl %al, %edi
callq 0x217e1
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x22801
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
incl 0xeebd5(%rip)           # 0x1113f8
movl 0x17a8e(%rip), %r14d    # 0x3a2b8
movq (%rbx), %rdi
callq 0x7d27
movq %rax, %r15
movb (%rax), %al
testb %al, %al
je 0x22850
incq %r15
movsbl %al, %edi
callq 0x217e1
movb (%r15), %al
incq %r15
testb %al, %al
jne 0x2283e
movl %r14d, %edi
callq 0x2191c
movl 0x17a59(%rip), %r14d    # 0x3a2b8
movq 0x8(%rbx), %rdi
callq 0x7d27
movq %rax, %rbx
movb (%rax), %al
testb %al, %al
je 0x22885
incq %rbx
movsbl %al, %edi
callq 0x217e1
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x22874
movl %r14d, %edi
callq 0x2191c
decl 0xeeb65(%rip)           # 0x1113f8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22f81
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_symbol
void
fmt_symbol(struct atom *p)
{
	int k, t;
	char *s;

	if (p == symbol(EXP1)) {
		fmt_roman_string("exp(1)");
		return;
	}

	s = printname(p);

	if (iskeyword(p) || p == symbol(LAST) || p == symbol(TRACE) || p == symbol(TTY)) {
		fmt_roman_string(s);
		return;
	}

	k = fmt_symbol_fragment(s, 0);

	if (s[k] == '\0')
		return;

	// emit subscript

	fmt_level++;

	t = tos;

	while (s[k] != '\0')
		k = fmt_symbol_fragment(s, k);

	fmt_update_list(t);

	fmt_level--;

	fmt_update_subscript();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpq %rdi, 0x20a18(%rip)     # 0x432c8
je 0x228c4
movb 0x10(%rdi), %al
movl %eax, %ecx
andb $-0x2, %cl
cmpb $0x2, %cl
jne 0x228e9
movq (%rdi), %rbx
jmp 0x228f0
movb $0x65, %al
movl $0x1, %ebx
leaq 0x3aa7(%rip), %r14      # 0x26379
movsbl %al, %edi
callq 0x217e1
movb (%rbx,%r14), %al
incq %rbx
cmpq $0x7, %rbx
jne 0x228d2
jmp 0x2295e
leaq 0x8688(%rip), %rbx      # 0x2af78
cmpb $0x2, %al
je 0x22944
cmpq %rdi, 0x1dac5(%rip)     # 0x403c0
je 0x22944
cmpq %rdi, 0x1f41c(%rip)     # 0x41d20
je 0x22944
cmpq %rdi, 0x1f423(%rip)     # 0x41d30
je 0x22944
movq %rbx, %rdi
xorl %esi, %esi
callq 0x23a8c
movslq %eax, %rcx
cmpb $0x0, (%rbx,%rcx)
je 0x2295e
incl 0xeead0(%rip)           # 0x1113f8
movl 0x17989(%rip), %r14d    # 0x3a2b8
cmpb $0x0, (%rbx,%rcx)
je 0x22963
movq %rbx, %rdi
movl %eax, %esi
callq 0x23a8c
movslq %eax, %rcx
jmp 0x2292f
movb (%rbx), %al
testb %al, %al
je 0x2295e
incq %rbx
movsbl %al, %edi
callq 0x217e1
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x2294d
popq %rbx
popq %r14
popq %rbp
retq
movl %r14d, %edi
callq 0x2191c
decl 0xeea87(%rip)           # 0x1113f8
popq %rbx
popq %r14
popq %rbp
jmp 0x23b31
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_power
void
fmt_power(struct atom *p)
{
	if (cadr(p) == symbol(EXP1)) {
		fmt_roman_string("exp");
		fmt_args(cdr(p));
		return;
	}

	if (isimaginaryunit(p)) {
		if (isimaginaryunit(get_binding(symbol(J_LOWER)))) {
			fmt_roman_char('j');
			return;
		}
		if (isimaginaryunit(get_binding(symbol(I_LOWER)))) {
			fmt_roman_char('i');
			return;
		}
	}

	if (isnegativenumber(caddr(p))) {
		fmt_reciprocal(p);
		return;
	}

	fmt_base(cadr(p));
	fmt_exponent(caddr(p));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
cmpb $0x1, 0x10(%rdi)
leaq 0x1e01c(%rip), %r15     # 0x40a00
movq %r15, %rax
cmoveq %r14, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r15, %rax
movq (%rax), %rax
cmpq 0x208c8(%rip), %rax     # 0x432c8
je 0x22a31
movq %rbx, %rdi
callq 0x15b7a
testl %eax, %eax
je 0x22a9e
movq 0x1d36f(%rip), %rdi     # 0x3fd88
callq 0xe468
movq %rax, %rdi
callq 0x15b7a
testl %eax, %eax
je 0x22a74
movl $0x6a, %edi
jmp 0x22a91
movb $0x65, %al
movl $0x1, %r15d
leaq 0x859c(%rip), %r12      # 0x2afdc
movsbl %al, %edi
callq 0x217e1
movb (%r15,%r12), %al
incq %r15
cmpq $0x4, %r15
jne 0x22a40
cmpb $0x1, 0x10(%rbx)
leaq 0x1dfa0(%rip), %rax     # 0x40a00
cmoveq %r14, %rax
movq (%rax), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x21746
movq 0x1cfed(%rip), %rdi     # 0x3fa68
callq 0xe468
movq %rax, %rdi
callq 0x15b7a
testl %eax, %eax
je 0x22a9e
movl $0x69, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x217e1
cmpb $0x1, 0x10(%rbx)
movq %r15, %rax
cmoveq %r14, %rax
movq (%rax), %rax
movb 0x10(%rax), %cl
leaq 0x8(%rax), %rdx
cmpb $0x1, %cl
movq %r15, %rsi
cmoveq %rdx, %rsi
movq (%rsi), %rsi
cmpb $0x1, 0x10(%rsi)
jne 0x22ad7
cmpb $0x1, %cl
leaq 0x1df30(%rip), %rsi     # 0x40a00
cmoveq %rdx, %rsi
movq (%rsi), %r15
movq (%r15), %rdx
movzbl 0x10(%rdx), %esi
cmpl $0x5, %esi
je 0x22af1
cmpl $0x4, %esi
jne 0x22b10
cmpb $0x1, 0x12(%rdx)
sete %dl
jmp 0x22afc
xorpd %xmm0, %xmm0
ucomisd (%rdx), %xmm0
seta %dl
testb %dl, %dl
je 0x22b10
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x23991
cmpb $0x1, %cl
leaq 0x1dee6(%rip), %r15     # 0x40a00
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x21d04
cmpb $0x1, 0x10(%rbx)
cmovneq %r15, %r14
movq (%r14), %rax
movb 0x10(%rax), %cl
addq $0x8, %rax
cmpb $0x1, %cl
movq %r15, %rdx
cmoveq %rax, %rdx
movq (%rdx), %rdx
cmpb $0x1, 0x10(%rdx)
jne 0x22b5c
cmpb $0x1, %cl
leaq 0x1deab(%rip), %rcx     # 0x40a00
cmoveq %rax, %rcx
movq (%rcx), %r15
movq (%r15), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x22677