LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: push_bignum
void
push_bignum(int sign, uint32_t *a, uint32_t *b)
{
	struct atom *p;

	// normalize zero

	if (MZERO(a)) {
		sign = MPLUS;
		if (!MEQUAL(b, 1)) {
			mfree(b);
			b = mint(1);
		}
	}

	p = alloc_atom();
	p->atomtype = RATIONAL;
	p->sign = sign;
	p->u.q.a = a;
	p->u.q.b = b;

	push(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movl %edi, %r15d
cmpl $0x1, -0x4(%rsi)
jne 0xb059
cmpl $0x0, (%rbx)
jne 0xb059
cmpl $0x1, -0x4(%r14)
jne 0xb043
xorl %r15d, %r15d
cmpl $0x1, (%r14)
je 0xb059
movq %r14, %rdi
callq 0x7ad9
pushq $0x1
popq %rdi
callq 0x7a09
movq %rax, %r14
xorl %r15d, %r15d
callq 0x749c
movb $0x4, 0x10(%rax)
movb %r15b, 0x12(%rax)
movq %rbx, (%rax)
movq %r14, 0x8(%rax)
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x861b
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_and
void
eval_and(struct atom *p1)
{
	struct atom *p2;
	p1 = cdr(p1);
	while (iscons(p1)) {
		push(car(p1));
		evalp();
		p2 = pop();
		if (iszero(p2)) {
			push_integer(0);
			return;
		}
		p1 = cdr(p1);
	}
	push_integer(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x33418(%rip), %r15     # 0x3e9f0
pushq $0x1
popq %rbx
leaq 0x8(%r14), %rax
cmpb $0x1, 0x10(%r14)
cmovneq %r15, %rax
movq (%rax), %r14
cmpb $0x1, 0x10(%r14)
jne 0xb612
movq (%r14), %rdi
callq 0x861b
callq 0x940b
callq 0x868d
movq %rax, %rdi
callq 0xa641
testl %eax, %eax
je 0xb5db
xorl %ebx, %ebx
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa426
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: isdoublez
int
isdoublez(struct atom *p)
{
	if (car(p) == symbol(ADD)) {

		if (lengthf(p) != 3)
			return 0;

		if (!isdouble(cadr(p))) // x
			return 0;

		p = caddr(p);
	}

	if (car(p) != symbol(MULTIPLY))
		return 0;

	if (lengthf(p) != 3)
		return 0;

	if (!isdouble(cadr(p))) // y
		return 0;

	p = caddr(p);

	if (car(p) != symbol(POWER))
		return 0;

	if (!isminusone(cadr(p)))
		return 0;

	if (!isequalq(caddr(p), 1, 2))
		return 0;

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x10(%rdi), %r15b
cmpb $0x1, %r15b
leaq 0x3315e(%rip), %r14     # 0x3e9f0
movq %r14, %rax
cmoveq %rdi, %rax
movq (%rax), %rax
cmpq 0x359ed(%rip), %rax     # 0x41290
je 0xb90c
cmpb $0x1, %r15b
movq %r14, %rax
cmoveq %rbx, %rax
movq (%rax), %rax
cmpq 0x359de(%rip), %rax     # 0x41298
jne 0xb995
movq %rbx, %rdi
callq 0x86c3
cmpl $0x3, %eax
jne 0xb995
addq $0x8, %rbx
cmpb $0x1, %r15b
cmovneq %r14, %rbx
movq (%rbx), %rax
cmpb $0x1, 0x10(%rax)
jne 0xb96c
movq (%rax), %rcx
cmpb $0x5, 0x10(%rcx)
jne 0xb995
movq 0x8(%rax), %rcx
cmpb $0x1, 0x10(%rcx)
leaq 0x330ea(%rip), %rax     # 0x3e9f0
cmoveq %rcx, %rax
jmp 0xb97c
movq %rbx, %rdi
callq 0x86c3
cmpl $0x3, %eax
jne 0xb995
addq $0x8, %rbx
cmpb $0x1, %r15b
leaq 0x330c8(%rip), %rax     # 0x3e9f0
cmovneq %rax, %rbx
movq (%rbx), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0xb953
movq (%rcx), %rax
cmpb $0x5, 0x10(%rax)
jne 0xb995
movq 0x8(%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
leaq 0x330a3(%rip), %rax     # 0x3e9f0
cmoveq %rcx, %rax
jmp 0xb960
movq 0x33096(%rip), %rcx     # 0x3e9f0
cmpb $0x5, 0x10(%rcx)
jne 0xb995
movq (%rax), %rbx
movb 0x10(%rbx), %r15b
jmp 0xb8a5
movq 0x3307d(%rip), %rax     # 0x3e9f0
cmpb $0x5, 0x10(%rax)
movq %r14, %rax
jne 0xb995
movq (%rax), %rax
movb 0x10(%rax), %cl
cmpb $0x1, %cl
cmoveq %rax, %r14
movq (%r14), %rdx
cmpq 0x3590d(%rip), %rdx     # 0x412a0
je 0xb9a2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq $0x8, %rax
cmpb $0x1, %cl
leaq 0x33040(%rip), %rbx     # 0x3e9f0
cmovneq %rbx, %rax
movq (%rax), %r14
movb 0x10(%r14), %r15b
cmpb $0x1, %r15b
movq %rbx, %rax
cmoveq %r14, %rax
movq (%rax), %rdi
callq 0xbfac
testl %eax, %eax
je 0xb995
cmpb $0x1, %r15b
jne 0xb9de
movq 0x8(%r14), %rax
jmp 0xb9e5
movq 0x3300b(%rip), %rax     # 0x3e9f0
cmpb $0x1, 0x10(%rax)
jne 0xb9ee
movq %rax, %rbx
movq (%rbx), %rdi
pushq $0x1
popq %rsi
pushq $0x2
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xbf44
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: isequalq
int
isequalq(struct atom *p, int a, int b)
{
	int sign;
	if (isrational(p)) {
		if (a < 0) {
			sign = MMINUS;
			a = -a;
		} else
			sign = MPLUS;
		return p->sign == sign && MEQUAL(p->u.q.a, a) && MEQUAL(p->u.q.b, b);
	}
	if (isdouble(p))
		return p->u.d == (double) a / b;
	return 0;
}

// Assembly:
movzbl 0x10(%rdi), %eax
cmpl $0x5, %eax
je 0xbf8a
cmpl $0x4, %eax
jne 0xbf86
movl %esi, %eax
negl %eax
cmovsl %esi, %eax
shrl $0x1f, %esi
movzbl 0x12(%rdi), %ecx
cmpl %ecx, %esi
jne 0xbf86
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rcx
cmpl $0x1, -0x4(%rcx)
jne 0xbfa5
cmpl %eax, (%rcx)
jne 0xbfa5
movq 0x8(%rdi), %rax
cmpl $0x1, -0x4(%rax)
jne 0xbfa5
cmpl %edx, (%rax)
sete %al
jmp 0xbfa7
xorl %eax, %eax
jmp 0xbfa8
cvtsi2sd %esi, %xmm0
cvtsi2sd %edx, %xmm1
divsd %xmm1, %xmm0
cmpeqsd (%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0xbfa8
xorl %eax, %eax
popq %rbp
movzbl %al, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: arccosh
void
arccosh(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]);
			arccosh();
			p1->u.tensor->elem[i] = pop();
		}
		push(p1);
		return;
	}

	if (isdouble(p1)) {
		push(p1);
		d = pop_double();
		if (d >= 1.0) {
			d = acosh(d);
			push_double(d);
			return;
		}
	}

	// arccosh(z) = log(sqrt(z^2 - 1) + z)

	if (isdouble(p1) || isdoublez(p1)) {
		push(p1);
		push(p1);
		multiply();
		push_double(-1.0);
		add();
		sqrtfunc();
		push(p1);
		add();
		logfunc();
		return;
	}

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

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

	push_symbol(ARCCOSH);
	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 0xc06a
cmpl $0x7, %r14d
jne 0xc08b
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 0xc058
movq (%rbx), %rax
movq 0x68(%rax,%r15,8), %rdi
callq 0x861b
callq 0xbff0
callq 0x868d
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r15,8)
incq %r15
jmp 0xc02f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x861b
movq %rbx, %rdi
callq 0x861b
callq 0x8ae1
ucomisd 0x170c1(%rip), %xmm0    # 0x23140
jae 0xc0df
movb 0x10(%rbx), %r14b
cmpb $0x5, %r14b
je 0xc097
movq %rbx, %rdi
callq 0xb876
testl %eax, %eax
je 0xc0f3
movq %rbx, %rdi
callq 0x861b
movq %rbx, %rdi
callq 0x861b
callq 0x9fae
movsd 0x17094(%rip), %xmm0    # 0x23148
callq 0xaf59
callq 0xa1f6
callq 0xba06
movq %rbx, %rdi
callq 0x861b
callq 0xa1f6
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xba1b
callq 0x7330
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xaf59
movq %rbx, %rdi
callq 0xa95a
testl %eax, %eax
je 0xc110
xorl %edi, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa426
cmpb $0x1, %r14b
leaq 0x328d5(%rip), %rax     # 0x3e9f0
movq %rax, %rcx
cmoveq %rbx, %rcx
movq (%rcx), %rcx
cmpq 0x306bc(%rip), %rcx     # 0x3c7e8
je 0xc154
movq 0x3003b(%rip), %rdi     # 0x3c170
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 0xc05b
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: arcsinh
void
arcsinh(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]);
			arcsinh();
			p1->u.tensor->elem[i] = pop();
		}
		push(p1);
		return;
	}

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

	// arcsinh(z) = log(sqrt(z^2 + 1) + z)

	if (isdoublez(p1)) {
		push(p1);
		push(p1);
		multiply();
		push_double(1.0);
		add();
		sqrtfunc();
		push(p1);
		add();
		logfunc();
		return;
	}

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

	// arcsinh(-x) = -arcsinh(x)

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

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

	push_symbol(ARCSINH);
	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 0xc449
cmpl $0x7, %r14d
jne 0xc46a
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 0xc4c7
movq (%rbx), %rax
movq 0x68(%rax,%r15,8), %rdi
callq 0x861b
callq 0xc3dd
callq 0x868d
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r15,8)
incq %r15
jmp 0xc41c
movq %rbx, %rdi
callq 0x861b
callq 0x8ae1
callq 0x7390
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xaf59
movq %rbx, %rdi
callq 0xb876
movq %rbx, %rdi
testl %eax, %eax
je 0xc4be
callq 0x861b
movq %rbx, %rdi
callq 0x861b
callq 0x9fae
movsd 0x16cad(%rip), %xmm0    # 0x23140
callq 0xaf59
callq 0xa1f6
callq 0xba06
movq %rbx, %rdi
callq 0x861b
callq 0xa1f6
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xba1b
callq 0xa641
testl %eax, %eax
je 0xc4d9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x861b
movq %rbx, %rdi
callq 0x9fd6
testl %eax, %eax
je 0xc506
movq %rbx, %rdi
callq 0x861b
callq 0x975f
callq 0xc3dd
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x975f
cmpb $0x1, %r14b
leaq 0x324df(%rip), %rax     # 0x3e9f0
movq %rax, %rcx
cmoveq %rbx, %rcx
movq (%rcx), %rcx
cmpq 0x33496(%rip), %rcx     # 0x3f9b8
je 0xc54a
movq 0x2fc55(%rip), %rdi     # 0x3c180
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 0xc4ca
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_arctan
void
eval_arctan(struct atom *p1)
{
	push(cadr(p1));
	evalf();

	p1 = cddr(p1);

	if (iscons(p1)) {
		push(car(p1));
		evalf();
	} else
		push_integer(1);

	arctan();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
cmpb $0x1, 0x10(%rdi)
leaq 0x3246b(%rip), %r15     # 0x3e9f0
movq %r15, %rax
cmoveq %r14, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x861b
callq 0x8fbb
cmpb $0x1, 0x10(%rbx)
cmovneq %r15, %r14
movq (%r14), %rax
leaq 0x8(%rax), %rcx
cmpb $0x1, 0x10(%rax)
cmovneq %r15, %rcx
movq (%rcx), %rax
cmpb $0x1, 0x10(%rax)
jne 0xc5d3
movq (%rax), %rdi
callq 0x861b
callq 0x8fbb
jmp 0xc5db
pushq $0x1
popq %rdi
callq 0xa426
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xc5ea
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_arg
void
eval_arg(struct atom *p1)
{
	push(cadr(p1));
	evalf();
	polar(); // normalize
	argfunc();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rax
leaq 0x31d79(%rip), %rcx     # 0x3e9f0
cmovneq %rcx, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %rcx
movq (%rcx), %rdi
callq 0x861b
callq 0x8fbb
callq 0xcc9e
popq %rbp
jmp 0xcd92
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: polar
void
polar(void)
{
	int i, n;
	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]);
			polar();
			p1->u.tensor->elem[i] = pop();
		}
		push(p1);
		return;
	}

	push(p1);
	magfunc();
	push(p1);
	argfunc();
	p2 = pop();
	if (isdouble(p2)) {
		push_double(p2->u.d / M_PI);
		push_symbol(PI);
		push(imaginaryunit);
		multiply_factors(3);
	} else {
		// the result of arg is arctan
		push(p2);
		push(imaginaryunit);
		multiply();
	}
	expfunc();
	multiply();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x868d
movq %rax, %rbx
cmpb $0x7, 0x10(%rax)
jne 0xccfb
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 0xcd53
movq (%rbx), %rax
movq 0x68(%rax,%r15,8), %rdi
callq 0x861b
callq 0xcc9e
callq 0x868d
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r15,8)
incq %r15
jmp 0xccd2
movq %rbx, %rdi
callq 0x861b
callq 0xd79d
movq %rbx, %rdi
callq 0x861b
callq 0xcd92
callq 0x868d
cmpb $0x5, 0x10(%rax)
jne 0xcd65
movsd (%rax), %xmm0
divsd 0x1640c(%rip), %xmm0    # 0x23138
callq 0xaf59
movq 0x32308(%rip), %rdi     # 0x3f040
callq 0x861b
movq 0xf7d8c(%rip), %rdi     # 0x104ad0
callq 0x861b
pushq $0x3
popq %rdi
callq 0xa04c
jmp 0xcd7e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x861b
movq %rax, %rdi
callq 0x861b
movq 0xf7d5c(%rip), %rdi     # 0x104ad0
callq 0x861b
callq 0x9fae
callq 0xe4ce
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9fae
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: argfunc
void
argfunc(void)
{
	int i, n;
	struct atom *p1, *p2, *num, *den;

	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]);
			argfunc();
			p1->u.tensor->elem[i] = pop();
		}
		push(p1);
		return;
	}

	push(p1);
	numden();
	num = pop();
	den = pop();
	push(num);
	arg_nib();
	push(den);
	arg_nib();
	subtract();

	p2 = pop();

	if (hasdouble(p1) && findf(p2, symbol(PI))) {
		push(p2);
		push_symbol(PI);
		push_double(M_PI);
		subst();
		evalf();
	} else
		push(p2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x868d
movq %rax, %rbx
cmpb $0x7, 0x10(%rax)
jne 0xcdf3
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 0xce8b
movq (%rbx), %rax
movq 0x68(%rax,%r15,8), %rdi
callq 0x861b
callq 0xcd92
callq 0x868d
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r15,8)
incq %r15
jmp 0xcdc6
movq %rbx, %rdi
callq 0x861b
callq 0xcea2
callq 0x868d
movq %rax, %r14
callq 0x868d
movq %rax, %r15
movq %r14, %rdi
callq 0x861b
callq 0xcf25
movq %r15, %rdi
callq 0x861b
callq 0xcf25
callq 0xb07f
callq 0x868d
movq %rax, %r14
movq %rbx, %rdi
callq 0xd1c9
testl %eax, %eax
je 0xce90
movq 0x321f6(%rip), %rsi     # 0x3f040
movq %r14, %rdi
callq 0x86d9
testl %eax, %eax
je 0xce90
movq %r14, %rdi
callq 0x861b
movq 0x321db(%rip), %rdi     # 0x3f040
callq 0x861b
movsd 0x162c6(%rip), %xmm0    # 0x23138
callq 0xaf59
callq 0x8de5
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8fbb
movq %rbx, %rdi
jmp 0xce93
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x861b
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: numden
void
numden(void)
{
	struct atom *p0, *p1, *p2;

	p1 = pop();
	p2 = one;

	while (numden_find_divisor(p1)) {
		p0 = pop();
		push(p0);
		push(p1);
		numden_cancel_factor();
		p1 = pop();
		push(p0);
		push(p2);
		multiply();
		p2 = pop();
	}

	push(p2);
	push(p1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x868d
movq %rax, %rbx
movq 0xf7c0d(%rip), %r14     # 0x104ac8
movq %rbx, %rdi
callq 0x20e3a
testl %eax, %eax
je 0xcf0b
callq 0x868d
movq %rax, %r15
movq %rax, %rdi
callq 0x861b
movq %rbx, %rdi
callq 0x861b
callq 0x20eb7
callq 0x868d
movq %rax, %rbx
movq %r15, %rdi
callq 0x861b
movq %r14, %rdi
callq 0x861b
callq 0x9fae
callq 0x868d
movq %rax, %r14
jmp 0xcebb
movq %r14, %rdi
callq 0x861b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x861b
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: hasdouble
int
hasdouble(struct atom *p)
{
	if (iscons(p)) {
		p = cdr(p);
		while (iscons(p)) {
			if (hasdouble(car(p)))
				return 1;
			p = cdr(p);
		}
		return 0;
	}
	return isdouble(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movb 0x10(%rdi), %al
cmpb $0x1, %al
jne 0xd1f6
movq %rdi, %r14
pushq $0x1
popq %rbx
movq 0x8(%r14), %r14
cmpb $0x1, 0x10(%r14)
jne 0xd1ff
movq (%r14), %rdi
callq 0xd1c9
testl %eax, %eax
je 0xd1dd
jmp 0xd201
xorl %ebx, %ebx
cmpb $0x5, %al
sete %bl
jmp 0xd201
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: imag
void
imag(void)
{
	int i, n;
	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]);
			imag();
			p1->u.tensor->elem[i] = pop();
		}
		push(p1);
		return;
	}

	push(p1);
	rect();
	p1 = pop();
	push_rational(-1, 2);
	push(imaginaryunit);
	push(p1);
	push(p1);
	conjfunc();
	subtract();
	multiply_factors(3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x868d
cmpb $0x7, 0x10(%rax)
jne 0xd262
movq %rax, %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 0xd2ba
movq (%rbx), %rax
movq 0x68(%rax,%r15,8), %rdi
callq 0x861b
callq 0xd208
callq 0x868d
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r15,8)
incq %r15
jmp 0xd239
movq %rax, %rdi
callq 0x861b
callq 0x128dd
callq 0x868d
movq %rax, %rbx
pushq $-0x1
popq %rdi
pushq $0x2
popq %rsi
callq 0x9a47
movq 0xf7847(%rip), %rdi     # 0x104ad0
callq 0x861b
movq %rbx, %rdi
callq 0x861b
movq %rbx, %rdi
callq 0x861b
callq 0x9771
callq 0xb07f
pushq $0x3
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa04c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x861b
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: real
void
real(void)
{
	int i, n;
	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]);
			real();
			p1->u.tensor->elem[i] = pop();
		}
		push(p1);
		return;
	}

	push(p1);
	rect();
	p1 = pop();
	push(p1);
	push(p1);
	conjfunc();
	add();
	push_rational(1, 2);
	multiply();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x868d
cmpb $0x7, 0x10(%rax)
jne 0xd326
movq %rax, %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 0xd36f
movq (%rbx), %rax
movq 0x68(%rax,%r15,8), %rdi
callq 0x861b
callq 0xd2cc
callq 0x868d
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r15,8)
incq %r15
jmp 0xd2fd
movq %rax, %rdi
callq 0x861b
callq 0x128dd
callq 0x868d
movq %rax, %rbx
movq %rax, %rdi
callq 0x861b
movq %rbx, %rdi
callq 0x861b
callq 0x9771
callq 0xa1f6
pushq $0x1
popq %rdi
pushq $0x2
popq %rsi
callq 0x9a47
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9fae
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x861b
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: get_binding
struct atom *
get_binding(struct atom *p1)
{
	struct atom *p2;
	if (!isusersymbol(p1))
		stopf("symbol error");
	p2 = binding[p1->u.usym.index];
	if (p2 == NULL || p2 == symbol(NIL))
		p2 = p1; // symbol binds to itself
	return p2;
}

// Assembly:
cmpb $0x3, 0x10(%rdi)
jne 0xd3de
movl 0x8(%rdi), %eax
leaq 0xf771c(%rip), %rcx     # 0x104ae0
movq (%rcx,%rax,8), %rcx
cmpq 0x31621(%rip), %rcx     # 0x3e9f0
movq %rcx, %rax
cmoveq %rdi, %rax
testq %rcx, %rcx
cmoveq %rdi, %rax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1abe9(%rip), %rdi     # 0x27fd2
callq 0x7756
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: ceilingfunc
void
ceilingfunc(void)
{
	int i, n;
	uint32_t *a, *b;
	double d;
	struct atom *p1;

	p1 = pop();

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

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

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

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

	push_symbol(CEILING);
	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 $0x7, %r14d
jne 0xd4a0
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 0xd4ac
movq (%rbx), %rax
movq 0x68(%rax,%r15,8), %rdi
callq 0x861b
callq 0xd43e
callq 0x868d
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r15,8)
incq %r15
jmp 0xd477
movq %rbx, %rdi
callq 0x8b5d
testl %eax, %eax
je 0xd4be
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x861b
cmpl $0x5, %r14d
je 0xd508
cmpl $0x4, %r14d
jne 0xd529
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x7e20
movq %rax, %r14
pushq $0x1
popq %rdi
callq 0x7a09
movq %rax, %r15
movq %rbx, %rdi
callq 0x8c2a
testl %eax, %eax
je 0xd54f
pushq $0x1
popq %rdi
movq %r14, %rsi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb015
movq %rbx, %rdi
callq 0x861b
callq 0x8ae1
callq 0x7350
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xaf59
movq 0x2f270(%rip), %rdi     # 0x3c7a0
callq 0x861b
movq %rbx, %rdi
callq 0x861b
pushq $0x2
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x85eb
xorl %edi, %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0xb015
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_check
void
eval_check(struct atom *p1)
{
	push(cadr(p1));
	evalp();
	p1 = pop();
	if (iszero(p1))
		stopf("check");
	push_symbol(NIL); // no result is printed
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rax
leaq 0x3146a(%rip), %rcx     # 0x3e9f0
cmovneq %rcx, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %rcx
movq (%rcx), %rdi
callq 0x861b
callq 0x940b
callq 0x868d
movq %rax, %rdi
callq 0xa641
testl %eax, %eax
jne 0xd5c0
movq 0x31436(%rip), %rdi     # 0x3e9f0
popq %rbp
jmp 0x861b
leaq 0x15ccf(%rip), %rdi     # 0x23296
callq 0x7756
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_clear
void
eval_clear(struct atom *p1)
{
	int i;

	(void) p1; // silence compiler

	save_symbol(symbol(TRACE));
	save_symbol(symbol(TTY));

	for (i = 0; i < 27 * BUCKETSIZE; i++) {
		binding[i] = NULL;
		usrfunc[i] = NULL;
	}

	run_init_script();

	restore_symbol();
	restore_symbol();

	if (gc_level == eval_level)
		gc();

	push_symbol(NIL); // result
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x32739(%rip), %rdi     # 0x3fd10
callq 0xd63f
movq 0x3273d(%rip), %rdi     # 0x3fd20
callq 0xd63f
xorl %eax, %eax
leaq 0xf74ef(%rip), %rcx     # 0x104ae0
leaq 0xfc948(%rip), %rdx     # 0x109f40
cmpq $0x5460, %rax           # imm = 0x5460
je 0xd610
andq $0x0, (%rax,%rcx)
andq $0x0, (%rax,%rdx)
addq $0x8, %rax
jmp 0xd5f8
callq 0xd673
callq 0xd684
callq 0xd684
movl 0xf748b(%rip), %eax     # 0x104ab0
cmpl 0xf7489(%rip), %eax     # 0x104ab4
jne 0xd632
callq 0x756a
movq 0x313b7(%rip), %rdi     # 0x3e9f0
popq %rbp
jmp 0x861b
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: restore_symbol
void
restore_symbol(void)
{
	struct atom *p1, *p2, *p3;
	p3 = pop();
	p2 = pop();
	p1 = pop();
	set_symbol(p1, p2, p3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
callq 0x868d
movq %rax, %rbx
callq 0x868d
movq %rax, %r14
callq 0x868d
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x12721
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: clockfunc
void
clockfunc(void)
{
	int i, n;
	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]);
			clockfunc();
			p1->u.tensor->elem[i] = pop();
		}
		push(p1);
		return;
	}

	push(p1);
	magfunc();

	push_integer(-1); // base

	push(p1);
	argfunc();
	push_symbol(PI);
	divide();

	power();

	multiply();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x868d
movq %rax, %rbx
cmpb $0x7, 0x10(%rax)
jne 0xd744
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 0xd78b
movq (%rbx), %rax
movq 0x68(%rax,%r15,8), %rdi
callq 0x861b
callq 0xd6e7
callq 0x868d
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r15,8)
incq %r15
jmp 0xd71b
movq %rbx, %rdi
callq 0x861b
callq 0xd79d
pushq $-0x1
popq %rdi
callq 0xa426
movq %rbx, %rdi
callq 0x861b
callq 0xcd92
movq 0x318d3(%rip), %rdi     # 0x3f040
callq 0x861b
callq 0xca0b
callq 0x9a87
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9fae
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x861b
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: magfunc
void
magfunc(void)
{
	int i, n;
	struct atom *p1, *num, *den;

	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]);
			magfunc();
			p1->u.tensor->elem[i] = pop();
		}
		push(p1);
		return;
	}

	// use numden to handle (a + i b) / (c + i d)

	push(p1);
	numden();
	num = pop();
	den = pop();
	push(num);
	magfunc_nib();
	push(den);
	magfunc_nib();
	divide();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x868d
cmpb $0x7, 0x10(%rax)
jne 0xd7f7
movq %rax, %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 0xd83d
movq (%rbx), %rax
movq 0x68(%rax,%r15,8), %rdi
callq 0x861b
callq 0xd79d
callq 0x868d
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r15,8)
incq %r15
jmp 0xd7ce
movq %rax, %rdi
callq 0x861b
callq 0xcea2
callq 0x868d
movq %rax, %rbx
callq 0x868d
movq %rax, %r14
movq %rbx, %rdi
callq 0x861b
callq 0x15682
movq %r14, %rdi
callq 0x861b
callq 0x15682
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xca0b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x861b
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_cofactor
void
eval_cofactor(struct atom *p1)
{
	int i, j;
	struct atom *p2;

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

	push(caddr(p1));
	evalf();
	i = pop_integer();

	push(cadddr(p1));
	evalf();
	j = pop_integer();

	if (!issquarematrix(p2))
		stopf("cofactor: square matrix expected");

	if (i < 1 || i > p2->u.tensor->dim[0] || j < 0 || j > p2->u.tensor->dim[1])
		stopf("cofactor: index err");

	push(p2);

	minormatrix(i, j);

	det();

	if ((i + j) % 2)
		negate();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %r15
cmpb $0x1, 0x10(%rdi)
leaq 0x31184(%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 0x8fbb
callq 0x868d
cmpb $0x1, 0x10(%r14)
movq %r12, %rcx
cmoveq %r15, %rcx
movq %rax, %rbx
movq (%rcx), %rax
cmpb $0x1, 0x10(%rax)
jne 0xd8ae
movq 0x8(%rax), %rax
jmp 0xd8b5
movq 0x3113b(%rip), %rax     # 0x3e9f0
cmpb $0x1, 0x10(%rax)
movq %r12, %rcx
jne 0xd8c1
movq %rax, %rcx
movq (%rcx), %rdi
callq 0x861b
callq 0x8fbb
callq 0xd9d9
cmpb $0x1, 0x10(%r14)
cmoveq %r15, %r12
movl %eax, %r14d
movq (%r12), %rax
cmpb $0x1, 0x10(%rax)
jne 0xd8f9
movq 0x8(%rax), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0xd920
movq 0x8(%rcx), %rcx
jmp 0xd927
movq 0x310f0(%rip), %rcx     # 0x3e9f0
leaq 0x310e9(%rip), %rax     # 0x3e9f0
cmpb $0x1, 0x10(%rcx)
jne 0xd950
movq 0x8(%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0xd950
movq 0x310d2(%rip), %rax     # 0x3e9f0
jmp 0xd931
movq 0x310c9(%rip), %rcx     # 0x3e9f0
cmpb $0x1, 0x10(%rcx)
jne 0xd93d
movq 0x8(%rax), %rax
cmpb $0x1, 0x10(%rax)
jne 0xd946
addq $0x8, %rax
jmp 0xd94d
leaq 0x310ac(%rip), %rax     # 0x3e9f0
jmp 0xd950
leaq 0x310a3(%rip), %rax     # 0x3e9f0
movq (%rax), %rax
movq (%rax), %rdi
callq 0x861b
callq 0x8fbb
callq 0xd9d9
movl %eax, %r15d
movq %rbx, %rdi
callq 0xb291
testl %eax, %eax
je 0xd9cd
testl %r14d, %r14d
jle 0xd9c1
movq (%rbx), %rax
cmpl 0x4(%rax), %r14d
jg 0xd9c1
testl %r15d, %r15d
js 0xd9c1
cmpl 0x8(%rax), %r15d
jg 0xd9c1
movq %rbx, %rdi
callq 0x861b
movl %r14d, %edi
movl %r15d, %esi
callq 0xda2c
callq 0xb2b2
addl %r14d, %r15d
testb $0x1, %r15b
jne 0xd9b4
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x975f
leaq 0x158f5(%rip), %rdi     # 0x232bd
callq 0x7756
leaq 0x158c8(%rip), %rdi     # 0x2329c
callq 0x7756
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: pop_integer
int
pop_integer(void)
{
	int n;
	struct atom *p;

	p = pop();

	if (!issmallinteger(p))
		stopf("small integer expected");

	if (isrational(p)) {
		n = p->u.q.a[0];
		if (isnegativenumber(p))
			n = -n;
	} else
		n = (int) p->u.d;

	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
callq 0x868d
movq %rax, %rbx
movq %rax, %rdi
callq 0x126ab
testl %eax, %eax
je 0xda20
cmpb $0x4, 0x10(%rbx)
jne 0xda17
movq (%rbx), %rax
movl (%rax), %r14d
movq %rbx, %rdi
callq 0x8c2a
movl %eax, %ecx
movl %r14d, %eax
negl %eax
testl %ecx, %ecx
cmovel %r14d, %eax
jmp 0xda1b
cvttsd2si (%rbx), %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1a55e(%rip), %rdi     # 0x27f85
callq 0x7756
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: minormatrix
void
minormatrix(int row, int col)
{
	int i, j, k, m, n;
	struct atom *p1, *p2;

	p2 = symbol(NIL); // silence compiler

	p1 = pop();

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

	if (n == 2 && m == 2) {
		if (row == 1) {
			if (col == 1)
				push(p1->u.tensor->elem[3]);
			else
				push(p1->u.tensor->elem[2]);
		} else {
			if (col == 1)
				push(p1->u.tensor->elem[1]);
			else
				push(p1->u.tensor->elem[0]);
		}
		return;
	}

	if (n == 2)
		p2 = alloc_vector(m - 1);

	if (m == 2)
		p2 = alloc_vector(n - 1);

	if (n > 2 && m > 2)
		p2 = alloc_matrix(n - 1, m - 1);

	row--;
	col--;

	k = 0;

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

		if (i == row)
			continue;

		for (j = 0; j < m; j++) {

			if (j == col)
				continue;

			p2->u.tensor->elem[k++] = p1->u.tensor->elem[m * i + j];
		}
	}

	push(p2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %r14d
movq 0x30faa(%rip), %r12     # 0x3e9f0
callq 0x868d
movq %rax, %r15
movq (%rax), %rax
movl 0x4(%rax), %r13d
movl 0x8(%rax), %esi
movl %r13d, %ecx
xorl $0x2, %ecx
movl %esi, %edx
xorl $0x2, %edx
orl %ecx, %edx
jne 0xda99
xorl %ecx, %ecx
cmpl $0x1, %r14d
sete %cl
xorl %edx, %edx
cmpl $0x1, %ebx
sete %dl
shll $0x4, %ecx
leal (%rcx,%rdx,8), %ecx
movq 0x68(%rcx,%rax), %r12
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x861b
movq %r14, -0x30(%rbp)
cmpl $0x2, %r13d
jne 0xdab4
leal -0x1(%rsi), %edi
movq %rsi, %r14
callq 0x77b7
movq %r14, %rsi
movq %rax, %r12
movslq %esi, %r14
cmpl $0x2, %esi
jne 0xdaca
leal -0x1(%r13), %edi
movq %rsi, %r12
callq 0x77b7
jmp 0xdaed
cmpl $0x3, %r13d
setge %al
cmpl $0x3, %r14d
setge %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xdaf3
leal -0x1(%r13), %edi
movq %rsi, %r12
decl %esi
callq 0x782d
movq %r12, %rsi
movq %rax, %r12
movq -0x30(%rbp), %r11
decl %r11d
decl %ebx
xorl %eax, %eax
testl %esi, %esi
movl $0x0, %ecx
cmovgl %esi, %ecx
testl %r13d, %r13d
cmovlel %eax, %r13d
shlq $0x3, %r14
pushq $0x68
popq %rdx
xorl %esi, %esi
cmpq %r13, %rax
je 0xda83
cmpq %r11, %rax
jne 0xdb2e
incq %rax
addq %r14, %rdx
jmp 0xdb18
xorl %edi, %edi
cmpq %rdi, %rcx
je 0xdb26
cmpq %rdi, %rbx
je 0xdb52
movq (%r15), %r8
addq %rdx, %r8
movq (%r8,%rdi,8), %r8
movq (%r12), %r9
movslq %esi, %r10
incl %esi
movq %r8, 0x68(%r9,%r10,8)
incq %rdi
jmp 0xdb30
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: conjfunc_subst
void
conjfunc_subst(void)
{
	int h, i, n;
	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]);
			conjfunc_subst();
			p1->u.tensor->elem[i] = pop();
		}
		push(p1);
		return;
	}

	// (-1) ^ expr

	if (car(p1) == symbol(POWER) && isminusone(cadr(p1))) {
		push_symbol(POWER);
		push_integer(-1);
		push(caddr(p1));
		negate();
		list(3);
		return;
	}

	if (iscons(p1)) {
		h = tos;
		push(car(p1));
		p1 = cdr(p1);
		while (iscons(p1)) {
			push(car(p1));
			conjfunc_subst();
			p1 = cdr(p1);
		}
		list(tos - h);
		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, %r14
movq %rax, %rbx
movzbl 0x10(%rax), %r13d
cmpl $0x1, %r13d
je 0xdc02
cmpl $0x7, %r13d
jne 0xdbfb
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 0xdc4e
movq (%rbx), %rax
movq 0x68(%rax,%r15,8), %rdi
callq 0x861b
callq 0xdb8c
callq 0x868d
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r15,8)
incq %r15
jmp 0xdbd2
leaq 0x30dee(%rip), %rax     # 0x3e9f0
movq 0x33697(%rip), %r15     # 0x412a0
cmpq %r15, (%rax)
je 0xdc6f
cmpb $0x1, %r13b
jne 0xdc4e
movl 0x2a68d(%rip), %r14d    # 0x382a8
movq (%rbx), %rdi
callq 0x861b
leaq 0x30dc6(%rip), %r15     # 0x3e9f0
leaq 0x8(%rbx), %rax
cmpb $0x1, 0x10(%rbx)
cmovneq %r15, %rax
movq (%rax), %rbx
cmpb $0x1, 0x10(%rbx)
jne 0xdc64
movq (%rbx), %rdi
callq 0x861b
callq 0xdb8c
jmp 0xdc2a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x861b
movl 0x2a63e(%rip), %edi     # 0x382a8
subl %r14d, %edi
jmp 0xdce8
addq $0x8, %r14
cmpb $0x1, %r13b
leaq 0x30d72(%rip), %r12     # 0x3e9f0
movq %r12, %rax
cmoveq %r14, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0xbfac
testl %eax, %eax
je 0xdc0e
movq %r15, %rdi
callq 0x861b
pushq $-0x1
popq %rdi
callq 0xa426
cmpb $0x1, 0x10(%rbx)
cmovneq %r12, %r14
movq (%r14), %rax
cmpb $0x1, 0x10(%rax)
jne 0xdcc7
movq 0x8(%rax), %rax
jmp 0xdcce
movq 0x30d22(%rip), %rax     # 0x3e9f0
cmpb $0x1, 0x10(%rax)
jne 0xdcd7
movq %rax, %r12
movq (%r12), %rdi
callq 0x861b
callq 0x975f
pushq $0x3
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x85eb
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_contract
void
eval_contract(struct atom *p1)
{
	push(cadr(p1));
	evalf();

	p1 = cddr(p1);

	if (!iscons(p1)) {
		push_integer(1);
		push_integer(2);
		contract();
		return;
	}

	while (iscons(p1)) {
		push(car(p1));
		evalf();
		push(cadr(p1));
		evalf();
		contract();
		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 0x30cd9(%rip), %r14     # 0x3e9f0
movq %r14, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rax
movq (%rax), %rdi
callq 0x861b
callq 0x8fbb
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %r15
movq (%r15), %rax
leaq 0x8(%rax), %rcx
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rcx
movq (%rcx), %rbx
cmpb $0x1, 0x10(%rbx)
jne 0xddbf
movb $0x1, %al
cmpb $0x1, %al
jne 0xddb4
movq (%rbx), %rdi
callq 0x861b
callq 0x8fbb
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 0x861b
callq 0x8fbb
callq 0xddde
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %r15
movq (%r15), %rax
leaq 0x8(%rax), %rcx
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rcx
movq (%rcx), %rbx
movb 0x10(%rbx), %al
jmp 0xdd58
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rdi
callq 0xa426
pushq $0x2
popq %rdi
callq 0xa426
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xddde
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: cosfunc_sum
void
cosfunc_sum(struct atom *p1)
{
	struct atom *p2, *p3;
	p2 = cdr(p1);
	while (iscons(p2)) {
		push_integer(2);
		push(car(p2));
		multiply();
		push_symbol(PI);
		divide();
		p3 = pop();
		if (isinteger(p3)) {
			push(p1);
			push(car(p2));
			subtract();
			p3 = pop();
			push(p3);
			cosfunc();
			push(car(p2));
			cosfunc();
			multiply();
			push(p3);
			sinfunc();
			push(car(p2));
			sinfunc();
			multiply();
			subtract();
			return;
		}
		p2 = cdr(p2);
	}
	push_symbol(COS);
	push(p1);
	list(2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x304f2(%rip), %r15     # 0x3e9f0
pushq $0x2
popq %r14
movq %rdi, %r12
leaq 0x8(%r12), %rax
cmpb $0x1, 0x10(%r12)
cmovneq %r15, %rax
movq (%rax), %r12
cmpb $0x1, 0x10(%r12)
jne 0xe5f3
movl %r14d, %edi
callq 0xa426
cmpb $0x1, 0x10(%r12)
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rdi
callq 0x861b
callq 0x9fae
movq 0x30af4(%rip), %rdi     # 0x3f040
callq 0x861b
callq 0xca0b
callq 0x868d
movq %rax, %rdi
callq 0x8b5d
testl %eax, %eax
je 0xe505
movq %rbx, %rdi
callq 0x861b
cmpb $0x1, 0x10(%r12)
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rdi
callq 0x861b
callq 0xb07f
callq 0x868d
movq %rax, %rbx
movq %rax, %rdi
callq 0x861b
callq 0xe086
cmpb $0x1, 0x10(%r12)
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rdi
callq 0x861b
callq 0xe086
callq 0x9fae
movq %rbx, %rdi
callq 0x861b
callq 0xe75b
cmpb $0x1, 0x10(%r12)
cmoveq %r12, %r15
movq (%r15), %rdi
callq 0x861b
callq 0xe75b
callq 0x9fae
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xb07f
movq 0x2e1e6(%rip), %rdi     # 0x3c7e0
callq 0x861b
movq %rbx, %rdi
callq 0x861b
pushq $0x2
popq %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x85eb
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: modfunc
void
modfunc(void)
{
	int i, n;
	double d1, d2;
	struct atom *p1, *p2;

	p2 = pop();
	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]);
			push(p2);
			modfunc();
			p1->u.tensor->elem[i] = pop();
		}
		push(p1);
		return;
	}

	if (!isnum(p1) || !isnum(p2) || iszero(p2)) {
		push_symbol(MOD);
		push(p1);
		push(p2);
		list(3);
		return;
	}

	if (isrational(p1) && isrational(p2)) {
		mod_rationals(p1, p2);
		return;
	}

	push(p1);
	d1 = pop_double();

	push(p2);
	d2 = pop_double();

	push_double(fmod(d1, d2));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
callq 0x868d
movq %rax, %rbx
callq 0x868d
movq %rax, %r14
movb 0x10(%rax), %r15b
movzbl %r15b, %eax
leal -0x4(%rax), %ecx
cmpl $0x2, %ecx
jae 0xe68b
movb 0x10(%rbx), %r12b
movl %r12d, %eax
andb $-0x2, %al
cmpb $0x4, %al
jne 0xe6dd
movq %rbx, %rdi
callq 0xa641
testl %eax, %eax
jne 0xe6dd
xorb $0x4, %r15b
xorb $0x4, %r12b
movq %r14, %rdi
orb %r15b, %r12b
jne 0xe721
movq %rbx, %rsi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x15c33
cmpl $0x7, %eax
jne 0xe6dd
movq %r14, %rdi
callq 0x8f1b
movq %rax, %r14
movq (%rax), %rax
movl 0x64(%rax), %r15d
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
cmpq %r12, %r15
je 0xe70d
movq (%r14), %rax
movq 0x68(%rax,%r12,8), %rdi
callq 0x861b
movq %rbx, %rdi
callq 0x861b
callq 0xe617
callq 0x868d
movq (%r14), %rcx
movq %rax, 0x68(%rcx,%r12,8)
incq %r12
jmp 0xe6ac
movq 0x30004(%rip), %rdi     # 0x3e6e8
callq 0x861b
movq %r14, %rdi
callq 0x861b
movq %rbx, %rdi
callq 0x861b
pushq $0x3
popq %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x85eb
movq %r14, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x861b
callq 0x861b
callq 0x8ae1
movsd %xmm0, -0x28(%rbp)
movq %rbx, %rdi
callq 0x861b
callq 0x8ae1
movaps %xmm0, %xmm1
movsd -0x28(%rbp), %xmm0
callq 0x7160
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xaf59
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: coshfunc
void
coshfunc(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]);
			coshfunc();
			p1->u.tensor->elem[i] = pop();
		}
		push(p1);
		return;
	}

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

	// cosh(z) = 1/2 exp(z) + 1/2 exp(-z)

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

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

	// cosh(-x) = cosh(x)

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

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

	push_symbol(COSH);
	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 0xec59
cmpl $0x7, %r14d
je 0xec7a
movq %rbx, %rdi
callq 0xb876
testl %eax, %eax
jne 0xecc7
movq %rbx, %rdi
callq 0xa641
testl %eax, %eax
jne 0xed05
movq %rbx, %rdi
callq 0x9fd6
testl %eax, %eax
je 0xed17
movq %rbx, %rdi
callq 0x861b
callq 0x975f
jmp 0xec01
movq %rbx, %rdi
callq 0x861b
callq 0x8ae1
callq 0x7210
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xaf59
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 0xecbf
movq (%rbx), %rax
movq 0x68(%rax,%r15,8), %rdi
callq 0x861b
callq 0xebf7
callq 0x868d
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r15,8)
incq %r15
jmp 0xec96
movq %rbx, %rdi
jmp 0xed75
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 0xa1f6
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9fae
pushq $0x1
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa426
cmpb $0x1, %r14b
leaq 0x2fcce(%rip), %rax     # 0x3e9f0
movq %rax, %rcx
cmoveq %rbx, %rcx
movq (%rcx), %rcx
cmpq 0x2d43d(%rip), %rcx     # 0x3c170
je 0xed5b
movq 0x2daac(%rip), %rdi     # 0x3c7e8
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
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x861b
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_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
pushq %rax
movq %rdi, %r14
leaq 0x8(%rdi), %r15
cmpb $0x1, 0x10(%rdi)
leaq 0x2fc4c(%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 0x8fbb
callq 0x868d
movq %rax, %rbx
cmpb $0x1, 0x10(%r14)
cmovneq %r12, %r15
movq (%r15), %rax
leaq 0x8(%rax), %rcx
cmpb $0x1, 0x10(%rax)
cmovneq %r12, %rcx
movq (%rcx), %r13
cmpb $0x1, 0x10(%r13)
jne 0xef40
movq (%r13), %rdi
callq 0x861b
callq 0x8fbb
callq 0x868d
cmpb $0x1, 0x10(%r13)
leaq 0x8(%r13), %r15
movq %r12, %rcx
cmoveq %r15, %rcx
movq (%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
movq %rax, %r14
cmovneq %r12, %rcx
movq (%rcx), %rdi
callq 0x861b
callq 0x8fbb
callq 0x868d
cmpb $0x1, 0x10(%r13)
movq %r12, %rcx
cmoveq %r15, %rcx
movq %rax, -0x30(%rbp)
movq (%rcx), %rax
cmpb $0x1, 0x10(%rax)
jne 0xee53
movq 0x8(%rax), %rax
jmp 0xee5a
movq 0x2fb96(%rip), %rax     # 0x3e9f0
cmpb $0x1, 0x10(%rax)
movq %r12, %rcx
jne 0xee66
movq %rax, %rcx
movq (%rcx), %rdi
callq 0x861b
callq 0x8fbb
callq 0x868d
movq %rax, %r12
movq %rbx, %rdi
callq 0x861b
movq %r14, %rdi
callq 0x861b
callq 0xef62
callq 0x868d
movq %rax, %rbx
movq 0x2ebd9(%rip), %rsi     # 0x3da78
movq %rax, %rdi
callq 0x86d9
testl %eax, %eax
jne 0xef56
movq %rbx, %rdi
callq 0x861b
movq %r14, %rdi
callq 0x861b
movq %r12, %rdi
callq 0x861b
callq 0x8de5
callq 0x8fbb
movq %rbx, %rdi
callq 0x861b
movq %r14, %rdi
callq 0x861b
movq -0x30(%rbp), %rdi
callq 0x861b
callq 0x8de5
callq 0x8fbb
callq 0xb07f
callq 0x868d
cmpb $0x1, 0x10(%r13)
leaq 0x2fae6(%rip), %r12     # 0x3e9f0
cmovneq %r12, %r15
movq %rax, %rbx
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
jne 0xef20
movq 0x8(%rax), %rax
jmp 0xef27
movq 0x2fac9(%rip), %rax     # 0x3e9f0
cmpb $0x1, 0x10(%rax)
movq %r12, %rcx
jne 0xede3
addq $0x8, %rax
movq %rax, %rcx
jmp 0xede3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x861b
leaq 0x143ae(%rip), %rdi     # 0x2330b
callq 0x7756
// File: /workspace/github_c_makefile_star2_O2/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 0x868d
movq %rax, %rbx
callq 0x868d
cmpb $0x3, 0x10(%rbx)
jne 0xf046
movq %rax, %r14
cmpb $0x1, 0x10(%rax)
leaq 0x2fa5e(%rip), %r15     # 0x3e9f0
movq %rax, %rcx
cmovneq %r15, %rcx
sete %al
movq (%rcx), %rcx
cmpq 0x322ea(%rip), %rcx     # 0x41290
je 0xefc4
cmpq 0x322e9(%rip), %rcx     # 0x41298
je 0xf014
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x143d6
movl 0x292dd(%rip), %r12d    # 0x382a8
addq $0x8, %r14
testb $0x1, %al
cmoveq %r15, %r14
movq (%r14), %r14
cmpb $0x1, 0x10(%r14)
jne 0xeffe
movq (%r14), %rdi
callq 0x861b
movq %rbx, %rdi
callq 0x861b
callq 0xef62
cmpb $0x1, 0x10(%r14)
sete %al
jmp 0xefcb
movl 0x292a4(%rip), %edi     # 0x382a8
subl %r12d, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa0fd
movq %r14, %rdi
callq 0x861b
movq %rbx, %rdi
callq 0x861b
callq 0x14284
callq 0x868d
movq %rax, %rdi
movq %rbx, %rsi
callq 0x143d6
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9fae
leaq 0x18834(%rip), %rdi     # 0x27881
callq 0x7756