LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: mroot
uint32_t *
mroot(uint32_t *a, uint32_t *n)
{
	int i, j, k;
	uint32_t *b, *c, m;

	if (MLENGTH(n) > 1 || n[0] == 0)
		return NULL;

	// k is bit length of a

	k = 32 * (MLENGTH(a) - 1);

	m = a[MLENGTH(a) - 1];

	while (m) {
		m >>= 1;
		k++;
	}

	if (k == 0)
		return mint(0);

	// initial guess of index of ms bit in result

	k = (k - 1) / n[0];

	j = k / 32 + 1; // k is bit index, not number of bits

	b = mnew(j);

	for (i = 0; i < j; i++)
		b[i] = 0;

	while (k >= 0) {
		msetbit(b, k);
		mnorm(b);
		c = mpow(b, n);
		switch (mcmp(c, a)) {
		case -1:
			break;
		case 0:
			mfree(c);
			return b;
		case 1:
			mclrbit(b, k);
			break;
		}
		mfree(c);
		k--;
	}

	mfree(b);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, -0x30(%rbp)
cmpl $0x1, -0x4(%rsi)
jg 0x85cc
movl (%rsi), %ecx
testl %ecx, %ecx
je 0x85cc
movq -0x30(%rbp), %rax
movslq -0x4(%rax), %rdi
movl -0x4(%rax,%rdi,4), %edx
shll $0x5, %edi
pushq $0x21
popq %rax
subl %edi, %eax
testl %edx, %edx
je 0x8514
shrl %edx
decl %eax
jmp 0x850a
cmpl $0x1, %eax
jne 0x852e
xorl %edi, %edi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7a09
movq %rsi, -0x38(%rbp)
negl %eax
xorl %r14d, %r14d
xorl %edx, %edx
divl %ecx
movl %eax, %r12d
pushq $0x20
popq %rcx
cltd
idivl %ecx
movl %eax, %r13d
incl %r13d
movl %r13d, %edi
callq 0x7d34
movq %rax, %r15
testl %r13d, %r13d
cmovlel %r14d, %r13d
cmpq %r14, %r13
je 0x85bf
andl $0x0, (%r15,%r14,4)
incq %r14
jmp 0x855c
pushq $0x1
popq %r14
movl %r12d, %ecx
shll %cl, %r14d
movl %r12d, %ebx
shrl $0x5, %ebx
orl %r14d, (%r15,%rbx,4)
movq %r15, %rdi
callq 0x7d16
movq %r15, %rdi
movq -0x38(%rbp), %rsi
callq 0x81cc
movq %rax, %r13
movq %rax, %rdi
movq -0x30(%rbp), %rsi
callq 0x82a7
cmpl $0x1, %eax
je 0x85ad
testl %eax, %eax
jne 0x85b4
jmp 0x85e1
notl %r14d
andl %r14d, (%r15,%rbx,4)
movq %r13, %rdi
callq 0x7ad9
decl %r12d
testl %r12d, %r12d
jns 0x856b
movq %r15, %rdi
callq 0x7ad9
xorl %r15d, %r15d
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
callq 0x7ad9
jmp 0x85cf
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: list
void
list(int n)
{
	int i;
	push_symbol(NIL);
	for (i = 0; i < n; i++)
		cons();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
movq 0x363f5(%rip), %rdi     # 0x3e9f0
callq 0x861b
xorl %r14d, %r14d
testl %ebx, %ebx
cmovgl %ebx, %r14d
subl $0x1, %r14d
jb 0x8616
callq 0x865c
jmp 0x8609
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: push
void
push(struct atom *p)
{
	if (tos < 0 || tos >= STACKSIZE)
		stopf("stack error");
	stack[tos++] = p;
	if (tos > max_tos)
		max_tos = tos;
}

// Assembly:
movl 0x2fc87(%rip), %eax     # 0x382a8
cmpq $0x186a0, %rax          # imm = 0x186A0
jae 0x864c
leal 0x1(%rax), %ecx
movl %ecx, 0x2fc76(%rip)     # 0x382a8
leaq 0x38f77(%rip), %rdx     # 0x415b0
movq %rdi, (%rdx,%rax,8)
cmpl 0x106d99(%rip), %eax    # 0x10f3dc
jl 0x864b
movl %ecx, 0x106d91(%rip)    # 0x10f3dc
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1f922(%rip), %rdi     # 0x27f79
callq 0x7756
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: cons
void
cons(void)
{
	struct atom *p;
	p = alloc_atom();
	p->atomtype = CONS;
	p->u.cons.cdr = pop();
	p->u.cons.car = pop();
	push(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x749c
movq %rax, %rbx
movb $0x1, 0x10(%rax)
callq 0x868d
movq %rax, 0x8(%rbx)
callq 0x868d
movq %rax, (%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x861b
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: lengthf
int
lengthf(struct atom *p)
{
	int n = 0;
	while (iscons(p)) {
		n++;
		p = cdr(p);
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
cmpb $0x1, 0x10(%rdi)
jne 0x86d7
incl %eax
movq 0x8(%rdi), %rdi
jmp 0x86c9
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: findf
int
findf(struct atom *p, struct atom *q)
{
	int i;

	if (equal(p, q))
		return 1;

	if (istensor(p)) {
		for (i = 0; i < p->u.tensor->nelem; i++)
			if (findf(p->u.tensor->elem[i], q))
				return 1;
		return 0;
	}

	while (iscons(p)) {
		if (findf(car(p), q))
			return 1;
		p = cdr(p);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x8760
pushq $0x1
popq %rbx
testl %eax, %eax
je 0x8755
movb 0x10(%r15), %al
cmpb $0x7, %al
jne 0x8723
xorl %r12d, %r12d
movq (%r15), %rax
movslq 0x64(%rax), %rcx
cmpq %rcx, %r12
jge 0x8753
movq 0x68(%rax,%r12,8), %rdi
movq %r14, %rsi
callq 0x86d9
incq %r12
testl %eax, %eax
je 0x8701
jmp 0x8755
leaq 0x362c6(%rip), %r12     # 0x3e9f0
cmpb $0x1, %al
jne 0x8753
movq (%r15), %rdi
movq %r14, %rsi
callq 0x86d9
testl %eax, %eax
jne 0x8755
leaq 0x8(%r15), %rax
cmpb $0x1, 0x10(%r15)
cmovneq %r12, %rax
movq (%rax), %r15
movb 0x10(%r15), %al
jmp 0x872a
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: cmp
int
cmp(struct atom *p1, struct atom *p2)
{
	int t;

	if (p1 == p2)
		return 0;

	if (p1 == symbol(NIL))
		return -1;

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

	if (isnum(p1) && isnum(p2))
		return cmp_numbers(p1, p2);

	if (isnum(p1))
		return -1;

	if (isnum(p2))
		return 1;

	if (isstr(p1) && isstr(p2))
		return strcmp(p1->u.str, p2->u.str);

	if (isstr(p1))
		return -1;

	if (isstr(p2))
		return 1;

	if (issymbol(p1) && issymbol(p2))
		return strcmp(printname(p1), printname(p2));

	if (issymbol(p1))
		return -1;

	if (issymbol(p2))
		return 1;

	if (istensor(p1) && istensor(p2))
		return cmp_tensors(p1, p2);

	if (istensor(p1))
		return -1;

	if (istensor(p2))
		return 1;

	while (iscons(p1) && iscons(p2)) {
		t = cmp(car(p1), car(p2));
		if (t)
			return t;
		p1 = cdr(p1);
		p2 = cdr(p2);
	}

	if (iscons(p2))
		return -1; // lengthf(p1) < lengthf(p2)

	if (iscons(p1))
		return 1; // lengthf(p1) > lengthf(p2)

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpq %rsi, %rdi
je 0x87c0
movq %rdi, %r14
movq 0x36276(%rip), %rcx     # 0x3e9f0
pushq $-0x1
popq %rax
cmpq %rdi, %rcx
je 0x87cd
movq %rsi, %rbx
pushq $0x1
popq %r15
cmpq %rsi, %rcx
je 0x87ca
movb 0x10(%r14), %cl
movl %ecx, %edi
andb $-0x2, %dil
movb 0x10(%rbx), %dl
movl %edx, %esi
andb $-0x2, %sil
cmpb $0x4, %dil
jne 0x87c4
cmpb $0x4, %sil
jne 0x87cd
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8924
xorl %eax, %eax
jmp 0x87cd
cmpb $0x4, %sil
jne 0x87d6
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %ecx, %r8d
xorb $0x6, %r8b
movl %edx, %r9d
xorb $0x6, %r9b
orb %r8b, %r9b
jne 0x87fc
movq (%r14), %rdi
movq (%rbx), %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x71e0
cmpb $0x6, %dl
sete %r10b
xorl %r8d, %r8d
cmpb $0x6, %cl
sete %r9b
orb %r9b, %r10b
je 0x8821
movb %r9b, %r8b
negl %r8d
orl $0x1, %r8d
movl %r8d, %eax
jmp 0x87cd
cmpb $0x2, %dil
jne 0x882f
cmpb $0x2, %sil
jne 0x87cd
jmp 0x87e9
cmpb $0x2, %sil
je 0x87ca
movl %ecx, %eax
xorb $0x7, %al
movl %edx, %esi
xorb $0x7, %sil
orb %al, %sil
jne 0x8857
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x899e
cmpb $0x7, %dl
sete %sil
xorl %eax, %eax
cmpb $0x7, %cl
sete %dl
orb %dl, %sil
je 0x8877
movb %dl, %al
negl %eax
orl $0x1, %eax
jmp 0x87cd
leaq 0x36172(%rip), %r12     # 0x3e9f0
movb 0x10(%rbx), %dl
cmpb $0x1, %cl
jne 0x88c7
cmpb $0x1, %dl
jne 0x87ca
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x8760
testl %eax, %eax
jne 0x87cd
leaq 0x8(%r14), %rax
cmpb $0x1, 0x10(%r14)
cmovneq %r12, %rax
movq (%rax), %r14
leaq 0x8(%rbx), %rax
cmpb $0x1, 0x10(%rbx)
cmovneq %r12, %rax
movq (%rax), %rbx
movb 0x10(%r14), %cl
jmp 0x887e
xorl %eax, %eax
cmpb $0x1, %dl
sete %al
negl %eax
jmp 0x87cd
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: cmp_numbers
int
cmp_numbers(struct atom *p1, struct atom *p2)
{
	double d1, d2;

	if (isrational(p1) && isrational(p2))
		return cmp_rationals(p1, p2);

	push(p1);
	d1 = pop_double();

	push(p2);
	d2 = pop_double();

	if (d1 < d2)
		return -1;

	if (d1 > d2)
		return 1;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x4, 0x10(%rdi)
jne 0x8947
cmpb $0x4, 0x10(%rbx)
jne 0x8947
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8a1a
callq 0x861b
callq 0x8ae1
movsd %xmm0, -0x10(%rbp)
movq %rbx, %rdi
callq 0x861b
callq 0x8ae1
movsd -0x10(%rbp), %xmm1
ucomisd %xmm1, %xmm0
jbe 0x8973
pushq $-0x1
popq %rax
jmp 0x897c
xorl %eax, %eax
ucomisd %xmm0, %xmm1
seta %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: cmp_tensors
int
cmp_tensors(struct atom *p1, struct atom *p2)
{
	int i, t;

	t = p1->u.tensor->ndim - p2->u.tensor->ndim;

	if (t)
		return t;

	for (i = 0; i < p1->u.tensor->ndim; i++) {
		t = p1->u.tensor->dim[i] - p2->u.tensor->dim[i];
		if (t)
			return t;
	}

	for (i = 0; i < p1->u.tensor->nelem; i++) {
		t = cmp(p1->u.tensor->elem[i], p2->u.tensor->elem[i]);
		if (t)
			return t;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %rax
movl (%rax), %ecx
movq (%rsi), %rdx
movl %ecx, %r15d
subl (%rdx), %r15d
jne 0x8a0e
movq %rsi, %rbx
movq %rdi, %r14
xorl %esi, %esi
testl %ecx, %ecx
cmovlel %esi, %ecx
cmpq %rsi, %rcx
je 0x89e0
movl 0x4(%rax,%rsi,4), %r15d
leaq 0x1(%rsi), %rdi
subl 0x4(%rdx,%rsi,4), %r15d
movq %rdi, %rsi
je 0x89c6
jmp 0x8a0e
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%r14), %rax
movslq 0x64(%rax), %rcx
cmpq %rcx, %r12
jge 0x8a0e
movq 0x68(%rax,%r12,8), %rdi
movq (%rbx), %rax
movq 0x68(%rax,%r12,8), %rsi
callq 0x8760
incq %r12
testl %eax, %eax
je 0x89e6
movl %eax, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: cmp_rationals
int
cmp_rationals(struct atom *a, struct atom *b)
{
	int t;
	uint32_t *ab, *ba;
	if (a->sign == MMINUS && b->sign == MPLUS)
		return -1;
	if (a->sign == MPLUS && b->sign == MMINUS)
		return 1;
	if (isinteger(a) && isinteger(b)) {
		if (a->sign == MMINUS)
			return mcmp(b->u.q.a, a->u.q.a);
		else
			return mcmp(a->u.q.a, b->u.q.a);
	}
	ab = mmul(a->u.q.a, b->u.q.b);
	ba = mmul(a->u.q.b, b->u.q.a);
	if (a->sign == MMINUS)
		t = mcmp(ba, ab);
	else
		t = mcmp(ab, ba);
	mfree(ab);
	mfree(ba);
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movb 0x12(%rdi), %r15b
cmpb $0x1, %r15b
jne 0x8a3f
cmpb $0x0, 0x12(%r14)
jne 0x8a50
pushq $-0x1
jmp 0x8a4d
testb %r15b, %r15b
jne 0x8a50
cmpb $0x1, 0x12(%r14)
jne 0x8a50
pushq $0x1
popq %rbx
jmp 0x8abf
movq %rbx, %rdi
callq 0x8b5d
testl %eax, %eax
je 0x8a76
movq %r14, %rdi
callq 0x8b5d
testl %eax, %eax
je 0x8a76
cmpb $0x1, %r15b
jne 0x8acc
movq (%r14), %rdi
movq (%rbx), %rsi
jmp 0x8ad2
movq (%rbx), %rdi
movq 0x8(%r14), %rsi
callq 0x7a22
movq %rax, %r15
movq 0x8(%rbx), %rdi
movq (%r14), %rsi
callq 0x7a22
movq %rax, %r14
cmpb $0x1, 0x12(%rbx)
jne 0x8aa2
movq %r14, %rdi
movq %r15, %rsi
jmp 0x8aa8
movq %r15, %rdi
movq %r14, %rsi
callq 0x82a7
movl %eax, %ebx
movq %r15, %rdi
callq 0x7ad9
movq %r14, %rdi
callq 0x7ad9
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
movq (%r14), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x82a7
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: pop_double
double
pop_double(void)
{
	double a, b, d;
	struct atom *p;

	p = pop();

	if (!isnum(p))
		stopf("number expected");

	if (isdouble(p))
		d = p->u.d;
	else {
		a = mfloat(p->u.q.a);
		b = mfloat(p->u.q.b);
		d = a / b;
		if (isnegativenumber(p))
			d = -d;
	}

	return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
callq 0x868d
movq %rax, %rbx
movb 0x10(%rax), %al
movl %eax, %ecx
andb $-0x2, %cl
cmpb $0x4, %cl
jne 0x8b51
cmpb $0x5, %al
jne 0x8b09
movsd (%rbx), %xmm0
jmp 0x8b4a
movq (%rbx), %rdi
callq 0x7878
movapd %xmm0, -0x20(%rbp)
movq 0x8(%rbx), %rdi
callq 0x7878
movapd -0x20(%rbp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, -0x20(%rbp)
movq %rbx, %rdi
callq 0x8c2a
testl %eax, %eax
je 0x8b46
movaps -0x20(%rbp), %xmm0
xorps 0x1a5cc(%rip), %xmm0    # 0x23110
jmp 0x8b4a
movaps -0x20(%rbp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1f444(%rip), %rdi     # 0x27f9c
callq 0x7756
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: find_denominator
int
find_denominator(struct atom *p)
{
	struct atom *q;
	p = cdr(p);
	while (iscons(p)) {
		q = car(p);
		if (car(q) == symbol(POWER) && isnegativenumber(caddr(q)))
			return 1;
		p = cdr(p);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %r14
leaq 0x35e56(%rip), %r15     # 0x3e9f0
cmovneq %r15, %r14
movq 0x386fb(%rip), %r12     # 0x412a0
movq 0x35e44(%rip), %r13     # 0x3e9f0
pushq $0x1
popq %rbx
movq (%r14), %r14
cmpb $0x1, 0x10(%r14)
jne 0x8c17
movq (%r14), %rax
movb 0x10(%rax), %cl
cmpb $0x1, %cl
movq %r15, %rdx
cmoveq %rax, %rdx
cmpq %r12, (%rdx)
jne 0x8c11
addq $0x8, %rax
cmpb $0x1, %cl
cmovneq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
jne 0x8bf5
movq 0x8(%rax), %rcx
cmpb $0x1, 0x10(%rcx)
movq %r15, %rcx
jne 0x8c05
addq $0x8, %rax
jmp 0x8c02
cmpb $0x1, 0x10(%r13)
movq %r15, %rax
movq %r15, %rcx
jne 0x8c05
movq (%rax), %rcx
movq (%rcx), %rdi
callq 0x8c2a
testl %eax, %eax
jne 0x8c19
addq $0x8, %r14
jmp 0x8baf
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: count_denominators
int
count_denominators(struct atom *p)
{
	int n = 0;
	p = cdr(p);
	while (iscons(p)) {
		if (isdenominator(car(p)))
			n++;
		p = cdr(p);
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x8(%rdi), %rax
cmpb $0x1, 0x10(%rdi)
leaq 0x35d81(%rip), %r14     # 0x3e9f0
cmoveq %rax, %r14
xorl %ebx, %ebx
movq (%r14), %r14
cmpb $0x1, 0x10(%r14)
jne 0x8c8f
movq (%r14), %rdi
callq 0x8c96
addl %eax, %ebx
addq $0x8, %r14
jmp 0x8c75
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: isdenominator
int
isdenominator(struct atom *p)
{
	if (car(p) == symbol(POWER) && isnegativenumber(caddr(p)))
		return 1;
	else if (isrational(p) && !MEQUAL(p->u.q.b, 1))
		return 1;
	else
		return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movb 0x10(%rdi), %r15b
cmpb $0x1, %r15b
leaq 0x35d3e(%rip), %rax     # 0x3e9f0
movq %rax, %rcx
cmoveq %rdi, %rcx
movq (%rcx), %rcx
pushq $0x1
popq %rbx
cmpq 0x385da(%rip), %rcx     # 0x412a0
je 0x8ce1
cmpb $0x4, %r15b
jne 0x8cdd
movq 0x8(%r14), %rax
cmpl $0x1, -0x4(%rax)
jne 0x8d18
cmpl $0x1, (%rax)
jne 0x8d18
xorl %ebx, %ebx
jmp 0x8d18
leaq 0x8(%r14), %rcx
cmpb $0x1, %r15b
cmovneq %rax, %rcx
movq (%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0x8cfc
movq 0x8(%rcx), %rcx
jmp 0x8d03
movq 0x35ced(%rip), %rcx     # 0x3e9f0
cmpb $0x1, 0x10(%rcx)
jne 0x8d0c
movq %rcx, %rax
movq (%rax), %rdi
callq 0x8c2a
testl %eax, %eax
je 0x8cc8
movl %ebx, %eax
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: count_numerators
int
count_numerators(struct atom *p)
{
	int n = 0;
	p = cdr(p);
	while (iscons(p)) {
		if (isnumerator(car(p)))
			n++;
		p = cdr(p);
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x8(%rdi), %rax
cmpb $0x1, 0x10(%rdi)
leaq 0x35cb5(%rip), %r14     # 0x3e9f0
cmoveq %rax, %r14
xorl %ebx, %ebx
movq (%r14), %r14
cmpb $0x1, 0x10(%r14)
jne 0x8d5b
movq (%r14), %rdi
callq 0x8d62
addl %eax, %ebx
addq $0x8, %r14
jmp 0x8d41
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: isnumerator
int
isnumerator(struct atom *p)
{
	if (car(p) == symbol(POWER) && isnegativenumber(caddr(p)))
		return 0;
	else if (isrational(p) && MEQUAL(p->u.q.a, 1))
		return 0;
	else
		return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb 0x10(%rdi), %r14b
cmpb $0x1, %r14b
leaq 0x35c75(%rip), %rax     # 0x3e9f0
movq %rax, %rcx
cmoveq %rdi, %rcx
movq (%rcx), %rcx
cmpq 0x38514(%rip), %rcx     # 0x412a0
je 0x8da7
cmpb $0x4, %r14b
jne 0x8da2
movq (%rbx), %rax
cmpl $0x1, -0x4(%rax)
jne 0x8da2
cmpl $0x1, (%rax)
je 0x8dde
pushq $0x1
popq %rax
jmp 0x8de0
leaq 0x8(%rbx), %rcx
cmpb $0x1, %r14b
cmovneq %rax, %rcx
movq (%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0x8dc2
movq 0x8(%rcx), %rcx
jmp 0x8dc9
movq 0x35c27(%rip), %rcx     # 0x3e9f0
cmpb $0x1, 0x10(%rcx)
jne 0x8dd2
movq %rcx, %rax
movq (%rax), %rdi
callq 0x8c2a
testl %eax, %eax
je 0x8d8e
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: subst
void
subst(void)
{
	int h, i, n;
	struct atom *p1, *p2, *p3;

	p3 = pop(); // new expr
	p2 = pop(); // old expr
	p1 = pop(); // expr

	if (p2 == symbol(NIL) || p3 == symbol(NIL)) {
		push(p1);
		return;
	}

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

	if (equal(p1, p2)) {
		push(p3);
		return;
	}

	if (!iscons(p1)) {
		push(p1);
		return;
	}

	// depth first

	h = tos;

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

	list(tos - h);
}

// 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
callq 0x868d
movq %rax, %r15
movq 0x35bde(%rip), %rax     # 0x3e9f0
cmpq %rax, %r14
sete %cl
cmpq %rax, %rbx
sete %al
orb %cl, %al
cmpb $0x1, %al
jne 0x8e3a
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x861b
cmpb $0x7, 0x10(%r15)
jne 0x8e96
movq %r15, %rdi
callq 0x8f1b
movq %rax, %r15
movq (%rax), %rax
movl 0x64(%rax), %r12d
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
cmpq %r13, %r12
je 0x8e24
movq (%r15), %rax
movq 0x68(%rax,%r13,8), %rdi
callq 0x861b
movq %r14, %rdi
callq 0x861b
movq %rbx, %rdi
callq 0x861b
callq 0x8de5
callq 0x868d
movq (%r15), %rcx
movq %rax, 0x68(%rcx,%r13,8)
incq %r13
jmp 0x8e5d
movq %r15, %rdi
movq %r14, %rsi
callq 0x8760
testl %eax, %eax
je 0x8ef7
cmpb $0x1, 0x10(%r15)
jne 0x8e24
movb $0x1, %al
movl 0x2f3ef(%rip), %r12d    # 0x382a8
leaq 0x35b30(%rip), %r13     # 0x3e9f0
cmpb $0x1, %al
jne 0x8eff
movq (%r15), %rdi
callq 0x861b
movq %r14, %rdi
callq 0x861b
movq %rbx, %rdi
callq 0x861b
callq 0x8de5
leaq 0x8(%r15), %rax
cmpb $0x1, 0x10(%r15)
cmovneq %r13, %rax
movq (%rax), %r15
movb 0x10(%r15), %al
jmp 0x8ec0
movq %rbx, %rdi
jmp 0x8e27
movl 0x2f3a3(%rip), %edi     # 0x382a8
subl %r12d, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x85eb
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: copy_tensor
struct atom *
copy_tensor(struct atom *p1)
{
	int i;
	struct atom *p2;

	p2 = alloc_tensor(p1->u.tensor->nelem);

	p2->u.tensor->ndim = p1->u.tensor->ndim;

	for (i = 0; i < p1->u.tensor->ndim; i++)
		p2->u.tensor->dim[i] = p1->u.tensor->dim[i];

	for (i = 0; i < p1->u.tensor->nelem; i++)
		p2->u.tensor->elem[i] = p1->u.tensor->elem[i];

	return p2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movl 0x64(%rax), %edi
callq 0x77da
movq (%rbx), %rcx
movl (%rcx), %ecx
movq (%rax), %rdx
movl %ecx, (%rdx)
xorl %edx, %edx
movq (%rbx), %rcx
movslq (%rcx), %rsi
cmpq %rsi, %rdx
jge 0x8f56
movl 0x4(%rcx,%rdx,4), %ecx
movq (%rax), %rsi
movl %ecx, 0x4(%rsi,%rdx,4)
incq %rdx
jmp 0x8f3b
xorl %edx, %edx
movslq 0x64(%rcx), %rsi
cmpq %rsi, %rdx
jge 0x8f76
movq 0x68(%rcx,%rdx,8), %rcx
movq (%rax), %rsi
movq %rcx, 0x68(%rsi,%rdx,8)
incq %rdx
movq (%rbx), %rcx
jmp 0x8f58
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: evalg
void
evalg(void)
{
	if (gc_level == eval_level && alloc_count > MAXBLOCKS * BLOCKSIZE / 10)
		gc();
	gc_level++;
	evalf();
	gc_level--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0xfbb29(%rip), %eax     # 0x104ab0
cmpl 0xfbb27(%rip), %eax     # 0x104ab4
jne 0x8fa6
cmpl $0x1e8481, 0x2f307(%rip) # imm = 0x1E8481
jl 0x8fa6
callq 0x756a
movl 0xfbb0a(%rip), %eax     # 0x104ab0
incl %eax
movl %eax, 0xfbb02(%rip)     # 0x104ab0
callq 0x8fbb
decl 0xfbaf7(%rip)           # 0x104ab0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: evalf
void
evalf(void)
{
	struct atom *p;
	eval_level++;
	p = pop();
	push(p); // make visible to garbage collector
	evalf_nib(p);
	p = pop();
	pop(); // remove
	push(p);
	eval_level--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
incl 0xfbaed(%rip)           # 0x104ab4
callq 0x868d
movq %rax, %rbx
movq %rax, %rdi
callq 0x861b
movq %rbx, %rdi
callq 0x9001
callq 0x868d
movq %rax, %rbx
callq 0x868d
movq %rbx, %rdi
callq 0x861b
decl 0xfbaba(%rip)           # 0x104ab4
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: evalf_nib
void
evalf_nib(struct atom *p1)
{
	if (interrupt)
		stopf("interrupt");

	// this is needed to prevent seg fault (STACKSIZE is greater than process stack)

	if (eval_level > 1000)
		stopf("evaluation depth exceeded, possibly due to recursive function or circular symbol definition");

	if (eval_level > max_eval_level)
		max_eval_level = eval_level;

	if (iscons(p1) && iskeyword(car(p1))) {
		expanding++;
		car(p1)->u.ksym.func(p1); // call through function pointer
		expanding--;
		return;
	}

	if (iscons(p1) && isusersymbol(car(p1))) {
		eval_user_function(p1);
		return;
	}

	if (iskeyword(p1)) { // bare keyword
		push(p1);
		push_symbol(LAST); // default arg
		list(2);
		evalg();
		return;
	}

	if (isusersymbol(p1)) {
		eval_user_symbol(p1);
		return;
	}

	if (istensor(p1)) {
		eval_tensor(p1);
		return;
	}

	push(p1); // rational, double, or string
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0xfbaac(%rip)     # 0x104ab8
jne 0x90a5
movl 0xfba9c(%rip), %eax     # 0x104ab4
cmpl $0x3e9, %eax            # imm = 0x3E9
jge 0x90b1
cmpl 0xfba93(%rip), %eax     # 0x104abc
jle 0x9031
movl %eax, 0xfba8b(%rip)     # 0x104abc
movzbl 0x10(%rdi), %eax
decl %eax
cmpl $0x6, %eax
ja 0x906e
leaq 0x19fd9(%rip), %rcx     # 0x2301c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rdi), %rax
movzbl 0x10(%rax), %ecx
cmpl $0x3, %ecx
je 0x909f
cmpl $0x2, %ecx
jne 0x906e
incl 0xfba5d(%rip)           # 0x104ac0
callq *0x8(%rax)
decl 0xfba54(%rip)           # 0x104ac0
popq %rbp
retq
popq %rbp
jmp 0x861b
popq %rbp
jmp 0x9387
callq 0x861b
movq 0x3532a(%rip), %rdi     # 0x3e3b0
callq 0x861b
pushq $0x2
popq %rdi
callq 0x85eb
popq %rbp
jmp 0x8f7d
popq %rbp
jmp 0x93bb
popq %rbp
jmp 0x90bd
leaq 0x1a149(%rip), %rdi     # 0x231f5
callq 0x7756
leaq 0x1a147(%rip), %rdi     # 0x231ff
callq 0x7756
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_user_symbol
void
eval_user_symbol(struct atom *p1)
{
	struct atom *p2;
	p2 = get_binding(p1);
	if (p1 == p2)
		push(p1); // symbol evaluates to itself
	else {
		push(p2); // evaluate symbol binding
		evalg();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xd3b4
cmpq %rbx, %rax
je 0x93ad
movq %rax, %rdi
callq 0x861b
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8f7d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x861b
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_tensor
void
eval_tensor(struct atom *p1)
{
	int i;

	p1 = copy_tensor(p1);

	for (i = 0; i < p1->u.tensor->nelem; i++) {
		push(p1->u.tensor->elem[i]);
		evalf();
		p1->u.tensor->elem[i] = pop();
	}

	push(p1);

	promote_tensor();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
callq 0x8f1b
movq %rax, %rbx
xorl %r14d, %r14d
movq (%rbx), %rax
movslq 0x64(%rax), %rcx
cmpq %rcx, %r14
jge 0x93fa
movq 0x68(%rax,%r14,8), %rdi
callq 0x861b
callq 0x8fbb
callq 0x868d
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r14,8)
incq %r14
jmp 0x93cd
movq %rbx, %rdi
callq 0x861b
popq %rbx
popq %r14
popq %rbp
jmp 0x1ced1
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: evalp
void
evalp(void)
{
	struct atom *p1;
	p1 = pop();
	if (car(p1) == symbol(SETQ)) {
		push_symbol(TESTEQ);
		push(cadr(p1));
		push(caddr(p1));
		list(3);
		p1 = pop();
	}
	push(p1);
	evalg();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x868d
movq %rax, %rbx
cmpb $0x1, 0x10(%rax)
leaq 0x355c8(%rip), %r14     # 0x3e9f0
movq %r14, %rax
cmoveq %rbx, %rax
movq (%rax), %rax
cmpq 0x37e77(%rip), %rax     # 0x412b0
jne 0x94ab
movq 0x3689e(%rip), %rdi     # 0x3fce0
callq 0x861b
movq %rbx, %r15
addq $0x8, %r15
cmpb $0x1, 0x10(%rbx)
movq %r14, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rax
movq (%rax), %rdi
callq 0x861b
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
jne 0x9483
movq 0x8(%rax), %rax
jmp 0x948a
movq 0x35566(%rip), %rax     # 0x3e9f0
cmpb $0x1, 0x10(%rax)
jne 0x9493
movq %rax, %r14
movq (%r14), %rdi
callq 0x861b
pushq $0x3
popq %rdi
callq 0x85eb
callq 0x868d
movq %rax, %rbx
movq %rbx, %rdi
callq 0x861b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8f7d
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: floatfunc
void
floatfunc(void)
{
	floatfunc_subst();
	evalf();
	floatfunc_subst(); // in case pi popped up
	evalf();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x11fe9
callq 0x8fbb
callq 0x11fe9
popq %rbp
jmp 0x8fbb
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: multiply_factors
void
multiply_factors(int n)
{
	int h;
	struct atom *T;

	if (n < 2)
		return;

	h = tos - n;

	flatten_factors(h);

	T = multiply_tensor_factors(h);

	multiply_scalar_factors(h);

	if (istensor(T)) {
		push(T);
		inner();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $0x2, %edi
jl 0xa094
movl 0x2e249(%rip), %r14d    # 0x382a8
subl %edi, %r14d
movl %r14d, %edi
callq 0x15d46
movl %r14d, %edi
callq 0x15de4
movq %rax, %rbx
movl %r14d, %edi
callq 0x15e60
cmpb $0x7, 0x10(%rbx)
jne 0xa094
movq %rbx, %rdi
callq 0x861b
popq %rbx
popq %r14
popq %rbp
jmp 0x9780
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_add
void
eval_add(struct atom *p1)
{
	int h = tos;
	expanding--; // undo expanding++ in evalf
	p1 = cdr(p1);
	while (iscons(p1)) {
		push(car(p1));
		evalg();
		p1 = cdr(p1);
	}
	add_terms(tos - h);
	expanding++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x2e1fb(%rip), %r14d    # 0x382a8
decl 0xfaa0d(%rip)           # 0x104ac0
leaq 0x34936(%rip), %r15     # 0x3e9f0
leaq 0x8(%rbx), %rax
cmpb $0x1, 0x10(%rbx)
cmovneq %r15, %rax
movq (%rax), %rbx
cmpb $0x1, 0x10(%rbx)
jne 0xa0de
movq (%rbx), %rdi
callq 0x861b
callq 0x8f7d
jmp 0xa0ba
movl 0x2e1c4(%rip), %edi     # 0x382a8
subl %r14d, %edi
callq 0xa0fd
incl 0xfa9ce(%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: add_terms
void
add_terms(int n)
{
	int h, i;
	struct atom *p, *T;

	if (n < 2)
		return;

	h = tos - n;

	flatten_terms(h);

	T = combine_tensors(h);

	combine_terms(h);
	normalize_terms(h);

	n = tos - h;

	if (n == 0) {
		if (istensor(T))
			push(T);
		else
			push_integer(0);
		return;
	}

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

	if (!istensor(T))
		return;

	// add scalar p to every element of T, as is done in R

	p = pop();
	T = copy_tensor(T);
	n = T->u.tensor->nelem;
	for (i = 0; i < n; i++) {
		push(T->u.tensor->elem[i]);
		push(p);
		add();
		T->u.tensor->elem[i] = pop();
	}
	push(T);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x2, %edi
jge 0xa116
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl 0x2e18b(%rip), %r14d    # 0x382a8
subl %edi, %r14d
movl %r14d, %edi
callq 0xa205
movl %r14d, %edi
callq 0xa2a3
movq %rax, %rbx
movl %r14d, %edi
callq 0xa31f
movl %r14d, %edi
callq 0xa394
movl 0x2e15f(%rip), %edi     # 0x382a8
subl %r14d, %edi
jne 0xa168
cmpb $0x7, 0x10(%rbx)
jne 0xa1e7
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x861b
cmpl $0x2, %edi
jl 0xa188
callq 0x85eb
movq 0x37117(%rip), %rdi     # 0x41290
callq 0x861b
callq 0xa49b
callq 0x865c
cmpb $0x7, 0x10(%rbx)
jne 0xa10d
callq 0x868d
movq %rax, %r14
movq %rbx, %rdi
callq 0x8f1b
movq %rax, %rbx
movq (%rax), %rax
movl 0x64(%rax), %r15d
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
cmpq %r12, %r15
je 0xa158
movq (%rbx), %rax
movq 0x68(%rax,%r12,8), %rdi
callq 0x861b
movq %r14, %rdi
callq 0x861b
callq 0xa1f6
callq 0x868d
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r12,8)
incq %r12
jmp 0xa1b6
xorl %edi, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa426
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: flatten_terms
void
flatten_terms(int h)
{
	int i, n;
	struct atom *p1;
	n = tos;
	for (i = h; i < n; i++) {
		p1 = stack[i];
		if (car(p1) == symbol(ADD)) {
			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 0x2e08e(%rip), %rbx     # 0x382a8
movslq %edi, %r14
leaq 0x3738c(%rip), %r15     # 0x415b0
leaq 0x347c5(%rip), %r12     # 0x3e9f0
cmpq %rbx, %r14
jge 0xa294
movq (%r15,%r14,8), %rax
movb 0x10(%rax), %cl
cmpb $0x1, %cl
movq %r12, %rdx
cmoveq %rax, %rdx
movq (%rdx), %rdx
cmpq 0x37045(%rip), %rdx     # 0x41290
je 0xa252
incq %r14
jmp 0xa22b
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 0xa24d
movq (%r13), %rdi
callq 0x861b
jmp 0xa272
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: combine_tensors
struct atom *
combine_tensors(int h)
{
	int i;
	struct atom *p1, *T;
	T = symbol(NIL);
	for (i = h; i < tos; i++) {
		p1 = stack[i];
		if (istensor(p1)) {
			if (istensor(T)) {
				push(T);
				push(p1);
				add_tensors();
				T = pop();
			} else
				T = p1;
			slice(i, 1);
			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 0x34739(%rip), %rdi     # 0x3e9f0
movl 0x2dfeb(%rip), %eax     # 0x382a8
leaq 0x372ec(%rip), %r12     # 0x415b0
pushq $0x1
popq %r14
cmpl %eax, %ebx
jge 0xa313
movslq %ebx, %rcx
movq (%r12,%rcx,8), %r15
cmpb $0x7, 0x10(%r15)
jne 0xa30f
cmpb $0x7, 0x10(%rdi)
jne 0xa2fa
callq 0x861b
movq %r15, %rdi
callq 0x861b
callq 0xa4c6
callq 0x868d
movq %rax, %r15
movl %ebx, %edi
movl %r14d, %esi
callq 0xa55e
decl %ebx
movl 0x2df9c(%rip), %eax     # 0x382a8
movq %r15, %rdi
incl %ebx
jmp 0xa2c8
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: combine_terms
void
combine_terms(int h)
{
	int i;
	sort_terms(h);
	for (i = h; i < tos; i++) {
		if (iszero(stack[i])) {
			slice(i, 1); // remove
			i--; // use same index again
		} else if (i + 1 < tos && combine_terms_nib(i)) {
			slice(i + 1, 1); // remove
			i--; // use same index again
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
callq 0xa60e
leaq 0x37275(%rip), %r12     # 0x415b0
pushq $0x1
popq %r14
movl 0x2df62(%rip), %r13d    # 0x382a8
cmpl %r13d, %ebx
jge 0xa385
movslq %ebx, %rax
movq (%r12,%rax,8), %rdi
callq 0xa641
movl %ebx, %r15d
testl %eax, %eax
je 0xa36d
movl %r15d, %edi
movl %r14d, %esi
callq 0xa55e
decl %ebx
jmp 0xa381
leal 0x1(%rbx), %r15d
cmpl %r13d, %r15d
jge 0xa381
movl %ebx, %edi
callq 0xa6bd
testl %eax, %eax
jne 0xa35e
incl %ebx
jmp 0xa33f
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: normalize_terms
void
normalize_terms(int h)
{
	int i, n;
	struct atom *p;
	n = 0;
	for (i = h; i < tos; i++) {
		p = stack[i];
		if (isradicalterm(p)) {
			push(p);
			evalf();
			stack[i] = pop();
			n++;
		}
	}
	if (n)
		combine_terms(h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, -0x2c(%rbp)
movslq %edi, %r15
movl 0x2defa(%rip), %ebx     # 0x382a8
leaq 0x371fb(%rip), %rax     # 0x415b0
leaq (%rax,%r15,8), %r13
xorl %r12d, %r12d
movslq %ebx, %rax
cmpq %rax, %r15
jge 0xa3fc
movq (%r13), %r14
movq %r14, %rdi
callq 0xad58
testl %eax, %eax
je 0xa3f3
movq %r14, %rdi
callq 0x861b
callq 0x8fbb
callq 0x868d
movq %rax, (%r13)
incl %r12d
movl 0x2deb5(%rip), %ebx     # 0x382a8
incq %r15
addq $0x8, %r13
jmp 0xa3bc
testl %r12d, %r12d
je 0xa417
movl -0x2c(%rbp), %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xa31f
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: push_integer
void
push_integer(int n)
{
	switch (n) {
	case 0:
		push(zero);
		break;
	case 1:
		push(one);
		break;
	case -1:
		push(minusone);
		break;
	default:
		if (n < 0)
			push_bignum(MMINUS, mint(-n), mint(1));
		else
			push_bignum(MPLUS, mint(n), mint(1));
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $-0x1, %edi
je 0xa44d
cmpl $0x1, %edi
je 0xa444
testl %edi, %edi
jne 0xa45d
movq 0x31cee(%rip), %rdi     # 0x3c130
jmp 0xa454
movq 0xfa67d(%rip), %rdi     # 0x104ac8
jmp 0xa454
movq 0x104f8c(%rip), %rdi    # 0x10f3e0
popq %rbx
popq %r14
popq %rbp
jmp 0x861b
js 0xa473
callq 0x7a09
movq %rax, %rbx
pushq $0x1
popq %rdi
callq 0x7a09
xorl %edi, %edi
jmp 0xa48c
negl %edi
callq 0x7a09
movq %rax, %rbx
pushq $0x1
popq %r14
movl %r14d, %edi
callq 0x7a09
movl %r14d, %edi
movq %rbx, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0xb015
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: swap
void
swap(void)
{
	struct atom *p1, *p2;
	p1 = pop();
	p2 = pop();
	push(p1);
	push(p2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
callq 0x868d
movq %rax, %rbx
callq 0x868d
movq %rax, %r14
movq %rbx, %rdi
callq 0x861b
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x861b
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: add_tensors
void
add_tensors(void)
{
	int i, n;
	struct atom *p1, *p2;

	p2 = pop();
	p1 = pop();

	if (!compatible_dimensions(p1, p2))
		stopf("incompatible tensor arithmetic");

	p1 = copy_tensor(p1);

	n = p1->u.tensor->nelem;

	for (i = 0; i < n; i++) {
		push(p1->u.tensor->elem[i]);
		push(p2->u.tensor->elem[i]);
		add();
		p1->u.tensor->elem[i] = pop();
	}

	push(p1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
callq 0x868d
movq %rax, %rbx
callq 0x868d
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa5bd
testl %eax, %eax
je 0xa552
movq %r14, %rdi
callq 0x8f1b
movq %rax, %r14
movq (%rax), %rax
movl 0x64(%rax), %r15d
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
cmpq %r12, %r15
je 0xa542
movq (%r14), %rax
movq 0x68(%rax,%r12,8), %rdi
callq 0x861b
movq (%rbx), %rax
movq 0x68(%rax,%r12,8), %rdi
callq 0x861b
callq 0xa1f6
callq 0x868d
movq (%r14), %rcx
movq %rax, 0x68(%rcx,%r12,8)
incq %r12
jmp 0xa50c
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x861b
leaq 0x18d02(%rip), %rdi     # 0x2325b
callq 0x7756
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: slice
void
slice(int h, int n)
{
	int i, m;
	m = tos - h - n;
	if (m < 0)
		stopf("stack slice error");
	for (i = 0; i < m; i++)
		stack[h + i] = stack[h + n + i];
	tos -= n;
}

// Assembly:
movl 0x2dd44(%rip), %eax     # 0x382a8
leal (%rsi,%rdi), %edx
movl %eax, %r8d
subl %edx, %r8d
js 0xa5ad
movslq %edi, %rcx
movslq %edx, %rdx
movl %r8d, %edi
shlq $0x3, %rdx
shlq $0x3, %rcx
xorl %r8d, %r8d
leaq 0x37026(%rip), %r9      # 0x415b0
cmpq %r8, %rdi
je 0xa5a4
leaq (%rdx,%r8,8), %r10
movq (%r9,%r10), %r10
leaq (%rcx,%r8,8), %r11
movq %r10, (%r9,%r11)
incq %r8
jmp 0xa58a
subl %esi, %eax
movl %eax, 0x2dcfc(%rip)     # 0x382a8
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1d9f4(%rip), %rdi     # 0x27fac
callq 0x7756
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: compatible_dimensions
int
compatible_dimensions(struct atom *p, struct atom *q)
{
	int i, n;

	if (!istensor(p) && !istensor(q))
		return 1; // both p and q are scalars

	if (!istensor(p) || !istensor(q))
		return 0; // scalar and tensor

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

	if (n != q->u.tensor->ndim)
		return 0;

	for (i = 0; i < n; i++)
		if (p->u.tensor->dim[i] != q->u.tensor->dim[i])
			return 0;

	return 1;
}

// Assembly:
cmpb $0x7, 0x10(%rdi)
movb 0x10(%rsi), %cl
jne 0xa605
xorl %eax, %eax
cmpb $0x7, %cl
jne 0xa60d
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rcx
movl (%rcx), %edx
movq (%rsi), %rsi
cmpl (%rsi), %edx
jne 0xa603
xorl %edi, %edi
testl %edx, %edx
cmovlel %edi, %edx
movl $0x1, %eax
cmpq %rdi, %rdx
je 0xa603
movl 0x4(%rcx,%rdi,4), %r8d
leaq 0x1(%rdi), %r9
cmpl 0x4(%rsi,%rdi,4), %r8d
movq %r9, %rdi
je 0xa5e9
xorl %eax, %eax
popq %rbp
retq
xorl %eax, %eax
cmpb $0x7, %cl
setne %al
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: iszero
int
iszero(struct atom *p)
{
	int i;
	if (isrational(p))
		return MZERO(p->u.q.a);
	if (isdouble(p))
		return p->u.d == 0.0;
	if (istensor(p)) {
		for (i = 0; i < p->u.tensor->nelem; i++)
			if (!iszero(p->u.tensor->elem[i]))
				return 0;
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movzbl 0x10(%rdi), %eax
cmpl $0x4, %eax
je 0xa69e
cmpl $0x5, %eax
je 0xa68b
cmpl $0x7, %eax
jne 0xa6af
movq (%rdi), %r14
movl 0x64(%r14), %r15d
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
cmpq %r12, %r15
sete %bl
je 0xa6b1
movq 0x68(%r14,%r12,8), %rdi
callq 0xa641
incq %r12
testl %eax, %eax
jne 0xa670
jmp 0xa6b1
xorpd %xmm0, %xmm0
cmpeqsd (%rdi), %xmm0
movq %xmm0, %rbx
andl $0x1, %ebx
jmp 0xa6b1
movq (%rdi), %rax
cmpl $0x1, -0x4(%rax)
jne 0xa6af
cmpl $0x0, (%rax)
sete %bl
jmp 0xa6b1
xorl %ebx, %ebx
movzbl %bl, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: add_numbers
void
add_numbers(struct atom *p1, struct atom *p2)
{
	double d1, d2;

	if (isrational(p1) && isrational(p2)) {
		add_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 0xa92e
cmpb $0x4, 0x10(%rbx)
jne 0xa92e
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xadd6
callq 0x861b
callq 0x8ae1
movsd %xmm0, -0x10(%rbp)
movq %rbx, %rdi
callq 0x861b
callq 0x8ae1
addsd -0x10(%rbp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xaf59
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: isimaginaryterm
int
isimaginaryterm(struct atom *p)
{
	if (isimaginaryfactor(p))
		return 1;
	if (car(p) == symbol(MULTIPLY)) {
		p = cdr(p);
		while (iscons(p)) {
			if (isimaginaryfactor(car(p)))
				return 1;
			p = cdr(p);
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x21179
pushq $0x1
popq %rbx
testl %eax, %eax
jne 0xac0a
movb 0x10(%r14), %al
cmpb $0x1, %al
leaq 0x33dfb(%rip), %r15     # 0x3e9f0
movq %r15, %rcx
cmoveq %r14, %rcx
movq (%rcx), %rcx
cmpq 0x36692(%rip), %rcx     # 0x41298
je 0xac17
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
addq $0x8, %r14
cmpb $0x1, %al
cmoveq %r14, %r15
movq (%r15), %r15
cmpb $0x1, 0x10(%r15)
jne 0xac08
movq (%r15), %rdi
callq 0x21179
addq $0x8, %r15
testl %eax, %eax
je 0xac21
jmp 0xac0a
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: cmp_factors
int
cmp_factors(struct atom *p1, struct atom *p2)
{
	int a, b, c;
	struct atom *base1, *base2, *expo1, *expo2;

	a = order_factor(p1);
	b = order_factor(p2);

	if (a < b)
		return -1;

	if (a > b)
		return 1;

	if (car(p1) == symbol(POWER)) {
		base1 = cadr(p1);
		expo1 = caddr(p1);
	} else {
		base1 = p1;
		expo1 = one;
	}

	if (car(p2) == symbol(POWER)) {
		base2 = cadr(p2);
		expo2 = caddr(p2);
	} else {
		base2 = p2;
		expo2 = one;
	}

	c = cmp(base1, base2);

	if (c == 0)
		c = cmp(expo2, expo1); // swapped to reverse sort order

	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1654d
movl %eax, %r15d
movq %rbx, %rdi
callq 0x1654d
cmpl %eax, %r15d
jae 0xac67
pushq $-0x1
jmp 0xac6b
jbe 0xac75
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movb 0x10(%r14), %cl
cmpb $0x1, %cl
leaq 0x33d6d(%rip), %rax     # 0x3e9f0
movq %rax, %rdi
cmoveq %r14, %rdi
movq 0x3660f(%rip), %rsi     # 0x412a0
leaq 0xf9e30(%rip), %rdx     # 0x104ac8
cmpq %rsi, (%rdi)
je 0xaca2
movq %rdx, %rcx
jmp 0xacdf
addq $0x8, %r14
cmpb $0x1, %cl
leaq 0x33d40(%rip), %rcx     # 0x3e9f0
cmovneq %rcx, %r14
movq (%r14), %rdi
cmpb $0x1, 0x10(%rdi)
jne 0xaccc
movq (%rdi), %r14
movq 0x8(%rdi), %rdi
cmpb $0x1, 0x10(%rdi)
je 0xacdc
jmp 0xacdf
movq 0x33d1d(%rip), %rdi     # 0x3e9f0
cmpb $0x1, 0x10(%rdi)
movq %rdi, %r14
jne 0xacdf
movq %rdi, %rcx
movb 0x10(%rbx), %dil
cmpb $0x1, %dil
movq %rax, %r8
cmoveq %rbx, %r8
cmpq %rsi, (%r8)
je 0xad22
movq %rdx, %rax
movq (%rcx), %r15
movq (%rax), %r12
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8760
testl %eax, %eax
jne 0xac6c
movq %r12, %rdi
movq %r15, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8760
addq $0x8, %rbx
cmpb $0x1, %dil
cmovneq %rax, %rbx
movq (%rbx), %rdx
cmpb $0x1, 0x10(%rdx)
jne 0xad46
movq (%rdx), %rbx
movq 0x8(%rdx), %rdx
cmpb $0x1, 0x10(%rdx)
je 0xacf3
jmp 0xacf6
movq 0x33ca3(%rip), %rdx     # 0x3e9f0
cmpb $0x1, 0x10(%rdx)
movq %rdx, %rbx
je 0xacf3
jmp 0xacf6
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: add_rationals
void
add_rationals(struct atom *p1, struct atom *p2)
{
	int sign;
	uint32_t *a, *ab, *b, *ba, *c;

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

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

	if (isinteger(p1) && isinteger(p2)) {
		add_integers(p1, p2);
		return;
	}

	ab = mmul(p1->u.q.a, p2->u.q.b);
	ba = mmul(p1->u.q.b, p2->u.q.a);

	if (p1->sign == p2->sign) {
		a = madd(ab, ba);
		sign = p1->sign;
	} else {
		switch (mcmp(ab, ba)) {
		case 1:
			a = msub(ab, ba);
			sign = p1->sign;
			break;
		case 0:
			push_integer(0);
			mfree(ab);
			mfree(ba);
			return;
		case -1:
			a = msub(ba, ab);
			sign = p2->sign;
			break;
		default:
			// never gets here, fix compiler warning
			return;
		}
	}

	mfree(ab);
	mfree(ba);

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

	push_bignum(sign, mdiv(a, c), mdiv(b, c));

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa641
testl %eax, %eax
je 0xadf8
movq %rbx, %rdi
jmp 0xae07
movq %rbx, %rdi
callq 0xa641
testl %eax, %eax
je 0xae1a
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x861b
movq %r14, %rdi
callq 0x8b5d
testl %eax, %eax
je 0xae4b
movq %rbx, %rdi
callq 0x8b5d
testl %eax, %eax
je 0xae4b
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xaf85
movq (%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x7a22
movq %rax, %r15
movq 0x8(%r14), %rdi
movq (%rbx), %rsi
callq 0x7a22
movq %rax, %r12
leaq 0x12(%r14), %r13
movb 0x12(%r14), %al
cmpb 0x12(%rbx), %al
jne 0xae87
movq %r13, -0x30(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x7aee
jmp 0xaed1
movq %r15, %rdi
movq %r12, %rsi
callq 0x82a7
cmpl $-0x1, %eax
je 0xaeb2
testl %eax, %eax
jne 0xaec2
xorl %edi, %edi
callq 0xa426
movq %r15, %rdi
callq 0x7ad9
movq %r12, %rdi
jmp 0xaf46
leaq 0x12(%rbx), %rax
movq %rax, -0x30(%rbp)
movq %r12, %rdi
movq %r15, %rsi
jmp 0xaecc
movq %r13, -0x30(%rbp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x7d5b
movq %rax, %r13
movq -0x30(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x30(%rbp)
movq %r15, %rdi
callq 0x7ad9
movq %r12, %rdi
callq 0x7ad9
movq 0x8(%r14), %rdi
movq 0x8(%rbx), %rsi
callq 0x7a22
movq %rax, %rbx
movq %r13, %rdi
movq %rax, %rsi
callq 0x832b
movq %rax, %r14
movq %r13, %rdi
movq %rax, %rsi
callq 0x7e20
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7e20
movl -0x30(%rbp), %edi
movq %r15, %rsi
movq %rax, %rdx
callq 0xb015
movq %r13, %rdi
callq 0x7ad9
movq %rbx, %rdi
callq 0x7ad9
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7ad9
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: push_double
void
push_double(double d)
{
	struct atom *p;
	p = alloc_atom();
	p->atomtype = DOUBLE;
	p->u.d = d;
	push(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
callq 0x749c
movb $0x5, 0x10(%rax)
movsd -0x8(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rax, %rdi
addq $0x10, %rsp
popq %rbp
jmp 0x861b
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: add_integers
void
add_integers(struct atom *p1, struct atom *p2)
{
	int sign = 0; // compiler nag
	uint32_t *c = NULL; // compiler nag
	if (p1->sign == p2->sign) {
		c = madd(p1->u.q.a, p2->u.q.a);
		sign = p1->sign;
	} else {
		switch (mcmp(p1->u.q.a, p2->u.q.a)) {
		case 1:
			c = msub(p1->u.q.a, p2->u.q.a);
			sign = p1->sign;
			break;
		case 0:
			push_integer(0);
			return;
		case -1:
			c = msub(p2->u.q.a, p1->u.q.a);
			sign = p2->sign;
			break;
		default:
			stopf("error");
		}
	}
	push_bignum(sign, c, mint(1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x12(%rdi), %r15
movb 0x12(%rdi), %al
movq (%rdi), %rdi
movq (%rsi), %rsi
cmpb 0x12(%rbx), %al
jne 0xafae
callq 0x7aee
jmp 0xafef
callq 0x82a7
cmpl $-0x1, %eax
je 0xafcd
testl %eax, %eax
jne 0xafe4
xorl %edi, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xa426
movq (%rbx), %rdi
addq $0x12, %rbx
movq (%r14), %rsi
callq 0x7d5b
movq %rax, %r14
movq %rbx, %r15
jmp 0xaff2
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x7d5b
movq %rax, %r14
movzbl (%r15), %ebx
pushq $0x1
popq %rdi
callq 0x7a09
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb015