LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
jne 0x3e29a
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq 0x68(%rax,%rcx,8), %rdi
callq 0x36c50
jmp 0x3e365
movl $0x1, -0x24(%rbp)
movl -0xc(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
jge 0x3e2d9
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movl 0x4(%rax,%rcx,4), %eax
imull -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3e2aa
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl 0x4(%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x3e35a
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3e34d
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
addl $0x2, %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %eax
imull -0x1c(%rbp), %eax
addl -0x18(%rbp), %eax
imull -0x24(%rbp), %eax
addl %eax, %edx
callq 0x3e260
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3e318
jmp 0x3e34f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3e309
movl -0x20(%rbp), %edi
movl -0x1c(%rbp), %esi
callq 0x3e370
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x31, -0x1c(%rbp)
jge 0x3f3f7
movslq -0x1c(%rbp), %rcx
leaq 0x17db9(%rip), %rax     # 0x57170
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x70e0
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
movq -0x28(%rbp), %rsi
movslq -0x20(%rbp), %rdx
callq 0x7080
cmpl $0x0, %eax
jne 0x3f3ea
jmp 0x3f3f7
jmp 0x3f3ec
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3f3a6
cmpl $0x31, -0x1c(%rbp)
jne 0x3f419
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x39140
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x3f43b
movslq -0x1c(%rbp), %rcx
leaq 0x17edc(%rip), %rax     # 0x57300
movl (%rax,%rcx,4), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %edi
callq 0x39140
movl -0x14(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movl $0x1, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x407ff
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movl 0x4(%rax,%rcx,4), %eax
imull -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x407d6
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x4(%rax), %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x4083b
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
imull -0x14(%rbp), %edx
movl $0x1, %esi
callq 0x3e260
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x40813
movl -0x10(%rbp), %edi
movl $0x1, %esi
callq 0x3e370
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9c10
cmpl $0x0, %eax
je 0x40878
movq -0x8(%rbp), %rdi
callq 0x3cfe0
jmp 0x409d3
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x40893
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x4089e
movq 0x1e166(%rip), %rax     # 0x5ea00
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x408c0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x408cb
movq 0x1e139(%rip), %rax     # 0x5ea00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10770
cmpl $0x0, %eax
je 0x40907
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x408f4
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x408ff
movq 0x1e105(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x40921
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x4092c
movq 0x1e0d8(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x3a600
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x40950
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x4095b
movq 0x1e0a9(%rip), %rax     # 0x5ea00
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x409d3
callq 0x3a580
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x4098f
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x4099a
movq 0x1e06a(%rip), %rax     # 0x5ea00
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3a600
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x409be
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x409c9
movq 0x1e03b(%rip), %rax     # 0x5ea00
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x40963
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
cmpl $0x1, -0xc(%rbp)
jg 0x40a54
cmpl $0x0, -0x10(%rbp)
jle 0x40a7e
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
callq 0x41930
movl -0x4(%rbp), %edi
addl -0x14(%rbp), %edi
subl $0x1, %edi
movl -0x8(%rbp), %esi
movl -0xc(%rbp), %edx
movl -0x10(%rbp), %ecx
callq 0x419b0
jmp 0x40aa4
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl $0x28, %edx
callq 0x409e0
movl -0x4(%rbp), %edi
addl -0x14(%rbp), %edi
subl $0x1, %edi
movl -0x8(%rbp), %esi
movl $0x29, %edx
callq 0x409e0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
subl -0xc(%rbp), %esi
addl $0x1, %esi
movl $0xe2948c, %edx         # imm = 0xE2948C
callq 0x409e0
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0xc(%rbp), %ecx
addl -0x10(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x41995
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
subl -0xc(%rbp), %esi
addl $0x1, %esi
addl -0x14(%rbp), %esi
movl $0xe29482, %edx         # imm = 0xE29482
callq 0x409e0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x41961
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
addl -0x10(%rbp), %esi
movl $0xe29494, %edx         # imm = 0xE29494
callq 0x409e0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
subl -0xc(%rbp), %esi
addl $0x1, %esi
movl $0xe29490, %edx         # imm = 0xE29490
callq 0x409e0
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl -0xc(%rbp), %ecx
addl -0x10(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x41a15
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
subl -0xc(%rbp), %esi
addl $0x1, %esi
addl -0x14(%rbp), %esi
movl $0xe29482, %edx         # imm = 0xE29482
callq 0x409e0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x419e1
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
addl -0x10(%rbp), %esi
movl $0xe29498, %edx         # imm = 0xE29498
callq 0x409e0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x41a48
jmp 0x41ae4
jmp 0x41a4a
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x41a88
movq -0x8(%rbp), %rax
movzbl 0x11(%rax), %eax
cmpl $0x0, %eax
jne 0x41a66
jmp 0x41ae4
movq -0x8(%rbp), %rax
movb $0x0, 0x11(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x41a30
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x41a4a
movq -0x8(%rbp), %rax
movzbl 0x11(%rax), %eax
cmpl $0x0, %eax
jne 0x41a97
jmp 0x41ae4
movq -0x8(%rbp), %rax
movb $0x0, 0x11(%rax)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x7, %eax
jne 0x41ae4
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x64(%rcx), %eax
jge 0x41ae2
movq -0x8(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq 0x68(%rax,%rcx,8), %rdi
callq 0x41a30
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x41ab3
jmp 0x41ae4
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x41b31
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x41b60
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x41b0d
movq 0xf498(%rip), %rax      # 0x50fd0
movq (%rax), %rdi
callq 0x7230
movl %eax, %edi
callq 0x70b0
cmpl $0x0, %eax
je 0x41b51
callq 0x41bc0
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30680
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x41ba6
movq 0xf471(%rip), %rax      # 0x50ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x80ee(%rip), %rsi      # 0x49c83
movb $0x0, %al
callq 0x71f0
movl $0x1, %edi
callq 0x7320
movq -0x10(%rbp), %rdi
callq 0x41c20
movq -0x10(%rbp), %rdi
callq 0x7040
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
jmp 0x41bc6
movq 0xf403(%rip), %rax      # 0x50fd0
movq (%rax), %rsi
leaq 0x3795(%rip), %rdi      # 0x4536c
callq 0x7120
movq 0xf3ed(%rip), %rax      # 0x50fd0
movq (%rax), %rdi
callq 0x7270
movq 0xf3e6(%rip), %rax      # 0x50fd8
movq (%rax), %rdx
leaq 0xed814(%rip), %rdi     # 0x12f410
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x71b0
leaq 0xed803(%rip), %rdi     # 0x12f410
callq 0x41c20
jmp 0x41bc6
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xedbcd(%rip), %rdi     # 0x12f800
callq 0x71c0
cmpl $0x0, %eax
je 0x41c42
jmp 0x41d9e
movl $0x0, 0x1666c(%rip)     # 0x582b8
movl $0x0, 0xe2e72(%rip)     # 0x124ac8
movl $0x0, 0xe2e64(%rip)     # 0x124ac4
movl $0x0, 0xe2e56(%rip)     # 0x124ac0
movl $0x1, 0xe2e5c(%rip)     # 0x124ad0
movl $0x0, 0xedc4a(%rip)     # 0x12f8c8
movl $0x0, 0xed73c(%rip)     # 0x12f3c4
movl $0x0, 0xed72e(%rip)     # 0x12f3c0
movl $0x0, 0xe2e4c(%rip)     # 0x124ae8
cmpq $0x0, 0x1a49c(%rip)     # 0x5c140
jne 0x41d95
xorl %eax, %eax
movl %eax, %edi
callq 0x7220
movl %eax, %edi
callq 0x71a0
callq 0x42ab0
xorl %edi, %edi
callq 0x7d10
movq %rax, -0x20(%rbp)
movl $0x1, %edi
callq 0x7d10
movq -0x20(%rbp), %rsi
movq %rax, %rdx
xorl %edi, %edi
callq 0xe740
callq 0x91d0
movq %rax, 0x1a452(%rip)     # 0x5c140
movl $0x1, %edi
callq 0x7d10
movq %rax, -0x18(%rbp)
movl $0x1, %edi
callq 0x7d10
movq -0x18(%rbp), %rsi
movq %rax, %rdx
xorl %edi, %edi
callq 0xe740
callq 0x91d0
movq %rax, 0xe2db8(%rip)     # 0x124ad8
movl $0x1, %edi
callq 0x7d10
movq %rax, -0x10(%rbp)
movl $0x1, %edi
callq 0x7d10
movq -0x10(%rbp), %rsi
movq %rax, %rdx
movl $0x1, %edi
callq 0xe740
callq 0x91d0
movq %rax, 0xed69b(%rip)     # 0x12f3f0
movq 0x1f554(%rip), %rdi     # 0x612b0
callq 0x9110
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0xca50
movl $0x1, %edi
movl $0x2, %esi
callq 0xb840
movl $0x3, %edi
callq 0x90d0
callq 0x91d0
movq %rax, 0xe2d50(%rip)     # 0x124ae0
callq 0x12d50
movq -0x8(%rbp), %rdi
callq 0x307a0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x41e16
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x41e21
movq 0x1cbe3(%rip), %rax     # 0x5ea00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq 0x1f474(%rip), %rax     # 0x612a0
jne 0x41ee2
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x41e4d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x41e58
movq 0x1cbac(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x41ed9
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x41e87
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x41e92
movq 0x1cb72(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x42030
cmpl $0x0, %eax
je 0x41ea9
movl $0x1, -0x4(%rbp)
jmp 0x41eee
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x41ec4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x41ecf
movq 0x1cb35(%rip), %rax     # 0x5ea00
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x41e60
movl $0x0, -0x4(%rbp)
jmp 0x41eee
movq -0x10(%rbp), %rdi
callq 0x42030
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: 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
subq $0x40, %rsp
callq 0x91d0
movq %rax, -0x18(%rbp)
callq 0x91d0
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x41f34
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x41f3f
movq 0x1cac5(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq 0x1f356(%rip), %rax     # 0x612a0
jne 0x42010
movl 0x16362(%rip), %eax     # 0x582b8
movl %eax, -0x4(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x41f74
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x41f7f
movq 0x1ca85(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x42000
movq -0x10(%rbp), %rdi
callq 0x9110
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x41fb7
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x41fc2
movq 0x1ca42(%rip), %rax     # 0x5ea00
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x9110
callq 0xc280
movq -0x18(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x41feb
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x41ff6
movq 0x1ca0e(%rip), %rax     # 0x5ea00
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x41f87
movl 0x162b2(%rip), %edi     # 0x582b8
subl -0x4(%rbp), %edi
callq 0xc520
jmp 0x42027
movq -0x10(%rbp), %rdi
callq 0x9110
movq -0x18(%rbp), %rdi
callq 0x9110
callq 0xc280
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x42056
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x42061
movq 0x1c9a3(%rip), %rax     # 0x5ea00
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq 0x1f23c(%rip), %rax     # 0x612a8
jne 0x42122
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x4208d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x42098
movq 0x1c96c(%rip), %rax     # 0x5ea00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x42119
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x420c7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x420d2
movq 0x1c932(%rip), %rax     # 0x5ea00
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x42140
cmpl $0x0, %eax
je 0x420e9
movl $0x1, -0x4(%rbp)
jmp 0x4212e
movq -0x10(%rbp), %rax
movzbl 0x10(%rax), %eax
cmpl $0x1, %eax
jne 0x42104
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x4210f
movq 0x1c8f5(%rip), %rax     # 0x5ea00
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x420a0
movl $0x0, -0x4(%rbp)
jmp 0x4212e
movq -0x10(%rbp), %rdi
callq 0x42140
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: 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
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
cmpl $0xa8c, -0x4(%rbp)      # imm = 0xA8C
jge 0x42b0c
movslq -0x4(%rbp), %rcx
leaq 0x1968d(%rip), %rax     # 0x5c160
movq $0x0, (%rax,%rcx,8)
movslq -0x4(%rbp), %rcx
leaq 0xe200a(%rip), %rax     # 0x124af0
movq $0x0, (%rax,%rcx,8)
movslq -0x4(%rbp), %rcx
leaq 0xe7457(%rip), %rax     # 0x129f50
movq $0x0, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x42abf
movl $0x9d, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x42c2a
callq 0x74b0
movq %rax, -0x18(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x14896(%rip), %rax     # 0x573d0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x7350
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x42b5e
movl $0x1, %edi
callq 0x7320
movslq -0x4(%rbp), %rcx
leaq 0x14867(%rip), %rax     # 0x573d0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
je 0x42bb9
movq -0x18(%rbp), %rax
movb $0x2, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movslq -0x4(%rbp), %rcx
leaq 0x1483b(%rip), %rax     # 0x573d0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl 0xec836(%rip), %eax     # 0x12f3e4
addl $0x1, %eax
movl %eax, 0xec82d(%rip)     # 0x12f3e4
jmp 0x42bf7
movq -0x18(%rbp), %rax
movb $0x3, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movslq -0x4(%rbp), %rcx
leaq 0x147f9(%rip), %rax     # 0x573d0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl 0xec7fa(%rip), %eax     # 0x12f3e8
addl $0x1, %eax
movl %eax, 0xec7f1(%rip)     # 0x12f3e8
movq -0x18(%rbp), %rdx
movslq -0x4(%rbp), %rcx
leaq 0x147ca(%rip), %rax     # 0x573d0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movslq 0x8(%rax), %rcx
leaq 0x19548(%rip), %rax     # 0x5c160
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x42b1a
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, 0xecc89(%rip)     # 0x12f8d0
movq -0x8(%rbp), %rdi
callq 0x42ca0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, 0xecc79(%rip)     # 0x12f8d8
movq 0x1d0ba(%rip), %rdi     # 0x5fd20
callq 0x128e0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x1d0a6(%rip), %rax     # 0x5fd20
je 0x42c94
movq -0x10(%rbp), %rdi
callq 0xcdc0
cmpl $0x0, %eax
jne 0x42c94
movl $0x1, %edi
callq 0x42cd0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
cmpq $0x0, 0xecbed(%rip)     # 0x12f8d0
je 0x42cef
cmpq $0x0, 0xecbeb(%rip)     # 0x12f8d8
jne 0x42cf4
jmp 0x42d74
callq 0x1ee80
movb $0xa, -0x5(%rbp)
movq 0xecbcc(%rip), %rax     # 0x12f8d0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x11(%rbp)
je 0x42d2a
movq -0x10(%rbp), %rax
cmpq 0xecbb4(%rip), %rax     # 0x12f8d8
setb %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x42d33
jmp 0x42d52
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %edi
callq 0x21f60
jmp 0x42d08
movsbl -0x5(%rbp), %eax
cmpl $0xa, %eax
je 0x42d65
movl $0xa, %edi
callq 0x21f60
movq 0xec65c(%rip), %rdi     # 0x12f3c8
movl -0x4(%rbp), %esi
callq 0x1f110
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, 0xecb51(%rip)     # 0x12f8e8
movl $0x0, 0xecb4f(%rip)     # 0x12f8f0
callq 0x42e00
cmpl $0x3f3, 0xecb44(%rip)   # imm = 0x3F3
jne 0x42dbc
movq $0x0, -0x8(%rbp)
jmp 0x42df0
callq 0x42e30
cmpl $0x3ee, 0xecb29(%rip)   # imm = 0x3EE
je 0x42de5
cmpl $0x3f3, 0xecb1d(%rip)   # imm = 0x3F3
je 0x42de5
leaq 0x70c6(%rip), %rdi      # 0x49ea6
callq 0x42e70
movq 0xecafc(%rip), %rax     # 0x12f8e8
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0x42ea0
cmpl $0x3d, 0xecab4(%rip)    # 0x12f8f4
jne 0x42e67
callq 0x42e00
movq 0x1e472(%rip), %rdi     # 0x612c0
callq 0x9110
callq 0xcb10
callq 0x42ea0
movl $0x3, %edi
callq 0x90d0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
callq 0x42f60
movl 0xeca41(%rip), %eax     # 0x12f8f4
movl %eax, -0x4(%rbp)
subl $0x3c, %eax
je 0x42f15
jmp 0x42ebd
movl -0x4(%rbp), %eax
subl $0x3e, %eax
je 0x42f23
jmp 0x42ec7
movl -0x4(%rbp), %eax
subl $0x3f0, %eax            # imm = 0x3F0
je 0x42f07
jmp 0x42ed3
movl -0x4(%rbp), %eax
subl $0x3f1, %eax            # imm = 0x3F1
je 0x42ef9
jmp 0x42edf
movl -0x4(%rbp), %eax
subl $0x3f2, %eax            # imm = 0x3F2
jne 0x42f31
jmp 0x42eeb
movq 0x1cdfe(%rip), %rdi     # 0x5fcf0
callq 0x9110
jmp 0x42f33
movq 0x1ce08(%rip), %rdi     # 0x5fd08
callq 0x9110
jmp 0x42f33
movq 0x1cdea(%rip), %rdi     # 0x5fcf8
callq 0x9110
jmp 0x42f33
movq 0x1cdf4(%rip), %rdi     # 0x5fd10
callq 0x9110
jmp 0x42f33
movq 0x1cdd6(%rip), %rdi     # 0x5fd00
callq 0x9110
jmp 0x42f33
jmp 0x42f4c
callq 0xcb10
callq 0x42e00
callq 0x42f60
movl $0x3, %edi
callq 0x90d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl 0x1534a(%rip), %eax     # 0x582b8
movl %eax, -0x4(%rbp)
movl 0xec97d(%rip), %eax     # 0x12f8f4
movl %eax, -0x8(%rbp)
cmpl $0x2b, 0xec973(%rip)    # 0x12f8f4
je 0x42f8c
cmpl $0x2d, 0xec96a(%rip)    # 0x12f8f4
jne 0x42f91
callq 0x42e00
callq 0x43020
cmpl $0x2d, -0x8(%rbp)
jne 0x42fa1
callq 0x430b0
jmp 0x42fa3
movb $0x1, %al
cmpl $0x2b, 0xec948(%rip)    # 0x12f8f4
movb %al, -0x9(%rbp)
je 0x42fbe
cmpl $0x2d, 0xec93c(%rip)    # 0x12f8f4
sete %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x42fc7
jmp 0x42fe7
movl 0xec927(%rip), %eax     # 0x12f8f4
movl %eax, -0x8(%rbp)
callq 0x42e00
callq 0x43020
cmpl $0x2d, -0x8(%rbp)
jne 0x42fe5
callq 0x430b0
jmp 0x42fa3
movl 0x152cb(%rip), %eax     # 0x582b8
subl -0x4(%rbp), %eax
cmpl $0x1, %eax
jle 0x43019
movl 0x152bd(%rip), %edi     # 0x582b8
subl -0x4(%rbp), %edi
callq 0x90d0
movq 0x1e296(%rip), %rdi     # 0x612a0
callq 0x9110
callq 0xcb10
callq 0x9180
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl 0x1528a(%rip), %eax     # 0x582b8
movl %eax, -0x4(%rbp)
callq 0x43410
callq 0x433b0
cmpl $0x0, %eax
je 0x43072
movl 0xec8ae(%rip), %eax     # 0x12f8f4
movl %eax, -0x8(%rbp)
cmpl $0x2a, 0xec8a4(%rip)    # 0x12f8f4
je 0x4305b
cmpl $0x2f, 0xec89b(%rip)    # 0x12f8f4
jne 0x43060
callq 0x42e00
callq 0x43410
cmpl $0x2f, -0x8(%rbp)
jne 0x43070
callq 0x43450
jmp 0x43036
movl 0x15240(%rip), %eax     # 0x582b8
subl -0x4(%rbp), %eax
cmpl $0x1, %eax
jle 0x430a4
movl 0x15232(%rip), %edi     # 0x582b8
subl -0x4(%rbp), %edi
callq 0x90d0
movq 0x1e213(%rip), %rdi     # 0x612a8
callq 0x9110
callq 0xcb10
callq 0x9180
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: another_factor_pending
int
another_factor_pending(void)
{
	switch (token) {
	case '*':
	case '/':
	case '(':
	case T_SYMBOL:
	case T_FUNCTION:
	case T_INTEGER:
	case T_DOUBLE:
	case T_STRING:
		return 1;
	default:
		break;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0xec53a(%rip), %eax     # 0x12f8f4
movl %eax, -0x8(%rbp)
subl $0x28, %eax
je 0x433f3
jmp 0x433c4
movl -0x8(%rbp), %eax
subl $0x2a, %eax
je 0x433f3
jmp 0x433ce
movl -0x8(%rbp), %eax
subl $0x2f, %eax
je 0x433f3
jmp 0x433d8
movl -0x8(%rbp), %eax
addl $0xfffffc17, %eax       # imm = 0xFFFFFC17
subl $0x4, %eax
jb 0x433f3
jmp 0x433e7
movl -0x8(%rbp), %eax
subl $0x3ef, %eax            # imm = 0x3EF
jne 0x433fc
jmp 0x433f3
movl $0x1, -0x4(%rbp)
jmp 0x43405
jmp 0x433fe
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 0x43a10
cmpl $0x5e, 0xec4d4(%rip)    # 0x12f8f4
jne 0x43447
callq 0x42e00
movq 0x1de82(%rip), %rdi     # 0x612b0
callq 0x9110
callq 0xcb10
callq 0x43410
movl $0x3, %edi
callq 0x90d0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl 0x1489a(%rip), %eax     # 0x582b8
movl %eax, -0x4(%rbp)
movl 0xebecd(%rip), %eax     # 0x12f8f4
movl %eax, -0x8(%rbp)
subl $0x28, %eax
je 0x43a6d
jmp 0x43a31
movl -0x8(%rbp), %eax
subl $0x3e9, %eax            # imm = 0x3E9
je 0x43a82
jmp 0x43a3d
movl -0x8(%rbp), %eax
subl $0x3ea, %eax            # imm = 0x3EA
je 0x43a8e
jmp 0x43a49
movl -0x8(%rbp), %eax
subl $0x3eb, %eax            # imm = 0x3EB
je 0x43a74
jmp 0x43a55
movl -0x8(%rbp), %eax
subl $0x3ec, %eax            # imm = 0x3EC
je 0x43a7b
jmp 0x43a61
movl -0x8(%rbp), %eax
subl $0x3ef, %eax            # imm = 0x3EF
je 0x43aa6
jmp 0x43aad
callq 0x43b70
jmp 0x43ab9
callq 0x43c50
jmp 0x43ab9
callq 0x43d00
jmp 0x43ab9
callq 0x43dc0
callq 0x43e70
jmp 0x43ab9
movq 0xebe63(%rip), %rdi     # 0x12f8f8
callq 0x70c0
callq 0xe5e0
callq 0x43e70
jmp 0x43ab9
callq 0x43ea0
jmp 0x43ab9
leaq 0x63f2(%rip), %rdi      # 0x49ea6
callq 0x42e70
cmpl $0x5b, 0xebe34(%rip)    # 0x12f8f4
jne 0x43b38
movl 0xebe28(%rip), %eax     # 0x12f8f0
addl $0x1, %eax
movl %eax, 0xebe1f(%rip)     # 0x12f8f0
callq 0x43e70
movq 0x1d7db(%rip), %rdi     # 0x612b8
callq 0x9110
callq 0xcb10
callq 0x42f60
cmpl $0x2c, 0xebe01(%rip)    # 0x12f8f4
jne 0x43b01
callq 0x43e70
callq 0x42f60
jmp 0x43aec
cmpl $0x5d, 0xebdec(%rip)    # 0x12f8f4
je 0x43b16
leaq 0x63a0(%rip), %rdi      # 0x49eb1
callq 0x42e70
movl 0xebdd4(%rip), %eax     # 0x12f8f0
addl $-0x1, %eax
movl %eax, 0xebdcb(%rip)     # 0x12f8f0
callq 0x43e70
movl 0x14788(%rip), %edi     # 0x582b8
subl -0x4(%rbp), %edi
callq 0x90d0
jmp 0x43b3a
cmpl $0x21, 0xebdb3(%rip)    # 0x12f8f4
jne 0x43b65
callq 0x43e70
movq 0x195b1(%rip), %rdi     # 0x5d100
callq 0x9110
callq 0xcb10
movl $0x2, %edi
callq 0x90d0
jmp 0x43b3a
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl 0x1473a(%rip), %eax     # 0x582b8
movl %eax, -0x4(%rbp)
movl 0xebd69(%rip), %eax     # 0x12f8f0
addl $0x1, %eax
movl %eax, 0xebd60(%rip)     # 0x12f8f0
callq 0x43e70
callq 0x42e30
cmpl $0x2c, 0xebd53(%rip)    # 0x12f8f4
jne 0x43baf
callq 0x43e70
callq 0x42e30
jmp 0x43b9a
cmpl $0x29, 0xebd3e(%rip)    # 0x12f8f4
je 0x43bc4
leaq 0x62ff(%rip), %rdi      # 0x49ebe
callq 0x42e70
movl 0xebd26(%rip), %eax     # 0x12f8f0
addl $-0x1, %eax
movl %eax, 0xebd1d(%rip)     # 0x12f8f0
callq 0x43e70
movl 0x146da(%rip), %eax     # 0x582b8
subl -0x4(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0x2, -0xc(%rbp)
jge 0x43bec
jmp 0x43c48
movl -0xc(%rbp), %edi
callq 0x7970
movq %rax, -0x18(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x43c36
movl -0x4(%rbp), %eax
addl -0x8(%rbp), %eax
movslq %eax, %rcx
leaq 0x1d9a9(%rip), %rax     # 0x615c0
movq (%rax,%rcx,8), %rdx
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x8(%rbp), %rcx
movq %rdx, 0x68(%rax,%rcx,8)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x43bff
movl -0x4(%rbp), %eax
movl %eax, 0x14679(%rip)     # 0x582b8
movq -0x18(%rbp), %rdi
callq 0x9110
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
cmpl $0x0, 0xebc81(%rip)     # 0x12f8e0
je 0x43cdb
movq 0xebc90(%rip), %rdi     # 0x12f8f8
callq 0x70e0
cmpq $0x1, %rax
jne 0x43cdb
movq 0xebc7e(%rip), %rax     # 0x12f8f8
movsbl (%rax), %eax
movl %eax, -0x4(%rbp)
subl $0x61, %eax
je 0x43c9b
jmp 0x43c87
movl -0x4(%rbp), %eax
subl $0x62, %eax
je 0x43ca9
jmp 0x43c91
movl -0x4(%rbp), %eax
subl $0x78, %eax
je 0x43cb7
jmp 0x43cc5
movq 0x1d62e(%rip), %rdi     # 0x612d0
callq 0x9110
jmp 0x43cd9
movq 0x1d628(%rip), %rdi     # 0x612d8
callq 0x9110
jmp 0x43cd9
movq 0x1d622(%rip), %rdi     # 0x612e0
callq 0x9110
jmp 0x43cd9
movq 0xebc2c(%rip), %rdi     # 0x12f8f8
callq 0x43ec0
movq %rax, %rdi
callq 0x9110
jmp 0x43cef
movq 0xebc16(%rip), %rdi     # 0x12f8f8
callq 0x43ec0
movq %rax, %rdi
callq 0x9110
callq 0x43e70
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl 0x145aa(%rip), %eax     # 0x582b8
movl %eax, -0x4(%rbp)
movl 0xebbd9(%rip), %eax     # 0x12f8f0
addl $0x1, %eax
movl %eax, 0xebbd0(%rip)     # 0x12f8f0
movq 0xebbd1(%rip), %rdi     # 0x12f8f8
callq 0x43ec0
movq %rax, %rdi
callq 0x9110
callq 0x43e70
callq 0x43e70
cmpl $0x29, 0xebbaf(%rip)    # 0x12f8f4
jne 0x43d67
movl 0xebba3(%rip), %eax     # 0x12f8f0
addl $-0x1, %eax
movl %eax, 0xebb9a(%rip)     # 0x12f8f0
callq 0x43e70
movl $0x1, %edi
callq 0x90d0
jmp 0x43db8
callq 0x42e30
cmpl $0x2c, 0xebb81(%rip)    # 0x12f8f4
jne 0x43d81
callq 0x43e70
callq 0x42e30
jmp 0x43d6c
cmpl $0x29, 0xebb6c(%rip)    # 0x12f8f4
je 0x43d96
leaq 0x612d(%rip), %rdi      # 0x49ebe
callq 0x42e70
movl 0xebb54(%rip), %eax     # 0x12f8f0
addl $-0x1, %eax
movl %eax, 0xebb4b(%rip)     # 0x12f8f0
callq 0x43e70
movl 0x14508(%rip), %edi     # 0x582b8
subl -0x4(%rbp), %edi
callq 0x90d0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq 0xebb29(%rip), %rax     # 0x12f8f8
movsbl (%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x2b, %eax
je 0x43de6
jmp 0x43ddc
movl -0x14(%rbp), %eax
subl $0x2d, %eax
je 0x43e03
jmp 0x43e20
movl $0x0, -0x4(%rbp)
movq 0xebb04(%rip), %rdi     # 0x12f8f8
addq $0x1, %rdi
callq 0x7ba0
movq %rax, -0x10(%rbp)
jmp 0x43e37
movl $0x1, -0x4(%rbp)
movq 0xebae7(%rip), %rdi     # 0x12f8f8
addq $0x1, %rdi
callq 0x7ba0
movq %rax, -0x10(%rbp)
jmp 0x43e37
movl $0x0, -0x4(%rbp)
movq 0xebaca(%rip), %rdi     # 0x12f8f8
callq 0x7ba0
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x1, %edi
callq 0x7d10
movl -0x24(%rbp), %edi
movq -0x20(%rbp), %rsi
movq %rax, %rdx
callq 0xe740
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]eigenmath/eigenmath.c
// Function: get_token
void
get_token(void)
{
	get_token_nib();
	if (scan_level)
		while (token == T_NEWLINE)
			get_token_nib();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x44040
cmpl $0x0, 0xeba70(%rip)     # 0x12f8f0
je 0x43e99
jmp 0x43e84
cmpl $0x3ee, 0xeba66(%rip)   # imm = 0x3EE
jne 0x43e97
callq 0x44040
jmp 0x43e84
jmp 0x43e99
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
callq 0x7390
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x100, %eax            # imm = 0x100
cmpl $0x0, %eax
je 0x43efe
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
subl $0x41, %eax
imull $0x64, %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x43f39
callq 0x7390
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x200, %eax            # imm = 0x200
cmpl $0x0, %eax
je 0x43f30
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
subl $0x61, %eax
imull $0x64, %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x43f37
movl $0xa28, -0x18(%rbp)     # imm = 0xA28
jmp 0x43f39
movl $0x0, -0x14(%rbp)
cmpl $0x64, -0x14(%rbp)
jge 0x43fa3
movl -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
movslq %eax, %rcx
leaq 0x1820a(%rip), %rax     # 0x5c160
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x43f67
jmp 0x43fa3
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x9870
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x71e0
cmpl $0x0, %eax
jne 0x43f96
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4402b
jmp 0x43f98
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x43f40
cmpl $0x64, -0x14(%rbp)
jne 0x43fb5
leaq 0x5f86(%rip), %rdi      # 0x49f36
callq 0x78d0
callq 0x74b0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7350
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x43fdc
movl $0x1, %edi
callq 0x7320
movq -0x20(%rbp), %rax
movb $0x3, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0x18(%rbp), %ecx
addl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rdx
movl -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
movslq %eax, %rcx
leaq 0x18150(%rip), %rax     # 0x5c160
movq %rdx, (%rax,%rcx,8)
movl 0xeb3ce(%rip), %eax     # 0x12f3e8
addl $0x1, %eax
movl %eax, 0xeb3c5(%rip)     # 0x12f3e8
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl $0x3e8, %ecx            # imm = 0x3E8
cltd
idivl %ecx
addl $0x1, %eax
imull $0x3e8, %eax, %eax      # imm = 0x3E8
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0xeb35a(%rip), %eax     # 0x12f908
jle 0x445de
cmpq $0x0, 0xeb340(%rip)     # 0x12f8f8
je 0x445c6
movq 0xeb337(%rip), %rdi     # 0x12f8f8
callq 0x7040
movl -0x14(%rbp), %edi
callq 0x7930
movq %rax, 0xeb323(%rip)     # 0x12f8f8
movl -0x14(%rbp), %eax
movl %eax, 0xeb32a(%rip)     # 0x12f908
movq 0xeb313(%rip), %rdi     # 0x12f8f8
movq -0x8(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0x7070
movq 0xeb2ff(%rip), %rax     # 0x12f8f8
movslq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
addq $0x20, %rsp
popq %rbp
retq