LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/alexgirao[P]aimant/str.c
// Function: str_shiftl
void str_shiftl(struct str *s, int start, int end, int n, int pad)
{
  int i, window_size;
  char *ss;

  if (start < 0) {
    start = s->len + start;
  }

  if (end < 0) {
    end = s->len + end;
  }

  assert(n >= 0);
  assert(start >= 0);
  assert(start <= s->len);

  window_size = end - start;

  assert(end >= 0);
  assert(start <= end);
  assert(n <= window_size);

  assert(end <= s->len);

  ss = s->s + start;
  bcopyl(ss, window_size - n, ss + n);

  ss += window_size - n;
  for (i=0; i<n; i++) {
    ss[i] = pad;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %esi, %esi
jns 0xa494
addl 0x8(%rdi), %esi
testl %edx, %edx
jns 0xa49b
addl 0x8(%rdi), %edx
testl %ecx, %ecx
js 0xa517
testl %esi, %esi
js 0xa536
movl 0x8(%rdi), %eax
cmpl %eax, %esi
jg 0xa555
testl %edx, %edx
js 0xa574
cmpl %esi, %edx
jb 0xa593
movl %edx, %r9d
subl %esi, %r9d
cmpl %ecx, %r9d
jl 0xa5b2
cmpl %eax, %edx
ja 0xa5d1
movl %esi, %eax
addq (%rdi), %rax
movl %ecx, %edx
subl %ecx, %r9d
je 0xa4ff
leaq (%rax,%rdx), %rsi
movl %r9d, %edi
xorl %r10d, %r10d
movb (%rsi,%r10), %r11b
movb %r11b, (%rax,%r10)
incq %r10
cmpl %r10d, %edi
jne 0xa4ef
testl %ecx, %ecx
je 0xa515
movslq %r9d, %rcx
addq %rcx, %rax
movq %rax, %rdi
movl %r8d, %esi
popq %rbp
jmp 0x21d0
popq %rbp
retq
leaq 0xe9a(%rip), %rdi       # 0xb3b8
leaq 0x2e20(%rip), %rsi      # 0xd345
leaq 0x2fdf(%rip), %rcx      # 0xd50b
movl $0x1e9, %edx            # imm = 0x1E9
callq 0x21b0
leaq 0x2f8c(%rip), %rdi      # 0xd4c9
leaq 0x2e01(%rip), %rsi      # 0xd345
leaq 0x2fc0(%rip), %rcx      # 0xd50b
movl $0x1ea, %edx            # imm = 0x1EA
callq 0x21b0
leaq 0x2f78(%rip), %rdi      # 0xd4d4
leaq 0x2de2(%rip), %rsi      # 0xd345
leaq 0x2fa1(%rip), %rcx      # 0xd50b
movl $0x1eb, %edx            # imm = 0x1EB
callq 0x21b0
leaq 0x2f69(%rip), %rdi      # 0xd4e4
leaq 0x2dc3(%rip), %rsi      # 0xd345
leaq 0x2f82(%rip), %rcx      # 0xd50b
movl $0x1ef, %edx            # imm = 0x1EF
callq 0x21b0
leaq 0x2f53(%rip), %rdi      # 0xd4ed
leaq 0x2da4(%rip), %rsi      # 0xd345
leaq 0x2f63(%rip), %rcx      # 0xd50b
movl $0x1f0, %edx            # imm = 0x1F0
callq 0x21b0
leaq 0x2f41(%rip), %rdi      # 0xd4fa
leaq 0x2d85(%rip), %rsi      # 0xd345
leaq 0x2f44(%rip), %rcx      # 0xd50b
movl $0x1f1, %edx            # imm = 0x1F1
callq 0x21b0
leaq 0x2f65(%rip), %rdi      # 0xd53d
leaq 0x2d66(%rip), %rsi      # 0xd345
leaq 0x2f25(%rip), %rcx      # 0xd50b
movl $0x1f3, %edx            # imm = 0x1F3
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O3/alexgirao[P]aimant/str.c
// Function: str_from_file
void str_from_file(struct str *s, const char *file)
{
  off_t fsz = get_file_size(file);
  str_alloc(s, fsz + 1);
  get_file_data(file, fsz, s->s);
  s->s[fsz] = 0;
  s->len = fsz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq -0xb0(%rbp), %rsi
movq %r15, %rdi
callq 0x2250
testl %eax, %eax
jne 0xa6b1
movq -0x80(%rbp), %r14
leal 0x1(%r14), %esi
movq %rbx, %rdi
callq 0x9a40
movq (%rbx), %r12
leaq 0x2f23(%rip), %rsi      # 0xd57e
movq %r15, %rdi
callq 0x22f0
testq %r12, %r12
je 0xa6d0
movq %rax, %r15
testq %rax, %rax
je 0xa6ef
movl $0x1, %edx
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0x20e0
cmpq $0x1, %rax
jne 0xa70e
movq %r15, %rdi
callq 0x2130
movq (%rbx), %rax
movb $0x0, (%rax,%r14)
movl %r14d, 0x8(%rbx)
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e93(%rip), %rdi      # 0xd54b
leaq 0x2c86(%rip), %rsi      # 0xd345
leaq 0x2e96(%rip), %rcx      # 0xd55c
movl $0x20b, %edx            # imm = 0x20B
callq 0x21b0
leaq 0x117c(%rip), %rdi      # 0xb853
leaq 0x2c67(%rip), %rsi      # 0xd345
leaq 0x2e9c(%rip), %rcx      # 0xd581
movl $0x212, %edx            # imm = 0x212
callq 0x21b0
leaq 0x12b2(%rip), %rdi      # 0xb9a8
leaq 0x2c48(%rip), %rsi      # 0xd345
leaq 0x2e7d(%rip), %rcx      # 0xd581
movl $0x213, %edx            # imm = 0x213
callq 0x21b0
leaq 0x2e9d(%rip), %rdi      # 0xd5b2
leaq 0x2c29(%rip), %rsi      # 0xd345
leaq 0x2e5e(%rip), %rcx      # 0xd581
movl $0x214, %edx            # imm = 0x214
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: alloc_atom
struct atom *
alloc_atom(void)
{
	struct atom *p;

	if (free_count == 0)
		alloc_block();

	p = free_list;
	free_list = p->u.next;

	free_count--;
	alloc_count++;

	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x37dba(%rip), %ecx     # 0x3f2a0
testl %ecx, %ecx
jne 0x74f5
callq 0x7516
movl 0x37dab(%rip), %ecx     # 0x3f2a0
movq 0x37dac(%rip), %rax     # 0x3f2a8
movq (%rax), %rdx
movq %rdx, 0x37da2(%rip)     # 0x3f2a8
decl %ecx
movl %ecx, 0x37d92(%rip)     # 0x3f2a0
incl 0x37d9c(%rip)           # 0x3f2b0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: alloc_block
void
alloc_block(void)
{
	int i;
	struct atom *p;

	if (block_count == MAXBLOCKS) {
		tos = 0;
		gc(); // prep for next run
		stopf("out of memory");
	}

	p = alloc_mem(BLOCKSIZE * sizeof (struct atom));

	mem[block_count++] = p;

	for (i = 0; i < BLOCKSIZE - 1; i++) {
		p[i].atomtype = FREEATOM;
		p[i].u.next = p + i + 1;
	}

	p[i].atomtype = FREEATOM;
	p[i].u.next = NULL;

	free_list = p;
	free_count = BLOCKSIZE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movslq 0x37d91(%rip), %rbx     # 0x3f2b4
cmpq $0x7d0, %rbx            # imm = 0x7D0
je 0x759c
movl $0x3a980, %edi          # imm = 0x3A980
callq 0x7260
testq %rax, %rax
je 0x75b7
leal 0x1(%rbx), %ecx
movl %ecx, 0x37d70(%rip)     # 0x3f2b4
leaq 0x37d75(%rip), %rcx     # 0x3f2c0
movq %rax, (%rcx,%rbx,8)
movq %rax, %rcx
addq $0x18, %rcx
xorl %edx, %edx
movb $0x0, 0x10(%rax,%rdx)
leaq (%rcx,%rdx), %rsi
movq %rsi, (%rax,%rdx)
addq $0x18, %rdx
cmpq $0x3a968, %rdx          # imm = 0x3A968
jne 0x7558
movb $0x0, 0x3a978(%rax)
movq $0x0, 0x3a968(%rax)
movq %rax, 0x37d1d(%rip)     # 0x3f2a8
movl $0x2710, 0x37d0b(%rip)  # imm = 0x2710
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x0, 0x37d12(%rip)     # 0x3f2b8
callq 0x75c1
leaq 0x22bee(%rip), %rdi     # 0x2a1a0
callq 0x780b
movl $0x1, %edi
callq 0x7330
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: stopf
void
stopf(char *s)
{
	print_trace(RED);
	snprintf(strbuf, STRBUFLEN, "Stop: %s\n", s);
	printbuf(strbuf, RED);
	longjmp(jmpbuf, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x28683
leaq 0x10f0ef(%rip), %r14    # 0x116910
leaq 0x276c4(%rip), %rdx     # 0x2eeec
movl $0x3e8, %esi            # imm = 0x3E8
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x7100
movq %r14, %rdi
callq 0x16615
leaq 0x10efb7(%rip), %rdi    # 0x116800
movl $0x1, %esi
callq 0x72d0
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: alloc_mem
void *
alloc_mem(int n)
{
	void *p = malloc(n);
	if (p == NULL)
		exit(1);
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %edi, %rdi
callq 0x7260
testq %rax, %rax
je 0x7866
popq %rbp
retq
movl $0x1, %edi
callq 0x7330
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: alloc_vector
struct atom *
alloc_vector(int nrow)
{
	struct atom *p = alloc_tensor(nrow);
	p->u.tensor->ndim = 1;
	p->u.tensor->dim[0] = nrow;
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
callq 0x7893
movq (%rax), %rcx
movl $0x1, (%rcx)
movq (%rax), %rcx
movl %ebx, 0x4(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: alloc_tensor
struct atom *
alloc_tensor(int nelem)
{
	int i;
	struct atom *p;
	struct tensor *t;
	p = alloc_atom();
	t = alloc_mem(sizeof (struct tensor) + nelem * sizeof (struct atom *));
	p->atomtype = TENSOR;
	p->u.tensor = t;
	t->nelem = nelem;
	for (i = 0; i < nelem; i++)
		t->elem[i] = zero;
	tensor_count++;
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %r14d
callq 0x74dc
movq %rax, %rbx
leal 0x70(,%r14,8), %edi
callq 0x7853
movb $0x7, 0x10(%rbx)
movq %rax, (%rbx)
movl %r14d, 0x64(%rax)
testl %r14d, %r14d
jle 0x78db
movq 0x3b877(%rip), %rcx     # 0x43140
movl %r14d, %edx
xorl %esi, %esi
movq %rcx, 0x68(%rax,%rsi,8)
incq %rsi
cmpq %rsi, %rdx
jne 0x78ce
incl 0x3b867(%rip)           # 0x43148
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: alloc_matrix
struct atom *
alloc_matrix(int nrow, int ncol)
{
	struct atom *p = alloc_tensor(nrow * ncol);
	p->u.tensor->ndim = 2;
	p->u.tensor->dim[0] = nrow;
	p->u.tensor->dim[1] = ncol;
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %r14d
movl %esi, %edi
imull %r14d, %edi
callq 0x7893
movq (%rax), %rcx
movl $0x2, (%rcx)
movq (%rax), %rcx
movl %r14d, 0x4(%rcx)
movq (%rax), %rcx
movl %ebx, 0x8(%rcx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: mscan
uint32_t *
mscan(char *s)
{
	int i, k, len;
	uint32_t *a, *b, *t;
	a = mint(0);
	len = (int) strlen(s);
	if (len == 0)
		return a;
	k = len % 9;
	if (k == 0)
		k = 9;
	for (i = 0; i < k; i++)
		a[0] = 10 * a[0] + s[i] - '0';
	if (k == len)
		return a;
	b = mint(0);
	while (k < len) {
		b[0] = 1000000000; // 10^9
		t = mmul(a, b);
		mfree(a);
		a = t;
		b[0] = 0;
		for (i = 0; i < 9; i++)
			b[0] = 10 * b[0] + s[k++] - '0';
		t = madd(a, b);
		mfree(a);
		a = t;
	}
	mfree(b);
	return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r13
xorl %edi, %edi
callq 0x7b1f
movq %rax, %r15
movq %r13, %rdi
callq 0x70e0
movq %rax, %rbx
testl %ebx, %ebx
je 0x7b0d
movslq %ebx, %rax
imulq $0x38e38e39, %rax, %rax # imm = 0x38E38E39
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x21, %rax
addl %ecx, %eax
leal (%rax,%rax,8), %eax
movl %ebx, %ecx
subl %eax, %ecx
movl $0x9, %r14d
cmovnel %ecx, %r14d
testl %r14d, %r14d
jle 0x7a48
movl (%r15), %ecx
movl %r14d, %eax
xorl %edx, %edx
leal (%rcx,%rcx,4), %ecx
movsbl (%r13,%rdx), %esi
leal (%rsi,%rcx,2), %ecx
addl $-0x30, %ecx
incq %rdx
cmpq %rdx, %rax
jne 0x7a2e
movl %ecx, (%r15)
cmpl %ebx, %r14d
je 0x7b0d
xorl %edi, %edi
callq 0x7b1f
movq %rax, %r12
cmpl %ebx, %r14d
jge 0x7af3
movq %rbx, -0x30(%rbp)
movq %r13, -0x38(%rbp)
movslq %r14d, %rbx
addq %r13, %rbx
movl $0x3b9aca00, (%r12)     # imm = 0x3B9ACA00
movq %r15, %rdi
movq %r12, %rsi
callq 0x7b60
movq %rax, %r13
addq $-0x4, %r15
movq %r15, %rdi
callq 0x7040
decl 0x3b6c2(%rip)           # 0x4315c
xorl %eax, %eax
xorl %ecx, %ecx
leal (%rcx,%rcx,4), %ecx
movsbl (%rbx,%rax), %edx
leal (%rdx,%rcx,2), %ecx
addl $-0x30, %ecx
incq %rax
cmpl $0x9, %eax
jne 0x7a9e
addl $0x9, %r14d
movl %ecx, (%r12)
movq %r13, %rdi
movq %r12, %rsi
callq 0x7c62
movq %rax, %r15
addq $-0x4, %r13
movq %r13, %rdi
callq 0x7040
movl 0x3b681(%rip), %ebx     # 0x4315c
decl %ebx
movl %ebx, 0x3b679(%rip)     # 0x4315c
cmpl -0x30(%rbp), %r14d
movq -0x38(%rbp), %r13
jl 0x7a6c
jmp 0x7af9
movl 0x3b663(%rip), %ebx     # 0x4315c
addq $-0x4, %r12
movq %r12, %rdi
callq 0x7040
decl %ebx
movl %ebx, 0x3b64f(%rip)     # 0x4315c
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: mint
uint32_t *
mint(uint32_t n)
{
	uint32_t *p;
	p = mnew(1);
	p[0] = n;
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x8, %edi
callq 0x7260
testq %rax, %rax
je 0x7b56
incl 0x3b620(%rip)           # 0x4315c
movl $0x1, (%rax)
movq %rax, %rcx
addq $0x4, %rcx
movl %ebx, 0x4(%rax)
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x1, %edi
callq 0x7330
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: mmul
uint32_t *
mmul(uint32_t *u, uint32_t *v)
{
	int i, j, nu, nv, nw;
	uint64_t t;
	uint32_t *w;
	nu = MLENGTH(u);
	nv = MLENGTH(v);
	nw = nu + nv;
	w = mnew(nw);
	for (i = 0; i < nw; i++)
		w[i] = 0;
	for (i = 0; i < nu; i++) {
		t = 0;
		for (j = 0; j < nv; j++) {
			t += (uint64_t) u[i] * v[j] + w[i + j];
			w[i + j] = (uint32_t) t;
			t >>= 32;
		}
		w[i + j] = (uint32_t) t;
	}
	mnorm(w);
	return w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, -0x38(%rbp)
movl -0x4(%rdi), %r12d
movl -0x4(%rsi), %ebx
leal (%rbx,%r12), %r13d
leal 0x4(,%r13,4), %edi
callq 0x7853
incl 0x3b5c6(%rip)           # 0x4315c
movl %r13d, (%rax)
leaq 0x4(%rax), %r14
testl %r13d, %r13d
jle 0x7bc0
leal -0x1(%r13), %ecx
leaq 0x4(,%rcx,4), %rdx
movq %r14, %rdi
xorl %esi, %esi
movq %rax, -0x30(%rbp)
callq 0x7130
movq -0x30(%rbp), %rax
testl %r12d, %r12d
movq -0x38(%rbp), %r11
jle 0x7c1d
xorl %r10d, %r10d
movq %r14, %rcx
testl %ebx, %ebx
jle 0x7c05
movl (%r11,%r10,4), %esi
xorl %edi, %edi
xorl %edx, %edx
movl (%r15,%rdi,4), %r8d
imulq %rsi, %r8
movl (%rcx,%rdi,4), %r9d
addq %rdx, %r9
addq %r8, %r9
movl %r9d, (%rcx,%rdi,4)
movq %r9, %rdx
shrq $0x20, %rdx
incq %rdi
cmpq %rdi, %rbx
jne 0x7bdb
movq %rbx, %rsi
jmp 0x7c09
xorl %esi, %esi
xorl %edx, %edx
leaq (%r14,%rsi,4), %rsi
movl %edx, (%rsi,%r10,4)
incq %r10
addq $0x4, %rcx
cmpq %r12, %r10
jne 0x7bcf
cmpl $0x2, %r13d
jl 0x7c3b
movl %r13d, %ecx
cmpl $0x0, (%rax,%rcx,4)
jne 0x7c3b
leal -0x1(%r13), %ecx
movl %ecx, (%rax)
cmpl $0x2, %r13d
movl %ecx, %r13d
jg 0x7c23
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: madd
uint32_t *
madd(uint32_t *u, uint32_t *v)
{
	int i, nu, nv, nw;
	uint64_t t;
	uint32_t *w;
	nu = MLENGTH(u);
	nv = MLENGTH(v);
	if (nu > nv)
		nw = nu + 1;
	else
		nw = nv + 1;
	w = mnew(nw);
	for (i = 0; i < nu; i++)
		w[i] = u[i];
	for (i = nu; i < nw; i++)
		w[i] = 0;
	t = 0;
	for (i = 0; i < nv; i++) {
		t += (uint64_t) w[i] + v[i];
		w[i] = (uint32_t) t;
		t >>= 32;
	}
	for (i = nv; i < nw; i++) {
		t += w[i];
		w[i] = (uint32_t) t;
		t >>= 32;
	}
	mnorm(w);
	return w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, -0x40(%rbp)
movslq -0x4(%rdi), %r14
movl -0x4(%rsi), %r12d
cmpl %r12d, %r14d
movl %r12d, %r13d
cmovgl %r14d, %r13d
leal 0x1(%r13), %eax
movl %eax, -0x30(%rbp)
leal 0x8(,%r13,4), %edi
callq 0x7853
incl 0x3b4b6(%rip)           # 0x4315c
leaq 0x4(%rax), %rbx
movl -0x30(%rbp), %ecx
movl %ecx, (%rax)
testq %r14, %r14
movq %rax, -0x38(%rbp)
jle 0x7cd0
leaq (,%r14,4), %rdx
movq %rbx, %rdi
movq -0x40(%rbp), %rsi
callq 0x7210
movq -0x38(%rbp), %rax
movslq %r12d, %rcx
movq %rcx, -0x30(%rbp)
leaq (%rax,%r14,4), %rdi
addq $0x4, %rdi
movl %r13d, %eax
subl %r14d, %eax
leaq 0x4(,%rax,4), %rdx
xorl %r14d, %r14d
xorl %esi, %esi
callq 0x7130
testl %r12d, %r12d
jle 0x7d1e
xorl %eax, %eax
xorl %r14d, %r14d
movl (%rbx,%rax,4), %ecx
addq %r14, %rcx
movl (%r15,%rax,4), %r14d
addq %rcx, %r14
movl %r14d, (%rbx,%rax,4)
shrq $0x20, %r14
incq %rax
cmpq %rax, %r12
jne 0x7d01
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rax
leaq (%rsi,%rax,4), %rax
addq $0x4, %rax
subl %r12d, %r13d
incl %r13d
xorl %ecx, %ecx
movl (%rax,%rcx,4), %edx
addq %r14, %rdx
movl %edx, (%rax,%rcx,4)
shrq $0x20, %rdx
incq %rcx
movq %rdx, %r14
cmpl %ecx, %r13d
jne 0x7d36
movl (%rsi), %eax
cmpl $0x2, %eax
jl 0x7d69
movl %eax, %ecx
cmpl $0x0, (%rsi,%rcx,4)
jne 0x7d69
leal -0x1(%rax), %ecx
movl %ecx, (%rsi)
cmpl $0x2, %eax
movl %ecx, %eax
jg 0x7d55
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: mstr
char *
mstr(uint32_t *u)
{
	int i, k, n, r;
	static char *buf;
	static int len;

	// estimate string length

	// note that 0xffffffff -> 000000004 294967295

	// hence space for 8 leading zeroes is required

	n = 10 * MLENGTH(u) + 10;

	n = 1000 * (n / 1000 + 1);

	if (n > len) {
		if (buf)
			free(buf);
		buf = alloc_mem(n);
		len = n;
	}

	u = mcopy(u);

	k = len - 1;
	buf[k] = '\0'; // string terminator

	for (;;) {
		r = mdivby1billion(u);
		for (i = 0; i < 9; i++) {
			buf[--k] = r % 10 + '0';
			r /= 10;
		}
		if (MZERO(u))
			break;
	}

	mfree(u);

	// remove leading zeroes

	while (buf[k] == '0' && buf[k + 1])
		k++;

	return buf + k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl -0x4(%rdi), %eax
leal (%rax,%rax,4), %eax
leal 0xa(,%rax,2), %eax
cltq
imulq $0x10624dd3, %rax, %rax # imm = 0x10624DD3
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x26, %rax
addl %ecx, %eax
imull $0x3e8, %eax, %r14d     # imm = 0x3E8
addl $0x3e8, %r14d           # imm = 0x3E8
cmpl 0x3b394(%rip), %r14d    # 0x43158
jle 0x7ded
movq 0x3b383(%rip), %rdi     # 0x43150
testq %rdi, %rdi
je 0x7dd7
callq 0x7040
movl %r14d, %edi
callq 0x7853
movq %rax, 0x3b36a(%rip)     # 0x43150
movl %r14d, 0x3b36b(%rip)    # 0x43158
movq %rbx, %rdi
callq 0x7e97
movq %rax, %rbx
movslq 0x3b359(%rip), %r12     # 0x43158
movq 0x3b34a(%rip), %r13     # 0x43150
movb $0x0, -0x1(%r13,%r12)
decq %r12
movq %rax, %r14
addq $-0x4, %r14
movq %rbx, %rdi
callq 0x7ee0
movslq %r12d, %r15
addq %r13, %r15
xorl %ecx, %ecx
movslq %eax, %rdx
imulq $0x66666667, %rdx, %rax # imm = 0x66666667
movq %rax, %rsi
shrq $0x3f, %rsi
sarq $0x22, %rax
addl %esi, %eax
leal (%rax,%rax), %esi
leal (%rsi,%rsi,4), %esi
subl %esi, %edx
addb $0x30, %dl
movb %dl, -0x1(%r15)
decq %r15
incl %ecx
cmpl $0x9, %ecx
jne 0x7e26
subl %ecx, %r12d
cmpl $0x1, (%r14)
jne 0x7e16
cmpl $0x0, (%rbx)
jne 0x7e16
movq %r14, %rdi
callq 0x7040
decl 0x3b2ea(%rip)           # 0x4315c
movb (%r15), %cl
movq %r15, %rax
cmpb $0x30, %cl
jne 0x7e88
leaq 0x1(%rax), %r15
movb 0x1(%rax), %cl
testb %cl, %cl
jne 0x7e75
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: mcopy
uint32_t *
mcopy(uint32_t *u)
{
	int i;
	uint32_t *v;
	v = mnew(MLENGTH(u));
	for (i = 0; i < MLENGTH(u); i++)
		v[i] = u[i];
	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl -0x4(%rdi), %r14d
leal 0x4(,%r14,4), %edi
callq 0x7853
incl 0x3b2a4(%rip)           # 0x4315c
movl %r14d, (%rax)
addq $0x4, %rax
movslq -0x4(%rbx), %rdx
testq %rdx, %rdx
jle 0x7edb
shlq $0x2, %rdx
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x7210
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: mdivby1billion
int
mdivby1billion(uint32_t *u)
{
	int i;
	uint64_t r = 0;
	for (i = MLENGTH(u) - 1; i >= 0; i--) {
		r = r << 32 | u[i];
		u[i] = (uint32_t) (r / 1000000000);
		r -= (uint64_t) 1000000000 * u[i];
	}
	mnorm(u);
	return (int) r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq -0x4(%rdi), %rcx
testq %rcx, %rcx
jle 0x7f4d
movq %rcx, %rsi
incq %rsi
xorl %eax, %eax
movabsq $0x44b82fa09b5a53, %r8  # imm = 0x44B82FA09B5A53
shlq $0x20, %rax
movl -0x8(%rdi,%rsi,4), %r9d
orq %rax, %r9
movq %r9, %rax
shrq $0x9, %rax
mulq %r8
shrq $0xb, %rdx
movl %edx, -0x8(%rdi,%rsi,4)
imulq $-0x3b9aca00, %rdx, %rax # imm = 0xC4653600
addq %r9, %rax
decq %rsi
cmpq $0x1, %rsi
ja 0x7eff
cmpl $0x1, %ecx
je 0x7f4f
movl %ecx, %edx
cmpl $0x0, -0x4(%rdi,%rdx,4)
jne 0x7f4f
leal -0x1(%rcx), %edx
movl %edx, -0x4(%rdi)
cmpl $0x2, %ecx
movl %edx, %ecx
jg 0x7f35
jmp 0x7f4f
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: mnew
uint32_t *
mnew(int n)
{
	uint32_t *u;
	u = alloc_mem((n + 1) * sizeof (uint32_t));
	bignum_count++;
	*u = n;
	return u + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
leal 0x4(,%rbx,4), %edi
callq 0x7853
incl 0x3b1cd(%rip)           # 0x4315c
movl %ebx, (%rax)
addq $0x4, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: msub
uint32_t *
msub(uint32_t *u, uint32_t *v)
{
	int i, nu, nv, nw;
	uint64_t t;
	uint32_t *w;
	nu = MLENGTH(u);
	nv = MLENGTH(v);
	if (nu > nv)
		nw = nu;
	else
		nw = nv;
	w = mnew(nw);
	for (i = 0; i < nu; i++)
		w[i] = u[i];
	for (i = nu; i < nw; i++)
		w[i] = 0;
	t = 0;
	for (i = 0; i < nv; i++) {
		t += (uint64_t) w[i] - v[i];
		w[i] = (uint32_t) t;
		t = (int64_t) t >> 32; // cast to extend sign
	}
	for (i = nv; i < nw; i++) {
		t += w[i];
		w[i] = (uint32_t) t;
		t = (int64_t) t >> 32; // cast to extend sign
	}
	mnorm(w);
	return w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, -0x38(%rbp)
movslq -0x4(%rdi), %rax
movq %rax, -0x40(%rbp)
movl -0x4(%rsi), %r13d
cmpl %r13d, %eax
movl %r13d, %r12d
cmovgl %eax, %r12d
leal 0x4(,%r12,4), %edi
callq 0x7853
incl 0x3b17f(%rip)           # 0x4315c
movq %rax, %r14
leaq 0x4(%rax), %rbx
movq %r12, -0x30(%rbp)
movl %r12d, (%rax)
movq -0x40(%rbp), %r12
testq %r12, %r12
jle 0x8008
leaq (,%r12,4), %rdx
movq %rbx, %rdi
movq -0x38(%rbp), %rsi
callq 0x7210
cmpl %r12d, %r13d
jle 0x802c
leaq (%r14,%r12,4), %rdi
addq $0x4, %rdi
movl %r12d, %eax
notl %eax
addl -0x30(%rbp), %eax
leaq 0x4(,%rax,4), %rdx
xorl %esi, %esi
callq 0x7130
testl %r13d, %r13d
jle 0x8056
xorl %ecx, %ecx
xorl %edx, %edx
movl (%rbx,%rcx,4), %eax
movl (%r15,%rcx,4), %esi
subq %rsi, %rax
addq %rdx, %rax
movl %eax, (%rbx,%rcx,4)
sarq $0x20, %rax
incq %rcx
movq %rax, %rdx
cmpq %rcx, %r13
jne 0x8035
jmp 0x8058
xorl %eax, %eax
cmpl %r13d, %r12d
jle 0x807c
movslq %r13d, %rcx
movslq -0x30(%rbp), %rdx
movl (%rbx,%rcx,4), %esi
addq %rax, %rsi
movl %esi, (%rbx,%rcx,4)
sarq $0x20, %rsi
incq %rcx
movq %rsi, %rax
cmpq %rcx, %rdx
jne 0x8064
movl (%r14), %eax
cmpl $0x2, %eax
jl 0x809a
movl %eax, %ecx
cmpl $0x0, (%r14,%rcx,4)
jne 0x809a
leal -0x1(%rax), %ecx
movl %ecx, (%r14)
cmpl $0x2, %eax
movl %ecx, %eax
jg 0x8084
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: mpow
uint32_t *
mpow(uint32_t *u, uint32_t *v)
{
	uint32_t *t, *w;
	u = mcopy(u);
	v = mcopy(v);
	// w = 1
	w = mnew(1);
	w[0] = 1;
	for (;;) {
		if (v[0] & 1) {
			// w = w * u
			t = mmul(w, u);
			mfree(w);
			w = t;
		}
		// v = v >> 1
		mshr(v);
		// v = 0?
		if (MLENGTH(v) == 1 && v[0] == 0)
			break;
		// u = u * u
		t = mmul(u, u);
		mfree(u);
		u = t;
	}
	mfree(u);
	mfree(v);
	return w;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x7e97
movq %rax, %r14
movq %rbx, %rdi
callq 0x7e97
movq %rax, %r15
movl $0x8, %edi
callq 0x7260
testq %rax, %rax
je 0x869a
movq %rax, %rbx
incl 0x3ab75(%rip)           # 0x4315c
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, (%rbx)
addq $0x4, %rbx
movq %r15, %r12
addq $-0x4, %r12
testb $0x1, (%r15)
je 0x8628
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7b60
movq %rax, %r13
addq $-0x4, %rbx
movq %rbx, %rdi
callq 0x7040
decl 0x3ab37(%rip)           # 0x4315c
movq %r13, %rbx
movq %r15, %rdi
callq 0x86a4
cmpl $0x1, -0x4(%r15)
jne 0x863d
cmpl $0x0, (%r15)
je 0x8662
movq %r14, %rdi
movq %r14, %rsi
callq 0x7b60
movq %rax, %r13
addq $-0x4, %r14
movq %r14, %rdi
callq 0x7040
decl 0x3aaff(%rip)           # 0x4315c
movq %r13, %r14
jmp 0x85ff
addq $-0x4, %r14
movq %r14, %rdi
callq 0x7040
movl 0x3aae7(%rip), %r14d    # 0x4315c
movq %r12, %rdi
callq 0x7040
addl $-0x2, %r14d
movl %r14d, 0x3aad4(%rip)    # 0x4315c
movq %rbx, %rax
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_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: mshr
void
mshr(uint32_t *u)
{
	int i;
	for (i = 0; i < MLENGTH(u) - 1; i++) {
		u[i] >>= 1;
		if (u[i + 1] & 1)
			u[i] |= 0x80000000;
	}
	u[i] >>= 1;
	mnorm(u);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl -0x4(%rdi), %eax
cmpl $0x1, %eax
jle 0x8700
leal -0x1(%rax), %ecx
movl %ecx, %ecx
movl (%rdi), %esi
xorl %edx, %edx
movl %esi, %r8d
shrl %r8d
movl %r8d, (%rdi,%rdx,4)
movl 0x4(%rdi,%rdx,4), %esi
testb $0x1, %sil
je 0x86d8
orl $0x80000000, %r8d       # imm = 0x80000000
movl %r8d, (%rdi,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x86b9
shrl (%rdi,%rcx,4)
cmpl $0x2, %eax
jl 0x8702
movl %eax, %ecx
cmpl $0x0, -0x4(%rdi,%rcx,4)
jne 0x8702
leal -0x1(%rax), %ecx
movl %ecx, -0x4(%rdi)
cmpl $0x2, %eax
movl %ecx, %eax
jg 0x86e8
jmp 0x8702
shrl (%rdi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: mcmp
int
mcmp(uint32_t *u, uint32_t *v)
{
	int i;
	mnorm(u);
	mnorm(v);
	if (MLENGTH(u) < MLENGTH(v))
		return -1;
	if (MLENGTH(u) > MLENGTH(v))
		return 1;
	for (i = MLENGTH(u) - 1; i >= 0; i--) {
		if (u[i] < v[i])
			return -1;
		if (u[i] > v[i])
			return 1;
	}
	return 0; // u = v
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl -0x4(%rdi), %eax
cmpl $0x2, %eax
jl 0x8728
movl %eax, %ecx
cmpl $0x0, -0x4(%rdi,%rcx,4)
jne 0x8728
leal -0x1(%rax), %ecx
movl %ecx, -0x4(%rdi)
cmpl $0x2, %eax
movl %ecx, %eax
jg 0x8710
jmp 0x872a
movl %eax, %ecx
movl -0x4(%rsi), %edx
cmpl $0x2, %edx
jl 0x8751
movl %edx, %eax
cmpl $0x0, -0x4(%rsi,%rax,4)
jne 0x874a
leal -0x1(%rdx), %eax
movl %eax, -0x4(%rsi)
cmpl $0x2, %edx
movl %eax, %edx
jg 0x8732
jmp 0x874c
movl %edx, %eax
movl -0x4(%rdi), %ecx
movl %eax, %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %edx, %ecx
jl 0x8781
jg 0x8778
movl %ecx, %ecx
testl %ecx, %ecx
jle 0x877f
movl -0x4(%rdi,%rcx,4), %edx
movl -0x4(%rsi,%rcx,4), %r8d
cmpl %r8d, %edx
jb 0x8781
decq %rcx
cmpl %r8d, %edx
jbe 0x875e
movl $0x1, %eax
jmp 0x8781
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: meq
int
meq(uint32_t *u, uint32_t *v)
{
	int i;
	if (MLENGTH(u) != MLENGTH(v))
		return 0;
	for (i = 0; i < MLENGTH(u); i++)
		if (u[i] != v[i])
			return 0;
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl -0x4(%rdi), %ecx
xorl %eax, %eax
cmpl -0x4(%rsi), %ecx
jne 0x87b2
movl $0x1, %eax
testl %ecx, %ecx
jle 0x87b2
xorl %edx, %edx
movl (%rdi,%rdx,4), %r8d
cmpl (%rsi,%rdx,4), %r8d
jne 0x87b0
incq %rdx
cmpq %rdx, %rcx
jne 0x879c
jmp 0x87b2
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: mroot
uint32_t *
mroot(uint32_t *a, uint32_t *n)
{
	int i, j, k;
	uint32_t *b, *c, m;

	if (MLENGTH(n) > 1 || n[0] == 0)
		return NULL;

	// k is bit length of a

	k = 32 * (MLENGTH(a) - 1);

	m = a[MLENGTH(a) - 1];

	while (m) {
		m >>= 1;
		k++;
	}

	if (k == 0)
		return mint(0);

	// initial guess of index of ms bit in result

	k = (k - 1) / n[0];

	j = k / 32 + 1; // k is bit index, not number of bits

	b = mnew(j);

	for (i = 0; i < j; i++)
		b[i] = 0;

	while (k >= 0) {
		msetbit(b, k);
		mnorm(b);
		c = mpow(b, n);
		switch (mcmp(c, a)) {
		case -1:
			break;
		case 0:
			mfree(c);
			return b;
		case 1:
			mclrbit(b, k);
			break;
		}
		mfree(c);
		k--;
	}

	mfree(b);

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, -0x40(%rbp)
cmpl $0x1, -0x4(%rsi)
jg 0x8b3f
movq %rsi, %r15
movl (%rsi), %ecx
testl %ecx, %ecx
je 0x8b3f
movq -0x40(%rbp), %rsi
movslq -0x4(%rsi), %rax
leaq -0x1(%rax), %rdx
shll $0x5, %edx
movl -0x4(%rsi,%rax,4), %eax
bsrl %eax, %esi
xorl $0x1f, %esi
negl %esi
testl %eax, %eax
leal 0x20(%rdx,%rsi), %eax
cmovel %edx, %eax
testl %eax, %eax
je 0x8b50
decl %eax
xorl %edx, %edx
divl %ecx
movl %eax, %r14d
leal 0x1f(%r14), %ebx
testl %eax, %eax
cmovnsl %eax, %ebx
sarl $0x5, %ebx
leal 0x8(,%rbx,4), %edi
incl %ebx
callq 0x7853
movq %r14, %rcx
movq %rax, %r13
movl 0x3a71c(%rip), %r14d    # 0x4315c
leal 0x1(%r14), %eax
movl %eax, 0x3a712(%rip)     # 0x4315c
movl %ebx, (%r13)
cmpl $-0x1f, %ecx
jl 0x8b30
movq %r13, %rdi
addq $0x4, %rdi
movq %rcx, %r12
movl %ebx, %edx
shlq $0x2, %rdx
movq %rdi, -0x38(%rbp)
xorl %esi, %esi
callq 0x7130
movq %r12, %rcx
testl %ecx, %ecx
js 0x8b30
movq %r15, -0x48(%rbp)
movq -0x38(%rbp), %r12
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x30(%rbp)
movl %ecx, %r15d
shrl $0x5, %r15d
movl (%r12,%r15,4), %eax
movl %eax, -0x2c(%rbp)
btsl %ecx, %eax
movl %eax, (%r12,%r15,4)
cmpl $0x2, %ebx
movq %rcx, -0x50(%rbp)
jl 0x8aca
movl %ebx, %eax
cmpl $0x0, (%r13,%rax,4)
jne 0x8aca
leal -0x1(%rbx), %eax
movl %eax, (%r13)
cmpl $0x2, %ebx
movl %eax, %ebx
jg 0x8aad
movl $0x1, %ebx
movq %r12, %rdi
movq -0x48(%rbp), %rsi
callq 0x85a7
movq %rax, %r14
movq %rax, %rdi
movq -0x40(%rbp), %rsi
callq 0x8704
cmpl $0x1, %eax
je 0x8af0
testl %eax, %eax
jne 0x8afe
jmp 0x8b65
movl -0x30(%rbp), %eax
notl %eax
movl -0x2c(%rbp), %ecx
andl %eax, %ecx
movl %ecx, (%r12,%r15,4)
addq $-0x4, %r14
movq %r14, %rdi
callq 0x7040
movl 0x3a64b(%rip), %r14d    # 0x4315c
leal -0x1(%r14), %eax
movl %eax, 0x3a641(%rip)     # 0x4315c
movq -0x50(%rbp), %rcx
leal -0x1(%rcx), %eax
testl %ecx, %ecx
movl %eax, %ecx
jg 0x8a85
addl $-0x2, %r14d
movq %r13, %rdi
callq 0x7040
movl %r14d, 0x3a61d(%rip)    # 0x4315c
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %edi, %edi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7b1f
addq $-0x4, %r14
movq %r14, %rdi
callq 0x7040
decl 0x3a5e5(%rip)           # 0x4315c
movq -0x38(%rbp), %rax
jmp 0x8b41
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: list
void
list(int n)
{
	int i;
	push_symbol(NIL);
	for (i = 0; i < n; i++)
		cons();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0x3ce74(%rip), %rdi     # 0x45a00
callq 0x8ba5
testl %ebx, %ebx
jle 0x8b9e
callq 0x8be6
decl %ebx
jne 0x8b95
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: push
void
push(struct atom *p)
{
	if (tos < 0 || tos >= STACKSIZE)
		stopf("stack error");
	stack[tos++] = p;
	if (tos > max_tos)
		max_tos = tos;
}

// Assembly:
movl 0x3670d(%rip), %eax     # 0x3f2b8
cmpq $0x186a0, %rax          # imm = 0x186A0
jae 0x8bd6
leal 0x1(%rax), %ecx
movl %ecx, 0x366fc(%rip)     # 0x3f2b8
leaq 0x3f9fd(%rip), %rdx     # 0x485c0
movq %rdi, (%rdx,%rax,8)
cmpl 0x10d81f(%rip), %eax    # 0x1163ec
jl 0x8bd5
movl %ecx, 0x10d817(%rip)    # 0x1163ec
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x26360(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: cons
void
cons(void)
{
	struct atom *p;
	p = alloc_atom();
	p->atomtype = CONS;
	p->u.cons.cdr = pop();
	p->u.cons.car = pop();
	push(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x74dc
movb $0x1, 0x10(%rax)
movl 0x366bf(%rip), %ecx     # 0x3f2b8
movl $0xfffe795f, %edx       # imm = 0xFFFE795F
leal (%rcx,%rdx), %esi
cmpl %edx, %esi
jbe 0x8c3b
leal -0x1(%rcx), %esi
movl %esi, 0x366aa(%rip)     # 0x3f2b8
leaq 0x3f9ab(%rip), %rdx     # 0x485c0
movq (%rdx,%rsi,8), %rsi
movq %rsi, 0x8(%rax)
cmpl $0x1, %ecx
jbe 0x8c3b
addl $-0x2, %ecx
movl %ecx, 0x3668d(%rip)     # 0x3f2b8
movq (%rdx,%rcx,8), %rcx
movq %rcx, (%rax)
movq %rax, %rdi
popq %rbp
jmp 0x8ba5
leaq 0x262ff(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: lengthf
int
lengthf(struct atom *p)
{
	int n = 0;
	while (iscons(p)) {
		n++;
		p = cdr(p);
	}
	return n;
}

// Assembly:
xorl %eax, %eax
cmpb $0x1, 0x10(%rdi)
jne 0x8c98
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
incl %eax
movq 0x8(%rdi), %rdi
cmpb $0x1, 0x10(%rdi)
je 0x8c8b
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: findf
int
findf(struct atom *p, struct atom *q)
{
	int i;

	if (equal(p, q))
		return 1;

	if (istensor(p)) {
		for (i = 0; i < p->u.tensor->nelem; i++)
			if (findf(p->u.tensor->elem[i], q))
				return 1;
		return 0;
	}

	while (iscons(p)) {
		if (findf(car(p), q))
			return 1;
		p = cdr(p);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x8d48
testl %eax, %eax
je 0x8d30
movzbl 0x10(%r14), %eax
xorl %r15d, %r15d
cmpl $0x7, %eax
je 0x8cff
cmpl $0x1, %eax
jne 0x8d36
leaq 0x10(%r14), %r13
leaq 0x3cd2d(%rip), %r12     # 0x45a00
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x8c99
testl %eax, %eax
jne 0x8d30
addq $0x8, %r14
cmpb $0x1, (%r13)
cmovneq %r12, %r14
movq (%r14), %r14
leaq 0x10(%r14), %r13
cmpb $0x1, 0x10(%r14)
je 0x8cd3
jmp 0x8d36
movq (%r14), %rax
cmpl $0x0, 0x64(%rax)
jle 0x8d36
xorl %r15d, %r15d
movq 0x68(%rax,%r15,8), %rdi
movq %rbx, %rsi
callq 0x8c99
testl %eax, %eax
jne 0x8d30
incq %r15
movq (%r14), %rax
movslq 0x64(%rax), %rcx
cmpq %rcx, %r15
jl 0x8d0b
xorl %r15d, %r15d
jmp 0x8d36
movl $0x1, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: cmp_numbers
int
cmp_numbers(struct atom *p1, struct atom *p2)
{
	double d1, d2;

	if (isrational(p1) && isrational(p2))
		return cmp_rationals(p1, p2);

	push(p1);
	d1 = pop_double();

	push(p2);
	d2 = pop_double();

	if (d1 < d2)
		return -1;

	if (d1 > d2)
		return 1;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
cmpb $0x4, 0x10(%rdi)
jne 0x8f68
cmpb $0x4, 0x10(%rbx)
jne 0x8f68
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9032
callq 0x8ba5
callq 0x9128
movsd %xmm0, -0x10(%rbp)
movq %rbx, %rdi
callq 0x8ba5
callq 0x9128
movsd -0x10(%rbp), %xmm1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
ucomisd %xmm1, %xmm0
ja 0x8f9d
xorl %eax, %eax
ucomisd %xmm0, %xmm1
seta %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: cmp_tensors
int
cmp_tensors(struct atom *p1, struct atom *p2)
{
	int i, t;

	t = p1->u.tensor->ndim - p2->u.tensor->ndim;

	if (t)
		return t;

	for (i = 0; i < p1->u.tensor->ndim; i++) {
		t = p1->u.tensor->dim[i] - p2->u.tensor->dim[i];
		if (t)
			return t;
	}

	for (i = 0; i < p1->u.tensor->nelem; i++) {
		t = cmp(p1->u.tensor->elem[i], p2->u.tensor->elem[i]);
		if (t)
			return t;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rcx
movl (%rcx), %edx
movq (%rsi), %rsi
movl (%rsi), %edi
movl %edx, %eax
subl %edi, %eax
jne 0x9027
testl %edx, %edx
jle 0x8ff7
xorl %edi, %edi
movl 0x4(%rcx,%rdi,4), %eax
subl 0x4(%rsi,%rdi,4), %eax
jne 0x9027
incq %rdi
cmpq %rdi, %rdx
jne 0x8fe5
cmpl $0x0, 0x64(%rcx)
jle 0x9025
xorl %r15d, %r15d
movq 0x68(%rcx,%r15,8), %rdi
movq (%rbx), %rax
movq 0x68(%rax,%r15,8), %rsi
callq 0x8d48
testl %eax, %eax
jne 0x9027
incq %r15
movq (%r14), %rcx
movslq 0x64(%rcx), %rax
cmpq %rax, %r15
jl 0x9000
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: cmp_rationals
int
cmp_rationals(struct atom *a, struct atom *b)
{
	int t;
	uint32_t *ab, *ba;
	if (a->sign == MMINUS && b->sign == MPLUS)
		return -1;
	if (a->sign == MPLUS && b->sign == MMINUS)
		return 1;
	if (isinteger(a) && isinteger(b)) {
		if (a->sign == MMINUS)
			return mcmp(b->u.q.a, a->u.q.a);
		else
			return mcmp(a->u.q.a, b->u.q.a);
	}
	ab = mmul(a->u.q.a, b->u.q.b);
	ba = mmul(a->u.q.b, b->u.q.a);
	if (a->sign == MMINUS)
		t = mcmp(ba, ab);
	else
		t = mcmp(ab, ba);
	mfree(ab);
	mfree(ba);
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movb 0x12(%rdi), %al
cmpb $0x1, %al
jne 0x905c
cmpb $0x0, 0x12(%r14)
jne 0x9071
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
jmp 0x9109
testb %al, %al
jne 0x9071
movl $0x1, %r12d
cmpb $0x1, 0x12(%r14)
je 0x9109
cmpb $0x4, 0x10(%rbx)
jne 0x90a8
movq 0x8(%rbx), %rcx
cmpl $0x1, -0x4(%rcx)
jne 0x90a8
cmpl $0x1, (%rcx)
jne 0x90a8
cmpb $0x4, 0x10(%r14)
jne 0x90a8
movq 0x8(%r14), %rcx
cmpl $0x1, -0x4(%rcx)
jne 0x90a8
cmpl $0x1, (%rcx)
jne 0x90a8
cmpb $0x1, %al
jne 0x9115
movq (%r14), %rdi
movq (%rbx), %rsi
jmp 0x911b
movq (%rbx), %rdi
movq 0x8(%r14), %rsi
callq 0x7b60
movq %rax, %r15
movq 0x8(%rbx), %rdi
movq (%r14), %rsi
callq 0x7b60
movq %rax, %r14
cmpb $0x1, 0x12(%rbx)
jne 0x90d4
movq %r14, %rdi
movq %r15, %rsi
jmp 0x90da
movq %r15, %rdi
movq %r14, %rsi
callq 0x8704
movl %eax, %r12d
addq $-0x4, %r15
movq %r15, %rdi
callq 0x7040
movl 0x3a068(%rip), %ebx     # 0x4315c
addq $-0x4, %r14
movq %r14, %rdi
callq 0x7040
addl $-0x2, %ebx
movl %ebx, 0x3a053(%rip)     # 0x4315c
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
movq (%r14), %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x8704
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: pop_double
double
pop_double(void)
{
	double a, b, d;
	struct atom *p;

	p = pop();

	if (!isnum(p))
		stopf("number expected");

	if (isdouble(p))
		d = p->u.d;
	else {
		a = mfloat(p->u.q.a);
		b = mfloat(p->u.q.b);
		d = a / b;
		if (isnegativenumber(p))
			d = -d;
	}

	return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movl 0x36181(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x91bf
decl %eax
movl %eax, 0x3616d(%rip)     # 0x3f2b8
leaq 0x3f46e(%rip), %rcx     # 0x485c0
movq (%rcx,%rax,8), %rbx
movb 0x10(%rbx), %al
movl %eax, %ecx
andb $-0x2, %cl
cmpb $0x4, %cl
jne 0x91cb
cmpb $0x5, %al
jne 0x916d
movsd (%rbx), %xmm1
jmp 0x91a8
movq (%rbx), %rdi
callq 0x7937
movapd %xmm0, -0x20(%rbp)
movq 0x8(%rbx), %rdi
callq 0x7937
movapd -0x20(%rbp), %xmm1
divsd %xmm0, %xmm1
movzbl 0x10(%rbx), %eax
cmpl $0x5, %eax
je 0x91b3
cmpl $0x4, %eax
jne 0x91a8
cmpb $0x1, 0x12(%rbx)
jne 0x91a8
xorpd 0x20f68(%rip), %xmm1    # 0x2a110
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
xorpd %xmm0, %xmm0
ucomisd (%rbx), %xmm0
ja 0x91a0
jmp 0x91a8
leaq 0x25d7b(%rip), %rdi     # 0x2ef41
callq 0x780b
leaq 0x25d92(%rip), %rdi     # 0x2ef64
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: find_denominator
int
find_denominator(struct atom *p)
{
	struct atom *q;
	p = cdr(p);
	while (iscons(p)) {
		q = car(p);
		if (car(q) == symbol(POWER) && isnegativenumber(caddr(q)))
			return 1;
		p = cdr(p);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rax
leaq 0x3c7f6(%rip), %rcx     # 0x45a00
cmovneq %rcx, %rax
movq (%rax), %rdx
xorl %eax, %eax
cmpb $0x1, 0x10(%rdx)
jne 0x92b4
movq 0x3f08c(%rip), %rsi     # 0x482b0
movq 0x3c7d5(%rip), %rdi     # 0x45a00
xorpd %xmm0, %xmm0
movq (%rdx), %r8
movb 0x10(%r8), %r9b
cmpb $0x1, %r9b
movq %rcx, %r10
cmoveq %r8, %r10
cmpq %rsi, (%r10)
je 0x9252
movq 0x8(%rdx), %rdx
cmpb $0x1, 0x10(%rdx)
je 0x922f
jmp 0x92b4
addq $0x8, %r8
cmpb $0x1, %r9b
cmovneq %rcx, %r8
movq (%r8), %r8
cmpb $0x1, 0x10(%r8)
jne 0x927c
movq 0x8(%r8), %r9
cmpb $0x1, 0x10(%r9)
movq %rcx, %r9
jne 0x928b
addq $0x8, %r8
jmp 0x9288
cmpb $0x1, 0x10(%rdi)
movq %rcx, %r8
movq %rcx, %r9
jne 0x928b
movq (%r8), %r9
movq (%r9), %r8
movzbl 0x10(%r8), %r9d
cmpl $0x5, %r9d
je 0x92a8
cmpl $0x4, %r9d
jne 0x9246
cmpb $0x1, 0x12(%r8)
jne 0x9246
jmp 0x92af
ucomisd (%r8), %xmm0
jbe 0x9246
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: count_denominators
int
count_denominators(struct atom *p)
{
	int n = 0;
	p = cdr(p);
	while (iscons(p)) {
		if (isdenominator(car(p)))
			n++;
		p = cdr(p);
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rax
leaq 0x3c705(%rip), %rcx     # 0x45a00
cmoveq %rax, %rcx
movq (%rcx), %r14
xorl %ebx, %ebx
cmpb $0x1, 0x10(%r14)
jne 0x9322
xorl %ebx, %ebx
movq (%r14), %rdi
callq 0x9329
addl %eax, %ebx
movq 0x8(%r14), %r14
cmpb $0x1, 0x10(%r14)
je 0x930d
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: isdenominator
int
isdenominator(struct atom *p)
{
	if (car(p) == symbol(POWER) && isnegativenumber(caddr(p)))
		return 1;
	else if (isrational(p) && !MEQUAL(p->u.q.b, 1))
		return 1;
	else
		return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb 0x10(%rdi), %cl
cmpb $0x1, %cl
leaq 0x3c6c6(%rip), %rax     # 0x45a00
movq %rax, %rdx
cmoveq %rdi, %rdx
movq (%rdx), %rdx
cmpq 0x3ef65(%rip), %rdx     # 0x482b0
je 0x936a
cmpb $0x4, %cl
jne 0x9366
movq 0x8(%rdi), %rcx
movl $0x1, %eax
cmpl $0x1, -0x4(%rcx)
jne 0x9368
cmpl $0x1, (%rcx)
jne 0x9368
xorl %eax, %eax
popq %rbp
retq
leaq 0x8(%rdi), %rdx
cmpb $0x1, %cl
cmovneq %rax, %rdx
movq (%rdx), %rdx
cmpb $0x1, 0x10(%rdx)
jne 0x9384
movq 0x8(%rdx), %rdx
jmp 0x938b
movq 0x3c675(%rip), %rdx     # 0x45a00
cmpb $0x1, 0x10(%rdx)
jne 0x9394
movq %rdx, %rax
movq (%rax), %rdx
movzbl 0x10(%rdx), %eax
cmpl $0x5, %eax
je 0x93b2
cmpl $0x4, %eax
jne 0x934d
movl $0x1, %eax
cmpb $0x1, 0x12(%rdx)
jne 0x934d
jmp 0x9368
movl $0x1, %eax
xorpd %xmm0, %xmm0
ucomisd (%rdx), %xmm0
jbe 0x934d
jmp 0x9368
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: count_numerators
int
count_numerators(struct atom *p)
{
	int n = 0;
	p = cdr(p);
	while (iscons(p)) {
		if (isnumerator(car(p)))
			n++;
		p = cdr(p);
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rax
leaq 0x3c627(%rip), %rcx     # 0x45a00
cmoveq %rax, %rcx
movq (%rcx), %r14
xorl %ebx, %ebx
cmpb $0x1, 0x10(%r14)
jne 0x9400
xorl %ebx, %ebx
movq (%r14), %rdi
callq 0x9407
addl %eax, %ebx
movq 0x8(%r14), %r14
cmpb $0x1, 0x10(%r14)
je 0x93eb
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: isnumerator
int
isnumerator(struct atom *p)
{
	if (car(p) == symbol(POWER) && isnegativenumber(caddr(p)))
		return 0;
	else if (isrational(p) && MEQUAL(p->u.q.a, 1))
		return 0;
	else
		return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb 0x10(%rdi), %al
cmpb $0x1, %al
leaq 0x3c5e9(%rip), %rcx     # 0x45a00
movq %rcx, %rdx
cmoveq %rdi, %rdx
movq (%rdx), %rdx
cmpq 0x3ee88(%rip), %rdx     # 0x482b0
je 0x9443
cmpb $0x4, %al
jne 0x943c
movq (%rdi), %rax
cmpl $0x1, -0x4(%rax)
jne 0x943c
cmpl $0x1, (%rax)
je 0x948f
movl $0x1, %eax
jmp 0x9491
leaq 0x8(%rdi), %rdx
cmpb $0x1, %al
cmovneq %rcx, %rdx
movq (%rdx), %rdx
cmpb $0x1, 0x10(%rdx)
jne 0x945c
movq 0x8(%rdx), %rdx
jmp 0x9463
movq 0x3c59d(%rip), %rdx     # 0x45a00
cmpb $0x1, 0x10(%rdx)
jne 0x946c
movq %rdx, %rcx
movq (%rcx), %rcx
movzbl 0x10(%rcx), %edx
cmpl $0x5, %edx
je 0x9485
cmpl $0x4, %edx
jne 0x942a
cmpb $0x1, 0x12(%rcx)
jne 0x942a
jmp 0x948f
xorpd %xmm0, %xmm0
ucomisd (%rcx), %xmm0
jbe 0x942a
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: subst
void
subst(void)
{
	int h, i, n;
	struct atom *p1, *p2, *p3;

	p3 = pop(); // new expr
	p2 = pop(); // old expr
	p1 = pop(); // expr

	if (p2 == symbol(NIL) || p3 == symbol(NIL)) {
		push(p1);
		return;
	}

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

	if (equal(p1, p2)) {
		push(p3);
		return;
	}

	if (!iscons(p1)) {
		push(p1);
		return;
	}

	// depth first

	h = tos;

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

	list(tos - h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x35e11(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x962c
leal -0x1(%rax), %ecx
movl %ecx, 0x35df8(%rip)     # 0x3f2b8
cmpl $0x1, %eax
jbe 0x962c
leaq 0x3f0f0(%rip), %rdx     # 0x485c0
movq (%rdx,%rcx,8), %r13
leal -0x2(%rax), %ecx
movl %ecx, 0x35ddb(%rip)     # 0x3f2b8
cmpl $0x2, %eax
je 0x962c
movq (%rdx,%rcx,8), %r14
addl $-0x3, %eax
movl %eax, 0x35dc5(%rip)     # 0x3f2b8
movq (%rdx,%rax,8), %r15
movq 0x3c502(%rip), %rax     # 0x45a00
cmpq %rax, %r14
sete %cl
cmpq %rax, %r13
sete %al
orb %cl, %al
cmpb $0x1, %al
je 0x9611
cmpb $0x7, 0x10(%r15)
jne 0x959f
movq %r13, -0x30(%rbp)
movq %r15, %rdi
callq 0x9638
movq %rax, %r15
movq (%rax), %rax
movslq 0x64(%rax), %r13
testq %r13, %r13
jle 0x9611
xorl %r12d, %r12d
movl $0xfffe795f, %ebx       # imm = 0xFFFE795F
movq (%r15), %rax
movq 0x68(%rax,%r12,8), %rdi
callq 0x8ba5
movq %r14, %rdi
callq 0x8ba5
movq -0x30(%rbp), %rdi
callq 0x8ba5
callq 0x9493
movl 0x35d49(%rip), %eax     # 0x3f2b8
leal (%rax,%rbx), %ecx
cmpl %ebx, %ecx
jbe 0x962c
decl %eax
movl %eax, 0x35d36(%rip)     # 0x3f2b8
leaq 0x3f037(%rip), %rcx     # 0x485c0
movq (%rcx,%rax,8), %rax
movq (%r15), %rcx
movq %rax, 0x68(%rcx,%r12,8)
incq %r12
cmpq %r12, %r13
jne 0x9546
jmp 0x9611
movq %r15, %rdi
movq %r14, %rsi
callq 0x8d48
testl %eax, %eax
je 0x9627
cmpb $0x1, 0x10(%r15)
jne 0x9611
movl 0x35cfd(%rip), %ebx     # 0x3f2b8
leaq 0x3c43e(%rip), %r12     # 0x45a00
movq (%r15), %rdi
callq 0x8ba5
movq %r14, %rdi
callq 0x8ba5
movq %r13, %rdi
callq 0x8ba5
callq 0x9493
leaq 0x8(%r15), %rax
cmpb $0x1, 0x10(%r15)
cmovneq %r12, %rax
movq (%rax), %r15
cmpb $0x1, 0x10(%r15)
je 0x95c2
movl 0x35cbc(%rip), %edi     # 0x3f2b8
subl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8b7d
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8ba5
movq %r13, %rdi
jmp 0x9614
leaq 0x2590e(%rip), %rdi     # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: copy_tensor
struct atom *
copy_tensor(struct atom *p1)
{
	int i;
	struct atom *p2;

	p2 = alloc_tensor(p1->u.tensor->nelem);

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

	for (i = 0; i < p1->u.tensor->ndim; i++)
		p2->u.tensor->dim[i] = p1->u.tensor->dim[i];

	for (i = 0; i < p1->u.tensor->nelem; i++)
		p2->u.tensor->elem[i] = p1->u.tensor->elem[i];

	return p2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movl 0x64(%rax), %edi
callq 0x7893
movq (%rbx), %rcx
movl (%rcx), %ecx
movq (%rax), %rdx
movl %ecx, (%rdx)
movq (%rbx), %rcx
cmpl $0x0, (%rcx)
jle 0x9679
xorl %edx, %edx
movl 0x4(%rcx,%rdx,4), %ecx
movq (%rax), %rsi
movl %ecx, 0x4(%rsi,%rdx,4)
incq %rdx
movq (%rbx), %rcx
movslq (%rcx), %rsi
cmpq %rsi, %rdx
jl 0x9660
cmpl $0x0, 0x64(%rcx)
jle 0x969d
xorl %edx, %edx
movq 0x68(%rcx,%rdx,8), %rcx
movq (%rax), %rsi
movq %rcx, 0x68(%rsi,%rdx,8)
incq %rdx
movq (%rbx), %rcx
movslq 0x64(%rcx), %rsi
cmpq %rsi, %rdx
jl 0x9681
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: evalg
void
evalg(void)
{
	if (gc_level == eval_level && alloc_count > MAXBLOCKS * BLOCKSIZE / 10)
		gc();
	gc_level++;
	evalf();
	gc_level--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x102412(%rip), %eax    # 0x10bac0
cmpl 0x102410(%rip), %eax    # 0x10bac4
jne 0x96cd
cmpl $0x1e8481, 0x35bf0(%rip) # imm = 0x1E8481
jl 0x96cd
callq 0x75c1
movl 0x1023f3(%rip), %eax    # 0x10bac0
incl %eax
movl %eax, 0x1023eb(%rip)    # 0x10bac0
callq 0x96e2
decl 0x1023e0(%rip)          # 0x10bac0
popq %rbp
retq