LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_expr
void
fmt_expr(struct atom *p)
{
	if (isnegativeterm(p) || (car(p) == symbol(ADD) && isnegativeterm(cadr(p))))
		fmt_roman_char(MINUS_SIGN);

	if (car(p) == symbol(ADD))
		fmt_expr_nib(p);
	else
		fmt_term(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0xac49
leaq 0x20f25(%rip), %r14     # 0x45a00
testl %eax, %eax
je 0x24af6
movl $0xe28892, %edi         # imm = 0xE28892
callq 0x24a13
movb 0x10(%rbx), %r15b
movq 0x237ac(%rip), %r12     # 0x482a0
jmp 0x24b17
movb 0x10(%rbx), %r15b
cmpb $0x1, %r15b
movq %r14, %rax
cmoveq %rbx, %rax
movq (%rax), %r12
movq 0x23791(%rip), %rax     # 0x482a0
cmpq %rax, %r12
je 0x24b44
movq %rax, %r12
cmpb $0x1, %r15b
cmoveq %rbx, %r14
cmpq %r12, (%r14)
je 0x24b34
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x25ad6
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x25a2e
leaq 0x8(%rbx), %rax
cmpb $0x1, %r15b
cmovneq %r14, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r14, %rax
movq (%rax), %rdi
callq 0xac49
testl %eax, %eax
jne 0x24adf
jmp 0x24b17
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_update_subexpr
void
fmt_update_subexpr(void)
{
	int d, h, w;
	struct atom *p1;

	p1 = pop();

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

	// delimiters have vertical symmetry (h - m == d + m, m = 1/2)

	if (h > 1 || d > 0) {
		h = MAX(h, d + 1) + 1; // plus extra
		d = h - 1; // by symmetry
	}

	w += 2;

	push_double(EMIT_SUBEXPR);
	push_double(h);
	push_double(d);
	push_double(w);
	push(p1);

	list(5);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x1a474(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x25011
decl %eax
movl %eax, 0x1a45c(%rip)     # 0x3f2b8
leaq 0x2375d(%rip), %rcx     # 0x485c0
movq (%rcx,%rax,8), %rbx
cmpb $0x1, 0x10(%rbx)
leaq 0x8(%rbx), %rcx
leaq 0x20b8a(%rip), %rax     # 0x45a00
cmovneq %rax, %rcx
movq (%rcx), %rcx
movb 0x10(%rcx), %dl
cmpb $0x1, %dl
jne 0x24ecf
movq (%rcx), %rax
cvttsd2si (%rax), %r14d
movq 0x8(%rcx), %rsi
cmpb $0x1, 0x10(%rsi)
leaq 0x20b64(%rip), %rax     # 0x45a00
movq %rax, %rdi
cmoveq %rsi, %rdi
movq (%rdi), %rdi
cvttsd2si (%rdi), %r15d
jne 0x24f1d
movq 0x8(%rsi), %rsi
cmpb $0x1, 0x10(%rsi)
jne 0x24f32
cmpb $0x1, %dl
jne 0x24f00
movq 0x8(%rcx), %rdx
cmpb $0x1, 0x10(%rdx)
jne 0x24f2a
addq $0x8, %rcx
movq %rcx, %rax
jmp 0x24f14
movq 0x20b2a(%rip), %rcx     # 0x45a00
cvttsd2si (%rcx), %r14d
cmpb $0x1, 0x10(%rcx)
jne 0x24f2f
movq (%rcx), %rcx
cvttsd2si (%rcx), %r15d
movq 0x20b10(%rip), %rcx     # 0x45a00
cmpb $0x1, 0x10(%rcx)
jne 0x24f32
movq 0x8(%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0x24f32
leaq 0x20af9(%rip), %rax     # 0x45a00
movq 0x20af2(%rip), %rcx     # 0x45a00
cmpb $0x1, 0x10(%rcx)
jne 0x24f2a
movq (%rax), %rax
addq $0x8, %rax
jmp 0x24f2a
movq 0x20adc(%rip), %rcx     # 0x45a00
cmpb $0x1, 0x10(%rcx)
jne 0x24f32
movq (%rax), %rax
jmp 0x24f32
movl %r14d, %r15d
movq (%rax), %rax
movsd (%rax), %xmm0
cmpl $0x1, %r14d
jg 0x24f44
testl %r15d, %r15d
jle 0x24f52
incl %r15d
cmpl %r14d, %r15d
cmovlel %r14d, %r15d
leal 0x1(%r15), %r14d
cvttsd2si %xmm0, %r12d
addl $0x2, %r12d
callq 0x74dc
movb $0x5, %r13b
movb %r13b, 0x10(%rax)
movabsq $0x4018000000000000, %rcx # imm = 0x4018000000000000
movq %rcx, (%rax)
movq %rax, %rdi
callq 0x8ba5
xorps %xmm0, %xmm0
cvtsi2sd %r14d, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x74dc
movb %r13b, 0x10(%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rax, %rdi
callq 0x8ba5
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x74dc
movb %r13b, 0x10(%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rax, %rdi
callq 0x8ba5
xorps %xmm0, %xmm0
cvtsi2sd %r12d, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x74dc
movb %r13b, 0x10(%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rax, %rdi
callq 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
movl $0x5, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8b7d
leaq 0x9f29(%rip), %rdi      # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_base
void
fmt_base(struct atom *p)
{
	if (isnegativenumber(p) || isfraction(p) || isdouble(p) || car(p) == symbol(ADD) || car(p) == symbol(MULTIPLY) || car(p) == symbol(POWER))
		fmt_subexpr(p);
	else
		fmt_expr(p);
}

// Assembly:
movzbl 0x10(%rdi), %eax
movq %rdi, %rcx
cmpl $0x1, %eax
je 0x2504f
cmpl $0x5, %eax
je 0x25081
cmpl $0x4, %eax
jne 0x25048
cmpb $0x1, 0x12(%rdi)
je 0x25081
movq 0x8(%rdi), %rcx
cmpl $0x1, -0x4(%rcx)
jne 0x25081
cmpl $0x1, (%rcx)
jne 0x25081
leaq 0x209b1(%rip), %rcx     # 0x45a00
movq (%rcx), %rcx
cmpq 0x23247(%rip), %rcx     # 0x482a0
je 0x25081
cmpb $0x1, %al
leaq 0x2099c(%rip), %rax     # 0x45a00
cmoveq %rdi, %rax
movq (%rax), %rax
cmpq 0x23236(%rip), %rax     # 0x482a8
je 0x25081
cmpq 0x23235(%rip), %rax     # 0x482b0
jne 0x24ac1
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0x1a22b(%rip), %ebx     # 0x3f2b8
callq 0x24ac1
movl %ebx, %edi
callq 0x24b6d
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x24e30
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_denominators
void
fmt_denominators(struct atom *p)
{
	int n, t;
	char *s;
	struct atom *q;

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

	while (iscons(p)) {

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

		if (!isdenominator(q))
			continue;

		if (tos > t)
			fmt_space();

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

		if (isminusone(caddr(q))) {
			q = cadr(q);
			if (car(q) == symbol(ADD) && n == 1)
				fmt_expr(q); // parens not needed
			else
				fmt_factor(q);
		} else {
			fmt_base(cadr(q));
			fmt_numeric_exponent(caddr(q)); // sign is not emitted
		}
	}

	fmt_update_list(t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl 0x1a1da(%rip), %eax     # 0x3f2b8
movl %eax, -0x2c(%rbp)
callq 0x92e5
cmpb $0x1, 0x10(%r14)
leaq 0x8(%r14), %rcx
leaq 0x2090a(%rip), %r12     # 0x45a00
cmovneq %r12, %rcx
movl %eax, -0x30(%rbp)
movq (%rcx), %r13
cmpb $0x1, 0x10(%r13)
jne 0x25263
movq (%r13), %r15
movq 0x8(%r13), %r13
movq %r15, %rdi
callq 0x9329
testl %eax, %eax
je 0x25100
movl -0x2c(%rbp), %eax
cmpl %eax, 0x1a190(%rip)     # 0x3f2b8
jle 0x2512f
callq 0x25279
movzbl 0x10(%r15), %r14d
cmpl $0x1, %r14d
je 0x2516c
movq %r12, %rax
cmpl $0x4, %r14d
jne 0x25170
movq 0x8(%r15), %rdi
callq 0x7d7b
movq %rax, %r15
movb (%rax), %al
testb %al, %al
je 0x25100
incq %r15
movsbl %al, %edi
callq 0x24a13
movb (%r15), %al
incq %r15
testb %al, %al
jne 0x25158
jmp 0x25100
leaq 0x8(%r15), %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %r12, %rax
jne 0x2518f
leaq 0x8(%r15), %rax
cmpb $0x1, %r14b
cmovneq %r12, %rax
movq (%rax), %rax
addq $0x8, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
movq %r12, %rax
jne 0x251b9
leaq 0x8(%r15), %rax
cmpb $0x1, %r14b
cmovneq %r12, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
leaq 0x8(%rax), %rax
cmovneq %r12, %rax
movq (%rax), %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0xd1c4
leaq 0x8(%r15), %rbx
cmpb $0x1, %r14b
movq %r12, %rcx
cmoveq %rbx, %rcx
movq (%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
cmovneq %r12, %rcx
movq (%rcx), %rdi
testl %eax, %eax
je 0x2521c
cmpl $0x1, -0x30(%rbp)
sete %al
cmpb $0x1, 0x10(%rdi)
movq %r12, %rcx
cmoveq %rdi, %rcx
movq (%rcx), %rcx
cmpq 0x23098(%rip), %rcx     # 0x482a0
sete %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x25239
callq 0x24ac1
jmp 0x25100
callq 0x2501d
cmpb $0x1, 0x10(%r15)
cmovneq %r12, %rbx
movq (%rbx), %rax
cmpb $0x1, 0x10(%rax)
jne 0x25243
movq 0x8(%rax), %rax
jmp 0x2524a
callq 0x2531c
jmp 0x25100
movq 0x207b6(%rip), %rax     # 0x45a00
cmpb $0x1, 0x10(%rax)
movq %r12, %rcx
jne 0x25256
movq %rax, %rcx
movq (%rcx), %rdi
callq 0x253de
jmp 0x25100
movl -0x2c(%rbp), %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x24b6d
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_space
void
fmt_space(void)
{
	push_double(EMIT_SPACE);
	push_double(0);
	push_double(0);
	push_double(1);

	list(4);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x74dc
movb $0x5, %bl
movb %bl, 0x10(%rax)
movabsq $0x3ff0000000000000, %r14 # imm = 0x3FF0000000000000
movq %r14, (%rax)
movq %rax, %rdi
callq 0x8ba5
callq 0x74dc
movb %bl, 0x10(%rax)
xorl %r15d, %r15d
movq %r15, (%rax)
movq %rax, %rdi
callq 0x8ba5
callq 0x74dc
movb %bl, 0x10(%rax)
movq %r15, (%rax)
movq %rax, %rdi
callq 0x8ba5
callq 0x74dc
movb %bl, 0x10(%rax)
movq %r14, (%rax)
movq %rax, %rdi
callq 0x8ba5
movl $0x4, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8b7d
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_factor
void
fmt_factor(struct atom *p)
{
	if (isrational(p)) {
		fmt_rational(p);
		return;
	}

	if (isdouble(p)) {
		fmt_double(p);
		return;
	}

	if (issymbol(p)) {
		fmt_symbol(p);
		return;
	}

	if (isstr(p)) {
		fmt_string(p);
		return;
	}

	if (istensor(p)) {
		fmt_tensor(p);
		return;
	}

	if (iscons(p)) {
		if (car(p) == symbol(POWER))
			fmt_power(p);
		else if (car(p) == symbol(ADD) || car(p) == symbol(MULTIPLY))
			fmt_subexpr(p);
		else
			fmt_function(p);
		return;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movzbl 0x10(%rdi), %eax
decl %eax
cmpl $0x6, %eax
ja 0x25399
leaq 0x4d98(%rip), %rcx      # 0x2a0cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x25bf1
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x25b20
movq (%rdi), %rax
cmpq 0x22f53(%rip), %rax     # 0x482b0
je 0x253b6
cmpq 0x22f3a(%rip), %rax     # 0x482a0
je 0x253c1
cmpq 0x22f39(%rip), %rax     # 0x482a8
je 0x253c1
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x25e9f
movq (%rdi), %rbx
movb (%rbx), %al
testb %al, %al
je 0x25399
incq %rbx
movsbl %al, %edi
callq 0x24a13
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x25388
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x25cf3
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x25489
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x25d16
movl 0x19ef1(%rip), %ebx     # 0x3f2b8
callq 0x24ac1
movl %ebx, %edi
callq 0x24b6d
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x24e30
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_numeric_exponent
void
fmt_numeric_exponent(struct atom *p)
{
	int t;
	char *s;

	fmt_level++;

	t = tos;

	if (isrational(p)) {
		s = mstr(p->u.q.a);
		fmt_roman_string(s);
		if (!MEQUAL(p->u.q.b, 1)) {
			fmt_roman_char('/');
			s = mstr(p->u.q.b);
			fmt_roman_string(s);
		}
	} else
		fmt_double(p);

	fmt_update_list(t);

	fmt_level--;

	fmt_update_superscript();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
incl 0xf100a(%rip)           # 0x1163f8
movq %rdi, %r14
movl 0x19ec1(%rip), %ebx     # 0x3f2b8
cmpb $0x4, 0x10(%rdi)
jne 0x25465
movq (%r14), %rdi
callq 0x7d7b
movq %rax, %r15
movb (%rax), %al
testb %al, %al
je 0x25423
incq %r15
movsbl %al, %edi
callq 0x24a13
movb (%r15), %al
incq %r15
testb %al, %al
jne 0x25411
movq 0x8(%r14), %rax
cmpl $0x1, -0x4(%rax)
jne 0x25432
cmpl $0x1, (%rax)
je 0x2546d
movl $0x2f, %edi
callq 0x24a13
movq 0x8(%r14), %rdi
callq 0x7d7b
movq %rax, %r14
movb (%rax), %al
testb %al, %al
je 0x2546d
incq %r14
movsbl %al, %edi
callq 0x24a13
movb (%r14), %al
incq %r14
testb %al, %al
jne 0x25451
jmp 0x2546d
movq %r14, %rdi
callq 0x25489
movl %ebx, %edi
callq 0x24b6d
decl 0xf0f7e(%rip)           # 0x1163f8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x25581
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_double
void
fmt_double(struct atom *p)
{
	int t;
	char *s;

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

	s = strbuf;

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

	if (!*s)
		return;

	s++;

	fmt_roman_char(MULTIPLY_SIGN);

	fmt_roman_string("10");

	// superscripted exponent

	fmt_level++;

	t = tos;

	// sign of exponent

	if (*s == '+')
		s++;
	else if (*s == '-') {
		fmt_roman_char(MINUS_SIGN);
		s++;
	}

	// skip leading zeroes in exponent

	while (*s == '0')
		s++;

	fmt_roman_string(s);

	fmt_update_list(t);

	fmt_level--;

	fmt_update_superscript();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movsd (%rdi), %xmm0
andps 0x4c81(%rip), %xmm0     # 0x2a120
leaq 0xf146a(%rip), %rdi     # 0x116910
leaq 0x4f26(%rip), %rdx      # 0x2a3d3
movl $0x3e8, %esi            # imm = 0x3E8
movb $0x1, %al
callq 0x7100
leaq 0xf1451(%rip), %r14     # 0x116911
movzbl -0x1(%r14), %eax
testl %eax, %eax
je 0x25578
cmpl $0x45, %eax
je 0x254e4
cmpl $0x65, %eax
je 0x254e4
movsbl %al, %edi
callq 0x24a13
incq %r14
jmp 0x254c0
movl $0xc397, %edi           # imm = 0xC397
callq 0x24a13
movb $0x31, %al
xorl %r15d, %r15d
leaq 0x569d(%rip), %rbx      # 0x2ab97
leaq 0x1(%r15), %r12
movsbl %al, %edi
callq 0x24a13
movb 0x1(%r15,%rbx), %al
movq %r12, %r15
cmpq $0x2, %r12
jne 0x254fa
incl 0xf0ede(%rip)           # 0x1163f8
movl 0x19d98(%rip), %ebx     # 0x3f2b8
movzbl (%r14), %eax
cmpl $0x2b, %eax
je 0x25538
cmpl $0x2d, %eax
jne 0x2553b
movl $0xe28892, %edi         # imm = 0xE28892
callq 0x24a13
incq %r14
incq %r14
movzbl -0x1(%r14), %eax
cmpl $0x30, %eax
je 0x2553b
testl %eax, %eax
je 0x2555e
movsbl %al, %edi
callq 0x24a13
movb (%r14), %al
incq %r14
testb %al, %al
jne 0x2554c
movl %ebx, %edi
callq 0x24b6d
decl 0xf0e8d(%rip)           # 0x1163f8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x25581
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_exponent
void
fmt_exponent(struct atom *p)
{
	if (isnum(p) && !isnegativenumber(p)) {
		fmt_numeric_exponent(p); // sign is not emitted
		return;
	}

	fmt_level++;
	fmt_list(p);
	fmt_level--;

	fmt_update_superscript();
}

// Assembly:
movb 0x10(%rdi), %al
movl %eax, %ecx
andb $-0x2, %cl
cmpb $0x4, %cl
jne 0x259fa
cmpb $0x4, %al
jne 0x259f0
cmpb $0x1, 0x12(%rdi)
jne 0x253de
jmp 0x259fa
xorpd %xmm0, %xmm0
ucomisd (%rdi), %xmm0
jbe 0x25a29
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
incl 0xf09f2(%rip)           # 0x1163f8
movl 0x198ac(%rip), %ebx     # 0x3f2b8
callq 0x24ac1
movl %ebx, %edi
callq 0x24b6d
decl 0xf09da(%rip)           # 0x1163f8
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x25581
jmp 0x253de
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_expr_nib
void
fmt_expr_nib(struct atom *p)
{
	p = cdr(p);
	fmt_term(car(p));
	p = cdr(p);
	while (iscons(p)) {
		if (isnegativeterm(car(p)))
			fmt_infix_operator(MINUS_SIGN);
		else
			fmt_infix_operator(PLUS_SIGN);
		fmt_term(car(p));
		p = cdr(p);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpb $0x1, 0x10(%rdi)
leaq 0x8(%rdi), %rax
leaq 0x1ffb8(%rip), %r14     # 0x45a00
cmovneq %r14, %rax
movq (%rax), %rbx
cmpb $0x1, 0x10(%rbx)
movq %r14, %rax
cmoveq %rbx, %rax
movq (%rax), %rdi
callq 0x25ad6
leaq 0x8(%rbx), %rax
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %rax
movq (%rax), %r15
cmpb $0x1, 0x10(%r15)
jne 0x25acd
movl $0x2b, %r12d
movq (%r15), %rdi
callq 0xac49
movl %eax, %ebx
callq 0x25279
testl %ebx, %ebx
movl $0xe28892, %edi         # imm = 0xE28892
cmovel %r12d, %edi
callq 0x24a13
callq 0x25279
cmpb $0x1, 0x10(%r15)
movq %r14, %rax
cmoveq %r15, %rax
movq (%rax), %rdi
callq 0x25ad6
leaq 0x8(%r15), %rax
cmpb $0x1, 0x10(%r15)
cmovneq %r14, %rax
movq (%rax), %r15
cmpb $0x1, 0x10(%r15)
je 0x25a7e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_rational
void
fmt_rational(struct atom *p)
{
	int t;
	char *s;

	if (MEQUAL(p->u.q.b, 1)) {
		s = mstr(p->u.q.a);
		fmt_roman_string(s);
		return;
	}

	fmt_level++;

	t = tos;
	s = mstr(p->u.q.a);
	fmt_roman_string(s);
	fmt_update_list(t);

	t = tos;
	s = mstr(p->u.q.b);
	fmt_roman_string(s);
	fmt_update_list(t);

	fmt_level--;

	fmt_update_fraction();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpl $0x1, -0x4(%rax)
jne 0x25b6c
cmpl $0x1, (%rax)
jne 0x25b6c
movq (%rbx), %rdi
callq 0x7d7b
movq %rax, %rbx
movb (%rax), %al
testb %al, %al
je 0x25b61
incq %rbx
movsbl %al, %edi
callq 0x24a13
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x25b50
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
incl 0xf0886(%rip)           # 0x1163f8
movl 0x1973f(%rip), %r14d    # 0x3f2b8
movq (%rbx), %rdi
callq 0x7d7b
movq %rax, %r15
movb (%rax), %al
testb %al, %al
je 0x25b9f
incq %r15
movsbl %al, %edi
callq 0x24a13
movb (%r15), %al
incq %r15
testb %al, %al
jne 0x25b8d
movl %r14d, %edi
callq 0x24b6d
movl 0x1970a(%rip), %r14d    # 0x3f2b8
movq 0x8(%rbx), %rdi
callq 0x7d7b
movq %rax, %rbx
movb (%rax), %al
testb %al, %al
je 0x25bd4
incq %rbx
movsbl %al, %edi
callq 0x24a13
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x25bc3
movl %r14d, %edi
callq 0x24b6d
decl 0xf0816(%rip)           # 0x1163f8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x262b1
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_symbol
void
fmt_symbol(struct atom *p)
{
	int k, t;
	char *s;

	if (p == symbol(EXP1)) {
		fmt_roman_string("exp(1)");
		return;
	}

	s = printname(p);

	if (iskeyword(p) || p == symbol(LAST) || p == symbol(TRACE) || p == symbol(TTY)) {
		fmt_roman_string(s);
		return;
	}

	k = fmt_symbol_fragment(s, 0);

	if (s[k] == '\0')
		return;

	// emit subscript

	fmt_level++;

	t = tos;

	while (s[k] != '\0')
		k = fmt_symbol_fragment(s, k);

	fmt_update_list(t);

	fmt_level--;

	fmt_update_subscript();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpq %rdi, 0x226c9(%rip)     # 0x482c8
je 0x25c13
movb 0x10(%rdi), %al
movl %eax, %ecx
andb $-0x2, %cl
cmpb $0x2, %cl
jne 0x25c38
movq (%rdi), %rbx
jmp 0x25c3f
movb $0x65, %al
movl $0x1, %ebx
leaq 0x4778(%rip), %r14      # 0x2a399
movsbl %al, %edi
callq 0x24a13
movb (%rbx,%r14), %al
incq %rbx
cmpq $0x7, %rbx
jne 0x25c21
jmp 0x25cad
leaq 0x9359(%rip), %rbx      # 0x2ef98
cmpb $0x2, %al
je 0x25c93
cmpq %rdi, 0x1f776(%rip)     # 0x453c0
je 0x25c93
cmpq %rdi, 0x210cd(%rip)     # 0x46d20
je 0x25c93
cmpq %rdi, 0x210d4(%rip)     # 0x46d30
je 0x25c93
movq %rbx, %rdi
xorl %esi, %esi
callq 0x26f22
movslq %eax, %rcx
cmpb $0x0, (%rbx,%rcx)
je 0x25cad
incl 0xf0781(%rip)           # 0x1163f8
movl 0x1963a(%rip), %r14d    # 0x3f2b8
cmpb $0x0, (%rbx,%rcx)
je 0x25cb2
movq %rbx, %rdi
movl %eax, %esi
callq 0x26f22
movslq %eax, %rcx
jmp 0x25c7e
movb (%rbx), %al
testb %al, %al
je 0x25cad
incq %rbx
movsbl %al, %edi
callq 0x24a13
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x25c9c
popq %rbx
popq %r14
popq %rbp
retq
movl %r14d, %edi
callq 0x24b6d
decl 0xf0738(%rip)           # 0x1163f8
popq %rbx
popq %r14
popq %rbp
jmp 0x26fab
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_power
void
fmt_power(struct atom *p)
{
	if (cadr(p) == symbol(EXP1)) {
		fmt_roman_string("exp");
		fmt_args(cdr(p));
		return;
	}

	if (isimaginaryunit(p)) {
		if (isimaginaryunit(get_binding(symbol(J_LOWER)))) {
			fmt_roman_char('j');
			return;
		}
		if (isimaginaryunit(get_binding(symbol(I_LOWER)))) {
			fmt_roman_char('i');
			return;
		}
	}

	if (isnegativenumber(caddr(p))) {
		fmt_reciprocal(p);
		return;
	}

	fmt_base(cadr(p));
	fmt_exponent(caddr(p));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movb 0x10(%rdi), %r12b
leaq 0x8(%rdi), %r14
cmpb $0x1, %r12b
leaq 0x1fcc9(%rip), %r15     # 0x45a00
movq %r15, %rax
cmoveq %r14, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r15, %rax
movq (%rax), %rax
cmpq 0x22575(%rip), %rax     # 0x482c8
je 0x25d84
movq %rbx, %rdi
callq 0x173ff
testl %eax, %eax
je 0x25df5
movq 0x1f01c(%rip), %rdi     # 0x44d88
callq 0xf05c
movq %rax, %rdi
callq 0x173ff
testl %eax, %eax
je 0x25dc7
movl $0x6a, %edi
jmp 0x25de4
movb $0x65, %al
movl $0x1, %r15d
leaq 0x9269(%rip), %r12      # 0x2effc
movsbl %al, %edi
callq 0x24a13
movb (%r15,%r12), %al
incq %r15
cmpq $0x4, %r15
jne 0x25d93
cmpb $0x1, 0x10(%rbx)
leaq 0x1fc4d(%rip), %rax     # 0x45a00
cmoveq %r14, %rax
movq (%rax), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x24978
movq 0x1ec9a(%rip), %rdi     # 0x44a68
callq 0xf05c
movq %rax, %rdi
callq 0x173ff
testl %eax, %eax
je 0x25df1
movl $0x69, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x24a13
movb 0x10(%rbx), %r12b
cmpb $0x1, %r12b
movq %r15, %rax
cmoveq %r14, %rax
movq (%rax), %rax
movb 0x10(%rax), %cl
cmpb $0x1, %cl
jne 0x25e11
movq 0x8(%rax), %rdx
jmp 0x25e18
movq 0x1fbe8(%rip), %rdx     # 0x45a00
cmpb $0x1, 0x10(%rdx)
jne 0x25e21
movq %rdx, %r15
movq (%r15), %rdx
movzbl 0x10(%rdx), %esi
cmpl $0x5, %esi
je 0x25e48
cmpl $0x4, %esi
jne 0x25e52
cmpb $0x1, 0x12(%rdx)
jne 0x25e52
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x26e2b
xorpd %xmm0, %xmm0
ucomisd (%rdx), %xmm0
ja 0x25e38
cmpb $0x1, %cl
leaq 0x1fba4(%rip), %r15     # 0x45a00
cmovneq %r15, %rax
movq (%rax), %rdi
callq 0x2501d
cmpb $0x1, 0x10(%rbx)
cmovneq %r15, %r14
movq (%r14), %rax
cmpb $0x1, 0x10(%rax)
jne 0x25e7f
movq 0x8(%rax), %rax
jmp 0x25e86
movq 0x1fb7a(%rip), %rax     # 0x45a00
cmpb $0x1, 0x10(%rax)
jne 0x25e8f
movq %rax, %r15
movq (%r15), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x259d3
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_numerators
void
fmt_numerators(struct atom *p)
{
	int n, t;
	char *s;
	struct atom *q;

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

	while (iscons(p)) {

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

		if (!isnumerator(q))
			continue;

		if (tos > t)
			fmt_space();

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

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

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

	fmt_update_list(t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl 0x190ea(%rip), %ebx     # 0x3f2b8
callq 0x93c3
cmpb $0x1, 0x10(%r14)
leaq 0x8(%r14), %rcx
leaq 0x1f81d(%rip), %r12     # 0x45a00
cmovneq %r12, %rcx
movq (%rcx), %r13
cmpb $0x1, 0x10(%r13)
jne 0x26292
movl %eax, %r14d
movq (%r13), %r15
movq 0x8(%r13), %r13
movq %r15, %rdi
callq 0x9407
testl %eax, %eax
je 0x2627f
cmpl %ebx, 0x190a6(%rip)     # 0x3f2b8
jle 0x26219
callq 0x25279
movzbl 0x10(%r15), %ecx
movq %r15, %rax
cmpl $0x1, %ecx
je 0x26256
cmpl $0x4, %ecx
jne 0x26253
movq (%r15), %rdi
callq 0x7d7b
movq %rax, %r15
movb (%rax), %al
testb %al, %al
je 0x2627f
incq %r15
movsbl %al, %edi
callq 0x24a13
movb (%r15), %al
incq %r15
testb %al, %al
jne 0x2623f
jmp 0x2627f
movq %r12, %rax
cmpl $0x1, %r14d
sete %cl
movq (%rax), %rax
cmpq 0x22039(%rip), %rax     # 0x482a0
sete %al
andb %cl, %al
movq %r15, %rdi
cmpb $0x1, %al
jne 0x2627a
callq 0x24ac1
jmp 0x2627f
callq 0x2531c
cmpb $0x1, 0x10(%r13)
je 0x261f8
cmpl 0x19028(%rip), %ebx     # 0x3f2b8
jne 0x2629c
movl $0x31, %edi
callq 0x24a13
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x24b6d
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_indices
void
fmt_indices(struct atom *p)
{
	fmt_roman_char('[');

	p = cdr(p);

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

	fmt_roman_char(']');
}

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

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

	// compute element span

	span = 1;

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

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

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

	fmt_update_table(n, m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq (%rdi), %rax
movl (%rax), %edi
movl %edi, %ecx
subl %esi, %ecx
jne 0x26770
movslq %edx, %rcx
movq 0x68(%rax,%rcx,8), %rdi
movl 0x18b62(%rip), %ebx     # 0x3f2b8
callq 0x24ac1
movl %ebx, %edi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x24b6d
leal 0x2(%rsi), %r15d
movl $0x1, %r13d
cmpl %edi, %r15d
jge 0x2679b
movslq %r15d, %rdi
leaq (%rax,%rdi,4), %r8
addq $0x4, %r8
addl $-0x2, %ecx
xorl %edi, %edi
imull (%r8,%rdi,4), %r13d
incq %rdi
cmpl %edi, %ecx
jne 0x2678f
movslq %esi, %rcx
movl 0x4(%rax,%rcx,4), %esi
movl 0x8(%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
movl %esi, -0x30(%rbp)
testl %esi, %esi
jle 0x267f4
movl %r13d, %eax
imull -0x2c(%rbp), %eax
movl %eax, -0x38(%rbp)
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
movl %edx, -0x34(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0x267e4
movl -0x34(%rbp), %ebx
movl -0x2c(%rbp), %r12d
movq %r14, %rdi
movl %r15d, %esi
movl %ebx, %edx
callq 0x26729
addl %r13d, %ebx
decl %r12d
jne 0x267cf
movl -0x3c(%rbp), %eax
incl %eax
movl -0x34(%rbp), %edx
addl -0x38(%rbp), %edx
cmpl -0x30(%rbp), %eax
jne 0x267bc
movl -0x30(%rbp), %edi
movl -0x2c(%rbp), %esi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2680d
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_reciprocal
void
fmt_reciprocal(struct atom *p)
{
	int t;

	fmt_roman_char('1'); // numerator

	t = tos;

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

	fmt_update_list(t);

	fmt_update_fraction();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x31, %edi
callq 0x24a13
leaq 0x8(%r14), %r12
cmpb $0x1, 0x10(%r14)
leaq 0x1ebaa(%rip), %rax     # 0x45a00
movq %rax, %rcx
cmoveq %r12, %rcx
movl 0x18455(%rip), %ebx     # 0x3f2b8
movq (%rcx), %r13
cmpb $0x1, 0x10(%r13)
jne 0x26e82
movq 0x8(%r13), %rax
cmpb $0x1, 0x10(%rax)
leaq 0x1eb84(%rip), %r15     # 0x45a00
cmoveq %rax, %r15
jmp 0x26e93
movq 0x1eb77(%rip), %r15     # 0x45a00
cmpb $0x1, 0x10(%r15)
jne 0x26eab
movq %rax, %r13
movq (%r15), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0xd1c4
movq (%r13), %r15
jmp 0x26ebd
movq %r15, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0xd1c4
movq %r15, %rdi
testl %eax, %eax
je 0x26ecb
callq 0x24ac1
jmp 0x26f08
callq 0x2501d
cmpb $0x1, 0x10(%r14)
leaq 0x1eb24(%rip), %rax     # 0x45a00
cmovneq %rax, %r12
movq (%r12), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0x26ef0
movq 0x8(%rcx), %rcx
jmp 0x26ef7
movq 0x1eb09(%rip), %rcx     # 0x45a00
cmpb $0x1, 0x10(%rcx)
jne 0x26f00
movq %rcx, %rax
movq (%rax), %rdi
callq 0x253de
movl %ebx, %edi
callq 0x24b6d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x262b1
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_symbol_fragment
int
fmt_symbol_fragment(char *s, int k)
{
	int c, i, n;
	char *t;

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

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

	c = symbol_unicode_tab[i];

	fmt_roman_char(c);

	return k + n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, -0x2c(%rbp)
movslq %esi, %r14
addq %rdi, %r14
leaq 0x17230(%rip), %rbx     # 0x3e170
xorl %r13d, %r13d
movq (%rbx), %r12
movq %r12, %rdi
callq 0x70e0
movq %rax, %r15
movslq %r15d, %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x7080
testl %eax, %eax
je 0x26f84
addq $0x4, %r13
addq $0x8, %rbx
cmpq $0xc4, %r13
jne 0x26f43
movsbl (%r14), %edi
callq 0x24a13
movl -0x2c(%rbp), %eax
incl %eax
jmp 0x26f9c
leaq 0x17375(%rip), %rax     # 0x3e300
movl (%r13,%rax), %edi
callq 0x24a13
addl -0x2c(%rbp), %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: fmt_update_subscript
void
fmt_update_subscript(void)
{
	int d, dx, dy, h, w;
	struct atom *p1;

	p1 = pop();

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

	dx = 0;
	dy = 1;

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

	list(7);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl 0x182fa(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x271a3
decl %eax
movl %eax, 0x182e2(%rip)     # 0x3f2b8
leaq 0x215e3(%rip), %rcx     # 0x485c0
movq (%rcx,%rax,8), %rbx
cmpb $0x1, 0x10(%rbx)
leaq 0x8(%rbx), %rcx
leaq 0x1ea10(%rip), %rax     # 0x45a00
cmovneq %rax, %rcx
movq (%rcx), %rcx
movb 0x10(%rcx), %dl
cmpb $0x1, %dl
jne 0x2704b
movq (%rcx), %rax
movq 0x8(%rcx), %rsi
movsd (%rax), %xmm0
movaps %xmm0, -0x30(%rbp)
cmpb $0x1, 0x10(%rsi)
leaq 0x1e9e7(%rip), %rax     # 0x45a00
movq %rax, %rdi
cmoveq %rsi, %rdi
movq (%rdi), %rdi
movsd (%rdi), %xmm0
jne 0x2709c
movq 0x8(%rsi), %rsi
cmpb $0x1, 0x10(%rsi)
jne 0x270ac
cmpb $0x1, %dl
jne 0x2707f
movq 0x8(%rcx), %rdx
cmpb $0x1, 0x10(%rdx)
jne 0x270a9
addq $0x8, %rcx
movq %rcx, %rax
jmp 0x27093
movq 0x1e9ae(%rip), %rcx     # 0x45a00
movsd (%rcx), %xmm0
cmpb $0x1, 0x10(%rcx)
movapd %xmm0, -0x30(%rbp)
jne 0x270ac
movq (%rcx), %rcx
movsd (%rcx), %xmm0
movq 0x1e991(%rip), %rcx     # 0x45a00
cmpb $0x1, 0x10(%rcx)
jne 0x270ac
movq 0x8(%rcx), %rcx
cmpb $0x1, 0x10(%rcx)
jne 0x270ac
leaq 0x1e97a(%rip), %rax     # 0x45a00
movq 0x1e973(%rip), %rcx     # 0x45a00
cmpb $0x1, 0x10(%rcx)
jne 0x270a9
movq (%rax), %rax
addq $0x8, %rax
jmp 0x270a9
movq 0x1e95d(%rip), %rcx     # 0x45a00
cmpb $0x1, 0x10(%rcx)
jne 0x270ac
movq (%rax), %rax
movq (%rax), %rax
cvttsd2si %xmm0, %r15d
movsd (%rax), %xmm0
movaps %xmm0, -0x40(%rbp)
callq 0x74dc
movb $0x5, %r14b
movb %r14b, 0x10(%rax)
movabsq $0x4014000000000000, %rcx # imm = 0x4014000000000000
movq %rcx, (%rax)
movq %rax, %rdi
callq 0x8ba5
cvttpd2dq -0x30(%rbp), %xmm0
cvtdq2pd %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
callq 0x74dc
movb %r14b, 0x10(%rax)
movaps -0x30(%rbp), %xmm0
movlps %xmm0, (%rax)
movq %rax, %rdi
callq 0x8ba5
incl %r15d
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
movsd %xmm0, -0x30(%rbp)
callq 0x74dc
movb %r14b, 0x10(%rax)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rax, %rdi
callq 0x8ba5
cvttpd2dq -0x40(%rbp), %xmm0
cvtdq2pd %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
callq 0x74dc
movb %r14b, 0x10(%rax)
movaps -0x30(%rbp), %xmm0
movlps %xmm0, (%rax)
movq %rax, %rdi
callq 0x8ba5
callq 0x74dc
movb %r14b, 0x10(%rax)
movq $0x0, (%rax)
movq %rax, %rdi
callq 0x8ba5
callq 0x74dc
movb %r14b, 0x10(%rax)
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax)
movq %rax, %rdi
callq 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
movl $0x7, %edi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8b7d
leaq 0x7d97(%rip), %rdi      # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_vector
void
fmt_vector(struct atom *p)
{
	int i, n, span;

	// compute element span

	span = 1;

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

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movslq (%rax), %rcx
movl $0x1, %r12d
cmpq $0x2, %rcx
jl 0x2758e
decq %rcx
xorl %edx, %edx
imull 0x8(%rax,%rdx,4), %r12d
incq %rdx
cmpq %rdx, %rcx
jne 0x27580
movl 0x4(%rax), %r14d
testl %r14d, %r14d
jle 0x275b5
xorl %r15d, %r15d
movl %r14d, %r13d
movq %rbx, %rdi
movl $0x1, %esi
movl %r15d, %edx
callq 0x26729
addl %r12d, %r15d
decl %r13d
jne 0x2759d
movl %r14d, %edi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2680d
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_term_nib
void
fmt_term_nib(struct atom *p)
{
	if (find_denominator(p)) {
		fmt_frac(p);
		return;
	}

	// no denominators

	p = cdr(p);

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

	fmt_factor(car(p));

	p = cdr(p);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x91f7
testl %eax, %eax
je 0x27605
movq %rbx, %rdi
callq 0x261b7
movq %rbx, %rdi
callq 0x250c7
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x262b1
cmpb $0x1, 0x10(%rbx)
leaq 0x8(%rbx), %rax
leaq 0x1e3ec(%rip), %rbx     # 0x45a00
cmovneq %rbx, %rax
movq (%rax), %r14
movb 0x10(%r14), %r15b
cmpb $0x1, %r15b
movq %rbx, %rax
cmoveq %r14, %rax
movq (%rax), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0xd1c4
testl %eax, %eax
je 0x27653
addq $0x8, %r14
cmpb $0x1, %r15b
cmovneq %rbx, %r14
movq (%r14), %r14
movb 0x10(%r14), %r15b
cmpb $0x1, %r15b
movq %rbx, %rax
cmoveq %r14, %rax
movq (%rax), %rdi
callq 0x2531c
leaq 0x8(%r14), %rax
cmpb $0x1, 0x10(%r14)
cmovneq %rbx, %rax
movq (%rax), %r14
cmpb $0x1, 0x10(%r14)
jne 0x27689
callq 0x25279
cmpb $0x1, 0x10(%r14)
jmp 0x27657
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: fmt_draw_delims
void
fmt_draw_delims(int x, int y, int h, int d, int w)
{
	if (h > 1 || d > 0) {
		fmt_draw_ldelim(x, y, h, d);
		fmt_draw_rdelim(x + w - 1, y, h, d);
	} else {
		fmt_draw_char(x, y, '(');
		fmt_draw_char(x + w - 1, y, ')');
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r14d
movl %ecx, %r12d
movl %esi, %ebx
movl %edi, %r15d
cmpl $0x2, %edx
setl %al
testl %ecx, %ecx
setle %cl
testb %cl, %al
jne 0x2771c
movl %edx, %r13d
movl %r15d, %edi
movl %ebx, %esi
movl %r12d, %ecx
callq 0x27b3b
leal (%r14,%r15), %edi
decl %edi
movl %ebx, %esi
movl %r13d, %edx
movl %r12d, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x27bf7
testl %r15d, %r15d
js 0x2774c
testl %ebx, %ebx
js 0x2774c
movl 0xeecd5(%rip), %eax     # 0x116400
cmpl %r15d, %eax
jle 0x2774c
cmpl %ebx, 0xeecc6(%rip)     # 0x1163fc
jle 0x2774c
movq 0xeecc9(%rip), %rcx     # 0x116408
imull %ebx, %eax
addl %r15d, %eax
movl $0x28, (%rcx,%rax,4)
leal (%r14,%r15), %ecx
testl %ecx, %ecx
jle 0x27783
testl %ebx, %ebx
js 0x27783
movl 0xeeca2(%rip), %eax     # 0x116400
cmpl %ecx, %eax
jl 0x27783
cmpl %ebx, 0xeec94(%rip)     # 0x1163fc
jle 0x27783
leal (%r14,%r15), %ecx
decl %ecx
movq 0xeec91(%rip), %rdx     # 0x116408
imull %ebx, %eax
addl %ecx, %eax
movl $0x29, (%rdx,%rax,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_draw_ldelim
void
fmt_draw_ldelim(int x, int y, int h, int d)
{
	int i;

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

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

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

// Assembly:
movl %esi, %eax
subl %edx, %eax
testl %edi, %edi
js 0x27b77
cmpl $-0x1, %eax
jl 0x27b77
movl 0xee8b1(%rip), %r8d     # 0x116400
cmpl %edi, %r8d
jle 0x27b77
leal 0x1(%rax), %r9d
cmpl %r9d, 0xee89d(%rip)     # 0x1163fc
jle 0x27b77
movq 0xee8a0(%rip), %r10     # 0x116408
imull %r9d, %r8d
addl %edi, %r8d
movl $0xe2948c, (%r10,%r8,4) # imm = 0xE2948C
pushq %rbp
movq %rsp, %rbp
leal (%rdx,%rcx), %r8d
decl %r8d
cmpl $0x2, %r8d
jl 0x27bc8
movq 0xee879(%rip), %r8      # 0x116408
addl %ecx, %edx
addl $-0x2, %edx
addl $0x2, %eax
testl %edi, %edi
js 0x27bc2
testl %eax, %eax
js 0x27bc2
movl 0xee85a(%rip), %r9d     # 0x116400
cmpl %edi, %r9d
jle 0x27bc2
cmpl %eax, 0xee84b(%rip)     # 0x1163fc
jle 0x27bc2
imull %eax, %r9d
addl %edi, %r9d
movl $0xe29482, (%r8,%r9,4)  # imm = 0xE29482
incl %eax
decl %edx
jne 0x27b97
testl %edi, %edi
js 0x27bf5
addl %esi, %ecx
js 0x27bf5
movl 0xee82a(%rip), %eax     # 0x116400
cmpl %edi, %eax
jle 0x27bf5
cmpl %ecx, 0xee81c(%rip)     # 0x1163fc
jle 0x27bf5
movq 0xee81f(%rip), %rdx     # 0x116408
imull %ecx, %eax
addl %edi, %eax
movl $0xe29494, (%rdx,%rax,4) # imm = 0xE29494
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: fmt_draw_rdelim
void
fmt_draw_rdelim(int x, int y, int h, int d)
{
	int i;

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

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

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

// Assembly:
movl %esi, %eax
subl %edx, %eax
testl %edi, %edi
js 0x27c33
cmpl $-0x1, %eax
jl 0x27c33
movl 0xee7f5(%rip), %r8d     # 0x116400
cmpl %edi, %r8d
jle 0x27c33
leal 0x1(%rax), %r9d
cmpl %r9d, 0xee7e1(%rip)     # 0x1163fc
jle 0x27c33
movq 0xee7e4(%rip), %r10     # 0x116408
imull %r9d, %r8d
addl %edi, %r8d
movl $0xe29490, (%r10,%r8,4) # imm = 0xE29490
pushq %rbp
movq %rsp, %rbp
leal (%rdx,%rcx), %r8d
decl %r8d
cmpl $0x2, %r8d
jl 0x27c84
movq 0xee7bd(%rip), %r8      # 0x116408
addl %ecx, %edx
addl $-0x2, %edx
addl $0x2, %eax
testl %edi, %edi
js 0x27c7e
testl %eax, %eax
js 0x27c7e
movl 0xee79e(%rip), %r9d     # 0x116400
cmpl %edi, %r9d
jle 0x27c7e
cmpl %eax, 0xee78f(%rip)     # 0x1163fc
jle 0x27c7e
imull %eax, %r9d
addl %edi, %r9d
movl $0xe29482, (%r8,%r9,4)  # imm = 0xE29482
incl %eax
decl %edx
jne 0x27c53
testl %edi, %edi
js 0x27cb1
addl %esi, %ecx
js 0x27cb1
movl 0xee76e(%rip), %eax     # 0x116400
cmpl %edi, %eax
jle 0x27cb1
cmpl %ecx, 0xee760(%rip)     # 0x1163fc
jle 0x27cb1
movq 0xee763(%rip), %rdx     # 0x116408
imull %ecx, %eax
addl %edi, %eax
movl $0xe29498, (%rdx,%rax,4) # imm = 0xE29498
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: untag
void
untag(struct atom *p)
{
	int i;

	if (p == NULL)
		return;

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

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

	p->tag = 0;

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

// Assembly:
testq %rdi, %rdi
je 0x27d18
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb 0x10(%rbx), %al
cmpb $0x1, %al
jne 0x27ce1
cmpb $0x0, 0x11(%rbx)
je 0x27d14
movb $0x0, 0x11(%rbx)
movq (%rbx), %rdi
callq 0x27cb3
movq 0x8(%rbx), %rbx
jmp 0x27cc2
cmpb $0x0, 0x11(%rbx)
je 0x27d14
movb $0x0, 0x11(%rbx)
cmpb $0x7, %al
jne 0x27d14
movq (%rbx), %rax
cmpl $0x0, 0x64(%rax)
jle 0x27d14
xorl %r14d, %r14d
movq 0x68(%rax,%r14,8), %rdi
callq 0x27cb3
incq %r14
movq (%rbx), %rax
movslq 0x64(%rax), %rcx
cmpq %rcx, %r14
jl 0x27cfb
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: main
int
main(int argc, char *argv[])
{
	int i;
	for (i = 1; i < argc; i++)
		run_infile(argv[i]);
	if (isatty(fileno(stdout)))
		run_stdin();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jl 0x27d45
movq %rsi, %rbx
movl %edi, %r14d
movl $0x1, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x27d71
incq %r15
cmpq %r15, %r14
jne 0x27d34
movq 0x10284(%rip), %rax     # 0x37fd0
movq (%rax), %rdi
callq 0x7240
movl %eax, %edi
callq 0x70b0
testl %eax, %eax
jne 0x27d6c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x27da4
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: run_infile
void
run_infile(char *infile)
{
	char *buf;
	buf = read_file(infile);
	if (buf == NULL) {
		fprintf(stderr, "cannot read %s\n", infile);
		exit(1);
	}
	run(buf);
	free(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x207bf
testq %rax, %rax
je 0x27d9c
movq %rax, %r14
movq %rax, %rdi
callq 0x27df9
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x7040
movq %rbx, %rdi
callq 0x73c0
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: run_stdin
void
run_stdin(void)
{
	static char inbuf[1000];
	for (;;) {
		fputs("? ", stdout);
		fflush(stdout);
		fgets(inbuf, sizeof inbuf, stdin);
		run(inbuf);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x1021a(%rip), %r15     # 0x37fd0
leaq 0x25ff(%rip), %rbx      # 0x2a3bc
movq 0x10214(%rip), %r12     # 0x37fd8
leaq 0xee645(%rip), %r14     # 0x116410
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x7120
movq (%r15), %rdi
callq 0x7280
movq (%r12), %rdx
movq %r14, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x71b0
movq %r14, %rdi
callq 0x27df9
jmp 0x27dcb
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: numden_find_divisor
int
numden_find_divisor(struct atom *p)
{
	if (car(p) == symbol(ADD)) {
		p = cdr(p);
		while (iscons(p)) {
			if (numden_find_divisor_term(car(p)))
				return 1;
			p = cdr(p);
		}
		return 0;
	}

	return numden_find_divisor_term(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movb 0x10(%rdi), %al
cmpb $0x1, %al
leaq 0x1d9d1(%rip), %r14     # 0x45a00
movq %r14, %rcx
cmoveq %rdi, %rcx
movq (%rcx), %rcx
cmpq 0x20260(%rip), %rcx     # 0x482a0
je 0x2804f
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x281ab
addq $0x8, %rdi
cmpb $0x1, %al
cmovneq %r14, %rdi
movq (%rdi), %r15
xorl %ebx, %ebx
cmpb $0x1, 0x10(%r15)
jne 0x28097
leaq 0x10(%r15), %r12
movq (%r15), %rdi
callq 0x281ab
testl %eax, %eax
jne 0x28092
addq $0x8, %r15
cmpb $0x1, (%r12)
cmovneq %r14, %r15
movq (%r15), %r15
leaq 0x10(%r15), %r12
cmpb $0x1, 0x10(%r15)
je 0x28069
jmp 0x28097
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: numden_cancel_factor
void
numden_cancel_factor(void)
{
	int h;
	struct atom *p1, *p2;

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x17204(%rip), %r15d    # 0x3f2b8
movl $0xfffe795f, %eax       # imm = 0xFFFE795F
leal (%r15,%rax), %ecx
cmpl %eax, %ecx
jbe 0x2819f
leal -0x1(%r15), %eax
movl %eax, 0x171e9(%rip)     # 0x3f2b8
cmpl $0x1, %r15d
jbe 0x2819f
leaq 0x204e0(%rip), %rcx     # 0x485c0
movq (%rcx,%rax,8), %r14
addl $-0x2, %r15d
movl %r15d, 0x171c9(%rip)    # 0x3f2b8
movb 0x10(%r14), %al
cmpb $0x1, %al
leaq 0x1d904(%rip), %r12     # 0x45a00
movq %r12, %rdx
cmoveq %r14, %rdx
movq (%rcx,%r15,8), %rbx
movq (%rdx), %rcx
cmpq 0x2018f(%rip), %rcx     # 0x482a0
je 0x28135
movq %rbx, %rdi
callq 0x8ba5
movq %r14, %rdi
callq 0x8ba5
movl $0x2, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xacef
addq $0x8, %r14
cmpb $0x1, %al
cmovneq %r12, %r14
movq (%r14), %r14
cmpb $0x1, 0x10(%r14)
movl %r15d, %edi
jne 0x2818f
movq %rbx, %rdi
callq 0x8ba5
cmpb $0x1, 0x10(%r14)
movq %r12, %rax
cmoveq %r14, %rax
movq (%rax), %rdi
callq 0x8ba5
movl $0x2, %edi
callq 0xacef
leaq 0x8(%r14), %rax
cmpb $0x1, 0x10(%r14)
cmovneq %r12, %rax
movq (%rax), %r14
cmpb $0x1, 0x10(%r14)
je 0x2814c
movl 0x17129(%rip), %edi     # 0x3f2b8
subl %r15d, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xadb3
leaq 0x6d9b(%rip), %rdi      # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: numden_find_divisor_term
int
numden_find_divisor_term(struct atom *p)
{
	if (car(p) == symbol(MULTIPLY)) {
		p = cdr(p);
		while (iscons(p)) {
			if (numden_find_divisor_factor(car(p)))
				return 1;
			p = cdr(p);
		}
		return 0;
	}

	return numden_find_divisor_factor(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movb 0x10(%rdi), %al
cmpb $0x1, %al
leaq 0x1d83e(%rip), %r14     # 0x45a00
movq %r14, %rcx
cmoveq %rdi, %rcx
movq (%rcx), %rcx
cmpq 0x200d5(%rip), %rcx     # 0x482a8
je 0x281e2
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x28235
addq $0x8, %rdi
cmpb $0x1, %al
cmovneq %r14, %rdi
movq (%rdi), %r15
xorl %ebx, %ebx
cmpb $0x1, 0x10(%r15)
jne 0x2822a
leaq 0x10(%r15), %r12
movq (%r15), %rdi
callq 0x28235
testl %eax, %eax
jne 0x28225
addq $0x8, %r15
cmpb $0x1, (%r12)
cmovneq %r14, %r15
movq (%r15), %r15
leaq 0x10(%r15), %r12
cmpb $0x1, 0x10(%r15)
je 0x281fc
jmp 0x2822a
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq