LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_vector
void
fmt_vector(struct atom *p)
{
	int i, n, span;

	// compute element span

	span = 1;

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

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

	n = p->u.tensor->dim[0]; // number of rows

	for (i = 0; i < n; i++)
		fmt_matrix(p, 1, i * span);

	fmt_update_table(n, 1); // n rows, 1 column
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movslq (%rax), %rcx
pushq $0x1
popq %r13
pushq $0x1
popq %rdx
cmpq %rcx, %rdx
jge 0x20557
imull 0x4(%rax,%rdx,4), %r13d
incq %rdx
jmp 0x20547
movl 0x4(%rax), %eax
xorl %r15d, %r15d
testl %eax, %eax
movl $0x0, %r14d
movl %eax, -0x2c(%rbp)
cmovgl %eax, %r14d
pushq $0x1
popq %r12
subl $0x1, %r14d
jb 0x20589
movq %rbx, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0x1fa26
addl %r13d, %r15d
jmp 0x20570
pushq $0x1
popq %rsi
movl -0x2c(%rbp), %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1fafd
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_term_nib
void
fmt_term_nib(struct atom *p)
{
	if (find_denominator(p)) {
		fmt_frac(p);
		return;
	}

	// no denominators

	p = cdr(p);

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

	fmt_factor(car(p));

	p = cdr(p);

	while (iscons(p)) {
		fmt_space();
		fmt_factor(car(p));
		p = cdr(p);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8b7d
testl %eax, %eax
je 0x205ca
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1f5fa
cmpb $0x1, 0x10(%rbx)
leaq 0x8(%rbx), %rax
leaq 0x1e417(%rip), %rbx     # 0x3e9f0
cmovneq %rbx, %rax
movq (%rax), %r14
movb 0x10(%r14), %r15b
cmpb $0x1, %r15b
movq %rbx, %rax
cmoveq %r14, %rax
movq (%rax), %rdi
callq 0xbfac
testl %eax, %eax
je 0x2060e
addq $0x8, %r14
cmpb $0x1, %r15b
cmovneq %rbx, %r14
movq (%r14), %r14
movb 0x10(%r14), %r15b
cmpb $0x1, %r15b
movq %rbx, %rax
cmoveq %r14, %rax
movq (%rax), %rdi
callq 0x1eaac
leaq 0x8(%r14), %rax
cmpb $0x1, 0x10(%r14)
cmovneq %rbx, %rax
movq (%rax), %r14
cmpb $0x1, 0x10(%r14)
jne 0x2063f
callq 0x1ea54
jmp 0x2060a
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_draw_delims
void
fmt_draw_delims(int x, int y, int h, int d, int w)
{
	if (h > 1 || d > 0) {
		fmt_draw_ldelim(x, y, h, d);
		fmt_draw_rdelim(x + w - 1, y, h, d);
	} else {
		fmt_draw_char(x, y, '(');
		fmt_draw_char(x + w - 1, y, ')');
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r14d
movl %esi, %ebx
cmpl $0x2, %edx
setl %al
testl %ecx, %ecx
setle %cl
leal (%rdi,%r8), %r12d
decl %r12d
testb %cl, %al
jne 0x206c4
movl %edx, %r15d
movl %ebx, %esi
movl %r14d, %ecx
callq 0x20a7b
movl %r12d, %edi
movl %ebx, %esi
movl %r15d, %edx
movl %r14d, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x20af4
pushq $0x28
popq %rdx
movl %ebx, %esi
callq 0x2064a
pushq $0x29
popq %rdx
movl %r12d, %edi
movl %ebx, %esi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2064a
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_draw_ldelim
void
fmt_draw_ldelim(int x, int y, int h, int d)
{
	int i;

	fmt_draw_char(x, y - h + 1, BDLDAR);

	for (i = 1; i < h + d - 1; i++)
		fmt_draw_char(x, y - h + 1 + i, BDLV);

	fmt_draw_char(x, y + d, BDLUAR);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %r13d
movl %edi, %r14d
movl %esi, -0x2c(%rbp)
movl %esi, %r12d
subl %edx, %r12d
leal 0x1(%r12), %esi
movl $0xe2948c, %edx         # imm = 0xE2948C
callq 0x2064a
addl %ebx, %r13d
decl %r13d
addl $0x2, %r12d
pushq $0x1
popq %r15
cmpl %r13d, %r15d
jge 0x20ad4
movl %r14d, %edi
movl %r12d, %esi
movl $0xe29482, %edx         # imm = 0xE29482
callq 0x2064a
incl %r15d
incl %r12d
jmp 0x20ab7
addl -0x2c(%rbp), %ebx
movl %r14d, %edi
movl %ebx, %esi
movl $0xe29494, %edx         # imm = 0xE29494
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2064a
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_draw_rdelim
void
fmt_draw_rdelim(int x, int y, int h, int d)
{
	int i;

	fmt_draw_char(x, y - h + 1, BDLDAL);

	for (i = 1; i < h + d - 1; i++)
		fmt_draw_char(x, y - h + 1 + i, BDLV);

	fmt_draw_char(x, y + d, BDLUAL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %r13d
movl %edi, %r14d
movl %esi, -0x2c(%rbp)
movl %esi, %r12d
subl %edx, %r12d
leal 0x1(%r12), %esi
movl $0xe29490, %edx         # imm = 0xE29490
callq 0x2064a
addl %ebx, %r13d
decl %r13d
addl $0x2, %r12d
pushq $0x1
popq %r15
cmpl %r13d, %r15d
jge 0x20b4d
movl %r14d, %edi
movl %r12d, %esi
movl $0xe29482, %edx         # imm = 0xE29482
callq 0x2064a
incl %r15d
incl %r12d
jmp 0x20b30
addl -0x2c(%rbp), %ebx
movl %r14d, %edi
movl %ebx, %esi
movl $0xe29498, %edx         # imm = 0xE29498
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2064a
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: untag
void
untag(struct atom *p)
{
	int i;

	if (p == NULL)
		return;

	while (iscons(p)) {
		if (p->tag == 0)
			return;
		p->tag = 0;
		untag(p->u.cons.car);
		p = p->u.cons.cdr;
	}

	if (p->tag == 0)
		return;

	p->tag = 0;

	if (istensor(p))
		for (i = 0; i < p->u.tensor->nelem; i++)
			untag(p->u.tensor->elem[i]);
}

// Assembly:
testq %rdi, %rdi
je 0x20bca
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb 0x10(%rbx), %al
movb 0x11(%rbx), %cl
cmpb $0x1, %al
jne 0x20b9c
testb %cl, %cl
je 0x20bc6
movb $0x0, 0x11(%rbx)
movq (%rbx), %rdi
callq 0x20b6d
movq 0x8(%rbx), %rbx
jmp 0x20b7c
testb %cl, %cl
je 0x20bc6
movb $0x0, 0x11(%rbx)
cmpb $0x7, %al
jne 0x20bc6
xorl %r14d, %r14d
movq (%rbx), %rax
movslq 0x64(%rax), %rcx
cmpq %rcx, %r14
jge 0x20bc6
movq 0x68(%rax,%r14,8), %rdi
callq 0x20b6d
incq %r14
jmp 0x20bab
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: main
int
main(int argc, char *argv[])
{
	int i;
	for (i = 1; i < argc; i++)
		run_infile(argv[i]);
	if (isatty(fileno(stdout)))
		run_stdin();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq %edi, %r14
pushq $0x1
popq %r15
cmpq %r14, %r15
jge 0x20bf2
movq (%rbx,%r15,8), %rdi
callq 0x20c1e
incq %r15
jmp 0x20bdf
movq 0x103d7(%rip), %rax     # 0x30fd0
movq (%rax), %rdi
callq 0x7230
movl %eax, %edi
callq 0x70b0
testl %eax, %eax
jne 0x20c19
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x20c6c
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: run_infile
void
run_infile(char *infile)
{
	char *buf;
	buf = read_file(infile);
	if (buf == NULL) {
		fprintf(stderr, "cannot read %s\n", infile);
		exit(1);
	}
	run(buf);
	free(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x1b01a
testq %rax, %rax
je 0x20c49
movq %rax, %r14
movq %rax, %rdi
callq 0x20cc1
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7040
movq 0x103a8(%rip), %rax     # 0x30ff8
movq (%rax), %rdi
leaq 0x70b1(%rip), %rsi      # 0x27d0b
movq %rbx, %rdx
xorl %eax, %eax
callq 0x71f0
pushq $0x1
popq %rdi
callq 0x7320
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: run_stdin
void
run_stdin(void)
{
	static char inbuf[1000];
	for (;;) {
		fputs("? ", stdout);
		fflush(stdout);
		fgets(inbuf, sizeof inbuf, stdin);
		run(inbuf);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x10352(%rip), %r15     # 0x30fd0
leaq 0x276f(%rip), %rbx      # 0x233f4
movq 0x1034c(%rip), %r12     # 0x30fd8
leaq 0xee76d(%rip), %r14     # 0x10f400
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x7120
movq (%r15), %rdi
callq 0x7270
movq (%r12), %rdx
movq %r14, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x71b0
movq %r14, %rdi
callq 0x20cc1
jmp 0x20c93
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: run
void
run(char *buf)
{
	if (setjmp(jmpbuf))
		return;

	tos = 0;
	interrupt = 0;
	eval_level = 0;
	gc_level = 0;
	expanding = 1;
	drawing = 0;
	shuntflag = 0;
	errorflag = 0;
	breakflag = 0;

	if (zero == NULL) {
		srand((unsigned) time(NULL));
		init_symbol_table();
		push_bignum(MPLUS, mint(0), mint(1));
		zero = pop();
		push_bignum(MPLUS, mint(1), mint(1));
		one = pop();
		push_bignum(MMINUS, mint(1), mint(1));
		minusone = pop();
		push_symbol(POWER);
		push_integer(-1);
		push_rational(1, 2);
		list(3);
		imaginaryunit = pop();
		run_init_script();
	}

	run_buf(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0xeeb1a(%rip), %rdi     # 0x10f7f0
callq 0x71c0
testl %eax, %eax
jne 0x20e15
andl $0x0, 0x175be(%rip)     # 0x382a8
andl $0x0, 0xe3dc7(%rip)     # 0x104ab8
andl $0x0, 0xe3dbc(%rip)     # 0x104ab4
andl $0x0, 0xe3db1(%rip)     # 0x104ab0
andl $0x0, 0xeebb2(%rip)     # 0x10f8b8
andl $0x0, 0xee6a7(%rip)     # 0x10f3b4
andl $0x0, 0xee69c(%rip)     # 0x10f3b0
andl $0x0, 0xe3dbd(%rip)     # 0x104ad8
movl $0x1, 0xe3d9b(%rip)     # 0x104ac0
cmpq $0x0, 0x1b403(%rip)     # 0x3c130
jne 0x20e0d
xorl %r15d, %r15d
movl %r15d, %edi
callq 0x7220
movl %eax, %edi
callq 0x71a0
callq 0x2126d
movl %r15d, %edi
callq 0x7a09
movq %rax, %r12
pushq $0x1
popq %r14
movl %r14d, %edi
callq 0x7a09
movl %r15d, %edi
movq %r12, %rsi
movq %rax, %rdx
callq 0xb015
callq 0x868d
movq %rax, 0x1b3b5(%rip)     # 0x3c130
movl %r14d, %edi
callq 0x7a09
movq %rax, %r12
movl %r14d, %edi
callq 0x7a09
movl %r15d, %edi
movq %r12, %rsi
movq %rax, %rdx
callq 0xb015
callq 0x868d
movq %rax, 0xe3d20(%rip)     # 0x104ac8
movl %r14d, %edi
callq 0x7a09
movq %rax, %r15
movl %r14d, %edi
callq 0x7a09
movl %r14d, %edi
movq %r15, %rsi
movq %rax, %rdx
callq 0xb015
callq 0x868d
movq %rax, 0xee60b(%rip)     # 0x10f3e0
movq 0x204c4(%rip), %rdi     # 0x412a0
callq 0x861b
pushq $-0x1
popq %rdi
callq 0xa426
pushq $0x2
popq %rsi
movl %r14d, %edi
callq 0x9a47
pushq $0x3
popq %rdi
callq 0x85eb
callq 0x868d
movq %rax, 0xe3cc8(%rip)     # 0x104ad0
callq 0xd673
movq %rbx, %rdi
callq 0x1b0b0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: numden_find_divisor
int
numden_find_divisor(struct atom *p)
{
	if (car(p) == symbol(ADD)) {
		p = cdr(p);
		while (iscons(p)) {
			if (numden_find_divisor_term(car(p)))
				return 1;
			p = cdr(p);
		}
		return 0;
	}

	return numden_find_divisor_term(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x10(%rdi)
leaq 0x1db9e(%rip), %r15     # 0x3e9f0
movq %r15, %rcx
cmoveq %rdi, %rcx
sete %al
movq (%rcx), %rcx
cmpq 0x2042a(%rip), %rcx     # 0x41290
je 0x20e7a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20f69
pushq $0x1
popq %r14
addq $0x8, %rbx
testb $0x1, %al
cmoveq %r15, %rbx
movq (%rbx), %rbx
cmpb $0x1, 0x10(%rbx)
jne 0x20ea6
movq (%rbx), %rdi
callq 0x20f69
testl %eax, %eax
jne 0x20ea9
cmpb $0x1, 0x10(%rbx)
sete %al
jmp 0x20e7e
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: numden_cancel_factor
void
numden_cancel_factor(void)
{
	int h;
	struct atom *p1, *p2;

	p2 = pop(); // numerator
	p1 = pop(); // divisor

	// multiply term by term to ensure divisor is not distributed

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

	push(p1);
	push(p2);
	multiply();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
callq 0x868d
movq %rax, %rbx
callq 0x868d
movq %rax, %r14
cmpb $0x1, 0x10(%rbx)
leaq 0x1db13(%rip), %r15     # 0x3e9f0
movq %rbx, %rcx
cmovneq %r15, %rcx
sete %al
movq (%rcx), %rcx
cmpq 0x2039f(%rip), %rcx     # 0x41290
je 0x20f10
movq %r14, %rdi
callq 0x861b
movq %rbx, %rdi
callq 0x861b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x9fae
movl 0x17391(%rip), %r12d    # 0x382a8
addq $0x8, %rbx
testb $0x1, %al
cmoveq %r15, %rbx
movq (%rbx), %rbx
cmpb $0x1, 0x10(%rbx)
jne 0x20f53
movq %r14, %rdi
callq 0x861b
cmpb $0x1, 0x10(%rbx)
movq %r15, %rax
cmoveq %rbx, %rax
movq (%rax), %rdi
callq 0x861b
callq 0x9fae
cmpb $0x1, 0x10(%rbx)
sete %al
jmp 0x20f17
movl 0x1734f(%rip), %edi     # 0x382a8
subl %r12d, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa0fd
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: numden_find_divisor_term
int
numden_find_divisor_term(struct atom *p)
{
	if (car(p) == symbol(MULTIPLY)) {
		p = cdr(p);
		while (iscons(p)) {
			if (numden_find_divisor_factor(car(p)))
				return 1;
			p = cdr(p);
		}
		return 0;
	}

	return numden_find_divisor_factor(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x10(%rdi)
leaq 0x1da6f(%rip), %r15     # 0x3e9f0
movq %r15, %rcx
cmoveq %rdi, %rcx
sete %al
movq (%rcx), %rcx
cmpq 0x20303(%rip), %rcx     # 0x41298
je 0x20fa9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20fe6
pushq $0x1
popq %r14
addq $0x8, %rbx
testb $0x1, %al
cmoveq %r15, %rbx
movq (%rbx), %rbx
cmpb $0x1, 0x10(%rbx)
jne 0x20fd5
movq (%rbx), %rdi
callq 0x20fe6
testl %eax, %eax
jne 0x20fd8
cmpb $0x1, 0x10(%rbx)
sete %al
jmp 0x20fad
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: numden_find_divisor_factor
int
numden_find_divisor_factor(struct atom *p)
{
	if (isrational(p) && !isinteger(p)) {
		push_bignum(MPLUS, mcopy(p->u.q.b), mint(1));
		return 1;
	}

	if (car(p) == symbol(POWER) && isnegativeterm(caddr(p))) {
		if (isminusone(caddr(p)))
			push(cadr(p));
		else {
			push_symbol(POWER);
			push(cadr(p));
			push(caddr(p));
			negate();
			list(3);
		}
		return 1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x10(%rdi), %r12b
cmpb $0x4, %r12b
jne 0x2100d
movq %rbx, %rdi
callq 0x8b5d
testl %eax, %eax
je 0x21058
cmpb $0x1, %r12b
leaq 0x1d9d8(%rip), %rax     # 0x3e9f0
movq %rax, %rcx
cmoveq %rbx, %rcx
movq 0x2027a(%rip), %r14     # 0x412a0
xorl %r15d, %r15d
cmpq %r14, (%rcx)
jne 0x21158
leaq 0x8(%rbx), %rdx
cmpb $0x1, %r12b
movq %rax, %rcx
movq %rdx, -0x30(%rbp)
cmoveq %rdx, %rcx
movq (%rcx), %r13
movb 0x10(%r13), %r12b
cmpb $0x1, %r12b
jne 0x21082
movq 0x8(%r13), %rcx
jmp 0x21089
movq 0x8(%rbx), %rdi
callq 0x7c9c
movq %rax, %rbx
pushq $0x1
popq %r15
movl %r15d, %edi
callq 0x7a09
xorl %edi, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xb015
jmp 0x21158
movq 0x1d967(%rip), %rcx     # 0x3e9f0
cmpb $0x1, 0x10(%rcx)
jne 0x21092
movq %rcx, %rax
movq (%rax), %rdi
callq 0x9fd6
testl %eax, %eax
je 0x21158
cmpb $0x1, %r12b
jne 0x210ae
movq 0x8(%r13), %rax
jmp 0x210b5
movq 0x1d93b(%rip), %rax     # 0x3e9f0
cmpb $0x1, 0x10(%rax)
je 0x210c2
leaq 0x1d92e(%rip), %rax     # 0x3e9f0
movq (%rax), %rdi
callq 0xbfac
testl %eax, %eax
je 0x210e7
cmpb $0x1, %r12b
leaq 0x1d917(%rip), %rax     # 0x3e9f0
cmoveq %r13, %rax
movq (%rax), %rdi
callq 0x861b
jmp 0x21154
movq %r14, %rdi
callq 0x861b
cmpb $0x1, 0x10(%rbx)
leaq 0x1d8f6(%rip), %r14     # 0x3e9f0
movq %r14, %rax
movq -0x30(%rbp), %r15
cmoveq %r15, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rax
movq (%rax), %rdi
callq 0x861b
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %r15
movq (%r15), %rax
cmpb $0x1, 0x10(%rax)
jne 0x2112f
movq 0x8(%rax), %rax
jmp 0x21136
movq 0x1d8ba(%rip), %rax     # 0x3e9f0
cmpb $0x1, 0x10(%rax)
jne 0x2113f
movq %rax, %r14
movq (%r14), %rdi
callq 0x861b
callq 0x975f
pushq $0x3
popq %rdi
callq 0x85eb
pushq $0x1
popq %r15
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: init_symbol_table
void
init_symbol_table(void)
{
	int i, n;
	char *s;
	struct atom *p;

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

	n = sizeof stab / sizeof (struct se);

	for (i = 0; i < n; i++) {
		p = alloc_atom();
		s = strdup(stab[i].str);
		if (s == NULL)
			exit(1);
		if (stab[i].func) {
			p->atomtype = KSYM;
			p->u.ksym.name = s;
			p->u.ksym.func = stab[i].func;
			ksym_count++;
		} else {
			p->atomtype = USYM;
			p->u.usym.name = s;
			p->u.usym.index = stab[i].index;
			usym_count++;
		}
		symtab[stab[i].index] = p;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %eax, %eax
leaq 0x1aecf(%rip), %r14     # 0x3c150
leaq 0xe3858(%rip), %rcx     # 0x104ae0
leaq 0xe8cb1(%rip), %rdx     # 0x109f40
cmpq $0x5460, %rax           # imm = 0x5460
je 0x212ac
andq $0x0, (%rax,%r14)
andq $0x0, (%rax,%rcx)
andq $0x0, (%rax,%rdx)
addq $0x8, %rax
jmp 0x2128f
pushq $0x10
popq %r15
leaq 0x16109(%rip), %r12     # 0x373c0
cmpq $0xec8, %r15            # imm = 0xEC8
je 0x21317
callq 0x749c
movq %rax, %rbx
movq -0x10(%r15,%r12), %rdi
callq 0x7340
testq %rax, %rax
je 0x21320
cmpq $0x0, (%r15,%r12)
movq %rax, (%rbx)
je 0x212f8
movq (%r15,%r12), %rax
movq %rax, 0x8(%rbx)
incl 0xee0e5(%rip)           # 0x10f3d4
movl -0x8(%r15,%r12), %eax
movb $0x2, %cl
jmp 0x21308
movl -0x8(%r15,%r12), %eax
movl %eax, 0x8(%rbx)
incl 0xee0d2(%rip)           # 0x10f3d8
movb $0x3, %cl
movb %cl, 0x10(%rbx)
cltq
movq %rbx, (%r14,%rax,8)
addq $0x18, %r15
jmp 0x212b7
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rdi
callq 0x7320
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: scan_input
char *
scan_input(char *s)
{
	struct atom *p1;
	trace1 = s;
	s = scan(s);
	trace2 = s;
	p1 = get_binding(symbol(TRACE));
	if (p1 != symbol(TRACE) && !iszero(p1))
		print_trace(BLUE);
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, 0xee58b(%rip)     # 0x10f8c0
callq 0x21374
movq %rax, %rbx
movq %rax, 0xee584(%rip)     # 0x10f8c8
movq 0x1e9c5(%rip), %rdi     # 0x3fd10
callq 0xd3b4
cmpq 0x1e9b9(%rip), %rax     # 0x3fd10
je 0x2136a
movq %rax, %rdi
callq 0xa641
testl %eax, %eax
jne 0x2136a
callq 0x21385
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: print_trace
void
print_trace(int color)
{
	char c, *s;
	if (trace1 == NULL || trace2 == NULL)
		return;
	outbuf_init();
	c = '\n';
	s = trace1;
	while (*s && s < trace2) {
		c = *s++;
		outbuf_putc(c);
	}
	if (c != '\n')
		outbuf_putc('\n');
	printbuf(outbuf, color);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpq $0x0, 0xee52c(%rip)     # 0x10f8c0
je 0x213cd
cmpq $0x0, 0xee52a(%rip)     # 0x10f8c8
je 0x213cd
callq 0x12e54
movb $0xa, %al
movq 0xee512(%rip), %r14     # 0x10f8c0
movsbl (%r14), %ebx
testl %ebx, %ebx
je 0x213d2
cmpq 0xee50b(%rip), %r14     # 0x10f8c8
jae 0x213d2
incq %r14
movl %ebx, %edi
callq 0x13ea9
movl %ebx, %eax
jmp 0x213ae
popq %rbx
popq %r14
popq %rbp
retq
cmpb $0xa, %al
je 0x213de
pushq $0xa
popq %rdi
callq 0x13ea9
movq 0xedfd3(%rip), %rdi     # 0x10f3b8
popq %rbx
popq %r14
popq %rbp
jmp 0x13012
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: scan_nib
char *
scan_nib(char *s)
{
	scan_str = s;
	scan_level = 0;
	get_token_skip_newlines();
	if (token == T_END)
		return NULL;
	scan_stmt();
	if (token != T_NEWLINE && token != T_END)
		scan_error("syntax err"); // unexpected token, for example, 1:2
	return scan_str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, 0xee4df(%rip)     # 0x10f8d8
andl $0x0, 0xee4e0(%rip)     # 0x10f8e0
callq 0x21443
cmpl $0x3f3, 0xee4d5(%rip)   # imm = 0x3F3
jne 0x21415
xorl %eax, %eax
jmp 0x21435
callq 0x2145a
movl 0xee4c4(%rip), %eax     # 0x10f8e4
cmpl $0x3ee, %eax            # imm = 0x3EE
je 0x2142e
cmpl $0x3f3, %eax            # imm = 0x3F3
jne 0x21437
movq 0xee4a3(%rip), %rax     # 0x10f8d8
popq %rbp
retq
leaq 0x6af0(%rip), %rdi      # 0x27f2e
callq 0x21492
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: scan_stmt
void
scan_stmt(void)
{
	scan_comparison();
	if (token == '=') {
		get_token_skip_newlines(); // get token after '='
		push_symbol(SETQ);
		swap();
		scan_comparison();
		list(3);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x214a9
cmpl $0x3d, 0xee47a(%rip)    # 0x10f8e4
jne 0x21490
callq 0x21443
movq 0x1fe38(%rip), %rdi     # 0x412b0
callq 0x861b
callq 0xa49b
callq 0x214a9
pushq $0x3
popq %rdi
popq %rbp
jmp 0x85eb
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: scan_comparison
void
scan_comparison(void)
{
	scan_expression();
	switch (token) {
	case T_EQ:
		push_symbol(TESTEQ); // ==
		break;
	case T_LTEQ:
		push_symbol(TESTLE);
		break;
	case T_GTEQ:
		push_symbol(TESTGE);
		break;
	case '<':
		push_symbol(TESTLT);
		break;
	case '>':
		push_symbol(TESTGT);
		break;
	default:
		return;
	}
	swap();
	get_token_skip_newlines(); // get token after rel op
	scan_expression();
	list(3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x21524
movl 0xee42c(%rip), %eax     # 0x10f8e4
cmpl $0x3c, %eax
je 0x214fd
cmpl $0x3e, %eax
je 0x214e0
cmpl $0x3f0, %eax            # imm = 0x3F0
je 0x214f2
cmpl $0x3f2, %eax            # imm = 0x3F2
je 0x214e9
cmpl $0x3f1, %eax            # imm = 0x3F1
jne 0x214fb
leaq 0x1e81a(%rip), %rax     # 0x3fcf8
jmp 0x21504
leaq 0x1e809(%rip), %rax     # 0x3fcf0
jmp 0x21504
leaq 0x1e7f0(%rip), %rax     # 0x3fce0
jmp 0x21504
leaq 0x1e7ef(%rip), %rax     # 0x3fce8
jmp 0x21504
popq %rbp
retq
leaq 0x1e7fc(%rip), %rax     # 0x3fd00
movq (%rax), %rdi
callq 0x861b
callq 0xa49b
callq 0x21443
callq 0x21524
pushq $0x3
popq %rdi
popq %rbp
jmp 0x85eb
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: scan_expression
void
scan_expression(void)
{
	int h = tos, t;
	t = token;
	if (token == '+' || token == '-')
		get_token_skip_newlines();
	scan_term();
	if (t == '-')
		static_negate();
	while (token == '+' || token == '-') {
		t = token;
		get_token_skip_newlines(); // get token after '+' or '-'
		scan_term();
		if (t == '-')
			static_negate();
	}
	if (tos - h > 1) {
		list(tos - h);
		push_symbol(ADD);
		swap();
		cons(); // prepend ADD to list
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl 0x16d77(%rip), %ebx     # 0x382a8
movl 0xee3ac(%rip), %r14d    # 0x10f8e4
cmpl $0x2d, %r14d
je 0x21544
cmpl $0x2b, %r14d
jne 0x21549
callq 0x21443
callq 0x2159f
cmpl $0x2d, %r14d
je 0x21593
movl 0xee389(%rip), %r14d    # 0x10f8e4
cmpl $0x2d, %r14d
je 0x21544
cmpl $0x2b, %r14d
je 0x21544
movl 0x16d3b(%rip), %edi     # 0x382a8
subl %ebx, %edi
cmpl $0x2, %edi
jl 0x2159a
callq 0x85eb
movq 0x1fd10(%rip), %rdi     # 0x41290
callq 0x861b
callq 0xa49b
popq %rbx
popq %r14
popq %rbp
jmp 0x865c
callq 0x21615
jmp 0x21554
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: scan_term
void
scan_term(void)
{
	int h = tos, t;

	scan_power();

	while (another_factor_pending()) {

		t = token;

		if (token == '*' || token == '/')
			get_token_skip_newlines();

		scan_power();

		if (t == '/')
			static_reciprocate();
	}

	if (tos - h > 1) {
		list(tos - h);
		push_symbol(MULTIPLY);
		swap();
		cons(); // prepend MULTIPLY to list
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl 0x16cfc(%rip), %ebx     # 0x382a8
callq 0x2176d
callq 0x2172e
testl %eax, %eax
je 0x215e4
movl 0xee323(%rip), %r14d    # 0x10f8e4
cmpl $0x2f, %r14d
je 0x215cd
cmpl $0x2a, %r14d
jne 0x215d2
callq 0x21443
callq 0x2176d
cmpl $0x2f, %r14d
jne 0x215b1
callq 0x217a5
jmp 0x215b1
movl 0x16cbe(%rip), %edi     # 0x382a8
subl %ebx, %edi
cmpl $0x2, %edi
jl 0x21610
callq 0x85eb
movq 0x1fc9b(%rip), %rdi     # 0x41298
callq 0x861b
callq 0xa49b
popq %rbx
popq %r14
popq %rbp
jmp 0x865c
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: static_negate
void
static_negate(void)
{
	struct atom *p1;

	p1 = pop();

	if (isnum(p1)) {
		push(p1);
		negate();
		return;
	}

	if (car(p1) == symbol(MULTIPLY)) {
		push_symbol(MULTIPLY);
		if (isnum(cadr(p1))) {
			push(cadr(p1)); // A
			negate();
			push(cddr(p1)); // B
		} else {
			push_integer(-1); // A
			push(cdr(p1)); // B
		}
		cons(); // prepend A to B
		cons(); // prepend MULTIPLY
		return;
	}

	push_symbol(MULTIPLY);
	push_integer(-1);
	push(p1);
	list(3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
callq 0x868d
movq %rax, %r14
movq %rax, %rbx
movzbl 0x10(%rax), %eax
leal -0x4(%rax), %ecx
cmpl $0x2, %ecx
jae 0x2164c
movq %rbx, %rdi
callq 0x861b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x975f
movq %rbx, %rcx
cmpl $0x1, %eax
je 0x2165b
leaq 0x1d395(%rip), %rcx     # 0x3e9f0
movq (%rcx), %r12
movq 0x1fc33(%rip), %r15     # 0x41298
movq %r15, %rdi
callq 0x861b
cmpq %r15, %r12
je 0x21692
pushq $-0x1
popq %rdi
callq 0xa426
movq %rbx, %rdi
callq 0x861b
pushq $0x3
popq %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x85eb
addq $0x8, %r14
cmpb $0x1, 0x10(%rbx)
leaq 0x1d34f(%rip), %r15     # 0x3e9f0
movq %r15, %rax
cmoveq %r14, %rax
movq (%rax), %rax
movb 0x10(%rax), %cl
cmpb $0x1, %cl
jne 0x216c0
movq (%rax), %rdx
movb 0x10(%rdx), %dl
cmpb $0x4, %dl
jne 0x216cf
jmp 0x216d4
movq 0x1d329(%rip), %rdi     # 0x3e9f0
movb 0x10(%rdi), %dl
cmpb $0x4, %dl
je 0x216de
cmpb $0x5, %dl
jne 0x21701
cmpb $0x1, %cl
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x861b
callq 0x975f
cmpb $0x1, 0x10(%rbx)
cmovneq %r15, %r14
movq (%r14), %rcx
leaq 0x8(%rcx), %rax
cmpb $0x1, 0x10(%rcx)
cmovneq %r15, %rax
jmp 0x21714
pushq $-0x1
popq %rdi
callq 0xa426
cmpb $0x1, 0x10(%rbx)
cmoveq %r14, %r15
movq %r15, %rax
movq (%rax), %rdi
callq 0x861b
callq 0x865c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x865c
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: scan_power
void
scan_power(void)
{
	scan_factor();
	if (token == '^') {
		get_token_skip_newlines();
		push_symbol(POWER);
		swap();
		scan_power();
		list(3);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x2198d
cmpl $0x5e, 0xee167(%rip)    # 0x10f8e4
jne 0x217a3
callq 0x21443
movq 0x1fb15(%rip), %rdi     # 0x412a0
callq 0x861b
callq 0xa49b
callq 0x2176d
pushq $0x3
popq %rdi
popq %rbp
jmp 0x85eb
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: static_reciprocate
void
static_reciprocate(void)
{
	struct atom *p1, *p2;

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

	// save divide by zero error for runtime

	if (iszero(p2)) {
		push(p1);
		push_symbol(POWER);
		push(p2);
		push_integer(-1);
		list(3);
		return;
	}

	if (isnum(p1) && isnum(p2)) {
		push(p1);
		push(p2);
		divide();
		return;
	}

	if (!isrational(p1) || !isequaln(p1, 1))
		push(p1); // p1 != 1

	if (isnum(p2)) {
		push(p2);
		reciprocate();
		return;
	}

	if (car(p2) == symbol(POWER) && isnum(caddr(p2))) {
		push_symbol(POWER);
		push(cadr(p2));
		push(caddr(p2));
		negate();
		list(3);
		return;
	}

	push_symbol(POWER);
	push(p2);
	push_integer(-1);
	list(3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
callq 0x868d
movq %rax, %r14
movq %rax, %rbx
callq 0x868d
movq %rax, %r15
movq %r14, %rdi
callq 0xa641
testl %eax, %eax
je 0x21803
movq %r15, %rdi
callq 0x861b
movq 0x1fac2(%rip), %rdi     # 0x412a0
callq 0x861b
movq %rbx, %rdi
callq 0x861b
pushq $-0x1
popq %rdi
callq 0xa426
pushq $0x3
popq %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x85eb
movb 0x10(%r15), %al
movl %eax, %ecx
andb $-0x2, %cl
cmpb $0x4, %cl
jne 0x21850
movb 0x10(%rbx), %r12b
movl %r12d, %ecx
andb $-0x2, %cl
cmpb $0x4, %cl
jne 0x2183d
movq %r15, %rdi
callq 0x861b
movq %rbx, %rdi
callq 0x861b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xca0b
cmpb $0x4, %al
jne 0x21850
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x2116a
testl %eax, %eax
jne 0x2185c
movq %r15, %rdi
callq 0x861b
movb 0x10(%rbx), %r12b
movzbl %r12b, %eax
leal -0x4(%rax), %ecx
cmpl $0x2, %ecx
jae 0x2187d
movq %rbx, %rdi
callq 0x861b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa03a
movq %rbx, %rcx
cmpl $0x1, %eax
je 0x2188c
leaq 0x1d164(%rip), %rcx     # 0x3e9f0
movq 0x1fa0d(%rip), %rdi     # 0x412a0
cmpq %rdi, (%rcx)
jne 0x217de
addq $0x8, %r14
cmpb $0x1, %r12b
leaq 0x1d145(%rip), %rax     # 0x3e9f0
movq %rax, %rcx
cmoveq %r14, %rcx
movq (%rcx), %rcx
movb 0x10(%rcx), %dl
cmpb $0x1, %dl
jne 0x218ef
movq 0x8(%rcx), %r8
cmpb $0x1, 0x10(%r8)
leaq 0x1d123(%rip), %rsi     # 0x3e9f0
cmovneq %rsi, %r8
movq (%r8), %r8
cmpb $0x4, 0x10(%r8)
je 0x2192a
cmpb $0x1, %dl
jne 0x2190d
movq 0x8(%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
movq %rsi, %rax
je 0x2191a
jmp 0x2191d
movq 0x1d0fa(%rip), %rcx     # 0x3e9f0
movzbl 0x10(%rcx), %edx
cmpl $0x4, %edx
je 0x2192a
cmpl $0x1, %edx
jne 0x2191d
movq (%rcx), %rcx
cmpb $0x4, 0x10(%rcx)
je 0x2192a
movq 0x1d0dc(%rip), %rcx     # 0x3e9f0
cmpb $0x1, 0x10(%rcx)
jne 0x2191d
movq %rcx, %rax
movq (%rax), %rax
cmpb $0x5, 0x10(%rax)
jne 0x217de
callq 0x861b
cmpb $0x1, 0x10(%rbx)
leaq 0x1d0b6(%rip), %r15     # 0x3e9f0
movq %r15, %rax
cmoveq %r14, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x861b
cmpb $0x1, 0x10(%rbx)
cmovneq %r15, %r14
movq (%r14), %rax
cmpb $0x1, 0x10(%rax)
jne 0x2196b
movq 0x8(%rax), %rax
jmp 0x21972
movq 0x1d07e(%rip), %rax     # 0x3e9f0
cmpb $0x1, 0x10(%rax)
jne 0x2197b
movq %rax, %r15
movq (%r15), %rdi
callq 0x861b
callq 0x975f
jmp 0x217f3
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: scan_factor
void
scan_factor(void)
{
	int h = tos;

	switch (token) {

	case '(':
		scan_subexpr();
		break;

	case T_SYMBOL:
		scan_symbol();
		break;

	case T_FUNCTION:
		scan_function_call();
		break;

	case T_INTEGER:
		scan_integer();
		get_token();
		break;

	case T_DOUBLE:
		push_double(atof(token_buf));
		get_token();
		break;

	case T_STRING:
		scan_string();
		break;

	default:
		scan_error("syntax err");
		break;
	}

	// index

	if (token == '[') {
		scan_level++;
		get_token(); // get token after '['
		push_symbol(INDEX);
		swap();
		scan_expression();
		while (token == ',') {
			get_token(); // get token after ','
			scan_expression();
		}
		if (token != ']')
			scan_error("expected ']'");
		scan_level--;
		get_token(); // get token after ']'
		list(tos - h);
	}

	while (token == '!') {
		get_token(); // get token after '!'
		push_symbol(FACTORIAL);
		swap();
		list(2);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0x1690f(%rip), %ebx     # 0x382a8
movl 0xedf45(%rip), %ecx     # 0x10f8e4
leal -0x3e9(%rcx), %eax
cmpl $0x6, %eax
ja 0x219c1
leaq 0x1737(%rip), %rcx      # 0x230e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x21c42
jmp 0x219e9
cmpl $0x28, %ecx
jne 0x21a5e
callq 0x21a9a
jmp 0x219fc
callq 0x21caf
jmp 0x219fc
movq 0xedf09(%rip), %rdi     # 0x10f8e8
callq 0x70c0
callq 0xaf59
callq 0x21c88
jmp 0x219fc
callq 0x21bb3
jmp 0x219fc
callq 0x21b47
cmpl $0x5b, 0xedee1(%rip)    # 0x10f8e4
jne 0x21a6f
incl 0xeded5(%rip)           # 0x10f8e0
callq 0x21c88
movq 0x1f891(%rip), %rdi     # 0x412a8
callq 0x861b
callq 0xa49b
callq 0x21524
movl 0xedeb8(%rip), %eax     # 0x10f8e4
cmpl $0x2c, %eax
jne 0x21a38
callq 0x21c88
jmp 0x21a21
cmpl $0x5d, %eax
jne 0x21a52
decl 0xede9d(%rip)           # 0x10f8e0
callq 0x21c88
movl 0x1685a(%rip), %edi     # 0x382a8
subl %ebx, %edi
jmp 0x21a6a
leaq 0x64e0(%rip), %rdi      # 0x27f39
callq 0x21492
leaq 0x64c9(%rip), %rdi      # 0x27f2e
callq 0x21492
callq 0x85eb
cmpl $0x21, 0xede6e(%rip)    # 0x10f8e4
jne 0x21a93
callq 0x21c88
movq 0x1b66c(%rip), %rdi     # 0x3d0f0
callq 0x861b
callq 0xa49b
pushq $0x2
popq %rdi
jmp 0x21a6a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: scan_subexpr
void
scan_subexpr(void)
{
	int h, i, n;
	struct atom *p;
	h = tos;
	scan_level++;
	get_token(); // get token after '('
	scan_stmt();
	while (token == ',') {
		get_token(); // get token after ','
		scan_stmt();
	}
	if (token != ')')
		scan_error("expected ')'");
	scan_level--;
	get_token(); // get token after ')'
	n = tos - h;
	if (n < 2)
		return;
	p = alloc_vector(n);
	for (i = 0; i < n; i++)
		p->u.tensor->elem[i] = stack[h + i];
	tos = h;
	push(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x167fd(%rip), %r14d    # 0x382a8
movslq %r14d, %r15
incl 0xede2c(%rip)           # 0x10f8e0
callq 0x21c88
callq 0x2145a
movl 0xede20(%rip), %eax     # 0x10f8e4
cmpl $0x2c, %eax
je 0x21ab4
cmpl $0x29, %eax
jne 0x21b3b
decl 0xede0c(%rip)           # 0x10f8e0
callq 0x21c88
movl 0x167c9(%rip), %ebx     # 0x382a8
subl %r14d, %ebx
cmpl $0x2, %ebx
jge 0x21af2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %ebx, %edi
callq 0x77b7
movl %ebx, %ecx
shlq $0x3, %r15
xorl %edx, %edx
leaq 0x1faa8(%rip), %rsi     # 0x415b0
cmpq %rdx, %rcx
je 0x21b22
leaq (%r15,%rdx,8), %rdi
movq (%rsi,%rdi), %rdi
movq (%rax), %r8
movq %rdi, 0x68(%r8,%rdx,8)
incq %rdx
jmp 0x21b08
movl %r14d, 0x1677f(%rip)    # 0x382a8
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x861b
leaq 0x6404(%rip), %rdi      # 0x27f46
callq 0x21492
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: scan_symbol
void
scan_symbol(void)
{
	if (scan_mode && strlen(token_buf) == 1)
		switch (token_buf[0]) {
		case 'a':
			push_symbol(SA);
			break;
		case 'b':
			push_symbol(SB);
			break;
		case 'x':
			push_symbol(SX);
			break;
		default:
			push(lookup(token_buf));
			break;
		}
	else
		push(lookup(token_buf));
	get_token();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpl $0x0, 0xedd7c(%rip)     # 0x10f8d0
movq 0xedd8d(%rip), %rbx     # 0x10f8e8
je 0x21b86
movq %rbx, %rdi
callq 0x70e0
cmpq $0x1, %rax
jne 0x21b86
movzbl (%rbx), %eax
cmpl $0x78, %eax
je 0x21baa
cmpl $0x62, %eax
je 0x21ba1
cmpl $0x61, %eax
jne 0x21b86
movq 0x1f73c(%rip), %rdi     # 0x412c0
jmp 0x21b91
movq %rbx, %rdi
callq 0x21cc5
movq %rax, %rdi
callq 0x861b
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21c88
movq 0x1f720(%rip), %rdi     # 0x412c8
jmp 0x21b91
movq 0x1f71f(%rip), %rdi     # 0x412d0
jmp 0x21b91
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: scan_function_call
void
scan_function_call(void)
{
	int h = tos;
	scan_level++;
	push(lookup(token_buf)); // push function name
	get_token(); // get token after function name
	get_token(); // get token after '('
	if (token == ')') {
		scan_level--;
		get_token(); // get token after ')'
		list(1); // function call with no args
		return;
	}
	scan_stmt();
	while (token == ',') {
		get_token(); // get token after ','
		scan_stmt();
	}
	if (token != ')')
		scan_error("expected ')'");
	scan_level--;
	get_token(); // get token after ')'
	list(tos - h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0x166e9(%rip), %ebx     # 0x382a8
incl 0xedd1b(%rip)           # 0x10f8e0
movq 0xedd1c(%rip), %rdi     # 0x10f8e8
callq 0x21cc5
movq %rax, %rdi
callq 0x861b
callq 0x21c88
callq 0x21c88
cmpl $0x29, 0xedcfa(%rip)    # 0x10f8e4
jne 0x21bfc
decl 0xedcee(%rip)           # 0x10f8e0
callq 0x21c88
pushq $0x1
popq %rdi
jmp 0x21c2b
callq 0x2145a
movl 0xedcdd(%rip), %eax     # 0x10f8e4
cmpl $0x2c, %eax
jne 0x21c13
callq 0x21c88
jmp 0x21bfc
cmpl $0x29, %eax
jne 0x21c36
decl 0xedcc2(%rip)           # 0x10f8e0
callq 0x21c88
movl 0x1667f(%rip), %edi     # 0x382a8
subl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x85eb
leaq 0x6309(%rip), %rdi      # 0x27f46
callq 0x21492
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: lookup
struct atom *
lookup(char *s)
{
	int i, k;
	struct atom *p;

	if (isupper(*s))
		k = BUCKETSIZE * (*s - 'A');
	else if (islower(*s))
		k = BUCKETSIZE * (*s - 'a');
	else
		k = BUCKETSIZE * 26;

	for (i = 0; i < BUCKETSIZE; i++) {
		p = symtab[k + i];
		if (p == NULL)
			break;
		if (strcmp(s, printname(p)) == 0)
			return p;
	}

	if (i == BUCKETSIZE)
		stopf("symbol table full");

	p = alloc_atom();
	s = strdup(s);
	if (s == NULL)
		exit(1);
	p->atomtype = USYM;
	p->u.usym.name = s;
	p->u.usym.index = k + i;
	symtab[k + i] = p;
	usym_count++;

	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x7380
movq (%rax), %rax
movsbq (%rbx), %rcx
movzwl (%rax,%rcx,2), %edx
btl $0x8, %edx
jb 0x21d01
movl $0xa28, %eax            # imm = 0xA28
btl $0x9, %edx
jae 0x21d09
imull $0x64, %ecx, %eax
addl $0xffffda1c, %eax       # imm = 0xFFFFDA1C
jmp 0x21d09
imull $0x64, %ecx, %eax
addl $0xffffe69c, %eax       # imm = 0xFFFFE69C
cltq
movq %rax, -0x30(%rbp)
leaq (,%rax,8), %r15
xorl %r12d, %r12d
leaq 0x62af(%rip), %r13      # 0x27fd0
cmpq $0x64, %r12
je 0x21db0
leaq (%r15,%r12,8), %rax
leaq 0x1a41a(%rip), %rcx     # 0x3c150
movq (%rcx,%rax), %r14
testq %r14, %r14
je 0x21d60
movb 0x10(%r14), %al
andb $-0x2, %al
movq %r13, %rsi
cmpb $0x2, %al
jne 0x21d4f
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x71e0
testl %eax, %eax
je 0x21d9e
incq %r12
jmp 0x21d21
callq 0x749c
movq %rax, %r14
movq %rbx, %rdi
callq 0x7340
testq %rax, %rax
je 0x21dbc
movb $0x3, 0x10(%r14)
movq %rax, (%r14)
movq -0x30(%rbp), %rcx
leal (%rcx,%r12), %eax
movl %eax, 0x8(%r14)
leaq 0x1a3c0(%rip), %rax     # 0x3c150
leaq (%rax,%rcx,8), %rax
movq %r14, (%rax,%r12,8)
incl 0xed63a(%rip)           # 0x10f3d8
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6207(%rip), %rdi      # 0x27fbe
callq 0x7756
pushq $0x1
popq %rdi
callq 0x7320
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]eigenmath/eigenmath.c
// Function: update_token_buf
void
update_token_buf(char *a, char *b)
{
	int m, n;

	n = (int) (b - a);

	// Let n == 1000

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

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

	if (m > token_buf_len) {
		if (token_buf)
			free(token_buf);
		token_buf = alloc_mem(m);
		token_buf_len = m;
	}

	strncpy(token_buf, a, n);
	token_buf[n] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
subq %rdi, %r14
movl $0x3e8, %ecx            # imm = 0x3E8
movl %r14d, %eax
cltd
idivl %ecx
movl %r14d, %r15d
subl %edx, %r15d
addl %ecx, %r15d
movq 0xed855(%rip), %rdi     # 0x10f8e8
cmpl 0xed85e(%rip), %r15d    # 0x10f8f8
jle 0x220ba
callq 0x7040
movl %r15d, %edi
callq 0x779c
movq %rax, %rdi
movq %rax, 0xed835(%rip)     # 0x10f8e8
movl %r15d, 0xed83e(%rip)    # 0x10f8f8
movslq %r14d, %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x7070
movq 0xed819(%rip), %rax     # 0x10f8e8
movb $0x0, (%rax,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]wld/buffer.c
// Function: buffer_initialize
void
buffer_initialize(struct buffer *buffer,
                  const struct wld_buffer_impl *impl,
                  uint32_t width, uint32_t height,
                  uint32_t format, uint32_t pitch)
{
	*((const struct wld_buffer_impl **)&buffer->base.impl) = impl;
	buffer->base.width = width;
	buffer->base.height = height;
	buffer->base.format = format;
	buffer->base.pitch = pitch;
	buffer->base.map = NULL;
	buffer->ref = 1;
	buffer->map_ref = 0;
	buffer->exporters = NULL;
	buffer->destructors = NULL;
	pixman_region32_init_rect(&buffer->base.damage, 0, 0, width, height);
}

// Assembly:
movl %ecx, %eax
movl %edx, %ecx
movq %rsi, (%rdi)
movl %edx, 0x8(%rdi)
movl %eax, 0xc(%rdi)
movl %r8d, 0x14(%rdi)
movl %r9d, 0x10(%rdi)
andq $0x0, 0x30(%rdi)
movl $0x1, 0x38(%rdi)
leaq 0x18(%rdi), %rdx
xorps %xmm0, %xmm0
movups %xmm0, 0x3c(%rdi)
andl $0x0, 0x4c(%rdi)
movq %rdx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl %eax, %r8d
jmp 0x9680
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]wld/buffer.c
// Function: wld_export
EXPORT
bool
wld_export(struct wld_buffer *base, uint32_t type, union wld_object *object)
{
	struct buffer *buffer = (void *)base;
	struct wld_exporter *exporter;

	for (exporter = buffer->exporters; exporter; exporter = exporter->next) {
		if (exporter->export(exporter, &buffer->base, type, object))
			return true;
	}

	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x40(%rdi), %rcx
movq (%rcx), %r15
testq %r15, %r15
je 0x9a53
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
movq %rbx, %rcx
callq *(%r15)
leaq 0x8(%r15), %rcx
testb %al, %al
je 0x9a35
testq %r15, %r15
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]wld/buffer.c
// Function: wld_buffer_unreference
EXPORT
void
wld_buffer_unreference(struct wld_buffer *base)
{
	struct buffer *buffer = (void *)base;
	struct wld_destructor *destructor, *next;

	if (--buffer->ref > 0)
		return;

	pixman_region32_fini(&buffer->base.damage);

	for (destructor = buffer->destructors; destructor; destructor = next) {
		next = destructor->next;
		destructor->destroy(destructor);
	}

	if (buffer->map_ref > 0)
		buffer->base.impl->unmap(buffer);

	buffer->base.impl->destroy(buffer);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
decl 0x38(%rdi)
je 0x9a93
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x9130
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x9ab3
movq 0x8(%rdi), %r14
callq *(%rdi)
movq %r14, %rdi
jmp 0x9aa3
cmpl $0x0, 0x3c(%rbx)
je 0x9ac2
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x10(%rax)
nop
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]wld/buffered_surface.c
// Function: buffered_surface_create
struct wld_surface *
buffered_surface_create(struct wld_context *context, uint32_t width, uint32_t height,
                        uint32_t format, uint32_t flags, struct buffer_socket *buffer_socket)
{
	struct buffered_surface *surface;

	if (!(surface = malloc(sizeof *surface)))
		return NULL;

	surface_initialize(&surface->base, &wld_surface_impl);
	surface->context = context;
	surface->entries = NULL;
	surface->back = NULL;
	surface->entries_size = 0;
	surface->entries_capacity = 0;
	surface->buffer_socket = buffer_socket;
	surface->width = width;
	surface->height = height;
	surface->format = format;
	surface->flags = flags;

	return &surface->base;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movl %r8d, 0x4(%rsp)
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %rbx
pushq $0x40
popq %rdi
callq 0x9570
movq %rax, %r13
testq %rax, %rax
je 0x9b3a
leaq 0xbf07(%rip), %rsi      # 0x15a10
movq %r13, %rdi
callq 0xa444
movq %rbx, 0x8(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r13)
andq $0x0, 0x20(%r13)
movq %r14, 0x28(%r13)
movl %r12d, 0x30(%r13)
movl %r15d, 0x34(%r13)
movl %ebp, 0x38(%r13)
movl 0x4(%rsp), %eax
movl %eax, 0x3c(%r13)
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]wld/buffered_surface.c
// Function: surface_damage
pixman_region32_t *
surface_damage(struct wld_surface *base, pixman_region32_t *new_damage)
{
	struct buffered_surface *surface = buffered_surface(base);
	struct buffer *back_buffer;
	unsigned index;

	if (pixman_region32_not_empty(new_damage)) {
		for (index = 0; index < surface->entries_size; ++index) {
			pixman_region32_union(&surface->entries[index].buffer->base.damage,
			                      &surface->entries[index].buffer->base.damage,
			                      new_damage);
		}
	}

	if (!(back_buffer = surface_back(base)))
		return NULL;

	return &back_buffer->base.damage;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x9dcd
movq %r14, %rdi
callq 0x91f0
testl %eax, %eax
je 0x9b99
xorl %r15d, %r15d
xorl %r12d, %r12d
movl 0x20(%rbx), %eax
cmpq %rax, %r12
jae 0x9b99
movq 0x10(%rbx), %rax
movq (%rax,%r15), %rdi
addq $0x18, %rdi
movq %rdi, %rsi
movq %r14, %rdx
callq 0x9760
incq %r12
addq $0x10, %r15
jmp 0x9b71
movq %rbx, %rdi
callq 0x9bb8
leaq 0x18(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/michaelforney[P]wld/buffered_surface.c
// Function: surface_back
struct buffer *
surface_back(struct wld_surface *base)
{
	struct buffered_surface *surface = buffered_surface(base);
	unsigned index;

	if (surface->back)
		return surface->back->buffer;

	/* The buffer socket may need to process any incoming buffer releases. */
	if (surface->buffer_socket)
		surface->buffer_socket->impl->process(surface->buffer_socket);

	for (index = 0; index < surface->entries_size; ++index) {
		if (!surface->entries[index].busy) {
			surface->back = &surface->entries[index];
			return surface->back->buffer;
		}
	}

	/* If there are no free buffers, we need to allocate another one. */
	struct buffer *buffer;

	buffer = surface->context->impl->create_buffer(surface->context, surface->width, surface->height,
	                                               surface->format, surface->flags);

	if (!buffer)
		goto error0;

	if (surface->entries_size == surface->entries_capacity) {
		struct buffer_entry *new_entries;
		size_t new_capacity = surface->entries_capacity * 2 + 1;

		new_entries = realloc(surface->entries,
		                      new_capacity * sizeof surface->entries[0]);

		if (!new_entries)
			goto error1;

		surface->entries = new_entries;
		surface->entries_capacity = new_capacity;
	}

	surface->back = &surface->entries[surface->entries_size++];
	*surface->back = (struct buffer_entry){
		.buffer = buffer,
		.busy = false
	};

	return buffer;

error1:
	wld_buffer_unreference(&buffer->base);
error0:
	return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x9dcd
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x9bd6
movq (%rax), %r14
jmp 0x9c90
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x9be5
movq (%rdi), %rax
callq *0x8(%rax)
movl 0x20(%rbx), %eax
shlq $0x4, %rax
pushq $-0x10
popq %rdx
leaq 0x10(%rdx), %rcx
cmpq %rcx, %rax
je 0x9c14
movq 0x10(%rbx), %rsi
cmpb $0x0, 0x18(%rsi,%rdx)
movq %rcx, %rdx
jne 0x9bef
leaq (%rsi,%rcx), %rax
movq %rax, 0x18(%rbx)
movq (%rsi,%rcx), %r14
jmp 0x9c90
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movl 0x30(%rbx), %esi
movl 0x34(%rbx), %edx
movl 0x38(%rbx), %ecx
movl 0x3c(%rbx), %r8d
callq *0x8(%rax)
testq %rax, %rax
je 0x9c8d
movq %rax, %r14
movl 0x20(%rbx), %ecx
movq 0x10(%rbx), %rax
cmpl 0x24(%rbx), %ecx
jne 0x9c66
leal 0x1(,%rcx,2), %r15d
movq %r15, %rsi
shlq $0x4, %rsi
movq %rax, %rdi
callq 0x9600
testq %rax, %rax
je 0x9c85
movq %rax, 0x10(%rbx)
movl %r15d, 0x24(%rbx)
movl 0x20(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0x20(%rbx)
movl %ecx, %ecx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rdx
movq %rdx, 0x18(%rbx)
movq %r14, (%rax,%rcx)
movb $0x0, 0x8(%rax,%rcx)
jmp 0x9c90
movq %r14, %rdi
callq 0x9260
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq