LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_defint
void
eval_defint(struct atom *p1)
{
	struct atom *F, *X, *A, *B;

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

	p1 = cddr(p1);

	while (iscons(p1)) {

		push(car(p1));
		evalf();
		X = pop();

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

		push(caddr(p1));
		evalf();
		B = pop();

		push(F);
		push(X);
		integral();
		F = pop();

		if (findf(F, symbol(INTEGRAL)))
			stopf("defint: unsolved integral");

		push(F);
		push(X);
		push(B);
		subst();
		evalf();

		push(F);
		push(X);
		push(A);
		subst();
		evalf();

		subtract();
		F = pop();

		p1 = cdddr(p1);
	}

	push(F);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
cmpb $0x1, 0x10(%rdi)
leaq 0x3078c(%rip), %r15     # 0x40a00
movq %r15, %rax
cmoveq %r14, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x8b01
callq 0x95e2
callq 0x8b78
cmpb $0x1, 0x10(%rbx)
cmovneq %r15, %r14
movq (%r14), %rcx
leaq 0x8(%rcx), %rdx
cmpb $0x1, 0x10(%rcx)
cmovneq %r15, %rdx
movq %rax, %rdi
movq (%rdx), %r12
cmpb $0x1, 0x10(%r12)
jne 0x1044a
leaq 0x10(%r12), %r15
movq %rdi, -0x38(%rbp)
movq (%r12), %rdi
callq 0x8b01
callq 0x95e2
callq 0x8b78
cmpb $0x1, 0x10(%r12)
leaq 0x8(%r12), %r13
leaq 0x30711(%rip), %rbx     # 0x40a00
movq %rbx, %rcx
cmoveq %r13, %rcx
movq (%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
movq %rax, %r14
cmovneq %rbx, %rcx
movq (%rcx), %rdi
callq 0x8b01
callq 0x95e2
callq 0x8b78
cmpb $0x1, 0x10(%r12)
movq %rbx, %rcx
cmoveq %r13, %rcx
movq %rax, -0x30(%rbp)
movq (%rcx), %rax
movb 0x10(%rax), %cl
addq $0x8, %rax
cmpb $0x1, %cl
movq %rbx, %rdx
cmoveq %rax, %rdx
movq (%rdx), %rdx
cmpb $0x1, 0x10(%rdx)
jne 0x10355
cmpb $0x1, %cl
leaq 0x306b2(%rip), %rcx     # 0x40a00
cmovneq %rcx, %rax
movq (%rax), %rbx
movq (%rbx), %rdi
callq 0x8b01
callq 0x95e2
callq 0x8b78
movq %rax, %r12
movq -0x38(%rbp), %rdi
callq 0x8b01
movq %r14, %rdi
callq 0x8b01
callq 0x10469
callq 0x8b78
movq %rax, %rbx
movq 0x2f6f9(%rip), %rsi     # 0x3fa88
movq %rax, %rdi
callq 0x8bd3
testl %eax, %eax
jne 0x1045d
movq %rbx, %rdi
callq 0x8b01
movq %r14, %rdi
callq 0x8b01
movq %r12, %rdi
callq 0x8b01
callq 0x9402
callq 0x95e2
movq %rbx, %rdi
callq 0x8b01
movq %r14, %rdi
callq 0x8b01
movq -0x30(%rbp), %rdi
callq 0x8b01
callq 0x9402
callq 0x95e2
callq 0xba6d
callq 0x8b78
cmpb $0x1, (%r15)
leaq 0x30607(%rip), %rsi     # 0x40a00
cmovneq %rsi, %r13
movq %rax, %rdi
movq (%r13), %rax
movb 0x10(%rax), %cl
addq $0x8, %rax
cmpb $0x1, %cl
movq %rsi, %rdx
cmoveq %rax, %rdx
movq (%rdx), %rdx
cmpb $0x1, 0x10(%rdx)
movq %rsi, %rdx
jne 0x10436
cmpb $0x1, %cl
leaq 0x305d5(%rip), %rcx     # 0x40a00
cmovneq %rcx, %rax
movq (%rax), %rdx
addq $0x8, %rdx
movq (%rdx), %r12
leaq 0x10(%r12), %r15
cmpb $0x1, 0x10(%r12)
je 0x102c6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8b01
leaq 0x15e4f(%rip), %rdi     # 0x262b3
callq 0x77c8
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: integral
void
integral(void)
{
	int h;
	struct atom *p1, *F, *X;

	X = pop();
	F = pop();

	if (!isusersymbol(X))
		stopf("integral: symbol expected");

	if (car(F) == symbol(ADD)) {
		h = tos;
		p1 = cdr(F);
		while (iscons(p1)) {
			push(car(p1));
			push(X);
			integral();
			p1 = cdr(p1);
		}
		add_terms(tos - h);
		return;
	}

	if (car(F) == symbol(MULTIPLY)) {
		push(F);
		push(X);
		partition_term();	// push const part then push var part
		F = pop();		// pop var part
		integral_solve(F, X);
		multiply();		// multiply by const part
		return;
	}

	integral_solve(F, X);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
callq 0x8b78
movq %rax, %rbx
callq 0x8b78
cmpb $0x3, 0x10(%rbx)
jne 0x10558
movb 0x10(%rax), %cl
cmpb $0x1, %cl
leaq 0x30568(%rip), %r14     # 0x40a00
movq %r14, %rdx
cmoveq %rax, %rdx
movq (%rdx), %rdx
cmpq 0x32df7(%rip), %rdx     # 0x432a0
je 0x104c7
cmpq 0x32df6(%rip), %rdx     # 0x432a8
je 0x10521
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x162f0
addq $0x8, %rax
cmpb $0x1, %cl
cmovneq %r14, %rax
movl 0x29ddf(%rip), %r15d    # 0x3a2b8
movq (%rax), %r12
cmpb $0x1, 0x10(%r12)
jne 0x1050b
movq (%r12), %rdi
callq 0x8b01
movq %rbx, %rdi
callq 0x8b01
callq 0x10469
leaq 0x8(%r12), %rax
cmpb $0x1, 0x10(%r12)
cmovneq %r14, %rax
jmp 0x104d9
movl 0x29da7(%rip), %edi     # 0x3a2b8
subl %r15d, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa975
movq %rax, %rdi
callq 0x8b01
movq %rbx, %rdi
callq 0x8b01
callq 0x16162
callq 0x8b78
movq %rax, %rdi
movq %rbx, %rsi
callq 0x162f0
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa8bb
leaq 0x1a2ca(%rip), %rdi     # 0x2a829
callq 0x77c8
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_derivative
void
eval_derivative(struct atom *p1)
{
	int flag, i, n;
	struct atom *X, *Y = NULL; // silence compiler

	push(cadr(p1));
	evalf();
	p1 = cddr(p1);

	if (!iscons(p1)) {
		push_symbol(X_LOWER);
		derivative();
		return;
	}

	flag = 0;

	while (iscons(p1) || flag) {

		if (flag) {
			X = Y;
			flag = 0;
		} else {
			push(car(p1));
			evalf();
			X = pop();
			p1 = cdr(p1);
		}

		if (isnum(X)) {
			push(X);
			n = pop_integer();
			push_symbol(X_LOWER);
			X = pop();
			for (i = 0; i < n; i++) {
				push(X);
				derivative();
			}
			continue;
		}

		if (iscons(p1)) {

			push(car(p1));
			evalf();
			Y = pop();
			p1 = cdr(p1);

			if (isnum(Y)) {
				push(Y);
				n = pop_integer();
				for (i = 0; i < n; i++) {
					push(X);
					derivative();
				}
				continue;
			}

			flag = 1;
		}

		push(X);
		derivative();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
cmpb $0x1, 0x10(%rdi)
leaq 0x30442(%rip), %r12     # 0x40a00
movq %r12, %rax
cmoveq %r14, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x8b01
callq 0x95e2
cmpb $0x1, 0x10(%rbx)
cmovneq %r12, %r14
movq (%r14), %rax
leaq 0x8(%rax), %rcx
cmpb $0x1, 0x10(%rax)
cmovneq %r12, %rcx
movq (%rcx), %r13
cmpb $0x1, 0x10(%r13)
jne 0x10752
cmpb $0x1, 0x10(%r13)
sete %al
jne 0x10743
leaq 0x10(%r13), %r14
xorl %r15d, %r15d
xorl %ebx, %ebx
testb $0x1, %r15b
je 0x10624
movq %rbx, %r14
jmp 0x10652
testb $0x1, %al
movq %r12, %rax
cmovneq %r13, %rax
movq (%rax), %rdi
callq 0x8b01
callq 0x95e2
callq 0x8b78
addq $0x8, %r13
cmpb $0x1, (%r14)
movq %rax, %r14
cmovneq %r12, %r13
movq (%r13), %r13
movb 0x10(%r14), %al
andb $-0x2, %al
cmpb $0x4, %al
jne 0x106b1
movq %r14, %rdi
callq 0x8b01
callq 0xeb5b
movl %eax, %r14d
movq 0x322d5(%rip), %rdi     # 0x42948
callq 0x8b01
callq 0x8b78
testl %r14d, %r14d
jle 0x10697
movq %rax, %r15
movq %r15, %rdi
callq 0x8b01
callq 0x10771
decl %r14d
jne 0x10685
leaq 0x10(%r13), %r14
xorl %r15d, %r15d
cmpb $0x1, 0x10(%r13)
sete %al
je 0x10619
jmp 0x10743
cmpb $0x1, 0x10(%r13)
sete %r15b
jne 0x10716
movq (%r13), %rdi
callq 0x8b01
callq 0x95e2
callq 0x8b78
movq %rax, %rbx
leaq 0x8(%r13), %rax
cmpb $0x1, 0x10(%r13)
cmovneq %r12, %rax
movq (%rax), %r13
movb 0x10(%rbx), %al
andb $-0x2, %al
cmpb $0x4, %al
jne 0x10716
movq %rbx, %rdi
callq 0x8b01
callq 0xeb5b
testl %eax, %eax
jle 0x10711
movl %eax, %r15d
movq %r14, %rdi
callq 0x8b01
callq 0x10771
decl %r15d
jne 0x106ff
xorl %r15d, %r15d
jmp 0x10723
movq %r14, %rdi
callq 0x8b01
callq 0x10771
leaq 0x10(%r13), %r14
movb 0x10(%r13), %cl
cmpb $0x1, %cl
sete %al
testb %r15b, %r15b
jne 0x10619
cmpb $0x1, %cl
je 0x10619
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x321ef(%rip), %rdi     # 0x42948
callq 0x8b01
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10771
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: derivative
void
derivative(void)
{
	struct atom *F, *X;

	X = pop();
	F = pop();

	if (istensor(F)) {
		if (istensor(X))
			d_tensor_tensor(F, X);
		else
			d_tensor_scalar(F, X);
	} else {
		if (istensor(X))
			d_scalar_tensor(F, X);
		else
			d_scalar_scalar(F, X);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x8b78
movq %rax, %rbx
callq 0x8b78
cmpb $0x7, 0x10(%rax)
movb 0x10(%rbx), %cl
movq %rax, %rdi
movq %rbx, %rsi
jne 0x107a3
addq $0x8, %rsp
cmpb $0x7, %cl
jne 0x107b3
popq %rbx
popq %rbp
jmp 0x107c1
addq $0x8, %rsp
cmpb $0x7, %cl
jne 0x107ba
popq %rbx
popq %rbp
jmp 0x10987
popq %rbx
popq %rbp
jmp 0x10917
popq %rbx
popq %rbp
jmp 0x109fa
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: d_tensor_tensor
void
d_tensor_tensor(struct atom *p1, struct atom *p2)
{
	int i, j, k, m, n;
	struct atom *p3;

	if (p1->u.tensor->ndim + p2->u.tensor->ndim > MAXDIM)
		stopf("rank exceeds max");

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

	p3 = alloc_tensor(n * m);

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

	// dim info

	p3->u.tensor->ndim = p1->u.tensor->ndim + p2->u.tensor->ndim;

	k = 0;

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

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

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

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

	push(p3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rax
movq (%rsi), %rcx
movl (%rcx), %ecx
addl (%rax), %ecx
cmpl $0x19, %ecx
jge 0x1090b
movq %rdi, %r13
movq (%rdi), %rax
movslq 0x64(%rax), %rbx
movq %rsi, -0x30(%rbp)
movq (%rsi), %rax
movl 0x64(%rax), %r12d
movl %r12d, %edi
imull %ebx, %edi
callq 0x7850
movq %rax, %r9
movq %rbx, -0x40(%rbp)
testq %rbx, %rbx
jle 0x1088f
leaq (,%r12,8), %rax
movq %rax, -0x38(%rbp)
movl $0x68, %r15d
xorl %ecx, %ecx
testl %r12d, %r12d
jle 0x10882
xorl %r14d, %r14d
movq %rcx, -0x48(%rbp)
movq (%r13), %rax
movq 0x68(%rax,%rcx,8), %rdi
movq %r12, %rbx
movq %r13, %r12
movq %r9, %r13
callq 0x8b01
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq 0x68(%rax,%r14,8), %rdi
callq 0x8b01
callq 0x10771
callq 0x8b78
movq %r13, %r9
movq %r12, %r13
movq %rbx, %r12
movq (%r9), %rcx
addq %r15, %rcx
movq %rax, (%rcx,%r14,8)
movq -0x48(%rbp), %rcx
incq %r14
cmpq %r14, %rbx
jne 0x10831
incq %rcx
addq -0x38(%rbp), %r15
cmpq -0x40(%rbp), %rcx
jne 0x10825
movq (%r13), %rax
movq -0x30(%rbp), %r8
movq (%r8), %rcx
movl (%rcx), %ecx
addl (%rax), %ecx
movq (%r9), %rax
movl %ecx, (%rax)
movq (%r13), %rax
movslq (%rax), %rcx
xorl %eax, %eax
testq %rcx, %rcx
jle 0x108c8
movq (%r13), %rdx
movl 0x4(%rdx,%rax,4), %edx
movq (%r9), %rsi
movl %edx, 0x4(%rsi,%rax,4)
incq %rax
cmpq %rax, %rcx
jne 0x108b1
movq (%r8), %rcx
movslq (%rcx), %rcx
testq %rcx, %rcx
jle 0x108f5
leaq 0x4(,%rax,4), %rax
xorl %edx, %edx
movq (%r8), %rsi
movl 0x4(%rsi,%rdx,4), %esi
movq (%r9), %rdi
addq %rax, %rdi
movl %esi, (%rdi,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x108dd
movq %r9, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8b01
leaq 0x15ad7(%rip), %rdi     # 0x263e9
callq 0x77c8
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: d_tensor_scalar
void
d_tensor_scalar(struct atom *p1, struct atom *p2)
{
	int i, n;
	struct atom *p3;

	p3 = copy_tensor(p1);

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

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

	push(p3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x953d
movq %rax, %r15
movq (%r14), %rax
movslq 0x64(%rax), %r12
testq %r12, %r12
jle 0x10971
xorl %r13d, %r13d
movq (%r14), %rax
movq 0x68(%rax,%r13,8), %rdi
callq 0x8b01
movq %rbx, %rdi
callq 0x8b01
callq 0x10771
callq 0x8b78
movq (%r15), %rcx
movq %rax, 0x68(%rcx,%r13,8)
incq %r13
cmpq %r13, %r12
jne 0x10942
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8b01
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: d_scalar_tensor
void
d_scalar_tensor(struct atom *p1, struct atom *p2)
{
	int i, n;
	struct atom *p3;

	p3 = copy_tensor(p2);

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

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

	push(p3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x953d
movq %rax, %r15
movq (%rbx), %rax
movslq 0x64(%rax), %r12
testq %r12, %r12
jle 0x109e4
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x8b01
movq (%rbx), %rax
movq 0x68(%rax,%r13,8), %rdi
callq 0x8b01
callq 0x10771
callq 0x8b78
movq (%r15), %rcx
movq %rax, 0x68(%rcx,%r13,8)
incq %r13
cmpq %r13, %r12
jne 0x109b5
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8b01
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: derivative_of_derivative
void
derivative_of_derivative(struct atom *F, struct atom *X)
{
	struct atom *G, *Y;

	G = cadr(F);
	Y = caddr(F);

	if (X == Y) {
		push_symbol(DERIVATIVE);
		push(F);
		push(X);
		list(3);
		return;
	}

	push(G);
	push(X);
	derivative();

	G = pop();

	if (car(G) == symbol(DERIVATIVE)) {

		// sort derivatives

		F = cadr(G);
		X = caddr(G);

		push_symbol(DERIVATIVE);
		push_symbol(DERIVATIVE);
		push(F);

		if (lessp(X, Y)) {
			push(X);
			list(3);
			push(Y);
			list(3);
		} else {
			push(Y);
			list(3);
			push(X);
			list(3);
		}

		return;
	}

	push(G);
	push(Y);
	derivative();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x8(%rdi), %rax
cmpb $0x1, 0x10(%rdi)
leaq 0x2fd3c(%rip), %rcx     # 0x40a00
cmovneq %rcx, %rax
movq (%rax), %rax
movb 0x10(%rax), %dil
leaq 0x8(%rax), %rdx
cmpb $0x1, %dil
cmovneq %rcx, %rax
movq %rcx, %r8
cmoveq %rdx, %r8
movq %rsi, %r15
movq (%r8), %rsi
cmpb $0x1, 0x10(%rsi)
jne 0x10d00
cmpb $0x1, %dil
leaq 0x2fd07(%rip), %rcx     # 0x40a00
cmoveq %rdx, %rcx
movq (%rcx), %rcx
movq (%rcx), %rbx
cmpq %r15, %rbx
je 0x10d61
movq (%rax), %rdi
callq 0x8b01
movq %r15, %rdi
callq 0x8b01
callq 0x10771
callq 0x8b78
movb 0x10(%rax), %dl
cmpb $0x1, %dl
leaq 0x2fcd1(%rip), %rcx     # 0x40a00
movq %rcx, %rsi
cmoveq %rax, %rsi
movq 0x2dda3(%rip), %rdi     # 0x3eae0
cmpq %rdi, (%rsi)
je 0x10d7d
movq %rax, %rdi
callq 0x8b01
movq %rbx, %rdi
callq 0x8b01
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x10771
movq 0x2dd78(%rip), %rdi     # 0x3eae0
callq 0x8b01
movq %r14, %rdi
callq 0x8b01
movq %r15, %rdi
jmp 0x10e14
addq $0x8, %rax
cmpb $0x1, %dl
cmovneq %rcx, %rax
movq (%rax), %rsi
movb 0x10(%rsi), %dl
leaq 0x8(%rsi), %rax
cmpb $0x1, %dl
cmovneq %rcx, %rsi
movq %rcx, %r8
cmoveq %rax, %r8
movq (%rsi), %r15
movq (%r8), %rsi
cmpb $0x1, 0x10(%rsi)
jne 0x10dbd
cmpb $0x1, %dl
leaq 0x2fc4a(%rip), %rcx     # 0x40a00
cmoveq %rax, %rcx
movq (%rcx), %rcx
movq (%rcx), %r14
callq 0x8b01
movq 0x2dd14(%rip), %rdi     # 0x3eae0
callq 0x8b01
movq %r15, %rdi
callq 0x8b01
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8c79
testl %eax, %eax
js 0x10dff
movq %rbx, %rdi
callq 0x8b01
movl $0x3, %edi
callq 0x8ad9
movq %r14, %rdi
jmp 0x10e14
movq %r14, %rdi
callq 0x8b01
movl $0x3, %edi
callq 0x8ad9
movq %rbx, %rdi
callq 0x8b01
movl $0x3, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8ad9
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: derivative_of_integral
void
derivative_of_integral(struct atom *F, struct atom *X)
{
	struct atom *G, *Y;

	G = cadr(F);
	Y = caddr(F);

	if (X == Y) {
		push(G); // derivative and integral cancel
		return;
	}

	push(G);
	push(X);
	derivative();
	push(Y);
	integral();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x8(%rdi), %rcx
cmpb $0x1, 0x10(%rdi)
leaq 0x2fbbd(%rip), %rax     # 0x40a00
cmovneq %rax, %rcx
movq (%rcx), %rdi
movb 0x10(%rdi), %dl
leaq 0x8(%rdi), %rcx
cmpb $0x1, %dl
cmovneq %rax, %rdi
movq %rsi, %rbx
movq %rax, %rsi
cmoveq %rcx, %rsi
movq (%rdi), %rdi
movq (%rsi), %rsi
cmpb $0x1, 0x10(%rsi)
jne 0x10e7f
cmpb $0x1, %dl
leaq 0x2fb88(%rip), %rax     # 0x40a00
cmoveq %rcx, %rax
movq (%rax), %rax
movq (%rax), %r14
callq 0x8b01
cmpq %rbx, %r14
je 0x10eaa
movq %rbx, %rdi
callq 0x8b01
callq 0x10771
movq %r14, %rdi
callq 0x8b01
popq %rbx
popq %r14
popq %rbp
jmp 0x10469
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: dsum
void
dsum(struct atom *p1, struct atom *p2)
{
	int h = tos;
	p1 = cdr(p1);
	while (iscons(p1)) {
		push(car(p1));
		push(p2);
		derivative();
		p1 = cdr(p1);
	}
	add_terms(tos - h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rax
leaq 0x2fb37(%rip), %r15     # 0x40a00
cmovneq %r15, %rax
movl 0x293e4(%rip), %r14d    # 0x3a2b8
movq (%rax), %r12
cmpb $0x1, 0x10(%r12)
jne 0x10f12
movq %rsi, %rbx
movq (%r12), %rdi
callq 0x8b01
movq %rbx, %rdi
callq 0x8b01
callq 0x10771
leaq 0x8(%r12), %rax
cmpb $0x1, 0x10(%r12)
cmovneq %r15, %rax
movq (%rax), %r12
cmpb $0x1, 0x10(%r12)
je 0x10ee2
movl 0x293a0(%rip), %edi     # 0x3a2b8
subl %r14d, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa975
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: dproduct
void
dproduct(struct atom *p1, struct atom *p2)
{
	int i, j, n;
	struct atom *p3;
	n = lengthf(p1) - 1;
	for (i = 0; i < n; i++) {
		p3 = cdr(p1);
		for (j = 0; j < n; j++) {
			push(car(p3));
			if (i == j) {
				push(p2);
				derivative();
			}
			p3 = cdr(p3);
		}
		multiply_factors(n);
	}
	add_terms(n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x40(%rbp)
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movq %rdi, -0x30(%rbp)
cmpb $0x1, 0x10(%rdi)
jne 0x10f5e
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
incl %r15d
cmpb $0x1, 0x10(%rax)
je 0x10f51
testl %r15d, %r15d
jle 0x10fdc
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x38(%rbp)
xorl %r13d, %r13d
leaq 0x2fa87(%rip), %r12     # 0x40a00
movq -0x30(%rbp), %rax
cmpb $0x1, 0x10(%rax)
movq %r12, %r14
cmoveq -0x38(%rbp), %r14
xorl %ebx, %ebx
movq (%r14), %r14
cmpb $0x1, 0x10(%r14)
movq %r12, %rax
cmoveq %r14, %rax
movq (%rax), %rdi
callq 0x8b01
cmpl %ebx, %r13d
jne 0x10fb5
movq -0x40(%rbp), %rdi
callq 0x8b01
callq 0x10771
cmpb $0x1, 0x10(%r14)
je 0x10fc1
movq %r12, %r14
jmp 0x10fc5
addq $0x8, %r14
incl %ebx
cmpl %ebx, %r15d
jne 0x10f8b
movl %r15d, %edi
callq 0xa8bb
incl %r13d
cmpl %r15d, %r13d
jne 0x10f79
movl %r15d, %edi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa975
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: dpower
void
dpower(struct atom *F, struct atom *X)
{
	if (isnum(cadr(F)) && isnum(caddr(F))) {
		push_integer(0); // irr or imag
		return;
	}

	push(caddr(F));		// v/u
	push(cadr(F));
	divide();

	push(cadr(F));		// du/dx
	push(X);
	derivative();

	multiply();

	push(cadr(F));		// log u
	logfunc();

	push(caddr(F));		// dv/dx
	push(X);
	derivative();

	multiply();

	add();

	push(F);		// u^v

	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 0x2f9f1(%rip), %r15     # 0x40a00
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rax
movb 0x10(%rax), %cl
cmpb $0x1, %cl
movq %r15, %rdx
cmoveq %rax, %rdx
movq %rsi, %r14
movq (%rdx), %rdx
cmpb $0x4, 0x10(%rdx)
je 0x11049
cmpb $0x1, %cl
movq %r15, %rdx
cmoveq %rax, %rdx
movq (%rdx), %rdx
cmpb $0x5, 0x10(%rdx)
jne 0x110c9
leaq 0x8(%rax), %rdx
cmpb $0x1, %cl
leaq 0x2f9a9(%rip), %rsi     # 0x40a00
movq %rsi, %rdi
cmoveq %rdx, %rdi
movq (%rdi), %rdi
cmpb $0x1, 0x10(%rdi)
jne 0x11078
cmpb $0x1, %cl
leaq 0x2f98f(%rip), %rsi     # 0x40a00
cmoveq %rdx, %rsi
movq (%rsi), %rsi
movq (%rsi), %rsi
cmpb $0x4, 0x10(%rsi)
je 0x110b5
cmpb $0x1, %cl
leaq 0x2f975(%rip), %rsi     # 0x40a00
movq %rsi, %rdi
cmoveq %rdx, %rdi
movq (%rdi), %rdi
cmpb $0x1, 0x10(%rdi)
jne 0x110ac
cmpb $0x1, %cl
leaq 0x2f95b(%rip), %rsi     # 0x40a00
cmoveq %rdx, %rsi
movq (%rsi), %rsi
movq (%rsi), %rdx
cmpb $0x5, 0x10(%rdx)
jne 0x110c9
movq 0x2d084(%rip), %rdi     # 0x3e140
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8b01
addq $0x8, %rax
cmpb $0x1, %cl
movq %r15, %rdx
cmoveq %rax, %rdx
movq (%rdx), %rdx
cmpb $0x1, 0x10(%rdx)
movq %r15, %rdx
jne 0x110f4
cmpb $0x1, %cl
leaq 0x2f913(%rip), %rcx     # 0x40a00
cmoveq %rax, %rcx
movq (%rcx), %rdx
movq (%rdx), %rdi
callq 0x8b01
cmpb $0x1, 0x10(%rbx)
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x8b01
movq 0x1002cf(%rip), %rdi    # 0x1113f0
callq 0x8b01
callq 0xa234
movl $0x2, %edi
callq 0xa8bb
cmpb $0x1, 0x10(%rbx)
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x8b01
movq %r14, %rdi
callq 0x8b01
callq 0x10771
movl $0x2, %edi
callq 0xa8bb
cmpb $0x1, 0x10(%rbx)
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x8b01
callq 0xc5b0
cmpb $0x1, 0x10(%rbx)
cmovneq %r15, %r12
movq (%r12), %rax
movb 0x10(%rax), %cl
addq $0x8, %rax
cmpb $0x1, %cl
movq %r15, %rdx
cmoveq %rax, %rdx
movq (%rdx), %rdx
cmpb $0x1, 0x10(%rdx)
jne 0x111c4
cmpb $0x1, %cl
leaq 0x2f843(%rip), %rcx     # 0x40a00
cmoveq %rax, %rcx
movq (%rcx), %r15
movq (%r15), %rdi
callq 0x8b01
movq %r14, %rdi
callq 0x8b01
callq 0x10771
movl $0x2, %edi
callq 0xa8bb
movl $0x2, %edi
callq 0xa975
movq %rbx, %rdi
callq 0x8b01
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa8bb
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: dlog
void
dlog(struct atom *p1, struct atom *p2)
{
	push(cadr(p1));
	push(p2);
	derivative();
	push(cadr(p1));
	divide();
}

// 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 0x2f7dc(%rip), %r12     # 0x40a00
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x8b01
movq %r14, %rdi
callq 0x8b01
callq 0x10771
cmpb $0x1, 0x10(%rbx)
cmovneq %r12, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r12
movq (%r12), %rdi
callq 0x8b01
movq 0x10017f(%rip), %rdi    # 0x1113f0
callq 0x8b01
callq 0xa234
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa8bb
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: dsin
void
dsin(struct atom *p1, struct atom *p2)
{
	push(cadr(p1));
	push(p2);
	derivative();
	push(cadr(p1));
	cosfunc();
	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 0x2f756(%rip), %r12     # 0x40a00
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x8b01
movq %r14, %rdi
callq 0x8b01
callq 0x10771
cmpb $0x1, 0x10(%rbx)
cmovneq %r12, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r12
movq (%r12), %rdi
callq 0x8b01
callq 0xf2ab
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa8bb
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: dcos
void
dcos(struct atom *p1, struct atom *p2)
{
	push(cadr(p1));
	push(p2);
	derivative();
	push(cadr(p1));
	sinfunc();
	multiply();
	negate();
}

// 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 0x2f6dc(%rip), %r12     # 0x40a00
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x8b01
movq %r14, %rdi
callq 0x8b01
callq 0x10771
cmpb $0x1, 0x10(%rbx)
cmovneq %r12, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r12
movq (%r12), %rdi
callq 0x8b01
callq 0xfade
movl $0x2, %edi
callq 0xa8bb
movq 0x100070(%rip), %rdi    # 0x1113f0
callq 0x8b01
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa8bb
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: dtan
void
dtan(struct atom *p1, struct atom *p2)
{
	push(cadr(p1));
	push(p2);
	derivative();
	push(cadr(p1));
	cosfunc();
	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 0x2f64c(%rip), %r12     # 0x40a00
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x8b01
movq %r14, %rdi
callq 0x8b01
callq 0x10771
cmpb $0x1, 0x10(%rbx)
cmovneq %r12, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r12
movq (%r12), %rdi
callq 0x8b01
callq 0xf2ab
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
callq 0xacbe
callq 0xa234
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa8bb
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: darcsin
void
darcsin(struct atom *p1, struct atom *p2)
{
	push(cadr(p1));
	push(p2);
	derivative();
	push_integer(1);
	push(cadr(p1));
	push_integer(2);
	power();
	subtract();
	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), %r12
cmpb $0x1, 0x10(%rdi)
leaq 0x2f5c3(%rip), %r15     # 0x40a00
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x8b01
movq %r14, %rdi
callq 0x8b01
callq 0x10771
movq 0xf566a(%rip), %rdi     # 0x106ad8
callq 0x8b01
cmpb $0x1, 0x10(%rbx)
cmovneq %r15, %r12
movq (%r12), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r15
movq (%r15), %rdi
callq 0x8b01
movl $0x2, %edi
callq 0xacbe
callq 0xa234
movq 0xfff4b(%rip), %rdi     # 0x1113f0
callq 0x8b01
movl $0x2, %edi
callq 0xa8bb
movl $0x2, %edi
callq 0xa975
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x2, %esi
callq 0xa1f4
callq 0xa234
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa8bb
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: darccos
void
darccos(struct atom *p1, struct atom *p2)
{
	push(cadr(p1));
	push(p2);
	derivative();
	push_integer(1);
	push(cadr(p1));
	push_integer(2);
	power();
	subtract();
	push_rational(-1, 2);
	power();
	multiply();
	negate();
}

// 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 0x2f4ff(%rip), %r15     # 0x40a00
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x8b01
movq %r14, %rdi
callq 0x8b01
callq 0x10771
movq 0xf55a6(%rip), %rdi     # 0x106ad8
callq 0x8b01
cmpb $0x1, 0x10(%rbx)
cmovneq %r15, %r12
movq (%r12), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r15
movq (%r15), %rdi
callq 0x8b01
movl $0x2, %edi
callq 0xacbe
callq 0xa234
movq 0xffe87(%rip), %rdi     # 0x1113f0
callq 0x8b01
movl $0x2, %edi
callq 0xa8bb
movl $0x2, %edi
callq 0xa975
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x2, %esi
callq 0xa1f4
callq 0xa234
movl $0x2, %edi
callq 0xa8bb
movq 0xffe49(%rip), %rdi     # 0x1113f0
callq 0x8b01
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa8bb
// File: /workspace/github_c_makefile_star2_O1/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 0x2f425(%rip), %r15     # 0x40a00
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x8b01
movq %r14, %rdi
callq 0x8b01
callq 0x10771
movq 0xf54cc(%rip), %rdi     # 0x106ad8
callq 0x8b01
cmpb $0x1, 0x10(%rbx)
cmovneq %r15, %r12
movq (%r12), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r15
movq (%r15), %rdi
callq 0x8b01
movl $0x2, %edi
callq 0xacbe
callq 0xa234
movl $0x2, %edi
callq 0xa975
movq 0xffda3(%rip), %rdi     # 0x1113f0
callq 0x8b01
callq 0xa234
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa8bb
// File: /workspace/github_c_makefile_star2_O1/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 0x2f1fd(%rip), %r12     # 0x40a00
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x8b01
movq %r14, %rdi
callq 0x8b01
callq 0x10771
cmpb $0x1, 0x10(%rbx)
cmovneq %r12, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r12
movq (%r12), %rdi
callq 0x8b01
movl $0x2, %edi
callq 0xacbe
callq 0xa234
movq 0xf5279(%rip), %rdi     # 0x106ad8
callq 0x8b01
movl $0x2, %edi
callq 0xa975
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x2, %esi
callq 0xa1f4
callq 0xa234
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa8bb
// File: /workspace/github_c_makefile_star2_O1/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 0x2f14f(%rip), %r12     # 0x40a00
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x8b01
movq %r14, %rdi
callq 0x8b01
callq 0x10771
cmpb $0x1, 0x10(%rbx)
cmovneq %r12, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r12
movq (%r12), %rdi
callq 0x8b01
movl $0x2, %edi
callq 0xacbe
callq 0xa234
movq 0xffae3(%rip), %rdi     # 0x1113f0
callq 0x8b01
movl $0x2, %edi
callq 0xa975
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x2, %esi
callq 0xa1f4
callq 0xa234
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa8bb
// File: /workspace/github_c_makefile_star2_O1/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 0x2f0a1(%rip), %r15     # 0x40a00
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x8b01
movq %r14, %rdi
callq 0x8b01
callq 0x10771
movq 0xf5148(%rip), %rdi     # 0x106ad8
callq 0x8b01
cmpb $0x1, 0x10(%rbx)
cmovneq %r15, %r12
movq (%r12), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r15
movq (%r15), %rdi
callq 0x8b01
movl $0x2, %edi
callq 0xacbe
callq 0xa234
movq 0xffa29(%rip), %rdi     # 0x1113f0
callq 0x8b01
movl $0x2, %edi
callq 0xa8bb
movl $0x2, %edi
callq 0xa975
movq 0xffa09(%rip), %rdi     # 0x1113f0
callq 0x8b01
callq 0xa234
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa8bb
// File: /workspace/github_c_makefile_star2_O1/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 0x2efe0(%rip), %r15     # 0x40a00
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %rbx
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x8b01
movl $0x2, %edi
callq 0xacbe
callq 0xa234
movq 0xff99d(%rip), %rdi     # 0x1113f0
callq 0x8b01
movl $0x2, %edi
callq 0xa8bb
movq 0x3185f(%rip), %rdi     # 0x432c8
callq 0x8b01
callq 0xad38
callq 0xa234
movq 0x2f5d1(%rip), %rdi     # 0x41050
callq 0x8b01
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x2, %esi
callq 0xa1f4
callq 0xa234
movl $0x2, %edi
callq 0xa8bb
movl $0x2, %edi
callq 0xacbe
movl $0x2, %edi
callq 0xa8bb
cmpb $0x1, 0x10(%r14)
cmovneq %r15, %r12
movq (%r12), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r15
movq (%r15), %rdi
callq 0x8b01
movq %rbx, %rdi
callq 0x8b01
callq 0x10771
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa8bb
// File: /workspace/github_c_makefile_star2_O1/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 0x2eef1(%rip), %r15     # 0x40a00
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %rbx
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x8b01
movl $0x2, %edi
callq 0xacbe
callq 0xa234
movq 0xff8ae(%rip), %rdi     # 0x1113f0
callq 0x8b01
movl $0x2, %edi
callq 0xa8bb
movq 0x31770(%rip), %rdi     # 0x432c8
callq 0x8b01
callq 0xad38
callq 0xa234
movq 0x2f4e2(%rip), %rdi     # 0x41050
callq 0x8b01
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x2, %esi
callq 0xa1f4
callq 0xa234
movl $0x2, %edi
callq 0xa8bb
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
callq 0xacbe
movl $0x2, %edi
callq 0xa8bb
cmpb $0x1, 0x10(%r14)
cmovneq %r15, %r12
movq (%r12), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r15
movq (%r15), %rdi
callq 0x8b01
movq %rbx, %rdi
callq 0x8b01
callq 0x10771
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa8bb
// File: /workspace/github_c_makefile_star2_O1/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 0x2ee06(%rip), %rcx     # 0x40a00
cmoveq %rax, %rcx
movq %rsi, %r14
movq (%rcx), %rdi
cmpq 0x2edf5(%rip), %rdi     # 0x40a00
je 0x11c19
movq %r14, %rsi
callq 0x8bd3
testl %eax, %eax
je 0x11c43
movq 0x2cec0(%rip), %rdi     # 0x3eae0
callq 0x8b01
movq %rbx, %rdi
callq 0x8b01
movq %r14, %rdi
callq 0x8b01
movl $0x3, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x8ad9
movq 0x2c4f6(%rip), %rdi     # 0x3e140
popq %rbx
popq %r14
popq %rbp
jmp 0x8b01
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: sinhfunc
void
sinhfunc(void)
{
	int i, n;
	double d;
	struct atom *p1;

	p1 = pop();

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

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

	// sinh(z) = 1/2 exp(z) - 1/2 exp(-z)

	if (isdoublez(p1)) {
		push_rational(1, 2);
		push(p1);
		expfunc();
		push(p1);
		negate();
		expfunc();
		subtract();
		multiply();
		return;
	}

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

	// sinh(-x) -> -sinh(x)

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x8b78
movq %rax, %rbx
movzbl 0x10(%rax), %r14d
cmpl $0x5, %r14d
je 0x11cc0
cmpl $0x7, %r14d
jne 0x11cfb
movq %rbx, %rdi
callq 0x953d
movq %rax, %rbx
movq (%rax), %rax
movslq 0x64(%rax), %r14
testq %r14, %r14
jle 0x11cbb
xorl %r15d, %r15d
movq (%rbx), %rax
movq 0x68(%rax,%r15,8), %rdi
callq 0x8b01
callq 0x11c53
callq 0x8b78
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x11c94
movq %rbx, %rdi
jmp 0x11cec
movq %rbx, %rdi
callq 0x8b01
callq 0x9086
callq 0x7250
movsd %xmm0, -0x20(%rbp)
callq 0x74ec
movb $0x5, 0x10(%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8b01
movq %rbx, %rdi
callq 0xc3a9
testl %eax, %eax
je 0x11da0
movl $0x1, %edi
movl $0x2, %esi
callq 0xa1f4
movq %rbx, %rdi
callq 0x8b01
movq 0x3159f(%rip), %rdi     # 0x432c8
callq 0x8b01
callq 0xad38
callq 0xa234
movq %rbx, %rdi
callq 0x8b01
movq 0xff6a9(%rip), %rdi     # 0x1113f0
callq 0x8b01
movl $0x2, %edi
callq 0xa8bb
movq 0x3156b(%rip), %rdi     # 0x432c8
callq 0x8b01
callq 0xad38
callq 0xa234
movq 0xff67d(%rip), %rdi     # 0x1113f0
callq 0x8b01
movl $0x2, %edi
callq 0xa8bb
movl $0x2, %edi
callq 0xa975
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa8bb
movq %rbx, %rdi
callq 0xaece
testl %eax, %eax
je 0x11db8
movq 0x2c38d(%rip), %rdi     # 0x3e140
jmp 0x11cec
movq %rbx, %rdi
callq 0xa813
testl %eax, %eax
je 0x11df5
movq %rbx, %rdi
callq 0x8b01
movq 0xff61d(%rip), %rdi     # 0x1113f0
callq 0x8b01
movl $0x2, %edi
callq 0xa8bb
callq 0x11c53
movq 0xff602(%rip), %rdi     # 0x1113f0
callq 0x8b01
jmp 0x11d8c
cmpb $0x1, %r14b
leaq 0x2ec00(%rip), %rax     # 0x40a00
movq %rax, %rcx
cmoveq %rbx, %rcx
movq (%rcx), %rcx
cmpq 0x2c37f(%rip), %rcx     # 0x3e190
je 0x11e3b
movq 0x2fbae(%rip), %rdi     # 0x419c8
callq 0x8b01
movq %rbx, %rdi
callq 0x8b01
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8ad9
addq $0x8, %rbx
cmpb $0x1, %r14b
cmovneq %rax, %rbx
movq (%rbx), %rcx
cmpb $0x1, 0x10(%rcx)
cmoveq %rcx, %rax
movq (%rax), %rdi
jmp 0x11cec
// File: /workspace/github_c_makefile_star2_O1/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, %r14
leaq 0x8(%rdi), %r12
cmpb $0x1, 0x10(%rdi)
leaq 0x2eb54(%rip), %r15     # 0x40a00
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x8b01
callq 0x95e2
callq 0x8b78
cmpb $0x7, 0x10(%rax)
jne 0x11f60
movq %rax, %rbx
cmpb $0x1, 0x10(%r14)
movq %r15, %rcx
jne 0x11f00
movl $0x2, %eax
movq 0x8(%r14), %r14
decl %eax
cmpb $0x1, 0x10(%r14)
je 0x11eec
movq %r12, %rcx
testl %eax, %eax
je 0x11f74
movq (%rcx), %rax
movb 0x10(%rax), %cl
addq $0x8, %rax
cmpb $0x1, %cl
movq %r15, %rdx
cmoveq %rax, %rdx
movq (%rdx), %rdx
cmpb $0x1, 0x10(%rdx)
jne 0x11f2e
cmpb $0x1, %cl
leaq 0x2ead9(%rip), %rcx     # 0x40a00
cmoveq %rax, %rcx
movq (%rcx), %r15
movq (%r15), %rdi
callq 0x8b01
callq 0x95e2
callq 0xeb5b
testl %eax, %eax
jle 0x11f7b
movq (%rbx), %rcx
cmpl (%rcx), %eax
jg 0x11f7b
movq (%rbx), %rcx
cltq
movl (%rcx,%rax,4), %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xacbe
movq 0xf4b71(%rip), %rdi     # 0x106ad8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8b01
movl $0x1, %eax
jmp 0x11f40
leaq 0x14383(%rip), %rdi     # 0x26305
callq 0x77c8
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2ea68(%rip), %r14     # 0x40a00
movq 0x2ea61(%rip), %rdi     # 0x40a00
callq 0x8b01
leaq 0x8(%rbx), %rax
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %rax
movq (%rax), %rbx
cmpb $0x1, 0x10(%rbx)
jne 0x11fd8
callq 0x8b78
cmpb $0x1, 0x10(%rbx)
movq %r14, %rax
cmoveq %rbx, %rax
movq (%rax), %rdi
callq 0x8b01
callq 0x95ac
jmp 0x11fa4
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1242d
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 0x13d2c(%rip), %xmm0    # 0x26118
jne 0x123f0
jnp 0x12408
movq -0x30(%rbp), %rdi
movq -0x60(%rbp), %rsi
movl %r12d, %edx
movl %ebx, %ecx
movl %r14d, %r8d
callq 0x1243f
incl %r13d
incq %r14
addq $0x8, %r15
cmpq %r14, %r12
jne 0x123df
movq -0x50(%rbp), %r14
incq %r14
movq -0x58(%rbp), %r15
addq -0x38(%rbp), %r15
movq -0x48(%rbp), %rbx
cmpq -0x40(%rbp), %rbx
jne 0x123cf
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_O1/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 %rbx
pushq %rax
callq 0x8b78
movq %rax, %rbx
cmpb $0x7, 0x10(%rax)
jne 0x1272f
movq %rbx, %rdi
callq 0x953d
movq %rax, %rbx
movq (%rax), %rax
movslq 0x64(%rax), %r14
testq %r14, %r14
jle 0x1272a
xorl %r15d, %r15d
movq (%rbx), %rax
movq 0x68(%rax,%r15,8), %rdi
callq 0x8b01
callq 0x126d1
callq 0x8b78
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x12703
movq %rbx, %rdi
jmp 0x12778
movq %rbx, %rdi
callq 0x8b01
callq 0xa7fa
callq 0x8b78
movb 0x10(%rax), %cl
andb $-0x2, %cl
cmpb $0x4, %cl
jne 0x12787
movq %rax, %rdi
callq 0x8b01
callq 0x9086
callq 0x7050
movsd %xmm0, -0x20(%rbp)
callq 0x74ec
movb $0x5, 0x10(%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8b01
movq %rbx, %rdi
callq 0xa813
movl %eax, %r14d
movq 0x2c64f(%rip), %rdi     # 0x3ede8
callq 0x8b01
movq %rbx, %rdi
callq 0x8b01
testl %r14d, %r14d
je 0x127eb
movq 0xfec3e(%rip), %rdi     # 0x1113f0
callq 0x8b01
movl $0x2, %edi
callq 0xa8bb
movl $0x2, %edi
callq 0x8ad9
movq 0xfec1e(%rip), %rdi     # 0x1113f0
callq 0x8b01
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa8bb
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8ad9
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: 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 %rbx
pushq %rax
callq 0x8b78
movq %rax, %rbx
cmpb $0x7, 0x10(%rax)
jne 0x12892
movq %rbx, %rdi
callq 0x953d
movq %rax, %rbx
movq (%rax), %rax
movslq 0x64(%rax), %r14
testq %r14, %r14
jle 0x1288d
xorl %r15d, %r15d
movq (%rbx), %rax
movq 0x68(%rax,%r15,8), %rdi
callq 0x8b01
callq 0x12834
callq 0x8b78
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x12866
movq %rbx, %rdi
jmp 0x128db
movq %rbx, %rdi
callq 0x8b01
callq 0xa7fa
callq 0x8b78
movb 0x10(%rax), %cl
andb $-0x2, %cl
cmpb $0x4, %cl
jne 0x128ea
movq %rax, %rdi
callq 0x8b01
callq 0x9086
callq 0x7030
movsd %xmm0, -0x20(%rbp)
callq 0x74ec
movb $0x5, 0x10(%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8b01
movq %rbx, %rdi
callq 0xa813
movl %eax, %r14d
movq 0x2c4ec(%rip), %rdi     # 0x3ede8
callq 0x8b01
movq %rbx, %rdi
callq 0x8b01
testl %r14d, %r14d
je 0x12930
movq 0xfeadb(%rip), %rdi     # 0x1113f0
callq 0x8b01
movl $0x2, %edi
callq 0xa8bb
movl $0x2, %edi
callq 0x8ad9
jmp 0x12950
movl $0x2, %edi
callq 0x8ad9
movq 0xfeaaf(%rip), %rdi     # 0x1113f0
callq 0x8b01
movl $0x2, %edi
callq 0xa8bb
movq 0xf4181(%rip), %rdi     # 0x106ad8
callq 0x8b01
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa975
// File: /workspace/github_c_makefile_star2_O1/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 0x2e074(%rip), %r14     # 0x40a00
movq %r14, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rax
movq (%rax), %rdi
callq 0x8b01
callq 0x95e2
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %r15
movq (%r15), %rax
leaq 0x8(%rax), %rcx
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rcx
movq (%rcx), %rbx
cmpb $0x1, 0x10(%rbx)
jne 0x12a06
movq (%rbx), %rdi
callq 0x8b01
callq 0x95e2
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 0x8b01
callq 0x95e2
callq 0x12a11
jmp 0x129ab
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq