LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_numerators
void
fmt_numerators(struct atom *p)
{
	int n, t;
	char *s;
	struct atom *q;

	t = tos;
	n = count_numerators(p);
	p = cdr(p);

	while (iscons(p)) {

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

		if (!isnumerator(q))
			continue;

		if (tos > t)
			fmt_space();

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

		if (car(q) == symbol(ADD) && n == 1)
			fmt_expr(q); // parens not needed
		else
			fmt_factor(q);
	}

	if (t == tos)
		fmt_roman_char('1'); // no numerators

	fmt_update_list(t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl 0x1741a(%rip), %ebx     # 0x3a2b8
callq 0x9319
cmpb $0x1, 0x10(%r14)
leaq 0x8(%r14), %rcx
leaq 0x1db4d(%rip), %r12     # 0x40a00
cmovneq %r12, %rcx
movq (%rcx), %r13
cmpb $0x1, 0x10(%r13)
jne 0x22f5a
movl %eax, %r14d
movq (%r13), %r15
movq 0x8(%r13), %r13
movq %r15, %rdi
callq 0x935d
testl %eax, %eax
je 0x22f4f
cmpl %ebx, 0x173d6(%rip)     # 0x3a2b8
jle 0x22ee9
callq 0x21f9a
movzbl 0x10(%r15), %ecx
movq %r15, %rax
cmpl $0x1, %ecx
je 0x22f26
cmpl $0x4, %ecx
jne 0x22f23
movq (%r15), %rdi
callq 0x7d27
movq %rax, %r15
movb (%rax), %al
testb %al, %al
je 0x22f4f
incq %r15
movsbl %al, %edi
callq 0x217e1
movb (%r15), %al
incq %r15
testb %al, %al
jne 0x22f0f
jmp 0x22f4f
movq %r12, %rax
cmpl $0x1, %r14d
sete %cl
movq (%rax), %rax
cmpq 0x20369(%rip), %rax     # 0x432a0
sete %al
andb %cl, %al
movq %r15, %rdi
cmpb $0x1, %al
jne 0x22f4a
callq 0x2188f
jmp 0x22f4f
callq 0x2203d
cmpb $0x1, 0x10(%r13)
je 0x22ec8
cmpl 0x17358(%rip), %ebx     # 0x3a2b8
jne 0x22f6c
movl $0x31, %edi
callq 0x217e1
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2191c
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_indices
void
fmt_indices(struct atom *p)
{
	fmt_roman_char('[');

	p = cdr(p);

	if (iscons(p)) {
		fmt_expr(car(p));
		p = cdr(p);
		while (iscons(p)) {
			fmt_roman_char(',');
			fmt_expr(car(p));
			p = cdr(p);
		}
	}

	fmt_roman_char(']');
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x5b, %edi
callq 0x217e1
cmpb $0x1, 0x10(%rbx)
leaq 0x8(%rbx), %rax
leaq 0x1d6cd(%rip), %rbx     # 0x40a00
cmovneq %rbx, %rax
movq (%rax), %r14
cmpb $0x1, 0x10(%r14)
jne 0x2337b
movq (%r14), %rdi
callq 0x2188f
leaq 0x8(%r14), %rax
cmpb $0x1, 0x10(%r14)
cmovneq %rbx, %rax
movq (%rax), %r14
cmpb $0x1, 0x10(%r14)
jne 0x2337b
movl $0x2c, %edi
callq 0x217e1
cmpb $0x1, 0x10(%r14)
movq %rbx, %rax
cmoveq %r14, %rax
movq (%rax), %rdi
jmp 0x23344
movl $0x5d, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x217e1
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_matrix
void
fmt_matrix(struct atom *p, int d, int k)
{
	int i, j, m, n, span;

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

	// compute element span

	span = 1;

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

	n = p->u.tensor->dim[d];	// number of rows
	m = p->u.tensor->dim[d + 1];	// number of columns

	for (i = 0; i < n; i++)
		for (j = 0; j < m; j++)
			fmt_matrix(p, d + 2, k + (i * m + j) * span);

	fmt_update_table(n, m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq (%rdi), %rax
movl (%rax), %edi
movl %edi, %ecx
subl %esi, %ecx
jne 0x233d0
movslq %edx, %rcx
movq 0x68(%rax,%rcx,8), %rdi
movl 0x16f02(%rip), %ebx     # 0x3a2b8
callq 0x2188f
movl %ebx, %edi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2191c
leal 0x2(%rsi), %r15d
movl $0x1, %r13d
cmpl %edi, %r15d
jge 0x233fb
movslq %r15d, %rdi
leaq (%rax,%rdi,4), %r8
addq $0x4, %r8
addl $-0x2, %ecx
xorl %edi, %edi
imull (%r8,%rdi,4), %r13d
incq %rdi
cmpl %edi, %ecx
jne 0x233ef
movslq %esi, %rcx
movl 0x4(%rax,%rcx,4), %esi
movl 0x8(%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
movl %esi, -0x30(%rbp)
testl %esi, %esi
jle 0x23454
movl %r13d, %eax
imull -0x2c(%rbp), %eax
movl %eax, -0x38(%rbp)
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
movl %edx, -0x34(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0x23444
movl -0x34(%rbp), %ebx
movl -0x2c(%rbp), %r12d
movq %r14, %rdi
movl %r15d, %esi
movl %ebx, %edx
callq 0x23389
addl %r13d, %ebx
decl %r12d
jne 0x2342f
movl -0x3c(%rbp), %eax
incl %eax
movl -0x34(%rbp), %edx
addl -0x38(%rbp), %edx
cmpl -0x30(%rbp), %eax
jne 0x2341c
movl -0x30(%rbp), %edi
movl -0x2c(%rbp), %esi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2346d
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_reciprocal
void
fmt_reciprocal(struct atom *p)
{
	int t;

	fmt_roman_char('1'); // numerator

	t = tos;

	if (isminusone(caddr(p)))
		fmt_expr(cadr(p));
	else {
		fmt_base(cadr(p));
		fmt_numeric_exponent(caddr(p)); // sign is not emitted
	}

	fmt_update_list(t);

	fmt_update_fraction();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x31, %edi
callq 0x217e1
leaq 0x8(%r14), %r15
cmpb $0x1, 0x10(%r14)
leaq 0x1d044(%rip), %r12     # 0x40a00
movq %r12, %rax
cmoveq %r15, %rax
movq (%rax), %r13
movb 0x10(%r13), %bl
leaq 0x8(%r13), %rax
cmpb $0x1, %bl
movq %r12, %rcx
cmoveq %rax, %rcx
movq (%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
movq %r12, %rcx
jne 0x239f5
cmpb $0x1, %bl
leaq 0x1d012(%rip), %rcx     # 0x40a00
cmoveq %rax, %rcx
movq (%rcx), %rcx
movl 0x168bd(%rip), %eax     # 0x3a2b8
movl %eax, -0x2c(%rbp)
movq (%rcx), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0xcb82
cmpb $0x1, %bl
cmoveq %r13, %r12
movq (%r12), %rdi
testl %eax, %eax
je 0x23a26
callq 0x2188f
jmp 0x23a71
callq 0x21d04
cmpb $0x1, 0x10(%r14)
leaq 0x1cfc9(%rip), %rax     # 0x40a00
cmovneq %rax, %r15
movq (%r15), %rcx
movb 0x10(%rcx), %dl
addq $0x8, %rcx
cmpb $0x1, %dl
movq %rax, %rsi
cmoveq %rcx, %rsi
movq (%rsi), %rsi
cmpb $0x1, 0x10(%rsi)
jne 0x23a69
cmpb $0x1, %dl
leaq 0x1cf9e(%rip), %rax     # 0x40a00
cmoveq %rcx, %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x22110
movl -0x2c(%rbp), %edi
callq 0x2191c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22f81
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_symbol_fragment
int
fmt_symbol_fragment(char *s, int k)
{
	int c, i, n;
	char *t;

	for (i = 0; i < NUM_SYMBOL_NAMES; i++) {
		t = symbol_name_tab[i];
		n = (int) strlen(t);
		if (strncmp(s + k, t, n) == 0)
			break;
	}

	if (i == NUM_SYMBOL_NAMES) {
		fmt_roman_char(s[k]);
		return k + 1;
	}

	c = symbol_unicode_tab[i];

	fmt_roman_char(c);

	return k + n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, -0x2c(%rbp)
movslq %esi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
leaq (%rdi,%rax), %r13
leaq 0x156ba(%rip), %r14     # 0x39170
xorl %r15d, %r15d
movq (%r14), %rbx
movq %rbx, %rdi
callq 0x70e0
movq %rax, %r12
movslq %r12d, %rdx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x7080
testl %eax, %eax
je 0x23aec
incq %r15
addq $0x8, %r14
cmpq $0x31, %r15
jne 0x23ab9
movl $0x31, %r15d
cmpl $0x31, %r15d
jne 0x23b09
movq -0x40(%rbp), %r12
movq -0x38(%rbp), %rax
movsbl (%rax,%r12), %edi
callq 0x217e1
incl %r12d
jmp 0x23b1f
movl %r15d, %eax
leaq 0x157ed(%rip), %rcx     # 0x39300
movl (%rcx,%rax,4), %edi
callq 0x217e1
addl -0x2c(%rbp), %r12d
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_update_subscript
void
fmt_update_subscript(void)
{
	int d, dx, dy, h, w;
	struct atom *p1;

	p1 = pop();

	h = HEIGHT(p1);
	d = DEPTH(p1);
	w = WIDTH(p1);

	dx = 0;
	dy = 1;

	push_double(EMIT_SUBSCRIPT);
	push_double(h);
	push_double(d + dy);
	push_double(w);
	push_double(dx);
	push_double(dy);
	push(p1);

	list(7);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
callq 0x8b78
movq %rax, %rbx
addq $0x8, %rax
cmpb $0x1, 0x10(%rbx)
leaq 0x1ceab(%rip), %rdx     # 0x40a00
cmovneq %rdx, %rax
movq (%rax), %rsi
movb 0x10(%rsi), %cl
leaq 0x8(%rsi), %rax
cmpb $0x1, %cl
cmovneq %rdx, %rsi
movq %rdx, %rdi
cmoveq %rax, %rdi
movq (%rdi), %rdi
cmpb $0x1, 0x10(%rdi)
movq %rdx, %rdi
jne 0x23b8e
cmpb $0x1, %cl
leaq 0x1ce79(%rip), %rdi     # 0x40a00
cmoveq %rax, %rdi
movq (%rdi), %rdi
movq (%rsi), %rsi
cmpb $0x1, %cl
movq (%rdi), %rdi
movq %rdx, %r8
cmoveq %rax, %r8
movq (%r8), %r8
cmpb $0x1, 0x10(%r8)
movq %rdx, %r8
jne 0x23bc0
cmpb $0x1, %cl
leaq 0x1ce4b(%rip), %r8      # 0x40a00
cmoveq %rax, %r8
movq (%r8), %r8
addq $0x8, %r8
movsd (%rsi), %xmm0
movaps %xmm0, -0x30(%rbp)
movsd (%rdi), %xmm0
movq (%r8), %rsi
cmpb $0x1, 0x10(%rsi)
jne 0x23c07
cmpb $0x1, %cl
leaq 0x1ce21(%rip), %rdx     # 0x40a00
movq %rdx, %rsi
cmoveq %rax, %rsi
movq (%rsi), %rsi
cmpb $0x1, 0x10(%rsi)
jne 0x23c04
cmpb $0x1, %cl
leaq 0x1ce07(%rip), %rcx     # 0x40a00
cmoveq %rax, %rcx
movq (%rcx), %rdx
addq $0x8, %rdx
movq (%rdx), %rdx
movq (%rdx), %rax
cvttsd2si %xmm0, %r15d
movsd (%rax), %xmm0
movaps %xmm0, -0x40(%rbp)
callq 0x74ec
movb $0x5, %r14b
movb %r14b, 0x10(%rax)
movabsq $0x4014000000000000, %rcx # imm = 0x4014000000000000
movq %rcx, (%rax)
movq %rax, %rdi
callq 0x8b01
cvttpd2dq -0x30(%rbp), %xmm0
cvtdq2pd %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
callq 0x74ec
movb %r14b, 0x10(%rax)
movaps -0x30(%rbp), %xmm0
movlps %xmm0, (%rax)
movq %rax, %rdi
callq 0x8b01
incl %r15d
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x74ec
movb %r14b, 0x10(%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rax, %rdi
callq 0x8b01
cvttpd2dq -0x40(%rbp), %xmm0
cvtdq2pd %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
callq 0x74ec
movb %r14b, 0x10(%rax)
movaps -0x30(%rbp), %xmm0
movlps %xmm0, (%rax)
movq %rax, %rdi
callq 0x8b01
callq 0x74ec
movb %r14b, 0x10(%rax)
movq $0x0, (%rax)
movq %rax, %rdi
callq 0x8b01
callq 0x74ec
movb %r14b, 0x10(%rax)
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax)
movq %rax, %rdi
callq 0x8b01
movq %rbx, %rdi
callq 0x8b01
movl $0x7, %edi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8ad9
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x1, %r12d
cmpq $0x2, %rcx
jl 0x2407c
decq %rcx
xorl %edx, %edx
imull 0x8(%rax,%rdx,4), %r12d
incq %rdx
cmpq %rdx, %rcx
jne 0x2406e
movl 0x4(%rax), %r14d
testl %r14d, %r14d
jle 0x240a3
xorl %r15d, %r15d
movl %r14d, %r13d
movq %rbx, %rdi
movl $0x1, %esi
movl %r15d, %edx
callq 0x23389
addl %r12d, %r15d
decl %r13d
jne 0x2408b
movl %r14d, %edi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2346d
// File: /workspace/github_c_makefile_star2_O1/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 0x9130
testl %eax, %eax
je 0x240f3
movq %rbx, %rdi
callq 0x22e87
movq %rbx, %rdi
callq 0x21de0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x22f81
cmpb $0x1, 0x10(%rbx)
leaq 0x8(%rbx), %rax
leaq 0x1c8fe(%rip), %rbx     # 0x40a00
cmovneq %rbx, %rax
movq (%rax), %r14
movb 0x10(%r14), %r15b
cmpb $0x1, %r15b
movq %rbx, %rax
cmoveq %r14, %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0xcb82
testl %eax, %eax
je 0x24144
addq $0x8, %r14
cmpb $0x1, %r15b
cmovneq %rbx, %r14
movq (%r14), %r14
jmp 0x24144
callq 0x21f9a
cmpb $0x1, 0x10(%r14)
movq %rbx, %rax
cmoveq %r14, %rax
movq (%rax), %rdi
callq 0x2203d
leaq 0x8(%r14), %rax
cmpb $0x1, 0x10(%r14)
cmovneq %rbx, %rax
movq (%rax), %r14
cmpb $0x1, 0x10(%r14)
je 0x2413f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r14d
movl %ecx, %r12d
movl %esi, %ebx
movl %edi, %r15d
cmpl $0x2, %edx
setl %al
testl %ecx, %ecx
setle %cl
testb %cl, %al
jne 0x24202
movl %edx, %r13d
movl %r15d, %edi
movl %ebx, %esi
movl %r12d, %ecx
callq 0x245c0
leal (%r14,%r15), %edi
decl %edi
movl %ebx, %esi
movl %r13d, %edx
movl %r12d, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2467c
testl %r15d, %r15d
js 0x24232
testl %ebx, %ebx
js 0x24232
movl 0xed1ef(%rip), %eax     # 0x111400
cmpl %r15d, %eax
jle 0x24232
cmpl %ebx, 0xed1e0(%rip)     # 0x1113fc
jle 0x24232
movq 0xed1e3(%rip), %rcx     # 0x111408
imull %ebx, %eax
addl %r15d, %eax
movl $0x28, (%rcx,%rax,4)
leal (%r14,%r15), %ecx
testl %ecx, %ecx
jle 0x24269
testl %ebx, %ebx
js 0x24269
movl 0xed1bc(%rip), %eax     # 0x111400
cmpl %ecx, %eax
jl 0x24269
cmpl %ebx, 0xed1ae(%rip)     # 0x1113fc
jle 0x24269
leal (%r14,%r15), %ecx
decl %ecx
movq 0xed1ab(%rip), %rdx     # 0x111408
imull %ebx, %eax
addl %ecx, %eax
movl $0x29, (%rdx,%rax,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl %esi, %eax
subl %edx, %eax
testl %edi, %edi
js 0x245fc
cmpl $-0x1, %eax
jl 0x245fc
movl 0xece2c(%rip), %r8d     # 0x111400
cmpl %edi, %r8d
jle 0x245fc
leal 0x1(%rax), %r9d
cmpl %r9d, 0xece18(%rip)     # 0x1113fc
jle 0x245fc
movq 0xece1b(%rip), %r10     # 0x111408
imull %r9d, %r8d
addl %edi, %r8d
movl $0xe2948c, (%r10,%r8,4) # imm = 0xE2948C
pushq %rbp
movq %rsp, %rbp
leal (%rdx,%rcx), %r8d
decl %r8d
cmpl $0x2, %r8d
jl 0x2464d
movq 0xecdf4(%rip), %r8      # 0x111408
addl %ecx, %edx
addl $-0x2, %edx
addl $0x2, %eax
testl %edi, %edi
js 0x24647
testl %eax, %eax
js 0x24647
movl 0xecdd5(%rip), %r9d     # 0x111400
cmpl %edi, %r9d
jle 0x24647
cmpl %eax, 0xecdc6(%rip)     # 0x1113fc
jle 0x24647
imull %eax, %r9d
addl %edi, %r9d
movl $0xe29482, (%r8,%r9,4)  # imm = 0xE29482
incl %eax
decl %edx
jne 0x2461c
testl %edi, %edi
js 0x2467a
addl %esi, %ecx
js 0x2467a
movl 0xecda5(%rip), %eax     # 0x111400
cmpl %edi, %eax
jle 0x2467a
cmpl %ecx, 0xecd97(%rip)     # 0x1113fc
jle 0x2467a
movq 0xecd9a(%rip), %rdx     # 0x111408
imull %ecx, %eax
addl %edi, %eax
movl $0xe29494, (%rdx,%rax,4) # imm = 0xE29494
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
movl %esi, %eax
subl %edx, %eax
testl %edi, %edi
js 0x246b8
cmpl $-0x1, %eax
jl 0x246b8
movl 0xecd70(%rip), %r8d     # 0x111400
cmpl %edi, %r8d
jle 0x246b8
leal 0x1(%rax), %r9d
cmpl %r9d, 0xecd5c(%rip)     # 0x1113fc
jle 0x246b8
movq 0xecd5f(%rip), %r10     # 0x111408
imull %r9d, %r8d
addl %edi, %r8d
movl $0xe29490, (%r10,%r8,4) # imm = 0xE29490
pushq %rbp
movq %rsp, %rbp
leal (%rdx,%rcx), %r8d
decl %r8d
cmpl $0x2, %r8d
jl 0x24709
movq 0xecd38(%rip), %r8      # 0x111408
addl %ecx, %edx
addl $-0x2, %edx
addl $0x2, %eax
testl %edi, %edi
js 0x24703
testl %eax, %eax
js 0x24703
movl 0xecd19(%rip), %r9d     # 0x111400
cmpl %edi, %r9d
jle 0x24703
cmpl %eax, 0xecd0a(%rip)     # 0x1113fc
jle 0x24703
imull %eax, %r9d
addl %edi, %r9d
movl $0xe29482, (%r8,%r9,4)  # imm = 0xE29482
incl %eax
decl %edx
jne 0x246d8
testl %edi, %edi
js 0x24736
addl %esi, %ecx
js 0x24736
movl 0xecce9(%rip), %eax     # 0x111400
cmpl %edi, %eax
jle 0x24736
cmpl %ecx, 0xeccdb(%rip)     # 0x1113fc
jle 0x24736
movq 0xeccde(%rip), %rdx     # 0x111408
imull %ecx, %eax
addl %edi, %eax
movl $0xe29498, (%rdx,%rax,4) # imm = 0xE29498
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2479d
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb 0x10(%rbx), %al
cmpb $0x1, %al
jne 0x24766
cmpb $0x0, 0x11(%rbx)
je 0x24799
movb $0x0, 0x11(%rbx)
movq (%rbx), %rdi
callq 0x24738
movq 0x8(%rbx), %rbx
jmp 0x24747
cmpb $0x0, 0x11(%rbx)
je 0x24799
movb $0x0, 0x11(%rbx)
cmpb $0x7, %al
jne 0x24799
movq (%rbx), %rax
cmpl $0x0, 0x64(%rax)
jle 0x24799
xorl %r14d, %r14d
movq 0x68(%rax,%r14,8), %rdi
callq 0x24738
incq %r14
movq (%rbx), %rax
movslq 0x64(%rax), %rcx
cmpq %rcx, %r14
jl 0x24780
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpl $0x2, %edi
jl 0x247ca
movq %rsi, %rbx
movl %edi, %r14d
movl $0x1, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x247f6
incq %r15
cmpq %r15, %r14
jne 0x247b9
movq 0xe7ff(%rip), %rax      # 0x32fd0
movq (%rax), %rdi
callq 0x7240
movl %eax, %edi
callq 0x70b0
testl %eax, %eax
jne 0x247f1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x24829
// File: /workspace/github_c_makefile_star2_O1/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 0x1dfaf
testq %rax, %rax
je 0x24821
movq %rax, %r14
movq %rax, %rdi
callq 0x2487e
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7040
movq %rbx, %rdi
callq 0x73d0
// File: /workspace/github_c_makefile_star2_O1/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 0xe795(%rip), %r15      # 0x32fd0
leaq 0x1b5a(%rip), %rbx      # 0x2639c
movq 0xe78f(%rip), %r12      # 0x32fd8
leaq 0xecbc0(%rip), %r14     # 0x111410
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x7120
movq (%r15), %rdi
callq 0x7280
movq (%r12), %rdx
movq %r14, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x71b0
movq %r14, %rdi
callq 0x2487e
jmp 0x24850
// File: /workspace/github_c_makefile_star2_O1/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 0xecf6d(%rip), %rdi     # 0x111800
callq 0x71c0
testl %eax, %eax
jne 0x249dd
xorl %eax, %eax
movl %eax, 0x15a10(%rip)     # 0x3a2b8
movl %eax, 0xe221a(%rip)     # 0x106ac8
movl %eax, 0xe2210(%rip)     # 0x106ac4
movl %eax, 0xe2206(%rip)     # 0x106ac0
movl $0x1, 0xe220c(%rip)     # 0x106ad0
movl %eax, 0xecffe(%rip)     # 0x1118c8
movl %eax, 0xecaf4(%rip)     # 0x1113c4
movl %eax, 0xecaea(%rip)     # 0x1113c0
movl %eax, 0xe220c(%rip)     # 0x106ae8
cmpq $0x0, 0x1985c(%rip)     # 0x3e140
jne 0x249d5
xorl %r15d, %r15d
movl %r15d, %edi
callq 0x7230
movl %eax, %edi
callq 0x71a0
callq 0x24eee
movl %r15d, %edi
callq 0x7ad5
movq %rax, %r12
movl $0x1, %r14d
movl %r14d, %edi
callq 0x7ad5
movl %r15d, %edi
movq %r12, %rsi
movq %rax, %rdx
callq 0xb9f7
callq 0x8b78
movq %rax, 0x1980c(%rip)     # 0x3e140
movl %r14d, %edi
callq 0x7ad5
movq %rax, %r12
movl %r14d, %edi
callq 0x7ad5
movl %r15d, %edi
movq %r12, %rsi
movq %rax, %rdx
callq 0xb9f7
callq 0x8b78
movq %rax, 0xe2177(%rip)     # 0x106ad8
movl %r14d, %edi
callq 0x7ad5
movq %rax, %r15
movl %r14d, %edi
callq 0x7ad5
movl %r14d, %edi
movq %r15, %rsi
movq %rax, %rdx
callq 0xb9f7
callq 0x8b78
movq %rax, 0xeca62(%rip)     # 0x1113f0
movq 0x1e91b(%rip), %rdi     # 0x432b0
callq 0x8b01
movq 0xeca4f(%rip), %rdi     # 0x1113f0
callq 0x8b01
movl %r14d, %edi
movl $0x2, %esi
callq 0xa1f4
movl $0x3, %edi
callq 0x8ad9
callq 0x8b78
movq %rax, 0xe2117(%rip)     # 0x106ae0
movq 0x149f8(%rip), %rdi     # 0x393c8
callq 0x1e047
movq %rbx, %rdi
callq 0x1e047
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
movb 0x10(%rdi), %al
cmpb $0x1, %al
leaq 0x1bfe7(%rip), %r14     # 0x40a00
movq %r14, %rcx
cmoveq %rdi, %rcx
movq (%rcx), %rcx
cmpq 0x1e876(%rip), %rcx     # 0x432a0
je 0x24a39
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x24b54
addq $0x8, %rdi
cmpb $0x1, %al
cmovneq %r14, %rdi
movq (%rdi), %r15
xorl %ebx, %ebx
cmpb $0x1, 0x10(%r15)
jne 0x24a81
leaq 0x10(%r15), %r12
movq (%r15), %rdi
callq 0x24b54
testl %eax, %eax
jne 0x24a7c
addq $0x8, %r15
cmpb $0x1, (%r12)
cmovneq %r14, %r15
movq (%r15), %r15
leaq 0x10(%r15), %r12
cmpb $0x1, 0x10(%r15)
je 0x24a53
jmp 0x24a81
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8b78
movq %rax, %r14
callq 0x8b78
movb 0x10(%r14), %cl
cmpb $0x1, %cl
leaq 0x1bf4e(%rip), %r15     # 0x40a00
movq %r15, %rdx
cmoveq %r14, %rdx
movq %rax, %rbx
movq (%rdx), %rax
cmpq 0x1e7da(%rip), %rax     # 0x432a0
je 0x24aea
movq %rbx, %rdi
callq 0x8b01
movq %r14, %rdi
callq 0x8b01
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa8bb
addq $0x8, %r14
cmpb $0x1, %cl
cmovneq %r15, %r14
movl 0x157bc(%rip), %r12d    # 0x3a2b8
movq (%r14), %r14
cmpb $0x1, 0x10(%r14)
jne 0x24b3e
movq %rbx, %rdi
callq 0x8b01
cmpb $0x1, 0x10(%r14)
movq %r15, %rax
cmoveq %r14, %rax
movq (%rax), %rdi
callq 0x8b01
movl $0x2, %edi
callq 0xa8bb
leaq 0x8(%r14), %rax
cmpb $0x1, 0x10(%r14)
cmovneq %r15, %rax
movq (%rax), %r14
jmp 0x24aff
movl 0x15774(%rip), %edi     # 0x3a2b8
subl %r12d, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa975
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
movb 0x10(%rdi), %al
cmpb $0x1, %al
leaq 0x1be95(%rip), %r14     # 0x40a00
movq %r14, %rcx
cmoveq %rdi, %rcx
movq (%rcx), %rcx
cmpq 0x1e72c(%rip), %rcx     # 0x432a8
je 0x24b8b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x24bde
addq $0x8, %rdi
cmpb $0x1, %al
cmovneq %r14, %rdi
movq (%rdi), %r15
xorl %ebx, %ebx
cmpb $0x1, 0x10(%r15)
jne 0x24bd3
leaq 0x10(%r15), %r12
movq (%r15), %rdi
callq 0x24bde
testl %eax, %eax
jne 0x24bce
addq $0x8, %r15
cmpb $0x1, (%r12)
cmovneq %r14, %r15
movq (%r15), %r15
leaq 0x10(%r15), %r12
cmpb $0x1, 0x10(%r15)
je 0x24ba5
jmp 0x24bd3
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movq %rdi, %r14
movb 0x10(%rdi), %cl
cmpb $0x4, %cl
jne 0x24c11
movq 0x8(%r14), %rax
cmpl $0x1, -0x4(%rax)
jne 0x24ced
cmpl $0x1, (%rax)
jne 0x24ced
cmpb $0x1, %cl
leaq 0x1bde5(%rip), %rax     # 0x40a00
movq %rax, %rdx
cmoveq %r14, %rdx
movq 0x1e687(%rip), %r15     # 0x432b0
xorl %ebx, %ebx
cmpq %r15, (%rdx)
jne 0x24d15
leaq 0x8(%r14), %rdx
cmpb $0x1, %cl
movq %rax, %rcx
movq %rdx, -0x30(%rbp)
cmoveq %rdx, %rcx
movq (%rcx), %rcx
movb 0x10(%rcx), %r12b
movq %rcx, -0x38(%rbp)
leaq 0x8(%rcx), %r13
cmpb $0x1, %r12b
movq %rax, %rcx
cmoveq %r13, %rcx
movq (%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0x24c7b
cmpb $0x1, %r12b
leaq 0x1bd8c(%rip), %rax     # 0x40a00
cmoveq %r13, %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0xa813
testl %eax, %eax
je 0x24d15
cmpb $0x1, %r12b
leaq 0x1bd6a(%rip), %rax     # 0x40a00
movq %rax, %rcx
cmoveq %r13, %rcx
movq (%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0x24cb8
cmpb $0x1, %r12b
leaq 0x1bd4f(%rip), %rax     # 0x40a00
cmoveq %r13, %rax
movq (%rax), %rax
movq (%rax), %rdi
movl $0x1, %ebx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0xcb82
testl %eax, %eax
je 0x24d26
cmpb $0x1, %r12b
leaq 0x1bd22(%rip), %rax     # 0x40a00
cmoveq -0x38(%rbp), %rax
movq (%rax), %rdi
callq 0x8b01
jmp 0x24d15
movq 0x8(%r14), %rdi
callq 0x7e34
movq %rax, %r14
movl $0x1, %ebx
movl $0x1, %edi
callq 0x7ad5
xorl %edi, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0xb9f7
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x8b01
cmpb $0x1, 0x10(%r14)
leaq 0x1bcc6(%rip), %r15     # 0x40a00
movq %r15, %rax
movq -0x30(%rbp), %r12
cmoveq %r12, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x8b01
cmpb $0x1, 0x10(%r14)
cmovneq %r15, %r12
movq (%r12), %rax
movb 0x10(%rax), %cl
addq $0x8, %rax
cmpb $0x1, %cl
movq %r15, %rdx
cmoveq %rax, %rdx
movq (%rdx), %rdx
cmpb $0x1, 0x10(%rdx)
jne 0x24d90
cmpb $0x1, %cl
leaq 0x1bc77(%rip), %rcx     # 0x40a00
cmoveq %rax, %rcx
movq (%rcx), %r15
movq (%r15), %rdi
callq 0x8b01
movq 0xec651(%rip), %rdi     # 0x1113f0
callq 0x8b01
movl $0x2, %edi
callq 0xa8bb
movl $0x3, %edi
callq 0x8ad9
jmp 0x24d15
// File: /workspace/github_c_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x1925d(%rip), %rbx     # 0x3e160
movl $0x5460, %edx           # imm = 0x5460
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7130
leaq 0xe1bd7(%rip), %rdi     # 0x106af0
movl $0x5460, %edx           # imm = 0x5460
xorl %esi, %esi
callq 0x7130
leaq 0xe7024(%rip), %rdi     # 0x10bf50
movl $0x5460, %edx           # imm = 0x5460
xorl %esi, %esi
callq 0x7130
movl $0x10, %r15d
leaq 0x1448b(%rip), %r12     # 0x393d0
leaq 0xec498(%rip), %r13     # 0x1113e4
callq 0x74ec
movq %rax, %r14
movq -0x10(%r15,%r12), %rdi
callq 0x7360
testq %rax, %rax
je 0x24fbe
cmpq $0x0, (%r15,%r12)
je 0x24f7f
movb $0x2, 0x10(%r14)
movq %rax, (%r14)
movq (%r15,%r12), %rax
movq %rax, 0x8(%r14)
movq %r13, %rax
jmp 0x24f97
movb $0x3, 0x10(%r14)
movq %rax, (%r14)
movl -0x8(%r15,%r12), %eax
movl %eax, 0x8(%r14)
leaq 0xec451(%rip), %rax     # 0x1113e8
incl (%rax)
movslq -0x8(%r15,%r12), %rax
movq %r14, (%rbx,%rax,8)
addq $0x18, %r15
cmpq $0xec8, %r15            # imm = 0xEC8
jne 0x24f4c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %edi
callq 0x7330
// File: /workspace/github_c_makefile_star2_O1/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, 0xec8fb(%rip)     # 0x1118d0
movl $0x0, 0xec901(%rip)     # 0x1118e0
callq 0x250d0
movq %rax, %rbx
movq %rax, 0xec8ea(%rip)     # 0x1118d8
movq 0x1cd2b(%rip), %rdi     # 0x41d20
callq 0xe468
cmpq 0x1cd1f(%rip), %rax     # 0x41d20
je 0x25014
movq %rax, %rdi
callq 0xaece
testl %eax, %eax
jne 0x25014
callq 0x25032
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpq $0x0, 0xec896(%rip)     # 0x1118d0
je 0x250cf
cmpq $0x0, 0xec890(%rip)     # 0x1118d8
je 0x250cf
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl $0x0, 0xec799(%rip)     # 0x1117f8
leaq 0x5e65(%rip), %rdi      # 0x2aecb
callq 0x14c8d
movq 0xec85e(%rip), %rbx     # 0x1118d0
movb (%rbx), %al
testb %al, %al
je 0x250b5
cmpq 0xec859(%rip), %rbx     # 0x1118d8
jae 0x250b5
incq %rbx
movl %eax, %r14d
movsbl %al, %edi
callq 0x15d29
movb (%rbx), %al
testb %al, %al
je 0x250a5
leaq 0x1(%rbx), %rcx
cmpq 0xec838(%rip), %rbx     # 0x1118d8
movq %rcx, %rbx
jb 0x25084
cmpb $0xa, %r14b
je 0x250b5
movl $0xa, %edi
callq 0x15d29
movq 0xec30c(%rip), %rdi     # 0x1113c8
movq 0xdf0d(%rip), %rax      # 0x32fd0
movq (%rax), %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x7120
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0xec80d(%rip)     # 0x1118e8
movl $0x1, 0xec80b(%rip)     # 0x1118f0
callq 0x25ab5
decl 0xec800(%rip)           # 0x1118f0
cmpl $0x3f3, 0xec7fa(%rip)   # imm = 0x3F3
jne 0x25100
xorl %eax, %eax
jmp 0x25120
callq 0x25153
movl 0xec7e9(%rip), %eax     # 0x1118f4
cmpl $0x3ee, %eax            # imm = 0x3EE
je 0x25119
cmpl $0x3f3, %eax            # imm = 0x3F3
jne 0x25122
movq 0xec7c8(%rip), %rax     # 0x1118e8
popq %rbp
retq
movq 0xec7bf(%rip), %rax     # 0x1118e8
movq %rax, 0xec7a8(%rip)     # 0x1118d8
leaq 0x5d9f(%rip), %rdi      # 0x2aed6
callq 0x77c8
// File: /workspace/github_c_makefile_star2_O1/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 0x251b0
cmpl $0x3d, 0xec791(%rip)    # 0x1118f4
jne 0x25197
incl 0xec785(%rip)           # 0x1118f0
callq 0x25ab5
decl 0xec77a(%rip)           # 0x1118f0
movq 0x1e143(%rip), %rdi     # 0x432c0
callq 0x8b01
callq 0xad38
callq 0x251b0
movl $0x3, %edi
popq %rbp
jmp 0x8ad9
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x25240
movl 0xec735(%rip), %eax     # 0x1118f4
cmpl $0x3ef, %eax            # imm = 0x3EF
jle 0x251e4
cmpl $0x3f0, %eax            # imm = 0x3F0
je 0x251f7
cmpl $0x3f2, %eax            # imm = 0x3F2
je 0x25200
cmpl $0x3f1, %eax            # imm = 0x3F1
jne 0x2523e
leaq 0x1cb26(%rip), %rax     # 0x41d08
jmp 0x25210
cmpl $0x3c, %eax
je 0x25209
cmpl $0x3e, %eax
jne 0x2523e
leaq 0x1cb0b(%rip), %rax     # 0x41d00
jmp 0x25210
leaq 0x1cafa(%rip), %rax     # 0x41cf8
jmp 0x25210
leaq 0x1cae9(%rip), %rax     # 0x41cf0
jmp 0x25210
leaq 0x1cb00(%rip), %rax     # 0x41d10
movq (%rax), %rdi
callq 0x8b01
callq 0xad38
incl 0xec6cd(%rip)           # 0x1118f0
callq 0x25ab5
decl 0xec6c2(%rip)           # 0x1118f0
callq 0x25240
movl $0x3, %edi
popq %rbp
jmp 0x8ad9
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1506b(%rip), %ebx     # 0x3a2b8
movl 0xec6a0(%rip), %r14d    # 0x1118f4
cmpl $0x2d, %r14d
je 0x25260
cmpl $0x2b, %r14d
jne 0x25271
incl 0xec68a(%rip)           # 0x1118f0
callq 0x25ab5
decl 0xec67f(%rip)           # 0x1118f0
callq 0x252c7
cmpl $0x2d, %r14d
je 0x252bb
movl 0xec671(%rip), %r14d    # 0x1118f4
cmpl $0x2d, %r14d
je 0x25260
cmpl $0x2b, %r14d
je 0x25260
movl 0x15023(%rip), %edi     # 0x3a2b8
subl %ebx, %edi
cmpl $0x2, %edi
jl 0x252c2
callq 0x8ad9
movq 0x1dff8(%rip), %rdi     # 0x432a0
callq 0x8b01
callq 0xad38
popq %rbx
popq %r14
popq %rbp
jmp 0x8b47
callq 0x25349
jmp 0x2527c
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x14fe4(%rip), %ebx     # 0x3a2b8
callq 0x254cd
callq 0x2548e
testl %eax, %eax
je 0x25318
movl 0xec60b(%rip), %r14d    # 0x1118f4
cmpl $0x2f, %r14d
je 0x252f5
cmpl $0x2a, %r14d
jne 0x25306
incl 0xec5f5(%rip)           # 0x1118f0
callq 0x25ab5
decl 0xec5ea(%rip)           # 0x1118f0
callq 0x254cd
cmpl $0x2f, %r14d
jne 0x252d9
callq 0x25513
jmp 0x252d9
movl 0x14f9a(%rip), %edi     # 0x3a2b8
subl %ebx, %edi
cmpl $0x2, %edi
jl 0x25344
callq 0x8ad9
movq 0x1df77(%rip), %rdi     # 0x432a8
callq 0x8b01
callq 0xad38
popq %rbx
popq %r14
popq %rbp
jmp 0x8b47
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8b78
movq %rax, %r14
movq %rax, %rbx
movzbl 0x10(%rax), %eax
leal -0x4(%rax), %ecx
cmpl $0x2, %ecx
jae 0x25391
movq %rbx, %rdi
callq 0x8b01
movq 0xec076(%rip), %rdi     # 0x1113f0
callq 0x8b01
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xa8bb
movq %rbx, %rcx
cmpl $0x1, %eax
je 0x253a0
leaq 0x1b660(%rip), %rcx     # 0x40a00
movq (%rcx), %r12
movq 0x1defe(%rip), %r15     # 0x432a8
movq %r15, %rdi
callq 0x8b01
cmpq %r15, %r12
je 0x253dd
movq 0xec032(%rip), %rdi     # 0x1113f0
callq 0x8b01
movq %rbx, %rdi
callq 0x8b01
movl $0x3, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8ad9
addq $0x8, %r14
cmpb $0x1, 0x10(%rbx)
leaq 0x1b614(%rip), %r15     # 0x40a00
movq %r15, %rax
cmoveq %r14, %rax
movq (%rax), %rax
movb 0x10(%rax), %cl
cmpb $0x1, %cl
movq %r15, %rdx
cmoveq %rax, %rdx
movq (%rdx), %rdx
cmpb $0x4, 0x10(%rdx)
je 0x2541f
cmpb $0x1, %cl
movq %r15, %rdx
cmoveq %rax, %rdx
movq (%rdx), %rdx
cmpb $0x5, 0x10(%rdx)
jne 0x2545d
cmpb $0x1, %cl
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x8b01
movq 0xebfbb(%rip), %rdi     # 0x1113f0
callq 0x8b01
movl $0x2, %edi
callq 0xa8bb
cmpb $0x1, 0x10(%rbx)
cmovneq %r15, %r14
movq (%r14), %rcx
leaq 0x8(%rcx), %rax
cmpb $0x1, 0x10(%rcx)
cmovneq %r15, %rax
jmp 0x25474
movq 0xebf8c(%rip), %rdi     # 0x1113f0
callq 0x8b01
cmpb $0x1, 0x10(%rbx)
cmoveq %r14, %r15
movq %r15, %rax
movq (%rax), %rdi
callq 0x8b01
callq 0x8b47
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8b47
// File: /workspace/github_c_makefile_star2_O1/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 0x2573e
cmpl $0x5e, 0xec417(%rip)    # 0x1118f4
jne 0x25511
incl 0xec40b(%rip)           # 0x1118f0
callq 0x25ab5
decl 0xec400(%rip)           # 0x1118f0
movq 0x1ddb9(%rip), %rdi     # 0x432b0
callq 0x8b01
callq 0xad38
callq 0x254cd
movl $0x3, %edi
popq %rbp
jmp 0x8ad9
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x14b6e(%rip), %ebx     # 0x3a2b8
movl 0xec1a4(%rip), %ecx     # 0x1118f4
leal -0x3e9(%rcx), %eax
cmpl $0x6, %eax
ja 0x25772
leaq 0x96a(%rip), %rcx       # 0x260cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x25a68
jmp 0x257bb
cmpl $0x28, %ecx
jne 0x25842
callq 0x2588c
jmp 0x257ce
movq 0xec16f(%rip), %rdi     # 0x1118f8
callq 0x14bf5
jmp 0x257bb
movq 0xec161(%rip), %rdi     # 0x1118f8
callq 0x70c0
movsd %xmm0, -0x10(%rbp)
callq 0x74ec
movb $0x5, 0x10(%rax)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rax, %rdi
callq 0x8b01
callq 0x25ab5
jmp 0x257ce
callq 0x259c9
jmp 0x257ce
callq 0x25954
cmpl $0x5b, 0xec11f(%rip)    # 0x1118f4
jne 0x2587c
incl 0xec10f(%rip)           # 0x1118f0
callq 0x25ab5
movq 0x1dacb(%rip), %rdi     # 0x432b8
callq 0x8b01
callq 0xad38
callq 0x25240
movl 0xec0f2(%rip), %eax     # 0x1118f4
cmpl $0x2c, %eax
jne 0x2580e
callq 0x25ab5
jmp 0x257f7
cmpl $0x5d, %eax
jne 0x25828
decl 0xec0d7(%rip)           # 0x1118f0
callq 0x25ab5
movl 0x14a94(%rip), %edi     # 0x3a2b8
subl %ebx, %edi
jmp 0x25877
movq 0xec0b9(%rip), %rax     # 0x1118e8
movq %rax, 0xec0a2(%rip)     # 0x1118d8
leaq 0x56a4(%rip), %rdi      # 0x2aee1
callq 0x77c8
movq 0xec09f(%rip), %rax     # 0x1118e8
movq %rax, 0xec088(%rip)     # 0x1118d8
leaq 0x567f(%rip), %rdi      # 0x2aed6
callq 0x77c8
callq 0x25ab5
movq 0x19898(%rip), %rdi     # 0x3f100
callq 0x8b01
callq 0xad38
movl $0x2, %edi
callq 0x8ad9
cmpl $0x21, 0xec071(%rip)    # 0x1118f4
je 0x2585c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x14a1b(%rip), %r14d    # 0x3a2b8
movslq %r14d, %r15
incl 0xec04a(%rip)           # 0x1118f0
callq 0x25ab5
callq 0x25153
movl 0xec03e(%rip), %eax     # 0x1118f4
cmpl $0x2c, %eax
je 0x258a6
cmpl $0x29, %eax
jne 0x2593a
decl 0xec02a(%rip)           # 0x1118f0
callq 0x25ab5
movl 0x149e7(%rip), %ebx     # 0x3a2b8
subl %r14d, %ebx
cmpl $0x2, %ebx
jge 0x258e4
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %ebx, %edi
callq 0x7850
movq (%rax), %rcx
movl $0x1, (%rcx)
movq (%rax), %rcx
movl %ebx, 0x4(%rcx)
movl %ebx, %ecx
shlq $0x3, %r15
xorl %edx, %edx
leaq 0x1dcb7(%rip), %rsi     # 0x435c0
leaq (%r15,%rdx,8), %rdi
movq (%rsi,%rdi), %rdi
movq (%rax), %r8
movq %rdi, 0x68(%r8,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x25909
movl %r14d, 0x14990(%rip)    # 0x3a2b8
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8b01
movq 0xebfa7(%rip), %rax     # 0x1118e8
movq %rax, 0xebf90(%rip)     # 0x1118d8
leaq 0x559f(%rip), %rdi      # 0x2aeee
callq 0x77c8
// File: /workspace/github_c_makefile_star2_O1/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, 0xebf7f(%rip)     # 0x1118e0
je 0x25993
movq 0xebf8e(%rip), %rbx     # 0x1118f8
movq %rbx, %rdi
callq 0x70e0
cmpq $0x1, %rax
jne 0x25993
movzbl (%rbx), %eax
cmpl $0x78, %eax
je 0x259bb
cmpl $0x62, %eax
je 0x259b2
cmpl $0x61, %eax
jne 0x259c4
movq 0x1d93f(%rip), %rdi     # 0x432d0
jmp 0x259a2
movq 0xebf5e(%rip), %rdi     # 0x1118f8
callq 0x25af2
movq %rax, %rdi
callq 0x8b01
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x25ab5
movq 0x1d91f(%rip), %rdi     # 0x432d8
jmp 0x259a2
movq 0x1d91e(%rip), %rdi     # 0x432e0
jmp 0x259a2
movq %rbx, %rdi
jmp 0x2599a
// File: /workspace/github_c_makefile_star2_O1/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 0x148e3(%rip), %ebx     # 0x3a2b8
incl 0xebf15(%rip)           # 0x1118f0
movq 0xebf16(%rip), %rdi     # 0x1118f8
callq 0x25af2
movq %rax, %rdi
callq 0x8b01
callq 0x25ab5
callq 0x25ab5
cmpl $0x29, 0xebef4(%rip)    # 0x1118f4
jne 0x25a14
decl 0xebee8(%rip)           # 0x1118f0
callq 0x25ab5
movl $0x1, %edi
jmp 0x25a43
callq 0x25153
movl 0xebed5(%rip), %eax     # 0x1118f4
cmpl $0x2c, %eax
jne 0x25a2b
callq 0x25ab5
jmp 0x25a14
cmpl $0x29, %eax
jne 0x25a4e
decl 0xebeba(%rip)           # 0x1118f0
callq 0x25ab5
movl 0x14877(%rip), %edi     # 0x3a2b8
subl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8ad9
movq 0xebe93(%rip), %rax     # 0x1118e8
movq %rax, 0xebe7c(%rip)     # 0x1118d8
leaq 0x548b(%rip), %rdi      # 0x2aeee
callq 0x77c8
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]eigenmath/eigenmath.c
// Function: scan_integer
void
scan_integer(void)
{
	int sign;
	uint32_t *a;
	switch (*token_buf) {
	case '+':
		sign = MPLUS;
		a = mscan(token_buf + 1);
		break;
	case '-':
		sign = MMINUS;
		a = mscan(token_buf + 1);
		break;
	default:
		sign = MPLUS;
		a = mscan(token_buf);
		break;
	}
	push_bignum(sign, a, mint(1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0xebe82(%rip), %rdi     # 0x1118f8
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x25a8a
xorl %ebx, %ebx
cmpl $0x2b, %eax
jne 0x25a92
incq %rdi
jmp 0x25a92
incq %rdi
movl $0x1, %ebx
callq 0x7985
movq %rax, %r14
movl $0x1, %edi
callq 0x7ad5
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0xb9f7