LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: infixform_tensor_nib
void
infixform_tensor_nib(struct atom *p, int d, int k)
{
	int i, n, span;

	if (d == p->u.tensor->ndim) {
		infixform_expr(p->u.tensor->elem[k]);
		return;
	}

	span = 1;

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

	for (i = d + 1; i < n; i++)
		span *= p->u.tensor->dim[i];

	outbuf_puts("(");

	n = p->u.tensor->dim[d];

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

		infixform_tensor_nib(p, d + 1, k);

		if (i < n - 1)
			outbuf_puts(",");

		k += span;
	}

	outbuf_puts(")");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebx
movq %rdi, -0x38(%rbp)
movq (%rdi), %rcx
movl (%rcx), %edx
movl %edx, %eax
subl %esi, %eax
jne 0x15e47
movslq %ebx, %rax
movq 0x68(%rcx,%rax,8), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x14b66
movl %esi, %r12d
leal 0x1(%r12), %esi
movl $0x1, %r13d
movl %esi, -0x2c(%rbp)
cmpl %edx, %esi
jge 0x15e75
movslq -0x2c(%rbp), %rdx
leaq (%rcx,%rdx,4), %rcx
movl $0x1, %edx
imull (%rcx,%rdx,4), %r13d
incq %rdx
cmpl %edx, %eax
jne 0x15e69
leaq 0x10526(%rip), %rdi     # 0x263a2
callq 0x14c8d
movq -0x38(%rbp), %rax
movq (%rax), %rax
movslq %r12d, %rcx
movl 0x4(%rax,%rcx,4), %r12d
testl %r12d, %r12d
jle 0x15ec7
leal -0x1(%r12), %r15d
xorl %r14d, %r14d
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
movl %ebx, %edx
callq 0x15e0a
cmpl %r15d, %r14d
jge 0x15ebc
leaq 0x104f6(%rip), %rdi     # 0x263ad
callq 0x14c8d
addl %r13d, %ebx
incl %r14d
cmpl %r14d, %r12d
jne 0x15e9d
leaq 0x1354c(%rip), %rdi     # 0x2941a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x14c8d
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_inner
void
eval_inner(struct atom *p1)
{
	int h = tos;

	// evaluate from right to left

	p1 = cdr(p1);

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

	if (h == tos)
		stopf("inner: no args");

	evalg();

	while (tos - h > 1) {
		swap();
		evalg();
		swap();
		inner();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rax
leaq 0x2ab06(%rip), %r14     # 0x40a00
cmovneq %r14, %rax
movl 0x243b4(%rip), %ebx     # 0x3a2b8
movq (%rax), %r15
cmpb $0x1, 0x10(%r15)
jne 0x15f25
movq (%r15), %rdi
callq 0x8b01
leaq 0x8(%r15), %rax
cmpb $0x1, 0x10(%r15)
cmovneq %r14, %rax
jmp 0x15f04
cmpl 0x2438d(%rip), %ebx     # 0x3a2b8
je 0x15f6b
callq 0x95ac
movl 0x24380(%rip), %eax     # 0x3a2b8
subl %ebx, %eax
cmpl $0x2, %eax
jl 0x15f60
callq 0xad38
callq 0x95ac
callq 0xad38
callq 0x9ef3
movl 0x2435f(%rip), %eax     # 0x3a2b8
subl %ebx, %eax
cmpl $0x1, %eax
jg 0x15f3f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1044c(%rip), %rdi     # 0x263be
callq 0x77c8
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_integral
void
eval_integral(struct atom *p1)
{
	int flag, i, n;
	struct atom *X, *Y = NULL; // silence compiler

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

	p1 = cddr(p1);

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

	flag = 0;

	while (iscons(p1) || flag) {

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

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

		if (!isusersymbol(X))
			stopf("integral");

		if (iscons(p1)) {

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

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

			flag = 1;
		}

		push(X);
		integral();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
cmpb $0x1, 0x10(%rdi)
leaq 0x2aa69(%rip), %r12     # 0x40a00
movq %r12, %rax
cmoveq %r14, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x8b01
callq 0x95e2
cmpb $0x1, 0x10(%rbx)
cmovneq %r12, %r14
movq (%r14), %rax
leaq 0x8(%rax), %rcx
cmpb $0x1, 0x10(%rax)
cmovneq %r12, %rcx
movq (%rcx), %r13
cmpb $0x1, 0x10(%r13)
jne 0x16137
cmpb $0x1, 0x10(%r13)
sete %al
jne 0x16128
leaq 0x10(%r13), %r14
xorl %r15d, %r15d
xorl %ebx, %ebx
testb $0x1, %r15b
je 0x15ffd
movq %rbx, %r14
jmp 0x1602b
testb $0x1, %al
movq %r12, %rax
cmovneq %r13, %rax
movq (%rax), %rdi
callq 0x8b01
callq 0x95e2
callq 0x8b78
addq $0x8, %r13
cmpb $0x1, (%r14)
movq %rax, %r14
cmovneq %r12, %r13
movq (%r13), %r13
movzbl 0x10(%r14), %eax
leal -0x4(%rax), %ecx
cmpl $0x2, %ecx
jae 0x1608d
movq %r14, %rdi
callq 0x8b01
callq 0xeb5b
movl %eax, %r14d
movq 0x2c8f9(%rip), %rdi     # 0x42948
callq 0x8b01
callq 0x8b78
testl %r14d, %r14d
jle 0x16073
movq %rax, %r15
movq %r15, %rdi
callq 0x8b01
callq 0x10469
decl %r14d
jne 0x16061
leaq 0x10(%r13), %r14
xorl %r15d, %r15d
cmpb $0x1, 0x10(%r13)
sete %al
je 0x15ff2
jmp 0x16128
cmpl $0x3, %eax
jne 0x16156
cmpb $0x1, 0x10(%r13)
sete %r15b
jne 0x160fb
movq (%r13), %rdi
callq 0x8b01
callq 0x95e2
callq 0x8b78
movq %rax, %rbx
leaq 0x8(%r13), %rax
cmpb $0x1, 0x10(%r13)
cmovneq %r12, %rax
movq (%rax), %r13
movb 0x10(%rbx), %al
andb $-0x2, %al
cmpb $0x4, %al
jne 0x160fb
movq %rbx, %rdi
callq 0x8b01
callq 0xeb5b
testl %eax, %eax
jle 0x160f6
movl %eax, %r15d
movq %r14, %rdi
callq 0x8b01
callq 0x10469
decl %r15d
jne 0x160e4
xorl %r15d, %r15d
jmp 0x16108
movq %r14, %rdi
callq 0x8b01
callq 0x10469
leaq 0x10(%r13), %r14
movb 0x10(%r13), %cl
cmpb $0x1, %cl
sete %al
testb %r15b, %r15b
jne 0x15ff2
cmpb $0x1, %cl
je 0x15ff2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2c80a(%rip), %rdi     # 0x42948
callq 0x8b01
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10469
leaq 0x10167(%rip), %rdi     # 0x262c4
callq 0x77c8
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: partition_term
void
partition_term(void)
{
	int h, n;
	struct atom *p1, *F, *X;

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

	// push const 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 == 0)
		push_integer(1);
	else if (n > 1) {
		list(n);
		push_symbol(MULTIPLY);
		swap();
		cons(); // makes MULTIPLY head of list
	}

	// push var 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 == 0)
		push_integer(1);
	else 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
subq $0x18, %rsp
callq 0x8b78
movq %rax, %rbx
callq 0x8b78
leaq 0x8(%rax), %r12
movq %rax, -0x38(%rbp)
cmpb $0x1, 0x10(%rax)
leaq 0x2a86d(%rip), %r15     # 0x40a00
movq %r15, %rax
cmoveq %r12, %rax
movl 0x24118(%rip), %ecx     # 0x3a2b8
movl %ecx, -0x2c(%rbp)
movq (%rax), %r13
cmpb $0x1, 0x10(%r13)
jne 0x161ef
leaq 0x10(%r13), %r14
movq (%r13), %rdi
movq %rbx, %rsi
callq 0x16ba1
testl %eax, %eax
jne 0x161d4
cmpb $0x1, (%r14)
movq %r15, %rax
cmoveq %r13, %rax
movq (%rax), %rdi
callq 0x8b01
addq $0x8, %r13
cmpb $0x1, (%r14)
cmovneq %r15, %r13
movq (%r13), %r13
leaq 0x10(%r13), %r14
cmpb $0x1, 0x10(%r13)
je 0x161b1
movl 0x240c3(%rip), %edi     # 0x3a2b8
subl -0x2c(%rbp), %edi
jne 0x16208
movq 0xf08d7(%rip), %rdi     # 0x106ad8
callq 0x8b01
jmp 0x16228
cmpl $0x2, %edi
jl 0x16228
callq 0x8ad9
movq 0x2d08f(%rip), %rdi     # 0x432a8
callq 0x8b01
callq 0xad38
callq 0x8b47
movq -0x38(%rbp), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r15, %r12
movl 0x2407d(%rip), %r14d    # 0x3a2b8
movq (%r12), %r12
cmpb $0x1, 0x10(%r12)
jne 0x1628e
leaq 0x10(%r12), %r13
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x16ba1
testl %eax, %eax
je 0x16270
cmpb $0x1, (%r13)
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rdi
callq 0x8b01
addq $0x8, %r12
cmpb $0x1, (%r13)
cmovneq %r15, %r12
movq (%r12), %r12
leaq 0x10(%r12), %r13
cmpb $0x1, 0x10(%r12)
je 0x1624c
movl 0x24024(%rip), %edi     # 0x3a2b8
subl %r14d, %edi
jne 0x162b3
movq 0xf0838(%rip), %rdi     # 0x106ad8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8b01
cmpl $0x2, %edi
jl 0x162e1
callq 0x8ad9
movq 0x2cfe4(%rip), %rdi     # 0x432a8
callq 0x8b01
callq 0xad38
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8b47
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: integral_solve
void
integral_solve(struct atom *F, struct atom *X)
{
	struct atom *p;

	if (car(F) == symbol(INTEGRAL)) {
		integral_of_integral(F, X);
		return;
	}

	if (car(F) == symbol(DERIVATIVE)) {
		integral_of_derivative(F, X);
		return;
	}

	save_symbol(symbol(SA));
	save_symbol(symbol(SB));
	save_symbol(symbol(SX));

	integral_solve_nib(F, X);

	p = pop();
	restore_symbol();
	restore_symbol();
	restore_symbol();
	push(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x10(%rdi)
leaq 0x2a6fb(%rip), %rax     # 0x40a00
cmoveq %rdi, %rax
movq %rsi, %r14
movq (%rax), %rax
cmpq 0x29772(%rip), %rax     # 0x3fa88
je 0x16373
cmpq 0x287c1(%rip), %rax     # 0x3eae0
je 0x16382
movq 0x2cfa8(%rip), %rdi     # 0x432d0
callq 0xe73e
movq 0x2cfa4(%rip), %rdi     # 0x432d8
callq 0xe73e
movq 0x2cfa0(%rip), %rdi     # 0x432e0
callq 0xe73e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x16674
callq 0x8b78
movq %rax, %rbx
callq 0xe7a4
callq 0xe7a4
callq 0xe7a4
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x8b01
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x16391
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x16520
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: integral_of_integral
void
integral_of_integral(struct atom *F, struct atom *X)
{
	struct atom *G, *Y;

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

	// if X == Y then F is not integrable for X

	if (equal(X, Y)) {
		push_symbol(INTEGRAL);
		push(F);
		push(X);
		list(3);
		return;
	}

	push(G);
	push(X);
	integral();

	G = pop();

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

		// sort integrals by measure

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

		push_symbol(INTEGRAL);
		push_symbol(INTEGRAL);
		push(F);

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

		return;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rax
cmpb $0x1, 0x10(%rdi)
leaq 0x2a652(%rip), %rcx     # 0x40a00
cmovneq %rcx, %rax
movq (%rax), %rax
movb 0x10(%rax), %dil
leaq 0x8(%rax), %rdx
cmpb $0x1, %dil
cmovneq %rcx, %rax
movq %rcx, %r8
cmoveq %rdx, %r8
movq %rsi, %r15
movq (%r8), %rsi
cmpb $0x1, 0x10(%rsi)
jne 0x163ea
cmpb $0x1, %dil
leaq 0x2a61d(%rip), %rcx     # 0x40a00
cmoveq %rdx, %rcx
movq (%rcx), %rcx
movq (%rax), %r12
movq (%rcx), %rbx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8c79
testl %eax, %eax
je 0x16456
movq %r12, %rdi
callq 0x8b01
movq %r15, %rdi
callq 0x8b01
callq 0x10469
callq 0x8b78
movb 0x10(%rax), %dl
cmpb $0x1, %dl
leaq 0x2a5da(%rip), %rcx     # 0x40a00
movq %rcx, %rsi
cmoveq %rax, %rsi
movq 0x29654(%rip), %rdi     # 0x3fa88
cmpq %rdi, (%rsi)
je 0x16472
movq %rax, %rdi
callq 0x8b01
movq %rbx, %rdi
callq 0x8b01
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10469
movq 0x2962b(%rip), %rdi     # 0x3fa88
callq 0x8b01
movq %r14, %rdi
callq 0x8b01
movq %r15, %rdi
jmp 0x16509
addq $0x8, %rax
cmpb $0x1, %dl
cmovneq %rcx, %rax
movq (%rax), %rsi
movb 0x10(%rsi), %dl
leaq 0x8(%rsi), %rax
cmpb $0x1, %dl
cmovneq %rcx, %rsi
movq %rcx, %r8
cmoveq %rax, %r8
movq (%rsi), %r15
movq (%r8), %rsi
cmpb $0x1, 0x10(%rsi)
jne 0x164b2
cmpb $0x1, %dl
leaq 0x2a555(%rip), %rcx     # 0x40a00
cmoveq %rax, %rcx
movq (%rcx), %rcx
movq (%rcx), %r14
callq 0x8b01
movq 0x295c7(%rip), %rdi     # 0x3fa88
callq 0x8b01
movq %r15, %rdi
callq 0x8b01
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8c79
testl %eax, %eax
js 0x164f4
movq %rbx, %rdi
callq 0x8b01
movl $0x3, %edi
callq 0x8ad9
movq %r14, %rdi
jmp 0x16509
movq %r14, %rdi
callq 0x8b01
movl $0x3, %edi
callq 0x8ad9
movq %rbx, %rdi
callq 0x8b01
movl $0x3, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8ad9
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: integral_of_derivative
void
integral_of_derivative(struct atom *F, struct atom *X)
{
	struct atom *G, *Y;

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

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

	push(G);
	push(X);
	integral();

	G = pop();

	// integral before derivative

	if (car(G) == symbol(INTEGRAL)) {
		F = cadr(G);
		X = caddr(G);
		push_symbol(INTEGRAL);
		push_symbol(DERIVATIVE);
		push(F);
		push(Y);
		list(3);
		push(X);
		list(3);
		return;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x8(%rdi), %rcx
cmpb $0x1, 0x10(%rdi)
leaq 0x2a4c6(%rip), %rax     # 0x40a00
cmovneq %rax, %rcx
movq (%rcx), %rdi
movb 0x10(%rdi), %dl
leaq 0x8(%rdi), %rcx
cmpb $0x1, %dl
cmovneq %rax, %rdi
movq %rsi, %r14
movq %rax, %rsi
cmoveq %rcx, %rsi
movq (%rdi), %r15
movq (%rsi), %rsi
cmpb $0x1, 0x10(%rsi)
jne 0x16576
cmpb $0x1, %dl
leaq 0x2a491(%rip), %rax     # 0x40a00
cmoveq %rcx, %rax
movq (%rax), %rax
movq (%rax), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8c79
movl %eax, %r12d
movq %r15, %rdi
callq 0x8b01
testl %r12d, %r12d
je 0x165e3
movq %r14, %rdi
callq 0x8b01
callq 0x10469
callq 0x8b78
movb 0x10(%rax), %dl
cmpb $0x1, %dl
leaq 0x2a44d(%rip), %rcx     # 0x40a00
movq %rcx, %rsi
cmoveq %rax, %rsi
movq 0x294c7(%rip), %rdi     # 0x3fa88
cmpq %rdi, (%rsi)
je 0x165ec
movq %rax, %rdi
callq 0x8b01
movq %rbx, %rdi
callq 0x8b01
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x10771
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
addq $0x8, %rax
cmpb $0x1, %dl
cmovneq %rcx, %rax
movq (%rax), %rsi
movb 0x10(%rsi), %dl
leaq 0x8(%rsi), %rax
cmpb $0x1, %dl
cmovneq %rcx, %rsi
movq %rcx, %r8
cmoveq %rax, %r8
movq (%rsi), %r14
movq (%r8), %rsi
cmpb $0x1, 0x10(%rsi)
jne 0x1662c
cmpb $0x1, %dl
leaq 0x2a3db(%rip), %rcx     # 0x40a00
cmoveq %rax, %rcx
movq (%rcx), %rcx
movq (%rcx), %r15
callq 0x8b01
movq 0x284a5(%rip), %rdi     # 0x3eae0
callq 0x8b01
movq %r14, %rdi
callq 0x8b01
movq %rbx, %rdi
callq 0x8b01
movl $0x3, %edi
callq 0x8ad9
movq %r15, %rdi
callq 0x8b01
movl $0x3, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8ad9
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: integral_solve_nib
void
integral_solve_nib(struct atom *F, struct atom *X)
{
	int h, t;

	set_symbol(symbol(SX), X, symbol(NIL));

	h = tos;

	push_integer(1); // 1 is a candidate for a and b

	push(F);
	push(X);
	decomp(); // push possible substitutions for a and b

	t = integral_classify(F);

	if ((t & 1) && integral_search(h, F, integral_tab_exp, sizeof integral_tab_exp / sizeof (char *)))
		return;

	if ((t & 2) && integral_search(h, F, integral_tab_log, sizeof integral_tab_log / sizeof (char *)))
		return;

	if ((t & 4) && integral_search(h, F, integral_tab_trig, sizeof integral_tab_trig / sizeof (char *)))
		return;

	if (car(F) == symbol(POWER)) {
		if (integral_search(h, F, integral_tab_power, sizeof integral_tab_power / sizeof (char *)))
			return;
	} else {
		if (integral_search(h, F, integral_tab, sizeof integral_tab / sizeof (char *)))
			return;
	}

	tos = h; // pop all

	push_symbol(INTEGRAL);
	push(F);
	push(X);
	list(3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x2cc5a(%rip), %rax     # 0x432e0
cmpb $0x3, 0x10(%rax)
jne 0x167dc
movq %rsi, %rbx
movq %rdi, %r14
movq 0x2a363(%rip), %rcx     # 0x40a00
movl 0x8(%rax), %edx
leaq 0xf0449(%rip), %rsi     # 0x106af0
movq %rbx, (%rsi,%rdx,8)
movl 0x8(%rax), %eax
leaq 0xf589b(%rip), %rdx     # 0x10bf50
movq %rcx, (%rdx,%rax,8)
movl 0x23bf8(%rip), %r15d    # 0x3a2b8
movq 0xf0411(%rip), %rdi     # 0x106ad8
callq 0x8b01
movq %r14, %rdi
callq 0x8b01
movq %rbx, %rdi
callq 0x8b01
callq 0x167e8
movq %r14, %rdi
callq 0x168bc
movl %eax, %r12d
testb $0x1, %r12b
je 0x16711
leaq 0x1caf7(%rip), %rdx     # 0x331f0
movl %r15d, %edi
movq %r14, %rsi
movl $0xab, %ecx
callq 0x16943
testl %eax, %eax
jne 0x1679e
testb $0x2, %r12b
je 0x16732
leaq 0x1d032(%rip), %rdx     # 0x33750
movl %r15d, %edi
movq %r14, %rsi
movl $0x21, %ecx
callq 0x16943
testl %eax, %eax
jne 0x1679e
cmpl $0x4, %r12d
jb 0x16753
leaq 0x1d121(%rip), %rdx     # 0x33860
movl %r15d, %edi
movq %r14, %rsi
movl $0xba, %ecx
callq 0x16943
testl %eax, %eax
jne 0x1679e
cmpb $0x1, 0x10(%r14)
leaq 0x2a2a1(%rip), %rax     # 0x40a00
cmoveq %r14, %rax
movq (%rax), %rax
cmpq 0x2cb43(%rip), %rax     # 0x432b0
je 0x16783
leaq 0x1d92a(%rip), %rdx     # 0x340a0
movl %r15d, %edi
movq %r14, %rsi
movl $0xbd, %ecx
jmp 0x16795
leaq 0x1d6a6(%rip), %rdx     # 0x33e30
movl %r15d, %edi
movq %r14, %rsi
movl $0x4e, %ecx
callq 0x16943
testl %eax, %eax
je 0x167a7
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %r15d, 0x23b0a(%rip)    # 0x3a2b8
movq 0x292d3(%rip), %rdi     # 0x3fa88
callq 0x8b01
movq %r14, %rdi
callq 0x8b01
movq %rbx, %rdi
callq 0x8b01
movl $0x3, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8ad9
leaq 0x14797(%rip), %rdi     # 0x2af7a
callq 0x77c8
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: decomp
void
decomp(void)
{
	struct atom *p1, *F, *X;

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

	// is the entire expression constant?

	if (!dependent(F, X)) {
		push(F);
		return;
	}

	// sum?

	if (car(F) == symbol(ADD)) {
		decomp_sum(F, X);
		return;
	}

	// product?

	if (car(F) == symbol(MULTIPLY)) {
		decomp_product(F, X);
		return;
	}

	// naive decomp

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x8b78
movq %rax, %rbx
callq 0x8b78
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16ba1
testl %eax, %eax
je 0x16875
movb 0x10(%r14), %al
cmpb $0x1, %al
leaq 0x2a1e2(%rip), %r15     # 0x40a00
movq %r15, %rcx
cmoveq %r14, %rcx
movq (%rcx), %rcx
cmpq 0x2ca71(%rip), %rcx     # 0x432a0
je 0x16892
cmpq 0x2ca70(%rip), %rcx     # 0x432a8
je 0x168a7
addq $0x8, %r14
cmpb $0x1, %al
cmovneq %r15, %r14
movq (%r14), %r14
cmpb $0x1, 0x10(%r14)
jne 0x16887
movq (%r14), %rdi
callq 0x8b01
movq %rbx, %rdi
callq 0x8b01
callq 0x167e8
leaq 0x8(%r14), %rax
cmpb $0x1, 0x10(%r14)
cmovneq %r15, %rax
movq (%rax), %r14
jmp 0x16847
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8b01
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x16c4e
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x16f1d
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: integral_classify
int
integral_classify(struct atom *p)
{
	int t = 0;

	if (iscons(p)) {
		while (iscons(p)) {
			t |= integral_classify(car(p));
			p = cdr(p);
		}
		return t;
	}

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

	if (p == symbol(LOG))
		return 2;

	if (p == symbol(SIN) || p == symbol(COS) || p == symbol(TAN))
		return 4;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x10(%rdi)
jne 0x168ef
xorl %r14d, %r14d
cmpb $0x1, 0x10(%rbx)
jne 0x1693b
xorl %r14d, %r14d
movq (%rbx), %rdi
callq 0x168bc
orl %eax, %r14d
movq 0x8(%rbx), %rbx
cmpb $0x1, 0x10(%rbx)
je 0x168d8
jmp 0x1693b
cmpq %rbx, 0x2c9d2(%rip)     # 0x432c8
je 0x1692d
cmpq %rbx, 0x29ad1(%rip)     # 0x403d0
je 0x16935
cmpq %rbx, 0x2b0b8(%rip)     # 0x419c0
sete %al
cmpq %rbx, 0x27ede(%rip)     # 0x3e7f0
sete %cl
orb %al, %cl
cmpq %rbx, 0x2b3b2(%rip)     # 0x41cd0
sete %al
orb %cl, %al
movzbl %al, %r14d
shll $0x2, %r14d
jmp 0x1693b
movl $0x1, %r14d
jmp 0x1693b
movl $0x2, %r14d
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: integral_search
int
integral_search(int h, struct atom *F, char **table, int n)
{
	int i;
	struct atom *C, *I;

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

		scan1(table[i + 0]); // integrand
		I = pop();

		scan1(table[i + 2]); // condition
		C = pop();

		if (integral_search_nib(h, F, I, C))
			break;
	}

	if (i >= n)
		return 0;

	tos = h; // pop all

	scan1(table[i + 1]); // answer
	evalf();

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x38(%rbp)
movl %edi, -0x2c(%rbp)
movl %ecx, -0x30(%rbp)
testl %ecx, %ecx
setg %r12b
jle 0x169fc
movq %rdx, %rbx
xorl %r14d, %r14d
movl $0x1, %r15d
movq (%rbx,%r14,8), %rdi
movl %r15d, 0xfaf5f(%rip)    # 0x1118e0
callq 0x250d0
callq 0x8b78
movq %rax, %r13
movq 0x10(%rbx,%r14,8), %rdi
movl %r15d, 0xfaf46(%rip)    # 0x1118e0
callq 0x250d0
callq 0x8b78
movl -0x2c(%rbp), %edi
movq -0x38(%rbp), %rsi
movq %r13, %rdx
movq %rax, %rcx
callq 0x16a21
testl %eax, %eax
jne 0x169ca
addq $0x3, %r14
cmpl -0x30(%rbp), %r14d
setl %r12b
jl 0x16976
jmp 0x169fc
testb $0x1, %r12b
je 0x169fc
movl -0x2c(%rbp), %eax
movl %eax, 0x238df(%rip)     # 0x3a2b8
movl %r14d, %eax
movq 0x8(%rbx,%rax,8), %rdi
movl $0x1, 0xfaef5(%rip)     # 0x1118e0
callq 0x250d0
callq 0x95e2
movl $0x1, %eax
jmp 0x169fe
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: integral_search_nib
int
integral_search_nib(int h, struct atom *F, struct atom *I, struct atom *C)
{
	int i, j;
	struct atom *p1;

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

		set_symbol(symbol(SA), stack[i], symbol(NIL));

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

			set_symbol(symbol(SB), stack[j], symbol(NIL));

			push(C);			// condition ok?
			evalf();
			p1 = pop();
			if (iszero(p1))
				continue;		// no, go to next j

			push(F);			// F = I?
			push(I);
			evalf();
			subtract();
			p1 = pop();
			if (iszero(p1))
				return 1;		// yes
		}
	}

	return 0;					// no
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, -0x50(%rbp)
movq %rsi, -0x48(%rbp)
xorl %eax, %eax
cmpl %edi, 0x23876(%rip)     # 0x3a2b8
jle 0x16b86
movq %rcx, %r14
movslq %edi, %r15
leaq 0x2cb6b(%rip), %rax     # 0x435c0
leaq (%rax,%r15,8), %rax
movq %rax, -0x38(%rbp)
leaq 0xf54ec(%rip), %r13     # 0x10bf50
movq %r15, -0x40(%rbp)
movl %edi, -0x2c(%rbp)
movq 0x2c85e(%rip), %rax     # 0x432d0
cmpb $0x3, 0x10(%rax)
jne 0x16b95
movq 0x29f7d(%rip), %rcx     # 0x40a00
leaq 0x2cb36(%rip), %rdx     # 0x435c0
movq (%rdx,%r15,8), %rdx
movl 0x8(%rax), %esi
leaq 0xf0058(%rip), %r8      # 0x106af0
movq %rdx, (%r8,%rsi,8)
movl 0x8(%rax), %eax
movq %rcx, (%r13,%rax,8)
cmpl %edi, 0x2380e(%rip)     # 0x3a2b8
jle 0x16b67
movq -0x38(%rbp), %r12
movq -0x40(%rbp), %rbx
movq 0x2c819(%rip), %rax     # 0x432d8
cmpb $0x3, 0x10(%rax)
jne 0x16b95
movq 0x29f30(%rip), %rcx     # 0x40a00
movq (%r12), %rdx
movl 0x8(%rax), %esi
leaq 0xf0012(%rip), %rdi     # 0x106af0
movq %rdx, (%rdi,%rsi,8)
movl 0x8(%rax), %eax
movq %rcx, (%r13,%rax,8)
movq %r14, %rdi
callq 0x8b01
callq 0x95e2
callq 0x8b78
movq %rax, %rdi
callq 0xaece
testl %eax, %eax
jne 0x16b50
movq -0x48(%rbp), %rdi
callq 0x8b01
movq -0x50(%rbp), %rdi
callq 0x8b01
callq 0x95e2
movq 0xfa8ca(%rip), %rdi     # 0x1113f0
callq 0x8b01
movl $0x2, %edi
callq 0xa8bb
movl $0x2, %edi
callq 0xa975
callq 0x8b78
movq %rax, %rdi
callq 0xaece
testl %eax, %eax
jne 0x16b81
incq %rbx
movslq 0x2375e(%rip), %rax     # 0x3a2b8
addq $0x8, %r12
cmpq %rax, %rbx
jl 0x16ab8
incq %r15
movslq 0x23747(%rip), %rax     # 0x3a2b8
cmpq %rax, %r15
movl -0x2c(%rbp), %edi
jl 0x16a6b
xorl %eax, %eax
jmp 0x16b86
movl $0x1, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x143de(%rip), %rdi     # 0x2af7a
callq 0x77c8
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: dependent
int
dependent(struct atom *f, struct atom *x)
{
	if (equal(f, x))
		return 1;

	// a user function with no arguments?

	if (isusersymbol(car(f)) && lengthf(f) == 1)
		return 1;

	while (iscons(f)) {
		if (dependent(car(f), x))
			return 1;
		f = cdr(f);
	}

	return 0;
}

// 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 0x8c79
movl $0x1, %ebx
testl %eax, %eax
je 0x16c3d
cmpb $0x1, 0x10(%r15)
setne %al
leaq 0x29e2e(%rip), %r12     # 0x40a00
movq %r15, %rcx
cmovneq %r12, %rcx
movq (%rcx), %rcx
cmpb $0x3, 0x10(%rcx)
setne %cl
orb %al, %cl
jne 0x16bff
movl $0x1, %eax
movq %r15, %rcx
movq 0x8(%rcx), %rcx
decl %eax
cmpb $0x1, 0x10(%rcx)
je 0x16bef
testl %eax, %eax
je 0x16c38
cmpb $0x1, 0x10(%r15)
jne 0x16c34
leaq 0x10(%r15), %r13
movq (%r15), %rdi
movq %r14, %rsi
callq 0x16ba1
testl %eax, %eax
jne 0x16c3d
addq $0x8, %r15
cmpb $0x1, (%r13)
cmovneq %r12, %r15
movq (%r15), %r15
leaq 0x10(%r15), %r13
cmpb $0x1, 0x10(%r15)
je 0x16c0a
xorl %ebx, %ebx
jmp 0x16c3d
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: 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
leaq 0x8(%rdi), %r12
movq %rdi, -0x30(%rbp)
cmpb $0x1, 0x10(%rdi)
leaq 0x29ac2(%rip), %r15     # 0x40a00
movq %r15, %rax
cmoveq %r12, %rax
movq %rsi, %rbx
movq (%rax), %r13
cmpb $0x1, 0x10(%r13)
jne 0x16fa1
leaq 0x10(%r13), %r14
movq (%r13), %rdi
movq %rbx, %rsi
callq 0x16ba1
testl %eax, %eax
je 0x16f86
cmpb $0x1, (%r14)
movq %r15, %rax
cmoveq %r13, %rax
movq (%rax), %rdi
callq 0x8b01
movq %rbx, %rdi
callq 0x8b01
callq 0x167e8
addq $0x8, %r13
cmpb $0x1, (%r14)
cmovneq %r15, %r13
movq (%r13), %r13
leaq 0x10(%r13), %r14
cmpb $0x1, 0x10(%r13)
je 0x16f56
movq -0x30(%rbp), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r15, %r12
movl 0x23304(%rip), %r14d    # 0x3a2b8
movq (%r12), %r12
cmpb $0x1, 0x10(%r12)
jne 0x17007
leaq 0x10(%r12), %r13
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x16ba1
testl %eax, %eax
jne 0x16fe9
cmpb $0x1, (%r13)
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rdi
callq 0x8b01
addq $0x8, %r12
cmpb $0x1, (%r13)
cmovneq %r15, %r12
movq (%r12), %r12
leaq 0x10(%r12), %r13
cmpb $0x1, 0x10(%r12)
je 0x16fc5
movl 0x232ab(%rip), %edi     # 0x3a2b8
subl %r14d, %edi
cmpl $0x2, %edi
jl 0x1703e
callq 0x8ad9
movq 0x2c287(%rip), %rdi     # 0x432a8
callq 0x8b01
callq 0xad38
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8b47
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: 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
callq 0x8b78
movq %rax, %rbx
cmpb $0x7, 0x10(%rax)
jne 0x170cb
movq (%rbx), %rax
cmpl $0x2, (%rax)
jne 0x170ea
movl 0x4(%rax), %ecx
cmpl 0x8(%rax), %ecx
jne 0x170ea
movq %rbx, %rdi
callq 0x8b01
callq 0xbac7
movq %rbx, %rdi
callq 0x8b01
callq 0xbd03
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xd9a4
movq %rbx, %rdi
callq 0x8b01
movq 0xfa316(%rip), %rdi     # 0x1113f0
callq 0x8b01
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa234
leaq 0x13752(%rip), %rdi     # 0x2a843
callq 0x77c8
// File: /workspace/github_c_makefile_star2_O1/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 0x298ee(%rip), %r14     # 0x40a00
movq %r14, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rax
movq (%rax), %rdi
callq 0x8b01
callq 0x95e2
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %r15
movq (%r15), %rax
leaq 0x8(%rax), %rcx
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rcx
movq (%rcx), %rbx
cmpb $0x1, 0x10(%rbx)
jne 0x17174
movq (%rbx), %rdi
callq 0x8b01
callq 0x95e2
callq 0x1717f
leaq 0x8(%rbx), %rax
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %rax
movq (%rax), %rbx
jmp 0x1714b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
callq 0x8b78
movq %rax, %rbx
cmpb $0x7, 0x10(%rax)
jne 0x1747a
movq %rbx, %rdi
callq 0x953d
movq %rax, %rbx
movq (%rax), %rax
movslq 0x64(%rax), %r14
testq %r14, %r14
jle 0x17475
xorl %r15d, %r15d
movq (%rbx), %rax
movq 0x68(%rax,%r15,8), %rdi
callq 0x8b01
callq 0x1741c
callq 0x8b78
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r15,8)
incq %r15
cmpq %r15, %r14
jne 0x1744e
movq %rbx, %rdi
jmp 0x174c3
movq %rbx, %rdi
callq 0x8b01
callq 0xa7fa
callq 0x8b78
movb 0x10(%rax), %cl
andb $-0x2, %cl
cmpb $0x4, %cl
jne 0x174d2
movq %rax, %rdi
callq 0x8b01
callq 0x9086
callq 0x7200
movsd %xmm0, -0x20(%rbp)
callq 0x74ec
movb $0x5, 0x10(%rax)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8b01
movq 0x28eef(%rip), %rdi     # 0x403c8
callq 0x8b01
movq %rbx, %rdi
callq 0x8b01
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8ad9
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: 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 0xef367(%rip), %r14d    # 0x106ae8
movl $0x0, 0xef35d(%rip)     # 0x106ae8
cmpb $0x1, 0x10(%rdi)
jne 0x17801
movq %rdi, %rbx
movl $0x1, %eax
movq %rdi, %rcx
movq 0x8(%rcx), %rcx
decl %eax
cmpb $0x1, 0x10(%rcx)
je 0x1779c
testl %eax, %eax
je 0x17801
leaq 0x8(%rbx), %r15
leaq 0x29249(%rip), %r12     # 0x40a00
cmpb $0x1, 0x10(%rbx)
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %r13
cmpb $0x1, 0x10(%r13)
jne 0x177b7
movq (%r13), %rdi
callq 0x8b01
callq 0x95ac
callq 0x8b78
leaq 0x8(%r13), %rax
cmpb $0x1, 0x10(%r13)
cmovneq %r12, %rax
movl 0xf9bce(%rip), %ecx     # 0x1113c0
orl 0xef2f0(%rip), %ecx     # 0x106ae8
je 0x177c2
movl %r14d, 0xef2e7(%rip)    # 0x106ae8
movq 0x291f8(%rip), %rdi     # 0x40a00
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8b01
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: 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), %r12
cmpb $0x1, 0x10(%rdi)
leaq 0x28f12(%rip), %r15     # 0x40a00
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x8b01
callq 0x95e2
callq 0x8b78
cmpb $0x1, 0x10(%r14)
movq %r15, %rcx
cmoveq %r12, %rcx
movq %rax, %rbx
movq (%rcx), %rax
movb 0x10(%rax), %cl
addq $0x8, %rax
cmpb $0x1, %cl
movq %r15, %rdx
cmoveq %rax, %rdx
movq (%rdx), %rdx
cmpb $0x1, 0x10(%rdx)
movq %r15, %rdx
jne 0x17b52
cmpb $0x1, %cl
leaq 0x28eb5(%rip), %rcx     # 0x40a00
cmoveq %rax, %rcx
movq (%rcx), %rdx
movq (%rdx), %rdi
callq 0x8b01
callq 0x95e2
callq 0xeb5b
cmpb $0x1, 0x10(%r14)
cmovneq %r15, %r12
movl %eax, %r14d
movq (%r12), %rax
movb 0x10(%rax), %cl
addq $0x8, %rax
cmpb $0x1, %cl
movq %r15, %rdx
cmoveq %rax, %rdx
movq (%rdx), %rdx
cmpb $0x1, 0x10(%rdx)
movq %r15, %rdx
jne 0x17ba6
cmpb $0x1, %cl
leaq 0x28e65(%rip), %rdx     # 0x40a00
cmoveq %rax, %rdx
movq (%rdx), %rdx
addq $0x8, %rdx
movq (%rdx), %rdx
cmpb $0x1, 0x10(%rdx)
jne 0x17be1
cmpb $0x1, %cl
leaq 0x28e47(%rip), %rdx     # 0x40a00
movq %rdx, %rsi
cmoveq %rax, %rsi
movq (%rsi), %rsi
cmpb $0x1, 0x10(%rsi)
jne 0x17bde
cmpb $0x1, %cl
leaq 0x28e2d(%rip), %rcx     # 0x40a00
cmoveq %rax, %rcx
movq (%rcx), %rdx
addq $0x8, %rdx
movq (%rdx), %r15
movq (%r15), %rdi
callq 0x8b01
callq 0x95e2
callq 0xeb5b
cmpb $0x7, 0x10(%rbx)
jne 0x17c45
movl %eax, %r15d
movq (%rbx), %rax
cmpl $0x2, (%rax)
jne 0x17c45
movl 0x4(%rax), %ecx
cmpl 0x8(%rax), %ecx
jne 0x17c45
testl %r14d, %r14d
jle 0x17c45
movq (%rbx), %rax
cmpl 0x4(%rax), %r14d
jg 0x17c45
testl %r15d, %r15d
js 0x17c45
cmpl 0x8(%rax), %r15d
jg 0x17c45
movq %rbx, %rdi
callq 0x8b01
movl %r14d, %edi
movl %r15d, %esi
callq 0xeba4
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xbd03
leaq 0x12c1d(%rip), %rdi     # 0x2a869
callq 0x77c8
// File: /workspace/github_c_makefile_star2_O1/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), %r12
cmpb $0x1, 0x10(%rdi)
leaq 0x28d92(%rip), %r15     # 0x40a00
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x8b01
callq 0x95e2
callq 0x8b78
cmpb $0x1, 0x10(%r14)
movq %r15, %rcx
cmoveq %r12, %rcx
movq %rax, %rbx
movq (%rcx), %rax
movb 0x10(%rax), %cl
addq $0x8, %rax
cmpb $0x1, %cl
movq %r15, %rdx
cmoveq %rax, %rdx
movq (%rdx), %rdx
cmpb $0x1, 0x10(%rdx)
movq %r15, %rdx
jne 0x17cd2
cmpb $0x1, %cl
leaq 0x28d35(%rip), %rcx     # 0x40a00
cmoveq %rax, %rcx
movq (%rcx), %rdx
movq (%rdx), %rdi
callq 0x8b01
callq 0x95e2
callq 0xeb5b
cmpb $0x1, 0x10(%r14)
cmovneq %r15, %r12
movl %eax, %r14d
movq (%r12), %rax
movb 0x10(%rax), %cl
addq $0x8, %rax
cmpb $0x1, %cl
movq %r15, %rdx
cmoveq %rax, %rdx
movq (%rdx), %rdx
cmpb $0x1, 0x10(%rdx)
movq %r15, %rdx
jne 0x17d26
cmpb $0x1, %cl
leaq 0x28ce5(%rip), %rdx     # 0x40a00
cmoveq %rax, %rdx
movq (%rdx), %rdx
addq $0x8, %rdx
movq (%rdx), %rdx
cmpb $0x1, 0x10(%rdx)
jne 0x17d61
cmpb $0x1, %cl
leaq 0x28cc7(%rip), %rdx     # 0x40a00
movq %rdx, %rsi
cmoveq %rax, %rsi
movq (%rsi), %rsi
cmpb $0x1, 0x10(%rsi)
jne 0x17d5e
cmpb $0x1, %cl
leaq 0x28cad(%rip), %rcx     # 0x40a00
cmoveq %rax, %rcx
movq (%rcx), %rdx
addq $0x8, %rdx
movq (%rdx), %r15
movq (%r15), %rdi
callq 0x8b01
callq 0x95e2
callq 0xeb5b
cmpb $0x7, 0x10(%rbx)
jne 0x17dc4
movl %eax, %r15d
movq (%rbx), %rax
cmpl $0x2, (%rax)
jne 0x17dc4
testl %r14d, %r14d
jle 0x17db8
movq (%rbx), %rax
cmpl 0x4(%rax), %r14d
jg 0x17db8
testl %r15d, %r15d
js 0x17db8
cmpl 0x8(%rax), %r15d
jg 0x17db8
movq %rbx, %rdi
callq 0x8b01
movl %r14d, %edi
movl %r15d, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xeba4
leaq 0x12acd(%rip), %rdi     # 0x2a88c
callq 0x77c8
leaq 0x12aa4(%rip), %rdi     # 0x2a86f
callq 0x77c8
// File: /workspace/github_c_makefile_star2_O1/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 0x28c14(%rip), %r14     # 0x40a00
movq %r14, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rax
movq (%rax), %rdi
callq 0x8b01
callq 0x95e2
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %r15
movq (%r15), %rax
movb 0x10(%rax), %cl
addq $0x8, %rax
cmpb $0x1, %cl
movq %r14, %rdx
cmoveq %rax, %rdx
movq (%rdx), %rdx
cmpb $0x1, 0x10(%rdx)
jne 0x17e41
cmpb $0x1, %cl
leaq 0x28bc6(%rip), %rcx     # 0x40a00
cmoveq %rax, %rcx
movq (%rcx), %r14
movq (%r14), %rdi
callq 0x8b01
callq 0x95e2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xf98a
// File: /workspace/github_c_makefile_star2_O1/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 0x17ea3
movq 0x8(%r14), %rax
cmpl $0x1, -0x4(%rax)
jne 0x17ea3
cmpl $0x1, (%rax)
jne 0x17ea3
cmpb $0x4, 0x10(%rbx)
jne 0x17ea3
movq 0x8(%rbx), %rax
cmpl $0x1, -0x4(%rax)
jne 0x17ea3
cmpl $0x1, (%rax)
jne 0x17ea3
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x17f1f
movq %r14, %rdi
callq 0x8b01
movq %r14, %rdi
callq 0x8b01
movq %rbx, %rdi
callq 0x8b01
movq 0xf952e(%rip), %rdi     # 0x1113f0
callq 0x8b01
callq 0xa234
movl $0x2, %edi
callq 0xa8bb
callq 0x9be7
callq 0x13eac
movq %rbx, %rdi
callq 0x8b01
movl $0x2, %edi
callq 0xa8bb
movb 0x12(%r14), %al
cmpb 0x12(%rbx), %al
jne 0x17f11
movq 0xf94ee(%rip), %rdi     # 0x1113f0
callq 0x8b01
movl $0x2, %edi
callq 0xa8bb
movl $0x2, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0xa975
// File: /workspace/github_c_makefile_star2_O1/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 0xeeb6c(%rip)           # 0x106ad0
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rax
leaq 0x28a8d(%rip), %r14     # 0x40a00
cmovneq %r14, %rax
movl 0x2233b(%rip), %ebx     # 0x3a2b8
movq (%rax), %r15
cmpb $0x1, 0x10(%r15)
jne 0x17fa3
movq (%r15), %rdi
callq 0x8b01
callq 0x95ac
leaq 0x8(%r15), %rax
cmpb $0x1, 0x10(%r15)
cmovneq %r14, %rax
jmp 0x17f7d
movl 0x2230f(%rip), %edi     # 0x3a2b8
subl %ebx, %edi
callq 0xa8bb
incl 0xeeb1a(%rip)           # 0x106ad0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x222e3(%rip), %ebx     # 0x3a2b8
cmpl %edi, %ebx
jle 0x18064
movslq %edi, %r14
leaq 0x2b5d9(%rip), %r15     # 0x435c0
leaq 0x28a12(%rip), %r12     # 0x40a00
movq (%r15,%r14,8), %rax
movb 0x10(%rax), %cl
cmpb $0x1, %cl
movq %r12, %rdx
cmoveq %rax, %rdx
movq (%rdx), %rdx
cmpq 0x2b29f(%rip), %rdx     # 0x432a8
jne 0x1805c
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 0x18055
movq (%r13), %rdi
callq 0x8b01
leaq 0x8(%r13), %rax
cmpb $0x1, 0x10(%r13)
cmovneq %r12, %rax
movq (%rax), %r13
cmpb $0x1, 0x10(%r13)
je 0x1803c
incq %r14
cmpl %r14d, %ebx
jne 0x17fee
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: 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 %rbx
pushq %rax
movl %edi, %ebx
movq 0x2897a(%rip), %rdi     # 0x40a00
cmpl %ebx, 0x2222c(%rip)     # 0x3a2b8
jle 0x180de
leaq 0x2b52b(%rip), %r15     # 0x435c0
movslq %ebx, %rax
movq (%r15,%rax,8), %r14
cmpb $0x7, 0x10(%r14)
jne 0x180d4
cmpb $0x7, 0x10(%rdi)
jne 0x180c3
callq 0x8b01
movq %r14, %rdi
callq 0x8b01
callq 0x1447d
callq 0x8b78
movq %rax, %r14
movl %ebx, %edi
movl $0x1, %esi
callq 0xadfc
decl %ebx
movq %r14, %rdi
incl %ebx
cmpl 0x221dc(%rip), %ebx     # 0x3a2b8
jl 0x18095
movq %rdi, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xee9dc(%rip), %rsi     # 0x106ad8
callq 0x18222
movq %rax, %r14
movq %rax, %rdi
callq 0xaece
testl %eax, %eax
jne 0x181c0
cmpl %ebx, 0x2219e(%rip)     # 0x3a2b8
je 0x181c0
movl %ebx, %edi
callq 0x18286
movl %ebx, %edi
callq 0x182f9
movl %ebx, %edi
callq 0x18286
movl %ebx, %edi
callq 0x182f9
movl %ebx, %edi
movq %r14, %rsi
callq 0x18222
movq %rax, %r14
movq %rax, %rdi
callq 0xaece
testl %eax, %eax
jne 0x181c0
cmpl %ebx, 0x2215d(%rip)     # 0x3a2b8
je 0x181c0
movl %ebx, %edi
movq %r14, %rsi
callq 0x1844b
movq %rax, %r14
cmpb $0x5, 0x10(%rax)
je 0x18186
movq %r14, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0xcb82
testl %eax, %eax
jne 0x1818e
movq %r14, %rdi
callq 0x8b01
cmpl $0x0, 0xee93b(%rip)     # 0x106ad0
je 0x1819e
movl %ebx, %edi
callq 0x1848d
movslq 0x22113(%rip), %rax     # 0x3a2b8
movslq %ebx, %rcx
movq %rax, %rbx
subq %rcx, %rbx
cmpl $0x1, %ebx
je 0x181d2
testl %ebx, %ebx
jne 0x181d7
movq 0xee91a(%rip), %rdi     # 0x106ad8
jmp 0x181c9
movl %ebx, 0x220f2(%rip)     # 0x3a2b8
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x8b01
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x2b3e2(%rip), %rcx     # 0x435c0
leaq (%rcx,%rax,8), %rdi
leaq (,%rbx,8), %rax
subq %rax, %rdi
leaq 0x6b6(%rip), %rcx       # 0x188aa
movl $0x8, %edx
movq %rbx, %rsi
callq 0x70a0
movl %ebx, %edi
callq 0x8ad9
movq 0x2b099(%rip), %rdi     # 0x432a8
callq 0x8b01
callq 0xad38
popq %rbx
popq %r14
popq %rbp
jmp 0x8b47
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
movq %rsi, %r14
cmpl %edi, 0x22083(%rip)     # 0x3a2b8
jle 0x18278
movl %edi, %ebx
leaq 0x2b380(%rip), %r15     # 0x435c0
movslq %ebx, %rax
movq (%r15,%rax,8), %rsi
movb 0x10(%rsi), %al
andb $-0x2, %al
cmpb $0x4, %al
jne 0x1826e
movq %r14, %rdi
callq 0x18620
callq 0x8b78
movq %rax, %r14
movl %ebx, %edi
movl $0x1, %esi
callq 0xadfc
decl %ebx
incl %ebx
cmpl 0x22042(%rip), %ebx     # 0x3a2b8
jl 0x18240
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2b327(%rip), %rax     # 0x435c0
leaq (%rax,%r14,8), %rdi
movslq 0x22014(%rip), %rsi     # 0x3a2b8
subq %r14, %rsi
leaq 0x57e(%rip), %rcx       # 0x1882c
movl $0x8, %edx
callq 0x70a0
movl 0x21ffa(%rip), %eax     # 0x3a2b8
decl %eax
cmpl %r14d, %eax
jle 0x182f4
leal 0x1(%rbx), %r14d
movl %ebx, %edi
movl %r14d, %esi
callq 0x186b7
testl %eax, %eax
je 0x182e6
movl %r14d, %edi
movl $0x1, %esi
callq 0xadfc
decl %ebx
incl %ebx
movl 0x21fca(%rip), %eax     # 0x3a2b8
decl %eax
cmpl %eax, %ebx
jl 0x182c5
popq %rbx
popq %r14
popq %rbp
retq