LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x2f949(%rip), %r12     # 0x3e9f0
movq %r12, %rax
cmoveq %r14, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x861b
callq 0x8fbb
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 0xf21c
xorl %r15d, %r15d
xorl %ebx, %ebx
testl %r15d, %r15d
setne %al
movb 0x10(%r13), %cl
testb $0x1, %al
jne 0xf107
cmpb $0x1, %cl
jne 0xf23b
testb $0x1, %al
je 0xf110
movq %rbx, %r14
jmp 0xf13f
cmpb $0x1, %cl
movq %r12, %rax
cmoveq %r13, %rax
movq (%rax), %rdi
callq 0x861b
callq 0x8fbb
callq 0x868d
movq %rax, %r14
cmpb $0x1, 0x10(%r13)
leaq 0x8(%r13), %rax
cmovneq %r12, %rax
movq (%rax), %r13
movb 0x10(%r14), %al
andb $-0x2, %al
cmpb $0x4, %al
jne 0xf195
movq %r14, %rdi
callq 0x861b
callq 0xd9d9
movl %eax, %r14d
movq 0x317d8(%rip), %rdi     # 0x40938
callq 0x861b
callq 0x868d
movq %rax, %r15
testl %r14d, %r14d
movl $0x0, %eax
cmovlel %eax, %r14d
subl $0x1, %r14d
jb 0xf18e
movq %r15, %rdi
callq 0x861b
callq 0xf24a
jmp 0xf179
xorl %eax, %eax
jmp 0xf0f6
xorl %r15d, %r15d
cmpb $0x1, 0x10(%r13)
jne 0xf202
movq (%r13), %rdi
callq 0x861b
callq 0x8fbb
callq 0x868d
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 0xf1fe
movq %rbx, %rdi
callq 0x861b
callq 0xd9d9
movl %eax, %r15d
testl %eax, %eax
movl $0x0, %eax
cmovlel %eax, %r15d
subl $0x1, %r15d
jb 0xf214
movq %r14, %rdi
callq 0x861b
callq 0xf24a
jmp 0xf1e9
pushq $0x1
popq %r15
movq %r14, %rdi
callq 0x861b
callq 0xf24a
jmp 0xf0f0
xorl %r15d, %r15d
jmp 0xf0f0
movq 0x31715(%rip), %rdi     # 0x40938
callq 0x861b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf24a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: 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 0x868d
movq %rax, %rbx
callq 0x868d
cmpb $0x7, 0x10(%rax)
movb 0x10(%rbx), %cl
movq %rax, %rdi
movq %rbx, %rsi
jne 0xf27c
addq $0x8, %rsp
cmpb $0x7, %cl
jne 0xf28c
popq %rbx
popq %rbp
jmp 0xf29a
addq $0x8, %rsp
cmpb $0x7, %cl
jne 0xf293
popq %rbx
popq %rbp
jmp 0xf462
popq %rbx
popq %rbp
jmp 0xf3ee
popq %rbx
popq %rbp
jmp 0xf4d9
// File: /workspace/github_c_makefile_star2_O2/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, -0x38(%rbp)
movq (%rsi), %rcx
movl (%rcx), %edx
addl (%rax), %edx
cmpl $0x19, %edx
jge 0xf3e2
movq %rdi, %r15
movl 0x64(%rax), %ebx
movslq 0x64(%rcx), %r14
movl %r14d, %edi
imull %ebx, %edi
callq 0x77da
movq %rax, -0x30(%rbp)
xorl %r12d, %r12d
testl %r14d, %r14d
movl $0x0, %r13d
cmovgl %r14d, %r13d
testl %ebx, %ebx
cmovlel %r12d, %ebx
movq %rbx, -0x48(%rbp)
shlq $0x3, %r14
movq %r14, -0x40(%rbp)
pushq $0x68
popq %rbx
cmpq -0x48(%rbp), %r12
je 0xf352
xorl %r14d, %r14d
cmpq %r14, %r13
je 0xf349
movq (%r15), %rax
movq 0x68(%rax,%r12,8), %rdi
callq 0x861b
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq 0x68(%rax,%r14,8), %rdi
callq 0x861b
callq 0xf24a
callq 0x868d
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
addq %rbx, %rcx
movq %rax, (%rcx,%r14,8)
incq %r14
jmp 0xf309
incq %r12
addq -0x40(%rbp), %rbx
jmp 0xf300
movq (%r15), %rax
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
movl (%rcx), %ecx
addl (%rax), %ecx
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl %ecx, (%rax)
movq (%r15), %rax
movl (%rax), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpq %rcx, %rax
je 0xf391
movq (%r15), %rdx
movl 0x4(%rdx,%rcx,4), %edx
movq -0x30(%rbp), %rsi
movq (%rsi), %rsi
movl %edx, 0x4(%rsi,%rcx,4)
incq %rcx
jmp 0xf375
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
movl (%rcx), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
leaq 0x4(,%rax,4), %rax
cmpq %rdx, %rcx
je 0xf3cb
movq -0x38(%rbp), %rsi
movq (%rsi), %rsi
movl 0x4(%rsi,%rdx,4), %esi
movq -0x30(%rbp), %rdi
movq (%rdi), %rdi
addq %rax, %rdi
movl %esi, (%rdi,%rdx,4)
incq %rdx
jmp 0xf3a9
movq -0x30(%rbp), %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x861b
leaq 0x14058(%rip), %rdi     # 0x23441
callq 0x7756
// File: /workspace/github_c_makefile_star2_O2/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 0x8f1b
movq %rax, %r15
movq (%r14), %rax
movl 0x64(%rax), %r12d
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
cmpq %r13, %r12
je 0xf44c
movq (%r14), %rax
movq 0x68(%rax,%r13,8), %rdi
callq 0x861b
movq %rbx, %rdi
callq 0x861b
callq 0xf24a
callq 0x868d
movq (%r15), %rcx
movq %rax, 0x68(%rcx,%r13,8)
incq %r13
jmp 0xf41b
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x861b
// File: /workspace/github_c_makefile_star2_O2/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 0x8f1b
movq %rax, %r15
movq (%rbx), %rax
movl 0x64(%rax), %r12d
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
cmpq %r13, %r12
je 0xf4c3
movq %r14, %rdi
callq 0x861b
movq (%rbx), %rax
movq 0x68(%rax,%r13,8), %rdi
callq 0x861b
callq 0xf24a
callq 0x868d
movq (%r15), %rcx
movq %rax, 0x68(%rcx,%r13,8)
incq %r13
jmp 0xf492
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x861b
// File: /workspace/github_c_makefile_star2_O2/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, %r15
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rcx
leaq 0x2f256(%rip), %rax     # 0x3e9f0
cmovneq %rax, %rcx
movq %rsi, %r14
movq (%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0xf7b9
movq (%rcx), %rdi
movq 0x8(%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
je 0xf7c9
jmp 0xf7cc
movq 0x2f230(%rip), %rcx     # 0x3e9f0
cmpb $0x1, 0x10(%rcx)
movq %rcx, %rdi
jne 0xf7cc
movq %rcx, %rax
movq (%rax), %rbx
cmpq %r14, %rbx
je 0xf82a
callq 0x861b
movq %r14, %rdi
callq 0x861b
callq 0xf24a
callq 0x868d
movb 0x10(%rax), %dl
cmpb $0x1, %dl
leaq 0x2f1f8(%rip), %rcx     # 0x3e9f0
movq %rcx, %rsi
cmoveq %rax, %rsi
movq 0x2d2ca(%rip), %rdi     # 0x3cad0
cmpq %rdi, (%rsi)
je 0xf84e
movq %rax, %rdi
callq 0x861b
movq %rbx, %rdi
callq 0x861b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xf24a
movq 0x2d29f(%rip), %rdi     # 0x3cad0
callq 0x861b
movq %r15, %rdi
callq 0x861b
movq %r14, %rdi
callq 0x861b
pushq $0x3
popq %rdi
jmp 0xf8ec
addq $0x8, %rax
cmpb $0x1, %dl
cmovneq %rcx, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
jne 0xf871
movq (%rax), %r15
movq 0x8(%rax), %rax
cmpb $0x1, 0x10(%rax)
je 0xf881
jmp 0xf884
movq 0x2f178(%rip), %rax     # 0x3e9f0
cmpb $0x1, 0x10(%rax)
movq %rax, %r15
jne 0xf884
movq %rax, %rcx
movq (%rcx), %r14
callq 0x861b
movq 0x2d23d(%rip), %rdi     # 0x3cad0
callq 0x861b
movq %r15, %rdi
callq 0x861b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8760
testl %eax, %eax
js 0xf8cd
movq %rbx, %rdi
callq 0x861b
pushq $0x3
popq %rbx
movl %ebx, %edi
callq 0x85eb
movq %r14, %rdi
callq 0x861b
movl %ebx, %edi
jmp 0xf8ec
movq %r14, %rdi
callq 0x861b
pushq $0x3
popq %r14
movl %r14d, %edi
callq 0x85eb
movq %rbx, %rdi
callq 0x861b
movl %r14d, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x85eb
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: 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
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rcx
leaq 0x2f0df(%rip), %rax     # 0x3e9f0
cmovneq %rax, %rcx
movq %rsi, %rbx
movq (%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0xf930
movq (%rcx), %rdi
movq 0x8(%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
je 0xf940
jmp 0xf943
movq 0x2f0b9(%rip), %rcx     # 0x3e9f0
cmpb $0x1, 0x10(%rcx)
movq %rcx, %rdi
jne 0xf943
movq %rcx, %rax
movq (%rax), %r14
callq 0x861b
cmpq %rbx, %r14
je 0xf96e
movq %rbx, %rdi
callq 0x861b
callq 0xf24a
movq %r14, %rdi
callq 0x861b
popq %rbx
popq %r14
popq %rbp
jmp 0xef62
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, %rbx
movq %rdi, %r14
movl 0x2891d(%rip), %r15d    # 0x382a8
leaq 0x2f05e(%rip), %r12     # 0x3e9f0
leaq 0x8(%r14), %rax
cmpb $0x1, 0x10(%r14)
cmovneq %r12, %rax
movq (%rax), %r14
cmpb $0x1, 0x10(%r14)
jne 0xf9c0
movq (%r14), %rdi
callq 0x861b
movq %rbx, %rdi
callq 0x861b
callq 0xf24a
jmp 0xf992
movl 0x288e2(%rip), %edi     # 0x382a8
subl %r15d, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa0fd
// File: /workspace/github_c_makefile_star2_O2/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 $0x28, %rsp
movq %rsi, -0x48(%rbp)
movq %rdi, %rbx
callq 0x86c3
movl %eax, %r15d
decl %r15d
movq %rbx, -0x40(%rbp)
leaq 0x8(%rbx), %rax
movq %rax, -0x38(%rbp)
xorl %r13d, %r13d
testl %r15d, %r15d
movl $0x0, %eax
cmovgl %r15d, %eax
movl %eax, -0x2c(%rbp)
leaq 0x2efd2(%rip), %r14     # 0x3e9f0
cmpl -0x2c(%rbp), %r13d
je 0xfa89
movq -0x40(%rbp), %rax
cmpb $0x1, 0x10(%rax)
movq %r14, %r12
cmoveq -0x38(%rbp), %r12
xorl %ebx, %ebx
cmpl %ebx, %r15d
je 0xfa7c
movq (%r12), %r12
cmpb $0x1, 0x10(%r12)
movq %r14, %rax
cmoveq %r12, %rax
movq (%rax), %rdi
callq 0x861b
cmpl %ebx, %r13d
jne 0xfa67
movq -0x48(%rbp), %rdi
callq 0x861b
callq 0xf24a
cmpb $0x1, 0x10(%r12)
je 0xfa74
movq %r14, %r12
jmp 0xfa78
addq $0x8, %r12
incl %ebx
jmp 0xfa36
movl %r15d, %edi
callq 0xa04c
incl %r13d
jmp 0xfa1e
movl %r15d, %edi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa0fd
// File: /workspace/github_c_makefile_star2_O2/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), %r15
cmpb $0x1, 0x10(%rdi)
leaq 0x2ef34(%rip), %rdx     # 0x3e9f0
movq %rdx, %rax
cmoveq %r15, %rax
movq %rsi, %r14
movq (%rax), %rax
movb 0x10(%rax), %cl
cmpb $0x1, %cl
jne 0xfb0e
movq (%rax), %rsi
movb 0x10(%rsi), %sil
andb $-0x2, %sil
cmpb $0x4, %sil
jne 0xfb7a
movq 0x8(%rax), %rsi
cmpb $0x1, 0x10(%rsi)
jne 0xfb3a
movq (%rsi), %rsi
cmpb $0x4, 0x10(%rsi)
je 0xfb6b
cmpb $0x1, %cl
jne 0xfb52
movq 0x8(%rax), %rsi
cmpb $0x1, 0x10(%rsi)
jne 0xfb62
leaq 0x8(%rax), %rdx
jmp 0xfb5f
movq 0x2eedb(%rip), %rsi     # 0x3e9f0
movzbl 0x10(%rsi), %esi
cmpl $0x4, %esi
je 0xfb6b
cmpl $0x5, %esi
jne 0xfb85
movq 0x2eec6(%rip), %rsi     # 0x3e9f0
movzbl 0x10(%rsi), %edi
cmpl $0x1, %edi
je 0xfb49
cmpl $0x4, %edi
je 0xfb6b
jmp 0xfb52
movq 0x2eeaf(%rip), %rsi     # 0x3e9f0
cmpb $0x4, 0x10(%rsi)
jne 0xfb62
jmp 0xfb6b
movq (%rsi), %rsi
cmpb $0x4, 0x10(%rsi)
je 0xfb6b
movq 0x2ee97(%rip), %rsi     # 0x3e9f0
cmpb $0x1, 0x10(%rsi)
jne 0xfb62
movq (%rdx), %rdx
movq (%rdx), %rdx
cmpb $0x5, 0x10(%rdx)
jne 0xfb7a
xorl %edi, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa426
cmpb $0x1, %cl
jne 0xfb85
movq 0x8(%rax), %rax
jmp 0xfb8c
movq 0x2ee64(%rip), %rax     # 0x3e9f0
cmpb $0x1, 0x10(%rax)
je 0xfb99
leaq 0x2ee57(%rip), %rax     # 0x3e9f0
movq (%rax), %rdi
callq 0x861b
cmpb $0x1, 0x10(%rbx)
leaq 0x2ee44(%rip), %r12     # 0x3e9f0
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x861b
callq 0xca0b
cmpb $0x1, 0x10(%rbx)
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x861b
movq %r14, %rdi
callq 0x861b
callq 0xf24a
callq 0x9fae
cmpb $0x1, 0x10(%rbx)
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x861b
callq 0xba1b
cmpb $0x1, 0x10(%rbx)
cmovneq %r12, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
jne 0xfc35
movq 0x8(%rax), %rax
jmp 0xfc3c
movq 0x2edb4(%rip), %rax     # 0x3e9f0
cmpb $0x1, 0x10(%rax)
jne 0xfc45
movq %rax, %r12
movq (%r12), %rdi
callq 0x861b
movq %r14, %rdi
callq 0x861b
callq 0xf24a
callq 0x9fae
callq 0xa1f6
movq %rbx, %rdi
callq 0x861b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9fae
// File: /workspace/github_c_makefile_star2_O2/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 0x2ed59(%rip), %r12     # 0x3e9f0
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x861b
movq %r14, %rdi
callq 0x861b
callq 0xf24a
cmpb $0x1, 0x10(%rbx)
cmovneq %r12, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r12
movq (%r12), %rdi
callq 0x861b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xca0b
// File: /workspace/github_c_makefile_star2_O2/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 0x2ec74(%rip), %r12     # 0x3e9f0
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x861b
movq %r14, %rdi
callq 0x861b
callq 0xf24a
cmpb $0x1, 0x10(%rbx)
cmovneq %r12, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r12
movq (%r12), %rdi
callq 0x861b
callq 0xe75b
callq 0x9fae
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x975f
// File: /workspace/github_c_makefile_star2_O2/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 0x2ebfa(%rip), %r12     # 0x3e9f0
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x861b
movq %r14, %rdi
callq 0x861b
callq 0xf24a
cmpb $0x1, 0x10(%rbx)
cmovneq %r12, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r12
movq (%r12), %rdi
callq 0x861b
callq 0xe086
pushq $-0x2
popq %rdi
callq 0xa426
callq 0x9a87
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9fae
// File: /workspace/github_c_makefile_star2_O2/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 0x2eb78(%rip), %r15     # 0x3e9f0
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x861b
movq %r14, %rdi
callq 0x861b
callq 0xf24a
pushq $0x1
popq %rdi
callq 0xa426
cmpb $0x1, 0x10(%rbx)
cmovneq %r15, %r12
movq (%r12), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r15
movq (%r15), %rdi
callq 0x861b
pushq $0x2
popq %rbx
movl %ebx, %edi
callq 0xa426
callq 0x9a87
callq 0xb07f
pushq $-0x1
popq %rdi
movl %ebx, %esi
callq 0x9a47
callq 0x9a87
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9fae
// File: /workspace/github_c_makefile_star2_O2/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 0x2eadd(%rip), %r15     # 0x3e9f0
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x861b
movq %r14, %rdi
callq 0x861b
callq 0xf24a
pushq $0x1
popq %rdi
callq 0xa426
cmpb $0x1, 0x10(%rbx)
cmovneq %r15, %r12
movq (%r12), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r15
movq (%r15), %rdi
callq 0x861b
pushq $0x2
popq %rbx
movl %ebx, %edi
callq 0xa426
callq 0x9a87
callq 0xb07f
pushq $-0x1
popq %rdi
movl %ebx, %esi
callq 0x9a47
callq 0x9a87
callq 0x9fae
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x975f
// File: /workspace/github_c_makefile_star2_O2/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 0x2ea3d(%rip), %r15     # 0x3e9f0
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x861b
movq %r14, %rdi
callq 0x861b
callq 0xf24a
pushq $0x1
popq %rdi
callq 0xa426
cmpb $0x1, 0x10(%rbx)
cmovneq %r15, %r12
movq (%r12), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r15
movq (%r15), %rdi
callq 0x861b
pushq $0x2
popq %rdi
callq 0xa426
callq 0x9a87
callq 0xa1f6
callq 0xa03a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9fae
// File: /workspace/github_c_makefile_star2_O2/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 0x2e9ae(%rip), %r12     # 0x3e9f0
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x861b
movq %r14, %rdi
callq 0x861b
callq 0xf24a
cmpb $0x1, 0x10(%rbx)
cmovneq %r12, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r12
movq (%r12), %rdi
callq 0x861b
callq 0xebf7
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9fae
// File: /workspace/github_c_makefile_star2_O2/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 0x2e939(%rip), %r12     # 0x3e9f0
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x861b
movq %r14, %rdi
callq 0x861b
callq 0xf24a
cmpb $0x1, 0x10(%rbx)
cmovneq %r12, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r12
movq (%r12), %rdi
callq 0x861b
callq 0x10567
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9fae
// File: /workspace/github_c_makefile_star2_O2/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 0x2e842(%rip), %r12     # 0x3e9f0
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x861b
movq %r14, %rdi
callq 0x861b
callq 0xf24a
cmpb $0x1, 0x10(%rbx)
cmovneq %r12, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r12
movq (%r12), %rdi
callq 0x861b
pushq $0x2
popq %rbx
movl %ebx, %edi
callq 0xa426
callq 0x9a87
pushq $0x1
popq %rdi
callq 0xa426
callq 0xa1f6
pushq $-0x1
popq %rdi
movl %ebx, %esi
callq 0x9a47
callq 0x9a87
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9fae
// File: /workspace/github_c_makefile_star2_O2/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 0x2e7a7(%rip), %r12     # 0x3e9f0
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x861b
movq %r14, %rdi
callq 0x861b
callq 0xf24a
cmpb $0x1, 0x10(%rbx)
cmovneq %r12, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r12
movq (%r12), %rdi
callq 0x861b
pushq $0x2
popq %rbx
movl %ebx, %edi
callq 0xa426
callq 0x9a87
pushq $-0x1
popq %r14
movl %r14d, %edi
callq 0xa426
callq 0xa1f6
movl %r14d, %edi
movl %ebx, %esi
callq 0x9a47
callq 0x9a87
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9fae
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
cmpb $0x1, 0x10(%rdi)
leaq 0x2e676(%rip), %r13     # 0x3e9f0
movq %r13, %rax
cmoveq %rbx, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, -0x30(%rbp)
cmovneq %r13, %rax
movq (%rax), %rdi
callq 0x861b
pushq $0x2
popq %r15
movl %r15d, %edi
callq 0xa426
callq 0x9a87
pushq $-0x1
popq %r12
movl %r12d, %edi
callq 0xa426
callq 0x9fae
callq 0xe4ce
movq 0x2ec7a(%rip), %rdi     # 0x3f040
callq 0x861b
movl %r12d, %edi
movl %r15d, %esi
callq 0x9a47
callq 0x9a87
callq 0x9fae
movl %r15d, %edi
callq 0xa426
callq 0x9fae
cmpb $0x1, 0x10(%r14)
cmovneq %r13, %rbx
movq (%rbx), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r13
movq (%r13), %rdi
callq 0x861b
movq -0x30(%rbp), %rdi
callq 0x861b
callq 0xf24a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9fae
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
cmpb $0x1, 0x10(%rdi)
leaq 0x2e5a5(%rip), %r13     # 0x3e9f0
movq %r13, %rax
cmoveq %rbx, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, -0x30(%rbp)
cmovneq %r13, %rax
movq (%rax), %rdi
callq 0x861b
pushq $0x2
popq %r15
movl %r15d, %edi
callq 0xa426
callq 0x9a87
pushq $-0x1
popq %r12
movl %r12d, %edi
callq 0xa426
callq 0x9fae
callq 0xe4ce
movq 0x2eba9(%rip), %rdi     # 0x3f040
callq 0x861b
movl %r12d, %edi
movl %r15d, %esi
callq 0x9a47
callq 0x9a87
callq 0x9fae
pushq $-0x2
popq %rdi
callq 0xa426
callq 0x9fae
cmpb $0x1, 0x10(%r14)
cmovneq %r13, %rbx
movq (%rbx), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r13
movq (%r13), %rdi
callq 0x861b
movq -0x30(%rbp), %rdi
callq 0x861b
callq 0xf24a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9fae
// File: /workspace/github_c_makefile_star2_O2/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 0x2e4db(%rip), %rcx     # 0x3e9f0
cmoveq %rax, %rcx
movq %rsi, %r14
movq (%rcx), %rdi
cmpq 0x2e4ca(%rip), %rdi     # 0x3e9f0
je 0x10534
movq %r14, %rsi
callq 0x86d9
testl %eax, %eax
je 0x1055c
movq 0x2c595(%rip), %rdi     # 0x3cad0
callq 0x861b
movq %rbx, %rdi
callq 0x861b
movq %r14, %rdi
callq 0x861b
pushq $0x3
popq %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x85eb
xorl %edi, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0xa426
// File: /workspace/github_c_makefile_star2_O2/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 0x868d
movq %rax, %rbx
movzbl 0x10(%rax), %r14d
cmpl $0x5, %r14d
je 0x105e1
cmpl $0x7, %r14d
jne 0x10602
movq %rbx, %rdi
callq 0x8f1b
movq %rax, %rbx
movq (%rax), %rax
movl 0x64(%rax), %r14d
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
cmpq %r15, %r14
je 0x105cf
movq (%rbx), %rax
movq 0x68(%rax,%r15,8), %rdi
callq 0x861b
callq 0x10567
callq 0x868d
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r15,8)
incq %r15
jmp 0x105a6
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x861b
movq %rbx, %rdi
callq 0x861b
callq 0x8ae1
callq 0x7240
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xaf59
movq %rbx, %rdi
callq 0xb876
testl %eax, %eax
je 0x1064c
pushq $0x1
popq %rdi
pushq $0x2
popq %rsi
callq 0x9a47
movq %rbx, %rdi
callq 0x861b
callq 0xe4ce
movq %rbx, %rdi
callq 0x861b
callq 0x975f
callq 0xe4ce
callq 0xb07f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9fae
movq %rbx, %rdi
callq 0xa641
testl %eax, %eax
je 0x10669
xorl %edi, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa426
movq %rbx, %rdi
callq 0x9fd6
testl %eax, %eax
je 0x10696
movq %rbx, %rdi
callq 0x861b
callq 0x975f
callq 0x10567
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x975f
cmpb $0x1, %r14b
leaq 0x2e34f(%rip), %rax     # 0x3e9f0
movq %rax, %rcx
cmoveq %rbx, %rcx
movq (%rcx), %rcx
cmpq 0x2bace(%rip), %rcx     # 0x3c180
je 0x106da
movq 0x2f2fd(%rip), %rdi     # 0x3f9b8
callq 0x861b
movq %rbx, %rdi
callq 0x861b
pushq $0x2
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x85eb
addq $0x8, %rbx
cmpb $0x1, %r14b
cmovneq %rax, %rbx
movq (%rbx), %rcx
cmpb $0x1, 0x10(%rcx)
cmoveq %rcx, %rax
movq (%rax), %rdi
jmp 0x105d2
// File: /workspace/github_c_makefile_star2_O2/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 0x2e2a5(%rip), %r15     # 0x3e9f0
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x861b
callq 0x8fbb
callq 0x868d
cmpb $0x7, 0x10(%rax)
jne 0x1078a
movq %rax, %rbx
movq %r14, %rdi
callq 0x86c3
cmpl $0x2, %eax
jne 0x1078f
pushq $0x1
popq %rax
jmp 0x107ce
pushq $0x1
popq %rdi
jmp 0x107db
cmpb $0x1, 0x10(%r14)
cmovneq %r15, %r12
movq (%r12), %rax
cmpb $0x1, 0x10(%rax)
jne 0x107a8
movq 0x8(%rax), %rax
jmp 0x107af
movq 0x2e241(%rip), %rax     # 0x3e9f0
cmpb $0x1, 0x10(%rax)
jne 0x107b8
movq %rax, %r15
movq (%r15), %rdi
callq 0x861b
callq 0x8fbb
callq 0xd9d9
testl %eax, %eax
jle 0x107e8
movq (%rbx), %rcx
cmpl (%rcx), %eax
jg 0x107e8
decl %eax
movl 0x4(%rcx,%rax,4), %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa426
leaq 0x12b6e(%rip), %rdi     # 0x2335d
callq 0x7756
// File: /workspace/github_c_makefile_star2_O2/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
movq 0x2e1eb(%rip), %rdi     # 0x3e9f0
callq 0x861b
leaq 0x2e1df(%rip), %r14     # 0x3e9f0
leaq 0x8(%rbx), %rax
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %rax
movq (%rax), %rbx
cmpb $0x1, 0x10(%rbx)
jne 0x10845
callq 0x868d
cmpb $0x1, 0x10(%rbx)
movq %r14, %rax
cmoveq %rbx, %rax
movq (%rax), %rdi
callq 0x861b
callq 0x8f7d
jmp 0x10811
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, -0x58(%rbp)
movslq %edx, %rax
cmpl $0x2, %eax
pushq $0x1
popq %rcx
cmovgel %eax, %ecx
decl %ecx
movq %rcx, -0x38(%rbp)
movl %eax, %r15d
movq %rdi, -0x50(%rbp)
leaq 0x8(%rdi), %r14
leaq 0x8(,%rax,8), %rax
movq %rax, -0x30(%rbp)
xorl %r12d, %r12d
pushq $0x1
popq %rbx
xorl %r13d, %r13d
cmpq -0x38(%rbp), %r12
je 0x10c0d
movq %r14, -0x48(%rbp)
movq %rbx, -0x40(%rbp)
cmpq %rbx, %r15
je 0x10bf9
movsd (%r14), %xmm0
ucomisd 0x1259d(%rip), %xmm0    # 0x23170
jne 0x10bd7
jnp 0x10bf0
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
movl %r15d, %edx
movl %r12d, %ecx
movl %ebx, %r8d
callq 0x10c1f
incl %r13d
incq %rbx
addq $0x8, %r14
jmp 0x10bc1
incq %r12
movq -0x40(%rbp), %rbx
incq %rbx
movq -0x48(%rbp), %r14
addq -0x30(%rbp), %r14
jmp 0x10bb3
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_O2/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 0x868d
movq %rax, %rbx
cmpb $0x7, 0x10(%rax)
jne 0x10e80
movq %rbx, %rdi
callq 0x8f1b
movq %rax, %rbx
movq (%rax), %rax
movl 0x64(%rax), %r14d
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
cmpq %r15, %r14
je 0x10ebe
movq (%rbx), %rax
movq 0x68(%rax,%r15,8), %rdi
callq 0x861b
callq 0x10e23
callq 0x868d
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r15,8)
incq %r15
jmp 0x10e57
movq %rbx, %rdi
callq 0x861b
callq 0x9fbd
callq 0x868d
movb 0x10(%rax), %cl
andb $-0x2, %cl
cmpb $0x4, %cl
jne 0x10ed0
movq %rax, %rdi
callq 0x861b
callq 0x8ae1
callq 0x7050
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xaf59
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x861b
movq %rbx, %rdi
callq 0x9fd6
movl %eax, %r14d
movq 0x2bef6(%rip), %rdi     # 0x3cdd8
callq 0x861b
movq %rbx, %rdi
callq 0x861b
testl %r14d, %r14d
je 0x10f10
callq 0x975f
pushq $0x2
popq %rdi
callq 0x85eb
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x975f
pushq $0x2
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x85eb
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: 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 0x868d
movq %rax, %rbx
cmpb $0x7, 0x10(%rax)
jne 0x10fb4
movq %rbx, %rdi
callq 0x8f1b
movq %rax, %rbx
movq (%rax), %rax
movl 0x64(%rax), %r14d
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
cmpq %r15, %r14
je 0x10ff2
movq (%rbx), %rax
movq 0x68(%rax,%r15,8), %rdi
callq 0x861b
callq 0x10f57
callq 0x868d
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r15,8)
incq %r15
jmp 0x10f8b
movq %rbx, %rdi
callq 0x861b
callq 0x9fbd
callq 0x868d
movb 0x10(%rax), %cl
andb $-0x2, %cl
cmpb $0x4, %cl
jne 0x11004
movq %rax, %rdi
callq 0x861b
callq 0x8ae1
callq 0x7030
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xaf59
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x861b
movq %rbx, %rdi
callq 0x9fd6
movl %eax, %r14d
movq 0x2bdc2(%rip), %rdi     # 0x3cdd8
callq 0x861b
movq %rbx, %rdi
callq 0x861b
testl %r14d, %r14d
je 0x11037
callq 0x975f
pushq $0x2
popq %rdi
callq 0x85eb
jmp 0x11044
pushq $0x2
popq %rdi
callq 0x85eb
callq 0x975f
pushq $0x1
popq %rdi
callq 0xa426
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa1f6
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x8(%rdi), %r15
cmpb $0x1, 0x10(%rdi)
leaq 0x2d97c(%rip), %rbx     # 0x3e9f0
movq %rbx, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
leaq 0x10(%rdi), %r14
cmovneq %rbx, %rax
movq (%rax), %rdi
callq 0x861b
callq 0x8fbb
cmpb $0x1, (%r14)
cmovneq %rbx, %r15
movq (%r15), %rax
leaq 0x8(%rax), %rcx
cmpb $0x1, 0x10(%rax)
cmovneq %rbx, %rcx
movq (%rcx), %r15
cmpb $0x1, 0x10(%r15)
jne 0x110f8
leaq 0x10(%r15), %r14
movq (%r15), %rdi
callq 0x861b
callq 0x8fbb
cmpb $0x1, 0x10(%r15)
leaq 0x8(%r15), %r15
movq %rbx, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %rbx, %rax
movq (%rax), %rdi
callq 0x861b
callq 0x8fbb
callq 0x11103
jmp 0x11097
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: asubst
void
asubst(void)
{
	int h, i, n;
	struct atom *p1, *p2, *p3;

	p3 = pop(); // new expr
	p2 = pop(); // old expr
	p1 = pop(); // expr

	if (p2 == symbol(NIL) || p3 == symbol(NIL)) {
		push(p1);
		return;
	}

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

	if (equal(p1, p2)) {
		push(p3);
		return;
	}

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

	// depth first

	h = tos;

	push(car(p1)); // func name
	p1 = cdr(p1);

	while (iscons(p1)) {
		push(car(p1));
		push(p2);
		push(p3);
		asubst();
		p1 = cdr(p1);
	}

	list(tos - h);

	evalf(); // normalize

	p1 = pop();

	if (addcmp(p1, p2)) {
		push(p1);
		push(p2);
		subtract();
		push(p3);
		add();
		return;
	}

	if (mulcmp(p1, p2) || powcmp(p1, p2)) {
		push(p1);
		push(p2);
		divide();
		push(p3);
		multiply();
		return;
	}

	push(p1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x868d
movq %rax, %rbx
callq 0x868d
movq %rax, %r14
callq 0x868d
movq %rax, %r15
movq 0x2d8c0(%rip), %rax     # 0x3e9f0
cmpq %rax, %r14
sete %cl
cmpq %rax, %rbx
sete %al
orb %cl, %al
cmpb $0x1, %al
jne 0x11158
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x861b
cmpb $0x7, 0x10(%r15)
jne 0x111b4
movq %r15, %rdi
callq 0x8f1b
movq %rax, %r15
movq (%rax), %rax
movl 0x64(%rax), %r12d
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
cmpq %r13, %r12
je 0x11142
movq (%r15), %rax
movq 0x68(%rax,%r13,8), %rdi
callq 0x861b
movq %r14, %rdi
callq 0x861b
movq %rbx, %rdi
callq 0x861b
callq 0x11103
callq 0x868d
movq (%r15), %rcx
movq %rax, 0x68(%rcx,%r13,8)
incq %r13
jmp 0x1117b
movq %r15, %rdi
movq %r14, %rsi
callq 0x8760
testl %eax, %eax
je 0x1121a
cmpb $0x1, 0x10(%r15)
jne 0x11142
movl 0x270d3(%rip), %r12d    # 0x382a8
movq (%r15), %rdi
callq 0x861b
leaq 0x2d80c(%rip), %r13     # 0x3e9f0
leaq 0x8(%r15), %rax
cmpb $0x1, 0x10(%r15)
cmovneq %r13, %rax
movq (%rax), %r15
cmpb $0x1, 0x10(%r15)
jne 0x11222
movq (%r15), %rdi
callq 0x861b
movq %r14, %rdi
callq 0x861b
movq %rbx, %rdi
callq 0x861b
callq 0x11103
jmp 0x111e4
movq %rbx, %rdi
jmp 0x11145
movl 0x27080(%rip), %edi     # 0x382a8
subl %r12d, %edi
callq 0x85eb
callq 0x8fbb
callq 0x868d
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x112ce
testl %eax, %eax
je 0x1127c
movq %r15, %rdi
callq 0x861b
movq %r14, %rdi
callq 0x861b
callq 0xb07f
movq %rbx, %rdi
callq 0x861b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa1f6
movq %r15, %rdi
movq %r14, %rsi
callq 0x1137d
testl %eax, %eax
jne 0x1129e
movq %r15, %rdi
movq %r14, %rsi
callq 0x11464
testl %eax, %eax
je 0x11142
movq %r15, %rdi
callq 0x861b
movq %r14, %rdi
callq 0x861b
callq 0xca0b
movq %rbx, %rdi
callq 0x861b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9fae
// File: /workspace/github_c_makefile_star2_O2/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), %al
cmpb $0x1, %al
leaq 0x2d70b(%rip), %r14     # 0x3e9f0
movq %r14, %rcx
cmoveq %rdi, %rcx
movq (%rcx), %rdx
xorl %ebx, %ebx
cmpq 0x2ff98(%rip), %rdx     # 0x41290
jne 0x11372
movb 0x10(%rsi), %cl
cmpb $0x1, %cl
movq %r14, %r8
cmoveq %rsi, %r8
cmpq %rdx, (%r8)
jne 0x11372
addq $0x8, %rdi
cmpb $0x1, %al
cmovneq %r14, %rdi
addq $0x8, %rsi
cmpb $0x1, %cl
cmovneq %r14, %rsi
movq (%rsi), %r15
pushq $0x1
popq %rbx
movq (%rdi), %r12
cmpb $0x1, 0x10(%r12)
movb 0x10(%r15), %al
jne 0x1136b
cmpb $0x1, %al
jne 0x11372
movq (%r12), %rdi
movq (%r15), %rsi
callq 0x8760
testl %eax, %eax
jne 0x1135a
cmpb $0x1, 0x10(%r15)
leaq 0x8(%r15), %rax
cmovneq %r14, %rax
movq (%rax), %r15
leaq 0x8(%r12), %rdi
cmpb $0x1, 0x10(%r12)
cmovneq %r14, %rdi
jmp 0x11327
xorl %ebx, %ebx
cmpb $0x1, %al
setne %bl
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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), %al
cmpb $0x1, %al
leaq 0x2d65c(%rip), %r15     # 0x3e9f0
movq %r15, %rcx
cmoveq %rdi, %rcx
movq (%rcx), %rdx
xorl %r14d, %r14d
cmpq 0x2fef0(%rip), %rdx     # 0x41298
jne 0x11458
movq %rdi, %rbx
movb 0x10(%rsi), %cl
cmpb $0x1, %cl
movq %r15, %rdi
cmoveq %rsi, %rdi
cmpq %rdx, (%rdi)
jne 0x11458
addq $0x8, %rbx
cmpb $0x1, %al
cmovneq %r15, %rbx
addq $0x8, %rsi
cmpb $0x1, %cl
cmovneq %r15, %rsi
movq (%rsi), %r12
pushq $0x1
popq %r14
movq (%rbx), %rbx
cmpb $0x1, 0x10(%rbx)
movb 0x10(%r12), %al
jne 0x1144f
cmpb $0x1, %al
jne 0x11458
movq (%rbx), %rdi
movq (%r12), %rsi
callq 0x8760
testl %eax, %eax
je 0x1142c
cmpb $0x1, 0x10(%rbx)
movq %r15, %rax
cmoveq %rbx, %rax
movq (%rax), %rdi
cmpb $0x1, 0x10(%r12)
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rsi
callq 0x11464
testl %eax, %eax
je 0x1143e
cmpb $0x1, 0x10(%r12)
leaq 0x8(%r12), %rax
cmovneq %r15, %rax
movq (%rax), %r12
cmpb $0x1, 0x10(%rbx)
je 0x11449
movq %r15, %rbx
jmp 0x113e3
addq $0x8, %rbx
jmp 0x113e3
xorl %r14d, %r14d
cmpb $0x1, %al
setne %r14b
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq