LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: darctan
void
darctan(struct atom *p1, struct atom *p2)
{
	push(cadr(p1));
	push(p2);
	derivative();
	push_integer(1);
	push(cadr(p1));
	push_integer(2);
	power();
	add();
	reciprocate();
	multiply();
}

// 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 0x33163(%rip), %r15     # 0x45a00
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x8ba5
movq %r14, %rdi
callq 0x8ba5
callq 0x1198a
movq 0xf920a(%rip), %rdi     # 0x10bad8
callq 0x8ba5
cmpb $0x1, 0x10(%rbx)
cmovneq %r15, %r12
movq (%r12), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r15
movq (%r15), %rdi
callq 0x8ba5
movl $0x2, %edi
callq 0xb1be
callq 0xa573
movl $0x2, %edi
callq 0xadb3
movq 0x103ae1(%rip), %rdi    # 0x1163f0
callq 0x8ba5
callq 0xa573
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xacef
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: dsinh
void
dsinh(struct atom *p1, struct atom *p2)
{
	push(cadr(p1));
	push(p2);
	derivative();
	push(cadr(p1));
	coshfunc();
	multiply();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
cmpb $0x1, 0x10(%rdi)
leaq 0x330b8(%rip), %r12     # 0x45a00
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x8ba5
movq %r14, %rdi
callq 0x8ba5
callq 0x1198a
cmpb $0x1, 0x10(%rbx)
cmovneq %r12, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r12
movq (%r12), %rdi
callq 0x8ba5
callq 0x110a5
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xacef
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: dcosh
void
dcosh(struct atom *p1, struct atom *p2)
{
	push(cadr(p1));
	push(p2);
	derivative();
	push(cadr(p1));
	sinhfunc();
	multiply();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
cmpb $0x1, 0x10(%rdi)
leaq 0x3303e(%rip), %r12     # 0x45a00
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x8ba5
movq %r14, %rdi
callq 0x8ba5
callq 0x1198a
cmpb $0x1, 0x10(%rbx)
cmovneq %r12, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r12
movq (%r12), %rdi
callq 0x8ba5
callq 0x12f15
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xacef
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: dtanh
void
dtanh(struct atom *p1, struct atom *p2)
{
	push(cadr(p1));
	push(p2);
	derivative();
	push(cadr(p1));
	coshfunc();
	push_integer(-2);
	power();
	multiply();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
cmpb $0x1, 0x10(%rdi)
leaq 0x32fc4(%rip), %r12     # 0x45a00
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x8ba5
movq %r14, %rdi
callq 0x8ba5
callq 0x1198a
cmpb $0x1, 0x10(%rbx)
cmovneq %r12, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r12
movq (%r12), %rdi
callq 0x8ba5
callq 0x110a5
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
callq 0xb1be
callq 0xa573
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xacef
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: darcsinh
void
darcsinh(struct atom *p1, struct atom *p2)
{
	push(cadr(p1));
	push(p2);
	derivative();
	push(cadr(p1));
	push_integer(2);
	power();
	push_integer(1);
	add();
	push_rational(-1, 2);
	power();
	multiply();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
cmpb $0x1, 0x10(%rdi)
leaq 0x32f3b(%rip), %r12     # 0x45a00
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x8ba5
movq %r14, %rdi
callq 0x8ba5
callq 0x1198a
cmpb $0x1, 0x10(%rbx)
cmovneq %r12, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r12
movq (%r12), %rdi
callq 0x8ba5
movl $0x2, %edi
callq 0xb1be
callq 0xa573
movq 0xf8fb7(%rip), %rdi     # 0x10bad8
callq 0x8ba5
movl $0x2, %edi
callq 0xadb3
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x2, %esi
callq 0xa533
callq 0xa573
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xacef
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: darccosh
void
darccosh(struct atom *p1, struct atom *p2)
{
	push(cadr(p1));
	push(p2);
	derivative();
	push(cadr(p1));
	push_integer(2);
	power();
	push_integer(-1);
	add();
	push_rational(-1, 2);
	power();
	multiply();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
cmpb $0x1, 0x10(%rdi)
leaq 0x32e8d(%rip), %r12     # 0x45a00
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x8ba5
movq %r14, %rdi
callq 0x8ba5
callq 0x1198a
cmpb $0x1, 0x10(%rbx)
cmovneq %r12, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r12
movq (%r12), %rdi
callq 0x8ba5
movl $0x2, %edi
callq 0xb1be
callq 0xa573
movq 0x103821(%rip), %rdi    # 0x1163f0
callq 0x8ba5
movl $0x2, %edi
callq 0xadb3
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x2, %esi
callq 0xa533
callq 0xa573
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xacef
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: darctanh
void
darctanh(struct atom *p1, struct atom *p2)
{
	push(cadr(p1));
	push(p2);
	derivative();
	push_integer(1);
	push(cadr(p1));
	push_integer(2);
	power();
	subtract();
	reciprocate();
	multiply();
}

// 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 0x32ddf(%rip), %r15     # 0x45a00
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x8ba5
movq %r14, %rdi
callq 0x8ba5
callq 0x1198a
movq 0xf8e86(%rip), %rdi     # 0x10bad8
callq 0x8ba5
cmpb $0x1, 0x10(%rbx)
cmovneq %r15, %r12
movq (%r12), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r15
movq (%r15), %rdi
callq 0x8ba5
movl $0x2, %edi
callq 0xb1be
callq 0xa573
movq 0x103767(%rip), %rdi    # 0x1163f0
callq 0x8ba5
movl $0x2, %edi
callq 0xacef
movl $0x2, %edi
callq 0xadb3
movq 0x103747(%rip), %rdi    # 0x1163f0
callq 0x8ba5
callq 0xa573
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xacef
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: derf
void
derf(struct atom *p1, struct atom *p2)
{
	push(cadr(p1));
	push_integer(2);
	power();
	push_integer(-1);
	multiply();
	expfunc();
	push_symbol(PI);
	push_rational(-1, 2);
	power();
	multiply();
	push_integer(2);
	multiply();
	push(cadr(p1));
	push(p2);
	derivative();
	multiply();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %r12
cmpb $0x1, 0x10(%rdi)
leaq 0x32d1e(%rip), %r15     # 0x45a00
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %rbx
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x8ba5
movl $0x2, %edi
callq 0xb1be
callq 0xa573
movq 0x1036db(%rip), %rdi    # 0x1163f0
callq 0x8ba5
movl $0x2, %edi
callq 0xacef
movq 0x3559d(%rip), %rdi     # 0x482c8
callq 0x8ba5
callq 0xb238
callq 0xa573
movq 0x3330f(%rip), %rdi     # 0x46050
callq 0x8ba5
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x2, %esi
callq 0xa533
callq 0xa573
movl $0x2, %edi
callq 0xacef
movl $0x2, %edi
callq 0xb1be
movl $0x2, %edi
callq 0xacef
cmpb $0x1, 0x10(%r14)
cmovneq %r15, %r12
movq (%r12), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r15
movq (%r15), %rdi
callq 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
callq 0x1198a
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xacef
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: derfc
void
derfc(struct atom *p1, struct atom *p2)
{
	push(cadr(p1));
	push_integer(2);
	power();
	push_integer(-1);
	multiply();
	expfunc();
	push_symbol(PI);
	push_rational(-1,2);
	power();
	multiply();
	push_integer(-2);
	multiply();
	push(cadr(p1));
	push(p2);
	derivative();
	multiply();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %r12
cmpb $0x1, 0x10(%rdi)
leaq 0x32c2f(%rip), %r15     # 0x45a00
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %rbx
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x8ba5
movl $0x2, %edi
callq 0xb1be
callq 0xa573
movq 0x1035ec(%rip), %rdi    # 0x1163f0
callq 0x8ba5
movl $0x2, %edi
callq 0xacef
movq 0x354ae(%rip), %rdi     # 0x482c8
callq 0x8ba5
callq 0xb238
callq 0xa573
movq 0x33220(%rip), %rdi     # 0x46050
callq 0x8ba5
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x2, %esi
callq 0xa533
callq 0xa573
movl $0x2, %edi
callq 0xacef
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
callq 0xb1be
movl $0x2, %edi
callq 0xacef
cmpb $0x1, 0x10(%r14)
cmovneq %r15, %r12
movq (%r12), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r15
movq (%r15), %rdi
callq 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
callq 0x1198a
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xacef
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: dfunction
void
dfunction(struct atom *p1, struct atom *p2)
{
	struct atom *p3;

	p3 = cdr(p1); // p3 is the argument list for the function

	if (p3 == symbol(NIL) || findf(p3, p2)) {
		push_symbol(DERIVATIVE);
		push(p1);
		push(p2);
		list(3);
	} else
		push_integer(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rax
leaq 0x32b44(%rip), %rcx     # 0x45a00
cmoveq %rax, %rcx
movq %rsi, %r14
movq (%rcx), %rdi
cmpq 0x32b33(%rip), %rdi     # 0x45a00
je 0x12edb
movq %r14, %rsi
callq 0x8c99
testl %eax, %eax
je 0x12f05
movq 0x30bfe(%rip), %rdi     # 0x43ae0
callq 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
movq %r14, %rdi
callq 0x8ba5
movl $0x3, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x8b7d
movq 0x30234(%rip), %rdi     # 0x43140
popq %rbx
popq %r14
popq %rbp
jmp 0x8ba5
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_dim
void
eval_dim(struct atom *p1)
{
	int k;
	struct atom *p2;

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

	if (!istensor(p2)) {
		push_integer(1);
		return;
	}

	if (lengthf(p1) == 2)
		k = 1;
	else {
		push(caddr(p1));
		evalf();
		k = pop_integer();
	}

	if (k < 1 || k > p2->u.tensor->ndim)
		stopf("dim 2nd arg: error");

	push_integer(p2->u.tensor->dim[k - 1]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
cmpb $0x1, 0x10(%rdi)
leaq 0x32835(%rip), %r12     # 0x45a00
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x8ba5
callq 0x96e2
movl 0x2c0c8(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x132a7
decl %eax
movl %eax, 0x2c0b0(%rip)     # 0x3f2b8
leaq 0x353b1(%rip), %rcx     # 0x485c0
movq (%rcx,%rax,8), %r14
cmpb $0x7, 0x10(%r14)
jne 0x13248
cmpb $0x1, 0x10(%rbx)
jne 0x13238
movl $0x2, %eax
movq 0x8(%rbx), %rbx
decl %eax
cmpb $0x1, 0x10(%rbx)
je 0x13225
movq %r15, %r12
testl %eax, %eax
je 0x132a0
movq (%r12), %rax
cmpb $0x1, 0x10(%rax)
jne 0x1325c
movq 0x8(%rax), %rax
jmp 0x13263
movq 0xf8889(%rip), %rdi     # 0x10bad8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8ba5
movq 0x3279d(%rip), %rax     # 0x45a00
cmpb $0x1, 0x10(%rax)
je 0x13270
leaq 0x32790(%rip), %rax     # 0x45a00
movq (%rax), %rdi
callq 0x8ba5
callq 0x96e2
callq 0xf8e6
testl %eax, %eax
jle 0x132b3
movq (%r14), %rcx
cmpl (%rcx), %eax
jg 0x132b3
decl %eax
movl 0x4(%rcx,%rax,4), %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xb1be
movl $0x1, %eax
jmp 0x13286
leaq 0x1bc93(%rip), %rdi     # 0x2ef41
callq 0x780b
leaq 0x1706b(%rip), %rdi     # 0x2a325
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_do
void
eval_do(struct atom *p1)
{
	push_symbol(NIL);
	p1 = cdr(p1);
	while (iscons(p1)) {
		pop(); // discard previous result
		push(car(p1));
		evalg();
		p1 = cdr(p1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x3272c(%rip), %r14     # 0x45a00
movq 0x32725(%rip), %rdi     # 0x45a00
callq 0x8ba5
leaq 0x8(%rbx), %rax
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %rax
movq (%rax), %rbx
cmpb $0x1, 0x10(%rbx)
jne 0x1333d
leaq 0x10(%rbx), %r12
movl $0xfffe795f, %r15d      # imm = 0xFFFE795F
movl 0x2bfb3(%rip), %eax     # 0x3f2b8
leal (%rax,%r15), %ecx
cmpl %r15d, %ecx
jbe 0x13346
decl %eax
movl %eax, 0x2bfa2(%rip)     # 0x3f2b8
movq (%rbx), %rdi
callq 0x8ba5
callq 0x96a4
addq $0x8, %rbx
cmpb $0x1, (%r12)
cmovneq %r14, %rbx
movq (%rbx), %rbx
leaq 0x10(%rbx), %r12
cmpb $0x1, 0x10(%rbx)
je 0x132ff
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1bbf4(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: eigenvec_step
int
eigenvec_step(double *D, double *Q, int n)
{
	int count, i, j;

	count = 0;

	// for each upper triangle "off-diagonal" component do step_nib

	for (i = 0; i < n - 1; i++) {
		for (j = i + 1; j < n; j++) {
			if (D[n * i + j] != 0.0) {
				eigenvec_step_nib(D, Q, n, i, j);
				count++;
			}
		}
	}

	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, -0x30(%rbp)
xorl %r13d, %r13d
cmpl $0x2, %edx
jl 0x137ed
movq %rdx, %rax
movl %eax, %r12d
decl %eax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
leaq 0x8(%rax), %r15
leaq 0x8(,%r12,8), %rax
movq %rax, -0x38(%rbp)
xorl %ebx, %ebx
movl $0x1, %r14d
xorl %r13d, %r13d
leaq 0x1(%rbx), %rax
movq %rax, -0x48(%rbp)
movq %r15, -0x58(%rbp)
movq %r14, -0x50(%rbp)
movsd (%r15), %xmm0
ucomisd 0x1698c(%rip), %xmm0    # 0x2a138
jne 0x137b0
jnp 0x137c8
movq -0x30(%rbp), %rdi
movq -0x60(%rbp), %rsi
movl %r12d, %edx
movl %ebx, %ecx
movl %r14d, %r8d
callq 0x137ff
incl %r13d
incq %r14
addq $0x8, %r15
cmpq %r14, %r12
jne 0x1379f
movq -0x50(%rbp), %r14
incq %r14
movq -0x58(%rbp), %r15
addq -0x38(%rbp), %r15
movq -0x48(%rbp), %rbx
cmpq -0x40(%rbp), %rbx
jne 0x1378f
movl %r13d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: erffunc
void
erffunc(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]);
			erffunc();
			p1->u.tensor->elem[i] = pop();
		}
		push(p1);
		return;
	}

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

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

	if (isnegativeterm(p1)) {
		push_symbol(ERF);
		push(p1);
		negate();
		list(2);
		negate();
	} else {
		push_symbol(ERF);
		push(p1);
		list(2);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x2b88a(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x13bb1
decl %eax
movl %eax, 0x2b872(%rip)     # 0x3f2b8
leaq 0x34b73(%rip), %r14     # 0x485c0
movq (%r14,%rax,8), %rbx
cmpb $0x7, 0x10(%rbx)
jne 0x13abd
movq %rbx, %rdi
callq 0x9638
movq %rax, %rbx
movq (%rax), %rax
movslq 0x64(%rax), %r15
testq %r15, %r15
jle 0x13ab8
xorl %r12d, %r12d
movl $0xfffe795f, %r13d      # imm = 0xFFFE795F
movq (%rbx), %rax
movq 0x68(%rax,%r12,8), %rdi
callq 0x8ba5
callq 0x13a1a
movl 0x2b829(%rip), %eax     # 0x3f2b8
leal (%rax,%r13), %ecx
cmpl %r13d, %ecx
jbe 0x13bb1
decl %eax
movl %eax, 0x2b814(%rip)     # 0x3f2b8
movq (%r14,%rax,8), %rax
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x13a77
movq %rbx, %rdi
jmp 0x13b1e
movq %rbx, %rdi
callq 0x8ba5
callq 0xac30
movl 0x2b7e8(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x13bb1
decl %eax
movl %eax, 0x2b7d0(%rip)     # 0x3f2b8
movq (%r14,%rax,8), %rdi
movb 0x10(%rdi), %al
andb $-0x2, %al
cmpb $0x4, %al
jne 0x13b31
callq 0x8ba5
callq 0x9128
callq 0x7050
movsd %xmm0, -0x30(%rbp)
callq 0x74dc
movb $0x5, 0x10(%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8ba5
movq %rbx, %rdi
callq 0xac49
movl %eax, %r14d
movq 0x302a5(%rip), %rdi     # 0x43de8
callq 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
testl %r14d, %r14d
je 0x13b99
movq 0x102894(%rip), %rdi    # 0x1163f0
callq 0x8ba5
movl $0x2, %edi
callq 0xacef
movl $0x2, %edi
callq 0x8b7d
movq 0x102874(%rip), %rdi    # 0x1163f0
callq 0x8ba5
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xacef
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8b7d
leaq 0x1b389(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: erfcfunc
void
erfcfunc(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]);
			erfcfunc();
			p1->u.tensor->elem[i] = pop();
		}
		push(p1);
		return;
	}

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

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

	if (isnegativeterm(p1)) {
		push_symbol(ERF);
		push(p1);
		negate();
		list(2);
	} else {
		push_symbol(ERF);
		push(p1);
		list(2);
		negate();
	}

	push_integer(1);
	add();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x2b6b2(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x13d93
decl %eax
movl %eax, 0x2b69a(%rip)     # 0x3f2b8
leaq 0x3499b(%rip), %r14     # 0x485c0
movq (%r14,%rax,8), %rbx
cmpb $0x7, 0x10(%rbx)
jne 0x13c95
movq %rbx, %rdi
callq 0x9638
movq %rax, %rbx
movq (%rax), %rax
movslq 0x64(%rax), %r15
testq %r15, %r15
jle 0x13c90
xorl %r12d, %r12d
movl $0xfffe795f, %r13d      # imm = 0xFFFE795F
movq (%rbx), %rax
movq 0x68(%rax,%r12,8), %rdi
callq 0x8ba5
callq 0x13bf2
movl 0x2b651(%rip), %eax     # 0x3f2b8
leal (%rax,%r13), %ecx
cmpl %r13d, %ecx
jbe 0x13d93
decl %eax
movl %eax, 0x2b63c(%rip)     # 0x3f2b8
movq (%r14,%rax,8), %rax
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x13c4f
movq %rbx, %rdi
jmp 0x13cf6
movq %rbx, %rdi
callq 0x8ba5
callq 0xac30
movl 0x2b610(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x13d93
decl %eax
movl %eax, 0x2b5f8(%rip)     # 0x3f2b8
movq (%r14,%rax,8), %rdi
movb 0x10(%rdi), %al
andb $-0x2, %al
cmpb $0x4, %al
jne 0x13d09
callq 0x8ba5
callq 0x9128
callq 0x7030
movsd %xmm0, -0x30(%rbp)
callq 0x74dc
movb $0x5, 0x10(%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8ba5
movq %rbx, %rdi
callq 0xac49
movl %eax, %r14d
movq 0x300cd(%rip), %rdi     # 0x43de8
callq 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
testl %r14d, %r14d
je 0x13d4f
movq 0x1026bc(%rip), %rdi    # 0x1163f0
callq 0x8ba5
movl $0x2, %edi
callq 0xacef
movl $0x2, %edi
callq 0x8b7d
jmp 0x13d6f
movl $0x2, %edi
callq 0x8b7d
movq 0x102690(%rip), %rdi    # 0x1163f0
callq 0x8ba5
movl $0x2, %edi
callq 0xacef
movq 0xf7d62(%rip), %rdi     # 0x10bad8
callq 0x8ba5
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xadb3
leaq 0x1b1a7(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_eval
void
eval_eval(struct atom *p1)
{
	push(cadr(p1));
	evalf();
	p1 = cddr(p1);
	while (iscons(p1)) {
		push(car(p1));
		evalf();
		push(cadr(p1));
		evalf();
		asubst();
		p1 = cddr(p1);
	}
}

// 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 0x31c45(%rip), %r14     # 0x45a00
movq %r14, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rax
movq (%rax), %rdi
callq 0x8ba5
callq 0x96e2
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %r15
movq (%r15), %rax
leaq 0x8(%rax), %rcx
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rcx
movq (%rcx), %rbx
cmpb $0x1, 0x10(%rbx)
jne 0x13e35
movq (%rbx), %rdi
callq 0x8ba5
callq 0x96e2
cmpb $0x1, 0x10(%rbx)
leaq 0x8(%rbx), %r15
movq %r14, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rax
movq (%rax), %rdi
callq 0x8ba5
callq 0x96e2
callq 0x13e40
jmp 0x13dda
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: addcmp
int
addcmp(struct atom *p1, struct atom *p2)
{
	if (car(p1) != symbol(ADD) || car(p2) != symbol(ADD))
		return 0;
	p1 = cdr(p1);
	p2 = cdr(p2);
	while (iscons(p1) && iscons(p2)) {
		if (equal(car(p1), car(p2)))
			p2 = cdr(p2); // next term on list
		p1 = cdr(p1);
	}
	if (iscons(p2))
		return 0;
	else
		return 1; // all terms matched
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movb 0x10(%rdi), %cl
cmpb $0x1, %cl
leaq 0x3192a(%rip), %rbx     # 0x45a00
movq %rbx, %rax
cmoveq %rdi, %rax
movq (%rax), %r8
xorl %eax, %eax
cmpq 0x341b7(%rip), %r8      # 0x482a0
jne 0x14173
movb 0x10(%rsi), %dl
cmpb $0x1, %dl
movq %rbx, %r9
cmoveq %rsi, %r9
cmpq %r8, (%r9)
jne 0x14173
addq $0x8, %rdi
cmpb $0x1, %cl
cmovneq %rbx, %rdi
addq $0x8, %rsi
cmpb $0x1, %dl
cmovneq %rbx, %rsi
movq (%rsi), %r14
movq (%rdi), %r15
cmpb $0x1, 0x10(%r15)
jne 0x14169
leaq 0x10(%r15), %r12
cmpb $0x1, 0x10(%r14)
jne 0x14169
movq (%r15), %rdi
movq (%r14), %rsi
callq 0x8d48
testl %eax, %eax
jne 0x1414e
cmpb $0x1, 0x10(%r14)
leaq 0x8(%r14), %rax
cmovneq %rbx, %rax
movq (%rax), %r14
addq $0x8, %r15
cmpb $0x1, (%r12)
cmovneq %rbx, %r15
movq (%r15), %r15
leaq 0x10(%r15), %r12
cmpb $0x1, 0x10(%r15)
je 0x14128
xorl %eax, %eax
cmpb $0x1, 0x10(%r14)
setne %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: mulcmp
int
mulcmp(struct atom *p1, struct atom *p2)
{
	if (car(p1) != symbol(MULTIPLY) || car(p2) != symbol(MULTIPLY))
		return 0;
	p1 = cdr(p1);
	p2 = cdr(p2);
	while (iscons(p1) && iscons(p2)) {
		if (equal(car(p1), car(p2)) || powcmp(car(p1), car(p2)))
			p2 = cdr(p2); // next factor on list
		p1 = cdr(p1);
	}
	if (iscons(p2))
		return 0;
	else
		return 1; // all factors matched
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movb 0x10(%rdi), %cl
cmpb $0x1, %cl
leaq 0x3186c(%rip), %rbx     # 0x45a00
movq %rbx, %rax
cmoveq %rdi, %rax
movq (%rax), %r8
xorl %eax, %eax
cmpq 0x34101(%rip), %r8      # 0x482a8
jne 0x1425c
movb 0x10(%rsi), %dl
cmpb $0x1, %dl
movq %rbx, %r9
cmoveq %rsi, %r9
cmpq %r8, (%r9)
jne 0x1425c
addq $0x8, %rdi
cmpb $0x1, %cl
cmovneq %rbx, %rdi
addq $0x8, %rsi
cmpb $0x1, %dl
cmovneq %rbx, %rsi
movq (%rsi), %r14
movq (%rdi), %r15
cmpb $0x1, 0x10(%r15)
jne 0x14252
leaq 0x10(%r15), %r12
cmpb $0x1, 0x10(%r14)
jne 0x14252
movq (%r15), %rdi
movq (%r14), %rsi
callq 0x8d48
testl %eax, %eax
je 0x14227
cmpb $0x1, (%r12)
movq %rbx, %rax
cmoveq %r15, %rax
movq (%rax), %rdi
cmpb $0x1, 0x10(%r14)
movq %rbx, %rax
cmoveq %r14, %rax
movq (%rax), %rsi
callq 0x14265
testl %eax, %eax
je 0x14237
cmpb $0x1, 0x10(%r14)
leaq 0x8(%r14), %rax
cmovneq %rbx, %rax
movq (%rax), %r14
addq $0x8, %r15
cmpb $0x1, (%r12)
cmovneq %rbx, %r15
movq (%r15), %r15
leaq 0x10(%r15), %r12
cmpb $0x1, 0x10(%r15)
je 0x141ea
xorl %eax, %eax
cmpb $0x1, 0x10(%r14)
setne %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: powcmp
int
powcmp(struct atom *p1, struct atom *p2)
{
	if (car(p1) != symbol(POWER) || car(p2) != symbol(POWER))
		return 0;
	if (!equal(cadr(p1), cadr(p2)))
		return 0; // bases don't match
	p1 = caddr(p1); // exponent
	p2 = caddr(p2); // exponent
	if (car(p1) != symbol(ADD))
		return 0; // p1 and p2 already failed exact match
	if (car(p2) == symbol(ADD))
		return addcmp(p1, p2);
	p1 = cdr(p1);
	while (iscons(p1)) {
		if (equal(car(p1), p2))
			return 1;
		p1 = cdr(p1);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movb 0x10(%rdi), %al
cmpb $0x1, %al
leaq 0x31781(%rip), %r12     # 0x45a00
movq %r12, %rcx
cmoveq %rdi, %rcx
movq (%rcx), %rdx
xorl %ebx, %ebx
cmpq 0x3401e(%rip), %rdx     # 0x482b0
jne 0x1437c
movq %rsi, %r14
movb 0x10(%rsi), %cl
cmpb $0x1, %cl
movq %r12, %rsi
cmoveq %r14, %rsi
cmpq %rdx, (%rsi)
jne 0x1437c
movq %rdi, %r15
leaq 0x8(%rdi), %r13
cmpb $0x1, %al
movq %r12, %rax
cmoveq %r13, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r12, %rax
leaq 0x8(%r14), %rdx
cmpb $0x1, %cl
movq %r12, %rcx
movq %rdx, -0x30(%rbp)
cmoveq %rdx, %rcx
movq (%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
movq (%rax), %rdi
cmovneq %r12, %rcx
movq (%rcx), %rsi
callq 0x8d48
testl %eax, %eax
jne 0x1437c
movq -0x30(%rbp), %rdx
cmpb $0x1, 0x10(%r15)
cmovneq %r12, %r13
movq (%r13), %rax
cmpb $0x1, 0x10(%rax)
jne 0x14319
movq 0x8(%rax), %rax
jmp 0x14320
movq 0x316e0(%rip), %rax     # 0x45a00
cmpb $0x1, 0x10(%rax)
movq %r12, %rcx
jne 0x1432c
movq %rax, %rcx
cmpb $0x1, 0x10(%r14)
cmoveq %rdx, %r12
movq (%rcx), %rdi
movq (%r12), %rax
cmpb $0x1, 0x10(%rax)
jne 0x14348
movq 0x8(%rax), %rax
jmp 0x1434f
movq 0x316b1(%rip), %rax     # 0x45a00
cmpb $0x1, 0x10(%rax)
je 0x1435c
leaq 0x316a4(%rip), %rax     # 0x45a00
movb 0x10(%rdi), %cl
cmpb $0x1, %cl
leaq 0x31697(%rip), %r15     # 0x45a00
movq %r15, %rdx
cmoveq %rdi, %rdx
movq (%rdx), %rdx
cmpq 0x33f26(%rip), %rdx     # 0x482a0
je 0x1438d
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rax), %r14
cmpb $0x1, 0x10(%r14)
movq %r15, %rax
cmoveq %r14, %rax
cmpq %rdx, (%rax)
je 0x143ec
addq $0x8, %rdi
cmpb $0x1, %cl
cmovneq %r15, %rdi
movq (%rdi), %r12
cmpb $0x1, 0x10(%r12)
jne 0x1437c
leaq 0x10(%r12), %r13
movq (%r12), %rdi
movq %r14, %rsi
callq 0x8d48
testl %eax, %eax
je 0x14402
addq $0x8, %r12
cmpb $0x1, (%r13)
cmovneq %r15, %r12
movq (%r12), %r12
leaq 0x10(%r12), %r13
cmpb $0x1, 0x10(%r12)
je 0x143bc
jmp 0x1437c
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x140be
movl $0x1, %ebx
jmp 0x1437c
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: expcos
void
expcos(void)
{
	struct atom *p1;
	p1 = pop();

	push(imaginaryunit);
	push(p1);
	multiply();
	expfunc();
	push_rational(1, 2);
	multiply();

	push(imaginaryunit);
	negate();
	push(p1);
	multiply();
	expfunc();
	push_rational(1, 2);
	multiply();

	add();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0x2ae25(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x14576
decl %eax
movl %eax, 0x2ae0d(%rip)     # 0x3f2b8
leaq 0x3410e(%rip), %rcx     # 0x485c0
movq (%rcx,%rax,8), %rbx
movq 0xf7623(%rip), %rdi     # 0x10bae0
callq 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
movl $0x2, %edi
callq 0xacef
movq 0x33ded(%rip), %rdi     # 0x482c8
callq 0x8ba5
callq 0xb238
callq 0xa573
movl $0x1, %edi
movl $0x2, %esi
callq 0xa533
movl $0x2, %edi
callq 0xacef
movq 0xf75d6(%rip), %rdi     # 0x10bae0
callq 0x8ba5
movq 0x101eda(%rip), %rdi    # 0x1163f0
callq 0x8ba5
movl $0x2, %edi
callq 0xacef
movq %rbx, %rdi
callq 0x8ba5
movl $0x2, %edi
callq 0xacef
movq 0x33d8a(%rip), %rdi     # 0x482c8
callq 0x8ba5
callq 0xb238
callq 0xa573
movl $0x1, %edi
movl $0x2, %esi
callq 0xa533
movl $0x2, %edi
callq 0xacef
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xadb3
leaq 0x1a9c4(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: expcosh
void
expcosh(void)
{
	struct atom *p1;
	p1 = pop();
	push(p1);
	expfunc();
	push(p1);
	negate();
	expfunc();
	add();
	push_rational(1, 2);
	multiply();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0x2acf5(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x14661
decl %eax
movl %eax, 0x2acdd(%rip)     # 0x3f2b8
leaq 0x33fde(%rip), %rcx     # 0x485c0
movq (%rcx,%rax,8), %rbx
movq %rbx, %rdi
callq 0x8ba5
movq 0x33cd3(%rip), %rdi     # 0x482c8
callq 0x8ba5
callq 0xb238
callq 0xa573
movq %rbx, %rdi
callq 0x8ba5
movq 0x101ddd(%rip), %rdi    # 0x1163f0
callq 0x8ba5
movl $0x2, %edi
callq 0xacef
movq 0x33c9f(%rip), %rdi     # 0x482c8
callq 0x8ba5
callq 0xb238
callq 0xa573
movl $0x2, %edi
callq 0xadb3
movl $0x1, %edi
movl $0x2, %esi
callq 0xa533
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xacef
leaq 0x1a8d9(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: expsin
void
expsin(void)
{
	struct atom *p1;
	p1 = pop();

	push(imaginaryunit);
	push(p1);
	multiply();
	expfunc();
	push(imaginaryunit);
	divide();
	push_rational(1, 2);
	multiply();

	push(imaginaryunit);
	negate();
	push(p1);
	multiply();
	expfunc();
	push(imaginaryunit);
	divide();
	push_rational(1, 2);
	multiply();

	subtract();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0x2a6d1(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x14ce7
decl %eax
movl %eax, 0x2a6b9(%rip)     # 0x3f2b8
leaq 0x339ba(%rip), %rcx     # 0x485c0
movq (%rcx,%rax,8), %rbx
movq 0xf6ecf(%rip), %rdi     # 0x10bae0
callq 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
movl $0x2, %edi
callq 0xacef
movq 0x33699(%rip), %rdi     # 0x482c8
callq 0x8ba5
callq 0xb238
callq 0xa573
movq 0xf6e9b(%rip), %rdi     # 0x10bae0
callq 0x8ba5
callq 0xe218
movl $0x1, %edi
movl $0x2, %esi
callq 0xa533
movl $0x2, %edi
callq 0xacef
movq 0xf6e71(%rip), %rdi     # 0x10bae0
callq 0x8ba5
movq 0x101775(%rip), %rdi    # 0x1163f0
callq 0x8ba5
movl $0x2, %edi
callq 0xacef
movq %rbx, %rdi
callq 0x8ba5
movl $0x2, %edi
callq 0xacef
movq 0x33625(%rip), %rdi     # 0x482c8
callq 0x8ba5
callq 0xb238
callq 0xa573
movq 0xf6e27(%rip), %rdi     # 0x10bae0
callq 0x8ba5
callq 0xe218
movl $0x1, %edi
movl $0x2, %esi
callq 0xa533
movl $0x2, %edi
callq 0xacef
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xbfb4
leaq 0x1a253(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: exptan
void
exptan(void)
{
	struct atom *p1;

	push_integer(2);
	push(imaginaryunit);
	multiply_factors(3);
	expfunc();

	p1 = pop();

	push(imaginaryunit);
	push(imaginaryunit);
	push(p1);
	multiply();
	subtract();

	push(p1);
	push_integer(1);
	add();

	divide();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl $0x2, %edi
callq 0xb1be
movq 0xf6dd6(%rip), %rdi     # 0x10bae0
callq 0x8ba5
movl $0x3, %edi
callq 0xacef
movq 0x335a8(%rip), %rdi     # 0x482c8
callq 0x8ba5
callq 0xb238
callq 0xa573
movl 0x2a583(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x14dac
decl %eax
movl %eax, 0x2a56f(%rip)     # 0x3f2b8
leaq 0x33870(%rip), %rcx     # 0x485c0
movq (%rcx,%rax,8), %rbx
movq 0xf6d85(%rip), %rdi     # 0x10bae0
callq 0x8ba5
movq 0xf6d79(%rip), %rdi     # 0x10bae0
callq 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
movl $0x2, %edi
callq 0xacef
callq 0xbfb4
movq %rbx, %rdi
callq 0x8ba5
movq 0xf6d46(%rip), %rdi     # 0x10bad8
callq 0x8ba5
movl $0x2, %edi
callq 0xadb3
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe218
leaq 0x1a18e(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: expsinh
void
expsinh(void)
{
	struct atom *p1;
	p1 = pop();
	push(p1);
	expfunc();
	push(p1);
	negate();
	expfunc();
	subtract();
	push_rational(1, 2);
	multiply();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0x2a4f4(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x14e5d
decl %eax
movl %eax, 0x2a4dc(%rip)     # 0x3f2b8
leaq 0x337dd(%rip), %rcx     # 0x485c0
movq (%rcx,%rax,8), %rbx
movq %rbx, %rdi
callq 0x8ba5
movq 0x334d2(%rip), %rdi     # 0x482c8
callq 0x8ba5
callq 0xb238
callq 0xa573
movq %rbx, %rdi
callq 0x8ba5
movq 0x1015dc(%rip), %rdi    # 0x1163f0
callq 0x8ba5
movl $0x2, %edi
callq 0xacef
movq 0x3349e(%rip), %rdi     # 0x482c8
callq 0x8ba5
callq 0xb238
callq 0xa573
callq 0xbfb4
movl $0x1, %edi
movl $0x2, %esi
callq 0xa533
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xacef
leaq 0x1a0dd(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: exptanh
void
exptanh(void)
{
	struct atom *p1;
	push_integer(2);
	multiply();
	expfunc();
	p1 = pop();
	push(p1);
	push_integer(1);
	subtract();
	push(p1);
	push_integer(1);
	add();
	divide();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl $0x2, %edi
callq 0xb1be
movl $0x2, %edi
callq 0xacef
movq 0x3343e(%rip), %rdi     # 0x482c8
callq 0x8ba5
callq 0xb238
callq 0xa573
movl 0x2a419(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x14f00
decl %eax
movl %eax, 0x2a405(%rip)     # 0x3f2b8
leaq 0x33706(%rip), %rcx     # 0x485c0
movq (%rcx,%rax,8), %rbx
movq %rbx, %rdi
callq 0x8ba5
movq 0xf6c0b(%rip), %rdi     # 0x10bad8
callq 0x8ba5
callq 0xbfb4
movq %rbx, %rdi
callq 0x8ba5
movq 0xf6bf2(%rip), %rdi     # 0x10bad8
callq 0x8ba5
movl $0x2, %edi
callq 0xadb3
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe218
leaq 0x1a03a(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: factorial
void
factorial(void)
{
	int i, n;
	double m;
	struct atom *p1;

	p1 = pop();

	if (isposint(p1)) {
		push(p1);
		n = pop_integer();
		push_integer(1);
		for (i = 2; i <= n; i++) {
			push_integer(i);
			multiply();
		}
		return;
	}

	if (isdouble(p1) && p1->u.d >= 0 && floor(p1->u.d) == p1->u.d) {
		push(p1);
		n = pop_integer();
		m = 1.0;
		for (i = 2; i <= n; i++)
			m *= i;
		push_double(m);
		return;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl 0x2a292(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x15186
decl %eax
movl %eax, 0x2a27a(%rip)     # 0x3f2b8
leaq 0x3357b(%rip), %rcx     # 0x485c0
movq (%rcx,%rax,8), %rbx
movzbl 0x10(%rbx), %eax
cmpl $0x5, %eax
je 0x150d6
cmpl $0x4, %eax
jne 0x15117
movq 0x8(%rbx), %rax
cmpl $0x1, -0x4(%rax)
jne 0x15117
cmpl $0x1, (%rax)
jne 0x15117
cmpb $0x1, 0x12(%rbx)
je 0x15117
movq %rbx, %rdi
callq 0x8ba5
callq 0xf8e6
movl %eax, %ebx
movq 0xf6a42(%rip), %rdi     # 0x10bad8
callq 0x8ba5
cmpl $0x2, %ebx
jl 0x150cd
negl %ebx
movl $0x2, %r14d
movl %r14d, %edi
callq 0xb1be
movl $0x2, %edi
callq 0xacef
leal (%rbx,%r14), %eax
incl %eax
movl %r14d, %ecx
incl %ecx
movl %ecx, %r14d
cmpl $0x1, %eax
jne 0x150a8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movsd (%rbx), %xmm0
movsd %xmm0, -0x18(%rbp)
callq 0x7300
xorpd %xmm1, %xmm1
movsd -0x18(%rbp), %xmm2
ucomisd %xmm1, %xmm2
jb 0x15117
ucomisd %xmm2, %xmm0
jne 0x15117
jp 0x15117
movq %rbx, %rdi
callq 0x8ba5
callq 0xf8e6
cmpl $0x2, %eax
jge 0x1513d
movsd 0x1501b(%rip), %xmm2    # 0x2a130
jmp 0x1515f
movq 0x2efe2(%rip), %rdi     # 0x44100
callq 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
movl $0x2, %edi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x8b7d
decl %eax
movsd 0x14fe9(%rip), %xmm0    # 0x2a130
movsd 0x15009(%rip), %xmm1    # 0x2a158
movapd %xmm0, %xmm2
mulsd %xmm1, %xmm2
addsd %xmm0, %xmm1
decl %eax
jne 0x15153
movsd %xmm2, -0x18(%rbp)
callq 0x74dc
movb $0x5, 0x10(%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rax, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x8ba5
leaq 0x19db4(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: floorfunc
void
floorfunc(void)
{
	int i, n;
	uint32_t *a, *b;
	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]);
			floorfunc();
			p1->u.tensor->elem[i] = pop();
		}
		push(p1);
		return;
	}

	if (isinteger(p1)) {
		push(p1);
		return;
	}

	if (isrational(p1)) {
		a = mdiv(p1->u.q.a, p1->u.q.b);
		b = mint(1);
		if (isnegativenumber(p1)) {
			push_bignum(MMINUS, a, b);
			push_integer(-1);
			add();
		} else
			push_bignum(MPLUS, a, b);
		return;
	}

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x29d20(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x1573e
decl %eax
movl %eax, 0x29d08(%rip)     # 0x3f2b8
leaq 0x33009(%rip), %r14     # 0x485c0
movq (%r14,%rax,8), %rbx
movzbl 0x10(%rbx), %eax
cmpl $0x4, %eax
je 0x1566b
cmpl $0x5, %eax
je 0x1563d
cmpl $0x7, %eax
jne 0x15690
movq %rbx, %rdi
callq 0x9638
movq %rax, %rbx
movq (%rax), %rax
movslq 0x64(%rax), %r15
testq %r15, %r15
jle 0x1567a
xorl %r12d, %r12d
movl $0xfffe795f, %r13d      # imm = 0xFFFE795F
movq (%rbx), %rax
movq 0x68(%rax,%r12,8), %rdi
callq 0x8ba5
callq 0x15584
movl 0x29ca6(%rip), %eax     # 0x3f2b8
leal (%rax,%r13), %ecx
cmpl %r13d, %ecx
jbe 0x1573e
decl %eax
movl %eax, 0x29c91(%rip)     # 0x3f2b8
movq (%r14,%rax,8), %rax
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x155fa
jmp 0x1567a
movq %rbx, %rdi
callq 0x8ba5
callq 0x9128
callq 0x7300
movsd %xmm0, -0x30(%rbp)
callq 0x74dc
movb $0x5, 0x10(%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rax, %rdi
jmp 0x1567d
movq 0x8(%rbx), %rsi
cmpl $0x1, -0x4(%rsi)
jne 0x156bc
cmpl $0x1, (%rsi)
jne 0x156bc
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8ba5
movq 0x2ea79(%rip), %rdi     # 0x44110
callq 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8b7d
movq (%rbx), %rdi
callq 0x80ac
movq %rax, %r14
movl $0x1, %edi
callq 0x7b1f
movzbl 0x10(%rbx), %ecx
cmpl $0x5, %ecx
je 0x15719
cmpl $0x4, %ecx
jne 0x15723
cmpb $0x1, 0x12(%rbx)
jne 0x15723
movl $0x1, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0xbf3e
movq 0x100cf4(%rip), %rdi    # 0x1163f0
callq 0x8ba5
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xadb3
xorpd %xmm0, %xmm0
ucomisd (%rbx), %xmm0
ja 0x156e5
xorl %edi, %edi
movq %r14, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xbf3e
leaq 0x197fc(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: issmallinteger
int
issmallinteger(struct atom *p)
{
	if (isinteger(p))
		return MLENGTH(p->u.q.a) == 1 && p->u.q.a[0] <= 0x7fffffff;

	if (isdouble(p))
		return p->u.d == floor(p->u.d) && fabs(p->u.d) <= 0x7fffffff;

	return 0;
}

// Assembly:
movzbl 0x10(%rdi), %eax
cmpl $0x5, %eax
je 0x15af4
cmpl $0x4, %eax
jne 0x15af0
movq 0x8(%rdi), %rax
cmpl $0x1, -0x4(%rax)
jne 0x15af0
cmpl $0x1, (%rax)
jne 0x15af0
movq (%rdi), %rax
cmpl $0x1, -0x4(%rax)
jne 0x15af0
cmpl $0x0, (%rax)
setns %al
jmp 0x15b3a
xorl %eax, %eax
jmp 0x15b3a
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd (%rdi), %xmm0
movapd %xmm0, -0x10(%rbp)
callq 0x7300
movapd 0x1460e(%rip), %xmm1    # 0x2a120
movapd -0x10(%rbp), %xmm3
andpd %xmm3, %xmm1
movsd 0x1463d(%rip), %xmm2    # 0x2a160
cmplepd %xmm2, %xmm1
cmpeqpd %xmm3, %xmm0
andpd %xmm1, %xmm0
movd %xmm0, %eax
addq $0x10, %rsp
popq %rbp
movzbl %al, %eax
andl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: set_symbol
void
set_symbol(struct atom *p1, struct atom *p2, struct atom *p3)
{
	if (!isusersymbol(p1))
		stopf("symbol error");
	binding[p1->u.usym.index] = p2;
	usrfunc[p1->u.usym.index] = p3;
}

// Assembly:
cmpb $0x3, 0x10(%rdi)
jne 0x15b64
movl 0x8(%rdi), %eax
leaq 0xf5f9f(%rip), %rcx     # 0x10baf0
movq %rsi, (%rcx,%rax,8)
movl 0x8(%rdi), %eax
leaq 0xfb3f1(%rip), %rcx     # 0x110f50
movq %rdx, (%rcx,%rax,8)
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1942b(%rip), %rdi     # 0x2ef9a
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_hadamard
void
eval_hadamard(struct atom *p1)
{
	push(cadr(p1));
	evalf();
	p1 = cddr(p1);
	while (iscons(p1)) {
		push(car(p1));
		evalf();
		hadamard();
		p1 = cdr(p1);
	}
}

// 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 0x2fe70(%rip), %r14     # 0x45a00
movq %r14, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rax
movq (%rax), %rdi
callq 0x8ba5
callq 0x96e2
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %r15
movq (%r15), %rax
leaq 0x8(%rax), %rcx
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rcx
movq (%rcx), %rbx
cmpb $0x1, 0x10(%rbx)
jne 0x15bf2
movq (%rbx), %rdi
callq 0x8ba5
callq 0x96e2
callq 0x15bfd
leaq 0x8(%rbx), %rax
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %rax
movq (%rax), %rbx
jmp 0x15bc9
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: hadamard
void
hadamard(void)
{
	int i, n;
	struct atom *p1, *p2;

	p2 = pop();
	p1 = pop();

	if (!istensor(p1) || !istensor(p2)) {
		push(p1);
		push(p2);
		multiply();
		return;
	}

	if (p1->u.tensor->ndim != p2->u.tensor->ndim)
		stopf("hadamard");

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

	for (i = 0; i < n; i++)
		if (p1->u.tensor->dim[i] != p2->u.tensor->dim[i])
			stopf("hadamard");

	p1 = copy_tensor(p1);

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

	for (i = 0; i < n; i++) {
		push(p1->u.tensor->elem[i]);
		push(p2->u.tensor->elem[i]);
		multiply();
		p1->u.tensor->elem[i] = pop();
	}

	push(p1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x296a7(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x15d3b
leal -0x1(%rax), %ecx
movl %ecx, 0x2968e(%rip)     # 0x3f2b8
cmpl $0x1, %eax
jbe 0x15d3b
leaq 0x32986(%rip), %rdx     # 0x485c0
movq (%rdx,%rcx,8), %rbx
addl $-0x2, %eax
movl %eax, 0x29671(%rip)     # 0x3f2b8
movq (%rdx,%rax,8), %rdi
cmpb $0x7, 0x10(%rdi)
jne 0x15d16
cmpb $0x7, 0x10(%rbx)
jne 0x15d16
movq (%rdi), %rax
movl (%rax), %ecx
movq (%rbx), %rdx
cmpl (%rdx), %ecx
jne 0x15d47
testl %ecx, %ecx
jle 0x15c8d
xorl %esi, %esi
movl 0x4(%rax,%rsi,4), %r8d
cmpl 0x4(%rdx,%rsi,4), %r8d
jne 0x15d47
incq %rsi
cmpq %rsi, %rcx
jne 0x15c75
callq 0x9638
movq %rax, %r14
movq (%rax), %rax
movslq 0x64(%rax), %r12
testq %r12, %r12
jle 0x15d00
xorl %r13d, %r13d
movl $0xfffe795f, %r15d      # imm = 0xFFFE795F
movq (%r14), %rax
movq 0x68(%rax,%r13,8), %rdi
callq 0x8ba5
movq (%rbx), %rax
movq 0x68(%rax,%r13,8), %rdi
callq 0x8ba5
movl $0x2, %edi
callq 0xacef
movl 0x295e4(%rip), %eax     # 0x3f2b8
leal (%rax,%r15), %ecx
cmpl %r15d, %ecx
jbe 0x15d3b
decl %eax
movl %eax, 0x295d3(%rip)     # 0x3f2b8
leaq 0x328d4(%rip), %rcx     # 0x485c0
movq (%rcx,%rax,8), %rax
movq (%r14), %rcx
movq %rax, 0x68(%rcx,%r13,8)
incq %r13
cmpq %r13, %r12
jne 0x15caa
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8ba5
callq 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xacef
leaq 0x191ff(%rip), %rdi     # 0x2ef41
callq 0x780b
leaq 0x1463a(%rip), %rdi     # 0x2a388
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_index
void
eval_index(struct atom *p1)
{
	int h, n;
	struct atom *T;

	T = cadr(p1);

	p1 = cddr(p1);

	h = tos;

	while (iscons(p1)) {
		push(car(p1));
		evalf();
		p1 = cdr(p1);
	}

	// try to optimize by indexing before eval

	if (isusersymbol(T)) {
		p1 = get_binding(T);
		n = tos - h;
		if (istensor(p1) && n <= p1->u.tensor->ndim) {
			T = p1;
			indexfunc(T, h);
			evalf();
			return;
		}
	}

	push(T);
	evalf();
	T = pop();

	if (!istensor(T)) {
		tos = h; // pop all
		push(T); // quirky, but EVA2.txt depends on it
		return;
	}

	indexfunc(T, h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x8(%rdi), %rax
cmpb $0x1, 0x10(%rdi)
leaq 0x2f949(%rip), %r15     # 0x45a00
cmovneq %r15, %rax
movq (%rax), %rax
leaq 0x8(%rax), %rcx
cmpb $0x1, 0x10(%rax)
cmovneq %r15, %rax
cmovneq %r15, %rcx
movq (%rax), %r14
movl 0x291e1(%rip), %ebx     # 0x3f2b8
movq (%rcx), %r12
cmpb $0x1, 0x10(%r12)
jne 0x16104
movq (%r12), %rdi
callq 0x8ba5
callq 0x96e2
leaq 0x8(%r12), %rax
cmpb $0x1, 0x10(%r12)
cmovneq %r15, %rax
movq (%rax), %r12
jmp 0x160da
cmpb $0x3, 0x10(%r14)
jne 0x16128
movq %r14, %rdi
callq 0xf05c
cmpb $0x7, 0x10(%rax)
jne 0x16128
movl 0x29199(%rip), %ecx     # 0x3f2b8
subl %ebx, %ecx
movq (%rax), %rdx
cmpl (%rdx), %ecx
jle 0x16182
movq %r14, %rdi
callq 0x8ba5
callq 0x96e2
movl 0x2917d(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x16199
decl %eax
movl %eax, 0x29169(%rip)     # 0x3f2b8
leaq 0x3246a(%rip), %rcx     # 0x485c0
movq (%rcx,%rax,8), %rdi
cmpb $0x7, 0x10(%rdi)
jne 0x1616f
movl %ebx, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x161a5
movl %ebx, 0x29143(%rip)     # 0x3f2b8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8ba5
movq %rax, %rdi
movl %ebx, %esi
callq 0x161a5
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x96e2
leaq 0x18da1(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_infixform
void
eval_infixform(struct atom *p1)
{
	push(cadr(p1));
	evalf();
	p1 = pop();

	outbuf_init();
	infixform_expr(p1);

	push_string(outbuf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rax
leaq 0x2f66b(%rip), %rcx     # 0x45a00
cmovneq %rcx, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %rcx
movq (%rcx), %rdi
callq 0x8ba5
callq 0x96e2
movl 0x28f01(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x16406
decl %eax
movl %eax, 0x28eed(%rip)     # 0x3f2b8
leaq 0x321ee(%rip), %rcx     # 0x485c0
movq (%rcx,%rax,8), %rbx
movl $0x0, 0x100418(%rip)    # 0x1167f8
leaq 0x18b04(%rip), %rdi     # 0x2eeeb
callq 0x16573
movq %rbx, %rdi
callq 0x1642d
movq 0xfffcd(%rip), %rdi     # 0x1163c8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x164db
leaq 0x18b34(%rip), %rdi     # 0x2ef41
callq 0x780b