LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
callq 0x868d
movq %rax, %rbx
callq 0x868d
movq %rax, %r14
movl 0x24000(%rip), %eax     # 0x382a8
movl %eax, -0x2c(%rbp)
leaq 0x8(%r14), %r12
cmpb $0x1, 0x10(%r14)
leaq 0x2a735(%rip), %r15     # 0x3e9f0
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %r13
cmpb $0x1, 0x10(%r13)
jne 0x142ff
movq (%r13), %rdi
movq %rbx, %rsi
callq 0x14b61
testl %eax, %eax
jne 0x142f0
cmpb $0x1, 0x10(%r13)
movq %r15, %rax
cmoveq %r13, %rax
movq (%rax), %rdi
callq 0x861b
leaq 0x8(%r13), %rax
cmpb $0x1, 0x10(%r13)
cmovneq %r15, %rax
jmp 0x142c2
movl 0x23fa3(%rip), %edi     # 0x382a8
subl -0x2c(%rbp), %edi
jne 0x14314
pushq $0x1
popq %rdi
callq 0xa426
jmp 0x14334
cmpl $0x2, %edi
jl 0x14334
callq 0x85eb
movq 0x2cf73(%rip), %rdi     # 0x41298
callq 0x861b
callq 0xa49b
callq 0x865c
movl 0x23f6d(%rip), %r13d    # 0x382a8
cmpb $0x1, 0x10(%r14)
cmovneq %r15, %r12
movq (%r12), %r14
cmpb $0x1, 0x10(%r14)
jne 0x14378
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x14b61
testl %eax, %eax
je 0x14372
cmpb $0x1, 0x10(%r14)
movq %r15, %rax
cmoveq %r14, %rax
movq (%rax), %rdi
callq 0x861b
leaq 0x8(%r14), %r12
jmp 0x1433b
movl 0x23f2a(%rip), %edi     # 0x382a8
subl %r13d, %edi
jne 0x14399
pushq $0x1
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa426
cmpl $0x2, %edi
jl 0x143c7
callq 0x85eb
movq 0x2ceee(%rip), %rdi     # 0x41298
callq 0x861b
callq 0xa49b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x865c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: 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 0x2a605(%rip), %rax     # 0x3e9f0
cmoveq %rdi, %rax
movq %rsi, %r14
movq (%rax), %rax
cmpq 0x2967c(%rip), %rax     # 0x3da78
je 0x14459
cmpq 0x286cb(%rip), %rax     # 0x3cad0
je 0x14468
movq 0x2ceb2(%rip), %rdi     # 0x412c0
callq 0xd63f
movq 0x2ceae(%rip), %rdi     # 0x412c8
callq 0xd63f
movq 0x2ceaa(%rip), %rdi     # 0x412d0
callq 0xd63f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1473b
callq 0x868d
movq %rax, %rbx
callq 0xd684
callq 0xd684
callq 0xd684
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x861b
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x14477
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x145fe
// File: /workspace/github_c_makefile_star2_O2/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, %r15
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rcx
leaq 0x2a55c(%rip), %rax     # 0x3e9f0
cmovneq %rax, %rcx
movq %rsi, %r14
movq (%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0x144b3
movq (%rcx), %r12
movq 0x8(%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
je 0x144c3
jmp 0x144c6
movq 0x2a536(%rip), %rcx     # 0x3e9f0
cmpb $0x1, 0x10(%rcx)
movq %rcx, %r12
jne 0x144c6
movq %rcx, %rax
movq (%rax), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8760
testl %eax, %eax
je 0x1452f
movq %r12, %rdi
callq 0x861b
movq %r14, %rdi
callq 0x861b
callq 0xef62
callq 0x868d
movb 0x10(%rax), %dl
cmpb $0x1, %dl
leaq 0x2a4f1(%rip), %rcx     # 0x3e9f0
movq %rcx, %rsi
cmoveq %rax, %rsi
movq 0x2956b(%rip), %rdi     # 0x3da78
cmpq %rdi, (%rsi)
je 0x14553
movq %rax, %rdi
callq 0x861b
movq %rbx, %rdi
callq 0x861b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xef62
movq 0x29542(%rip), %rdi     # 0x3da78
callq 0x861b
movq %r15, %rdi
callq 0x861b
movq %r14, %rdi
callq 0x861b
pushq $0x3
popq %rdi
jmp 0x145f1
addq $0x8, %rax
cmpb $0x1, %dl
cmovneq %rcx, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
jne 0x14576
movq (%rax), %r15
movq 0x8(%rax), %rax
cmpb $0x1, 0x10(%rax)
je 0x14586
jmp 0x14589
movq 0x2a473(%rip), %rax     # 0x3e9f0
cmpb $0x1, 0x10(%rax)
movq %rax, %r15
jne 0x14589
movq %rax, %rcx
movq (%rcx), %r14
callq 0x861b
movq 0x294e0(%rip), %rdi     # 0x3da78
callq 0x861b
movq %r15, %rdi
callq 0x861b
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8760
testl %eax, %eax
js 0x145d2
movq %rbx, %rdi
callq 0x861b
pushq $0x3
popq %rbx
movl %ebx, %edi
callq 0x85eb
movq %r14, %rdi
callq 0x861b
movl %ebx, %edi
jmp 0x145f1
movq %r14, %rdi
callq 0x861b
pushq $0x3
popq %r14
movl %r14d, %edi
callq 0x85eb
movq %rbx, %rdi
callq 0x861b
movl %r14d, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x85eb
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: 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
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rcx
leaq 0x2a3d8(%rip), %rax     # 0x3e9f0
cmovneq %rax, %rcx
movq %rsi, %r14
movq (%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0x14637
movq (%rcx), %r15
movq 0x8(%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
je 0x14647
jmp 0x1464a
movq 0x2a3b2(%rip), %rcx     # 0x3e9f0
cmpb $0x1, 0x10(%rcx)
movq %rcx, %r15
jne 0x1464a
movq %rcx, %rax
movq (%rax), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8760
movl %eax, %r12d
movq %r15, %rdi
callq 0x861b
testl %r12d, %r12d
je 0x146b7
movq %r14, %rdi
callq 0x861b
callq 0xef62
callq 0x868d
movb 0x10(%rax), %dl
cmpb $0x1, %dl
leaq 0x2a369(%rip), %rcx     # 0x3e9f0
movq %rcx, %rsi
cmoveq %rax, %rsi
movq 0x293e3(%rip), %rdi     # 0x3da78
cmpq %rdi, (%rsi)
je 0x146c0
movq %rax, %rdi
callq 0x861b
movq %rbx, %rdi
callq 0x861b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xf24a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
addq $0x8, %rax
cmpb $0x1, %dl
cmovneq %rcx, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
jne 0x146e3
movq (%rax), %r14
movq 0x8(%rax), %rax
cmpb $0x1, 0x10(%rax)
je 0x146f3
jmp 0x146f6
movq 0x2a306(%rip), %rax     # 0x3e9f0
cmpb $0x1, 0x10(%rax)
movq %rax, %r14
jne 0x146f6
movq %rax, %rcx
movq (%rcx), %r15
callq 0x861b
movq 0x283cb(%rip), %rdi     # 0x3cad0
callq 0x861b
movq %r14, %rdi
callq 0x861b
movq %rbx, %rdi
callq 0x861b
pushq $0x3
popq %rbx
movl %ebx, %edi
callq 0x85eb
movq %r15, %rdi
callq 0x861b
movl %ebx, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x85eb
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: 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 %rsi, %rbx
movq %rdi, %r14
movq 0x2cb7d(%rip), %rdi     # 0x412d0
movq 0x2a296(%rip), %rdx     # 0x3e9f0
callq 0x12721
movl 0x23b42(%rip), %r15d    # 0x382a8
pushq $0x1
popq %rdi
callq 0xa426
movq %r14, %rdi
callq 0x861b
movq %rbx, %rdi
callq 0x861b
callq 0x14878
movq %r14, %rdi
callq 0x14946
movl %eax, %r12d
testb $0x1, %r12b
je 0x147b3
leaq 0x1ca45(%rip), %rdx     # 0x311e0
movl %r15d, %edi
movq %r14, %rsi
movl $0xab, %ecx
callq 0x149c1
testl %eax, %eax
jne 0x1483c
testb $0x2, %r12b
je 0x147d2
leaq 0x1cf80(%rip), %rdx     # 0x31740
pushq $0x21
popq %rcx
movl %r15d, %edi
movq %r14, %rsi
callq 0x149c1
testl %eax, %eax
jne 0x1483c
cmpl $0x4, %r12d
jb 0x147f3
leaq 0x1d071(%rip), %rdx     # 0x31850
movl %r15d, %edi
movq %r14, %rsi
movl $0xba, %ecx
callq 0x149c1
testl %eax, %eax
jne 0x1483c
cmpb $0x1, 0x10(%r14)
leaq 0x2a1f1(%rip), %rax     # 0x3e9f0
cmoveq %r14, %rax
movq (%rax), %rax
cmpq 0x2ca93(%rip), %rax     # 0x412a0
je 0x14823
leaq 0x1d87a(%rip), %rdx     # 0x32090
movl %r15d, %edi
movq %r14, %rsi
movl $0xbd, %ecx
jmp 0x14833
leaq 0x1d5f6(%rip), %rdx     # 0x31e20
pushq $0x4e
popq %rcx
movl %r15d, %edi
movq %r14, %rsi
callq 0x149c1
testl %eax, %eax
je 0x14845
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %r15d, 0x23a5c(%rip)    # 0x382a8
movq 0x29225(%rip), %rdi     # 0x3da78
callq 0x861b
movq %r14, %rdi
callq 0x861b
movq %rbx, %rdi
callq 0x861b
pushq $0x3
popq %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x85eb
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: 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 0x868d
movq %rax, %rbx
callq 0x868d
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x14b61
testl %eax, %eax
je 0x148ff
cmpb $0x1, 0x10(%r14)
leaq 0x2a143(%rip), %r15     # 0x3e9f0
movq %r14, %rcx
cmovneq %r15, %rcx
sete %al
movq (%rcx), %rcx
cmpq 0x2c9cf(%rip), %rcx     # 0x41290
je 0x1491c
cmpq 0x2c9ce(%rip), %rcx     # 0x41298
je 0x14931
addq $0x8, %r14
testb $0x1, %al
cmoveq %r15, %r14
movq (%r14), %r14
cmpb $0x1, 0x10(%r14)
jne 0x14911
movq (%r14), %rdi
callq 0x861b
movq %rbx, %rdi
callq 0x861b
callq 0x14878
cmpb $0x1, 0x10(%r14)
sete %al
jmp 0x148cc
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x861b
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 0x14beb
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x14e6c
// File: /workspace/github_c_makefile_star2_O2/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 0x14973
xorl %r14d, %r14d
movb $0x1, %al
cmpb $0x1, %al
jne 0x149b9
movq (%rbx), %rdi
callq 0x14946
orl %eax, %r14d
movq 0x8(%rbx), %rbx
movb 0x10(%rbx), %al
jmp 0x1495b
cmpq %rbx, 0x2c93e(%rip)     # 0x412b8
je 0x149b1
cmpq %rbx, 0x29a3d(%rip)     # 0x3e3c0
je 0x149b5
cmpq %rbx, 0x2b024(%rip)     # 0x3f9b0
sete %al
cmpq %rbx, 0x27e4a(%rip)     # 0x3c7e0
sete %cl
orb %al, %cl
cmpq %rbx, 0x2b31e(%rip)     # 0x3fcc0
sete %al
orb %cl, %al
movzbl %al, %r14d
shll $0x2, %r14d
jmp 0x149b9
pushq $0x1
jmp 0x149b7
pushq $0x2
popq %r14
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
movq %rdx, %r14
movq %rsi, -0x30(%rbp)
movl %edi, %r15d
movslq %ecx, %rbx
xorl %r12d, %r12d
cmpq %rbx, %r12
jge 0x14a20
movq (%r14,%r12,8), %rdi
callq 0x14a4c
callq 0x868d
movq %rax, %r13
movq 0x10(%r14,%r12,8), %rdi
callq 0x14a4c
callq 0x868d
movl %r15d, %edi
movq -0x30(%rbp), %rsi
movq %r13, %rdx
movq %rax, %rcx
callq 0x14a60
testl %eax, %eax
jne 0x14a24
addq $0x3, %r12
jmp 0x149df
xorl %eax, %eax
jmp 0x14a3d
movl %r15d, 0x2387d(%rip)    # 0x382a8
movq 0x8(%r14,%r12,8), %rdi
callq 0x14a4c
callq 0x8fbb
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: 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 $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movslq %edi, %rcx
movl 0x23825(%rip), %eax     # 0x382a8
leaq 0x2cb26(%rip), %rdx     # 0x415b0
leaq (%rdx,%rcx,8), %rdx
movq %rdx, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
cltq
cmpq %rax, %rcx
jge 0x14b5d
movq 0x2c818(%rip), %rdi     # 0x412c0
leaq 0x2cb01(%rip), %rax     # 0x415b0
movq %rcx, -0x40(%rbp)
movq (%rax,%rcx,8), %rsi
movq 0x29f32(%rip), %rdx     # 0x3e9f0
callq 0x12721
movq -0x30(%rbp), %r14
movq -0x38(%rbp), %r13
movslq 0x237d6(%rip), %rax     # 0x382a8
cmpq %rax, %r13
jge 0x14b3f
movq 0x2c7ea(%rip), %rdi     # 0x412c8
movq (%r14), %rsi
movq 0x29f08(%rip), %rdx     # 0x3e9f0
callq 0x12721
movq %rbx, %rdi
callq 0x861b
callq 0x8fbb
callq 0x868d
movq %rax, %rdi
callq 0xa641
testl %eax, %eax
jne 0x14b36
movq %r12, %rdi
callq 0x861b
movq %r15, %rdi
callq 0x861b
callq 0x8fbb
callq 0xb07f
callq 0x868d
movq %rax, %rdi
callq 0xa641
testl %eax, %eax
jne 0x14b4b
incq %r13
addq $0x8, %r14
jmp 0x14acb
movq -0x40(%rbp), %rcx
incq %rcx
jmp 0x14a96
pushq $0x1
popq %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x14b4e
// File: /workspace/github_c_makefile_star2_O2/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 0x8760
pushq $0x1
popq %rbx
testl %eax, %eax
je 0x14bda
movb 0x10(%r15), %r13b
cmpb $0x1, %r13b
leaq 0x29e60(%rip), %r12     # 0x3e9f0
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x3, 0x10(%rax)
jne 0x14bad
movq %r15, %rdi
callq 0x86c3
cmpl $0x1, %eax
je 0x14bda
cmpb $0x1, %r13b
jne 0x14bd8
movq (%r15), %rdi
movq %r14, %rsi
callq 0x14b61
testl %eax, %eax
jne 0x14bda
leaq 0x8(%r15), %rax
cmpb $0x1, 0x10(%r15)
cmovneq %r12, %rax
movq (%rax), %r15
movb 0x10(%r15), %r13b
jmp 0x14bad
xorl %ebx, %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_O2/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
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %r15
cmpb $0x1, 0x10(%rdi)
leaq 0x29b61(%rip), %r12     # 0x3e9f0
movq %r12, %r13
cmoveq %r15, %r13
movq (%r13), %r13
cmpb $0x1, 0x10(%r13)
jne 0x14ee4
movq (%r13), %rdi
movq %rbx, %rsi
callq 0x14b61
testl %eax, %eax
je 0x14ed2
cmpb $0x1, 0x10(%r13)
movq %r12, %rax
cmoveq %r13, %rax
movq (%rax), %rdi
callq 0x861b
movq %rbx, %rdi
callq 0x861b
callq 0x14878
cmpb $0x1, 0x10(%r13)
je 0x14ede
movq %r12, %r13
jmp 0x14e96
addq $0x8, %r13
jmp 0x14e96
cmpb $0x1, 0x10(%r14)
movl 0x233b8(%rip), %r14d    # 0x382a8
leaq 0x29af9(%rip), %r12     # 0x3e9f0
cmovneq %r12, %r15
movq (%r15), %r13
cmpb $0x1, 0x10(%r13)
jne 0x14f34
movq (%r13), %rdi
movq %rbx, %rsi
callq 0x14b61
testl %eax, %eax
jne 0x14f29
cmpb $0x1, 0x10(%r13)
movq %r12, %rax
cmoveq %r13, %rax
movq (%rax), %rdi
callq 0x861b
leaq 0x8(%r13), %r15
cmpb $0x1, 0x10(%r13)
jmp 0x14ef7
movl 0x2336e(%rip), %edi     # 0x382a8
subl %r14d, %edi
cmpl $0x2, %edi
jl 0x14f6b
callq 0x85eb
movq 0x2c34a(%rip), %rdi     # 0x41298
callq 0x861b
callq 0xa49b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x865c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: 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 0x868d
movq %rax, %rbx
cmpb $0x7, 0x10(%rax)
jne 0x14ff4
movq %rbx, %rdi
callq 0xb291
testl %eax, %eax
je 0x15007
movq %rbx, %rdi
callq 0x861b
callq 0xb0c3
movq %rbx, %rdi
callq 0x861b
callq 0xb2b2
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xca0b
movq %rbx, %rdi
callq 0x861b
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa03a
leaq 0x1288d(%rip), %rdi     # 0x2789b
callq 0x7756
// File: /workspace/github_c_makefile_star2_O2/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 0x299c1(%rip), %r14     # 0x3e9f0
movq %r14, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rax
movq (%rax), %rdi
callq 0x861b
callq 0x8fbb
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %r15
movq (%r15), %rbx
leaq 0x8(%rbx), %rax
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %rax
movq (%rax), %rbx
cmpb $0x1, 0x10(%rbx)
jne 0x15082
movq (%rbx), %rdi
callq 0x861b
callq 0x8fbb
callq 0x1508d
jmp 0x15059
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: 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 0x868d
movq %rax, %rbx
cmpb $0x7, 0x10(%rax)
jne 0x15364
movq %rbx, %rdi
callq 0x8f1b
movq %rax, %rbx
movq (%rax), %rax
movl 0x64(%rax), %r14d
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
cmpq %r15, %r14
je 0x153a2
movq (%rbx), %rax
movq 0x68(%rax,%r15,8), %rdi
callq 0x861b
callq 0x15307
callq 0x868d
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r15,8)
incq %r15
jmp 0x1533b
movq %rbx, %rdi
callq 0x861b
callq 0x9fbd
callq 0x868d
movb 0x10(%rax), %cl
andb $-0x2, %cl
cmpb $0x4, %cl
jne 0x153b4
movq %rax, %rdi
callq 0x861b
callq 0x8ae1
callq 0x7200
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xaf59
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x861b
movq 0x28ffd(%rip), %rdi     # 0x3e3b8
callq 0x861b
movq %rbx, %rdi
callq 0x861b
pushq $0x2
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x85eb
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: factor_factor
void
factor_factor(void)
{
	uint32_t *numer, *denom;
	struct atom *INPUT, *BASE, *EXPO;

	INPUT = pop();

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

		BASE = cadr(INPUT);
		EXPO = caddr(INPUT);

		if (!isrational(BASE) || !isrational(EXPO)) {
			push(INPUT); // cannot factor
			return;
		}

		if (isminusone(BASE)) {
			push(INPUT); // -1 to the M
			return;
		}

		if (isnegativenumber(BASE)) {
			push_symbol(POWER);
			push_integer(-1);
			push(EXPO);
			list(3); // leave on stack
		}

		numer = BASE->u.q.a;
		denom = BASE->u.q.b;

		if (!MEQUAL(numer, 1))
			factor_bignum(numer, EXPO);

		if (!MEQUAL(denom, 1)) {
			// flip sign of exponent
			push(EXPO);
			negate();
			EXPO = pop();
			factor_bignum(denom, EXPO);
		}

		return;
	}

	if (!isrational(INPUT) || iszero(INPUT) || isplusone(INPUT) || isminusone(INPUT)) {
		push(INPUT);
		return;
	}

	if (isnegativenumber(INPUT))
		push_integer(-1);

	numer = INPUT->u.q.a;
	denom = INPUT->u.q.b;

	if (!MEQUAL(numer, 1))
		factor_bignum(numer, one);

	if (!MEQUAL(denom, 1))
		factor_bignum(denom, minusone);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
callq 0x868d
movq %rax, %rbx
movb 0x10(%rax), %cl
cmpb $0x1, %cl
leaq 0x295c1(%rip), %rax     # 0x3e9f0
movq %rax, %rdx
cmoveq %rbx, %rdx
movq 0x2be63(%rip), %r14     # 0x412a0
cmpq %r14, (%rdx)
je 0x154cf
cmpb $0x4, %cl
jne 0x15526
movq %rbx, %rdi
callq 0xa641
testl %eax, %eax
jne 0x15526
movq %rbx, %rdi
callq 0xa95a
testl %eax, %eax
jne 0x15526
movq %rbx, %rdi
callq 0xbfac
testl %eax, %eax
jne 0x15526
movq %rbx, %rdi
callq 0x8c2a
testl %eax, %eax
je 0x15493
pushq $-0x1
popq %rdi
callq 0xa426
movq (%rbx), %rdi
movq 0x8(%rbx), %rbx
cmpl $0x1, -0x4(%rdi)
jne 0x154a5
cmpl $0x1, (%rdi)
je 0x154b1
movq 0xef61c(%rip), %rsi     # 0x104ac8
callq 0x1d809
cmpl $0x1, -0x4(%rbx)
jne 0x154c0
cmpl $0x1, (%rbx)
je 0x15587
movq 0xf9f19(%rip), %rsi     # 0x10f3e0
movq %rbx, %rdi
jmp 0x155a8
movq %rbx, %rdx
addq $0x8, %rdx
cmpb $0x1, %cl
cmovneq %rax, %rdx
movq (%rdx), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0x154f5
movq (%rcx), %r15
movq 0x8(%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
je 0x15505
jmp 0x15508
movq 0x294f4(%rip), %rcx     # 0x3e9f0
cmpb $0x1, 0x10(%rcx)
movq %rcx, %r15
jne 0x15508
movq %rcx, %rax
cmpb $0x4, 0x10(%r15)
jne 0x15526
movq (%rax), %r12
cmpb $0x4, 0x10(%r12)
jne 0x15526
movq %r15, %rdi
callq 0xbfac
testl %eax, %eax
je 0x15536
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x861b
movq %r15, %rdi
callq 0x8c2a
testl %eax, %eax
je 0x15562
movq %r14, %rdi
callq 0x861b
pushq $-0x1
popq %rdi
callq 0xa426
movq %r12, %rdi
callq 0x861b
pushq $0x3
popq %rdi
callq 0x85eb
movq (%r15), %rdi
movq 0x8(%r15), %rbx
cmpl $0x1, -0x4(%rdi)
jne 0x15574
cmpl $0x1, (%rdi)
je 0x1557c
movq %r12, %rsi
callq 0x1d809
cmpl $0x1, -0x4(%rbx)
jne 0x15590
cmpl $0x1, (%rbx)
jne 0x15590
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
callq 0x861b
callq 0x975f
callq 0x868d
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1d809
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %rbx
movl 0xef50b(%rip), %r14d    # 0x104ad8
andl $0x0, 0xef504(%rip)     # 0x104ad8
callq 0x86c3
cmpl $0x2, %eax
jl 0x15633
leaq 0x8(%rbx), %r15
leaq 0x29407(%rip), %r12     # 0x3e9f0
cmpb $0x1, 0x10(%rbx)
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %r13
cmpb $0x1, 0x10(%r13)
jne 0x155e9
movq (%r13), %rdi
callq 0x861b
callq 0x8f7d
callq 0x868d
leaq 0x8(%r13), %rax
cmpb $0x1, 0x10(%r13)
cmovneq %r12, %rax
movl 0xf9d8c(%rip), %ecx     # 0x10f3b0
orl 0xef4ae(%rip), %ecx     # 0x104ad8
je 0x155f4
movl %r14d, 0xef4a5(%rip)    # 0x104ad8
movq 0x293b6(%rip), %rdi     # 0x3e9f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x861b
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: 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 0x290f7(%rip), %r12     # 0x3e9f0
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x861b
callq 0x8fbb
callq 0x868d
cmpb $0x1, 0x10(%r14)
movq %r12, %rcx
cmoveq %r15, %rcx
movq %rax, %rbx
movq (%rcx), %rax
cmpb $0x1, 0x10(%rax)
jne 0x1593b
movq 0x8(%rax), %rax
jmp 0x15942
movq 0x290ae(%rip), %rax     # 0x3e9f0
cmpb $0x1, 0x10(%rax)
movq %r12, %rcx
jne 0x1594e
movq %rax, %rcx
movq (%rcx), %rdi
callq 0x861b
callq 0x8fbb
callq 0xd9d9
cmpb $0x1, 0x10(%r14)
cmoveq %r15, %r12
movl %eax, %r14d
movq (%r12), %rax
cmpb $0x1, 0x10(%rax)
jne 0x15986
movq 0x8(%rax), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0x159ad
movq 0x8(%rcx), %rcx
jmp 0x159b4
movq 0x29063(%rip), %rcx     # 0x3e9f0
leaq 0x2905c(%rip), %rax     # 0x3e9f0
cmpb $0x1, 0x10(%rcx)
jne 0x159dd
movq 0x8(%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0x159dd
movq 0x29045(%rip), %rax     # 0x3e9f0
jmp 0x159be
movq 0x2903c(%rip), %rcx     # 0x3e9f0
cmpb $0x1, 0x10(%rcx)
jne 0x159ca
movq 0x8(%rax), %rax
cmpb $0x1, 0x10(%rax)
jne 0x159d3
addq $0x8, %rax
jmp 0x159da
leaq 0x2901f(%rip), %rax     # 0x3e9f0
jmp 0x159dd
leaq 0x29016(%rip), %rax     # 0x3e9f0
movq (%rax), %rax
movq (%rax), %rdi
callq 0x861b
callq 0x8fbb
callq 0xd9d9
cmpb $0x7, 0x10(%rbx)
jne 0x15a3c
movq (%rbx), %rcx
cmpl $0x2, (%rcx)
jne 0x15a3c
movl %eax, %r15d
movl 0x4(%rcx), %eax
cmpl 0x8(%rcx), %eax
jne 0x15a3c
testl %r14d, %r14d
jle 0x15a3c
cmpl %eax, %r14d
jg 0x15a3c
testl %r15d, %r15d
js 0x15a3c
cmpl %eax, %r15d
ja 0x15a3c
movq %rbx, %rdi
callq 0x861b
movl %r14d, %edi
movl %r15d, %esi
callq 0xda2c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xb2b2
leaq 0x11e7e(%rip), %rdi     # 0x278c1
callq 0x7756
// File: /workspace/github_c_makefile_star2_O2/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 0x28f8b(%rip), %r12     # 0x3e9f0
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x861b
callq 0x8fbb
callq 0x868d
cmpb $0x1, 0x10(%r14)
movq %r12, %rcx
cmoveq %r15, %rcx
movq %rax, %rbx
movq (%rcx), %rax
cmpb $0x1, 0x10(%rax)
jne 0x15aa7
movq 0x8(%rax), %rax
jmp 0x15aae
movq 0x28f42(%rip), %rax     # 0x3e9f0
cmpb $0x1, 0x10(%rax)
movq %r12, %rcx
jne 0x15aba
movq %rax, %rcx
movq (%rcx), %rdi
callq 0x861b
callq 0x8fbb
callq 0xd9d9
cmpb $0x1, 0x10(%r14)
cmoveq %r15, %r12
movl %eax, %r14d
movq (%r12), %rax
cmpb $0x1, 0x10(%rax)
jne 0x15af2
movq 0x8(%rax), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0x15b19
movq 0x8(%rcx), %rcx
jmp 0x15b20
movq 0x28ef7(%rip), %rcx     # 0x3e9f0
leaq 0x28ef0(%rip), %rax     # 0x3e9f0
cmpb $0x1, 0x10(%rcx)
jne 0x15b49
movq 0x8(%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0x15b49
movq 0x28ed9(%rip), %rax     # 0x3e9f0
jmp 0x15b2a
movq 0x28ed0(%rip), %rcx     # 0x3e9f0
cmpb $0x1, 0x10(%rcx)
jne 0x15b36
movq 0x8(%rax), %rax
cmpb $0x1, 0x10(%rax)
jne 0x15b3f
addq $0x8, %rax
jmp 0x15b46
leaq 0x28eb3(%rip), %rax     # 0x3e9f0
jmp 0x15b49
leaq 0x28eaa(%rip), %rax     # 0x3e9f0
movq (%rax), %rax
movq (%rax), %rdi
callq 0x861b
callq 0x8fbb
callq 0xd9d9
cmpb $0x7, 0x10(%rbx)
jne 0x15ba9
movl %eax, %r15d
movq (%rbx), %rax
cmpl $0x2, (%rax)
jne 0x15ba9
testl %r14d, %r14d
jle 0x15b9d
cmpl 0x4(%rax), %r14d
jg 0x15b9d
testl %r15d, %r15d
js 0x15b9d
cmpl 0x8(%rax), %r15d
jg 0x15b9d
movq %rbx, %rdi
callq 0x861b
movl %r14d, %edi
movl %r15d, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xda2c
leaq 0x11d40(%rip), %rdi     # 0x278e4
callq 0x7756
leaq 0x11d17(%rip), %rdi     # 0x278c7
callq 0x7756
// File: /workspace/github_c_makefile_star2_O2/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 0x28e1f(%rip), %r14     # 0x3e9f0
movq %r14, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rax
movq (%rax), %rdi
callq 0x861b
callq 0x8fbb
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
jne 0x15c07
movq 0x8(%rax), %rax
jmp 0x15c0e
movq 0x28de2(%rip), %rax     # 0x3e9f0
cmpb $0x1, 0x10(%rax)
jne 0x15c17
movq %rax, %r14
movq (%r14), %rdi
callq 0x861b
callq 0x8fbb
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe617
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x8b5d
testl %eax, %eax
je 0x15c64
movq %rbx, %rdi
callq 0x8b5d
testl %eax, %eax
je 0x15c64
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x15caf
movq %r14, %rdi
callq 0x861b
movq %r14, %rdi
callq 0x861b
movq %rbx, %rdi
callq 0x861b
callq 0xca0b
callq 0x94f7
callq 0x122e1
movq %rbx, %rdi
callq 0x861b
callq 0x9fae
movb 0x12(%r14), %al
cmpb 0x12(%rbx), %al
jne 0x15ca6
callq 0x975f
popq %rbx
popq %r14
popq %rbp
jmp 0xa1f6
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %rbx
movl 0x225b2(%rip), %r14d    # 0x382a8
decl 0xeedc4(%rip)           # 0x104ac0
leaq 0x28ced(%rip), %r15     # 0x3e9f0
leaq 0x8(%rbx), %rax
cmpb $0x1, 0x10(%rbx)
cmovneq %r15, %rax
movq (%rax), %rbx
cmpb $0x1, 0x10(%rbx)
jne 0x15d27
movq (%rbx), %rdi
callq 0x861b
callq 0x8f7d
jmp 0x15d03
movl 0x2257b(%rip), %edi     # 0x382a8
subl %r14d, %edi
callq 0xa04c
incl 0xeed85(%rip)           # 0x104ac0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: 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
movslq 0x2254d(%rip), %rbx     # 0x382a8
movslq %edi, %r14
leaq 0x2b84b(%rip), %r15     # 0x415b0
leaq 0x28c84(%rip), %r12     # 0x3e9f0
cmpq %rbx, %r14
jge 0x15dd5
movq (%r15,%r14,8), %rax
movb 0x10(%rax), %cl
cmpb $0x1, %cl
movq %r12, %rdx
cmoveq %rax, %rdx
movq (%rdx), %rdx
cmpq 0x2b50c(%rip), %rdx     # 0x41298
je 0x15d93
incq %r14
jmp 0x15d6c
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), %r13
leaq 0x8(%r13), %rax
cmpb $0x1, 0x10(%r13)
cmovneq %r12, %rax
movq (%rax), %r13
cmpb $0x1, 0x10(%r13)
jne 0x15d8e
movq (%r13), %rdi
callq 0x861b
jmp 0x15db3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: 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 0x28bf8(%rip), %rdi     # 0x3e9f0
movl 0x224aa(%rip), %eax     # 0x382a8
leaq 0x2b7ab(%rip), %r12     # 0x415b0
pushq $0x1
popq %r14
cmpl %eax, %ebx
jge 0x15e54
movslq %ebx, %rcx
movq (%r12,%rcx,8), %r15
cmpb $0x7, 0x10(%r15)
jne 0x15e50
cmpb $0x7, 0x10(%rdi)
jne 0x15e3b
callq 0x861b
movq %r15, %rdi
callq 0x861b
callq 0x127ce
callq 0x868d
movq %rax, %r15
movl %ebx, %edi
movl %r14d, %esi
callq 0xa55e
decl %ebx
movl 0x2245b(%rip), %eax     # 0x382a8
movq %r15, %rdi
incl %ebx
jmp 0x15e09
movq %rdi, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xeec58(%rip), %rsi     # 0x104ac8
callq 0x15f6a
movq %rax, %r14
movq %rax, %rdi
callq 0xa641
testl %eax, %eax
jne 0x15f29
cmpl %ebx, 0x2241a(%rip)     # 0x382a8
je 0x15f29
movl %ebx, %edi
callq 0x15fd3
movl %ebx, %edi
callq 0x16023
movl %ebx, %edi
callq 0x15fd3
movl %ebx, %edi
callq 0x16023
movl %ebx, %edi
movq %r14, %rsi
callq 0x15f6a
movq %rax, %r14
movq %rax, %rdi
callq 0xa641
testl %eax, %eax
jne 0x15f29
cmpl %ebx, 0x223d9(%rip)     # 0x382a8
je 0x15f29
movl %ebx, %edi
movq %r14, %rsi
callq 0x16158
movq %rax, %r14
cmpb $0x5, 0x10(%rax)
je 0x15ef0
movq %r14, %rdi
callq 0xa95a
testl %eax, %eax
jne 0x15ef8
movq %r14, %rdi
callq 0x861b
cmpl $0x0, 0xeebc1(%rip)     # 0x104ac0
je 0x15f08
movl %ebx, %edi
callq 0x1619a
movl 0x22399(%rip), %r14d    # 0x382a8
subl %ebx, %r14d
cmpl $0x1, %r14d
je 0x15f3b
testl %r14d, %r14d
jne 0x15f40
pushq $0x1
popq %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xa426
movl %ebx, 0x22379(%rip)     # 0x382a8
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x861b
popq %rbx
popq %r14
popq %rbp
retq
movl %r14d, %edi
callq 0x162a3
movl %r14d, %edi
callq 0x85eb
movq 0x2b341(%rip), %rdi     # 0x41298
callq 0x861b
callq 0xa49b
popq %rbx
popq %r14
popq %rbp
jmp 0x865c
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movl %edi, %ebx
movl 0x22328(%rip), %eax     # 0x382a8
leaq 0x2b629(%rip), %r12     # 0x415b0
pushq $0x1
popq %r14
cmpl %eax, %ebx
jge 0x15fc7
movslq %ebx, %rcx
movq (%r12,%rcx,8), %rsi
movb 0x10(%rsi), %cl
andb $-0x2, %cl
cmpb $0x4, %cl
jne 0x15fc3
movq %r15, %rdi
callq 0x162e1
callq 0x868d
movq %rax, %r15
movl %ebx, %edi
movl %r14d, %esi
callq 0xa55e
decl %ebx
movl 0x222e5(%rip), %eax     # 0x382a8
incl %ebx
jmp 0x15f8b
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
callq 0x16330
pushq $0x1
popq %r14
leal 0x1(%rbx), %r15d
movl 0x222b6(%rip), %eax     # 0x382a8
decl %eax
cmpl %eax, %ebx
jge 0x16018
movl %ebx, %edi
movl %r15d, %esi
callq 0x16363
testl %eax, %eax
je 0x16013
movl %r15d, %edi
movl %r14d, %esi
callq 0xa55e
jmp 0x15fec
movl %r15d, %ebx
jmp 0x15fe8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: 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
movslq 0x22270(%rip), %rbx     # 0x382a8
movslq %edi, %r14
leaq 0x2b56e(%rip), %r15     # 0x415b0
leaq 0x289a7(%rip), %r12     # 0x3e9f0
movq %rbx, -0x30(%rbp)
cmpq %rbx, %r14
jge 0x16149
movq (%r15,%r14,8), %r13
movb 0x10(%r13), %al
cmpb $0x1, %al
movq %r12, %rcx
cmoveq %r13, %rcx
movq (%rcx), %rcx
cmpq 0x2b22f(%rip), %rcx     # 0x412a0
jne 0x160fb
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 0x861b
cmpb $0x1, 0x10(%r13)
cmovneq %r12, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
jne 0x160b2
movq 0x8(%rax), %rax
jmp 0x160b9
movq 0x28937(%rip), %rax     # 0x3e9f0
cmpb $0x1, 0x10(%rax)
movq %r12, %rcx
jne 0x160c5
movq %rax, %rcx
movq (%rcx), %rdi
callq 0x861b
callq 0x9a87
callq 0x868d
movb 0x10(%rax), %cl
cmpb $0x1, %cl
movq %r12, %rdx
cmoveq %rax, %rdx
movq (%rdx), %rdx
cmpq 0x2b1aa(%rip), %rdx     # 0x41298
movq %rbx, %r15
je 0x16103
movq %rax, (%r15,%r14,8)
movq -0x30(%rbp), %rbx
incq %r14
jmp 0x1604d
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), %r13
movq -0x30(%rbp), %rbx
leaq 0x8(%r13), %rax
cmpb $0x1, 0x10(%r13)
cmovneq %r12, %rax
movq (%rax), %r13
cmpb $0x1, 0x10(%r13)
jne 0x160fb
movq (%r13), %rdi
callq 0x861b
jmp 0x16127
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: 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 0x16740
testl %eax, %eax
je 0x16183
cmpb $0x4, 0x10(%rbx)
jne 0x1618b
movl %r14d, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x1678b
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movl %r14d, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x169bb
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movslq 0x220fc(%rip), %rax     # 0x382a8
movl %eax, %ecx
subl %edi, %ecx
cmpl $0x2, %ecx
jl 0x16201
movl %edi, %ebx
movq 0x2b0d2(%rip), %rcx     # 0x41290
cmpl %edi, %eax
cmovgl %eax, %edi
movslq %ebx, %rdx
leaq 0x2b3e3(%rip), %rsi     # 0x415b0
leaq (%rsi,%rdx,8), %rsi
leaq 0x28818(%rip), %r15     # 0x3e9f0
cmpq %rax, %rdx
jge 0x161fd
movq (%rsi), %r12
cmpb $0x1, 0x10(%r12)
movq %r15, %r8
cmoveq %r12, %r8
cmpq %rcx, (%r8)
je 0x161fb
incq %rdx
addq $0x8, %rsi
jmp 0x161d8
movl %edx, %edi
cmpl %eax, %edi
jne 0x1620a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rsi
callq 0xa55e
movl 0x2208f(%rip), %r14d    # 0x382a8
subl %ebx, %r14d
cmpl $0x2, %r14d
jl 0x16248
movl %r14d, %edi
callq 0x162a3
movl %r14d, %edi
callq 0x85eb
movq 0x2b05f(%rip), %rdi     # 0x41298
callq 0x861b
callq 0xa49b
callq 0x865c
callq 0x868d
movq %rax, %r14
leaq 0x8(%r12), %rax
cmpb $0x1, 0x10(%r12)
cmovneq %r15, %rax
movq (%rax), %r12
cmpb $0x1, 0x10(%r12)
jne 0x1628e
movq %r14, %rdi
callq 0x861b
cmpb $0x1, 0x10(%r12)
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rdi
callq 0x861b
callq 0x9fae
jmp 0x16250
movl 0x22014(%rip), %edi     # 0x382a8
subl %ebx, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa0fd
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: 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 0x16304
cmpb $0x4, 0x10(%rbx)
jne 0x16304
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x16634
callq 0x861b
callq 0x8ae1
movsd %xmm0, -0x10(%rbp)
movq %rbx, %rdi
callq 0x861b
callq 0x8ae1
mulsd -0x10(%rbp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xaf59