LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x9ebe
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x9ec9
movq 0x54b3b(%rip), %rax     # 0x5ea00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x9f4a
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x9ef8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x9f03
movq 0x54b01(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9f60
cmpl $0x0, %eax
je 0x9f1a
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x9f35
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x9f40
movq 0x54ac4(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9ed1
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x9f86
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x9f91
movq 0x54a73(%rip), %rax     # 0x5ea00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq 0x57314(%rip), %rax     # 0x612b0
jne 0xa0c2
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x9fbd
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x9fc8
movq 0x54a3c(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xa009
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x9ff0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x9ffb
movq 0x54a09(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xa014
movq 0x549f0(%rip), %rax     # 0x5ea00
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xa0a0
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xa03c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xa047
movq 0x549bd(%rip), %rax     # 0x5ea00
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xa088
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xa06f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0xa07a
movq 0x5498a(%rip), %rax     # 0x5ea00
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0xa093
movq 0x54971(%rip), %rax     # 0x5ea00
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0xa0ab
movq 0x54959(%rip), %rax     # 0x5ea00
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x9e30
cmpl $0x0, %eax
je 0xa0c2
movl $0x1, -0x4(%rbp)
jmp 0xa0fa
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x4, %eax
jne 0xa0f3
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1, -0x4(%rax)
jne 0xa0ea
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
cmpl $0x1, (%rax)
je 0xa0f3
movl $0x1, -0x4(%rbp)
jmp 0xa0fa
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xa13e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xa149
movq 0x548bb(%rip), %rax     # 0x5ea00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xa1ca
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xa178
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xa183
movq 0x54881(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa1e0
cmpl $0x0, %eax
je 0xa19a
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xa1b5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xa1c0
movq 0x54844(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa151
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xa206
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xa211
movq 0x547f3(%rip), %rax     # 0x5ea00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq 0x57094(%rip), %rax     # 0x612b0
jne 0xa342
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xa23d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xa248
movq 0x547bc(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xa289
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xa270
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xa27b
movq 0x54789(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xa294
movq 0x54770(%rip), %rax     # 0x5ea00
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xa320
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xa2bc
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xa2c7
movq 0x5473d(%rip), %rax     # 0x5ea00
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xa308
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xa2ef
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0xa2fa
movq 0x5470a(%rip), %rax     # 0x5ea00
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0xa313
movq 0x546f1(%rip), %rax     # 0x5ea00
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0xa32b
movq 0x546d9(%rip), %rax     # 0x5ea00
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x9e30
cmpl $0x0, %eax
je 0xa342
movl $0x0, -0x4(%rbp)
jmp 0xa378
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x4, %eax
jne 0xa371
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, -0x4(%rax)
jne 0xa371
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, (%rax)
jne 0xa371
movl $0x0, -0x4(%rbp)
jmp 0xa378
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
callq 0x91d0
movq %rax, -0x28(%rbp)
callq 0x91d0
movq %rax, -0x20(%rbp)
callq 0x91d0
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
cmpq 0x54642(%rip), %rax     # 0x5ea00
je 0xa3cd
movq -0x28(%rbp), %rax
cmpq 0x54635(%rip), %rax     # 0x5ea00
jne 0xa3db
movq -0x18(%rbp), %rdi
callq 0x9110
jmp 0xa549
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x7, %eax
jne 0xa472
movq -0x18(%rbp), %rdi
callq 0xa550
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl 0x64(%rax), %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xa464
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x8(%rbp), %rcx
movq 0x68(%rax,%rcx,8), %rdi
callq 0x9110
movq -0x20(%rbp), %rdi
callq 0x9110
movq -0x28(%rbp), %rdi
callq 0x9110
callq 0xa390
callq 0x91d0
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x8(%rbp), %rcx
movq %rdx, 0x68(%rax,%rcx,8)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xa40d
movq -0x18(%rbp), %rdi
callq 0x9110
jmp 0xa549
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x93b0
cmpl $0x0, %eax
jne 0xa492
movq -0x28(%rbp), %rdi
callq 0x9110
jmp 0xa549
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
je 0xa4ad
movq -0x18(%rbp), %rdi
callq 0x9110
jmp 0xa549
movl 0x4de05(%rip), %eax     # 0x582b8
movl %eax, -0x4(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xa53b
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xa4dd
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xa4e8
movq 0x5451c(%rip), %rax     # 0x5ea00
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x9110
movq -0x20(%rbp), %rdi
callq 0x9110
movq -0x28(%rbp), %rdi
callq 0x9110
callq 0xa390
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xa523
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xa52e
movq 0x544d6(%rip), %rax     # 0x5ea00
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xa4b6
movl 0x4dd77(%rip), %edi     # 0x582b8
subl -0x4(%rbp), %edi
callq 0x90d0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x64(%rax), %edi
callq 0x79b0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %ecx, (%rax)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
jge 0xa5bf
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl 0x4(%rax,%rcx,4), %edx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl %edx, 0x4(%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa588
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x64(%rcx), %eax
jge 0xa600
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq 0x68(%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, 0x68(%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa5c6
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0x11a4a6(%rip), %eax    # 0x124ac0
cmpl 0x11a4a4(%rip), %eax    # 0x124ac4
jne 0xa633
cmpl $0x1e8480, 0x4dc84(%rip) # imm = 0x1E8480
jle 0xa633
callq 0x7610
movl 0x11a487(%rip), %eax    # 0x124ac0
addl $0x1, %eax
movl %eax, 0x11a47e(%rip)    # 0x124ac0
callq 0xa660
movl 0x11a473(%rip), %eax    # 0x124ac0
addl $-0x1, %eax
movl %eax, 0x11a46a(%rip)    # 0x124ac0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl 0x11a456(%rip), %eax    # 0x124ac4
addl $0x1, %eax
movl %eax, 0x11a44d(%rip)    # 0x124ac4
callq 0x91d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9110
movq -0x8(%rbp), %rdi
callq 0xa6c0
callq 0x91d0
movq %rax, -0x8(%rbp)
callq 0x91d0
movq -0x8(%rbp), %rdi
callq 0x9110
movl 0x11a415(%rip), %eax    # 0x124ac4
addl $-0x1, %eax
movl %eax, 0x11a40c(%rip)    # 0x124ac4
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x128e0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0xac8e
movq -0x8(%rbp), %rdi
callq 0x9110
jmp 0xac9c
movq -0x10(%rbp), %rdi
callq 0x9110
callq 0xa610
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa550
movq %rax, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x64(%rcx), %eax
jge 0xad1c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq 0x68(%rax,%rcx,8), %rdi
callq 0x9110
callq 0xa660
callq 0x91d0
movq %rax, %rdx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, 0x68(%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xacd0
movq -0x8(%rbp), %rdi
callq 0x9110
callq 0x35190
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x60, %rsp
callq 0x91d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xad5b
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xad66
movq 0x53c9e(%rip), %rax     # 0x5ea00
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x5654f(%rip), %rax     # 0x612c0
jne 0xaf22
movq 0x54f72(%rip), %rdi     # 0x5fcf0
callq 0x9110
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xad9e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xada9
movq 0x53c5b(%rip), %rax     # 0x5ea00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xade9
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xadd1
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xaddc
movq 0x53c28(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xadf4
movq 0x53c10(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x9110
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xae18
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xae23
movq 0x53be1(%rip), %rax     # 0x5ea00
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xae64
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xae4b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xae56
movq 0x53bae(%rip), %rax     # 0x5ea00
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0xae6f
movq 0x53b95(%rip), %rax     # 0x5ea00
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xaefb
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xae97
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0xaea2
movq 0x53b62(%rip), %rax     # 0x5ea00
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xaee3
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xaeca
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0xaed5
movq 0x53b2f(%rip), %rax     # 0x5ea00
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x58(%rbp)
jmp 0xaeee
movq 0x53b16(%rip), %rax     # 0x5ea00
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x60(%rbp)
jmp 0xaf06
movq 0x53afe(%rip), %rax     # 0x5ea00
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x9110
movl $0x3, %edi
callq 0x90d0
callq 0x91d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9110
callq 0xa610
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0x1cbf0
callq 0xa660
callq 0x1cbf0
callq 0xa660
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x2, -0x4(%rbp)
jge 0xc3e3
jmp 0xc426
movl 0x4becf(%rip), %eax     # 0x582b8
subl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x26000
movl -0x8(%rbp), %edi
callq 0x261f0
movq %rax, -0x10(%rbp)
movl -0x8(%rbp), %edi
callq 0x262a0
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x7, %eax
jne 0xc426
movq -0x10(%rbp), %rdi
callq 0x9110
callq 0xb4e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl 0x4be76(%rip), %eax     # 0x582b8
movl %eax, -0xc(%rbp)
movl 0x118685(%rip), %eax    # 0x124ad0
addl $-0x1, %eax
movl %eax, 0x11867c(%rip)    # 0x124ad0
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xc46f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xc47a
movq 0x5258a(%rip), %rax     # 0x5ea00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xc4f2
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xc4a9
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xc4b4
movq 0x52550(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9110
callq 0xa610
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xc4dd
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xc4e8
movq 0x5251c(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc482
movl 0x4bdc0(%rip), %edi     # 0x582b8
subl -0xc(%rbp), %edi
callq 0xc520
movl 0x1185ca(%rip), %eax    # 0x124ad0
addl $0x1, %eax
movl %eax, 0x1185c1(%rip)    # 0x124ad0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x2, -0x4(%rbp)
jge 0xc536
jmp 0xc653
movl 0x4bd7c(%rip), %eax     # 0x582b8
subl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0xc670
movl -0x8(%rbp), %edi
callq 0xc860
movq %rax, -0x20(%rbp)
movl -0x8(%rbp), %edi
callq 0xc910
movl -0x8(%rbp), %edi
callq 0xc9b0
movl 0x4bd4c(%rip), %eax     # 0x582b8
subl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jne 0xc59c
movq -0x20(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x7, %eax
jne 0xc590
movq -0x20(%rbp), %rdi
callq 0x9110
jmp 0xc597
xorl %edi, %edi
callq 0xca50
jmp 0xc653
cmpl $0x1, -0x4(%rbp)
jle 0xc5c0
movl -0x4(%rbp), %edi
callq 0x90d0
movq 0x54cef(%rip), %rdi     # 0x612a0
callq 0x9110
callq 0xcb10
callq 0x9180
movq -0x20(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x7, %eax
je 0xc5d2
jmp 0xc653
callq 0x91d0
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa550
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl 0x64(%rax), %eax
movl %eax, -0x4(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0xc64a
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq 0x68(%rax,%rcx,8), %rdi
callq 0x9110
movq -0x18(%rbp), %rdi
callq 0x9110
callq 0xc660
callq 0x91d0
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq %rdx, 0x68(%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xc5fc
movq -0x20(%rbp), %rdi
callq 0x9110
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movl 0x4bc37(%rip), %eax     # 0x582b8
movl %eax, -0xc(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xc85a
movslq -0x8(%rbp), %rcx
leaq 0x54f1f(%rip), %rax     # 0x615c0
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xc6c3
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xc6ce
movq 0x52336(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq 0x54bc7(%rip), %rax     # 0x612a0
jne 0xc84a
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xc6fa
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xc705
movq 0x522ff(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xc745
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xc72d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xc738
movq 0x522cc(%rip), %rax     # 0x5ea00
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0xc750
movq 0x522b4(%rip), %rax     # 0x5ea00
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdx
movslq -0x8(%rbp), %rcx
leaq 0x54e61(%rip), %rax     # 0x615c0
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xc77e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0xc789
movq 0x5227b(%rip), %rax     # 0x5ea00
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xc7ca
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xc7b1
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0xc7bc
movq 0x52248(%rip), %rax     # 0x5ea00
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0xc7d5
movq 0x5222f(%rip), %rax     # 0x5ea00
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xc848
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xc804
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x58(%rbp)
jmp 0xc80f
movq 0x521f5(%rip), %rax     # 0x5ea00
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x9110
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xc833
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x60(%rbp)
jmp 0xc83e
movq 0x521c6(%rip), %rax     # 0x5ea00
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xc7dd
jmp 0xc84a
jmp 0xc84c
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xc68a
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0x5218e(%rip), %rax     # 0x5ea00
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x4ba33(%rip), %eax     # 0x582b8
jge 0xc904
movslq -0x8(%rbp), %rcx
leaq 0x54d2e(%rip), %rax     # 0x615c0
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x7, %eax
jne 0xc8f4
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x7, %eax
jne 0xc8d6
movq -0x18(%rbp), %rdi
callq 0x9110
movq -0x10(%rbp), %rdi
callq 0x9110
callq 0xcb50
callq 0x91d0
movq %rax, -0x18(%rbp)
jmp 0xc8de
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x8(%rbp), %edi
movl $0x1, %esi
callq 0xcc20
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xc8f6
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xc87c
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0xcd80
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x4b986(%rip), %eax     # 0x582b8
jge 0xc9a8
movslq -0x8(%rbp), %rcx
leaq 0x54c81(%rip), %rax     # 0x615c0
movq (%rax,%rcx,8), %rdi
callq 0xcdc0
cmpl $0x0, %eax
je 0xc965
movl -0x8(%rbp), %edi
movl $0x1, %esi
callq 0xcc20
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xc99b
movl -0x8(%rbp), %eax
addl $0x1, %eax
cmpl 0x4b947(%rip), %eax     # 0x582b8
jge 0xc999
movl -0x8(%rbp), %edi
callq 0xceb0
cmpl $0x0, %eax
je 0xc999
movl -0x8(%rbp), %edi
addl $0x1, %edi
movl $0x1, %esi
callq 0xcc20
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xc99b
jmp 0xc99d
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xc929
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl $0x0, -0xc(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x4b8e7(%rip), %eax     # 0x582b8
jge 0xca2f
movslq -0x8(%rbp), %rcx
leaq 0x54be2(%rip), %rax     # 0x615c0
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe160
cmpl $0x0, %eax
je 0xca22
movq -0x18(%rbp), %rdi
callq 0x9110
callq 0xa660
callq 0x91d0
movq %rax, %rdx
movslq -0x8(%rbp), %rcx
leaq 0x54bab(%rip), %rax     # 0x615c0
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xca24
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xc9c8
cmpl $0x0, -0xc(%rbp)
je 0xca3d
movl -0x4(%rbp), %edi
callq 0xc910
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x8(%rbp)
subl $-0x1, %eax
je 0xca97
jmp 0xca68
movl -0x8(%rbp), %eax
testl %eax, %eax
je 0xca7b
jmp 0xca71
movl -0x8(%rbp), %eax
subl $0x1, %eax
je 0xca89
jmp 0xcaa5
movq 0x4f6be(%rip), %rdi     # 0x5c140
callq 0x9110
jmp 0xcafc
movq 0x118048(%rip), %rdi    # 0x124ad8
callq 0x9110
jmp 0xcafc
movq 0x122952(%rip), %rdi    # 0x12f3f0
callq 0x9110
jmp 0xcafc
cmpl $0x0, -0x4(%rbp)
jge 0xcad6
xorl %edi, %edi
subl -0x4(%rbp), %edi
callq 0x7d10
movq %rax, -0x10(%rbp)
movl $0x1, %edi
callq 0x7d10
movq -0x10(%rbp), %rsi
movq %rax, %rdx
movl $0x1, %edi
callq 0xe740
jmp 0xcafa
movl -0x4(%rbp), %edi
callq 0x7d10
movq %rax, -0x18(%rbp)
movl $0x1, %edi
callq 0x7d10
movq -0x18(%rbp), %rsi
movq %rax, %rdx
xorl %edi, %edi
callq 0xe740
jmp 0xcafc
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
callq 0x91d0
movq %rax, -0x8(%rbp)
callq 0x91d0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9110
movq -0x10(%rbp), %rdi
callq 0x9110
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
callq 0x91d0
movq %rax, -0x18(%rbp)
callq 0x91d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xccb0
cmpl $0x0, %eax
jne 0xcb88
leaq 0x38650(%rip), %rdi     # 0x451d3
callq 0x78d0
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 0xcc03
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movq 0x68(%rax,%rcx,8), %rdi
callq 0x9110
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movq 0x68(%rax,%rcx,8), %rdi
callq 0x9110
callq 0xc660
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 0xcba9
movq -0x10(%rbp), %rdi
callq 0x9110
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl 0x4b684(%rip), %eax     # 0x582b8
subl -0x4(%rbp), %eax
subl -0x8(%rbp), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jge 0xcc4f
leaq 0x3d2da(%rip), %rdi     # 0x49f24
callq 0x78d0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0xcc94
movl -0x4(%rbp), %eax
addl -0x8(%rbp), %eax
addl -0xc(%rbp), %eax
movslq %eax, %rcx
leaq 0x5494f(%rip), %rax     # 0x615c0
movq (%rax,%rcx,8), %rdx
movl -0x4(%rbp), %eax
addl -0xc(%rbp), %eax
movslq %eax, %rcx
leaq 0x5493b(%rip), %rax     # 0x615c0
movq %rdx, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xcc56
movl -0x8(%rbp), %ecx
movl 0x4b61b(%rip), %eax     # 0x582b8
subl %ecx, %eax
movl %eax, 0x4b613(%rip)     # 0x582b8
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x7, %eax
je 0xcce2
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x7, %eax
je 0xcce2
movl $0x1, -0x4(%rbp)
jmp 0xcd74
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x7, %eax
jne 0xccfc
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x7, %eax
je 0xcd05
movl $0x0, -0x4(%rbp)
jmp 0xcd74
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
je 0xcd28
movl $0x0, -0x4(%rbp)
jmp 0xcd74
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0xcd6d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movslq -0x1c(%rbp), %rdx
cmpl 0x4(%rcx,%rdx,4), %eax
je 0xcd60
movl $0x0, -0x4(%rbp)
jmp 0xcd74
jmp 0xcd62
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xcd2f
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x4, %eax
jne 0xce0b
movq -0x10(%rbp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpl $0x1, -0x4(%rcx)
movb %al, -0x15(%rbp)
jne 0xcdfb
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, (%rax)
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0xce9c
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x5, %eax
jne 0xce39
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0xce9c
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x7, %eax
jne 0xce95
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x64(%rcx), %eax
jge 0xce8c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq 0x68(%rax,%rcx,8), %rdi
callq 0xcdc0
cmpl $0x0, %eax
jne 0xce7f
movl $0x0, -0x4(%rbp)
jmp 0xce9c
jmp 0xce81
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xce4d
movl $0x1, -0x4(%rbp)
jmp 0xce9c
movl $0x0, -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: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x4, %eax
jne 0xd479
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x4, %eax
jne 0xd479
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xe3e0
jmp 0xd4ae
movq -0x8(%rbp), %rdi
callq 0x9110
callq 0x9af0
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9110
callq 0x9af0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
addsd -0x20(%rbp), %xmm0
callq 0xe5e0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x42710
cmpl $0x0, %eax
je 0xdb96
movl $0x1, -0x4(%rbp)
jmp 0xdc7c
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xdbb0
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xdbbb
movq 0x50e49(%rip), %rax     # 0x5ea00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq 0x536e2(%rip), %rax     # 0x612a8
jne 0xdc75
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xdbe7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xdbf2
movq 0x50e12(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xdc73
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xdc21
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xdc2c
movq 0x50dd8(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x42710
cmpl $0x0, %eax
je 0xdc43
movl $0x1, -0x4(%rbp)
jmp 0xdc7c
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xdc5e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0xdc69
movq 0x50d9b(%rip), %rax     # 0x5ea00
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0xdbfa
jmp 0xdc75
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0x74b0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movb $0x5, 0x10(%rax)
movsd -0x8(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x9110
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x12(%rax), %eax
movq -0x10(%rbp), %rcx
movzbl 0x12(%rcx), %ecx
cmpl %ecx, %eax
jne 0xe67a
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x7ea0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x12(%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0xe70b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x8b80
movl %eax, %ecx
movl %ecx, -0x24(%rbp)
subl $-0x1, %eax
je 0xe6d9
jmp 0xe699
movl -0x24(%rbp), %eax
testl %eax, %eax
je 0xe6d0
jmp 0xe6a2
movl -0x24(%rbp), %eax
subl $0x1, %eax
jne 0xe6fd
jmp 0xe6ac
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x8310
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x12(%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0xe709
xorl %edi, %edi
callq 0xca50
jmp 0xe732
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x8310
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x12(%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0xe709
leaq 0x36bde(%rip), %rdi     # 0x452e2
callq 0x78d0
jmp 0xe70b
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x1, %edi
callq 0x7d10
movl -0x34(%rbp), %edi
movq -0x30(%rbp), %rsi
movq %rax, %rdx
callq 0xe740
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: push_bignum
void
push_bignum(int sign, uint32_t *a, uint32_t *b)
{
	struct atom *p;

	// normalize zero

	if (MZERO(a)) {
		sign = MPLUS;
		if (!MEQUAL(b, 1)) {
			mfree(b);
			b = mint(1);
		}
	}

	p = alloc_atom();
	p->atomtype = RATIONAL;
	p->sign = sign;
	p->u.q.a = a;
	p->u.q.b = b;

	push(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x1, -0x4(%rax)
jne 0xe799
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xe799
movl $0x0, -0x4(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x1, -0x4(%rax)
jne 0xe780
movq -0x18(%rbp), %rax
cmpl $0x1, (%rax)
je 0xe797
movq -0x18(%rbp), %rdi
callq 0x7e70
movl $0x1, %edi
callq 0x7d10
movq %rax, -0x18(%rbp)
jmp 0xe799
callq 0x74b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movb $0x4, 0x10(%rax)
movl -0x4(%rbp), %eax
movb %al, %cl
movq -0x20(%rbp), %rax
movb %cl, 0x12(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rdi
callq 0x9110
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_and
void
eval_and(struct atom *p1)
{
	struct atom *p2;
	p1 = cdr(p1);
	while (iscons(p1)) {
		push(car(p1));
		evalp();
		p2 = pop();
		if (iszero(p2)) {
			push_integer(0);
			return;
		}
		p1 = cdr(p1);
	}
	push_integer(1);
}

// 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 0xef17
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xef22
movq 0x4fae2(%rip), %rax     # 0x5ea00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xefc1
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xef55
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xef60
movq 0x4faa4(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9110
callq 0xad30
callq 0x91d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xcdc0
cmpl $0x0, %eax
je 0xef8e
xorl %edi, %edi
callq 0xca50
jmp 0xefcb
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0xefa9
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xefb4
movq 0x4fa50(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xef2a
movl $0x1, %edi
callq 0xca50
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: isequalq
int
isequalq(struct atom *p, int a, int b)
{
	int sign;
	if (isrational(p)) {
		if (a < 0) {
			sign = MMINUS;
			a = -a;
		} else
			sign = MPLUS;
		return p->sign == sign && MEQUAL(p->u.q.a, a) && MEQUAL(p->u.q.b, b);
	}
	if (isdouble(p))
		return p->u.d == (double) a / b;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x4, %eax
jne 0x1071d
cmpl $0x0, -0x14(%rbp)
jge 0x106a6
movl $0x1, -0x1c(%rbp)
xorl %eax, %eax
subl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x106ad
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x12(%rax), %ecx
xorl %eax, %eax
cmpl -0x1c(%rbp), %ecx
movb %al, -0x1d(%rbp)
jne 0x10710
movq -0x10(%rbp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpl $0x1, -0x4(%rcx)
movb %al, -0x1d(%rbp)
jne 0x10710
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl (%rax), %ecx
xorl %eax, %eax
cmpl -0x14(%rbp), %ecx
movb %al, -0x1d(%rbp)
jne 0x10710
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
xorl %eax, %eax
cmpl $0x1, -0x4(%rcx)
movb %al, -0x1e(%rbp)
jne 0x1070a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
cmpl -0x18(%rbp), %eax
sete %al
movb %al, -0x1e(%rbp)
movb -0x1e(%rbp), %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x1075d
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x5, %eax
jne 0x10756
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
cvtsi2sdl -0x18(%rbp), %xmm2
divsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x1075d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)