LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_infixform
void
eval_infixform(struct atom *p1)
{
	push(cadr(p1));
	evalf();
	p1 = pop();

	outbuf_init();
	infixform_expr(p1);

	push_string(outbuf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x1ede7
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1edf2
movq 0x3fc12(%rip), %rax     # 0x5ea00
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x1ee32
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x1ee1a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1ee25
movq 0x3fbdf(%rip), %rax     # 0x5ea00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1ee3d
movq 0x3fbc7(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9110
callq 0xa660
callq 0x91d0
movq %rax, -0x8(%rbp)
callq 0x1ee80
movq -0x8(%rbp), %rdi
callq 0x1eea0
movq 0x11055f(%rip), %rdi    # 0x12f3c8
callq 0x1efd0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: infixform_expr
void
infixform_expr(struct atom *p)
{
	if (isnegativeterm(p) || (car(p) == symbol(ADD) && isnegativeterm(cadr(p))))
		outbuf_puts("-");
	if (car(p) == symbol(ADD))
		infixform_expr_nib(p);
	else
		infixform_term(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc2b0
cmpl $0x0, %eax
jne 0x1ef73
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x1eed8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1eee3
movq 0x3fb21(%rip), %rax     # 0x5ea00
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x423b2(%rip), %rax     # 0x612a0
jne 0x1ef7f
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x1ef0f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1ef1a
movq 0x3faea(%rip), %rax     # 0x5ea00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x1ef5a
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x1ef42
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1ef4d
movq 0x3fab7(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x1ef65
movq 0x3fa9f(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xc2b0
cmpl $0x0, %eax
je 0x1ef7f
leaq 0x26412(%rip), %rdi     # 0x4538c
callq 0x1f060
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x1ef99
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x1efa4
movq 0x3fa60(%rip), %rax     # 0x5ea00
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq 0x422f1(%rip), %rax     # 0x612a0
jne 0x1efbc
movq -0x8(%rbp), %rdi
callq 0x1f180
jmp 0x1efc5
movq -0x8(%rbp), %rdi
callq 0x1f350
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: push_string
void
push_string(char *s)
{
	struct atom *p;
	p = alloc_str();
	s = strdup(s);
	if (s == NULL)
		exit(1);
	p->u.str = s;
	push(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x7a90
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x7350
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1f003
movl $0x1, %edi
callq 0x7320
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
callq 0x9110
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: print_infixform
void
print_infixform(struct atom *p)
{
	outbuf_init();
	infixform_expr(p);
	outbuf_puts("\n");
	printbuf(outbuf, BLACK);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x1ee80
movq -0x8(%rbp), %rdi
callq 0x1eea0
leaq 0x2ae59(%rip), %rdi     # 0x49e9a
callq 0x1f060
movq 0x11037b(%rip), %rdi    # 0x12f3c8
xorl %esi, %esi
callq 0x1f110
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: outbuf_puts
void
outbuf_puts(char *s)
{
	int len, m;

	len = (int) strlen(s);

	// Let outbuf_index + len == 1000

	// Then m == 2000 hence there is always room for the terminator '\0'

	m = 1000 * ((outbuf_index + len) / 1000 + 1); // m is a multiple of 1000

	if (m > outbuf_length) {
		outbuf = realloc(outbuf, m);
		if (outbuf == NULL)
			exit(1);
		outbuf_length = m;
	}

	strcpy(outbuf + outbuf_index, s);
	outbuf_index += len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x70e0
movl %eax, -0xc(%rbp)
movl 0x11077a(%rip), %eax    # 0x12f7f8
addl -0xc(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
addl $0x1, %eax
imull $0x3e8, %eax, %eax      # imm = 0x3E8
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl 0x11075e(%rip), %eax    # 0x12f7fc
jle 0x1f0d4
movq 0x110321(%rip), %rdi    # 0x12f3c8
movslq -0x10(%rbp), %rsi
callq 0x72b0
movq %rax, 0x110311(%rip)    # 0x12f3c8
cmpq $0x0, 0x110309(%rip)    # 0x12f3c8
jne 0x1f0cb
movl $0x1, %edi
callq 0x7320
movl -0x10(%rbp), %eax
movl %eax, 0x110728(%rip)    # 0x12f7fc
movq 0x1102ed(%rip), %rdi    # 0x12f3c8
movslq 0x110716(%rip), %rax    # 0x12f7f8
addq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x7090
movl -0xc(%rbp), %eax
addl 0x110701(%rip), %eax    # 0x12f7f8
movl %eax, 0x1106fb(%rip)    # 0x12f7f8
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: infixform_expr_nib
void
infixform_expr_nib(struct atom *p)
{
	infixform_term(cadr(p));
	p = cddr(p);
	while (iscons(p)) {
		if (isnegativeterm(car(p)))
			outbuf_puts(" - ");
		else
			outbuf_puts(" + ");
		infixform_term(car(p));
		p = cdr(p);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x1f1a7
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1f1b2
movq 0x3f852(%rip), %rax     # 0x5ea00
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x1f1f2
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x1f1da
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1f1e5
movq 0x3f81f(%rip), %rax     # 0x5ea00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1f1fd
movq 0x3f807(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1f350
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x1f221
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x1f22c
movq 0x3f7d8(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x1f26d
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x1f254
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x1f25f
movq 0x3f7a5(%rip), %rax     # 0x5ea00
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x1f278
movq 0x3f78c(%rip), %rax     # 0x5ea00
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x1f33f
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x1f2ab
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x1f2b6
movq 0x3f74e(%rip), %rax     # 0x5ea00
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0xc2b0
cmpl $0x0, %eax
je 0x1f2d2
leaq 0x26076(%rip), %rdi     # 0x45341
callq 0x1f060
jmp 0x1f2de
leaq 0x2606c(%rip), %rdi     # 0x45345
callq 0x1f060
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x1f2f8
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x1f303
movq 0x3f701(%rip), %rax     # 0x5ea00
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x1f350
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x1f327
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x50(%rbp)
jmp 0x1f332
movq 0x3f6d2(%rip), %rax     # 0x5ea00
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1f280
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: infixform_term
void
infixform_term(struct atom *p)
{
	if (car(p) == symbol(MULTIPLY))
		infixform_term_nib(p);
	else
		infixform_factor(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x1f376
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1f381
movq 0x3f683(%rip), %rax     # 0x5ea00
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x41f1c(%rip), %rax     # 0x612a8
jne 0x1f399
movq -0x8(%rbp), %rdi
callq 0x1f3b0
jmp 0x1f3a2
movq -0x8(%rbp), %rdi
callq 0x1f560
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: infixform_term_nib
void
infixform_term_nib(struct atom *p)
{
	if (find_denominator(p)) {
		infixform_numerators(p);
		outbuf_puts(" / ");
		infixform_denominators(p);
		return;
	}

	// no denominators

	p = cdr(p);

	if (isminusone(car(p)))
		p = cdr(p); // sign already emitted

	infixform_factor(car(p));

	p = cdr(p);

	while (iscons(p)) {
		outbuf_puts(" "); // space in between factors
		infixform_factor(car(p));
		p = cdr(p);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9c10
cmpl $0x0, %eax
je 0x1f3ed
movq -0x8(%rbp), %rdi
callq 0x20530
leaq 0x25f9b(%rip), %rdi     # 0x45375
callq 0x1f060
movq -0x8(%rbp), %rdi
callq 0x20660
jmp 0x1f54f
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x1f408
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1f413
movq 0x3f5f1(%rip), %rax     # 0x5ea00
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x1f435
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1f440
movq 0x3f5c4(%rip), %rax     # 0x5ea00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10770
cmpl $0x0, %eax
je 0x1f47c
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x1f469
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1f474
movq 0x3f590(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x1f496
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x1f4a1
movq 0x3f563(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1f560
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x1f4c5
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x1f4d0
movq 0x3f534(%rip), %rax     # 0x5ea00
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x1f54f
leaq 0x25e5b(%rip), %rdi     # 0x45347
callq 0x1f060
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x1f50b
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x1f516
movq 0x3f4ee(%rip), %rax     # 0x5ea00
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x1f560
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x1f53a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x1f545
movq 0x3f4bf(%rip), %rax     # 0x5ea00
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1f4d8
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: infixform_numerators
void
infixform_numerators(struct atom *p)
{
	int k;
	char *s;
	struct atom *q;

	k = 0;

	p = cdr(p);

	while (iscons(p)) {

		q = car(p);
		p = cdr(p);

		if (!isnumerator(q))
			continue;

		if (++k > 1)
			outbuf_puts(" "); // space in between factors

		if (isrational(q)) {
			s = mstr(q->u.q.a);
			outbuf_puts(s);
			continue;
		}

		infixform_factor(q);
	}

	if (k == 0)
		outbuf_puts("1");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2055e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x20569
movq 0x3e49b(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x20640
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2059c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x205a7
movq 0x3e45d(%rip), %rax     # 0x5ea00
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x205ca
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x205d5
movq 0x3e42f(%rip), %rax     # 0x5ea00
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa1e0
cmpl $0x0, %eax
jne 0x205ed
jmp 0x20571
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x1, %eax
jle 0x20607
leaq 0x24d45(%rip), %rdi     # 0x45347
callq 0x1f060
movq -0x20(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x4, %eax
jne 0x20632
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x8000
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1f060
jmp 0x20571
movq -0x20(%rbp), %rdi
callq 0x1f560
jmp 0x20571
cmpl $0x0, -0xc(%rbp)
jne 0x20652
leaq 0x25a9f(%rip), %rdi     # 0x460ec
callq 0x1f060
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: infixform_base
void
infixform_base(struct atom *p)
{
	if (isnum(p))
		infixform_numeric_base(p);
	else if (car(p) == symbol(ADD) || car(p) == symbol(MULTIPLY) || car(p) == symbol(POWER) || car(p) == symbol(FACTORIAL))
		infixform_subexpr(p);
	else
		infixform_expr(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x4, %eax
je 0x20b76
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x5, %eax
jne 0x20b84
movq -0x8(%rbp), %rdi
callq 0x22010
jmp 0x20c66
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x20b9e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x20ba9
movq 0x3de5b(%rip), %rax     # 0x5ea00
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x406ec(%rip), %rax     # 0x612a0
je 0x20c50
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x20bd4
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x20bdf
movq 0x3de25(%rip), %rax     # 0x5ea00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq 0x406be(%rip), %rax     # 0x612a8
je 0x20c50
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x20c06
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x20c11
movq 0x3ddf3(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq 0x40694(%rip), %rax     # 0x612b0
je 0x20c50
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x20c38
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x20c43
movq 0x3ddc1(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq 0x3c4b2(%rip), %rax     # 0x5d100
jne 0x20c5b
movq -0x8(%rbp), %rdi
callq 0x1f140
jmp 0x20c64
movq -0x8(%rbp), %rdi
callq 0x1eea0
jmp 0x20c66
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: infixform_numeric_exponent
void
infixform_numeric_exponent(struct atom *p)
{
	if (isdouble(p)) {
		outbuf_puts("(");
		infixform_double(p);
		outbuf_puts(")");
		return;
	}

	if (isinteger(p)) {
		infixform_rational(p);
		return;
	}

	outbuf_puts("(");
	infixform_rational(p);
	outbuf_puts(")");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x5, %eax
jne 0x20cac
leaq 0x246e2(%rip), %rdi     # 0x45372
callq 0x1f060
movq -0x8(%rbp), %rdi
callq 0x20d60
leaq 0x27745(%rip), %rdi     # 0x483ea
callq 0x1f060
jmp 0x20ce6
movq -0x8(%rbp), %rdi
callq 0x9bc0
cmpl $0x0, %eax
je 0x20cc5
movq -0x8(%rbp), %rdi
callq 0x20cf0
jmp 0x20ce6
leaq 0x246a6(%rip), %rdi     # 0x45372
callq 0x1f060
movq -0x8(%rbp), %rdi
callq 0x20cf0
leaq 0x27709(%rip), %rdi     # 0x483ea
callq 0x1f060
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: infixform_rational
void
infixform_rational(struct atom *p)
{
	char *s;

	s = mstr(p->u.q.a);
	outbuf_puts(s);

	s = mstr(p->u.q.b);

	if (strcmp(s, "1") == 0)
		return;

	outbuf_puts("/");

	outbuf_puts(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x8000
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1f060
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8000
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x253bb(%rip), %rsi     # 0x460ec
callq 0x71e0
cmpl $0x0, %eax
jne 0x20d3d
jmp 0x20d52
leaq 0x2463d(%rip), %rdi     # 0x45381
callq 0x1f060
movq -0x10(%rbp), %rdi
callq 0x1f060
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: infixform_double
void
infixform_double(struct atom *p)
{
	char *s;

	snprintf(strbuf, STRBUFLEN, "%g", fabs(p->u.d));

	s = strbuf;

	while (*s && *s != 'E' && *s != 'e')
		outbuf_putc(*s++);

	if (!*s)
		return;

	s++;

	outbuf_puts(" 10^");

	if (*s == '-') {
		outbuf_puts("(-");
		s++;
		while (*s == '0')
			s++; // skip leading zeroes
		outbuf_puts(s);
		outbuf_puts(")");
	} else {
		if (*s == '+')
			s++;
		while (*s == '0')
			s++; // skip leading zeroes
		outbuf_puts(s);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd (%rax), %xmm0
movaps 0x243c5(%rip), %xmm1    # 0x45140
pand %xmm1, %xmm0
leaq 0x10eb8a(%rip), %rdi    # 0x12f910
movl $0x3e8, %esi            # imm = 0x3E8
leaq 0x245f1(%rip), %rdx     # 0x45383
movb $0x1, %al
callq 0x7100
leaq 0x10eb70(%rip), %rax    # 0x12f910
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x20dd6
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x45, %ecx
movb %al, -0x11(%rbp)
je 0x20dd6
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x65, %eax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x20ddf
jmp 0x20df8
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %edi
callq 0x21f60
jmp 0x20da4
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x20e06
jmp 0x20eb0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
leaq 0x2456d(%rip), %rdi     # 0x45386
callq 0x1f060
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x20e73
leaq 0x2455a(%rip), %rdi     # 0x4538b
callq 0x1f060
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x20e5c
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x20e42
movq -0x10(%rbp), %rdi
callq 0x1f060
leaq 0x2757e(%rip), %rdi     # 0x483ea
callq 0x1f060
jmp 0x20eb0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x20e8b
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x20e8d
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0x20ea7
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x20e8d
movq -0x10(%rbp), %rdi
callq 0x1f060
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: get_usrfunc
struct atom *
get_usrfunc(struct atom *p)
{
	if (!isusersymbol(p))
		stopf("symbol error");
	p = usrfunc[p->u.usym.index];
	if (p == NULL)
		p = symbol(NIL);
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x3, %eax
je 0x21845
leaq 0x2870a(%rip), %rdi     # 0x49f4a
callq 0x78d0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %ecx
leaq 0x1086fb(%rip), %rax    # 0x129f50
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2186f
movq 0x3d195(%rip), %rax     # 0x5ea00
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: infixform_arglist
void
infixform_arglist(struct atom *p)
{
	outbuf_puts("(");
	p = cdr(p);
	if (iscons(p)) {
		infixform_expr(car(p));
		p = cdr(p);
		while (iscons(p)) {
			outbuf_puts(",");
			infixform_expr(car(p));
			p = cdr(p);
		}
	}
	outbuf_puts(")");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x23adf(%rip), %rdi     # 0x45372
callq 0x1f060
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x218b3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x218be
movq 0x3d146(%rip), %rax     # 0x5ea00
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x219ac
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x218f1
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x218fc
movq 0x3d108(%rip), %rax     # 0x5ea00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1eea0
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x21920
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2192b
movq 0x3d0d9(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x219aa
leaq 0x23a36(%rip), %rdi     # 0x4537d
callq 0x1f060
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x21966
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x21971
movq 0x3d093(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1eea0
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x21995
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x219a0
movq 0x3d064(%rip), %rax     # 0x5ea00
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x21933
jmp 0x219ac
leaq 0x26a37(%rip), %rdi     # 0x483ea
callq 0x1f060
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: outbuf_putc
void
outbuf_putc(int c)
{
	int m;

	// Let outbuf_index + 1 == 1000

	// Then m == 2000 hence there is always room for the terminator '\0'

	m = 1000 * ((outbuf_index + 1) / 1000 + 1); // m is a multiple of 1000

	if (m > outbuf_length) {
		outbuf = realloc(outbuf, m);
		if (outbuf == NULL)
			exit(1);
		outbuf_length = m;
	}

	outbuf[outbuf_index++] = c;
	outbuf[outbuf_index] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl 0x10d887(%rip), %eax    # 0x12f7f8
addl $0x1, %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
addl $0x1, %eax
imull $0x3e8, %eax, %eax      # imm = 0x3E8
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x10d86b(%rip), %eax    # 0x12f7fc
jle 0x21fc7
movq 0x10d42e(%rip), %rdi    # 0x12f3c8
movslq -0x8(%rbp), %rsi
callq 0x72b0
movq %rax, 0x10d41e(%rip)    # 0x12f3c8
cmpq $0x0, 0x10d416(%rip)    # 0x12f3c8
jne 0x21fbe
movl $0x1, %edi
callq 0x7320
movl -0x8(%rbp), %eax
movl %eax, 0x10d835(%rip)    # 0x12f7fc
movl -0x4(%rbp), %eax
movb %al, %dl
movq 0x10d3f5(%rip), %rax    # 0x12f3c8
movl 0x10d81f(%rip), %ecx    # 0x12f7f8
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x10d814(%rip)    # 0x12f7f8
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq 0x10d3d7(%rip), %rax    # 0x12f3c8
movslq 0x10d800(%rip), %rcx    # 0x12f7f8
movb $0x0, (%rax,%rcx)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: infixform_tensor_nib
void
infixform_tensor_nib(struct atom *p, int d, int k)
{
	int i, n, span;

	if (d == p->u.tensor->ndim) {
		infixform_expr(p->u.tensor->elem[k]);
		return;
	}

	span = 1;

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

	for (i = d + 1; i < n; i++)
		span *= p->u.tensor->dim[i];

	outbuf_puts("(");

	n = p->u.tensor->dim[d];

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

		infixform_tensor_nib(p, d + 1, k);

		if (i < n - 1)
			outbuf_puts(",");

		k += span;
	}

	outbuf_puts(")");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
jne 0x2208a
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq 0x68(%rax,%rcx,8), %rdi
callq 0x1eea0
jmp 0x22147
movl $0x1, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x220cf
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movl 0x4(%rax,%rcx,4), %eax
imull -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x220a6
leaq 0x2329c(%rip), %rdi     # 0x45372
callq 0x1f060
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x2213b
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
movl -0x10(%rbp), %edx
callq 0x22050
movl -0x14(%rbp), %eax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x22127
leaq 0x2325b(%rip), %rdi     # 0x4537d
callq 0x1f060
movl -0x1c(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x220f4
leaq 0x262a8(%rip), %rdi     # 0x483ea
callq 0x1f060
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_inner
void
eval_inner(struct atom *p1)
{
	int h = tos;

	// evaluate from right to left

	p1 = cdr(p1);

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

	if (h == tos)
		stopf("inner: no args");

	evalg();

	while (tos - h > 1) {
		swap();
		evalg();
		swap();
		inner();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl 0x36156(%rip), %eax     # 0x582b8
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x22180
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2218b
movq 0x3c879(%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 0x221fe
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x221ba
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x221c5
movq 0x3c83f(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9110
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x221e9
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x221f4
movq 0x3c810(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x22193
movl -0xc(%rbp), %eax
cmpl 0x360b1(%rip), %eax     # 0x582b8
jne 0x22215
leaq 0x2317e(%rip), %rdi     # 0x4538e
callq 0x78d0
callq 0xa610
movl 0x36098(%rip), %eax     # 0x582b8
subl -0xc(%rbp), %eax
cmpl $0x1, %eax
jle 0x2223e
callq 0xcb10
callq 0xa610
callq 0xcb10
callq 0xb4e0
jmp 0x2221a
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: integral_solve
void
integral_solve(struct atom *F, struct atom *X)
{
	struct atom *p;

	if (car(F) == symbol(INTEGRAL)) {
		integral_of_integral(F, X);
		return;
	}

	if (car(F) == symbol(DERIVATIVE)) {
		integral_of_derivative(F, X);
		return;
	}

	save_symbol(symbol(SA));
	save_symbol(symbol(SB));
	save_symbol(symbol(SX));

	integral_solve_nib(F, X);

	p = pop();
	restore_symbol();
	restore_symbol();
	restore_symbol();
	push(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2284a
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x22855
movq 0x3c1af(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq 0x3b228(%rip), %rax     # 0x5da88
jne 0x22874
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x22910
jmp 0x22907
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2288e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x22899
movq 0x3c16b(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq 0x3a23c(%rip), %rax     # 0x5cae0
jne 0x228b5
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x22dd0
jmp 0x22907
movq 0x3ea14(%rip), %rdi     # 0x612d0
callq 0x12d10
movq 0x3ea10(%rip), %rdi     # 0x612d8
callq 0x12d10
movq 0x3ea0c(%rip), %rdi     # 0x612e0
callq 0x12d10
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x23230
callq 0x91d0
movq %rax, -0x18(%rbp)
callq 0x12d70
callq 0x12d70
callq 0x12d70
movq -0x18(%rbp), %rdi
callq 0x9110
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: integral_solve_nib
void
integral_solve_nib(struct atom *F, struct atom *X)
{
	int h, t;

	set_symbol(symbol(SX), X, symbol(NIL));

	h = tos;

	push_integer(1); // 1 is a candidate for a and b

	push(F);
	push(X);
	decomp(); // push possible substitutions for a and b

	t = integral_classify(F);

	if ((t & 1) && integral_search(h, F, integral_tab_exp, sizeof integral_tab_exp / sizeof (char *)))
		return;

	if ((t & 2) && integral_search(h, F, integral_tab_log, sizeof integral_tab_log / sizeof (char *)))
		return;

	if ((t & 4) && integral_search(h, F, integral_tab_trig, sizeof integral_tab_trig / sizeof (char *)))
		return;

	if (car(F) == symbol(POWER)) {
		if (integral_search(h, F, integral_tab_power, sizeof integral_tab_power / sizeof (char *)))
			return;
	} else {
		if (integral_search(h, F, integral_tab, sizeof integral_tab / sizeof (char *)))
			return;
	}

	tos = h; // pop all

	push_symbol(INTEGRAL);
	push(F);
	push(X);
	list(3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x3e099(%rip), %rdi     # 0x612e0
movq -0x10(%rbp), %rsi
movq 0x3b7ae(%rip), %rdx     # 0x5ea00
callq 0x1df90
movl 0x3505b(%rip), %eax     # 0x582b8
movl %eax, -0x14(%rbp)
movl $0x1, %edi
callq 0xca50
movq -0x8(%rbp), %rdi
callq 0x9110
movq -0x10(%rbp), %rdi
callq 0x9110
callq 0x233c0
movq -0x8(%rbp), %rdi
callq 0x23530
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x232ba
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rsi
leaq 0x2df4a(%rip), %rdx     # 0x511f0
movl $0xab, %ecx
callq 0x23640
cmpl $0x0, %eax
je 0x232ba
jmp 0x233b9
movl -0x18(%rbp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x232e7
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rsi
leaq 0x2e47d(%rip), %rdx     # 0x51750
movl $0x21, %ecx
callq 0x23640
cmpl $0x0, %eax
je 0x232e7
jmp 0x233b9
movl -0x18(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x23314
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rsi
leaq 0x2e560(%rip), %rdx     # 0x51860
movl $0xba, %ecx
callq 0x23640
cmpl $0x0, %eax
je 0x23314
jmp 0x233b9
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2332e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x23339
movq 0x3b6cb(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq 0x3df6c(%rip), %rax     # 0x612b0
jne 0x23367
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rsi
leaq 0x2eadc(%rip), %rdx     # 0x51e30
movl $0x4e, %ecx
callq 0x23640
cmpl $0x0, %eax
je 0x23365
jmp 0x233b9
jmp 0x23388
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rsi
leaq 0x2ed2b(%rip), %rdx     # 0x520a0
movl $0xbd, %ecx
callq 0x23640
cmpl $0x0, %eax
je 0x23386
jmp 0x233b9
jmp 0x23388
movl -0x14(%rbp), %eax
movl %eax, 0x34f27(%rip)     # 0x582b8
movq 0x3a6f0(%rip), %rdi     # 0x5da88
callq 0x9110
movq -0x8(%rbp), %rdi
callq 0x9110
movq -0x10(%rbp), %rdi
callq 0x9110
movl $0x3, %edi
callq 0x90d0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: decomp
void
decomp(void)
{
	struct atom *p1, *F, *X;

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

	// is the entire expression constant?

	if (!dependent(F, X)) {
		push(F);
		return;
	}

	// sum?

	if (car(F) == symbol(ADD)) {
		decomp_sum(F, X);
		return;
	}

	// product?

	if (car(F) == symbol(MULTIPLY)) {
		decomp_product(F, X);
		return;
	}

	// naive decomp

	p1 = cdr(F);
	while (iscons(p1)) {
		push(car(p1));
		push(X);
		decomp();
		p1 = cdr(p1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
callq 0x91d0
movq %rax, -0x18(%rbp)
callq 0x91d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x23860
cmpl $0x0, %eax
jne 0x233fa
movq -0x10(%rbp), %rdi
callq 0x9110
jmp 0x23529
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x23414
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2341f
movq 0x3b5e5(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq 0x3de76(%rip), %rax     # 0x612a0
jne 0x2343e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x23970
jmp 0x23529
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x23458
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x23463
movq 0x3b5a1(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq 0x3de3a(%rip), %rax     # 0x612a8
jne 0x23482
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x23ea0
jmp 0x23529
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2349d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x234a8
movq 0x3b55c(%rip), %rax     # 0x5ea00
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x23529
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x234d7
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x234e2
movq 0x3b522(%rip), %rax     # 0x5ea00
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x9110
movq -0x18(%rbp), %rdi
callq 0x9110
callq 0x233c0
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x23514
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x2351f
movq 0x3b4e5(%rip), %rax     # 0x5ea00
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x234b0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: integral_classify
int
integral_classify(struct atom *p)
{
	int t = 0;

	if (iscons(p)) {
		while (iscons(p)) {
			t |= integral_classify(car(p));
			p = cdr(p);
		}
		return t;
	}

	if (p == symbol(EXP1))
		return 1;

	if (p == symbol(LOG))
		return 2;

	if (p == symbol(SIN) || p == symbol(COS) || p == symbol(TAN))
		return 4;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x235cb
jmp 0x23552
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x235c3
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x23579
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x23584
movq 0x3b480(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x23530
orl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x235ae
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x235b9
movq 0x3b44b(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x23552
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2362e
movq -0x10(%rbp), %rax
cmpq 0x3dcf2(%rip), %rax     # 0x612c8
jne 0x235e1
movl $0x1, -0x4(%rbp)
jmp 0x2362e
movq -0x10(%rbp), %rax
cmpq 0x3ade4(%rip), %rax     # 0x5e3d0
jne 0x235f7
movl $0x2, -0x4(%rbp)
jmp 0x2362e
movq -0x10(%rbp), %rax
cmpq 0x3c3be(%rip), %rax     # 0x5f9c0
je 0x2361e
movq -0x10(%rbp), %rax
cmpq 0x391e1(%rip), %rax     # 0x5c7f0
je 0x2361e
movq -0x10(%rbp), %rax
cmpq 0x3c6b4(%rip), %rax     # 0x5fcd0
jne 0x23627
movl $0x4, -0x4(%rbp)
jmp 0x2362e
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: integral_search
int
integral_search(int h, struct atom *F, char **table, int n)
{
	int i;
	struct atom *C, *I;

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

		scan1(table[i + 0]); // integrand
		I = pop();

		scan1(table[i + 2]); // condition
		C = pop();

		if (integral_search_nib(h, F, I, C))
			break;
	}

	if (i >= n)
		return 0;

	tos = h; // pop all

	scan1(table[i + 1]); // answer
	evalf();

	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x236cb
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x0, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x23710
callq 0x91d0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x23710
callq 0x91d0
movq %rax, -0x28(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x23740
cmpl $0x0, %eax
je 0x236be
jmp 0x236cb
jmp 0x236c0
movl -0x20(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x20(%rbp)
jmp 0x2365d
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jl 0x236dc
movl $0x0, -0x4(%rbp)
jmp 0x23707
movl -0x8(%rbp), %eax
movl %eax, 0x34bd3(%rip)     # 0x582b8
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
callq 0x23710
callq 0xa660
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: integral_search_nib
int
integral_search_nib(int h, struct atom *F, struct atom *I, struct atom *C)
{
	int i, j;
	struct atom *p1;

	for (i = h; i < tos; i++) {

		set_symbol(symbol(SA), stack[i], symbol(NIL));

		for (j = h; j < tos; j++) {

			set_symbol(symbol(SB), stack[j], symbol(NIL));

			push(C);			// condition ok?
			evalf();
			p1 = pop();
			if (iszero(p1))
				continue;		// no, go to next j

			push(F);			// F = I?
			push(I);
			evalf();
			subtract();
			p1 = pop();
			if (iszero(p1))
				return 1;		// yes
		}
	}

	return 0;					// no
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl 0x34b52(%rip), %eax     # 0x582b8
jge 0x23848
movq 0x3db5d(%rip), %rdi     # 0x612d0
movslq -0x24(%rbp), %rcx
leaq 0x3de42(%rip), %rax     # 0x615c0
movq (%rax,%rcx,8), %rsi
movq 0x3b277(%rip), %rdx     # 0x5ea00
callq 0x1df90
movl -0x8(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl 0x34b1b(%rip), %eax     # 0x582b8
jge 0x23838
movq 0x3db2e(%rip), %rdi     # 0x612d8
movslq -0x28(%rbp), %rcx
leaq 0x3de0b(%rip), %rax     # 0x615c0
movq (%rax,%rcx,8), %rsi
movq 0x3b240(%rip), %rdx     # 0x5ea00
callq 0x1df90
movq -0x20(%rbp), %rdi
callq 0x9110
callq 0xa660
callq 0x91d0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xcdc0
cmpl $0x0, %eax
je 0x237ec
jmp 0x2382a
movq -0x10(%rbp), %rdi
callq 0x9110
movq -0x18(%rbp), %rdi
callq 0x9110
callq 0xa660
callq 0xe7e0
callq 0x91d0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xcdc0
cmpl $0x0, %eax
je 0x23828
movl $0x1, -0x4(%rbp)
jmp 0x2384f
jmp 0x2382a
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x23794
jmp 0x2383a
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2375d
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: dependent
int
dependent(struct atom *f, struct atom *x)
{
	if (equal(f, x))
		return 1;

	// a user function with no arguments?

	if (isusersymbol(car(f)) && lengthf(f) == 1)
		return 1;

	while (iscons(f)) {
		if (dependent(car(f), x))
			return 1;
		f = cdr(f);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x93b0
cmpl $0x0, %eax
jne 0x2388e
movl $0x1, -0x4(%rbp)
jmp 0x23960
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x238a8
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x238b3
movq 0x3b151(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x3, %eax
jne 0x238da
movq -0x10(%rbp), %rdi
callq 0x9220
cmpl $0x1, %eax
jne 0x238da
movl $0x1, -0x4(%rbp)
jmp 0x23960
jmp 0x238dc
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x23959
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x23903
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x2390e
movq 0x3b0f6(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x23860
cmpl $0x0, %eax
je 0x23929
movl $0x1, -0x4(%rbp)
jmp 0x23960
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x23944
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x2394f
movq 0x3b0b5(%rip), %rax     # 0x5ea00
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x238dc
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: inv
void
inv(void)
{
	struct atom *p1;

	p1 = pop();

	if (!istensor(p1)) {
		push(p1);
		reciprocate();
		return;
	}

	if (!issquarematrix(p1))
		stopf("inv: square matrix expected");

	push(p1);
	adj();

	push(p1);
	det();

	divide();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x91d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x7, %eax
je 0x2417e
movq -0x8(%rbp), %rdi
callq 0x9110
callq 0xc3b0
jmp 0x241b9
movq -0x8(%rbp), %rdi
callq 0xeac0
cmpl $0x0, %eax
jne 0x24198
leaq 0x25680(%rip), %rdi     # 0x49813
callq 0x78d0
movq -0x8(%rbp), %rdi
callq 0x9110
callq 0xe890
movq -0x8(%rbp), %rdi
callq 0x9110
callq 0xeb10
callq 0x117a0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: eval_kronecker
void
eval_kronecker(struct atom *p1)
{
	push(cadr(p1));
	evalf();
	p1 = cddr(p1);
	while (iscons(p1)) {
		push(car(p1));
		evalf();
		kronecker();
		p1 = cdr(p1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x241e7
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x241f2
movq 0x3a812(%rip), %rax     # 0x5ea00
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x24232
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2421a
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x24225
movq 0x3a7df(%rip), %rax     # 0x5ea00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2423d
movq 0x3a7c7(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9110
callq 0xa660
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x24266
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x24271
movq 0x3a793(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x242b2
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x24299
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x242a4
movq 0x3a760(%rip), %rax     # 0x5ea00
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x242bd
movq 0x3a747(%rip), %rax     # 0x5ea00
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x2433a
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x242ec
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x242f7
movq 0x3a70d(%rip), %rax     # 0x5ea00
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x9110
callq 0xa660
callq 0x24340
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x24325
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x24330
movq 0x3a6d4(%rip), %rax     # 0x5ea00
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x242c5
addq $0x50, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: lgammafunc
void
lgammafunc(void)
{
	int i, n;
	double d;
	struct atom *p1, *p2;

	p1 = pop();

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

	push(p1);
	floatfunc();
	p2 = pop();

	if (isnum(p2)) {
		push(p2);
		d = pop_double();
		d = lgamma(d);
		push_double(d);
		return;
	}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
callq 0x91d0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x7, %eax
jne 0x246bf
movq -0x18(%rbp), %rdi
callq 0xa550
movq %rax, -0x18(%rbp)
movq -0x18(%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 0x246b4
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x4(%rbp), %rcx
movq 0x68(%rax,%rcx,8), %rdi
callq 0x9110
callq 0x24630
callq 0x91d0
movq %rax, %rdx
movq -0x18(%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 0x2466f
movq -0x18(%rbp), %rdi
callq 0x9110
jmp 0x2473d
movq -0x18(%rbp), %rdi
callq 0x9110
callq 0xc290
callq 0x91d0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x4, %eax
je 0x246f0
movq -0x20(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x5, %eax
jne 0x2471e
movq -0x20(%rbp), %rdi
callq 0x9110
callq 0x9af0
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x7200
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0xe5e0
jmp 0x2473d
movq 0x39ca3(%rip), %rdi     # 0x5e3c8
callq 0x9110
movq -0x18(%rbp), %rdi
callq 0x9110
movl $0x2, %edi
callq 0x90d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)