LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: numden_find_divisor_factor
int
numden_find_divisor_factor(struct atom *p)
{
	if (isrational(p) && !isinteger(p)) {
		push_bignum(MPLUS, mcopy(p->u.q.b), mint(1));
		return 1;
	}

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

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movb 0x10(%rdi), %al
cmpb $0x4, %al
jne 0x28267
movq 0x8(%rbx), %rdi
cmpl $0x1, -0x4(%rdi)
jne 0x2830d
cmpl $0x1, (%rdi)
jne 0x2830d
cmpb $0x1, %al
leaq 0x1d790(%rip), %r13     # 0x45a00
movq %r13, %rcx
cmoveq %rbx, %rcx
movq 0x20032(%rip), %r14     # 0x482b0
xorl %r15d, %r15d
cmpq %r14, (%rcx)
jne 0x2842f
leaq 0x8(%rbx), %rcx
cmpb $0x1, %al
movq %r13, %rax
movq %rcx, -0x40(%rbp)
cmoveq %rcx, %rax
movq (%rax), %rax
movb 0x10(%rax), %cl
movb %cl, -0x29(%rbp)
cmpb $0x1, %cl
movq %rax, -0x38(%rbp)
jne 0x28337
movq 0x8(%rax), %rax
cmpb $0x1, 0x10(%rax)
leaq 0x1d740(%rip), %rcx     # 0x45a00
cmoveq %rax, %rcx
movq (%rcx), %rdi
callq 0xac49
testl %eax, %eax
je 0x2842f
cmpb $0x1, -0x29(%rbp)
jne 0x28357
movq -0x38(%rbp), %rax
movq 0x8(%rax), %r12
cmpb $0x1, 0x10(%r12)
je 0x28366
movq 0x1d70f(%rip), %rdi     # 0x45a00
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0xd1c4
testl %eax, %eax
jne 0x28398
jmp 0x2839e
callq 0x7e97
movq %rax, %rbx
movl $0x1, %r15d
movl $0x1, %edi
callq 0x7b1f
xorl %edi, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0xbf3e
jmp 0x2842f
movq 0x1d6c2(%rip), %r12     # 0x45a00
cmpb $0x1, 0x10(%r12)
jne 0x2836c
movq (%r12), %rdi
callq 0xac49
testl %eax, %eax
je 0x2842f
movq 0x1d6a2(%rip), %r12     # 0x45a00
cmpb $0x1, 0x10(%r12)
jne 0x2837c
movq (%r12), %r12
jmp 0x2837c
movq %r12, %rdi
callq 0xac49
testl %eax, %eax
je 0x2842f
movq %r12, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0xd1c4
testl %eax, %eax
je 0x2839e
cmpb $0x1, -0x29(%rbp)
jne 0x283df
movq -0x38(%rbp), %rax
jmp 0x283e6
movq %r14, %rdi
callq 0x8ba5
cmpb $0x1, 0x10(%rbx)
movq %r13, %rax
movq -0x40(%rbp), %r14
cmoveq %r14, %rax
movq (%rax), %rax
cmpb $0x1, 0x10(%rax)
cmovneq %r13, %rax
movq (%rax), %rdi
callq 0x8ba5
cmpb $0x1, 0x10(%rbx)
cmovneq %r13, %r14
movq (%r14), %rax
cmpb $0x1, 0x10(%rax)
jne 0x283f0
movq 0x8(%rax), %rax
jmp 0x283f7
leaq 0x1d61a(%rip), %rax     # 0x45a00
movq (%rax), %rdi
callq 0x8ba5
jmp 0x28429
movq 0x1d609(%rip), %rax     # 0x45a00
cmpb $0x1, 0x10(%rax)
jne 0x28400
movq %rax, %r13
movq (%r13), %rdi
callq 0x8ba5
movq 0xedfe0(%rip), %rdi     # 0x1163f0
callq 0x8ba5
movl $0x2, %edi
callq 0xacef
movl $0x3, %edi
callq 0x8b7d
movl $0x1, %r15d
movl %r15d, %eax
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: init_symbol_table
void
init_symbol_table(void)
{
	int i, n;
	char *s;
	struct atom *p;

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

	n = sizeof stab / sizeof (struct se);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x1abfc(%rip), %rbx     # 0x43160
movl $0x5460, %edx           # imm = 0x5460
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7130
leaq 0xe3576(%rip), %rdi     # 0x10baf0
movl $0x5460, %edx           # imm = 0x5460
xorl %esi, %esi
callq 0x7130
leaq 0xe89c3(%rip), %rdi     # 0x110f50
movl $0x5460, %edx           # imm = 0x5460
xorl %esi, %esi
callq 0x7130
movl $0x10, %r15d
leaq 0x15e2a(%rip), %r12     # 0x3e3d0
callq 0x74dc
movq %rax, %r14
movq -0x10(%r15,%r12), %rdi
callq 0x7350
testq %rax, %rax
je 0x2860f
cmpq $0x0, (%r15,%r12)
movq %rax, (%r14)
je 0x285de
movq (%r15,%r12), %rax
movq %rax, 0x8(%r14)
incl 0xede0f(%rip)           # 0x1163e4
movl -0x8(%r15,%r12), %eax
movb $0x2, %cl
jmp 0x285ef
movl -0x8(%r15,%r12), %eax
movl %eax, 0x8(%r14)
incl 0xeddfb(%rip)           # 0x1163e8
movb $0x3, %cl
movb %cl, 0x10(%r14)
cltq
movq %r14, (%rbx,%rax,8)
addq $0x18, %r15
cmpq $0xec8, %r15            # imm = 0xEC8
jne 0x285a6
popq %rbx
popq %r12
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: scan_input
char *
scan_input(char *s)
{
	struct atom *p1;
	trace1 = s;
	s = scan(s);
	trace2 = s;
	p1 = get_binding(symbol(TRACE));
	if (p1 != symbol(TRACE) && !iszero(p1))
		print_trace(BLUE);
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, 0xee2aa(%rip)     # 0x1168d0
movl $0x0, 0xee2b0(%rip)     # 0x1168e0
callq 0x28721
movq %rax, %rbx
movq %rax, 0xee299(%rip)     # 0x1168d8
movq 0x1e6da(%rip), %rdi     # 0x46d20
callq 0xf05c
cmpq 0x1e6ce(%rip), %rax     # 0x46d20
je 0x28665
movq %rax, %rdi
callq 0xb477
testl %eax, %eax
jne 0x28665
callq 0x28683
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: print_trace
void
print_trace(int color)
{
	char c, *s;
	if (trace1 == NULL || trace2 == NULL)
		return;
	outbuf_init();
	c = '\n';
	s = trace1;
	while (*s && s < trace2) {
		c = *s++;
		outbuf_putc(c);
	}
	if (c != '\n')
		outbuf_putc('\n');
	printbuf(outbuf, color);
}

// Assembly:
cmpq $0x0, 0xee245(%rip)     # 0x1168d0
je 0x28720
cmpq $0x0, 0xee23f(%rip)     # 0x1168d8
je 0x28720
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl $0x0, 0xee148(%rip)     # 0x1167f8
leaq 0x6834(%rip), %rdi      # 0x2eeeb
callq 0x16573
movq 0xee20d(%rip), %rbx     # 0x1168d0
movb (%rbx), %al
testb %al, %al
je 0x28706
cmpq 0xee208(%rip), %rbx     # 0x1168d8
jae 0x28706
incq %rbx
movl %eax, %r14d
movsbl %al, %edi
callq 0x17586
movb (%rbx), %al
testb %al, %al
je 0x286f6
leaq 0x1(%rbx), %rcx
cmpq 0xee1e7(%rip), %rbx     # 0x1168d8
movq %rcx, %rbx
jb 0x286d5
cmpb $0xa, %r14b
je 0x28706
movl $0xa, %edi
callq 0x17586
movq 0xedcbb(%rip), %rdi     # 0x1163c8
movq 0xf8bc(%rip), %rax      # 0x37fd0
movq (%rax), %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x7120
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: scan_nib
char *
scan_nib(char *s)
{
	scan_str = s;
	scan_level = 0;
	get_token_skip_newlines();
	if (token == T_END)
		return NULL;
	scan_stmt();
	if (token != T_NEWLINE && token != T_END)
		scan_error("syntax err"); // unexpected token, for example, 1:2
	return scan_str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, 0xee1bc(%rip)     # 0x1168e8
movl $0x1, 0xee1ba(%rip)     # 0x1168f0
callq 0x29173
decl 0xee1af(%rip)           # 0x1168f0
cmpl $0x3f3, 0xee1a9(%rip)   # imm = 0x3F3
jne 0x28751
xorl %eax, %eax
jmp 0x28771
callq 0x287a4
movl 0xee198(%rip), %eax     # 0x1168f4
cmpl $0x3ee, %eax            # imm = 0x3EE
je 0x2876a
cmpl $0x3f3, %eax            # imm = 0x3F3
jne 0x28773
movq 0xee177(%rip), %rax     # 0x1168e8
popq %rbp
retq
movq 0xee16e(%rip), %rax     # 0x1168e8
movq %rax, 0xee157(%rip)     # 0x1168d8
leaq 0x676e(%rip), %rdi      # 0x2eef6
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: scan_stmt
void
scan_stmt(void)
{
	scan_comparison();
	if (token == '=') {
		get_token_skip_newlines(); // get token after '='
		push_symbol(SETQ);
		swap();
		scan_comparison();
		list(3);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x28801
cmpl $0x3d, 0xee140(%rip)    # 0x1168f4
jne 0x287e8
incl 0xee134(%rip)           # 0x1168f0
callq 0x29173
decl 0xee129(%rip)           # 0x1168f0
movq 0x1faf2(%rip), %rdi     # 0x482c0
callq 0x8ba5
callq 0xb238
callq 0x28801
movl $0x3, %edi
popq %rbp
jmp 0x8b7d
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: scan_comparison
void
scan_comparison(void)
{
	scan_expression();
	switch (token) {
	case T_EQ:
		push_symbol(TESTEQ); // ==
		break;
	case T_LTEQ:
		push_symbol(TESTLE);
		break;
	case T_GTEQ:
		push_symbol(TESTGE);
		break;
	case '<':
		push_symbol(TESTLT);
		break;
	case '>':
		push_symbol(TESTGT);
		break;
	default:
		return;
	}
	swap();
	get_token_skip_newlines(); // get token after rel op
	scan_expression();
	list(3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x28891
movl 0xee0e4(%rip), %eax     # 0x1168f4
cmpl $0x3ef, %eax            # imm = 0x3EF
jle 0x28835
cmpl $0x3f0, %eax            # imm = 0x3F0
je 0x28848
cmpl $0x3f2, %eax            # imm = 0x3F2
je 0x28851
cmpl $0x3f1, %eax            # imm = 0x3F1
jne 0x2888f
leaq 0x1e4d5(%rip), %rax     # 0x46d08
jmp 0x28861
cmpl $0x3c, %eax
je 0x2885a
cmpl $0x3e, %eax
jne 0x2888f
leaq 0x1e4ba(%rip), %rax     # 0x46d00
jmp 0x28861
leaq 0x1e4a9(%rip), %rax     # 0x46cf8
jmp 0x28861
leaq 0x1e498(%rip), %rax     # 0x46cf0
jmp 0x28861
leaq 0x1e4af(%rip), %rax     # 0x46d10
movq (%rax), %rdi
callq 0x8ba5
callq 0xb238
incl 0xee07c(%rip)           # 0x1168f0
callq 0x29173
decl 0xee071(%rip)           # 0x1168f0
callq 0x28891
movl $0x3, %edi
popq %rbp
jmp 0x8b7d
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: scan_expression
void
scan_expression(void)
{
	int h = tos, t;
	t = token;
	if (token == '+' || token == '-')
		get_token_skip_newlines();
	scan_term();
	if (t == '-')
		static_negate();
	while (token == '+' || token == '-') {
		t = token;
		get_token_skip_newlines(); // get token after '+' or '-'
		scan_term();
		if (t == '-')
			static_negate();
	}
	if (tos - h > 1) {
		list(tos - h);
		push_symbol(ADD);
		swap();
		cons(); // prepend ADD to list
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl 0x16a1a(%rip), %ebx     # 0x3f2b8
movl 0xee04f(%rip), %r14d    # 0x1168f4
cmpl $0x2d, %r14d
je 0x288b1
cmpl $0x2b, %r14d
jne 0x288c2
incl 0xee039(%rip)           # 0x1168f0
callq 0x29173
decl 0xee02e(%rip)           # 0x1168f0
callq 0x28918
cmpl $0x2d, %r14d
je 0x2890c
movl 0xee020(%rip), %r14d    # 0x1168f4
cmpl $0x2d, %r14d
je 0x288b1
cmpl $0x2b, %r14d
je 0x288b1
movl 0x169d2(%rip), %edi     # 0x3f2b8
subl %ebx, %edi
cmpl $0x2, %edi
jl 0x28913
callq 0x8b7d
movq 0x1f9a7(%rip), %rdi     # 0x482a0
callq 0x8ba5
callq 0xb238
popq %rbx
popq %r14
popq %rbp
jmp 0x8be6
callq 0x2899a
jmp 0x288cd
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: scan_term
void
scan_term(void)
{
	int h = tos, t;

	scan_power();

	while (another_factor_pending()) {

		t = token;

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

		scan_power();

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl 0x16993(%rip), %ebx     # 0x3f2b8
callq 0x28b4d
callq 0x28b0e
testl %eax, %eax
je 0x28969
movl 0xedfba(%rip), %r14d    # 0x1168f4
cmpl $0x2f, %r14d
je 0x28946
cmpl $0x2a, %r14d
jne 0x28957
incl 0xedfa4(%rip)           # 0x1168f0
callq 0x29173
decl 0xedf99(%rip)           # 0x1168f0
callq 0x28b4d
cmpl $0x2f, %r14d
jne 0x2892a
callq 0x28b93
jmp 0x2892a
movl 0x16949(%rip), %edi     # 0x3f2b8
subl %ebx, %edi
cmpl $0x2, %edi
jl 0x28995
callq 0x8b7d
movq 0x1f926(%rip), %rdi     # 0x482a8
callq 0x8ba5
callq 0xb238
popq %rbx
popq %r14
popq %rbp
jmp 0x8be6
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: static_negate
void
static_negate(void)
{
	struct atom *p1;

	p1 = pop();

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x1690e(%rip), %eax     # 0x3f2b8
movl $0xfffe795f, %ecx       # imm = 0xFFFE795F
leal (%rax,%rcx), %edx
cmpl %ecx, %edx
jbe 0x28b02
decl %eax
movl %eax, 0x168f6(%rip)     # 0x3f2b8
leaq 0x1fbf7(%rip), %rcx     # 0x485c0
movq (%rcx,%rax,8), %rbx
movzbl 0x10(%rbx), %eax
leal -0x4(%rax), %ecx
cmpl $0x2, %ecx
jae 0x28a01
movq %rbx, %rdi
callq 0x8ba5
movq 0xeda08(%rip), %rdi     # 0x1163f0
callq 0x8ba5
movl $0x2, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xacef
movq %rbx, %rcx
cmpl $0x1, %eax
je 0x28a10
leaq 0x1cff0(%rip), %rcx     # 0x45a00
movq (%rcx), %r15
movq 0x1f88e(%rip), %r14     # 0x482a8
movq %r14, %rdi
callq 0x8ba5
cmpq %r14, %r15
je 0x28a4f
movq 0xed9c2(%rip), %rdi     # 0x1163f0
callq 0x8ba5
movq %rbx, %rdi
callq 0x8ba5
movl $0x3, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8b7d
leaq 0x8(%rbx), %r15
cmpb $0x1, 0x10(%rbx)
leaq 0x1cfa2(%rip), %r14     # 0x45a00
movq %r14, %rax
cmoveq %r15, %rax
movq (%rax), %rax
movb 0x10(%rax), %cl
cmpb $0x1, %cl
jne 0x28a7d
movq (%rax), %rdx
movb 0x10(%rdx), %dl
cmpb $0x4, %dl
jne 0x28a8c
jmp 0x28a91
movq 0x1cf7c(%rip), %rdi     # 0x45a00
movb 0x10(%rdi), %dl
cmpb $0x4, %dl
je 0x28a9b
cmpb $0x5, %dl
jne 0x28acf
cmpb $0x1, %cl
cmovneq %r14, %rax
movq (%rax), %rdi
callq 0x8ba5
movq 0xed949(%rip), %rdi     # 0x1163f0
callq 0x8ba5
movl $0x2, %edi
callq 0xacef
cmpb $0x1, 0x10(%rbx)
cmovneq %r14, %r15
movq (%r15), %rcx
leaq 0x8(%rcx), %rax
cmpb $0x1, 0x10(%rcx)
cmovneq %r14, %rax
jmp 0x28ae6
movq 0xed91a(%rip), %rdi     # 0x1163f0
callq 0x8ba5
cmpb $0x1, 0x10(%rbx)
cmoveq %r15, %r14
movq %r14, %rax
movq (%rax), %rdi
callq 0x8ba5
callq 0x8be6
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8be6
leaq 0x6438(%rip), %rdi      # 0x2ef41
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: scan_power
void
scan_power(void)
{
	scan_factor();
	if (token == '^') {
		get_token_skip_newlines();
		push_symbol(POWER);
		swap();
		scan_power();
		list(3);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x28df9
cmpl $0x5e, 0xedd97(%rip)    # 0x1168f4
jne 0x28b91
incl 0xedd8b(%rip)           # 0x1168f0
callq 0x29173
decl 0xedd80(%rip)           # 0x1168f0
movq 0x1f739(%rip), %rdi     # 0x482b0
callq 0x8ba5
callq 0xb238
callq 0x28b4d
movl $0x3, %edi
popq %rbp
jmp 0x8b7d
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: scan_factor
void
scan_factor(void)
{
	int h = tos;

	switch (token) {

	case '(':
		scan_subexpr();
		break;

	case T_SYMBOL:
		scan_symbol();
		break;

	case T_FUNCTION:
		scan_function_call();
		break;

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

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

	case T_STRING:
		scan_string();
		break;

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

	// index

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0x164b3(%rip), %ebx     # 0x3f2b8
movl 0xedae9(%rip), %ecx     # 0x1168f4
leal -0x3e9(%rcx), %eax
cmpl $0x6, %eax
ja 0x28e2d
leaq 0x12cb(%rip), %rcx      # 0x2a0e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x29126
jmp 0x28e76
cmpl $0x28, %ecx
jne 0x28f39
callq 0x28f53
jmp 0x28e89
movq 0xedab4(%rip), %rdi     # 0x1168f8
callq 0x164db
jmp 0x28e76
movq 0xedaa6(%rip), %rdi     # 0x1168f8
callq 0x70c0
movsd %xmm0, -0x10(%rbp)
callq 0x74dc
movb $0x5, 0x10(%rax)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, (%rax)
movq %rax, %rdi
callq 0x8ba5
callq 0x29173
jmp 0x28e89
callq 0x29087
jmp 0x28e89
callq 0x2901b
movl 0xeda65(%rip), %eax     # 0x1168f4
cmpl $0x5b, %eax
jne 0x28eea
incl 0xeda56(%rip)           # 0x1168f0
callq 0x29173
movq 0x1f412(%rip), %rdi     # 0x482b8
callq 0x8ba5
callq 0xb238
callq 0x28891
movl 0xeda39(%rip), %eax     # 0x1168f4
cmpl $0x2c, %eax
jne 0x28ec7
callq 0x29173
jmp 0x28eb0
cmpl $0x5d, %eax
jne 0x28f1f
decl 0xeda1e(%rip)           # 0x1168f0
callq 0x29173
movl 0x163db(%rip), %edi     # 0x3f2b8
subl %ebx, %edi
callq 0x8b7d
movl 0xeda0a(%rip), %eax     # 0x1168f4
cmpl $0x21, %eax
jne 0x28f18
callq 0x29173
movq 0x1b205(%rip), %rdi     # 0x44100
callq 0x8ba5
callq 0xb238
movl $0x2, %edi
callq 0x8b7d
cmpl $0x21, 0xed9de(%rip)    # 0x1168f4
je 0x28eef
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0xed9c2(%rip), %rax     # 0x1168e8
movq %rax, 0xed9ab(%rip)     # 0x1168d8
leaq 0x5fcd(%rip), %rdi      # 0x2ef01
callq 0x780b
movq 0xed9a8(%rip), %rax     # 0x1168e8
movq %rax, 0xed991(%rip)     # 0x1168d8
leaq 0x5fa8(%rip), %rdi      # 0x2eef6
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: scan_subexpr
void
scan_subexpr(void)
{
	int h, i, n;
	struct atom *p;
	h = tos;
	scan_level++;
	get_token(); // get token after '('
	scan_stmt();
	while (token == ',') {
		get_token(); // get token after ','
		scan_stmt();
	}
	if (token != ')')
		scan_error("expected ')'");
	scan_level--;
	get_token(); // get token after ')'
	n = tos - h;
	if (n < 2)
		return;
	p = alloc_vector(n);
	for (i = 0; i < n; i++)
		p->u.tensor->elem[i] = stack[h + i];
	tos = h;
	push(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x16354(%rip), %r14d    # 0x3f2b8
movslq %r14d, %r15
incl 0xed983(%rip)           # 0x1168f0
callq 0x29173
callq 0x287a4
movl 0xed977(%rip), %eax     # 0x1168f4
cmpl $0x2c, %eax
je 0x28f6d
cmpl $0x29, %eax
jne 0x29001
decl 0xed963(%rip)           # 0x1168f0
callq 0x29173
movl 0x16320(%rip), %ebx     # 0x3f2b8
subl %r14d, %ebx
cmpl $0x2, %ebx
jge 0x28fab
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %ebx, %edi
callq 0x7893
movq (%rax), %rcx
movl $0x1, (%rcx)
movq (%rax), %rcx
movl %ebx, 0x4(%rcx)
movl %ebx, %ecx
shlq $0x3, %r15
xorl %edx, %edx
leaq 0x1f5f0(%rip), %rsi     # 0x485c0
leaq (%r15,%rdx,8), %rdi
movq (%rsi,%rdi), %rdi
movq (%rax), %r8
movq %rdi, 0x68(%r8,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x28fd0
movl %r14d, 0x162c9(%rip)    # 0x3f2b8
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8ba5
movq 0xed8e0(%rip), %rax     # 0x1168e8
movq %rax, 0xed8c9(%rip)     # 0x1168d8
leaq 0x5ef8(%rip), %rdi      # 0x2ef0e
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: scan_symbol
void
scan_symbol(void)
{
	if (scan_mode && strlen(token_buf) == 1)
		switch (token_buf[0]) {
		case 'a':
			push_symbol(SA);
			break;
		case 'b':
			push_symbol(SB);
			break;
		case 'x':
			push_symbol(SX);
			break;
		default:
			push(lookup(token_buf));
			break;
		}
	else
		push(lookup(token_buf));
	get_token();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpl $0x0, 0xed8b8(%rip)     # 0x1168e0
movq 0xed8c9(%rip), %rbx     # 0x1168f8
je 0x2905a
movq %rbx, %rdi
callq 0x70e0
cmpq $0x1, %rax
jne 0x2905a
movzbl (%rbx), %eax
cmpl $0x78, %eax
je 0x2907e
cmpl $0x62, %eax
je 0x29075
cmpl $0x61, %eax
jne 0x2905a
movq 0x1f278(%rip), %rdi     # 0x482d0
jmp 0x29065
movq %rbx, %rdi
callq 0x291b0
movq %rax, %rdi
callq 0x8ba5
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x29173
movq 0x1f25c(%rip), %rdi     # 0x482d8
jmp 0x29065
movq 0x1f25b(%rip), %rdi     # 0x482e0
jmp 0x29065
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: scan_function_call
void
scan_function_call(void)
{
	int h = tos;
	scan_level++;
	push(lookup(token_buf)); // push function name
	get_token(); // get token after function name
	get_token(); // get token after '('
	if (token == ')') {
		scan_level--;
		get_token(); // get token after ')'
		list(1); // function call with no args
		return;
	}
	scan_stmt();
	while (token == ',') {
		get_token(); // get token after ','
		scan_stmt();
	}
	if (token != ')')
		scan_error("expected ')'");
	scan_level--;
	get_token(); // get token after ')'
	list(tos - h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0x16225(%rip), %ebx     # 0x3f2b8
incl 0xed857(%rip)           # 0x1168f0
movq 0xed858(%rip), %rdi     # 0x1168f8
callq 0x291b0
movq %rax, %rdi
callq 0x8ba5
callq 0x29173
callq 0x29173
cmpl $0x29, 0xed836(%rip)    # 0x1168f4
jne 0x290d2
decl 0xed82a(%rip)           # 0x1168f0
callq 0x29173
movl $0x1, %edi
jmp 0x29101
callq 0x287a4
movl 0xed817(%rip), %eax     # 0x1168f4
cmpl $0x2c, %eax
jne 0x290e9
callq 0x29173
jmp 0x290d2
cmpl $0x29, %eax
jne 0x2910c
decl 0xed7fc(%rip)           # 0x1168f0
callq 0x29173
movl 0x161b9(%rip), %edi     # 0x3f2b8
subl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8b7d
movq 0xed7d5(%rip), %rax     # 0x1168e8
movq %rax, 0xed7be(%rip)     # 0x1168d8
leaq 0x5ded(%rip), %rdi      # 0x2ef0e
callq 0x780b
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: scan_integer
void
scan_integer(void)
{
	int sign;
	uint32_t *a;
	switch (*token_buf) {
	case '+':
		sign = MPLUS;
		a = mscan(token_buf + 1);
		break;
	case '-':
		sign = MMINUS;
		a = mscan(token_buf + 1);
		break;
	default:
		sign = MPLUS;
		a = mscan(token_buf);
		break;
	}
	push_bignum(sign, a, mint(1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0xed7c4(%rip), %rdi     # 0x1168f8
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x29148
xorl %ebx, %ebx
cmpl $0x2b, %eax
jne 0x29150
incq %rdi
jmp 0x29150
incq %rdi
movl $0x1, %ebx
callq 0x79c8
movq %rax, %r14
movl $0x1, %edi
callq 0x7b1f
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0xbf3e
// File: /workspace/github_c_makefile_star2_O3/georgeweigt[P]eigenmath/eigenmath.c
// Function: lookup
struct atom *
lookup(char *s)
{
	int i, k;
	struct atom *p;

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

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

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

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

	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x7390
movq (%rax), %rax
movsbq (%rbx), %rcx
movzwl (%rax,%rcx,2), %edx
btl $0x8, %edx
jb 0x291ec
movl $0xa28, %eax            # imm = 0xA28
btl $0x9, %edx
jae 0x291f4
imull $0x64, %ecx, %eax
addl $0xffffda1c, %eax       # imm = 0xFFFFDA1C
jmp 0x291f4
imull $0x64, %ecx, %eax
addl $0xffffe69c, %eax       # imm = 0xFFFFE69C
cltq
movq %rax, -0x30(%rbp)
leaq (,%rax,8), %r15
xorl %r12d, %r12d
leaq 0x5d8c(%rip), %r13      # 0x2ef98
leaq (%r15,%r12,8), %rax
leaq 0x19f49(%rip), %rcx     # 0x43160
movq (%rcx,%rax), %r14
testq %r14, %r14
je 0x29251
movb 0x10(%r14), %al
andb $-0x2, %al
movq %r13, %rsi
cmpb $0x2, %al
jne 0x29230
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x71e0
testl %eax, %eax
je 0x2928f
incq %r12
cmpq $0x64, %r12
jne 0x2920c
leaq 0x5d3a(%rip), %rdi      # 0x2ef86
callq 0x780b
callq 0x74dc
movq %rax, %r14
movq %rbx, %rdi
callq 0x7350
testq %rax, %rax
je 0x292a1
movb $0x3, 0x10(%r14)
movq %rax, (%r14)
movq -0x30(%rbp), %rcx
leal (%rcx,%r12), %eax
movl %eax, 0x8(%r14)
leaq 0x19edf(%rip), %rax     # 0x43160
leaq (%rax,%rcx,8), %rax
movq %r14, (%rax,%r12,8)
incl 0xed159(%rip)           # 0x1163e8
movq %r14, %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: update_token_buf
void
update_token_buf(char *a, char *b)
{
	int m, n;

	n = (int) (b - a);

	// Let n == 1000

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

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
subq %rdi, %r14
movslq %r14d, %rax
imulq $0x10624dd3, %rax, %rax # imm = 0x10624DD3
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x26, %rax
addl %ecx, %eax
imull $0x3e8, %eax, %r15d     # imm = 0x3E8
addl $0x3e8, %r15d           # imm = 0x3E8
movq 0xed350(%rip), %rdi     # 0x1168f8
cmpl 0xed359(%rip), %r15d    # 0x116908
jle 0x295d4
testq %rdi, %rdi
je 0x295bb
callq 0x7040
movl %r15d, %edi
callq 0x7853
movq %rax, %rdi
movq %rax, 0xed32b(%rip)     # 0x1168f8
movl %r15d, 0xed334(%rip)    # 0x116908
movslq %r14d, %r14
movq %rbx, %rsi
movq %r14, %rdx
callq 0x7070
movq 0xed30f(%rip), %rax     # 0x1168f8
movb $0x0, (%rax,%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]wld/buffer.c
// Function: wld_buffer_unreference
EXPORT
void
wld_buffer_unreference(struct wld_buffer *base)
{
	struct buffer *buffer = (void *)base;
	struct wld_destructor *destructor, *next;

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

	pixman_region32_fini(&buffer->base.damage);

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

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

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

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

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

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

	return &surface->base;
}

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

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

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

	return &back_buffer->base.damage;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0xac78(%rip), %rax      # 0x14a10
cmpq %rax, (%rdi)
jne 0x9e00
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x91f0
testl %eax, %eax
je 0x9de1
cmpl $0x0, 0x20(%rbx)
je 0x9de1
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x10(%rbx), %rax
movq (%rax,%r15), %rdi
addq $0x18, %rdi
movq %rdi, %rsi
movq %r14, %rdx
callq 0x9760
incq %r12
movl 0x20(%rbx), %eax
addq $0x10, %r15
cmpq %rax, %r12
jb 0x9dbb
movq %rbx, %rdi
callq 0x9e1f
leaq 0x18(%rax), %rcx
testq %rax, %rax
cmovneq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x51f9(%rip), %rdi      # 0xf000
leaq 0x5214(%rip), %rsi      # 0xf022
leaq 0x5220(%rip), %rcx      # 0xf035
movl $0x1b, %edx
callq 0x9380
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]wld/buffered_surface.c
// Function: surface_back
struct buffer *
surface_back(struct wld_surface *base)
{
	struct buffered_surface *surface = buffered_surface(base);
	unsigned index;

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

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

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

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

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

	if (!buffer)
		goto error0;

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

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

		if (!new_entries)
			goto error1;

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

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

	return buffer;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0xabe5(%rip), %rax      # 0x14a10
cmpq %rax, (%rdi)
jne 0x9f09
movq %rdi, %rbx
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x9e4c
movq (%rax), %r14
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x9e5b
movq (%rdi), %rax
callq *0x8(%rax)
movl 0x20(%rbx), %eax
testq %rax, %rax
je 0x9e76
movq 0x10(%rbx), %rcx
cmpb $0x0, 0x8(%rcx)
je 0x9ec7
addq $0x10, %rcx
decq %rax
jne 0x9e67
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movl 0x30(%rbx), %esi
movl 0x34(%rbx), %edx
movl 0x38(%rbx), %ecx
movl 0x3c(%rbx), %r8d
callq *0x8(%rax)
testq %rax, %rax
je 0x9f01
movq %rax, %r14
movl 0x20(%rbx), %ecx
cmpl 0x24(%rbx), %ecx
jne 0x9ed3
leal 0x1(,%rcx,2), %r15d
movq 0x10(%rbx), %rdi
movq %r15, %rsi
shlq $0x4, %rsi
callq 0x9600
testq %rax, %rax
je 0x9ef9
movq %rax, 0x10(%rbx)
movl %r15d, 0x24(%rbx)
movl 0x20(%rbx), %ecx
jmp 0x9ed7
movq %rcx, 0x18(%rbx)
movq (%rcx), %r14
jmp 0x9e43
movq 0x10(%rbx), %rax
leal 0x1(%rcx), %edx
movl %edx, 0x20(%rbx)
movl %ecx, %ecx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rdx
movq %rdx, 0x18(%rbx)
movq %r14, (%rax,%rcx)
movb $0x0, 0x8(%rax,%rcx)
jmp 0x9e43
movq %r14, %rdi
callq 0x9260
xorl %r14d, %r14d
jmp 0x9e43
leaq 0x50f0(%rip), %rdi      # 0xf000
leaq 0x510b(%rip), %rsi      # 0xf022
leaq 0x5117(%rip), %rcx      # 0xf035
movl $0x1b, %edx
callq 0x9380
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]wld/buffered_surface.c
// Function: surface_take
struct buffer *
surface_take(struct wld_surface *base)
{
	struct buffered_surface *surface = buffered_surface(base);
	struct buffer *buffer;

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

	surface->back->busy = true;
	surface->back = NULL;
	pixman_region32_clear(&buffer->base.damage);

	return buffer;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xaadd(%rip), %rax      # 0x14a10
cmpq %rax, (%rdi)
jne 0x9f6f
movq %rdi, %rbx
callq 0x9e1f
movq %rax, %r14
testq %rax, %rax
je 0x9f64
movq 0x18(%rbx), %rax
movb $0x1, 0x8(%rax)
movq $0x0, 0x18(%rbx)
movq %r14, %rdi
addq $0x18, %rdi
callq 0x94b0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x508a(%rip), %rdi      # 0xf000
leaq 0x50a5(%rip), %rsi      # 0xf022
leaq 0x50b1(%rip), %rcx      # 0xf035
movl $0x1b, %edx
callq 0x9380
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]wld/buffered_surface.c
// Function: surface_release
bool
surface_release(struct wld_surface *base, struct buffer *buffer)
{
	struct buffered_surface *surface = buffered_surface(base);
	unsigned index;

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

	return false;
}

// Assembly:
pushq %rax
leaq 0xaa7a(%rip), %rax      # 0x14a10
cmpq %rax, (%rdi)
jne 0x9fde
movl 0x20(%rdi), %eax
testq %rax, %rax
je 0x9fd2
movq 0x10(%rdi), %rcx
cmpq %rsi, (%rcx)
je 0x9fd6
leaq -0x1(%rax), %rdi
xorl %edx, %edx
cmpq %rdx, %rdi
je 0x9fd2
leaq 0x10(%rcx), %r8
incq %rdx
cmpq %rsi, 0x10(%rcx)
movq %r8, %rcx
jne 0x9fb2
cmpq %rax, %rdx
setb %al
movq %r8, %rcx
jmp 0x9fd8
xorl %eax, %eax
jmp 0x9fdc
movb $0x1, %al
movb $0x0, 0x8(%rcx)
popq %rcx
retq
leaq 0x501b(%rip), %rdi      # 0xf000
leaq 0x5036(%rip), %rsi      # 0xf022
leaq 0x5042(%rip), %rcx      # 0xf035
movl $0x1b, %edx
callq 0x9380
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]wld/buffered_surface.c
// Function: surface_swap
bool
surface_swap(struct wld_surface *base)
{
	struct buffered_surface *surface = buffered_surface(base);
	struct buffer *buffer;

	if (!surface->buffer_socket)
		return false;

	if (!(buffer = surface_back(base)))
		return false;

	if (!surface->buffer_socket->impl->attach(surface->buffer_socket, buffer))
		return false;

	surface->back->busy = true;
	surface->back = NULL;
	pixman_region32_clear(&buffer->base.damage);

	return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xaa08(%rip), %rax      # 0x14a10
cmpq %rax, (%rdi)
jne 0xa061
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
je 0xa057
movq %rbx, %rdi
callq 0x9e1f
testq %rax, %rax
je 0xa057
movq %rax, %r14
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *(%rax)
testb %al, %al
je 0xa057
movq 0x18(%rbx), %rax
movb $0x1, 0x8(%rax)
movq $0x0, 0x18(%rbx)
addq $0x18, %r14
movq %r14, %rdi
callq 0x94b0
movb $0x1, %al
jmp 0xa059
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4f98(%rip), %rdi      # 0xf000
leaq 0x4fb3(%rip), %rsi      # 0xf022
leaq 0x4fbf(%rip), %rcx      # 0xf035
movl $0x1b, %edx
callq 0x9380
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]wld/buffered_surface.c
// Function: surface_destroy
void
surface_destroy(struct wld_surface *base)
{
	struct buffered_surface *surface = buffered_surface(base);
	unsigned index;

	if (surface->buffer_socket)
		surface->buffer_socket->impl->destroy(surface->buffer_socket);

	for (index = 0; index < surface->entries_size; ++index)
		wld_buffer_unreference(&surface->entries[index].buffer->base);

	free(surface->entries);
	free(surface);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0xa984(%rip), %rax      # 0x14a10
cmpq %rax, (%rdi)
jne 0xa0e1
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0xa0a3
movq (%rdi), %rax
callq *0x10(%rax)
cmpl $0x0, 0x20(%rbx)
je 0xa0cb
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0x9260
incq %r15
movl 0x20(%rbx), %eax
addq $0x10, %r14
cmpq %rax, %r15
jb 0xa0af
movq 0x10(%rbx), %rdi
callq 0x9060
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x9060
leaq 0x4f18(%rip), %rdi      # 0xf000
leaq 0x4f33(%rip), %rsi      # 0xf022
leaq 0x4f3f(%rip), %rcx      # 0xf035
movl $0x1b, %edx
callq 0x9380
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]wld/color.c
// Function: wld_lookup_named_color
EXPORT
bool
wld_lookup_named_color(const char *name, uint32_t *color)
{
	char *end;
	int low = 0, mid, high = ARRAY_LENGTH(named_colors);
	int r;

	if (name[0] == '#' && name[1] != '\0') {
		*color = strtoul(name + 1, &end, 16);

		/* Set alpha channel to opaque. */
		*color |= 0xff << 24;

		if (*end == '\0')
			return true;
	}

	while (low <= high) {
		mid = (low + high) / 2;
		r = strcasecmp(named_colors[mid].name, name);

		if (r == 0) {
			*color = named_colors[mid].color;
			return true;
		}
		if (r < 0)
			low = mid + 1;
		else
			high = mid - 1;
	}

	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x23, (%rdi)
jne 0xa145
cmpb $0x0, 0x1(%r14)
je 0xa145
leaq 0x1(%r14), %rdi
leaq 0x10(%rsp), %r15
movq %r15, %rsi
movl $0x10, %edx
callq 0x9780
orl $0xff000000, %eax       # imm = 0xFF000000
movl %eax, (%rbx)
movq (%r15), %rax
cmpb $0x0, (%rax)
je 0xa1a3
movq %rbx, 0x8(%rsp)
xorl %r12d, %r12d
movl $0x2f0, %r13d           # imm = 0x2F0
leaq 0xa8e6(%rip), %r15      # 0x14a40
leal (%r12,%r13), %eax
movl %eax, %ebp
shrl $0x1f, %ebp
addl %eax, %ebp
sarl %ebp
movslq %ebp, %rbx
shlq $0x4, %rbx
movq (%rbx,%r15), %rdi
movq %r14, %rsi
callq 0x9070
testl %eax, %eax
je 0xa195
js 0xa187
decl %ebp
movl %ebp, %r13d
jmp 0xa18c
incl %ebp
movl %ebp, %r12d
cmpl %r13d, %r12d
jle 0xa15a
xorl %eax, %eax
jmp 0xa1a5
addq %rbx, %r15
movl 0x8(%r15), %eax
movq 0x8(%rsp), %rcx
movl %eax, (%rcx)
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]wld/font.c
// Function: wld_font_text_extents_n
EXPORT
void
wld_font_text_extents_n(struct wld_font *font_base,
                        const char *text, int32_t length,
                        struct wld_extents *extents)
{
	struct font *font = (void *)font_base;
	int ret;
	uint32_t c;
	FT_UInt glyph_index;

	extents->advance = 0;

	while ((ret = FcUtf8ToUcs4((FcChar8 *)text, &c, length) > 0) && c != '\0') {
		length -= ret;
		text += ret;
		glyph_index = FT_Get_Char_Index(font->face, c);

		if (!font_ensure_glyph(font, glyph_index))
			continue;

		extents->advance += font->glyphs[glyph_index]->advance;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
movl $0x0, (%rcx)
leaq 0x4(%rsp), %r12
movq %rsi, %rdi
movq %r12, %rsi
callq 0x92a0
testl %eax, %eax
setg %cl
movl (%r12), %eax
testl %eax, %eax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0xa505
incq %r14
decl %ebp
leaq 0x4(%rsp), %r12
movq 0x18(%r15), %rdi
movl %eax, %esi
callq 0x9640
movl %eax, %r13d
movq %r15, %rdi
movl %eax, %esi
callq 0xa39c
testb %al, %al
je 0xa4e7
movq 0x20(%r15), %rax
movl %r13d, %ecx
movq (%rax,%rcx,8), %rax
movzwl 0x2c(%rax), %eax
addl %eax, (%rbx)
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x92a0
testl %eax, %eax
jle 0xa505
incq %r14
decl %ebp
movl 0x4(%rsp), %eax
testl %eax, %eax
jne 0xa4ba
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]wld/renderer.c
// Function: default_fill_region
void
default_fill_region(struct wld_renderer *renderer, uint32_t color, pixman_region32_t *region)
{
	pixman_box32_t *box;
	int num_boxes;

	box = pixman_region32_rectangles(region, &num_boxes);

	while (num_boxes--) {
		renderer->impl->fill_rectangle(renderer, color, box->x1, box->y1,
		                               box->x2 - box->x1, box->y2 - box->y1);
		++box;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
leaq 0x4(%rsp), %r12
movq %rdx, %rdi
movq %r12, %rsi
callq 0x93b0
subl $0x1, (%r12)
jb 0xa566
movq %rax, %r15
movq (%r14), %rax
movl (%r15), %edx
movl 0x4(%r15), %ecx
movl 0x8(%r15), %r8d
subl %edx, %r8d
movl 0xc(%r15), %r9d
subl %ecx, %r9d
movq %r14, %rdi
movl %ebx, %esi
callq *0x10(%rax)
addq $0x10, %r15
subl $0x1, 0x4(%rsp)
jae 0xa53b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]wld/drm.c
// Function: wld_drm_create_context
wld_context *
wld_drm_create_context(int fd)
{
	const struct drm_driver *driver;
	struct wld_context *context;

	if (!getenv("WLD_DRM_DUMB")) {
		driver = find_driver(fd);
		if (driver) {
			context = driver->create_context(fd);
			if (context)
				return context;
		}
	}

	DEBUG("Falling back to dumb DRM driver\n");
	return dumb_drm_driver.create_context(fd);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movl %edi, %ebp
leaq 0x6548(%rip), %rdi      # 0x10c26
callq 0x9030
testq %rax, %rax
jne 0xa870
leaq 0x78(%rsp), %rsi
movl %ebp, 0x4(%rsp)
movl %ebp, %edi
callq 0x9880
cmpl $-0x1, %eax
je 0xa86c
movq 0xa0(%rsp), %r14
movq %r14, %rdi
callq 0x95f0
movl %eax, %ebp
movq %r14, %rdi
callq 0x9770
leaq 0x654b(%rip), %rdx      # 0x10c71
leaq 0x10(%rsp), %rdi
movl $0x40, %esi
movl %ebp, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x9300
leal -0x3a(%rax), %ecx
cmpl $-0x40, %ecx
jb 0xa86c
movslq %eax, %rbx
movl $0x726f64, 0x13(%rsp,%rbx) # imm = 0x726F64
movl $0x646e6576, 0x10(%rsp,%rbx) # imm = 0x646E6576
leaq 0x574b(%rip), %rsi      # 0xfead
leaq 0x10(%rsp), %rdi
callq 0x96d0
testq %rax, %rax
je 0xa86c
movq %rax, %r14
addq %rsp, %rbx
addq $0x10, %rbx
leaq 0x50(%rsp), %r15
movq %r15, %rdi
movl $0x20, %esi
movq %rax, %rdx
callq 0x9420
movq %r14, %rdi
callq 0x91d0
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x9780
movq %rax, 0x8(%rsp)
movl $0x69766564, (%rbx)     # imm = 0x69766564
movl $0x656369, 0x3(%rbx)    # imm = 0x656369
leaq 0x56ec(%rip), %rsi      # 0xfead
leaq 0x10(%rsp), %rdi
callq 0x96d0
testq %rax, %rax
je 0xa86c
movq %rax, %r15
leaq 0x50(%rsp), %r12
movq %r12, %rdi
movl $0x20, %esi
movq %rax, %rdx
callq 0x9420
movq %r15, %rdi
callq 0x91d0
movq %r12, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x9780
movq %rax, %r13
movq 0xd7e6(%rip), %rax      # 0x17ff0
leaq 0xd12f(%rip), %rcx      # 0x17940
leaq 0x647c(%rip), %rsi      # 0x10c94
leaq 0x6493(%rip), %rdx      # 0x10cb2
xorl %ebp, %ebp
movq (%rax), %rdi
movq (%rbp,%rcx), %rbx
movq (%rbx), %rcx
movq %rsi, %r14
movq %rdx, %r15
xorl %eax, %eax
callq 0x9480
movq 0x8(%rsp), %rdi
movq %r13, %r12
movl %r13d, %esi
callq *0x8(%rbx)
testb %al, %al
jne 0xa89d
addq $0x8, %rbp
cmpq $0x18, %rbp
movq 0xd796(%rip), %rax      # 0x17ff0
leaq 0xd0df(%rip), %rcx      # 0x17940
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %r13
jne 0xa821
movl 0x4(%rsp), %ebp
movq 0xd779(%rip), %rax      # 0x17ff0
movq (%rax), %rdi
leaq 0x63b2(%rip), %rsi      # 0x10c33
leaq 0x63d2(%rip), %rdx      # 0x10c5a
xorl %eax, %eax
callq 0x9480
leaq 0xd0c2(%rip), %rax      # 0x17958
movl %ebp, %edi
callq *0x10(%rax)
jmp 0xa8ab
movl 0x4(%rsp), %ebp
movl %ebp, %edi
callq *0x10(%rbx)
testq %rax, %rax
je 0xa870
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]wld/dumb.c
// Function: context_create_buffer
struct buffer *
context_create_buffer(struct wld_context *base,
                      uint32_t width, uint32_t height,
                      uint32_t format, uint32_t flags)
{
	struct dumb_context *context = dumb_context(base);
	struct buffer *buffer;
	struct drm_mode_create_dumb create_dumb = {
		.height = height,
		.width = width,
		.bpp = format_bytes_per_pixel(format) * 8,
	};

	if (drmIoctl(context->fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_dumb) != 0)
		goto error0;

	buffer = new_buffer(context, width, height, format,
	                    create_dumb.handle, create_dumb.pitch);

	if (!buffer)
		goto error1;

	return buffer;

error1 : {
	struct drm_mode_destroy_dumb destroy_dumb = {
		.handle = create_dumb.handle
	};

	drmIoctl(context->fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_dumb);
}
error0:
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0xd047(%rip), %rax      # 0x17970
cmpq %rax, (%rdi)
jne 0xa9d6
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movl $0xc00464b4, %eax       # imm = 0xC00464B4
leaq 0x8(%rsp), %rdx
movl %r14d, (%rdx)
movl %esi, 0x4(%rdx)
cmpl $0x34325241, %ecx       # imm = 0x34325241
sete %cl
cmpl $0x34325258, %ebp       # imm = 0x34325258
sete %sil
orb %cl, %sil
movzbl %sil, %ecx
shll $0x5, %ecx
movl %ecx, 0x8(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%rdx)
movl $0x0, 0x1c(%rdx)
movl 0x8(%rdi), %edi
leaq 0x1bfffe(%rax), %rsi
callq 0x98a0
testl %eax, %eax
je 0xa992
xorl %eax, %eax
jmp 0xa9b1
movl 0x18(%rsp), %r8d
movl 0x1c(%rsp), %r9d
movq %rbx, %rdi
movl %r15d, %esi
movl %r14d, %edx
movl %ebp, %ecx
callq 0xaab9
testq %rax, %rax
je 0xa9bc
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x18(%rsp), %eax
leaq 0x4(%rsp), %rdx
movl %eax, (%rdx)
movl 0x8(%rbx), %edi
movl $0xc00464b4, %esi       # imm = 0xC00464B4
callq 0x98a0
jmp 0xa98e
leaq 0x62e6(%rip), %rdi      # 0x10cc3
leaq 0x6301(%rip), %rsi      # 0x10ce5
leaq 0x6301(%rip), %rcx      # 0x10cec
movl $0x33, %edx
callq 0x9380
// File: /workspace/github_c_makefile_star2_O3/michaelforney[P]wld/dumb.c
// Function: context_import_buffer
struct buffer *
context_import_buffer(struct wld_context *base,
                      uint32_t type, union wld_object object,
                      uint32_t width, uint32_t height,
                      uint32_t format, uint32_t pitch)
{
	struct dumb_context *context = dumb_context(base);
	uint32_t handle;

	switch (type) {
	case WLD_DRM_OBJECT_PRIME_FD:
		if (drmPrimeFDToHandle(context->fd, object.i, &handle) != 0)
			return NULL;
		break;
	default:
		return NULL;
	}

	return new_buffer(context, width, height, format, handle, pitch);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0xcf6d(%rip), %rax      # 0x17970
cmpq %rax, (%rdi)
jne 0xaa5a
cmpl $0x2000001, %esi        # imm = 0x2000001
jne 0xaa32
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movq %rdi, %r15
movl 0x8(%rdi), %edi
leaq 0x4(%rsp), %rax
movl %edx, %esi
movq %rax, %rdx
callq 0x97e0
testl %eax, %eax
je 0xaa3f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0x4(%rsp), %r8d
movl 0x30(%rsp), %r9d
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
movl %ebx, %ecx
callq 0xaab9
jmp 0xaa34
leaq 0x6262(%rip), %rdi      # 0x10cc3
leaq 0x627d(%rip), %rsi      # 0x10ce5
leaq 0x627d(%rip), %rcx      # 0x10cec
movl $0x33, %edx
callq 0x9380