LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: normalize_polar_term
void
normalize_polar_term(struct atom *EXPO)
{
	struct atom *R;

	// exp(i pi) = -1

	if (lengthf(EXPO) == 3) {
		push_integer(-1);
		return;
	}

	R = cadr(EXPO); // R = coeff of term

	if (isrational(R))
		normalize_polar_term_rational(R);
	else
		normalize_polar_term_double(R);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9220
cmpl $0x3, %eax
jne 0x2bd59
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xca50
jmp 0x2bdf3
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2bd74
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2bd7f
movq 0x32c85(%rip), %rax     # 0x5ea00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2bdbf
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2bda7
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2bdb2
movq 0x32c52(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x2bdca
movq 0x32c3a(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x4, %eax
jne 0x2bdea
movq -0x10(%rbp), %rdi
callq 0x2be00
jmp 0x2bdf3
movq -0x10(%rbp), %rdi
callq 0x2c170
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: power_complex_double
void
power_complex_double(struct atom *X, struct atom *Y, struct atom *EXPO)
{
	double expo, r, theta, x, y;

	push(EXPO);
	expo = pop_double();

	push(X);
	x = pop_double();

	push(Y);
	y = pop_double();

	r = hypot(x, y);
	theta = atan2(y, x);

	r = pow(r, expo);
	theta = expo * theta;

	x = r * cos(theta);
	y = r * sin(theta);

	push_double(x);
	push_double(y);
	push(imaginaryunit);
	multiply();
	add();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9110
callq 0x9af0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9110
callq 0x9af0
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9110
callq 0x9af0
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
movsd -0x40(%rbp), %xmm1
callq 0x72a0
movsd %xmm0, -0x28(%rbp)
movsd -0x40(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
callq 0x7290
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
callq 0x70d0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x7170
movaps %xmm0, %xmm1
movsd -0x50(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movsd -0x30(%rbp), %xmm0
callq 0x72e0
movaps %xmm0, %xmm1
movsd -0x48(%rbp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0xe5e0
movsd -0x40(%rbp), %xmm0
callq 0xe5e0
movq 0xf7743(%rip), %rdi     # 0x124ae0
callq 0x9110
callq 0xc280
callq 0xc660
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: power_complex_rational
void
power_complex_rational(struct atom *X, struct atom *Y, struct atom *EXPO)
{
	// calculate sqrt(X^2 + Y^2) ^ (1/2 * EXPO)

	push(X);
	push(X);
	multiply();
	push(Y);
	push(Y);
	multiply();
	add();
	push_rational(1, 2);
	push(EXPO);
	multiply();
	power();

	// calculate (-1) ^ (EXPO * arctan(Y, X) / pi)

	push(Y);
	push(X);
	arctan();
	push_symbol(PI);
	divide();
	push(EXPO);
	multiply();
	EXPO = pop();
	power_minusone(EXPO);

	// result = sqrt(X^2 + Y^2) ^ (1/2 * EXPO) * (-1) ^ (EXPO * arctan(Y, X) / pi)

	multiply();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9110
movq -0x8(%rbp), %rdi
callq 0x9110
callq 0xc280
movq -0x10(%rbp), %rdi
callq 0x9110
movq -0x10(%rbp), %rdi
callq 0x9110
callq 0xc280
callq 0xc660
movl $0x1, %edi
movl $0x2, %esi
callq 0xb840
movq -0x18(%rbp), %rdi
callq 0x9110
callq 0xc280
callq 0xb8b0
movq -0x10(%rbp), %rdi
callq 0x9110
movq -0x8(%rbp), %rdi
callq 0x9110
callq 0x111e0
movq 0x31c09(%rip), %rdi     # 0x5f050
callq 0x9110
callq 0x117a0
movq -0x18(%rbp), %rdi
callq 0x9110
callq 0xc280
callq 0x91d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2ac80
callq 0xc280
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: power_complex_plus
void
power_complex_plus(struct atom *X, struct atom *Y, int n)
{
	int i;
	struct atom *PX, *PY;

	PX = X;
	PY = Y;

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

		push(PX);
		push(X);
		multiply();
		push(PY);
		push(Y);
		multiply();
		subtract();

		push(PX);
		push(Y);
		multiply();
		push(PY);
		push(X);
		multiply();
		add();

		PY = pop();
		PX = pop();
	}

	// X + i*Y

	push(PX);
	push(imaginaryunit);
	push(PY);
	multiply();
	add();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2d53c
movq -0x20(%rbp), %rdi
callq 0x9110
movq -0x8(%rbp), %rdi
callq 0x9110
callq 0xc280
movq -0x28(%rbp), %rdi
callq 0x9110
movq -0x10(%rbp), %rdi
callq 0x9110
callq 0xc280
callq 0xe7e0
movq -0x20(%rbp), %rdi
callq 0x9110
movq -0x10(%rbp), %rdi
callq 0x9110
callq 0xc280
movq -0x28(%rbp), %rdi
callq 0x9110
movq -0x8(%rbp), %rdi
callq 0x9110
callq 0xc280
callq 0xc660
callq 0x91d0
movq %rax, -0x28(%rbp)
callq 0x91d0
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2d4aa
movq -0x20(%rbp), %rdi
callq 0x9110
movq 0xf7594(%rip), %rdi     # 0x124ae0
callq 0x9110
movq -0x28(%rbp), %rdi
callq 0x9110
callq 0xc280
callq 0xc660
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: power_complex_minus
void
power_complex_minus(struct atom *X, struct atom *Y, int n)
{
	int i;
	struct atom *PX, *PY, *R;

	// R = X^2 + Y^2

	push(X);
	push(X);
	multiply();
	push(Y);
	push(Y);
	multiply();
	add();
	R = pop();

	// X = X / R

	push(X);
	push(R);
	divide();
	X = pop();

	// Y = -Y / R

	push(Y);
	negate();
	push(R);
	divide();
	Y = pop();

	PX = X;
	PY = Y;

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

		push(PX);
		push(X);
		multiply();
		push(PY);
		push(Y);
		multiply();
		subtract();

		push(PX);
		push(Y);
		multiply();
		push(PY);
		push(X);
		multiply();
		add();

		PY = pop();
		PX = pop();
	}

	// X + i*Y

	push(PX);
	push(imaginaryunit);
	push(PY);
	multiply();
	add();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9110
movq -0x8(%rbp), %rdi
callq 0x9110
callq 0xc280
movq -0x10(%rbp), %rdi
callq 0x9110
movq -0x10(%rbp), %rdi
callq 0x9110
callq 0xc280
callq 0xc660
callq 0x91d0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9110
movq -0x30(%rbp), %rdi
callq 0x9110
callq 0x117a0
callq 0x91d0
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9110
callq 0xb4b0
movq -0x30(%rbp), %rdi
callq 0x9110
callq 0x117a0
callq 0x91d0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2d6ad
movq -0x20(%rbp), %rdi
callq 0x9110
movq -0x8(%rbp), %rdi
callq 0x9110
callq 0xc280
movq -0x28(%rbp), %rdi
callq 0x9110
movq -0x10(%rbp), %rdi
callq 0x9110
callq 0xc280
callq 0xe7e0
movq -0x20(%rbp), %rdi
callq 0x9110
movq -0x10(%rbp), %rdi
callq 0x9110
callq 0xc280
movq -0x28(%rbp), %rdi
callq 0x9110
movq -0x8(%rbp), %rdi
callq 0x9110
callq 0xc280
callq 0xc660
callq 0x91d0
movq %rax, -0x28(%rbp)
callq 0x91d0
movq %rax, -0x20(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2d61b
movq -0x20(%rbp), %rdi
callq 0x9110
movq 0xf7423(%rip), %rdi     # 0x124ae0
callq 0x9110
movq -0x28(%rbp), %rdi
callq 0x9110
callq 0xc280
callq 0xc660
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_prefixform
void
eval_prefixform(struct atom *p1)
{
	push(cadr(p1));
	evalf();
	p1 = pop();

	outbuf_init();
	prefixform(p1);

	push_string(outbuf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2d707
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2d712
movq 0x312f2(%rip), %rax     # 0x5ea00
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2d752
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2d73a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2d745
movq 0x312bf(%rip), %rax     # 0x5ea00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2d75d
movq 0x312a7(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9110
callq 0xa660
callq 0x91d0
movq %rax, -0x8(%rbp)
callq 0x1ee80
movq -0x8(%rbp), %rdi
callq 0x2d7a0
movq 0x101c3f(%rip), %rdi    # 0x12f3c8
callq 0x1efd0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: print_prefixform
void
print_prefixform(struct atom *p)
{
	outbuf_init();
	prefixform(p);
	outbuf_puts("\n");
	printbuf(outbuf, BLACK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x1ee80
movq -0x8(%rbp), %rdi
callq 0x2d7a0
leaq 0x1c449(%rip), %rdi     # 0x49e9a
callq 0x1f060
movq 0x10196b(%rip), %rdi    # 0x12f3c8
xorl %esi, %esi
callq 0x1f110
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_print
void
eval_print(struct atom *p1)
{
	p1 = cdr(p1);
	while (iscons(p1)) {
		push(car(p1));
		push(car(p1));
		evalf();
		print_result();
		p1 = cdr(p1);
	}
	push_symbol(NIL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2da97
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2daa2
movq 0x30f62(%rip), %rax     # 0x5ea00
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2db54
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2dad5
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2dae0
movq 0x30f24(%rip), %rax     # 0x5ea00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9110
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2db03
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2db0e
movq 0x30ef6(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9110
callq 0xa660
callq 0x2db70
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2db3c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x2db47
movq 0x30ebd(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2daaa
movq 0x30ea5(%rip), %rdi     # 0x5ea00
callq 0x9110
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: print_result
void
print_result(void)
{
	struct atom *p1, *p2;

	p2 = pop(); // result
	p1 = pop(); // input

	if (p2 == symbol(NIL))
		return;

	if (annotate_result(p1, p2)) {
		push_symbol(SETQ);
		push(p1);
		push(p2);
		list(3);
		p2 = pop();
	}

	p1 = get_binding(symbol(TTY));

	if (p1 == symbol(TTY) || iszero(p1)) {
		push(p2);
		display();
	} else
		print_infixform(p2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x91d0
movq %rax, -0x10(%rbp)
callq 0x91d0
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x30e6b(%rip), %rax     # 0x5ea00
jne 0x2db9c
jmp 0x2dc23
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2dc30
cmpl $0x0, %eax
je 0x2dbdf
movq 0x3370b(%rip), %rdi     # 0x612c0
callq 0x9110
movq -0x8(%rbp), %rdi
callq 0x9110
movq -0x10(%rbp), %rdi
callq 0x9110
movl $0x3, %edi
callq 0x90d0
callq 0x91d0
movq %rax, -0x10(%rbp)
movq 0x3214a(%rip), %rdi     # 0x5fd30
callq 0x128e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq 0x32136(%rip), %rax     # 0x5fd30
je 0x2dc0a
movq -0x8(%rbp), %rdi
callq 0xcdc0
cmpl $0x0, %eax
je 0x2dc1a
movq -0x10(%rbp), %rdi
callq 0x9110
callq 0x2dcd0
jmp 0x2dc23
movq -0x10(%rbp), %rdi
callq 0x1f020
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: annotate_result
int
annotate_result(struct atom *p1, struct atom *p2)
{
	if (!isusersymbol(p1))
		return 0;

	if (p1 == p2)
		return 0; // A = A

	if (p1 == symbol(I_LOWER) && isimaginaryunit(p2))
		return 0;

	if (p1 == symbol(J_LOWER) && isimaginaryunit(p2))
		return 0;

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x3, %eax
je 0x2dc56
movl $0x0, -0x4(%rbp)
jmp 0x2dcb8
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x2dc69
movl $0x0, -0x4(%rbp)
jmp 0x2dcb8
movq -0x10(%rbp), %rax
cmpq 0x2fdf4(%rip), %rax     # 0x5da68
jne 0x2dc8d
movq -0x18(%rbp), %rdi
callq 0x219c0
cmpl $0x0, %eax
je 0x2dc8d
movl $0x0, -0x4(%rbp)
jmp 0x2dcb8
movq -0x10(%rbp), %rax
cmpq 0x300f0(%rip), %rax     # 0x5dd88
jne 0x2dcb1
movq -0x18(%rbp), %rdi
callq 0x219c0
cmpl $0x0, %eax
je 0x2dcb1
movl $0x0, -0x4(%rbp)
jmp 0x2dcb8
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_rank
void
eval_rank(struct atom *p1)
{
	push(cadr(p1));
	evalf();
	p1 = pop();
	if (istensor(p1))
		push_integer(p1->u.tensor->ndim);
	else
		push_integer(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2ea77
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2ea82
movq 0x2ff82(%rip), %rax     # 0x5ea00
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2eac2
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2eaaa
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2eab5
movq 0x2ff4f(%rip), %rax     # 0x5ea00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2eacd
movq 0x2ff37(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9110
callq 0xa660
callq 0x91d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x7, %eax
jne 0x2eb01
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl (%rax), %edi
callq 0xca50
jmp 0x2eb08
xorl %edi, %edi
callq 0xca50
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: rationalize
void
rationalize(void)
{
	int i, n;
	struct atom *p1;

	p1 = pop();

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

	push(p1);
	numden();
	swap();
	reciprocate();
	multiply_noexpand();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x91d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x7, %eax
jne 0x2ec3f
movq -0x10(%rbp), %rdi
callq 0xa550
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x64(%rax), %eax
movl %eax, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x2ec34
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movq 0x68(%rax,%rcx,8), %rdi
callq 0x9110
callq 0x2ebb0
callq 0x91d0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movq %rdx, 0x68(%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2ebef
movq -0x10(%rbp), %rdi
callq 0x9110
jmp 0x2ec5c
movq -0x10(%rbp), %rdi
callq 0x9110
callq 0x11e60
callq 0xcb10
callq 0xc3b0
callq 0x27fe0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_roots
void
eval_roots(struct atom *p1)
{
	push(cadr(p1));
	evalf();

	p1 = cddr(p1);

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

	roots();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2edd7
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x2ede2
movq 0x2fc22(%rip), %rax     # 0x5ea00
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2ee22
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2ee0a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2ee15
movq 0x2fbef(%rip), %rax     # 0x5ea00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2ee2d
movq 0x2fbd7(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9110
callq 0xa660
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2ee56
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x2ee61
movq 0x2fba3(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2eea2
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2ee89
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x2ee94
movq 0x2fb70(%rip), %rax     # 0x5ea00
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x2eead
movq 0x2fb57(%rip), %rax     # 0x5ea00
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2eef7
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2eedc
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x2eee7
movq 0x2fb1d(%rip), %rax     # 0x5ea00
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x9110
callq 0xa660
jmp 0x2ef03
movq 0x31a4a(%rip), %rdi     # 0x60948
callq 0x9110
callq 0x2ef10
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: reduce
void
reduce(int h, int n, struct atom *A)
{
	int i;

	for (i = n - 1; i > 0; i--) {
		push(A);
		push(stack[h + i]);
		multiply();
		push(stack[h + i - 1]);
		add();
		stack[h + i - 1] = pop();
	}

	if (!iszero(stack[h]))
		stopf("roots: residual error"); // not a root

	// move

	for (i = 0; i < n - 1; i++)
		stack[h + i] = stack[h + i + 1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl -0x8(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x2f4a3
movq -0x10(%rbp), %rdi
callq 0x9110
movl -0x4(%rbp), %eax
addl -0x14(%rbp), %eax
movslq %eax, %rcx
leaq 0x32176(%rip), %rax     # 0x615c0
movq (%rax,%rcx,8), %rdi
callq 0x9110
callq 0xc280
movl -0x4(%rbp), %eax
addl -0x14(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x32155(%rip), %rax     # 0x615c0
movq (%rax,%rcx,8), %rdi
callq 0x9110
callq 0xc660
callq 0x91d0
movq %rax, %rdx
movl -0x4(%rbp), %eax
addl -0x14(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x3212c(%rip), %rax     # 0x615c0
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2f42b
movslq -0x4(%rbp), %rcx
leaq 0x32112(%rip), %rax     # 0x615c0
movq (%rax,%rcx,8), %rdi
callq 0xcdc0
cmpl $0x0, %eax
jne 0x2f4c8
leaq 0x1a3da(%rip), %rdi     # 0x4989d
callq 0x78d0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0x8(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x2f512
movl -0x4(%rbp), %eax
addl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x320d1(%rip), %rax     # 0x615c0
movq (%rax,%rcx,8), %rdx
movl -0x4(%rbp), %eax
addl -0x14(%rbp), %eax
movslq %eax, %rcx
leaq 0x320bd(%rip), %rax     # 0x615c0
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2f4cf
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: divisors
void
divisors(int n)
{
	int h, i, k;

	h = tos;

	factor_int(n);

	k = tos;

	// contruct divisors by recursive descent

	push_integer(1);

	divisors_nib(h, k);

	// move

	n = tos - k;

	for (i = 0; i < n; i++)
		stack[h + i] = stack[k + i];

	tos = h + n; // pop all
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0x28d87(%rip), %eax     # 0x582b8
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %edi
callq 0x2f640
movl 0x28d76(%rip), %eax     # 0x582b8
movl %eax, -0x10(%rbp)
movl $0x1, %edi
callq 0xca50
movl -0x8(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x2f700
movl 0x28d58(%rip), %eax     # 0x582b8
subl -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x2f5a8
movl -0x10(%rbp), %eax
addl -0xc(%rbp), %eax
movslq %eax, %rcx
leaq 0x3203b(%rip), %rax     # 0x615c0
movq (%rax,%rcx,8), %rdx
movl -0x8(%rbp), %eax
addl -0xc(%rbp), %eax
movslq %eax, %rcx
leaq 0x32027(%rip), %rax     # 0x615c0
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2f56d
movl -0x8(%rbp), %eax
addl -0x4(%rbp), %eax
movl %eax, 0x28d04(%rip)     # 0x582b8
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: horner
void
horner(int h, int n, struct atom *A)
{
	int i;

	push(stack[h + n - 1]);

	for (i = n - 2; i >= 0; i--) {
		push(A);
		multiply();
		push(stack[h + i]);
		add();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl -0x4(%rbp), %eax
addl -0x8(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x31fdb(%rip), %rax     # 0x615c0
movq (%rax,%rcx,8), %rdi
callq 0x9110
movl -0x8(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x2f634
movq -0x10(%rbp), %rdi
callq 0x9110
callq 0xc280
movl -0x4(%rbp), %eax
addl -0x14(%rbp), %eax
movslq %eax, %rcx
leaq 0x31fa5(%rip), %rax     # 0x615c0
movq (%rax,%rcx,8), %rdi
callq 0x9110
callq 0xc660
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2f5f7
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: factor_int
void
factor_int(int n)
{
	int d, k, m;

	n = abs(n);

	if (n < 2)
		return;

	for (k = 0; k < NPRIME; k++) {

		d = primetab[k];

		m = 0;

		while (n % d == 0) {
			n /= d;
			m++;
		}

		if (m == 0)
			continue;

		push_integer(d);
		push_integer(m);

		if (n == 1)
			return;
	}

	push_integer(n);
	push_integer(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x4(%rbp)
cmpl $0x2, -0x4(%rbp)
jge 0x2f663
jmp 0x2f6ed
movl $0x0, -0xc(%rbp)
cmpl $0x12b8, -0xc(%rbp)     # imm = 0x12B8
jge 0x2f6db
movslq -0xc(%rbp), %rcx
leaq 0x23012(%rip), %rax     # 0x52690
movl (%rax,%rcx,4), %eax
movl %eax, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x4(%rbp), %eax
cltd
idivl -0x8(%rbp)
cmpl $0x0, %edx
jne 0x2f6ae
movl -0x8(%rbp), %ecx
movl -0x4(%rbp), %eax
cltd
idivl %ecx
movl %eax, -0x4(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2f68b
cmpl $0x0, -0x10(%rbp)
jne 0x2f6b6
jmp 0x2f6d0
movl -0x8(%rbp), %edi
callq 0xca50
movl -0x10(%rbp), %edi
callq 0xca50
cmpl $0x1, -0x4(%rbp)
jne 0x2f6ce
jmp 0x2f6ed
jmp 0x2f6d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2f66a
movl -0x4(%rbp), %edi
callq 0xca50
movl $0x1, %edi
callq 0xca50
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: divisors_nib
void
divisors_nib(int h, int k)
{
	int i, n;
	struct atom *ACCUM, *BASE, *EXPO;

	if (h == k)
		return;

	ACCUM = pop();

	BASE = stack[h + 0];
	EXPO = stack[h + 1];

	push(EXPO);
	n = pop_integer();

	for (i = 0; i <= n; i++) {
		push(ACCUM);
		push(BASE);
		push_integer(i);
		power();
		multiply();
		divisors_nib(h + 2, k);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jne 0x2f71b
jmp 0x2f7b1
callq 0x91d0
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %eax
addl $0x0, %eax
movslq %eax, %rcx
leaq 0x31e8c(%rip), %rax     # 0x615c0
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rcx
leaq 0x31e74(%rip), %rax     # 0x615c0
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x9110
callq 0x13520
movl %eax, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jg 0x2f7b1
movq -0x18(%rbp), %rdi
callq 0x9110
movq -0x20(%rbp), %rdi
callq 0x9110
movl -0xc(%rbp), %edi
callq 0xca50
callq 0xb8b0
callq 0xc280
movl -0x4(%rbp), %edi
addl $0x2, %edi
movl -0x8(%rbp), %esi
callq 0x2f700
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2f76c
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: rotate_h
void
rotate_h(struct atom *PSI, uint32_t c, int n)
{
	int i;
	n = 1 << n;
	for (i = 0; i < NUMQBITS; i++) {
		if ((i & c) != c)
			continue;
		if (i & n) {
			push(KET0);
			push(KET1);
			add();
			push_rational(1, 2);
			sqrtfunc();
			multiply();
			push(KET0);
			push(KET1);
			subtract();
			push_rational(1, 2);
			sqrtfunc();
			multiply();
			KET1 = pop();
			KET0 = pop();
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x64(%rcx), %eax
jge 0x2ff27
movl -0x14(%rbp), %eax
andl -0xc(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x2fe39
jmp 0x2ff19
movl -0x14(%rbp), %eax
andl -0x10(%rbp), %eax
cmpl $0x0, %eax
je 0x2ff17
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
xorl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movq 0x68(%rax,%rcx,8), %rdi
callq 0x9110
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq 0x68(%rax,%rcx,8), %rdi
callq 0x9110
callq 0xc660
movl $0x1, %edi
movl $0x2, %esi
callq 0xb840
callq 0xfa20
callq 0xc280
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
xorl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movq 0x68(%rax,%rcx,8), %rdi
callq 0x9110
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq 0x68(%rax,%rcx,8), %rdi
callq 0x9110
callq 0xe7e0
movl $0x1, %edi
movl $0x2, %esi
callq 0xb840
callq 0xfa20
callq 0xc280
callq 0x91d0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, 0x68(%rax,%rcx,8)
callq 0x91d0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
xorl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movq %rdx, 0x68(%rax,%rcx,8)
jmp 0x2ff19
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2fe16
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: rotate_p
void
rotate_p(struct atom *PSI, struct atom *PHASE, uint32_t c, int n)
{
	int i;
	n = 1 << n;
	for (i = 0; i < NUMQBITS; i++) {
		if ((i & c) != c)
			continue;
		if (i & n) {
			push(KET1);
			push(PHASE);
			multiply();
			KET1 = pop();
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x18(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x64(%rcx), %eax
jge 0x2ffc9
movl -0x1c(%rbp), %eax
andl -0x14(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x2ff76
jmp 0x2ffbe
movl -0x1c(%rbp), %eax
andl -0x18(%rbp), %eax
cmpl $0x0, %eax
je 0x2ffbc
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq 0x68(%rax,%rcx,8), %rdi
callq 0x9110
movq -0x10(%rbp), %rdi
callq 0x9110
callq 0xc280
callq 0x91d0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, 0x68(%rax,%rcx,8)
jmp 0x2ffbe
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2ff5a
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: rotate_q
void
rotate_q(struct atom *PSI, int n)
{
	int i, j;
	struct atom *PHASE;
	for (i = n; i >= 0; i--) {
		rotate_h(PSI, 0, i);
		for (j = 0; j < i; j++) {
			push_rational(1, 2);
			push_integer(i - j);
			power();
			push(imaginaryunit);
			push_symbol(PI);
			evalf(); // in case PI is numerical
			multiply_factors(3);
			expfunc();
			PHASE = pop();
			rotate_p(PSI, PHASE, 1 << j, i);
		}
	}
	for (i = 0; i < (n + 1) / 2; i++)
		rotate_w(PSI, 0, i, n - i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jl 0x30098
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
xorl %esi, %esi
callq 0x2fdf0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x30088
movl $0x1, %edi
movl $0x2, %esi
callq 0xb840
movl -0x10(%rbp), %edi
subl -0x14(%rbp), %edi
callq 0xca50
callq 0xb8b0
movq 0xf4aae(%rip), %rdi     # 0x124ae0
callq 0x9110
movq 0x2f012(%rip), %rdi     # 0x5f050
callq 0x9110
callq 0xa660
movl $0x3, %edi
callq 0xc3d0
callq 0x14a50
callq 0x91d0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl -0x10(%rbp), %ecx
callq 0x2ff30
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x30004
jmp 0x3008a
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x2ffe5
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x300db
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
movl -0xc(%rbp), %ecx
subl -0x10(%rbp), %ecx
xorl %esi, %esi
callq 0x30210
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3009f
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: rotate_v
void
rotate_v(struct atom *PSI, int n)
{
	int i, j;
	struct atom *PHASE;
	for (i = 0; i < (n + 1) / 2; i++)
		rotate_w(PSI, 0, i, n - i);
	for (i = 0; i <= n; i++) {
		for (j = i - 1; j >= 0; j--) {
			push_rational(1, 2);
			push_integer(i - j);
			power();
			push(imaginaryunit);
			push_symbol(PI);
			evalf(); // in case PI is numerical
			multiply_factors(3);
			negate();
			expfunc();
			PHASE = pop();
			rotate_p(PSI, PHASE, 1 << j, i);
		}
		rotate_h(PSI, 0, i);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x30142
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
movl -0xc(%rbp), %ecx
subl -0x10(%rbp), %ecx
xorl %esi, %esi
callq 0x30210
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x30106
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jg 0x30205
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jl 0x301e9
movl $0x1, %edi
movl $0x2, %esi
callq 0xb840
movl -0x10(%rbp), %edi
subl -0x14(%rbp), %edi
callq 0xca50
callq 0xb8b0
movq 0xf4952(%rip), %rdi     # 0x124ae0
callq 0x9110
movq 0x2eeb6(%rip), %rdi     # 0x5f050
callq 0x9110
callq 0xa660
movl $0x3, %edi
callq 0xc3d0
callq 0xb4b0
callq 0x14a50
callq 0x91d0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl -0x10(%rbp), %ecx
callq 0x2ff30
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3015e
movq -0x8(%rbp), %rdi
movl -0x10(%rbp), %edx
xorl %esi, %esi
callq 0x2fdf0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x30149
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: rotate_w
void
rotate_w(struct atom *PSI, uint32_t c, int m, int n)
{
	int i;
	m = 1 << m;
	n = 1 << n;
	for (i = 0; i < NUMQBITS; i++) {
		if ((i & c) != c)
			continue;
		if ((i & m) && !(i & n)) {
			push(PSI->u.tensor->elem[i]);
			push(PSI->u.tensor->elem[i ^ m ^ n]);
			PSI->u.tensor->elem[i] = pop();
			PSI->u.tensor->elem[i ^ m ^ n] = pop();
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl -0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x64(%rcx), %eax
jge 0x302f9
movl -0x18(%rbp), %eax
andl -0xc(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x30269
jmp 0x302eb
movl -0x18(%rbp), %eax
andl -0x10(%rbp), %eax
cmpl $0x0, %eax
je 0x302e9
movl -0x18(%rbp), %eax
andl -0x14(%rbp), %eax
cmpl $0x0, %eax
jne 0x302e9
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movq 0x68(%rax,%rcx,8), %rdi
callq 0x9110
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x18(%rbp), %ecx
xorl -0x10(%rbp), %ecx
xorl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movq 0x68(%rax,%rcx,8), %rdi
callq 0x9110
callq 0x91d0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movq %rdx, 0x68(%rax,%rcx,8)
callq 0x91d0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x18(%rbp), %ecx
xorl -0x10(%rbp), %ecx
xorl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movq %rdx, 0x68(%rax,%rcx,8)
jmp 0x302eb
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x30246
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: rotate_x
void
rotate_x(struct atom *PSI, uint32_t c, int n)
{
	int i;
	n = 1 << n;
	for (i = 0; i < NUMQBITS; i++) {
		if ((i & c) != c)
			continue;
		if (i & n) {
			push(KET0);
			push(KET1);
			KET0 = pop();
			KET1 = pop();
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x64(%rcx), %eax
jge 0x303c5
movl -0x14(%rbp), %eax
andl -0xc(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x30346
jmp 0x303b7
movl -0x14(%rbp), %eax
andl -0x10(%rbp), %eax
cmpl $0x0, %eax
je 0x303b5
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
xorl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movq 0x68(%rax,%rcx,8), %rdi
callq 0x9110
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq 0x68(%rax,%rcx,8), %rdi
callq 0x9110
callq 0x91d0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
xorl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movq %rdx, 0x68(%rax,%rcx,8)
callq 0x91d0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, 0x68(%rax,%rcx,8)
jmp 0x303b7
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x30326
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: rotate_y
void
rotate_y(struct atom *PSI, uint32_t c, int n)
{
	int i;
	n = 1 << n;
	for (i = 0; i < NUMQBITS; i++) {
		if ((i & c) != c)
			continue;
		if (i & n) {
			push(imaginaryunit);
			push(KET0);
			multiply();
			push(imaginaryunit);
			negate();
			push(KET1);
			multiply();
			KET0 = pop();
			KET1 = pop();
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x64(%rcx), %eax
jge 0x304c3
movl -0x14(%rbp), %eax
andl -0xc(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x30419
jmp 0x304b5
movl -0x14(%rbp), %eax
andl -0x10(%rbp), %eax
cmpl $0x0, %eax
je 0x304b3
movq 0xf46b1(%rip), %rdi     # 0x124ae0
callq 0x9110
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
xorl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movq 0x68(%rax,%rcx,8), %rdi
callq 0x9110
callq 0xc280
movq 0xf4686(%rip), %rdi     # 0x124ae0
callq 0x9110
callq 0xb4b0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq 0x68(%rax,%rcx,8), %rdi
callq 0x9110
callq 0xc280
callq 0x91d0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
xorl -0x10(%rbp), %ecx
movslq %ecx, %rcx
movq %rdx, 0x68(%rax,%rcx,8)
callq 0x91d0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, 0x68(%rax,%rcx,8)
jmp 0x304b5
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x303f6
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: rotate_z
void
rotate_z(struct atom *PSI, uint32_t c, int n)
{
	int i;
	n = 1 << n;
	for (i = 0; i < NUMQBITS; i++) {
		if ((i & c) != c)
			continue;
		if (i & n) {
			push(KET1);
			negate();
			KET1 = pop();
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x64(%rcx), %eax
jge 0x3055c
movl -0x14(%rbp), %eax
andl -0xc(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x30512
jmp 0x30551
movl -0x14(%rbp), %eax
andl -0x10(%rbp), %eax
cmpl $0x0, %eax
je 0x3054f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq 0x68(%rax,%rcx,8), %rdi
callq 0x9110
callq 0xb4b0
callq 0x91d0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, 0x68(%rax,%rcx,8)
jmp 0x30551
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x304f6
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_run
void
eval_run(struct atom *p1)
{
	char *buf;
	struct atom *p2;

	push(cadr(p1));
	evalf();
	p1 = pop();
	if (!isstr(p1))
		stopf("run: file name expected");

	p2 = alloc_str();
	buf = read_file(p1->u.str);
	if (buf == NULL)
		stopf("run: cannot read file");
	p2->u.str = buf;

	push(p2); // make visible to garbage collector
	run_buf(buf);
	pop(); // buf is freed on next gc

	push_symbol(NIL); // return value
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x30597
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x305a2
movq 0x2e462(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x305e2
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x305ca
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x305d5
movq 0x2e42f(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x305ed
movq 0x2e417(%rip), %rax     # 0x5ea00
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x9110
callq 0xa660
callq 0x91d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x6, %eax
je 0x3061d
leaq 0x193bd(%rip), %rdi     # 0x499d5
callq 0x78d0
callq 0x7a90
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x30680
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x30649
leaq 0x193a9(%rip), %rdi     # 0x499ed
callq 0x78d0
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rdi
callq 0x9110
movq -0x10(%rbp), %rdi
callq 0x307a0
callq 0x91d0
movq 0x2e38e(%rip), %rdi     # 0x5ea00
callq 0x9110
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: read_file
char *
read_file(char *filename)
{
	int fd, n;
	char *buf;
	off_t t;

	fd = open(filename, O_RDONLY);

	if (fd < 0)
		return NULL;

	t = lseek(fd, 0, SEEK_END);

	if (t < 0 || t > 0x1000000) { // 16 MB max
		close(fd);
		return NULL;
	}

	if (lseek(fd, 0, SEEK_SET)) {
		close(fd);
		return NULL;
	}

	n = (int) t;

	buf = malloc(n + 1);

	if (buf == NULL) {
		close(fd);
		return NULL;
	}

	if (read(fd, buf, n) != n) {
		free(buf);
		close(fd);
		return NULL;
	}

	close(fd);

	buf[n] = '\0';

	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x72d0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x306af
movq $0x0, -0x8(%rbp)
jmp 0x30795
movl -0x14(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x7110
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jl 0x306d5
cmpq $0x1000000, -0x28(%rbp) # imm = 0x1000000
jle 0x306ea
movl -0x14(%rbp), %edi
callq 0x7140
movq $0x0, -0x8(%rbp)
jmp 0x30795
movl -0x14(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x7110
cmpq $0x0, %rax
je 0x30713
movl -0x14(%rbp), %edi
callq 0x7140
movq $0x0, -0x8(%rbp)
jmp 0x30795
movq -0x28(%rbp), %rax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x7250
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x30745
movl -0x14(%rbp), %edi
callq 0x7140
movq $0x0, -0x8(%rbp)
jmp 0x30795
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0x7190
movslq -0x18(%rbp), %rcx
cmpq %rcx, %rax
je 0x30779
movq -0x20(%rbp), %rdi
callq 0x7040
movl -0x14(%rbp), %edi
callq 0x7140
movq $0x0, -0x8(%rbp)
jmp 0x30795
movl -0x14(%rbp), %edi
callq 0x7140
movq -0x20(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: run_buf
void
run_buf(char *buf)
{
	char *s, *save_trace1, *save_trace2;
	struct atom *p1;

	save_trace1 = trace1;
	save_trace2 = trace2;

	s = buf;

	for (;;) {

		s = scan_input(s); // also updates trace1 and trace2

		if (s == NULL)
			break; // end of input

		dupl();
		evalg();

		// update last

		dupl();
		p1 = pop();

		if (p1 != symbol(NIL))
			set_symbol(symbol(LAST), p1, symbol(NIL));

		print_result();
	}

	trace1 = save_trace1;
	trace2 = save_trace2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq 0xff11d(%rip), %rax     # 0x12f8d0
movq %rax, -0x18(%rbp)
movq 0xff11a(%rip), %rax     # 0x12f8d8
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x42c30
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x307e0
jmp 0x30823
callq 0x29790
callq 0xa610
callq 0x29790
callq 0x91d0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq 0x2e1fd(%rip), %rax     # 0x5ea00
je 0x3081c
movq 0x2dbb4(%rip), %rdi     # 0x5e3c0
movq -0x28(%rbp), %rsi
movq 0x2e1e9(%rip), %rdx     # 0x5ea00
callq 0x1df90
callq 0x2db70
jmp 0x307ca
movq -0x18(%rbp), %rax
movq %rax, 0xff0a2(%rip)     # 0x12f8d0
movq -0x20(%rbp), %rax
movq %rax, 0xff09f(%rip)     # 0x12f8d8
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: sgnfunc
void
sgnfunc(void)
{
	int i, n;
	struct atom *p1, *p2;

	p1 = pop();

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

	p2 = p1;

	if (!isnum(p2)) {
		push(p2);
		floatfunc();
		p2 = pop();
	}

	if (!isnum(p2)) {
		push_symbol(SGN);
		push(p1);
		list(2);
		return;
	}

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

	if (isnegativenumber(p2))
		push_integer(-1);
	else
		push_integer(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x91d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x7, %eax
jne 0x31ff2
movq -0x10(%rbp), %rdi
callq 0xa550
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x64(%rax), %eax
movl %eax, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x31fe4
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movq 0x68(%rax,%rcx,8), %rdi
callq 0x9110
callq 0x31f60
callq 0x91d0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movq %rdx, 0x68(%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x31f9f
movq -0x10(%rbp), %rdi
callq 0x9110
jmp 0x320a1
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x4, %eax
je 0x3202b
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x5, %eax
je 0x3202b
movq -0x18(%rbp), %rdi
callq 0x9110
callq 0xc290
callq 0x91d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x4, %eax
je 0x32066
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x5, %eax
je 0x32066
movq 0x2d964(%rip), %rdi     # 0x5f9b0
callq 0x9110
movq -0x10(%rbp), %rdi
callq 0x9110
movl $0x2, %edi
callq 0x90d0
jmp 0x320a1
movq -0x18(%rbp), %rdi
callq 0xcdc0
cmpl $0x0, %eax
je 0x3207d
xorl %edi, %edi
callq 0xca50
jmp 0x320a1
movq -0x18(%rbp), %rdi
callq 0x9e30
cmpl $0x0, %eax
je 0x32097
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xca50
jmp 0x320a1
movl $0x1, %edi
callq 0xca50
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: simplify
void
simplify(void)
{
	int i, n;
	struct atom *p1;

	p1 = pop();

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

	push(p1);
	simplify_trig(); // do this first otherwise compton-demo runs out of memory
	simplify_nib();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x91d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x7, %eax
jne 0x321df
movq -0x10(%rbp), %rdi
callq 0xa550
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x64(%rax), %eax
movl %eax, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x321d4
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movq 0x68(%rax,%rcx,8), %rdi
callq 0x9110
callq 0x32150
callq 0x91d0
movq %rax, %rdx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movq %rdx, 0x68(%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3218f
movq -0x10(%rbp), %rdi
callq 0x9110
jmp 0x321f2
movq -0x10(%rbp), %rdi
callq 0x9110
callq 0x32200
callq 0x32280
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)