LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: decomp_product
void
decomp_product(struct atom *F, struct atom *X)
{
	int h, n;
	struct atom *p1;

	// decomp factors involving x

	p1 = cdr(F);
	while (iscons(p1)) {
		if (dependent(car(p1), X)) {
			push(car(p1));
			push(X);
			decomp();
		}
		p1 = cdr(p1);
	}

	// combine constant factors

	h = tos;
	p1 = cdr(F);
	while (iscons(p1)) {
		if (!dependent(car(p1), X))
			push(car(p1));
		p1 = cdr(p1);
	}

	n = tos - h;

	if (n > 1) {
		list(n);
		push_symbol(MULTIPLY);
		swap();
		cons(); // makes MULTIPLY head of list
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movb 0x10(%rdi), %al
leaq 0x8(%rdi), %r12
cmpb $0x1, %al
leaq 0x2d005(%rip), %r15     # 0x45a00
movq %r15, %rcx
cmoveq %r12, %rcx
movq %rsi, %rbx
movq (%rcx), %r13
cmpb $0x1, 0x10(%r13)
jne 0x18a69
movq %rdi, -0x30(%rbp)
leaq 0x10(%r13), %r14
movq (%r13), %rdi
movq %rbx, %rsi
callq 0x18607
testl %eax, %eax
je 0x18a47
cmpb $0x1, (%r14)
movq %r15, %rax
cmoveq %r13, %rax
movq (%rax), %rdi
callq 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
callq 0x1817d
addq $0x8, %r13
cmpb $0x1, (%r14)
cmovneq %r15, %r13
movq (%r13), %r13
leaq 0x10(%r13), %r14
cmpb $0x1, 0x10(%r13)
je 0x18a17
movq -0x30(%rbp), %rax
movb 0x10(%rax), %al
movl 0x26848(%rip), %r14d    # 0x3f2b8
cmpb $0x1, %al
cmovneq %r15, %r12
movq (%r12), %r12
cmpb $0x1, 0x10(%r12)
movl %r14d, %edi
jne 0x18ad2
leaq 0x10(%r12), %r13
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x18607
testl %eax, %eax
jne 0x18aae
cmpb $0x1, (%r13)
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rdi
callq 0x8ba5
addq $0x8, %r12
cmpb $0x1, (%r13)
cmovneq %r15, %r12
movq (%r12), %r12
leaq 0x10(%r12), %r13
cmpb $0x1, 0x10(%r12)
je 0x18a8a
movl 0x267e6(%rip), %edi     # 0x3f2b8
subl %r14d, %edi
cmpl $0x2, %edi
jl 0x18b03
callq 0x8b7d
movq 0x2f7c2(%rip), %rdi     # 0x482a8
callq 0x8ba5
callq 0xb238
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8be6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: inv
void
inv(void)
{
	struct atom *p1;

	p1 = pop();

	if (!istensor(p1)) {
		push(p1);
		reciprocate();
		return;
	}

	if (!issquarematrix(p1))
		stopf("inv: square matrix expected");

	push(p1);
	adj();

	push(p1);
	det();

	divide();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0x26765(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x18bcc
decl %eax
movl %eax, 0x26751(%rip)     # 0x3f2b8
leaq 0x2fa52(%rip), %rcx     # 0x485c0
movq (%rcx,%rax,8), %rbx
cmpb $0x7, 0x10(%rbx)
jne 0x18bad
movq (%rbx), %rax
cmpl $0x2, (%rax)
jne 0x18bd8
movl 0x4(%rax), %ecx
cmpl 0x8(%rax), %ecx
jne 0x18bd8
movq %rbx, %rdi
callq 0x8ba5
callq 0xc00e
movq %rbx, %rdi
callq 0x8ba5
callq 0xc2c8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe218
movq %rbx, %rdi
callq 0x8ba5
movq 0xfd834(%rip), %rdi     # 0x1163f0
callq 0x8ba5
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa573
leaq 0x1636e(%rip), %rdi     # 0x2ef41
callq 0x780b
leaq 0x15c84(%rip), %rdi     # 0x2e863
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_kronecker
void
eval_kronecker(struct atom *p1)
{
	push(cadr(p1));
	evalf();
	p1 = cddr(p1);
	while (iscons(p1)) {
		push(car(p1));
		evalf();
		kronecker();
		p1 = cdr(p1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
cmpb $0x1, 0x10(%rdi)
leaq 0x2ce00(%rip), %r14     # 0x45a00
movq %r14, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rax
movq (%rax), %rdi
callq 0x8ba5
callq 0x96e2
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %r15
movq (%r15), %rax
leaq 0x8(%rax), %rcx
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rcx
movq (%rcx), %rbx
cmpb $0x1, 0x10(%rbx)
jne 0x18c62
movq (%rbx), %rdi
callq 0x8ba5
callq 0x96e2
callq 0x18c6d
leaq 0x8(%rbx), %rax
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %rax
movq (%rax), %rbx
jmp 0x18c39
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: lgammafunc
void
lgammafunc(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]);
			lgammafunc();
			p1->u.tensor->elem[i] = pop();
		}
		push(p1);
		return;
	}

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x26362(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x19081
decl %eax
movl %eax, 0x2634a(%rip)     # 0x3f2b8
leaq 0x2f64b(%rip), %r14     # 0x485c0
movq (%r14,%rax,8), %rbx
cmpb $0x7, 0x10(%rbx)
jne 0x18fe5
movq %rbx, %rdi
callq 0x9638
movq %rax, %rbx
movq (%rax), %rax
movslq 0x64(%rax), %r15
testq %r15, %r15
jle 0x18fe0
xorl %r12d, %r12d
movl $0xfffe795f, %r13d      # imm = 0xFFFE795F
movq (%rbx), %rax
movq 0x68(%rax,%r12,8), %rdi
callq 0x8ba5
callq 0x18f42
movl 0x26301(%rip), %eax     # 0x3f2b8
leal (%rax,%r13), %ecx
cmpl %r13d, %ecx
jbe 0x19081
decl %eax
movl %eax, 0x262ec(%rip)     # 0x3f2b8
movq (%r14,%rax,8), %rax
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x18f9f
movq %rbx, %rdi
jmp 0x19042
movq %rbx, %rdi
callq 0x8ba5
callq 0xac30
movl 0x262c0(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x19081
decl %eax
movl %eax, 0x262ac(%rip)     # 0x3f2b8
movq (%r14,%rax,8), %rdi
movb 0x10(%rdi), %al
andb $-0x2, %al
cmpb $0x4, %al
jne 0x19055
callq 0x8ba5
callq 0x9128
callq 0x7200
movsd %xmm0, -0x30(%rbp)
callq 0x74dc
movb $0x5, 0x10(%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8ba5
movq 0x2c36c(%rip), %rdi     # 0x453c8
callq 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8b7d
leaq 0x15eb9(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_loop
void
eval_loop(struct atom *p1)
{
	int t;
	struct atom *p2;
	t = breakflag;
	breakflag = 0;
	if (lengthf(p1) < 2) {
		push_symbol(NIL);
		return;
	}
	for (;;) {
		p2 = cdr(p1);
		while (iscons(p2)) {
			push(car(p2));
			evalg();
			pop();
			p2 = cdr(p2);
			if (breakflag || errorflag) {
				breakflag = t;
				push_symbol(NIL);
				return;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0xf27ea(%rip), %edx     # 0x10bae8
movl $0x0, 0xf27e0(%rip)     # 0x10bae8
cmpb $0x1, 0x10(%rdi)
jne 0x193ab
movq %rdi, %rbx
movl $0x1, %eax
movq %rdi, %rcx
movq 0x8(%rcx), %rcx
decl %eax
cmpb $0x1, 0x10(%rcx)
je 0x1931d
testl %eax, %eax
je 0x193ab
movl %edx, -0x2c(%rbp)
leaq 0x8(%rbx), %rcx
movb $0x1, %al
leaq 0x2c6c3(%rip), %r12     # 0x45a00
movl $0xfffe795f, %r13d      # imm = 0xFFFE795F
cmpb $0x1, %al
movq %r12, %rax
movq %rcx, %r14
cmoveq %rcx, %rax
movq (%rax), %r15
cmpb $0x1, 0x10(%r15)
jne 0x1939a
movq (%r15), %rdi
callq 0x8ba5
callq 0x96a4
movl 0x25f4c(%rip), %eax     # 0x3f2b8
leal (%rax,%r13), %ecx
cmpl %r13d, %ecx
jbe 0x193c5
decl %eax
movl %eax, 0x25f3b(%rip)     # 0x3f2b8
leaq 0x8(%r15), %rax
cmpb $0x1, 0x10(%r15)
cmovneq %r12, %rax
movl 0xfd030(%rip), %ecx     # 0x1163c0
orl 0xf2752(%rip), %ecx     # 0x10bae8
je 0x1934f
jmp 0x193a2
movb 0x10(%rbx), %al
movq %r14, %rcx
jmp 0x19343
movl -0x2c(%rbp), %eax
movl %eax, 0xf273d(%rip)     # 0x10bae8
movq 0x2c64e(%rip), %rdi     # 0x45a00
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8ba5
leaq 0x15b75(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_minor
void
eval_minor(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 (!istensor(p2) || p2->u.tensor->ndim != 2 || p2->u.tensor->dim[0] != p2->u.tensor->dim[1])
		stopf("minor");

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

	push(p2);

	minormatrix(i, j);

	det();
}

// 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 0x2c2dc(%rip), %r12     # 0x45a00
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x8ba5
callq 0x96e2
movl 0x25b6f(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x19894
decl %eax
movl %eax, 0x25b57(%rip)     # 0x3f2b8
cmpb $0x1, 0x10(%r14)
movq %r12, %rdx
cmoveq %r15, %rdx
leaq 0x2ee4c(%rip), %rcx     # 0x485c0
movq (%rdx), %rdx
cmpb $0x1, 0x10(%rdx)
jne 0x19783
movq 0x8(%rdx), %rdx
jmp 0x1978a
movq 0x2c276(%rip), %rdx     # 0x45a00
cmpb $0x1, 0x10(%rdx)
movq %r12, %rsi
jne 0x19796
movq %rdx, %rsi
movq (%rcx,%rax,8), %rbx
movq (%rsi), %rdi
callq 0x8ba5
callq 0x96e2
callq 0xf8e6
cmpb $0x1, 0x10(%r14)
cmoveq %r15, %r12
movl %eax, %r14d
movq (%r12), %rax
cmpb $0x1, 0x10(%rax)
jne 0x197d2
movq 0x8(%rax), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0x197f9
movq 0x8(%rcx), %rcx
jmp 0x19800
movq 0x2c227(%rip), %rcx     # 0x45a00
leaq 0x2c220(%rip), %rax     # 0x45a00
cmpb $0x1, 0x10(%rcx)
jne 0x19829
movq 0x8(%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0x19829
movq 0x2c209(%rip), %rax     # 0x45a00
jmp 0x1980a
movq 0x2c200(%rip), %rcx     # 0x45a00
cmpb $0x1, 0x10(%rcx)
jne 0x19816
movq 0x8(%rax), %rax
cmpb $0x1, 0x10(%rax)
jne 0x1981f
addq $0x8, %rax
jmp 0x19826
leaq 0x2c1e3(%rip), %rax     # 0x45a00
jmp 0x19829
leaq 0x2c1da(%rip), %rax     # 0x45a00
movq (%rax), %rax
movq (%rax), %rdi
callq 0x8ba5
callq 0x96e2
callq 0xf8e6
cmpb $0x7, 0x10(%rbx)
jne 0x19888
movq (%rbx), %rcx
cmpl $0x2, (%rcx)
jne 0x19888
movl %eax, %r15d
movl 0x4(%rcx), %eax
cmpl 0x8(%rcx), %eax
jne 0x19888
testl %r14d, %r14d
jle 0x19888
cmpl %eax, %r14d
jg 0x19888
testl %r15d, %r15d
js 0x19888
cmpl %eax, %r15d
ja 0x19888
movq %rbx, %rdi
callq 0x8ba5
movl %r14d, %edi
movl %r15d, %esi
callq 0xf958
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc2c8
leaq 0x14ffa(%rip), %rdi     # 0x2e889
callq 0x780b
leaq 0x156a6(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_minormatrix
void
eval_minormatrix(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 (!istensor(p2) || p2->u.tensor->ndim != 2)
		stopf("minormatrix: matrix expected");

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

	push(p2);

	minormatrix(i, j);
}

// 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 0x2c143(%rip), %r12     # 0x45a00
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x8ba5
callq 0x96e2
movl 0x259d6(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x19a2e
decl %eax
movl %eax, 0x259be(%rip)     # 0x3f2b8
cmpb $0x1, 0x10(%r14)
movq %r12, %rdx
cmoveq %r15, %rdx
leaq 0x2ecb3(%rip), %rcx     # 0x485c0
movq (%rdx), %rdx
cmpb $0x1, 0x10(%rdx)
jne 0x1991c
movq 0x8(%rdx), %rdx
jmp 0x19923
movq 0x2c0dd(%rip), %rdx     # 0x45a00
cmpb $0x1, 0x10(%rdx)
movq %r12, %rsi
jne 0x1992f
movq %rdx, %rsi
movq (%rcx,%rax,8), %rbx
movq (%rsi), %rdi
callq 0x8ba5
callq 0x96e2
callq 0xf8e6
cmpb $0x1, 0x10(%r14)
cmoveq %r15, %r12
movl %eax, %r14d
movq (%r12), %rax
cmpb $0x1, 0x10(%rax)
jne 0x1996b
movq 0x8(%rax), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0x19992
movq 0x8(%rcx), %rcx
jmp 0x19999
movq 0x2c08e(%rip), %rcx     # 0x45a00
leaq 0x2c087(%rip), %rax     # 0x45a00
cmpb $0x1, 0x10(%rcx)
jne 0x199c2
movq 0x8(%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0x199c2
movq 0x2c070(%rip), %rax     # 0x45a00
jmp 0x199a3
movq 0x2c067(%rip), %rcx     # 0x45a00
cmpb $0x1, 0x10(%rcx)
jne 0x199af
movq 0x8(%rax), %rax
cmpb $0x1, 0x10(%rax)
jne 0x199b8
addq $0x8, %rax
jmp 0x199bf
leaq 0x2c04a(%rip), %rax     # 0x45a00
jmp 0x199c2
leaq 0x2c041(%rip), %rax     # 0x45a00
movq (%rax), %rax
movq (%rax), %rdi
callq 0x8ba5
callq 0x96e2
callq 0xf8e6
cmpb $0x7, 0x10(%rbx)
jne 0x19a22
movl %eax, %r15d
movq (%rbx), %rax
cmpl $0x2, (%rax)
jne 0x19a22
testl %r14d, %r14d
jle 0x19a16
cmpl 0x4(%rax), %r14d
jg 0x19a16
testl %r15d, %r15d
js 0x19a16
cmpl 0x8(%rax), %r15d
jg 0x19a16
movq %rbx, %rdi
callq 0x8ba5
movl %r14d, %edi
movl %r15d, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xf958
leaq 0x14e8f(%rip), %rdi     # 0x2e8ac
callq 0x780b
leaq 0x14e66(%rip), %rdi     # 0x2e88f
callq 0x780b
leaq 0x1550c(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_mod
void
eval_mod(struct atom *p1)
{
	push(cadr(p1));
	evalf();
	push(caddr(p1));
	evalf();
	modfunc();
}

// 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 0x2bfaa(%rip), %r14     # 0x45a00
movq %r14, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rax
movq (%rax), %rdi
callq 0x8ba5
callq 0x96e2
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
jne 0x19a8c
movq 0x8(%rax), %rax
jmp 0x19a93
movq 0x2bf6d(%rip), %rax     # 0x45a00
cmpb $0x1, 0x10(%rax)
jne 0x19a9c
movq %rax, %r14
movq (%r14), %rdi
callq 0x8ba5
callq 0x96e2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x108ee
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: mod_rationals
void
mod_rationals(struct atom *p1, struct atom *p2)
{
	if (isinteger(p1) && isinteger(p2)) {
		mod_integers(p1, p2);
		return;
	}
	push(p1);
	push(p1);
	push(p2);
	divide();
	absfunc();
	floorfunc();
	push(p2);
	multiply();
	if (p1->sign == p2->sign)
		negate();
	add();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x4, 0x10(%rdi)
jne 0x19afe
movq 0x8(%r14), %rax
cmpl $0x1, -0x4(%rax)
jne 0x19afe
cmpl $0x1, (%rax)
jne 0x19afe
cmpb $0x4, 0x10(%rbx)
jne 0x19afe
movq 0x8(%rbx), %rax
cmpl $0x1, -0x4(%rax)
jne 0x19afe
cmpl $0x1, (%rax)
jne 0x19afe
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x19b7a
movq %r14, %rdi
callq 0x8ba5
movq %r14, %rdi
callq 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
movq 0xfc8d3(%rip), %rdi     # 0x1163f0
callq 0x8ba5
callq 0xa573
movl $0x2, %edi
callq 0xacef
callq 0x9e31
callq 0x15584
movq %rbx, %rdi
callq 0x8ba5
movl $0x2, %edi
callq 0xacef
movb 0x12(%r14), %al
cmpb 0x12(%rbx), %al
jne 0x19b6c
movq 0xfc893(%rip), %rdi     # 0x1163f0
callq 0x8ba5
movl $0x2, %edi
callq 0xacef
movl $0x2, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0xadb3
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_multiply
void
eval_multiply(struct atom *p1)
{
	int h = tos;
	expanding--; // undo expanding++ in evalf
	p1 = cdr(p1);
	while (iscons(p1)) {
		push(car(p1));
		evalg();
		p1 = cdr(p1);
	}
	multiply_factors(tos - h);
	expanding++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
decl 0xf1f11(%rip)           # 0x10bad0
movl 0x256f3(%rip), %ebx     # 0x3f2b8
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rax
leaq 0x2be2c(%rip), %r14     # 0x45a00
cmovneq %r14, %rax
movq (%rax), %r15
cmpb $0x1, 0x10(%r15)
movl %ebx, %edi
jne 0x19c0e
movq (%r15), %rdi
callq 0x8ba5
callq 0x96a4
leaq 0x8(%r15), %rax
cmpb $0x1, 0x10(%r15)
cmovneq %r14, %rax
movq (%rax), %r15
cmpb $0x1, 0x10(%r15)
je 0x19be4
movl 0x256aa(%rip), %edi     # 0x3f2b8
subl %ebx, %edi
callq 0xacef
incl 0xf1eb5(%rip)           # 0x10bad0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: flatten_factors
void
flatten_factors(int h)
{
	int i, n;
	struct atom *p1;
	n = tos;
	for (i = h; i < n; i++) {
		p1 = stack[i];
		if (car(p1) == symbol(MULTIPLY)) {
			stack[i] = cadr(p1);
			p1 = cddr(p1);
			while (iscons(p1)) {
				push(car(p1));
				p1 = cdr(p1);
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x2567e(%rip), %ebx     # 0x3f2b8
cmpl %edi, %ebx
jle 0x19cc9
movslq %edi, %r14
leaq 0x2e974(%rip), %r15     # 0x485c0
leaq 0x2bdad(%rip), %r12     # 0x45a00
movq (%r15,%r14,8), %rax
movb 0x10(%rax), %cl
cmpb $0x1, %cl
movq %r12, %rdx
cmoveq %rax, %rdx
movq (%rdx), %rdx
cmpq 0x2e63a(%rip), %rdx     # 0x482a8
jne 0x19cc1
addq $0x8, %rax
cmpb $0x1, %cl
cmovneq %r12, %rax
movq (%rax), %rcx
cmpb $0x1, 0x10(%rcx)
cmovneq %r12, %rcx
movq (%rcx), %rcx
movq %rcx, (%r15,%r14,8)
movq (%rax), %rax
leaq 0x8(%rax), %rcx
cmpb $0x1, 0x10(%rax)
cmovneq %r12, %rcx
movq (%rcx), %r13
jmp 0x19cba
movq (%r13), %rdi
callq 0x8ba5
leaq 0x8(%r13), %rax
cmpb $0x1, 0x10(%r13)
cmovneq %r12, %rax
movq (%rax), %r13
cmpb $0x1, 0x10(%r13)
je 0x19ca1
incq %r14
cmpl %r14d, %ebx
jne 0x19c53
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: multiply_tensor_factors
struct atom *
multiply_tensor_factors(int h)
{
	int i;
	struct atom *p1, *T;
	T = symbol(NIL);
	for (i = h; i < tos; i++) {
		p1 = stack[i];
		if (!istensor(p1))
			continue;
		if (istensor(T)) {
			push(T);
			push(p1);
			hadamard();
			T = pop();
		} else
			T = p1;
		slice(i, 1); // remove factor
		i--; // use same index again
	}
	return T;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %ebx
movq 0x2bd14(%rip), %rdi     # 0x45a00
movl 0x255c6(%rip), %eax     # 0x3f2b8
cmpl %ebx, %eax
jle 0x19d61
leaq 0x2e8c3(%rip), %r15     # 0x485c0
movl $0xfffe795f, %r12d      # imm = 0xFFFE795F
movslq %ebx, %rcx
movq (%r15,%rcx,8), %r14
cmpb $0x7, 0x10(%r14)
jne 0x19d5b
cmpb $0x7, 0x10(%rdi)
jne 0x19d44
callq 0x8ba5
movq %r14, %rdi
callq 0x8ba5
callq 0x15bfd
movl 0x25589(%rip), %eax     # 0x3f2b8
leal (%rax,%r12), %ecx
cmpl %r12d, %ecx
jbe 0x19d6d
decl %eax
movl %eax, 0x25578(%rip)     # 0x3f2b8
movq (%r15,%rax,8), %r14
movl %ebx, %edi
movl $0x1, %esi
callq 0xb39c
decl %ebx
movl 0x25560(%rip), %eax     # 0x3f2b8
movq %r14, %rdi
incl %ebx
cmpl %eax, %ebx
jl 0x19d03
movq %rdi, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x151cd(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: multiply_scalar_factors
void
multiply_scalar_factors(int h)
{
	int n;
	struct atom *COEF;

	COEF = combine_numerical_factors(h, one);

	if (iszero(COEF) || h == tos) {
		tos = h; // pop all
		push(COEF);
		return;
	}

	combine_factors(h);
	normalize_power_factors(h);

	// do again in case exp(1/2 i pi) changed to i

	combine_factors(h);
	normalize_power_factors(h);

	COEF = combine_numerical_factors(h, COEF);

	if (iszero(COEF) || h == tos) {
		tos = h; // pop all
		push(COEF);
		return;
	}

	COEF = reduce_radical_factors(h, COEF);

	if (isdouble(COEF) || !isplusone(COEF))
		push(COEF);

	if (expanding)
		expand_sum_factors(h); // success leaves one expr on stack

	n = tos - h;

	switch (n) {
	case 0:
		push_integer(1); // all factors canceled
		break;
	case 1:
		break;
	default:
		sort_factors(n); // previously sorted provisionally
		list(n);
		push_symbol(MULTIPLY);
		swap();
		cons(); // prepend MULTIPLY to list
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
movq 0xf1d4f(%rip), %rsi     # 0x10bad8
callq 0x19eaf
movq %rax, %r14
movq %rax, %rdi
callq 0xb477
testl %eax, %eax
jne 0x19e4d
cmpl %ebx, 0x25511(%rip)     # 0x3f2b8
je 0x19e4d
movl %ebx, %edi
callq 0x19f3d
movl %ebx, %edi
callq 0x19fb1
movl %ebx, %edi
callq 0x19f3d
movl %ebx, %edi
callq 0x19fb1
movl %ebx, %edi
movq %r14, %rsi
callq 0x19eaf
movq %rax, %r14
movq %rax, %rdi
callq 0xb477
testl %eax, %eax
jne 0x19e4d
cmpl %ebx, 0x254d0(%rip)     # 0x3f2b8
je 0x19e4d
movl %ebx, %edi
movq %r14, %rsi
callq 0x1a11c
movq %rax, %r14
cmpb $0x5, 0x10(%rax)
je 0x19e13
movq %r14, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0xd1c4
testl %eax, %eax
jne 0x19e1b
movq %r14, %rdi
callq 0x8ba5
cmpl $0x0, 0xf1cae(%rip)     # 0x10bad0
je 0x19e2b
movl %ebx, %edi
callq 0x1a15e
movslq 0x25486(%rip), %rax     # 0x3f2b8
movslq %ebx, %rcx
movq %rax, %rbx
subq %rcx, %rbx
cmpl $0x1, %ebx
je 0x19e5f
testl %ebx, %ebx
jne 0x19e64
movq 0xf1c8d(%rip), %rdi     # 0x10bad8
jmp 0x19e56
movl %ebx, 0x25465(%rip)     # 0x3f2b8
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x8ba5
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2e755(%rip), %rcx     # 0x485c0
leaq (%rcx,%rax,8), %rdi
leaq (,%rbx,8), %rax
subq %rax, %rdi
leaq 0x744(%rip), %rcx       # 0x1a5c5
movl $0x8, %edx
movq %rbx, %rsi
callq 0x70a0
movl %ebx, %edi
callq 0x8b7d
movq 0x2e40c(%rip), %rdi     # 0x482a8
callq 0x8ba5
callq 0xb238
popq %rbx
popq %r14
popq %rbp
jmp 0x8be6
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: combine_numerical_factors
struct atom *
combine_numerical_factors(int h, struct atom *COEF)
{
	int i;
	struct atom *p1;
	for (i = h; i < tos; i++) {
		p1 = stack[i];
		if (isnum(p1)) {
			multiply_numbers(COEF, p1);
			COEF = pop();
			slice(i, 1); // remove factor
			i--; // use same index again
		}
	}
	return COEF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movl 0x253f5(%rip), %eax     # 0x3f2b8
cmpl %edi, %eax
jle 0x19f25
movl %edi, %ebx
leaq 0x2e6f0(%rip), %r15     # 0x485c0
movl $0xfffe795f, %r12d      # imm = 0xFFFE795F
movslq %ebx, %rcx
movq (%r15,%rcx,8), %rsi
movb 0x10(%rsi), %cl
andb $-0x2, %cl
cmpb $0x4, %cl
jne 0x19f1f
movq %r14, %rdi
callq 0x1a322
movl 0x253c2(%rip), %eax     # 0x3f2b8
leal (%rax,%r12), %ecx
cmpl %r12d, %ecx
jbe 0x19f31
decl %eax
movl %eax, 0x253b1(%rip)     # 0x3f2b8
movq (%r15,%rax,8), %r14
movl %ebx, %edi
movl $0x1, %esi
callq 0xb39c
decl %ebx
movl 0x25399(%rip), %eax     # 0x3f2b8
incl %ebx
cmpl %eax, %ebx
jl 0x19ed6
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x15009(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: combine_factors
void
combine_factors(int h)
{
	int i;
	sort_factors_provisional(h);
	for (i = h; i < tos - 1; i++) {
		if (combine_factors_nib(i, i + 1)) {
			slice(i + 1, 1); // remove factor
			i--; // use same index again
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
movslq %edi, %r14
leaq 0x2e670(%rip), %rax     # 0x485c0
leaq (%rax,%r14,8), %rdi
movslq 0x2535d(%rip), %rsi     # 0x3f2b8
subq %r14, %rsi
leaq 0x5e2(%rip), %rcx       # 0x1a547
movl $0x8, %edx
callq 0x70a0
movl 0x25343(%rip), %eax     # 0x3f2b8
decl %eax
cmpl %r14d, %eax
jle 0x19fac
leal 0x1(%rbx), %r14d
movl %ebx, %edi
movl %r14d, %esi
callq 0x1a3b9
testl %eax, %eax
je 0x19f9d
movl %r14d, %edi
movl $0x1, %esi
callq 0xb39c
jmp 0x19fa0
movl %r14d, %ebx
movl 0x25312(%rip), %eax     # 0x3f2b8
decl %eax
cmpl %eax, %ebx
jl 0x19f7c
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: normalize_power_factors
void
normalize_power_factors(int h)
{
	int i, k;
	struct atom *p1;
	k = tos;
	for (i = h; i < k; i++) {
		p1 = stack[i];
		if (car(p1) == symbol(POWER)) {
			push(cadr(p1));
			push(caddr(p1));
			power();
			p1 = pop();
			if (car(p1) == symbol(MULTIPLY)) {
				stack[i] = cadr(p1);
				p1 = cddr(p1);
				while (iscons(p1)) {
					push(car(p1));
					p1 = cdr(p1);
				}
			} else
				stack[i] = p1;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x252f3(%rip), %ebx     # 0x3f2b8
cmpl %edi, %ebx
jle 0x1a101
movslq %edi, %r14
leaq 0x2e5e9(%rip), %r15     # 0x485c0
leaq 0x2ba22(%rip), %r12     # 0x45a00
movl %ebx, -0x2c(%rbp)
movq (%r15,%r14,8), %r13
movb 0x10(%r13), %al
cmpb $0x1, %al
movq %r12, %rcx
cmoveq %r13, %rcx
movq (%rcx), %rcx
cmpq 0x2e2b4(%rip), %rcx     # 0x482b0
jne 0x1a0a2
movq %r15, %rbx
leaq 0x8(%r13), %r15
cmpb $0x1, %al
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x8ba5
cmpb $0x1, 0x10(%r13)
cmovneq %r12, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
jne 0x1a03d
movq 0x8(%rax), %rax
jmp 0x1a044
movq 0x2b9bc(%rip), %rax     # 0x45a00
cmpb $0x1, 0x10(%rax)
movq %r12, %rcx
jne 0x1a050
movq %rax, %rcx
movq (%rcx), %rdi
callq 0x8ba5
callq 0xa573
movl 0x25255(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %edx       # imm = 0xFFFE795F
leal (%rax,%rdx), %ecx
cmpl %edx, %ecx
jbe 0x1a110
movq %rbx, %r15
decl %eax
movl %eax, 0x2523a(%rip)     # 0x3f2b8
movq (%rbx,%rax,8), %rax
movb 0x10(%rax), %cl
cmpb $0x1, %cl
movq %r12, %rdx
cmoveq %rax, %rdx
movq (%rdx), %rdx
cmpq 0x2e20f(%rip), %rdx     # 0x482a8
movl -0x2c(%rbp), %ebx
je 0x1a0b0
movq %rax, (%r15,%r14,8)
incq %r14
cmpl %r14d, %ebx
jne 0x19fe1
jmp 0x1a101
addq $0x8, %rax
cmpb $0x1, %cl
cmovneq %r12, %rax
movq (%rax), %rcx
cmpb $0x1, 0x10(%rcx)
cmovneq %r12, %rcx
movq (%rcx), %rcx
movq %rcx, (%r15,%r14,8)
movq (%rax), %rax
leaq 0x8(%rax), %rcx
cmpb $0x1, 0x10(%rax)
cmovneq %r12, %rcx
movq (%rcx), %r13
cmpb $0x1, 0x10(%r13)
jne 0x1a0a2
movq (%r13), %rdi
callq 0x8ba5
leaq 0x8(%r13), %rax
cmpb $0x1, 0x10(%r13)
cmovneq %r12, %rax
movq (%rax), %r13
jmp 0x1a0df
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x14e2a(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: reduce_radical_factors
struct atom *
reduce_radical_factors(int h, struct atom *COEF)
{
	if (!any_radical_factors(h))
		return COEF;

	if (isrational(COEF))
		return reduce_radical_rational(h, COEF);
	else
		return reduce_radical_double(h, COEF);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %r14d
callq 0x1a81a
testl %eax, %eax
je 0x1a147
cmpb $0x4, 0x10(%rbx)
jne 0x1a14f
movl %r14d, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x1a86b
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movl %r14d, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x1acd5
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: expand_sum_factors
void
expand_sum_factors(int h)
{
	int i, n;
	struct atom *p1, *p2;

	if (tos - h < 2)
		return;

	// search for a sum factor

	for (i = h; i < tos; i++) {
		p2 = stack[i];
		if (car(p2) == symbol(ADD))
			break;
	}

	if (i == tos)
		return; // no sum factors

	// remove the sum factor

	slice(i, 1);

	n = tos - h;

	if (n > 1) {
		sort_factors(n);
		list(n);
		push_symbol(MULTIPLY);
		swap();
		cons(); // prepend MULTIPLY to list
	}

	p1 = pop(); // p1 is the multiplier

	p2 = cdr(p2); // p2 is the sum

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

	add_terms(tos - h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq 0x25145(%rip), %rax     # 0x3f2b8
movl %eax, %ecx
subl %edi, %ecx
cmpl $0x2, %ecx
jl 0x1a1cf
movl %edi, %ebx
cmpl %edi, %eax
jle 0x1a1cb
movq 0x2e117(%rip), %rcx     # 0x482a0
movslq %ebx, %rdx
movq %rax, %rsi
subq %rdx, %rsi
shlq $0x3, %rdx
xorl %edi, %edi
leaq 0x2e421(%rip), %r8      # 0x485c0
leaq 0x2b85a(%rip), %r9      # 0x45a00
leaq (%rdx,%rdi,8), %r10
movq (%r8,%r10), %r15
cmpb $0x1, 0x10(%r15)
movq %r9, %r10
cmoveq %r15, %r10
cmpq %rcx, (%r10)
je 0x1a1c9
incq %rdi
cmpq %rdi, %rsi
jne 0x1a1a6
jmp 0x1a1cf
addl %ebx, %edi
cmpl %eax, %edi
jne 0x1a1de
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %esi
callq 0xb39c
movl 0x250ca(%rip), %edi     # 0x3f2b8
movl %edi, %r14d
subl %ebx, %r14d
leaq 0x2e3c5(%rip), %r12     # 0x485c0
cmpl $0x2, %r14d
jl 0x1a24b
movslq %edi, %rax
leaq (%r12,%rax,8), %rdi
movl %r14d, %esi
leaq (,%rsi,8), %rax
subq %rax, %rdi
leaq 0x3a8(%rip), %rcx       # 0x1a5c5
movl $0x8, %edx
callq 0x70a0
movl %r14d, %edi
callq 0x8b7d
movq 0x2e072(%rip), %rdi     # 0x482a8
callq 0x8ba5
callq 0xb238
callq 0x8be6
movl 0x2506d(%rip), %edi     # 0x3f2b8
movl $0xfffe795f, %eax       # imm = 0xFFFE795F
leal (%rdi,%rax), %ecx
cmpl %eax, %ecx
jbe 0x1a2dd
decl %edi
movl %edi, 0x25055(%rip)     # 0x3f2b8
cmpb $0x1, 0x10(%r15)
leaq 0x8(%r15), %rax
leaq 0x2b78d(%rip), %r15     # 0x45a00
cmovneq %r15, %rax
movq (%rax), %r13
cmpb $0x1, 0x10(%r13)
jne 0x1a2c8
movq (%r12,%rdi,8), %r14
movq %r14, %rdi
callq 0x8ba5
cmpb $0x1, 0x10(%r13)
movq %r15, %rax
cmoveq %r13, %rax
movq (%rax), %rdi
callq 0x8ba5
movl $0x2, %edi
callq 0xacef
leaq 0x8(%r13), %rax
cmpb $0x1, 0x10(%r13)
cmovneq %r15, %rax
movq (%rax), %r13
cmpb $0x1, 0x10(%r13)
je 0x1a285
movl 0x24ff0(%rip), %edi     # 0x3f2b8
subl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xadb3
leaq 0x14c5d(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: multiply_numbers
void
multiply_numbers(struct atom *p1, struct atom *p2)
{
	double d1, d2;

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

	push(p1);
	d1 = pop_double();

	push(p2);
	d2 = pop_double();

	push_double(d1 * d2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x4, 0x10(%rdi)
jne 0x1a345
cmpb $0x4, 0x10(%rbx)
jne 0x1a345
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1a6d7
callq 0x8ba5
callq 0x9128
movsd %xmm0, -0x10(%rbp)
movq %rbx, %rdi
callq 0x8ba5
callq 0x9128
mulsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
callq 0x74dc
movb $0x5, 0x10(%rax)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8ba5
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: combine_factors_nib
int
combine_factors_nib(int i, int j)
{
	struct atom *p1, *p2, *BASE1, *EXPO1, *BASE2, *EXPO2;

	p1 = stack[i];
	p2 = stack[j];

	if (car(p1) == symbol(POWER)) {
		BASE1 = cadr(p1);
		EXPO1 = caddr(p1);
	} else {
		BASE1 = p1;
		EXPO1 = one;
	}

	if (car(p2) == symbol(POWER)) {
		BASE2 = cadr(p2);
		EXPO2 = caddr(p2);
	} else {
		BASE2 = p2;
		EXPO2 = one;
	}

	if (!equal(BASE1, BASE2))
		return 0;

	if (isdouble(BASE2))
		BASE1 = BASE2; // if mixed rational and double, use double

	push_symbol(POWER);
	push(BASE1);
	push(EXPO1);
	push(EXPO2);
	add();
	list(3);

	stack[i] = pop();

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq %edi, %r13
leaq 0x2e1ef(%rip), %rcx     # 0x485c0
movq (%rcx,%r13,8), %rbx
movslq %esi, %rax
movq (%rcx,%rax,8), %r14
movb 0x10(%rbx), %cl
cmpb $0x1, %cl
leaq 0x2b617(%rip), %rax     # 0x45a00
movq %rax, %rdi
cmoveq %rbx, %rdi
movq 0x2deb9(%rip), %rsi     # 0x482b0
leaq 0xf16da(%rip), %rdx     # 0x10bad8
cmpq %rsi, (%rdi)
je 0x1a408
movq %rdx, %rcx
jmp 0x1a445
addq $0x8, %rbx
cmpb $0x1, %cl
leaq 0x2b5ea(%rip), %rcx     # 0x45a00
cmovneq %rcx, %rbx
movq (%rbx), %rdi
cmpb $0x1, 0x10(%rdi)
jne 0x1a432
movq (%rdi), %rbx
movq 0x8(%rdi), %rdi
cmpb $0x1, 0x10(%rdi)
je 0x1a442
jmp 0x1a445
movq 0x2b5c7(%rip), %rdi     # 0x45a00
cmpb $0x1, 0x10(%rdi)
movq %rdi, %rbx
jne 0x1a445
movq %rdi, %rcx
movb 0x10(%r14), %dil
cmpb $0x1, %dil
movq %rax, %r8
cmoveq %r14, %r8
cmpq %rsi, (%r8)
je 0x1a4f7
movq %rdx, %rax
movq (%rcx), %r12
movq (%rax), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8d48
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x1a4e8
cmpb $0x5, 0x10(%r14)
cmoveq %r14, %rbx
movq 0x2de27(%rip), %rdi     # 0x482b0
callq 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
movq %r12, %rdi
callq 0x8ba5
movq %r15, %rdi
callq 0x8ba5
movl $0x2, %edi
callq 0xadb3
movl $0x3, %edi
callq 0x8b7d
movl 0x24df8(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x1a53b
decl %eax
movl %eax, 0x24de4(%rip)     # 0x3f2b8
leaq 0x2e0e5(%rip), %rcx     # 0x485c0
movq (%rcx,%rax,8), %rax
movq %rax, (%rcx,%r13,8)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x8, %r14
cmpb $0x1, %dil
cmovneq %rax, %r14
movq (%r14), %rdx
cmpb $0x1, 0x10(%rdx)
jne 0x1a522
movq (%rdx), %r14
movq 0x8(%rdx), %rdx
cmpb $0x1, 0x10(%rdx)
je 0x1a45d
jmp 0x1a460
movq 0x2b4d7(%rip), %rdx     # 0x45a00
cmpb $0x1, 0x10(%rdx)
movq %rdx, %r14
je 0x1a45d
jmp 0x1a460
leaq 0x149ff(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: cmp_factors_provisional
int
cmp_factors_provisional(struct atom *p1, struct atom *p2)
{
	if (car(p1) == symbol(POWER))
		p1 = cadr(p1); // p1 = base

	if (car(p2) == symbol(POWER))
		p2 = cadr(p2); // p2 = base

	return cmp(p1, p2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb 0x10(%rdi), %dl
cmpb $0x1, %dl
leaq 0x2b498(%rip), %rax     # 0x45a00
movq %rax, %r8
cmoveq %rdi, %r8
movq 0x2dd3a(%rip), %rcx     # 0x482b0
cmpq %rcx, (%r8)
jne 0x1a594
addq $0x8, %rdi
cmpb $0x1, %dl
cmovneq %rax, %rdi
movq (%rdi), %rdx
cmpb $0x1, 0x10(%rdx)
cmovneq %rax, %rdx
movq (%rdx), %rdi
movb 0x10(%rsi), %dl
cmpb $0x1, %dl
movq %rax, %r8
cmoveq %rsi, %r8
cmpq %rcx, (%r8)
jne 0x1a5bf
addq $0x8, %rsi
cmpb $0x1, %dl
cmovneq %rax, %rsi
movq (%rsi), %rcx
cmpb $0x1, 0x10(%rcx)
cmoveq %rcx, %rax
movq (%rax), %rsi
popq %rbp
jmp 0x8d48
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: order_factor
int
order_factor(struct atom *p)
{
	if (isnum(p))
		return 1;

	if (p == symbol(EXP1))
		return 5;

	if (car(p) == symbol(DERIVATIVE) || car(p) == symbol(D_LOWER))
		return 6;

	if (car(p) == symbol(POWER)) {

		p = cadr(p); // p = base

		if (isminusone(p))
			return 3;

		if (isnum(p))
			return 2;

		if (p == symbol(EXP1))
			return 5;

		if (car(p) == symbol(DERIVATIVE) || car(p) == symbol(D_LOWER))
			return 6;
	}

	return 4;
}

// Assembly:
movb 0x10(%rdi), %cl
movl %ecx, %edx
andb $-0x2, %dl
movl $0x1, %eax
cmpb $0x4, %dl
je 0x1a6d6
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x2dcc8(%rip), %r15     # 0x482c8
movl $0x5, %eax
cmpq %rdi, %r15
je 0x1a6c8
cmpb $0x1, %cl
leaq 0x2b3e8(%rip), %r14     # 0x45a00
movq %r14, %rax
cmoveq %rdi, %rax
movq (%rax), %rdx
movq 0x294b7(%rip), %r12     # 0x43ae0
movl $0x6, %eax
cmpq %r12, %rdx
je 0x1a6c8
movq 0x2948a(%rip), %r13     # 0x43ac8
cmpq %r13, %rdx
je 0x1a6c8
cmpq 0x2dc62(%rip), %rdx     # 0x482b0
je 0x1a657
movl $0x4, %eax
jmp 0x1a6c8
addq $0x8, %rdi
cmpb $0x1, %cl
cmovneq %r14, %rdi
movq (%rdi), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rax
movq (%rax), %rbx
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0xd1c4
movl %eax, %ecx
movl $0x3, %eax
testl %ecx, %ecx
jne 0x1a6c8
movb 0x10(%rbx), %cl
movl %ecx, %edx
andb $-0x2, %dl
movl $0x2, %eax
cmpb $0x4, %dl
je 0x1a6c8
movl $0x5, %eax
cmpq %r15, %rbx
je 0x1a6c8
cmpb $0x1, %cl
cmoveq %rbx, %r14
movq (%r14), %rax
cmpq %r12, %rax
sete %cl
cmpq %r13, %rax
sete %al
orb %cl, %al
movl $0x6, %eax
je 0x1a650
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: multiply_rationals
void
multiply_rationals(struct atom *p1, struct atom *p2)
{
	int sign;
	uint32_t *a, *b, *c;

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

	if (p1->sign == p2->sign)
		sign = MPLUS;
	else
		sign = MMINUS;

	if (isinteger(p1) && isinteger(p2)) {
		push_bignum(sign, mmul(p1->u.q.a, p2->u.q.a), mint(1));
		return;
	}

	a = mmul(p1->u.q.a, p2->u.q.a);
	b = mmul(p1->u.q.b, p2->u.q.b);
	c = mgcd(a, b);
	push_bignum(sign, mdiv(a, c), mdiv(b, c));

	mfree(a);
	mfree(b);
	mfree(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0xb477
testl %eax, %eax
jne 0x1a700
movq %r14, %rdi
callq 0xb477
testl %eax, %eax
je 0x1a71a
movq 0x28a39(%rip), %rdi     # 0x43140
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8ba5
movb 0x12(%r15), %al
xorl %ebx, %ebx
cmpb 0x12(%r14), %al
setne %bl
cmpb $0x4, 0x10(%r15)
jne 0x1a786
movq 0x8(%r15), %rax
cmpl $0x1, -0x4(%rax)
jne 0x1a786
cmpl $0x1, (%rax)
jne 0x1a786
cmpb $0x4, 0x10(%r14)
jne 0x1a786
movq 0x8(%r14), %rax
cmpl $0x1, -0x4(%rax)
jne 0x1a786
cmpl $0x1, (%rax)
jne 0x1a786
movq (%r15), %rdi
movq (%r14), %rsi
callq 0x7b60
movq %rax, %r14
movl $0x1, %edi
callq 0x7b1f
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xbf3e
movq (%r15), %rdi
movq (%r14), %rsi
callq 0x7b60
movq %rax, %r12
movq 0x8(%r15), %rdi
movq 0x8(%r14), %rsi
callq 0x7b60
movq %rax, %r14
movq %r12, %rdi
movq %rax, %rsi
callq 0x87b4
movq %rax, %r15
movq %r12, %rdi
movq %rax, %rsi
callq 0x80ac
movq %rax, %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x80ac
movl %ebx, %edi
movq %r13, %rsi
movq %rax, %rdx
callq 0xbf3e
addq $-0x4, %r12
movq %r12, %rdi
callq 0x7040
movl 0x28972(%rip), %ebx     # 0x4315c
addq $-0x4, %r14
movq %r14, %rdi
callq 0x7040
addq $-0x4, %r15
movq %r15, %rdi
callq 0x7040
addl $-0x3, %ebx
movl %ebx, 0x28951(%rip)     # 0x4315c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: any_radical_factors
int
any_radical_factors(int h)
{
	int i;
	for (i = h; i < tos; i++)
		if (isradical(stack[i]))
			return 1;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x24a8d(%rip), %ebx     # 0x3f2b8
subl %edi, %ebx
jle 0x1a859
movslq %edi, %r14
shlq $0x3, %r14
xorl %r15d, %r15d
leaq 0x2dd80(%rip), %r12     # 0x485c0
leaq (%r14,%r15,8), %rax
movq (%r12,%rax), %rdi
callq 0x1ae1b
testl %eax, %eax
jne 0x1a85d
incq %r15
cmpl %r15d, %ebx
jne 0x1a840
xorl %eax, %eax
jmp 0x1a862
movl $0x1, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: reduce_radical_double
struct atom *
reduce_radical_double(int h, struct atom *COEF)
{
	int i;
	double a, b, c;
	struct atom *p1;

	c = COEF->u.d;

	for (i = h; i < tos; i++) {

		p1 = stack[i];

		if (isradical(p1)) {

			push(cadr(p1)); // base
			a = pop_double();

			push(caddr(p1)); // exponent
			b = pop_double();

			c = c * pow(a, b); // a > 0 by isradical above

			slice(i, 1); // remove factor

			i--; // use same index again
		}
	}

	push_double(c);
	COEF = pop();

	return COEF;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movsd (%rsi), %xmm0
movsd %xmm0, -0x30(%rbp)
movl 0x245c2(%rip), %r13d    # 0x3f2b8
leaq 0x2d8c3(%rip), %r15     # 0x485c0
cmpl %edi, %r13d
jle 0x1adc8
movl %edi, %ebx
leaq 0x2acf1(%rip), %r12     # 0x45a00
movslq %ebx, %rax
movq (%r15,%rax,8), %r14
movq %r14, %rdi
callq 0x1ae1b
testl %eax, %eax
je 0x1adbd
cmpb $0x1, 0x10(%r14)
leaq 0x8(%r14), %r13
movq %r12, %rax
cmoveq %r13, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x8ba5
callq 0x9128
cmpb $0x1, 0x10(%r14)
cmovneq %r12, %r13
movsd %xmm0, -0x38(%rbp)
movq (%r13), %rax
cmpb $0x1, 0x10(%rax)
jne 0x1ad6c
movq 0x8(%rax), %rax
jmp 0x1ad73
movq 0x2ac8d(%rip), %rax     # 0x45a00
cmpb $0x1, 0x10(%rax)
movq %r12, %rcx
jne 0x1ad7f
movq %rax, %rcx
movq (%rcx), %rdi
callq 0x8ba5
callq 0x9128
movapd %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
callq 0x70d0
movsd -0x30(%rbp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, -0x30(%rbp)
movl %ebx, %edi
movl $0x1, %esi
callq 0xb39c
decl %ebx
movl 0x244fb(%rip), %r13d    # 0x3f2b8
incl %ebx
cmpl %r13d, %ebx
jl 0x1ad0f
callq 0x74dc
movb $0x5, 0x10(%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rax, %rdi
callq 0x8ba5
movl 0x244d0(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x1ae0f
decl %eax
movl %eax, 0x244bc(%rip)     # 0x3f2b8
movq (%r15,%rax,8), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1412b(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: multiply_noexpand
void
multiply_noexpand(void)
{
	int t;
	t = expanding;
	expanding = 0;
	multiply();
	expanding = t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0xf0bec(%rip), %ebx     # 0x10bad0
movl $0x0, 0xf0be2(%rip)     # 0x10bad0
movl $0x2, %edi
callq 0xacef
movl %ebx, 0xf0bd2(%rip)     # 0x10bad0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_noexpand
void
eval_noexpand(struct atom *p1)
{
	int t;

	t = expanding;
	expanding = 0;

	push(cadr(p1));
	evalf();

	expanding = t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0xf0bae(%rip), %ebx     # 0x10bad0
movl $0x0, 0xf0ba4(%rip)     # 0x10bad0
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rax
leaq 0x2aac5(%rip), %rcx     # 0x45a00
cmovneq %rcx, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %rcx
movq (%rcx), %rdi
callq 0x8ba5
callq 0x96e2
movl %ebx, 0xf0b73(%rip)     # 0x10bad0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_not
void
eval_not(struct atom *p1)
{
	push(cadr(p1));
	evalp();
	p1 = pop();
	if (iszero(p1))
		push_integer(1);
	else
		push_integer(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rax
leaq 0x2aa89(%rip), %rcx     # 0x45a00
cmovneq %rcx, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %rcx
movq (%rcx), %rdi
callq 0x8ba5
callq 0x9cff
movl 0x2431f(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x1afda
decl %eax
movl %eax, 0x2430b(%rip)     # 0x3f2b8
leaq 0x2d60c(%rip), %rcx     # 0x485c0
movq (%rcx,%rax,8), %rdi
callq 0xb477
testl %eax, %eax
leaq 0x2817a(%rip), %rax     # 0x43140
leaq 0xf0b0b(%rip), %rcx     # 0x10bad8
cmoveq %rax, %rcx
movq (%rcx), %rdi
popq %rbp
jmp 0x8ba5
leaq 0x13f60(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_nroots
void
eval_nroots(struct atom *p1)
{
	push(cadr(p1));
	evalf();

	p1 = cddr(p1);

	if (iscons(p1)) {
		push(car(p1));
		evalf();
	} else
		push_symbol(X_LOWER);

	nroots();
}

// 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 0x2a9fe(%rip), %r15     # 0x45a00
movq %r15, %rax
cmoveq %r14, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x8ba5
callq 0x96e2
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 0x1b050
movq (%rax), %rdi
callq 0x8ba5
callq 0x96e2
jmp 0x1b05c
movq 0x2c8f1(%rip), %rdi     # 0x47948
callq 0x8ba5
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1b06b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: coeffs
void
coeffs(struct atom *P, struct atom *X)
{
	struct atom *C;

	for (;;) {

		push(P);
		push(X);
		push_integer(0);
		subst();
		evalf();
		C = pop();

		push(C);

		push(P);
		push(C);
		subtract();
		P = pop();

		if (iszero(P))
			break;

		push(P);
		push(X);
		divide();
		P = pop();
	}
}

// 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 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
movq 0x27c53(%rip), %rdi     # 0x43140
callq 0x8ba5
callq 0x9493
callq 0x96e2
movl 0x23db6(%rip), %eax     # 0x3f2b8
leal -0x186a1(%rax), %ecx
cmpl $0xfffe7960, %ecx       # imm = 0xFFFE7960
jb 0x1b5e3
leaq 0x2d0a5(%rip), %r12     # 0x485c0
movl $0xfffe795f, %r13d      # imm = 0xFFFE795F
decl %eax
movl %eax, 0x23d8f(%rip)     # 0x3f2b8
movq (%r12,%rax,8), %r15
movq %r15, %rdi
callq 0x8ba5
movq %r14, %rdi
callq 0x8ba5
movq %r15, %rdi
callq 0x8ba5
callq 0xbfb4
movl 0x23d68(%rip), %eax     # 0x3f2b8
leal (%rax,%r13), %ecx
cmpl %r13d, %ecx
jbe 0x1b5e3
decl %eax
movl %eax, 0x23d53(%rip)     # 0x3f2b8
movq (%r12,%rax,8), %r14
movq %r14, %rdi
callq 0xb477
testl %eax, %eax
jne 0x1b5ef
movq %r14, %rdi
callq 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
callq 0xe218
movl 0x23d28(%rip), %eax     # 0x3f2b8
leal (%rax,%r13), %ecx
cmpl %r13d, %ecx
jbe 0x1b5e3
decl %eax
movl %eax, 0x23d17(%rip)     # 0x3f2b8
movq (%r12,%rax,8), %r14
movq %r14, %rdi
callq 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
movq 0x27b84(%rip), %rdi     # 0x43140
callq 0x8ba5
callq 0x9493
callq 0x96e2
movl 0x23ce7(%rip), %eax     # 0x3f2b8
leal -0x186a1(%rax), %ecx
cmpl $0xfffe7960, %ecx       # imm = 0xFFFE7960
jae 0x1b521
leaq 0x13957(%rip), %rdi     # 0x2ef41
callq 0x780b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: nreduce
void
nreduce(double cr[], double ci[], int n, double ar, double ai)
{
	int k;

	// divide

	for (k = n - 1; k > 0; k--) {
		cr[k - 1] += cr[k] * ar - ci[k] * ai;
		ci[k - 1] += ci[k] * ar + cr[k] * ai;
	}

	if (zabs(cr[0], ci[0]) > DELTA)
		stopf("nroots: residual error"); // not a root

	// shift

	for (k = 0; k < n - 1; k++) {
		cr[k] = cr[k + 1];
		ci[k] = ci[k + 1];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leal -0x1(%rdx), %eax
cmpl $0x2, %edx
jl 0x1b9de
movl %eax, %ecx
movsd (%rsi,%rcx,8), %xmm2
incq %rcx
movsd -0x8(%rdi,%rcx,8), %xmm3
mulsd %xmm1, %xmm2
movapd %xmm3, %xmm4
mulsd %xmm0, %xmm4
subsd %xmm2, %xmm4
addsd -0x10(%rdi,%rcx,8), %xmm4
movsd %xmm4, -0x10(%rdi,%rcx,8)
mulsd %xmm1, %xmm3
movsd -0x8(%rsi,%rcx,8), %xmm2
mulsd %xmm0, %xmm2
addsd %xmm3, %xmm2
addsd -0x10(%rsi,%rcx,8), %xmm2
movsd %xmm2, -0x10(%rsi,%rcx,8)
decq %rcx
cmpq $0x1, %rcx
ja 0x1b995
movsd (%rdi), %xmm0
movsd (%rsi), %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
ucomisd 0xe76a(%rip), %xmm0     # 0x2a168
ja 0x1ba2d
cmpl $0x2, %edx
jl 0x1ba2b
movl %eax, %eax
xorl %ecx, %ecx
movsd 0x8(%rdi,%rcx,8), %xmm0
movsd %xmm0, (%rdi,%rcx,8)
movsd 0x8(%rsi,%rcx,8), %xmm0
movsd %xmm0, (%rsi,%rcx,8)
leaq 0x1(%rcx), %rdx
movq %rdx, %rcx
cmpq %rdx, %rax
jne 0x1ba09
popq %rbp
retq
leaq 0x12eb8(%rip), %rdi     # 0x2e8ec
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: fata
void
fata(double cr[], double ci[], int n, double ar, double ai, double *far, double *fai)
{
	int k;
	double xr, xi, yr, yi;

	yr = cr[n - 1];
	yi = ci[n - 1];

	for (k = n - 2; k >= 0; k--) {

		// x = a * y

		xr = ar * yr - ai * yi;
		xi = ar * yi + ai * yr;

		// y = x + c

		yr = xr + cr[k];
		yi = xi + ci[k];
	}

	*far = yr;
	*fai = yi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %edx, %rax
movsd -0x8(%rdi,%rax,8), %xmm3
movsd -0x8(%rsi,%rax,8), %xmm2
cmpl $0x2, %eax
jl 0x1bab5
addl $-0x2, %edx
movapd %xmm0, %xmm5
mulsd %xmm2, %xmm5
mulsd %xmm1, %xmm2
movapd %xmm0, %xmm4
mulsd %xmm3, %xmm4
subsd %xmm2, %xmm4
mulsd %xmm1, %xmm3
addsd %xmm5, %xmm3
addsd (%rdi,%rdx,8), %xmm4
movapd %xmm3, %xmm2
addsd (%rsi,%rdx,8), %xmm2
movapd %xmm4, %xmm3
addq $-0x1, %rdx
jb 0x1ba7b
jmp 0x1bab9
movapd %xmm3, %xmm4
movsd %xmm4, (%rcx)
movsd %xmm2, (%r8)
popq %rbp
retq