LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: get_binding
struct atom *
get_binding(struct atom *p1)
{
	struct atom *p2;
	if (!isusersymbol(p1))
		stopf("symbol error");
	p2 = binding[p1->u.usym.index];
	if (p2 == NULL || p2 == symbol(NIL))
		p2 = p1; // symbol binds to itself
	return p2;
}

// Assembly:
cmpb $0x3, 0x10(%rdi)
jne 0xf086
movl 0x8(%rdi), %eax
leaq 0xfca84(%rip), %rcx     # 0x10baf0
movq (%rcx,%rax,8), %rcx
cmpq 0x36989(%rip), %rcx     # 0x45a00
movq %rcx, %rax
cmoveq %rdi, %rax
testq %rcx, %rcx
cmoveq %rdi, %rax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1ff09(%rip), %rdi     # 0x2ef9a
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: ceilingfunc
void
ceilingfunc(void)
{
	int i, n;
	uint32_t *a, *b;
	double d;
	struct atom *p1;

	p1 = pop();

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

	if (isinteger(p1)) {
		push(p1);
		return;
	}

	if (isrational(p1)) {
		a = mdiv(p1->u.q.a, p1->u.q.b);
		b = mint(1);
		if (isnegativenumber(p1))
			push_bignum(MMINUS, a, b);
		else {
			push_bignum(MPLUS, a, b);
			push_integer(1);
			add();
		}
		return;
	}

	if (isdouble(p1)) {
		push(p1);
		d = pop_double();
		d = ceil(d);
		push_double(d);
		return;
	}

	push_symbol(CEILING);
	push(p1);
	list(2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x301be(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0xf2a0
decl %eax
movl %eax, 0x301a6(%rip)     # 0x3f2b8
leaq 0x394a7(%rip), %r14     # 0x485c0
movq (%r14,%rax,8), %rbx
movzbl 0x10(%rbx), %eax
cmpl $0x4, %eax
je 0xf1cd
cmpl $0x5, %eax
je 0xf19f
cmpl $0x7, %eax
jne 0xf1f2
movq %rbx, %rdi
callq 0x9638
movq %rax, %rbx
movq (%rax), %rax
movslq 0x64(%rax), %r15
testq %r15, %r15
jle 0xf1dc
xorl %r12d, %r12d
movl $0xfffe795f, %r13d      # imm = 0xFFFE795F
movq (%rbx), %rax
movq 0x68(%rax,%r12,8), %rdi
callq 0x8ba5
callq 0xf0e6
movl 0x30144(%rip), %eax     # 0x3f2b8
leal (%rax,%r13), %ecx
cmpl %r13d, %ecx
jbe 0xf2a0
decl %eax
movl %eax, 0x3012f(%rip)     # 0x3f2b8
movq (%r14,%rax,8), %rax
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0xf15c
jmp 0xf1dc
movq %rbx, %rdi
callq 0x8ba5
callq 0x9128
callq 0x7360
movsd %xmm0, -0x30(%rbp)
callq 0x74dc
movb $0x5, 0x10(%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rax, %rdi
jmp 0xf1df
movq 0x8(%rbx), %rsi
cmpl $0x1, -0x4(%rsi)
jne 0xf21e
cmpl $0x1, (%rsi)
jne 0xf21e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8ba5
movq 0x345b7(%rip), %rdi     # 0x437b0
callq 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8b7d
movq (%rbx), %rdi
callq 0x80ac
movq %rax, %r14
movl $0x1, %edi
callq 0x7b1f
movzbl 0x10(%rbx), %ecx
cmpl $0x5, %ecx
je 0xf265
cmpl $0x4, %ecx
jne 0xf26f
cmpb $0x1, 0x12(%rbx)
jne 0xf26f
movl $0x1, %edi
movq %r14, %rsi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xbf3e
xorpd %xmm0, %xmm0
ucomisd (%rbx), %xmm0
ja 0xf247
xorl %edi, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0xbf3e
movq 0xfc855(%rip), %rdi     # 0x10bad8
callq 0x8ba5
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xadb3
leaq 0x1fc9a(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_check
void
eval_check(struct atom *p1)
{
	push(cadr(p1));
	evalp();
	p1 = pop();
	if (iszero(p1))
		stopf("check");
	push_symbol(NIL); // no result is printed
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rax
leaq 0x36741(%rip), %rcx     # 0x45a00
cmovneq %rcx, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %rcx
movq (%rcx), %rdi
callq 0x8ba5
callq 0x9cff
movl 0x2ffd7(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0xf316
decl %eax
movl %eax, 0x2ffc3(%rip)     # 0x3f2b8
leaq 0x392c4(%rip), %rcx     # 0x485c0
movq (%rcx,%rax,8), %rdi
callq 0xb477
testl %eax, %eax
jne 0xf322
movq 0x366f0(%rip), %rdi     # 0x45a00
popq %rbp
jmp 0x8ba5
leaq 0x1fc24(%rip), %rdi     # 0x2ef41
callq 0x780b
leaq 0x1af35(%rip), %rdi     # 0x2a25e
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_clear
void
eval_clear(struct atom *p1)
{
	int i;

	(void) p1; // silence compiler

	save_symbol(symbol(TRACE));
	save_symbol(symbol(TTY));

	for (i = 0; i < 27 * BUCKETSIZE; i++) {
		binding[i] = NULL;
		usrfunc[i] = NULL;
	}

	run_init_script();

	restore_symbol();
	restore_symbol();

	if (gc_level == eval_level)
		gc();

	push_symbol(NIL); // result
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x379e7(%rip), %rdi     # 0x46d20
callq 0xf3a6
movq 0x379eb(%rip), %rdi     # 0x46d30
callq 0xf3a6
leaq 0xfc79f(%rip), %rdi     # 0x10baf0
movl $0x5460, %edx           # imm = 0x5460
xorl %esi, %esi
callq 0x7130
leaq 0x101bec(%rip), %rdi    # 0x110f50
movl $0x5460, %edx           # imm = 0x5460
xorl %esi, %esi
callq 0x7130
movq 0x2f051(%rip), %rdi     # 0x3e3c8
callq 0x20857
callq 0xf40c
callq 0xf40c
movl 0xfc734(%rip), %eax     # 0x10bac0
cmpl 0xfc732(%rip), %eax     # 0x10bac4
jne 0xf399
callq 0x75c1
movq 0x36660(%rip), %rdi     # 0x45a00
popq %rbp
jmp 0x8ba5
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: restore_symbol
void
restore_symbol(void)
{
	struct atom *p1, *p2, *p3;
	p3 = pop();
	p2 = pop();
	p1 = pop();
	set_symbol(p1, p2, p3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x2fea2(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0xf47e
leal -0x1(%rax), %ecx
movl %ecx, 0x2fe8d(%rip)     # 0x3f2b8
cmpl $0x1, %eax
jbe 0xf47e
leaq 0x39189(%rip), %rdx     # 0x485c0
movq (%rdx,%rcx,8), %rcx
leal -0x2(%rax), %esi
movl %esi, 0x2fe74(%rip)     # 0x3f2b8
cmpl $0x2, %eax
je 0xf47e
movq (%rdx,%rsi,8), %rsi
addl $-0x3, %eax
movl %eax, 0x2fe62(%rip)     # 0x3f2b8
movq (%rdx,%rax,8), %rax
cmpb $0x3, 0x10(%rax)
jne 0xf48a
movl 0x8(%rax), %edx
leaq 0xfc686(%rip), %rdi     # 0x10baf0
movq %rsi, (%rdi,%rdx,8)
movl 0x8(%rax), %eax
leaq 0x101ad8(%rip), %rdx    # 0x110f50
movq %rcx, (%rdx,%rax,8)
popq %rbp
retq
leaq 0x1fabc(%rip), %rdi     # 0x2ef41
callq 0x780b
leaq 0x1fb09(%rip), %rdi     # 0x2ef9a
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: clockfunc
void
clockfunc(void)
{
	int i, n;
	struct atom *p1;

	p1 = pop();

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

	push(p1);
	magfunc();

	push_integer(-1); // base

	push(p1);
	argfunc();
	push_symbol(PI);
	divide();

	power();

	multiply();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x2fdd9(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0xf5d3
decl %eax
movl %eax, 0x2fdc1(%rip)     # 0x3f2b8
leaq 0x390c2(%rip), %r14     # 0x485c0
movq (%r14,%rax,8), %rbx
cmpb $0x7, 0x10(%rbx)
jne 0xf57f
movq %rbx, %rdi
callq 0x9638
movq %rax, %rbx
movq (%rax), %rax
movslq 0x64(%rax), %r15
testq %r15, %r15
jle 0xf569
xorl %r12d, %r12d
movl $0xfffe795f, %r13d      # imm = 0xFFFE795F
movq (%rbx), %rax
movq 0x68(%rax,%r12,8), %rdi
callq 0x8ba5
callq 0xf4cb
movl 0x2fd78(%rip), %eax     # 0x3f2b8
leal (%rax,%r13), %ecx
cmpl %r13d, %ecx
jbe 0xf5d3
decl %eax
movl %eax, 0x2fd63(%rip)     # 0x3f2b8
movq (%r14,%rax,8), %rax
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0xf528
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
callq 0xf5df
movq 0x106e5d(%rip), %rdi    # 0x1163f0
callq 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
callq 0xe743
movq 0x36aa4(%rip), %rdi     # 0x46050
callq 0x8ba5
callq 0xe218
callq 0xa573
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xacef
leaq 0x1f967(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: magfunc
void
magfunc(void)
{
	int i, n;
	struct atom *p1, *num, *den;

	p1 = pop();

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

	// use numden to handle (a + i b) / (c + i d)

	push(p1);
	numden();
	num = pop();
	den = pop();
	push(num);
	magfunc_nib();
	push(den);
	magfunc_nib();
	divide();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x2fcc5(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0xf70d
decl %eax
movl %eax, 0x2fcad(%rip)     # 0x3f2b8
leaq 0x38fae(%rip), %r14     # 0x485c0
movq (%r14,%rax,8), %rdi
cmpb $0x7, 0x10(%rdi)
jne 0xf690
callq 0x9638
movq %rax, %rbx
movq (%rax), %rax
movslq 0x64(%rax), %r15
testq %r15, %r15
jle 0xf67a
xorl %r12d, %r12d
movl $0xfffe795f, %r13d      # imm = 0xFFFE795F
movq (%rbx), %rax
movq 0x68(%rax,%r12,8), %rdi
callq 0x8ba5
callq 0xf5df
movl 0x2fc67(%rip), %eax     # 0x3f2b8
leal (%rax,%r13), %ecx
cmpl %r13d, %ecx
jbe 0xf70d
decl %eax
movl %eax, 0x2fc52(%rip)     # 0x3f2b8
movq (%r14,%rax,8), %rax
movq (%rbx), %rcx
movq %rax, 0x68(%rcx,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0xf639
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8ba5
callq 0x8ba5
callq 0xe915
movl 0x2fc18(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0xf70d
leal -0x1(%rax), %ecx
movl %ecx, 0x2fc03(%rip)     # 0x3f2b8
cmpl $0x1, %eax
jbe 0xf70d
movl %ecx, %ecx
movq (%r14,%rcx,8), %rdi
addl $-0x2, %eax
movl %eax, 0x2fbef(%rip)     # 0x3f2b8
movq (%r14,%rax,8), %rbx
callq 0x8ba5
callq 0x19406
movq %rbx, %rdi
callq 0x8ba5
callq 0x19406
movq 0x106d05(%rip), %rdi    # 0x1163f0
callq 0x8ba5
callq 0xa573
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xacef
leaq 0x1f82d(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_cofactor
void
eval_cofactor(struct atom *p1)
{
	int i, j;
	struct atom *p2;

	push(cadr(p1));
	evalf();
	p2 = pop();

	push(caddr(p1));
	evalf();
	i = pop_integer();

	push(cadddr(p1));
	evalf();
	j = pop_integer();

	if (!issquarematrix(p2))
		stopf("cofactor: square matrix expected");

	if (i < 1 || i > p2->u.tensor->dim[0] || j < 0 || j > p2->u.tensor->dim[1])
		stopf("cofactor: index err");

	push(p2);

	minormatrix(i, j);

	det();

	if ((i + j) % 2)
		negate();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %r15
cmpb $0x1, 0x10(%rdi)
leaq 0x362ca(%rip), %r12     # 0x45a00
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x8ba5
callq 0x96e2
movl 0x2fb5d(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0xf8da
decl %eax
movl %eax, 0x2fb45(%rip)     # 0x3f2b8
cmpb $0x1, 0x10(%r14)
movq %r12, %rdx
cmoveq %r15, %rdx
leaq 0x38e3a(%rip), %rcx     # 0x485c0
movq (%rdx), %rdx
cmpb $0x1, 0x10(%rdx)
jne 0xf795
movq 0x8(%rdx), %rdx
jmp 0xf79c
movq 0x36264(%rip), %rdx     # 0x45a00
cmpb $0x1, 0x10(%rdx)
movq %r12, %rsi
jne 0xf7a8
movq %rdx, %rsi
movq (%rcx,%rax,8), %rbx
movq (%rsi), %rdi
callq 0x8ba5
callq 0x96e2
callq 0xf8e6
cmpb $0x1, 0x10(%r14)
cmoveq %r15, %r12
movl %eax, %r14d
movq (%r12), %rax
cmpb $0x1, 0x10(%rax)
jne 0xf7e4
movq 0x8(%rax), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0xf80b
movq 0x8(%rcx), %rcx
jmp 0xf812
movq 0x36215(%rip), %rcx     # 0x45a00
leaq 0x3620e(%rip), %rax     # 0x45a00
cmpb $0x1, 0x10(%rcx)
jne 0xf83b
movq 0x8(%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0xf83b
movq 0x361f7(%rip), %rax     # 0x45a00
jmp 0xf81c
movq 0x361ee(%rip), %rcx     # 0x45a00
cmpb $0x1, 0x10(%rcx)
jne 0xf828
movq 0x8(%rax), %rax
cmpb $0x1, 0x10(%rax)
jne 0xf831
addq $0x8, %rax
jmp 0xf838
leaq 0x361d1(%rip), %rax     # 0x45a00
jmp 0xf83b
leaq 0x361c8(%rip), %rax     # 0x45a00
movq (%rax), %rax
movq (%rax), %rdi
callq 0x8ba5
callq 0x96e2
callq 0xf8e6
cmpb $0x7, 0x10(%rbx)
jne 0xf8c2
movq (%rbx), %rcx
cmpl $0x2, (%rcx)
jne 0xf8c2
movl %eax, %r15d
movl 0x4(%rcx), %eax
cmpl 0x8(%rcx), %eax
jne 0xf8c2
testl %r14d, %r14d
jle 0xf8ce
cmpl %eax, %r14d
jg 0xf8ce
testl %r15d, %r15d
js 0xf8ce
cmpl %eax, %r15d
ja 0xf8ce
movq %rbx, %rdi
callq 0x8ba5
movl %r14d, %edi
movl %r15d, %esi
callq 0xf958
callq 0xc2c8
addl %r14d, %r15d
testb $0x1, %r15b
jne 0xf8a4
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x106b45(%rip), %rdi    # 0x1163f0
callq 0x8ba5
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xacef
leaq 0x1a99b(%rip), %rdi     # 0x2a264
callq 0x780b
leaq 0x1a9b0(%rip), %rdi     # 0x2a285
callq 0x780b
leaq 0x1f660(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: pop_integer
int
pop_integer(void)
{
	int n;
	struct atom *p;

	p = pop();

	if (!issmallinteger(p))
		stopf("small integer expected");

	if (isrational(p)) {
		n = p->u.q.a[0];
		if (isnegativenumber(p))
			n = -n;
	} else
		n = (int) p->u.d;

	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0x2f9c6(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0xf940
decl %eax
movl %eax, 0x2f9b2(%rip)     # 0x3f2b8
leaq 0x38cb3(%rip), %rcx     # 0x485c0
movq (%rcx,%rax,8), %rbx
movq %rbx, %rdi
callq 0x15ac2
testl %eax, %eax
je 0xf94c
cmpb $0x4, 0x10(%rbx)
jne 0xf935
movq (%rbx), %rax
movl (%rax), %ecx
movl %ecx, %eax
negl %eax
cmpb $0x1, 0x12(%rbx)
cmovnel %ecx, %eax
jmp 0xf939
cvttsd2si (%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1f5fa(%rip), %rdi     # 0x2ef41
callq 0x780b
leaq 0x1f5fa(%rip), %rdi     # 0x2ef4d
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: minormatrix
void
minormatrix(int row, int col)
{
	int i, j, k, m, n;
	struct atom *p1, *p2;

	p2 = symbol(NIL); // silence compiler

	p1 = pop();

	n = p1->u.tensor->dim[0];
	m = p1->u.tensor->dim[1];

	if (n == 2 && m == 2) {
		if (row == 1) {
			if (col == 1)
				push(p1->u.tensor->elem[3]);
			else
				push(p1->u.tensor->elem[2]);
		} else {
			if (col == 1)
				push(p1->u.tensor->elem[1]);
			else
				push(p1->u.tensor->elem[0]);
		}
		return;
	}

	if (n == 2)
		p2 = alloc_vector(m - 1);

	if (m == 2)
		p2 = alloc_vector(n - 1);

	if (n > 2 && m > 2)
		p2 = alloc_matrix(n - 1, m - 1);

	row--;
	col--;

	k = 0;

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

		if (i == row)
			continue;

		for (j = 0; j < m; j++) {

			if (j == col)
				continue;

			p2->u.tensor->elem[k++] = p1->u.tensor->elem[m * i + j];
		}
	}

	push(p2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x2f94c(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0xfadf
movl %esi, %ebx
movl %edi, %r14d
movq 0x36078(%rip), %rdi     # 0x45a00
decl %eax
movl %eax, 0x2f928(%rip)     # 0x3f2b8
leaq 0x38c29(%rip), %rcx     # 0x485c0
movq (%rcx,%rax,8), %r12
movq (%r12), %rax
movl 0x4(%rax), %r13d
movl 0x8(%rax), %ecx
movl %r13d, %edx
xorl $0x2, %edx
movl %ecx, %esi
xorl $0x2, %esi
orl %edx, %esi
jne 0xf9d6
xorl %ecx, %ecx
cmpl $0x1, %r14d
sete %cl
xorl %edx, %edx
cmpl $0x1, %ebx
sete %dl
shll $0x4, %ecx
leal (%rcx,%rdx,8), %ecx
movq 0x68(%rcx,%rax), %rdi
jmp 0xfacc
movl %ecx, %r15d
cmpl $0x2, %r13d
jne 0xfa00
leal -0x1(%r15), %edi
movl %edi, -0x2c(%rbp)
callq 0x7893
movq %rax, %rdi
movq (%rax), %rax
movl $0x1, (%rax)
movq (%rdi), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, 0x4(%rax)
cmpl $0x2, %r15d
jne 0xfa29
leal -0x1(%r13), %edi
movl %edi, -0x2c(%rbp)
callq 0x7893
movq %rax, %rdi
movq (%rax), %rax
movl $0x1, (%rax)
movq (%rdi), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, 0x4(%rax)
jmp 0xfa74
cmpl $0x3, %r13d
setge %al
cmpl $0x3, %r15d
setge %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0xfa74
leal -0x1(%r13), %eax
movl %eax, -0x30(%rbp)
leal -0x1(%r15), %edi
movl %edi, -0x2c(%rbp)
imull %eax, %edi
callq 0x7893
movq %rax, %rdi
movq (%rax), %rax
movl $0x2, (%rax)
movq (%rdi), %rax
movl -0x30(%rbp), %ecx
movl %ecx, 0x4(%rax)
movq (%rdi), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, 0x8(%rax)
jmp 0xfa79
testl %r13d, %r13d
jle 0xfacc
decl %ebx
decl %r14d
leaq (,%r15,8), %rax
xorl %ecx, %ecx
movl $0x68, %edx
xorl %esi, %esi
cmpq %r14, %rcx
je 0xfac1
testl %r15d, %r15d
jle 0xfac1
xorl %r8d, %r8d
cmpq %r8, %rbx
je 0xfab9
movq (%r12), %r9
addq %rdx, %r9
movq (%r9,%r8,8), %r9
movq (%rdi), %r10
movslq %esi, %r11
incl %esi
movq %r9, 0x68(%r10,%r11,8)
incq %r8
cmpq %r8, %r15
jne 0xfa9c
incq %rcx
addq %rax, %rdx
cmpq %r13, %rcx
jne 0xfa8f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8ba5
leaq 0x1f45b(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_contract
void
eval_contract(struct atom *p1)
{
	push(cadr(p1));
	evalf();

	p1 = cddr(p1);

	if (!iscons(p1)) {
		push_integer(1);
		push_integer(2);
		contract();
		return;
	}

	while (iscons(p1)) {
		push(car(p1));
		evalf();
		push(cadr(p1));
		evalf();
		contract();
		p1 = cddr(p1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
cmpb $0x1, 0x10(%rdi)
leaq 0x35ccf(%rip), %r14     # 0x45a00
movq %r14, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rax
movq (%rax), %rdi
callq 0x8ba5
callq 0x96e2
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %r15
movq (%r15), %rax
leaq 0x8(%rax), %rcx
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rcx
movq (%rcx), %rbx
cmpb $0x1, 0x10(%rbx)
jne 0xfdd4
movq (%rbx), %rdi
callq 0x8ba5
callq 0x96e2
cmpb $0x1, 0x10(%rbx)
leaq 0x8(%rbx), %r15
movq %r14, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rax
movq (%rax), %rdi
callq 0x8ba5
callq 0x96e2
callq 0xfdf9
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %r15
movq (%r15), %rax
leaq 0x8(%rax), %rcx
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rcx
movq (%rcx), %rbx
cmpb $0x1, 0x10(%rbx)
je 0xfd70
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xfbcfd(%rip), %rdi     # 0x10bad8
callq 0x8ba5
movl $0x2, %edi
callq 0xb1be
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xfdf9
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: cosfunc_sum
void
cosfunc_sum(struct atom *p1)
{
	struct atom *p2, *p3;
	p2 = cdr(p1);
	while (iscons(p2)) {
		push_integer(2);
		push(car(p2));
		multiply();
		push_symbol(PI);
		divide();
		p3 = pop();
		if (isinteger(p3)) {
			push(p1);
			push(car(p2));
			subtract();
			p3 = pop();
			push(p3);
			cosfunc();
			push(car(p2));
			cosfunc();
			multiply();
			push(p3);
			sinfunc();
			push(car(p2));
			sinfunc();
			multiply();
			subtract();
			return;
		}
		p2 = cdr(p2);
	}
	push_symbol(COS);
	push(p1);
	list(2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x1, 0x10(%rdi)
movq %rdi, -0x30(%rbp)
leaq 0x8(%rdi), %rax
leaq 0x352f9(%rip), %r14     # 0x45a00
cmovneq %r14, %rax
movq (%rax), %r15
cmpb $0x1, 0x10(%r15)
jne 0x107ca
leaq 0x10(%r15), %r12
movl $0xfffe795f, %ebx       # imm = 0xFFFE795F
leaq 0x37e97(%rip), %r13     # 0x485c0
movl $0x2, %edi
callq 0xb1be
cmpb $0x1, 0x10(%r15)
movq %r14, %rax
cmoveq %r15, %rax
movq (%rax), %rdi
callq 0x8ba5
movl $0x2, %edi
callq 0xacef
movq 0x358f8(%rip), %rdi     # 0x46050
callq 0x8ba5
movq 0x105c8c(%rip), %rdi    # 0x1163f0
callq 0x8ba5
callq 0xa573
movl $0x2, %edi
callq 0xacef
movl 0x2eb3a(%rip), %eax     # 0x3f2b8
leal (%rax,%rbx), %ecx
cmpl %ebx, %ecx
jbe 0x108e2
decl %eax
movl %eax, 0x2eb27(%rip)     # 0x3f2b8
movq (%r13,%rax,8), %rax
cmpb $0x4, 0x10(%rax)
jne 0x107ab
movq 0x8(%rax), %rax
cmpl $0x1, -0x4(%rax)
jne 0x107ab
cmpl $0x1, (%rax)
je 0x107f7
addq $0x8, %r15
cmpb $0x1, (%r12)
cmovneq %r14, %r15
movq (%r15), %r15
leaq 0x10(%r15), %r12
cmpb $0x1, 0x10(%r15)
je 0x10729
movq 0x3301f(%rip), %rdi     # 0x437f0
callq 0x8ba5
movq -0x30(%rbp), %rdi
callq 0x8ba5
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8b7d
movq -0x30(%rbp), %rdi
callq 0x8ba5
cmpb $0x1, (%r12)
movq %r14, %rax
cmoveq %r15, %rax
movq (%rax), %rdi
callq 0x8ba5
movq 0x105bd5(%rip), %rdi    # 0x1163f0
callq 0x8ba5
movl $0x2, %edi
callq 0xacef
movl $0x2, %edi
callq 0xadb3
movl 0x2ea7e(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x108e2
decl %eax
movl %eax, 0x2ea66(%rip)     # 0x3f2b8
movq (%r13,%rax,8), %rbx
movq %rbx, %rdi
callq 0x8ba5
callq 0x10115
cmpb $0x1, (%r12)
movq %r14, %rax
cmoveq %r15, %rax
movq (%rax), %rdi
callq 0x8ba5
callq 0x10115
movl $0x2, %edi
callq 0xacef
movq %rbx, %rdi
callq 0x8ba5
callq 0x10ab4
cmpb $0x1, (%r12)
cmoveq %r15, %r14
movq (%r14), %rdi
callq 0x8ba5
callq 0x10ab4
movl $0x2, %edi
callq 0xacef
movq 0x105b35(%rip), %rdi    # 0x1163f0
callq 0x8ba5
movl $0x2, %edi
callq 0xacef
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xadb3
leaq 0x1e658(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: modfunc
void
modfunc(void)
{
	int i, n;
	double d1, d2;
	struct atom *p1, *p2;

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

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

	if (!isnum(p1) || !isnum(p2) || iszero(p2)) {
		push_symbol(MOD);
		push(p1);
		push(p2);
		list(3);
		return;
	}

	if (isrational(p1) && isrational(p2)) {
		mod_rationals(p1, p2);
		return;
	}

	push(p1);
	d1 = pop_double();

	push(p2);
	d2 = pop_double();

	push_double(fmod(d1, d2));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x2e9b6(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x10aa8
leal -0x1(%rax), %ecx
movl %ecx, 0x2e99d(%rip)     # 0x3f2b8
cmpl $0x1, %eax
jbe 0x10aa8
leaq 0x37c95(%rip), %rdx     # 0x485c0
movq (%rdx,%rcx,8), %rbx
addl $-0x2, %eax
movl %eax, 0x2e980(%rip)     # 0x3f2b8
movq (%rdx,%rax,8), %r14
movb 0x10(%r14), %r15b
movzbl %r15b, %eax
leal -0x4(%rax), %ecx
cmpl $0x2, %ecx
jae 0x1099a
movb 0x10(%rbx), %r12b
movl %r12d, %eax
andb $-0x2, %al
cmpb $0x4, %al
jne 0x10a29
movq %rbx, %rdi
callq 0xb477
testl %eax, %eax
jne 0x10a29
cmpb $0x4, %r15b
jne 0x10a5d
cmpb $0x4, %r12b
jne 0x10a5d
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x19ab8
cmpl $0x7, %eax
jne 0x10a29
movq %r14, %rdi
callq 0x9638
movq %rax, %r14
movq (%rax), %rax
movslq 0x64(%rax), %r12
testq %r12, %r12
jle 0x10a13
xorl %r13d, %r13d
movl $0xfffe795f, %r15d      # imm = 0xFFFE795F
movq (%r14), %rax
movq 0x68(%rax,%r13,8), %rdi
callq 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
callq 0x108ee
movl 0x2e8d5(%rip), %eax     # 0x3f2b8
leal (%rax,%r15), %ecx
cmpl %r15d, %ecx
jbe 0x10aa8
decl %eax
movl %eax, 0x2e8c0(%rip)     # 0x3f2b8
leaq 0x37bc1(%rip), %rcx     # 0x485c0
movq (%rcx,%rax,8), %rax
movq (%r14), %rcx
movq %rax, 0x68(%rcx,%r13,8)
incq %r13
cmpq %r13, %r12
jne 0x109c3
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8ba5
movq 0x34cc8(%rip), %rdi     # 0x456f8
callq 0x8ba5
movq %r14, %rdi
callq 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
movl $0x3, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8b7d
movq %r14, %rdi
callq 0x8ba5
callq 0x9128
movsd %xmm0, -0x30(%rbp)
movq %rbx, %rdi
callq 0x8ba5
callq 0x9128
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
callq 0x7160
movsd %xmm0, -0x30(%rbp)
callq 0x74dc
movb $0x5, 0x10(%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rax, %rdi
jmp 0x10a16
leaq 0x1e492(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: integral
void
integral(void)
{
	int h;
	struct atom *p1, *F, *X;

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

	if (!isusersymbol(X))
		stopf("integral: symbol expected");

	if (car(F) == symbol(ADD)) {
		h = tos;
		p1 = cdr(F);
		while (iscons(p1)) {
			push(car(p1));
			push(X);
			integral();
			p1 = cdr(p1);
		}
		add_terms(tos - h);
		return;
	}

	if (car(F) == symbol(MULTIPLY)) {
		push(F);
		push(X);
		partition_term();	// push const part then push var part
		F = pop();		// pop var part
		integral_solve(F, X);
		multiply();		// multiply by const part
		return;
	}

	integral_solve(F, X);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x2dcf5(%rip), %r14d    # 0x3f2b8
movl $0xfffe795f, %eax       # imm = 0xFFFE795F
leal (%r14,%rax), %ecx
cmpl %eax, %ecx
jbe 0x116e7
leal -0x1(%r14), %eax
movl %eax, 0x2dcda(%rip)     # 0x3f2b8
cmpl $0x1, %r14d
jbe 0x116e7
leaq 0x36fd1(%rip), %r15     # 0x485c0
movq (%r15,%rax,8), %rbx
addl $-0x2, %r14d
movl %r14d, 0x2dcba(%rip)    # 0x3f2b8
cmpb $0x3, 0x10(%rbx)
jne 0x116f3
movq (%r15,%r14,8), %rdi
movb 0x10(%rdi), %al
cmpb $0x1, %al
leaq 0x343e8(%rip), %r12     # 0x45a00
movq %r12, %rcx
cmoveq %rdi, %rcx
movq (%rcx), %rcx
cmpq 0x36c77(%rip), %rcx     # 0x482a0
je 0x11644
cmpq 0x36c76(%rip), %rcx     # 0x482a8
je 0x1169d
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x17c2d
addq $0x8, %rdi
cmpb $0x1, %al
cmovneq %r12, %rdi
movq (%rdi), %r15
cmpb $0x1, 0x10(%r15)
movl %r14d, %edi
jne 0x1168d
movq (%r15), %rdi
callq 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
callq 0x115b1
leaq 0x8(%r15), %rax
cmpb $0x1, 0x10(%r15)
cmovneq %r12, %rax
movq (%rax), %r15
cmpb $0x1, 0x10(%r15)
je 0x1165b
movl 0x2dc2b(%rip), %edi     # 0x3f2b8
subl %r14d, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xadb3
callq 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
callq 0x17a53
movl 0x2dc03(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x116e7
decl %eax
movl %eax, 0x2dbef(%rip)     # 0x3f2b8
movq (%r15,%rax,8), %rdi
movq %rbx, %rsi
callq 0x17c2d
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xacef
leaq 0x1d853(%rip), %rdi     # 0x2ef41
callq 0x780b
leaq 0x1d14f(%rip), %rdi     # 0x2e849
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: derivative
void
derivative(void)
{
	struct atom *F, *X;

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

	if (istensor(F)) {
		if (istensor(X))
			d_tensor_tensor(F, X);
		else
			d_tensor_scalar(F, X);
	} else {
		if (istensor(X))
			d_scalar_tensor(F, X);
		else
			d_scalar_scalar(F, X);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x2d924(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x119ef
leal -0x1(%rax), %ecx
movl %ecx, 0x2d90f(%rip)     # 0x3f2b8
cmpl $0x1, %eax
jbe 0x119ef
leaq 0x36c0b(%rip), %rdx     # 0x485c0
movq (%rdx,%rcx,8), %rsi
addl $-0x2, %eax
movl %eax, 0x2d8f6(%rip)     # 0x3f2b8
movq (%rdx,%rax,8), %rdi
cmpb $0x7, 0x10(%rdi)
movb 0x10(%rsi), %al
jne 0x119d9
cmpb $0x7, %al
jne 0x119e3
popq %rbp
jmp 0x119fb
cmpb $0x7, %al
jne 0x119e9
popq %rbp
jmp 0x11c1b
popq %rbp
jmp 0x11b7d
popq %rbp
jmp 0x11cbf
leaq 0x1d54b(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: d_tensor_tensor
void
d_tensor_tensor(struct atom *p1, struct atom *p2)
{
	int i, j, k, m, n;
	struct atom *p3;

	if (p1->u.tensor->ndim + p2->u.tensor->ndim > MAXDIM)
		stopf("rank exceeds max");

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

	p3 = alloc_tensor(n * m);

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

	// dim info

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

	k = 0;

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

	for (i = 0; i < n; i++)
		p3->u.tensor->dim[k++] = p1->u.tensor->dim[i];

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

	for (i = 0; i < n; i++)
		p3->u.tensor->dim[k++] = p2->u.tensor->dim[i];

	push(p3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, -0x40(%rbp)
movq (%rdi), %rcx
movq %rsi, -0x38(%rbp)
movq (%rsi), %rax
movl (%rax), %edx
addl (%rcx), %edx
cmpl $0x19, %edx
jge 0x11b71
movslq 0x64(%rcx), %rbx
movl 0x64(%rax), %ecx
movq %rcx, -0x30(%rbp)
movl %ecx, %edi
imull %ebx, %edi
callq 0x7893
movq %rax, %r13
movq %rbx, -0x50(%rbp)
testq %rbx, %rbx
movq -0x40(%rbp), %r9
jle 0x11ae5
movq -0x30(%rbp), %rcx
leaq (,%rcx,8), %rcx
movq %rcx, -0x48(%rbp)
movl $0x68, %r12d
xorl %ebx, %ebx
movl $0xfffe795f, %r14d      # imm = 0xFFFE795F
cmpl $0x0, -0x30(%rbp)
jle 0x11ad8
xorl %r15d, %r15d
movq (%r9), %rax
movq 0x68(%rax,%rbx,8), %rdi
callq 0x8ba5
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq 0x68(%rax,%r15,8), %rdi
callq 0x8ba5
callq 0x1198a
movl 0x2d818(%rip), %eax     # 0x3f2b8
leal (%rax,%r14), %ecx
cmpl %r14d, %ecx
jbe 0x11b65
decl %eax
movl %eax, 0x2d803(%rip)     # 0x3f2b8
leaq 0x36b04(%rip), %rcx     # 0x485c0
movq (%rcx,%rax,8), %rdx
movq (%r13), %rcx
addq %r12, %rcx
movq %rdx, (%rcx,%r15,8)
incq %r15
cmpq %r15, -0x30(%rbp)
movq -0x40(%rbp), %r9
jne 0x11a77
incq %rbx
addq -0x48(%rbp), %r12
cmpq -0x50(%rbp), %rbx
jne 0x11a6e
movq (%r9), %rdx
movq -0x38(%rbp), %r8
movq (%r8), %rcx
movl (%rcx), %ecx
addl (%rdx), %ecx
movq (%r13), %rdx
movl %ecx, (%rdx)
movq (%r9), %rcx
movslq (%rcx), %rdi
testq %rdi, %rdi
jle 0x11b1f
xorl %ecx, %ecx
movq (%r9), %rdx
movl 0x4(%rdx,%rcx,4), %edx
movq (%r13), %rsi
movl %edx, 0x4(%rsi,%rcx,4)
incq %rcx
cmpq %rcx, %rdi
jne 0x11b06
jmp 0x11b21
xorl %edi, %edi
movq (%r8), %rcx
movslq (%rcx), %rcx
testq %rcx, %rcx
jle 0x11b4f
leaq 0x4(,%rdi,4), %r9
xorl %edx, %edx
movq (%r8), %rsi
movl 0x4(%rsi,%rdx,4), %esi
movq (%r13), %rdi
addq %r9, %rdi
movl %esi, (%rdi,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x11b36
movq %r13, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8ba5
leaq 0x1d3d5(%rip), %rdi     # 0x2ef41
callq 0x780b
leaq 0x18891(%rip), %rdi     # 0x2a409
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: d_tensor_scalar
void
d_tensor_scalar(struct atom *p1, struct atom *p2)
{
	int i, n;
	struct atom *p3;

	p3 = copy_tensor(p1);

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

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

	push(p3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, -0x30(%rbp)
movq %rdi, %r14
callq 0x9638
movq %rax, %r15
movq (%r14), %rax
movslq 0x64(%rax), %r12
testq %r12, %r12
jle 0x11bf9
xorl %r13d, %r13d
movl $0xfffe795f, %ebx       # imm = 0xFFFE795F
movq (%r14), %rax
movq 0x68(%rax,%r13,8), %rdi
callq 0x8ba5
movq -0x30(%rbp), %rdi
callq 0x8ba5
callq 0x1198a
movl 0x2d6e9(%rip), %eax     # 0x3f2b8
leal (%rax,%rbx), %ecx
cmpl %ebx, %ecx
jbe 0x11c0f
decl %eax
movl %eax, 0x2d6da(%rip)     # 0x3f2b8
leaq 0x369db(%rip), %rcx     # 0x485c0
movq (%rcx,%rax,8), %rax
movq (%r15), %rcx
movq %rax, 0x68(%rcx,%r13,8)
incq %r13
cmpq %r13, %r12
jne 0x11bae
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8ba5
leaq 0x1d32b(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: d_scalar_tensor
void
d_scalar_tensor(struct atom *p1, struct atom *p2)
{
	int i, n;
	struct atom *p3;

	p3 = copy_tensor(p2);

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

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

	push(p3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, -0x30(%rbp)
movq %rsi, %rdi
callq 0x9638
movq %rax, %r15
movq (%rbx), %rax
movslq 0x64(%rax), %r12
testq %r12, %r12
jle 0x11c9d
xorl %r13d, %r13d
movl $0xfffe795f, %r14d      # imm = 0xFFFE795F
movq -0x30(%rbp), %rdi
callq 0x8ba5
movq (%rbx), %rax
movq 0x68(%rax,%r13,8), %rdi
callq 0x8ba5
callq 0x1198a
movl 0x2d647(%rip), %eax     # 0x3f2b8
leal (%rax,%r14), %ecx
cmpl %r14d, %ecx
jbe 0x11cb3
decl %eax
movl %eax, 0x2d636(%rip)     # 0x3f2b8
leaq 0x36937(%rip), %rcx     # 0x485c0
movq (%rcx,%rax,8), %rax
movq (%r15), %rcx
movq %rax, 0x68(%rcx,%r13,8)
incq %r13
cmpq %r13, %r12
jne 0x11c50
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8ba5
leaq 0x1d287(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: derivative_of_derivative
void
derivative_of_derivative(struct atom *F, struct atom *X)
{
	struct atom *G, *Y;

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

	if (X == Y) {
		push_symbol(DERIVATIVE);
		push(F);
		push(X);
		list(3);
		return;
	}

	push(G);
	push(X);
	derivative();

	G = pop();

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

		// sort derivatives

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

		push_symbol(DERIVATIVE);
		push_symbol(DERIVATIVE);
		push(F);

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

		return;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r15
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rcx
leaq 0x33a77(%rip), %rax     # 0x45a00
cmovneq %rax, %rcx
movq %rsi, %r14
movq (%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0x11fa8
movq (%rcx), %rdi
movq 0x8(%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
je 0x11fb8
jmp 0x11fbb
movq 0x33a51(%rip), %rcx     # 0x45a00
cmpb $0x1, 0x10(%rcx)
movq %rcx, %rdi
jne 0x11fbb
movq %rcx, %rax
movq (%rax), %rbx
cmpq %r14, %rbx
je 0x1203d
callq 0x8ba5
movq %r14, %rdi
callq 0x8ba5
callq 0x1198a
movl 0x2d2dd(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x120f9
decl %eax
movl %eax, 0x2d2c5(%rip)     # 0x3f2b8
leaq 0x365c6(%rip), %rcx     # 0x485c0
movq (%rcx,%rax,8), %rax
movb 0x10(%rax), %dl
cmpb $0x1, %dl
leaq 0x339f5(%rip), %rcx     # 0x45a00
movq %rcx, %rsi
cmoveq %rax, %rsi
movq 0x31ac7(%rip), %rdi     # 0x43ae0
cmpq %rdi, (%rsi)
je 0x12053
movq %rax, %rdi
callq 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1198a
movq 0x31a9c(%rip), %rdi     # 0x43ae0
callq 0x8ba5
movq %r15, %rdi
callq 0x8ba5
jmp 0x120c6
addq $0x8, %rax
cmpb $0x1, %dl
cmovneq %rcx, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
jne 0x12076
movq (%rax), %r15
movq 0x8(%rax), %rax
cmpb $0x1, 0x10(%rax)
je 0x12086
jmp 0x12089
movq 0x33983(%rip), %rax     # 0x45a00
cmpb $0x1, 0x10(%rax)
movq %rax, %r15
jne 0x12089
movq %rax, %rcx
movq (%rcx), %r14
callq 0x8ba5
movq 0x31a48(%rip), %rdi     # 0x43ae0
callq 0x8ba5
movq %r15, %rdi
callq 0x8ba5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8d48
testl %eax, %eax
js 0x120e2
movq %rbx, %rdi
callq 0x8ba5
movl $0x3, %edi
callq 0x8b7d
movq %r14, %rdi
callq 0x8ba5
movl $0x3, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8b7d
movq %r14, %rdi
callq 0x8ba5
movl $0x3, %edi
callq 0x8b7d
movq %rbx, %rdi
jmp 0x120c9
leaq 0x1ce41(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: derivative_of_integral
void
derivative_of_integral(struct atom *F, struct atom *X)
{
	struct atom *G, *Y;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rcx
leaq 0x338e5(%rip), %rax     # 0x45a00
cmovneq %rax, %rcx
movq %rsi, %rbx
movq (%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0x1213a
movq (%rcx), %rdi
movq 0x8(%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
je 0x1214a
jmp 0x1214d
movq 0x338bf(%rip), %rcx     # 0x45a00
cmpb $0x1, 0x10(%rcx)
movq %rcx, %rdi
jne 0x1214d
movq %rcx, %rax
movq (%rax), %r14
callq 0x8ba5
cmpq %rbx, %r14
je 0x12178
movq %rbx, %rdi
callq 0x8ba5
callq 0x1198a
movq %r14, %rdi
callq 0x8ba5
popq %rbx
popq %r14
popq %rbp
jmp 0x115b1
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: dsum
void
dsum(struct atom *p1, struct atom *p2)
{
	int h = tos;
	p1 = cdr(p1);
	while (iscons(p1)) {
		push(car(p1));
		push(p2);
		derivative();
		p1 = cdr(p1);
	}
	add_terms(tos - h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x2d129(%rip), %r14d    # 0x3f2b8
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rax
leaq 0x33862(%rip), %r15     # 0x45a00
cmovneq %r15, %rax
movq (%rax), %r12
cmpb $0x1, 0x10(%r12)
movl %r14d, %edi
jne 0x121e9
movq %rsi, %rbx
movq (%r12), %rdi
callq 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
callq 0x1198a
leaq 0x8(%r12), %rax
cmpb $0x1, 0x10(%r12)
cmovneq %r15, %rax
movq (%rax), %r12
cmpb $0x1, 0x10(%r12)
je 0x121b3
movl 0x2d0cf(%rip), %edi     # 0x3f2b8
subl %r14d, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xadb3
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: dproduct
void
dproduct(struct atom *p1, struct atom *p2)
{
	int i, j, n;
	struct atom *p3;
	n = lengthf(p1) - 1;
	for (i = 0; i < n; i++) {
		p3 = cdr(p1);
		for (j = 0; j < n; j++) {
			push(car(p3));
			if (i == j) {
				push(p2);
				derivative();
			}
			p3 = cdr(p3);
		}
		multiply_factors(n);
	}
	add_terms(n);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x40(%rbp)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpb $0x1, 0x10(%rdi)
jne 0x122aa
movq %rdi, %rax
movq 0x8(%rax), %rax
incl %ebx
cmpb $0x1, 0x10(%rax)
je 0x12220
testl %ebx, %ebx
je 0x122aa
leaq 0x8(%rdi), %rax
movq %rax, -0x30(%rbp)
xorl %r13d, %r13d
leaq 0x337be(%rip), %r12     # 0x45a00
movq %rdi, -0x38(%rbp)
cmpb $0x1, 0x10(%rdi)
movq %r12, %r15
cmoveq -0x30(%rbp), %r15
xorl %r14d, %r14d
movq (%r15), %r15
cmpb $0x1, 0x10(%r15)
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rdi
callq 0x8ba5
cmpl %r14d, %r13d
jne 0x1227f
movq -0x40(%rbp), %rdi
callq 0x8ba5
callq 0x1198a
cmpb $0x1, 0x10(%r15)
je 0x1228b
movq %r12, %r15
jmp 0x1228f
addq $0x8, %r15
incl %r14d
cmpl %r14d, %ebx
jne 0x12255
movl %ebx, %edi
callq 0xacef
incl %r13d
cmpl %r13d, %ebx
movq -0x38(%rbp), %rdi
jne 0x12246
movl %ebx, %edi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xadb3
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: dpower
void
dpower(struct atom *F, struct atom *X)
{
	if (isnum(cadr(F)) && isnum(caddr(F))) {
		push_integer(0); // irr or imag
		return;
	}

	push(caddr(F));		// v/u
	push(cadr(F));
	divide();

	push(cadr(F));		// du/dx
	push(X);
	derivative();

	multiply();

	push(cadr(F));		// log u
	logfunc();

	push(caddr(F));		// dv/dx
	push(X);
	derivative();

	multiply();

	add();

	push(F);		// u^v

	multiply();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
cmpb $0x1, 0x10(%rdi)
leaq 0x33724(%rip), %rdx     # 0x45a00
movq %rdx, %rax
cmoveq %r15, %rax
movq %rsi, %r14
movq (%rax), %rax
movb 0x10(%rax), %cl
cmpb $0x1, %cl
jne 0x1232e
movq (%rax), %rsi
movb 0x10(%rsi), %sil
andb $-0x2, %sil
cmpb $0x4, %sil
jne 0x1239f
movq 0x8(%rax), %rsi
cmpb $0x1, 0x10(%rsi)
jne 0x1235a
movq (%rsi), %rsi
cmpb $0x4, 0x10(%rsi)
je 0x1238b
cmpb $0x1, %cl
jne 0x12372
movq 0x8(%rax), %rsi
cmpb $0x1, 0x10(%rsi)
jne 0x12382
leaq 0x8(%rax), %rdx
jmp 0x1237f
movq 0x336cb(%rip), %rsi     # 0x45a00
movzbl 0x10(%rsi), %esi
cmpl $0x4, %esi
je 0x1238b
cmpl $0x5, %esi
jne 0x123aa
movq 0x336b6(%rip), %rsi     # 0x45a00
movzbl 0x10(%rsi), %edi
cmpl $0x1, %edi
je 0x12369
cmpl $0x4, %edi
je 0x1238b
jmp 0x12372
movq 0x3369f(%rip), %rsi     # 0x45a00
cmpb $0x4, 0x10(%rsi)
jne 0x12382
jmp 0x1238b
movq (%rsi), %rsi
cmpb $0x4, 0x10(%rsi)
je 0x1238b
movq 0x33687(%rip), %rsi     # 0x45a00
cmpb $0x1, 0x10(%rsi)
jne 0x12382
movq (%rdx), %rdx
movq (%rdx), %rdx
cmpb $0x5, 0x10(%rdx)
jne 0x1239f
movq 0x30dae(%rip), %rdi     # 0x43140
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8ba5
cmpb $0x1, %cl
jne 0x123aa
movq 0x8(%rax), %rax
jmp 0x123b1
movq 0x3364f(%rip), %rax     # 0x45a00
cmpb $0x1, 0x10(%rax)
je 0x123be
leaq 0x33642(%rip), %rax     # 0x45a00
movq (%rax), %rdi
callq 0x8ba5
cmpb $0x1, 0x10(%rbx)
leaq 0x3362f(%rip), %r12     # 0x45a00
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x8ba5
movq 0x103ffe(%rip), %rdi    # 0x1163f0
callq 0x8ba5
callq 0xa573
movl $0x2, %edi
callq 0xacef
cmpb $0x1, 0x10(%rbx)
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x8ba5
movq %r14, %rdi
callq 0x8ba5
callq 0x1198a
movl $0x2, %edi
callq 0xacef
cmpb $0x1, 0x10(%rbx)
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x8ba5
callq 0xcbe3
cmpb $0x1, 0x10(%rbx)
cmovneq %r12, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
jne 0x12475
movq 0x8(%rax), %rax
jmp 0x1247c
movq 0x33584(%rip), %rax     # 0x45a00
cmpb $0x1, 0x10(%rax)
jne 0x12485
movq %rax, %r12
movq (%r12), %rdi
callq 0x8ba5
movq %r14, %rdi
callq 0x8ba5
callq 0x1198a
movl $0x2, %edi
callq 0xacef
movl $0x2, %edi
callq 0xadb3
movq %rbx, %rdi
callq 0x8ba5
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xacef
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: dlog
void
dlog(struct atom *p1, struct atom *p2)
{
	push(cadr(p1));
	push(p2);
	derivative();
	push(cadr(p1));
	divide();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
cmpb $0x1, 0x10(%rdi)
leaq 0x3351a(%rip), %r12     # 0x45a00
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x8ba5
movq %r14, %rdi
callq 0x8ba5
callq 0x1198a
cmpb $0x1, 0x10(%rbx)
cmovneq %r12, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r12
movq (%r12), %rdi
callq 0x8ba5
movq 0x103ebd(%rip), %rdi    # 0x1163f0
callq 0x8ba5
callq 0xa573
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xacef
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: dsin
void
dsin(struct atom *p1, struct atom *p2)
{
	push(cadr(p1));
	push(p2);
	derivative();
	push(cadr(p1));
	cosfunc();
	multiply();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
cmpb $0x1, 0x10(%rdi)
leaq 0x33494(%rip), %r12     # 0x45a00
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x8ba5
movq %r14, %rdi
callq 0x8ba5
callq 0x1198a
cmpb $0x1, 0x10(%rbx)
cmovneq %r12, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r12
movq (%r12), %rdi
callq 0x8ba5
callq 0x10115
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xacef
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: dtan
void
dtan(struct atom *p1, struct atom *p2)
{
	push(cadr(p1));
	push(p2);
	derivative();
	push(cadr(p1));
	cosfunc();
	push_integer(-2);
	power();
	multiply();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
cmpb $0x1, 0x10(%rdi)
leaq 0x3338a(%rip), %r12     # 0x45a00
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r12, %rax
movq (%rax), %rdi
callq 0x8ba5
movq %r14, %rdi
callq 0x8ba5
callq 0x1198a
cmpb $0x1, 0x10(%rbx)
cmovneq %r12, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r12
movq (%r12), %rdi
callq 0x8ba5
callq 0x10115
movl $0xfffffffe, %edi       # imm = 0xFFFFFFFE
callq 0xb1be
callq 0xa573
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xacef
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: darcsin
void
darcsin(struct atom *p1, struct atom *p2)
{
	push(cadr(p1));
	push(p2);
	derivative();
	push_integer(1);
	push(cadr(p1));
	push_integer(2);
	power();
	subtract();
	push_rational(-1, 2);
	power();
	multiply();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r12
cmpb $0x1, 0x10(%rdi)
leaq 0x33301(%rip), %r15     # 0x45a00
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x8ba5
movq %r14, %rdi
callq 0x8ba5
callq 0x1198a
movq 0xf93a8(%rip), %rdi     # 0x10bad8
callq 0x8ba5
cmpb $0x1, 0x10(%rbx)
cmovneq %r15, %r12
movq (%r12), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r15
movq (%r15), %rdi
callq 0x8ba5
movl $0x2, %edi
callq 0xb1be
callq 0xa573
movq 0x103c89(%rip), %rdi    # 0x1163f0
callq 0x8ba5
movl $0x2, %edi
callq 0xacef
movl $0x2, %edi
callq 0xadb3
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x2, %esi
callq 0xa533
callq 0xa573
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xacef
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: darccos
void
darccos(struct atom *p1, struct atom *p2)
{
	push(cadr(p1));
	push(p2);
	derivative();
	push_integer(1);
	push(cadr(p1));
	push_integer(2);
	power();
	subtract();
	push_rational(-1, 2);
	power();
	multiply();
	negate();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r12
cmpb $0x1, 0x10(%rdi)
leaq 0x3323d(%rip), %r15     # 0x45a00
movq %r15, %rax
cmoveq %r12, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %rsi, %r14
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x8ba5
movq %r14, %rdi
callq 0x8ba5
callq 0x1198a
movq 0xf92e4(%rip), %rdi     # 0x10bad8
callq 0x8ba5
cmpb $0x1, 0x10(%rbx)
cmovneq %r15, %r12
movq (%r12), %rax
cmpb $0x1, 0x10(%rax)
cmoveq %rax, %r15
movq (%r15), %rdi
callq 0x8ba5
movl $0x2, %edi
callq 0xb1be
callq 0xa573
movq 0x103bc5(%rip), %rdi    # 0x1163f0
callq 0x8ba5
movl $0x2, %edi
callq 0xacef
movl $0x2, %edi
callq 0xadb3
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x2, %esi
callq 0xa533
callq 0xa573
movl $0x2, %edi
callq 0xacef
movq 0x103b87(%rip), %rdi    # 0x1163f0
callq 0x8ba5
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xacef