LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
leaq 0x219b0(%rip), %rbx     # 0x3e9f0
leaq 0x8(%rdi), %rax
cmpb $0x1, 0x10(%rdi)
cmovneq %rbx, %rax
movq (%rax), %r14
cmpb $0x1, 0x10(%r14)
jne 0x1d0b1
movq (%r14), %rdi
movq 0x8(%r14), %rax
movb 0x10(%rax), %r15b
callq 0x861b
cmpb $0x1, %r15b
jne 0x1d0a2
leaq 0x8(%r14), %r15
callq 0x940b
callq 0x868d
movq %rax, %rdi
callq 0xa641
cmpb $0x1, 0x10(%r14)
cmovneq %rbx, %r15
movq (%r15), %rdi
testl %eax, %eax
jne 0x1d040
cmpb $0x1, 0x10(%rdi)
cmoveq %rdi, %rbx
movq (%rbx), %rdi
callq 0x861b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8fbb
movq 0x21938(%rip), %rdi     # 0x3e9f0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x861b
// File: /workspace/github_c_makefile_star2_O2/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 0x2190d(%rip), %r14     # 0x3e9f0
movq %r14, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rax
movq (%rax), %rdi
callq 0x861b
callq 0x8fbb
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
jne 0x1d119
movq 0x8(%rax), %rax
jmp 0x1d120
movq 0x218d0(%rip), %rax     # 0x3e9f0
cmpb $0x1, 0x10(%rax)
jne 0x1d129
movq %rax, %r14
movq (%r14), %rdi
callq 0x861b
callq 0x8fbb
callq 0xb07f
callq 0x1b99a
callq 0x868d
movq %rax, %rdi
callq 0xa641
movl %eax, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa426
// File: /workspace/github_c_makefile_star2_O2/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 0x21860(%rip), %r14     # 0x3e9f0
movq %r14, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rax
movq (%rax), %rdi
callq 0x861b
callq 0x8fbb
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
jne 0x1d1c6
movq 0x8(%rax), %rax
jmp 0x1d1cd
movq 0x21823(%rip), %rax     # 0x3e9f0
cmpb $0x1, 0x10(%rax)
jne 0x1d1d6
movq %rax, %r14
movq (%r14), %rdi
callq 0x861b
callq 0x8fbb
callq 0xb07f
callq 0x9fbd
callq 0x868d
movq %rax, %rbx
movq %rax, %rdi
callq 0xa641
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x1d221
movb 0x10(%rbx), %al
andb $-0x2, %al
cmpb $0x4, %al
jne 0x1d22c
movq %rbx, %rdi
callq 0x8c2a
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
orl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xa97d(%rip), %rdi      # 0x27bb0
callq 0x7756
// File: /workspace/github_c_makefile_star2_O2/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 0x868d
movq %rax, %rbx
cmpb $0x7, 0x10(%rax)
jne 0x1d30c
movq %rbx, %rdi
callq 0x8f1b
movq %rax, %rbx
movq (%rax), %rax
movl 0x64(%rax), %r14d
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
cmpq %r15, %r14
je 0x1d34a
movq (%rbx), %rax
movq 0x68(%rax,%r15,8), %rdi
callq 0x861b
callq 0x1d2af
callq 0x868d
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r15,8)
incq %r15
jmp 0x1d2e3
movq %rbx, %rdi
callq 0x861b
callq 0x9fbd
callq 0x868d
movb 0x10(%rax), %cl
andb $-0x2, %cl
cmpb $0x4, %cl
jne 0x1d35c
movq %rax, %rdi
callq 0x861b
callq 0x8ae1
callq 0x71d0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xaf59
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x861b
movq 0x229a5(%rip), %rdi     # 0x3fd08
callq 0x861b
movq %rbx, %rdi
callq 0x861b
pushq $0x2
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x85eb
// File: /workspace/github_c_makefile_star2_O2/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 0x21651(%rip), %r15     # 0x3e9f0
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x861b
callq 0x8fbb
callq 0x868d
movq %rax, %r14
movq %rax, %rdi
callq 0x861b
cmpb $0x7, 0x10(%r14)
jne 0x1d3dd
movq (%r14), %rax
cmpl $0x2, (%rax)
jge 0x1d3e6
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 0x1d47a
movb $0x1, %al
cmpb $0x1, %al
jne 0x1d3dd
movq (%r14), %rdi
callq 0x861b
callq 0x8fbb
callq 0xd9d9
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 0x861b
callq 0x8fbb
callq 0xd9d9
movl %ebx, %edi
movl %eax, %esi
callq 0x1d48d
cmpb $0x1, 0x10(%r14)
cmovneq %r15, %r12
movq (%r12), %rax
leaq 0x8(%rax), %rcx
cmpb $0x1, 0x10(%rax)
cmovneq %r15, %rcx
movq (%rcx), %r14
movb 0x10(%r14), %al
jmp 0x1d40a
pushq $0x1
popq %rdi
pushq $0x2
popq %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1d48d
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: transpose
void
transpose(int n, int m)
{
	int i, j, k, ndim, nelem;
	int index[MAXDIM];
	struct atom *p1, *p2;

	p1 = pop();

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

	if (n < 1 || n > ndim || m < 1 || m > ndim)
		stopf("transpose: index error");

	n--; // make zero based
	m--;

	p2 = copy_tensor(p1);

	// interchange indices n and m

	p2->u.tensor->dim[n] = p1->u.tensor->dim[m];
	p2->u.tensor->dim[m] = p1->u.tensor->dim[n];

	for (i = 0; i < ndim; i++)
		index[i] = 0;

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

		k = 0;

		for (j = 0; j < ndim; j++) {
			if (j == n)
				k = k * p1->u.tensor->dim[m] + index[m];
			else if (j == m)
				k = k * p1->u.tensor->dim[n] + index[n];
			else
				k = k * p1->u.tensor->dim[j] + index[j];
		}

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

		// increment index

		for (j = ndim - 1; j >= 0; j--) {
			if (++index[j] < p1->u.tensor->dim[j])
				break;
			index[j] = 0;
		}
	}

	push(p2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebx
movl %edi, %r14d
callq 0x868d
testl %r14d, %r14d
jle 0x1d620
movq %rax, %r15
movq (%rax), %rax
movl (%rax), %ecx
cmpl %ebx, %ecx
jl 0x1d620
testl %ebx, %ebx
jle 0x1d620
cmpl %r14d, %ecx
jl 0x1d620
movl 0x64(%rax), %r12d
decl %r14d
decl %ebx
movq %rcx, -0x38(%rbp)
movq %r15, %rdi
callq 0x8f1b
movq -0x38(%rbp), %rsi
movq (%r15), %rcx
movl 0x4(%rcx,%rbx,4), %ecx
movq (%rax), %rdx
movl %ecx, 0x4(%rdx,%r14,4)
movq (%r15), %rcx
movl 0x4(%rcx,%r14,4), %ecx
movq %rax, -0x30(%rbp)
movq (%rax), %rdx
movl %ecx, 0x4(%rdx,%rbx,4)
xorl %ecx, %ecx
cmpq %rcx, %rsi
je 0x1d521
andl $0x0, -0xa0(%rbp,%rcx,4)
incq %rcx
jmp 0x1d50f
leaq -0xa0(,%r14,4), %rcx
addq %rbp, %rcx
xorl %edx, %edx
movq %r12, %rax
testl %eax, %eax
cmovlel %edx, %eax
leaq -0xa0(,%rbx,4), %r12
addq %rbp, %r12
leaq (,%rsi,4), %rdi
leaq (,%rbx,4), %r8
leaq (,%r14,4), %r9
cmpq %rax, %rdx
je 0x1d609
xorl %r11d, %r11d
xorl %r10d, %r10d
cmpq %r11, %rdi
je 0x1d5b8
cmpq %r11, %r9
jne 0x1d582
movq (%r15), %rsi
leaq (%rsi,%rbx,4), %r13
addq $0x4, %r13
movq %r12, %rsi
jmp 0x1d5aa
movq (%r15), %rsi
cmpq %r11, %r8
jne 0x1d597
addq $0x4, %rsi
leaq (%rsi,%r14,4), %r13
movq %rcx, %rsi
jmp 0x1d5aa
leaq (%rsi,%r11), %r13
addq $0x4, %r13
leaq (%r11,%rbp), %rsi
addq $-0xa0, %rsi
imull (%r13), %r10d
addl (%rsi), %r10d
addq $0x4, %r11
jmp 0x1d568
movq (%r15), %rsi
movq 0x68(%rsi,%rdx,8), %rsi
movq -0x30(%rbp), %r11
movq (%r11), %r11
movslq %r10d, %r10
movq %rsi, 0x68(%r11,%r10,8)
movq -0x38(%rbp), %r10
testl %r10d, %r10d
jle 0x1d601
movl -0xa4(%rbp,%r10,4), %esi
incl %esi
movl %esi, -0xa4(%rbp,%r10,4)
movq (%r15), %r11
cmpl (%r11,%r10,4), %esi
jl 0x1d601
andl $0x0, -0xa4(%rbp,%r10,4)
decq %r10
jmp 0x1d5d3
incq %rdx
jmp 0x1d559
movq -0x30(%rbp), %rdi
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x861b
leaq 0xa5ad(%rip), %rdi      # 0x27bd4
callq 0x7756
// File: /workspace/github_c_makefile_star2_O2/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 0x213af(%rip), %rcx     # 0x3e9f0
cmovneq %rcx, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %rcx
movq (%rcx), %rdi
callq 0x861b
callq 0x8fbb
callq 0xd9d9
testl %eax, %eax
jle 0x1d6e0
movl %eax, %ebx
cmpl $0x1, %eax
jne 0x1d67b
pushq $0x1
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa426
movl %ebx, %edi
movl %ebx, %esi
callq 0x782d
movl %ebx, %ecx
leaq (,%rcx,8), %rdx
pushq $0x68
popq %rsi
xorl %edi, %edi
leaq 0xe742e(%rip), %r8      # 0x104ac8
leaq 0x1ea8f(%rip), %r9      # 0x3c130
cmpq %rcx, %rdi
je 0x1d6d2
xorl %r10d, %r10d
cmpq %r10, %rcx
je 0x1d6ca
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
jmp 0x1d6a9
incq %rdi
addq %rdx, %rsi
jmp 0x1d6a1
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x861b
leaq 0xa504(%rip), %rdi      # 0x27beb
callq 0x7756
// File: /workspace/github_c_makefile_star2_O2/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 0x212e7(%rip), %r14     # 0x3e9f0
cmovneq %r14, %rax
pushq $0x1
popq %rbx
movl 0x1ab91(%rip), %r15d    # 0x382a8
movq (%rax), %r12
cmpb $0x1, 0x10(%r12)
jne 0x1d757
movq (%r12), %rdi
callq 0x861b
callq 0x8fbb
callq 0x17833
callq 0xd9d9
cmpl $0x1, %eax
jle 0x1d7f1
imull %eax, %ebx
leaq 0x8(%r12), %rax
cmpb $0x1, 0x10(%r12)
cmovneq %r14, %rax
jmp 0x1d717
movl 0x1ab4a(%rip), %r12d    # 0x382a8
movl %r12d, %r13d
subl %r15d, %r13d
jne 0x1d77b
xorl %edi, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa426
cmpl $0x19, %r13d
jge 0x1d7fd
movl %ebx, %edi
callq 0x77da
movq %rax, %r14
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
cmpq %rax, %rbx
je 0x1d7ab
movq 0x1e992(%rip), %rcx     # 0x3c130
movq (%r14), %rdx
movq %rcx, 0x68(%rdx,%rax,8)
incq %rax
jmp 0x1d792
movq (%r14), %rax
movl %r13d, (%rax)
xorl %ebx, %ebx
testl %r13d, %r13d
cmovgl %r13d, %ebx
notl %r15d
addl %r12d, %r15d
subq $0x1, %rbx
jb 0x1d7db
callq 0xd9d9
movq (%r14), %rcx
movslq %r15d, %r15
movl %eax, 0x4(%rcx,%r15,4)
decl %r15d
jmp 0x1d7c0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x861b
leaq 0xa403(%rip), %rdi      # 0x27bfb
callq 0x7756
leaq 0xa405(%rip), %rdi      # 0x27c09
callq 0x7756
// File: /workspace/github_c_makefile_star2_O2/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, %r13
cmpl $0x1, -0x4(%rdi)
jg 0x1d8e9
movl (%rdi), %eax
testl %eax, %eax
js 0x1d8e9
movslq 0x1aa70(%rip), %rbx     # 0x382a8
movl %eax, %edi
callq 0x1a5a9
movl 0x1aa63(%rip), %eax     # 0x382a8
subl %ebx, %eax
pushq $0x2
popq %rcx
cltd
idivl %ecx
xorl %r14d, %r14d
testl %eax, %eax
movl $0x0, %ecx
movl %eax, -0x2c(%rbp)
cmovgl %eax, %ecx
leaq 0x23d4c(%rip), %rax     # 0x415b0
movq %rbx, -0x38(%rbp)
leaq (%rax,%rbx,8), %rbx
shlq $0x3, %rcx
movq %rcx, -0x40(%rbp)
cmpq %r14, -0x40(%rbp)
je 0x1d941
movq (%rbx,%r14,2), %r12
movq 0x8(%rbx,%r14,2), %rdi
callq 0x861b
movq %r13, %r15
movq %r13, %rdi
callq 0x861b
callq 0x9fae
callq 0x868d
movq %rax, %r13
movq %rax, %rdi
callq 0xa95a
testl %eax, %eax
jne 0x1d8dc
movq 0x239e9(%rip), %rdi     # 0x412a0
callq 0x861b
movq %r12, %rdi
callq 0x861b
movq %r13, %rdi
callq 0x861b
pushq $0x3
popq %rdi
callq 0x85eb
callq 0x868d
movq %rax, %r12
movq %r12, (%rbx,%r14)
addq $0x8, %r14
movq %r15, %r13
jmp 0x1d874
callq 0x7c9c
movq %rax, %r14
pushq $0x1
popq %rdi
callq 0x7a09
xorl %edi, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0xb015
movq %r13, %rdi
callq 0xa95a
testl %eax, %eax
jne 0x1d94d
movq 0x23987(%rip), %rdi     # 0x412a0
callq 0x861b
callq 0xa49b
movq %r13, %rdi
callq 0x861b
pushq $0x3
popq %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x85eb
movl -0x2c(%rbp), %eax
addl -0x38(%rbp), %eax
movl %eax, 0x1a95b(%rip)     # 0x382a8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x20
popq %rbx
cmovnel %edi, %ebx
testl $0xff0000, %ebx         # imm = 0xFF0000
je 0x1e38f
movl %ebx, %eax
shrl $0x10, %eax
movzbl %al, %edi
callq 0x13ea9
testw $0xff00, %bx            # imm = 0xFF00
je 0x1e3a3
movl %ebx, %eax
shrl $0x8, %eax
movzbl %al, %edi
callq 0x13ea9
movzbl %bl, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x13ea9
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rax
leaq 0x20625(%rip), %r15     # 0x3e9f0
cmovneq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
jne 0x1e433
movl 0x19eca(%rip), %ebx     # 0x382a8
pushq $0x2c
popq %r14
movq %rax, %r12
movq (%rax), %rdi
callq 0x1e499
leaq 0x8(%r12), %rax
cmpb $0x1, 0x10(%r12)
cmovneq %r15, %rax
movq (%rax), %r12
cmpb $0x1, 0x10(%r12)
jne 0x1e41f
movl %r14d, %edi
callq 0x1e44b
cmpb $0x1, 0x10(%r12)
movq %r12, %rax
je 0x1e3e5
movq %r15, %rax
jmp 0x1e3e5
movl %ebx, %edi
callq 0x1e545
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1e6e9
pushq $0x28
popq %rdi
callq 0x1e44b
pushq $0x29
popq %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1e44b
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movl %edi, %ebx
movsd 0x4d1d(%rip), %xmm0     # 0x23178
callq 0xaf59
movsd 0x4cd8(%rip), %xmm0     # 0x23140
callq 0xaf59
xorps %xmm0, %xmm0
callq 0xaf59
movsd 0x4cc3(%rip), %xmm0     # 0x23140
callq 0xaf59
cvtsi2sd %ebx, %xmm0
callq 0xaf59
pushq $0x5
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x85eb
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x9fd6
leaq 0x2053d(%rip), %r14     # 0x3e9f0
testl %eax, %eax
je 0x1e4ce
movl $0xe28892, %edi         # imm = 0xE28892
callq 0x1e44b
movb 0x10(%rbx), %r15b
movq 0x22dc4(%rip), %r12     # 0x41290
jmp 0x1e4ef
movb 0x10(%rbx), %r15b
cmpb $0x1, %r15b
movq %r14, %rax
cmoveq %rbx, %rax
movq (%rax), %r12
movq 0x22da9(%rip), %rax     # 0x41290
cmpq %rax, %r12
je 0x1e51c
movq %rax, %r12
cmpb $0x1, %r15b
cmoveq %rbx, %r14
cmpq %r12, (%r14)
je 0x1e50c
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1f050
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1efdb
leaq 0x8(%rbx), %rax
cmpb $0x1, %r15b
cmovneq %r14, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rax
movq (%rax), %rdi
callq 0x9fd6
testl %eax, %eax
jne 0x1e4b7
jmp 0x1e4ef
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_update_list
void
fmt_update_list(int t)
{
	int d, h, i, w;
	struct atom *p1;

	if (tos - t == 1)
		return;

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

	for (i = t; i < tos; i++) {
		p1 = stack[i];
		h = MAX(h, HEIGHT(p1));
		d = MAX(d, DEPTH(p1));
		w += WIDTH(p1);
	}

	list(tos - t);
	p1 = pop();

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

	list(5);
}

// Assembly:
movl %edi, %eax
movslq 0x19d5a(%rip), %rcx     # 0x382a8
movl %ecx, %edi
subl %eax, %edi
cmpl $0x1, %edi
jne 0x1e558
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x20486(%rip), %rdx     # 0x3e9f0
cltq
leaq 0x2303d(%rip), %rsi     # 0x415b0
leaq (%rsi,%rax,8), %rsi
xorl %r15d, %r15d
leaq 0x2046f(%rip), %r8      # 0x3e9f0
xorl %r9d, %r9d
xorl %r14d, %r14d
movl %r9d, %r12d
cmpq %rcx, %rax
jge 0x1e699
movq (%rsi), %r9
leaq 0x8(%r9), %r10
cmpb $0x1, 0x10(%r9)
cmovneq %r8, %r10
movq (%r10), %r10
movb 0x10(%r10), %r11b
cmpb $0x1, %r11b
movq %r8, %r9
cmoveq %r10, %r9
movq (%r9), %r9
cvttsd2si (%r9), %r9d
cmpl %r9d, %r12d
cmovgl %r12d, %r9d
cmpb $0x1, %r11b
jne 0x1e5dd
movq 0x8(%r10), %rbx
cmpb $0x1, 0x10(%rbx)
movq %r8, %r12
jne 0x1e5ec
leaq 0x8(%r10), %rbx
jmp 0x1e5e9
cmpb $0x1, 0x10(%rdx)
movq %r8, %rbx
movq %r8, %r12
jne 0x1e5ec
movq (%rbx), %r12
movq (%r12), %rbx
cvttsd2si (%rbx), %ebx
cmpl %ebx, %r15d
jg 0x1e616
movq %rdx, %rbx
cmpb $0x1, %r11b
jne 0x1e606
movq 0x8(%r10), %rbx
cmpb $0x1, 0x10(%rbx)
cmovneq %r8, %rbx
movq (%rbx), %rbx
cvttsd2si (%rbx), %r15d
cmpb $0x1, %r11b
jne 0x1e62c
movq 0x8(%r10), %rbx
cmpb $0x1, 0x10(%rbx)
jne 0x1e65d
leaq 0x8(%r10), %r12
jmp 0x1e638
cmpb $0x1, 0x10(%rdx)
movq %r8, %r12
movq %r8, %rbx
jne 0x1e682
movq (%r12), %rbx
movq 0x8(%rbx), %rbx
cmpb $0x1, 0x10(%rbx)
movq %r8, %rbx
jne 0x1e682
cmpb $0x1, %r11b
je 0x1e666
cmpb $0x1, 0x10(%rdx)
movq %r8, %r10
movq %r8, %r11
je 0x1e678
jmp 0x1e67f
cmpb $0x1, 0x10(%rdx)
movq %r8, %rbx
jne 0x1e682
movq 0x8(%r10), %r11
cmpb $0x1, 0x10(%r11)
movq %r8, %r11
jne 0x1e67f
addq $0x8, %r10
movq (%r10), %r11
addq $0x8, %r11
movq (%r11), %rbx
movq (%rbx), %r10
cvttsd2si (%r10), %r10d
addl %r10d, %r14d
incq %rax
addq $0x8, %rsi
jmp 0x1e587
callq 0x85eb
callq 0x868d
movq %rax, %rbx
movsd 0x4b02(%rip), %xmm0     # 0x231b0
callq 0xaf59
cvtsi2sd %r12d, %xmm0
callq 0xaf59
cvtsi2sd %r15d, %xmm0
callq 0xaf59
cvtsi2sd %r14d, %xmm0
callq 0xaf59
movq %rbx, %rdi
callq 0x861b
pushq $0x5
popq %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x85eb
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
callq 0x868d
movq %rax, %rbx
cmpb $0x1, 0x10(%rax)
leaq 0x8(%rax), %rcx
leaq 0x202e5(%rip), %rax     # 0x3e9f0
cmovneq %rax, %rcx
movq (%rcx), %rcx
movb 0x10(%rcx), %dl
cmpb $0x1, %dl
jne 0x1e764
movq (%rcx), %rax
cvttsd2si (%rax), %r14d
movq 0x8(%rcx), %rsi
cmpb $0x1, 0x10(%rsi)
leaq 0x202bf(%rip), %rax     # 0x3e9f0
movq %rax, %rdi
cmoveq %rsi, %rdi
movq (%rdi), %rdi
cvttsd2si (%rdi), %r15d
jne 0x1e7b2
movq 0x8(%rsi), %rsi
cmpb $0x1, 0x10(%rsi)
jne 0x1e7c7
cmpb $0x1, %dl
jne 0x1e795
movq 0x8(%rcx), %rdx
cmpb $0x1, 0x10(%rdx)
jne 0x1e7bf
addq $0x8, %rcx
movq %rcx, %rax
jmp 0x1e7a9
movq 0x20285(%rip), %rcx     # 0x3e9f0
cvttsd2si (%rcx), %r14d
cmpb $0x1, 0x10(%rcx)
jne 0x1e7c4
movq (%rcx), %rcx
cvttsd2si (%rcx), %r15d
movq 0x2026b(%rip), %rcx     # 0x3e9f0
cmpb $0x1, 0x10(%rcx)
jne 0x1e7c7
movq 0x8(%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0x1e7c7
leaq 0x20254(%rip), %rax     # 0x3e9f0
movq 0x2024d(%rip), %rcx     # 0x3e9f0
cmpb $0x1, 0x10(%rcx)
jne 0x1e7bf
movq (%rax), %rax
addq $0x8, %rax
jmp 0x1e7bf
movq 0x20237(%rip), %rcx     # 0x3e9f0
cmpb $0x1, 0x10(%rcx)
jne 0x1e7c7
movq (%rax), %rax
jmp 0x1e7c7
movl %r14d, %r15d
movq (%rax), %rax
movsd (%rax), %xmm0
cmpl $0x1, %r14d
jg 0x1e7d9
testl %r15d, %r15d
jle 0x1e7e7
incl %r15d
cmpl %r14d, %r15d
cmovlel %r14d, %r15d
leal 0x1(%r15), %r14d
cvttsd2si %xmm0, %r12d
addl $0x2, %r12d
movsd 0x49c0(%rip), %xmm0     # 0x231b8
callq 0xaf59
cvtsi2sd %r14d, %xmm0
callq 0xaf59
cvtsi2sd %r15d, %xmm0
callq 0xaf59
cvtsi2sd %r12d, %xmm0
callq 0xaf59
movq %rbx, %rdi
callq 0x861b
pushq $0x5
popq %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x85eb
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8c2a
testl %eax, %eax
jne 0x1e851
movq %rbx, %rdi
callq 0x17b57
testl %eax, %eax
je 0x1e85f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1e8b3
movzbl 0x10(%rbx), %eax
movq %rbx, %rcx
cmpl $0x1, %eax
je 0x1e877
cmpl $0x5, %eax
je 0x1e851
leaq 0x20179(%rip), %rcx     # 0x3e9f0
movq (%rcx), %rcx
cmpq 0x22a0f(%rip), %rcx     # 0x41290
je 0x1e851
cmpb $0x1, %al
leaq 0x20164(%rip), %rax     # 0x3e9f0
cmoveq %rbx, %rax
movq (%rax), %rax
cmpq 0x229fe(%rip), %rax     # 0x41298
je 0x1e851
cmpq 0x229fd(%rip), %rax     # 0x412a0
je 0x1e851
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1e499
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movl 0x199cf(%rip), %eax     # 0x382a8
movl %eax, -0x2c(%rbp)
callq 0x8c59
movl %eax, -0x30(%rbp)
leaq 0x8(%r15), %rax
cmpb $0x1, 0x10(%r15)
leaq 0x200fc(%rip), %r12     # 0x3e9f0
cmovneq %r12, %rax
movq (%rax), %r13
cmpb $0x1, 0x10(%r13)
jne 0x1ea3e
movq (%r13), %r15
movq 0x8(%r13), %r13
movq %r15, %rdi
callq 0x8c96
testl %eax, %eax
je 0x1e8fb
movl -0x2c(%rbp), %eax
cmpl %eax, 0x19985(%rip)     # 0x382a8
jle 0x1e92a
callq 0x1ea54
movzbl 0x10(%r15), %r14d
cmpl $0x1, %r14d
je 0x1e951
movq %r12, %rax
cmpl $0x4, %r14d
jne 0x1e955
movq 0x8(%r15), %rdi
callq 0x7bb4
movq %rax, %rdi
callq 0x1ea8b
jmp 0x1e8fb
leaq 0x8(%r15), %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %r12, %rax
jne 0x1e974
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 0x1e99e
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
callq 0xbfac
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 0x1e9f7
cmpl $0x1, -0x30(%rbp)
sete %al
cmpb $0x1, 0x10(%rdi)
movq %r12, %rcx
cmoveq %rdi, %rcx
movq (%rcx), %rcx
cmpq 0x228ad(%rip), %rcx     # 0x41290
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1ea14
callq 0x1e499
jmp 0x1e8fb
callq 0x1e833
cmpb $0x1, 0x10(%r15)
cmovneq %r12, %rbx
movq (%rbx), %rax
cmpb $0x1, 0x10(%rax)
jne 0x1ea1e
movq 0x8(%rax), %rax
jmp 0x1ea25
callq 0x1eaac
jmp 0x1e8fb
movq 0x1ffcb(%rip), %rax     # 0x3e9f0
cmpb $0x1, 0x10(%rax)
movq %r12, %rcx
jne 0x1ea31
movq %rax, %rcx
movq (%rcx), %rdi
callq 0x1eb1b
jmp 0x1e8fb
movl -0x2c(%rbp), %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1e545
// File: /workspace/github_c_makefile_star2_O2/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
movsd 0x46e0(%rip), %xmm0     # 0x23140
callq 0xaf59
xorps %xmm0, %xmm0
callq 0xaf59
xorps %xmm0, %xmm0
callq 0xaf59
movsd 0x46c3(%rip), %xmm0     # 0x23140
callq 0xaf59
pushq $0x4
popq %rdi
popq %rbp
jmp 0x85eb
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
incl 0xf08c0(%rip)           # 0x10f3e8
movq %rdi, %r14
movl 0x19777(%rip), %ebx     # 0x382a8
cmpb $0x4, 0x10(%rdi)
jne 0x1eb71
movq (%r14), %rdi
callq 0x7bb4
movq %rax, %rdi
callq 0x1ea8b
movq 0x8(%r14), %rax
cmpl $0x1, -0x4(%rax)
jne 0x1eb56
cmpl $0x1, (%rax)
je 0x1eb79
pushq $0x2f
popq %rdi
callq 0x1e44b
movq 0x8(%r14), %rdi
callq 0x7bb4
movq %rax, %rdi
callq 0x1ea8b
jmp 0x1eb79
movq %r14, %rdi
callq 0x1eb8f
movl %ebx, %edi
callq 0x1e545
decl 0xf0862(%rip)           # 0x10f3e8
popq %rbx
popq %r14
popq %rbp
jmp 0x1ec53
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movsd (%rdi), %xmm0
andps 0x457f(%rip), %xmm0     # 0x23120
leaq 0xf0d58(%rip), %rdi     # 0x10f900
leaq 0x485c(%rip), %rdx      # 0x2340b
movl $0x3e8, %esi            # imm = 0x3E8
movb $0x1, %al
callq 0x7100
leaq 0xf0d3f(%rip), %rbx     # 0x10f901
movzbl -0x1(%rbx), %eax
testl %eax, %eax
je 0x1ec4e
cmpl $0x45, %eax
je 0x1ebe5
cmpl $0x65, %eax
je 0x1ebe5
movsbl %al, %edi
callq 0x1e44b
incq %rbx
jmp 0x1ebc2
movl $0xc397, %edi           # imm = 0xC397
callq 0x1e44b
leaq 0x4fd9(%rip), %rdi      # 0x23bcf
callq 0x1ea8b
incl 0xf07e7(%rip)           # 0x10f3e8
movl 0x196a0(%rip), %r14d    # 0x382a8
movzbl (%rbx), %eax
cmpl $0x2b, %eax
je 0x1ec1f
cmpl $0x2d, %eax
jne 0x1ec22
movl $0xe28892, %edi         # imm = 0xE28892
callq 0x1e44b
incq %rbx
decq %rbx
cmpb $0x30, 0x1(%rbx)
leaq 0x1(%rbx), %rbx
je 0x1ec25
movq %rbx, %rdi
callq 0x1ea8b
movl %r14d, %edi
callq 0x1e545
decl 0xf07a3(%rip)           # 0x10f3e8
popq %rbx
popq %r14
popq %rbp
jmp 0x1ec53
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x10(%rdi), %al
andb $-0x2, %al
cmpb $0x4, %al
jne 0x1efae
movq %rbx, %rdi
callq 0x8c2a
testl %eax, %eax
je 0x1efcd
incl 0xf0434(%rip)           # 0x10f3e8
movq %rbx, %rdi
callq 0x1db30
decl 0xf0426(%rip)           # 0x10f3e8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1ec53
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1eb1b
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
leaq 0x8(%rdi), %rax
cmpb $0x1, 0x10(%rdi)
leaq 0x1f9fc(%rip), %rbx     # 0x3e9f0
cmovneq %rbx, %rax
movq (%rax), %r15
pushq $0x2b
popq %r14
cmpb $0x1, 0x10(%r15)
movq %rbx, %rax
cmoveq %r15, %rax
movq (%rax), %rdi
callq 0x1f050
leaq 0x8(%r15), %rax
cmpb $0x1, 0x10(%r15)
cmovneq %rbx, %rax
movq (%rax), %r15
cmpb $0x1, 0x10(%r15)
jne 0x1f045
movq (%r15), %rdi
callq 0x9fd6
movl %r14d, %edi
testl %eax, %eax
je 0x1f03e
movl $0xe28892, %edi         # imm = 0xE28892
callq 0x1f07b
jmp 0x1efff
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpl $0x1, -0x4(%rax)
jne 0x1f0c7
cmpl $0x1, (%rax)
jne 0x1f0c7
movq (%rbx), %rdi
callq 0x7bb4
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1ea8b
incl 0xf031b(%rip)           # 0x10f3e8
movl 0x191d4(%rip), %r14d    # 0x382a8
movq (%rbx), %rdi
callq 0x7bb4
movq %rax, %rdi
callq 0x1ea8b
movl %r14d, %edi
callq 0x1e545
movl 0x191b5(%rip), %r14d    # 0x382a8
movq 0x8(%rbx), %rdi
callq 0x7bb4
movq %rax, %rdi
callq 0x1ea8b
movl %r14d, %edi
callq 0x1e545
decl 0xf02d6(%rip)           # 0x10f3e8
popq %rbx
popq %r14
popq %rbp
jmp 0x1f6f0
// File: /workspace/github_c_makefile_star2_O2/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, 0x2218f(%rip)     # 0x412b8
je 0x1f13d
movb 0x10(%rdi), %al
movl %eax, %ecx
andb $-0x2, %cl
cmpb $0x2, %cl
jne 0x1f146
movq (%rdi), %rbx
jmp 0x1f14d
leaq 0x428d(%rip), %rdi      # 0x233d1
jmp 0x1f1a4
leaq 0x8e83(%rip), %rbx      # 0x27fd0
cmpb $0x2, %al
je 0x1f1a1
cmpq %rdi, 0x1f258(%rip)     # 0x3e3b0
je 0x1f1a1
cmpq %rdi, 0x20baf(%rip)     # 0x3fd10
je 0x1f1a1
cmpq %rdi, 0x20bb6(%rip)     # 0x3fd20
je 0x1f1a1
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1ffb5
movslq %eax, %rcx
cmpb $0x0, (%rbx,%rcx)
je 0x1f1c4
incl 0xf0263(%rip)           # 0x10f3e8
movl 0x1911c(%rip), %r14d    # 0x382a8
movslq %eax, %rcx
cmpb $0x0, (%rbx,%rcx)
je 0x1f1ad
movq %rbx, %rdi
movl %eax, %esi
callq 0x1ffb5
jmp 0x1f18c
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1ea8b
movl %r14d, %edi
callq 0x1e545
decl 0xf022d(%rip)           # 0x10f3e8
popq %rbx
popq %r14
popq %rbp
jmp 0x20040
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x10(%rdi), %r12b
leaq 0x8(%rdi), %r14
cmpb $0x1, %r12b
leaq 0x1f7d3(%rip), %r15     # 0x3e9f0
movq %r15, %rax
cmoveq %r14, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r15, %rax
movq (%rax), %rax
cmpq 0x2207f(%rip), %rax     # 0x412b8
je 0x1f263
movq %rbx, %rdi
callq 0x13d3d
testl %eax, %eax
je 0x1f2c6
movq 0x1eb2a(%rip), %rdi     # 0x3dd78
callq 0xd3b4
movq %rax, %rdi
callq 0x13d3d
testl %eax, %eax
je 0x1f294
pushq $0x6a
jmp 0x1f2ae
leaq 0x8dca(%rip), %rdi      # 0x28034
callq 0x1ea8b
cmpb $0x1, 0x10(%rbx)
leaq 0x1f776(%rip), %rax     # 0x3e9f0
cmoveq %r14, %rax
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1e3b1
movq 0x1e7bd(%rip), %rdi     # 0x3da58
callq 0xd3b4
movq %rax, %rdi
callq 0x13d3d
testl %eax, %eax
je 0x1f2c2
pushq $0x69
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1e44b
movb 0x10(%rbx), %r12b
cmpb $0x1, %r12b
movq %r15, %rax
cmoveq %r14, %rax
movq (%rax), %r12
movb 0x10(%r12), %r13b
cmpb $0x1, %r13b
jne 0x1f2e6
movq 0x8(%r12), %rax
jmp 0x1f2ed
movq 0x1f703(%rip), %rax     # 0x3e9f0
cmpb $0x1, 0x10(%rax)
jne 0x1f2f6
movq %rax, %r15
movq (%r15), %rdi
callq 0x8c2a
testl %eax, %eax
je 0x1f318
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1fee2
cmpb $0x1, %r13b
leaq 0x1f6cd(%rip), %r15     # 0x3e9f0
cmovneq %r15, %r12
movq (%r12), %rdi
callq 0x1e833
cmpb $0x1, 0x10(%rbx)
cmovneq %r15, %r14
movq (%r14), %rax
cmpb $0x1, 0x10(%rax)
jne 0x1f347
movq 0x8(%rax), %rax
jmp 0x1f34e
movq 0x1f6a2(%rip), %rax     # 0x3e9f0
cmpb $0x1, 0x10(%rax)
jne 0x1f357
movq %rax, %r15
movq (%r15), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1ef90
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_numerators
void
fmt_numerators(struct atom *p)
{
	int n, t;
	char *s;
	struct atom *q;

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

	while (iscons(p)) {

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

		if (!isnumerator(q))
			continue;

		if (tos > t)
			fmt_space();

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

		if (car(q) == symbol(ADD) && n == 1)
			fmt_expr(q); // parens not needed
		else
			fmt_factor(q);
	}

	if (t == tos)
		fmt_roman_char('1'); // no numerators

	fmt_update_list(t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movl 0x18c76(%rip), %ebx     # 0x382a8
callq 0x8d25
movl %eax, %r14d
leaq 0x8(%r15), %rax
cmpb $0x1, 0x10(%r15)
leaq 0x1f3a6(%rip), %r12     # 0x3e9f0
cmovneq %r12, %rax
movq (%rax), %r13
cmpb $0x1, 0x10(%r13)
jne 0x1f6cb
movq (%r13), %r15
movq 0x8(%r13), %r13
movq %r15, %rdi
callq 0x8d62
testl %eax, %eax
je 0x1f651
cmpl %ebx, 0x18c36(%rip)     # 0x382a8
jle 0x1f679
callq 0x1ea54
movzbl 0x10(%r15), %ecx
movq %r15, %rax
cmpl $0x1, %ecx
je 0x1f6a0
cmpl $0x4, %ecx
jne 0x1f69d
movq (%r15), %rdi
callq 0x7bb4
movq %rax, %rdi
callq 0x1ea8b
jmp 0x1f651
movq %r12, %rax
cmpl $0x1, %r14d
sete %cl
movq (%rax), %rax
cmpq 0x21bdf(%rip), %rax     # 0x41290
sete %al
andb %cl, %al
movq %r15, %rdi
cmpb $0x1, %al
jne 0x1f6c4
callq 0x1e499
jmp 0x1f651
callq 0x1eaac
jmp 0x1f651
cmpl 0x18bd7(%rip), %ebx     # 0x382a8
jne 0x1f6db
pushq $0x31
popq %rdi
callq 0x1e44b
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1e545
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_indices
void
fmt_indices(struct atom *p)
{
	fmt_roman_char('[');

	p = cdr(p);

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

	fmt_roman_char(']');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x5b
popq %rdi
callq 0x1e44b
cmpb $0x1, 0x10(%rbx)
leaq 0x8(%rbx), %rax
leaq 0x1f024(%rip), %r14     # 0x3e9f0
cmovneq %r14, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
jne 0x1fa14
pushq $0x2c
popq %rbx
movq %rax, %r15
movq (%rax), %rdi
callq 0x1e499
leaq 0x8(%r15), %rax
cmpb $0x1, 0x10(%r15)
cmovneq %r14, %rax
movq (%rax), %r15
cmpb $0x1, 0x10(%r15)
jne 0x1fa14
movl %ebx, %edi
callq 0x1e44b
cmpb $0x1, 0x10(%r15)
movq %r15, %rax
je 0x1f9df
movq %r14, %rax
jmp 0x1f9df
pushq $0x5d
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1e44b
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_matrix
void
fmt_matrix(struct atom *p, int d, int k)
{
	int i, j, m, n, span;

	if (d == p->u.tensor->ndim) {
		fmt_list(p->u.tensor->elem[k]);
		return;
	}

	// compute element span

	span = 1;

	for (i = d + 2; i < p->u.tensor->ndim; i++)
		span *= p->u.tensor->dim[i];

	n = p->u.tensor->dim[d];	// number of rows
	m = p->u.tensor->dim[d + 1];	// number of columns

	for (i = 0; i < n; i++)
		for (j = 0; j < m; j++)
			fmt_matrix(p, d + 2, k + (i * m + j) * span);

	fmt_update_table(n, m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq (%rdi), %rax
movslq (%rax), %rcx
cmpl %esi, %ecx
jne 0x1fa5e
movslq %ebx, %rcx
movq 0x68(%rax,%rcx,8), %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1db30
movq %rdi, %r14
leal 0x2(%rsi), %r15d
movslq %r15d, %rdi
pushq $0x1
popq %r13
cmpq %rcx, %rdi
jge 0x1fa7c
imull 0x4(%rax,%rdi,4), %r13d
incq %rdi
jmp 0x1fa6c
movslq %esi, %rcx
movl 0x4(%rax,%rcx,4), %esi
movl 0x8(%rax,%rcx,4), %eax
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edi
cmovgl %eax, %edi
movl %edi, -0x38(%rbp)
testl %esi, %esi
movl $0x0, %edi
movl %esi, -0x30(%rbp)
cmovgl %esi, %edi
movl %edi, -0x3c(%rbp)
movl %eax, -0x2c(%rbp)
imull %r13d, %eax
movl %eax, -0x34(%rbp)
cmpl -0x3c(%rbp), %ecx
je 0x1fae4
movl %ecx, -0x40(%rbp)
movl %ebx, -0x44(%rbp)
movl -0x38(%rbp), %r12d
subl $0x1, %r12d
jb 0x1fad7
movq %r14, %rdi
movl %r15d, %esi
movl %ebx, %edx
callq 0x1fa26
addl %r13d, %ebx
jmp 0x1fabf
movl -0x40(%rbp), %ecx
incl %ecx
movl -0x44(%rbp), %ebx
addl -0x34(%rbp), %ebx
jmp 0x1fab0
movl -0x30(%rbp), %edi
movl -0x2c(%rbp), %esi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1fafd
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_reciprocal
void
fmt_reciprocal(struct atom *p)
{
	int t;

	fmt_roman_char('1'); // numerator

	t = tos;

	if (isminusone(caddr(p)))
		fmt_expr(cadr(p));
	else {
		fmt_base(cadr(p));
		fmt_numeric_exponent(caddr(p)); // sign is not emitted
	}

	fmt_update_list(t);

	fmt_update_fraction();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0x31
popq %rdi
callq 0x1e44b
leaq 0x8(%r14), %r15
cmpb $0x1, 0x10(%r14)
leaq 0x1eae5(%rip), %r12     # 0x3e9f0
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %r13
movb 0x10(%r13), %bl
cmpb $0x1, %bl
jne 0x1ff24
movq 0x8(%r13), %rax
jmp 0x1ff2b
movq 0x1eac5(%rip), %rax     # 0x3e9f0
cmpb $0x1, 0x10(%rax)
movq %r12, %rcx
jne 0x1ff37
movq %rax, %rcx
movl 0x1836b(%rip), %eax     # 0x382a8
movl %eax, -0x2c(%rbp)
movq (%rcx), %rdi
callq 0xbfac
cmpb $0x1, %bl
cmoveq %r13, %r12
movq (%r12), %rdi
testl %eax, %eax
je 0x1ff5e
callq 0x1e499
jmp 0x1ff9a
callq 0x1e833
cmpb $0x1, 0x10(%r14)
leaq 0x1ea81(%rip), %rax     # 0x3e9f0
cmovneq %rax, %r15
movq (%r15), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0x1ff82
movq 0x8(%rcx), %rcx
jmp 0x1ff89
movq 0x1ea67(%rip), %rcx     # 0x3e9f0
cmpb $0x1, 0x10(%rcx)
jne 0x1ff92
movq %rcx, %rax
movq (%rax), %rdi
callq 0x1eb1b
movl -0x2c(%rbp), %edi
callq 0x1e545
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1f6f0
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_symbol_fragment
int
fmt_symbol_fragment(char *s, int k)
{
	int c, i, n;
	char *t;

	for (i = 0; i < NUM_SYMBOL_NAMES; i++) {
		t = symbol_name_tab[i];
		n = (int) strlen(t);
		if (strncmp(s + k, t, n) == 0)
			break;
	}

	if (i == NUM_SYMBOL_NAMES) {
		fmt_roman_char(s[k]);
		return k + 1;
	}

	c = symbol_unicode_tab[i];

	fmt_roman_char(c);

	return k + n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, -0x2c(%rbp)
movslq %esi, %r14
addq %rdi, %r14
leaq 0x1718d(%rip), %rbx     # 0x37160
xorl %r13d, %r13d
cmpq $0xc4, %r13
je 0x20009
movq (%rbx), %r12
movq %r12, %rdi
callq 0x70e0
movq %rax, %r15
movslq %r15d, %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x7080
testl %eax, %eax
je 0x20019
addq $0x4, %r13
addq $0x8, %rbx
jmp 0x1ffd6
movsbl (%r14), %edi
callq 0x1e44b
movl -0x2c(%rbp), %eax
incl %eax
jmp 0x20031
leaq 0x172d0(%rip), %rax     # 0x372f0
movl (%r13,%rax), %edi
callq 0x1e44b
addl -0x2c(%rbp), %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_update_subscript
void
fmt_update_subscript(void)
{
	int d, dx, dy, h, w;
	struct atom *p1;

	p1 = pop();

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

	dx = 0;
	dy = 1;

	push_double(EMIT_SUBSCRIPT);
	push_double(h);
	push_double(d + dy);
	push_double(w);
	push_double(dx);
	push_double(dy);
	push(p1);

	list(7);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
callq 0x868d
movq %rax, %rbx
cmpb $0x1, 0x10(%rax)
leaq 0x8(%rax), %rcx
leaq 0x1e98e(%rip), %rax     # 0x3e9f0
cmovneq %rax, %rcx
movq (%rcx), %rcx
movb 0x10(%rcx), %dl
cmpb $0x1, %dl
jne 0x200bd
movq (%rcx), %rax
movq 0x8(%rcx), %rsi
movsd (%rax), %xmm0
movaps %xmm0, -0x20(%rbp)
cmpb $0x1, 0x10(%rsi)
leaq 0x1e965(%rip), %rax     # 0x3e9f0
movq %rax, %rdi
cmoveq %rsi, %rdi
movq (%rdi), %rdi
movsd (%rdi), %xmm0
jne 0x2010e
movq 0x8(%rsi), %rsi
cmpb $0x1, 0x10(%rsi)
jne 0x2011e
cmpb $0x1, %dl
jne 0x200f1
movq 0x8(%rcx), %rdx
cmpb $0x1, 0x10(%rdx)
jne 0x2011b
addq $0x8, %rcx
movq %rcx, %rax
jmp 0x20105
movq 0x1e92c(%rip), %rcx     # 0x3e9f0
movsd (%rcx), %xmm0
cmpb $0x1, 0x10(%rcx)
movapd %xmm0, -0x20(%rbp)
jne 0x2011e
movq (%rcx), %rcx
movsd (%rcx), %xmm0
movq 0x1e90f(%rip), %rcx     # 0x3e9f0
cmpb $0x1, 0x10(%rcx)
jne 0x2011e
movq 0x8(%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0x2011e
leaq 0x1e8f8(%rip), %rax     # 0x3e9f0
movq 0x1e8f1(%rip), %rcx     # 0x3e9f0
cmpb $0x1, 0x10(%rcx)
jne 0x2011b
movq (%rax), %rax
addq $0x8, %rax
jmp 0x2011b
movq 0x1e8db(%rip), %rcx     # 0x3e9f0
cmpb $0x1, 0x10(%rcx)
jne 0x2011e
movq (%rax), %rax
movq (%rax), %rax
cvttsd2si %xmm0, %r14d
movsd (%rax), %xmm0
movaps %xmm0, -0x30(%rbp)
movsd 0x309a(%rip), %xmm0     # 0x231d0
callq 0xaf59
cvttpd2dq -0x20(%rbp), %xmm0
cvtdq2pd %xmm0, %xmm0
callq 0xaf59
incl %r14d
cvtsi2sd %r14d, %xmm0
callq 0xaf59
cvttpd2dq -0x30(%rbp), %xmm0
cvtdq2pd %xmm0, %xmm0
callq 0xaf59
xorps %xmm0, %xmm0
callq 0xaf59
movsd 0x2fcc(%rip), %xmm0     # 0x23140
callq 0xaf59
movq %rbx, %rdi
callq 0x861b
pushq $0x7
popq %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x85eb