LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/init.c
// Function: genasgn
static int genasgn(e, sp) Tree e; struct structexp *sp; {
	Tree p;

	sp->off = roundup(sp->off, e->type->size);
	p = simplify(ADD+P, ptr(e->type), lvalue(idnode(sp->var)), constnode(sp->off, inttype));
	if (isarray(e->type)) {
		p = tree(ASGN+B, e->type, p, e);
		p->u.sym = intconst(e->type->size);
	} else
		p = asgnnode(ASGN, retype(rvalue(p), e->type), e);
	sp->tree = tree(RIGHT, voidtype, sp->tree, p);
	sp->off += e->type->size;
	return e->type->size;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rsi), %eax
movq 0x8(%rdi), %rdi
movl 0x8(%rdi), %ecx
addl %ecx, %eax
decl %eax
negl %ecx
andl %eax, %ecx
movl %ecx, 0x8(%rsi)
callq 0x188cc
movq %rax, %r15
movq (%rbx), %rdi
callq 0x9d8b
movq %rax, %rdi
callq 0xb318
movq %rax, %r12
movl 0x8(%rbx), %edi
leaq 0x25c14(%rip), %rax     # 0x32f98
movq (%rax), %rsi
callq 0x908f
movl $0x137, %edi            # imm = 0x137
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x12443
movq 0x8(%r14), %rsi
movl (%rsi), %ecx
cmpl $0xf, %ecx
jb 0xd3b0
movq 0x10(%rsi), %rcx
movl (%rcx), %ecx
cmpl $0xc, %ecx
jne 0xd3da
movl $0x39, %edi
movq %rax, %rdx
movq %r14, %rcx
callq 0x179e5
movq %rax, %r15
movq 0x8(%r14), %rax
movl 0x8(%rax), %edi
callq 0x175d3
movq %rax, 0x28(%r15)
jmp 0xd401
movq %rax, %rdi
callq 0xaaaa
movq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x17b29
movl $0x30, %edi
movq %rax, %rsi
movq %r14, %rdx
callq 0x8cee
movq %rax, %r15
leaq 0x25bd8(%rip), %rax     # 0x32fe0
movq (%rax), %rsi
movq 0x10(%rbx), %rdx
movl $0x2a0, %edi            # imm = 0x2A0
movq %r15, %rcx
callq 0x179e5
movq %rax, 0x10(%rbx)
movq 0x8(%r14), %rax
movl 0x8(%rax), %eax
addl %eax, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/init.c
// Function: initchar
static int initchar(int len, Type ty) {
	int n = 0;
	char buf[16], *s = buf;

	do {
		if (current) {
			Type aty;
			Tree e = expr1(0);
			aty = assign(ty, e);
			if (aty)
				genasgn(cast(e, aty), current);
			else
				error("invalid initialization type; found `%t' expected `%s'\n",
					e->type, ty);
			++n;
		} else {
			*s++ = initvalue(ty)->u.v.sc;
			if (++n%inttype->size == 0) {
				defstring(inttype->size, buf);
				s = buf;
			}
		}
		if ((len > 0 && n >= len) || t != ',')
			break;
		t = gettok();
	} while (t != '}');
	if (s > buf)
		defstring(s - buf, buf);
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movl %edi, %ebp
movq %rsp, %r15
leaq 0x1f188(%rip), %r12     # 0x2c9e0
xorl %ebx, %ebx
cmpq $0x0, 0x1d056(%rip)     # 0x2a8b8
je 0xd89a
xorl %edi, %edi
callq 0xae91
movq %rax, %r13
movq %r14, %rdi
movq %rax, %rsi
callq 0x9ff1
testq %rax, %rax
je 0xd8c5
movq %r13, %rdi
movq %rax, %rsi
callq 0xa2f7
movq 0x1d028(%rip), %rsi     # 0x2a8b8
movq %rax, %rdi
callq 0xd33c
jmp 0xd8da
movq %r14, %rdi
callq 0xdaf3
movb 0x28(%rax), %al
movb %al, (%r15)
incl %ebx
leaq 0x256e7(%rip), %rax     # 0x32f98
movq (%rax), %rax
movl 0x8(%rax), %edi
movl %ebx, %eax
cltd
idivl %edi
testl %edx, %edx
je 0xd8ff
incq %r15
jmp 0xd8dc
movq 0x8(%r13), %rsi
leaq 0x11d85(%rip), %rdi     # 0x1f655
movq %r14, %rdx
xorl %eax, %eax
callq 0x974c
incl %ebx
testl %ebp, %ebp
jle 0xd8e4
cmpl %ebp, %ebx
jge 0xd90c
cmpl $0x2c, (%r12)
jne 0xd90c
callq 0xe195
movl %eax, (%r12)
cmpl $0x7d, %eax
jne 0xd85a
jmp 0xd90c
movq %rsp, %r15
movq %r15, %rsi
callq 0x1a6f4
jmp 0xd8dc
movq %rsp, %rax
cmpq %rax, %r15
jbe 0xd922
movq %rsp, %rsi
subl %esi, %r15d
movl %r15d, %edi
callq 0x1a6f4
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/init.c
// Function: initarray
static int initarray(len, ty, lev) int len,lev; Type ty; {
	int n = 0;

	do {
		initializer(ty, lev);
		n += ty->size;
		if ((len > 0 && n >= len) || t != ',')
			break;
		t = gettok();
	} while (t != '}');
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movl %edi, %r15d
xorl %ebp, %ebp
leaq 0x1f094(%rip), %r12     # 0x2c9e0
movq %r14, %rdi
movl %ebx, %esi
callq 0xcd17
addl 0x8(%r14), %ebp
testl %r15d, %r15d
jle 0xd964
cmpl %r15d, %ebp
jge 0xd979
cmpl $0x2c, (%r12)
jne 0xd979
callq 0xe195
movl %eax, (%r12)
cmpl $0x7d, %eax
jne 0xd94c
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/init.c
// Function: genspace
static void genspace(n, sp) int n; struct structexp *sp; {
	if (sp == 0)
		space(n);
	else if (n <= inttype->size)
		for ( ; n > 0; n--)
			genasgn(constnode(0, chartype), sp);
	else {
		Tree e;
		static Symbol zeros;
		if (zeros == 0) {
			zeros = install(stringd(genlabel(1)), &globals, 1);
			zeros->sclass = STATIC;
			zeros->type = array(chartype, n, 0);
			zeros->generated = 1;
			defsymbol(zeros);
		}
		if (n > zeros->type->size)
			zeros->type = array(chartype, n, 0);
		e = tree(INDIR+B, zeros->type, idnode(zeros), 0);
		e->u.sym = intconst(n);
		genasgn(e, sp);
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edi, %ebp
testq %rsi, %rsi
je 0xda72
movq %rsi, %rbx
leaq 0x255fb(%rip), %rax     # 0x32f98
movq (%rax), %rax
cmpl %ebp, 0x8(%rax)
jge 0xda7d
movq 0x1cf18(%rip), %rdi     # 0x2a8c8
testq %rdi, %rdi
jne 0xda13
movl $0x1, %edi
callq 0x17522
movl %eax, %edi
callq 0x16d50
leaq 0x1c923(%rip), %rsi     # 0x2a2f0
movq %rax, %rdi
movl $0x1, %edx
callq 0x172de
movq %rax, 0x1cee7(%rip)     # 0x2a8c8
movb $0x51, 0x1a(%rax)
leaq 0x25594(%rip), %rax     # 0x32f80
movq (%rax), %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x188ea
movq 0x1cec9(%rip), %rdi     # 0x2a8c8
movq %rax, 0x20(%rdi)
orb $0x4, 0x1b(%rdi)
callq 0x1a458
movq 0x1ceb5(%rip), %rdi     # 0x2a8c8
movq 0x20(%rdi), %r14
cmpl %ebp, 0x8(%r14)
jge 0xda3e
leaq 0x2555c(%rip), %rax     # 0x32f80
movq (%rax), %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x188ea
movq %rax, %r14
movq 0x1ce8e(%rip), %rdi     # 0x2a8c8
movq %rax, 0x20(%rdi)
callq 0x9d8b
movl $0x49, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x179e5
movq %rax, %r14
movl %ebp, %edi
callq 0x175d3
movq %rax, 0x28(%r14)
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xd33c
movl %ebp, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x1a74a
testl %ebp, %ebp
jle 0xdaa6
incl %ebp
leaq 0x254f6(%rip), %r14     # 0x32f80
movq (%r14), %rsi
xorl %edi, %edi
callq 0x908f
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd33c
decl %ebp
cmpl $0x1, %ebp
ja 0xda8a
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/init.c
// Function: structexp
Tree structexp(ty, t1) Type ty; Symbol t1; {
	struct structexp e;

	e.var = t1;
	e.off = 0;
	e.tree = 0;
	e.link = current;
	current = &e;
	initializer(ty, 0);
	current = e.link;
	return e.tree;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rsp, %rbx
movq %rsi, (%rbx)
movl $0x0, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movq 0x1cdec(%rip), %rax     # 0x2a8b8
movq %rax, 0x18(%rbx)
movq %rbx, 0x1cde1(%rip)     # 0x2a8b8
xorl %esi, %esi
callq 0xcd17
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %rcx, 0x1cdcb(%rip)     # 0x2a8b8
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/init.c
// Function: initvalue
static Tree initvalue(ty) Type ty; {
	Type aty;
	Tree e;

	needconst++;
	e = expr1(0);
	aty = assign(ty, e);
	if (aty)
		e = cast(e, aty);
	else {
		error("invalid initialization type; found `%t' expected `%s'\n",
			e->type,  ty);
		e = constnode(0, ty);
	}
	needconst--;
	if (generic(e->op) != CNST) {
		error("initializer must be constant\n");
		e = constnode(0, ty);
	}
	return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x201f6(%rip), %r15     # 0x2dcf8
incl (%r15)
xorl %edi, %edi
callq 0xae91
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9ff1
testq %rax, %rax
je 0xdb2c
movq %r14, %rdi
movq %rax, %rsi
callq 0xa2f7
jmp 0xdb4b
movq 0x8(%r14), %rsi
leaq 0x11b1e(%rip), %rdi     # 0x1f655
movq %rbx, %rdx
xorl %eax, %eax
callq 0x974c
xorl %edi, %edi
movq %rbx, %rsi
callq 0x908f
decl (%r15)
movl (%rax), %ecx
andl $-0x10, %ecx
cmpl $0x10, %ecx
jne 0xdb5e
popq %rbx
popq %r14
popq %r15
retq
leaq 0x11a02(%rip), %rdi     # 0x1f567
xorl %eax, %eax
callq 0x974c
xorl %edi, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x908f
nop
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/input.c
// Function: inputInit
void inputInit(int fd) {
	limit = cp = &buffer[MAXTOKEN + 1];
	lineno = 0;
	file = 0;			/* omit */
	bsize = -1;
	infd = fd;
	nextline();
}

// Assembly:
leaq 0x1cd6e(%rip), %rax     # 0x2a8f1
movq %rax, 0x1dd6e(%rip)     # 0x2b8f8
movq %rax, 0x1dd6f(%rip)     # 0x2b900
movl $0x0, 0x1dd6d(%rip)     # 0x2b908
movq $0x0, 0x1dd6a(%rip) # 0x2b910
movl $0xffffffff, 0x1dd68(%rip) # imm = 0xFFFFFFFF
movl %edi, 0x1dd66(%rip)     # 0x2b91c
jmp 0xdbbb
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/input.c
// Function: inputstring
void inputstring(str) char *str; {
	limit = cp = &buffer[MAXTOKEN+1];
	while ((*limit++ = *str++))
		;
	*limit = '\n';
	bsize = 0;
}

// Assembly:
leaq 0x1c908(%rip), %rax     # 0x2a8f1
movq %rax, 0x1d908(%rip)     # 0x2b8f8
movq %rax, 0x1d909(%rip)     # 0x2b900
movb (%rdi), %al
incq %rdi
movq 0x1d8fd(%rip), %rcx     # 0x2b900
leaq 0x1(%rcx), %rdx
movq %rdx, 0x1d8f2(%rip)     # 0x2b900
movb %al, (%rcx)
testb %al, %al
jne 0xdff7
movq 0x1d8e5(%rip), %rax     # 0x2b900
movb $0xa, (%rax)
movl $0x0, 0x1d8f0(%rip)     # 0x2b918
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/input.c
// Function: fillbuf
void fillbuf() {
	if (bsize == 0)
		return;
	if (limit <= cp)
		cp = &buffer[MAXTOKEN + 1];
	else {		/* move tail portion */
		int n = limit - cp;
		unsigned char *s = &buffer[MAXTOKEN + 1] - n;
		assert(s >= buffer);
		line = (char *)s - ((char *)cp - line);
		while (cp < limit)
			*s++ = *cp++;
		cp = &buffer[MAXTOKEN + 1] - n;
	}
	bsize = read(infd, (char *)&buffer[MAXTOKEN + 1], BUFSIZE);
	assert(bsize >= 0);
	limit = &buffer[MAXTOKEN + 1 + bsize];
	*limit = '\n';
}

// Assembly:
pushq %rax
cmpl $0x0, 0x1d8e7(%rip)     # 0x2b918
je 0xe0e6
movq 0x1d8c2(%rip), %rax     # 0x2b900
movq 0x1d8b3(%rip), %rdx     # 0x2b8f8
cmpq %rdx, %rax
jbe 0xe09e
movl %eax, %ecx
subl %edx, %ecx
movslq %ecx, %rsi
leaq 0x1c878(%rip), %rdi     # 0x2a8d0
movq %rdi, %rcx
subq %rsi, %rcx
addq $0x21, %rcx
cmpq %rdi, %rcx
jb 0xe107
movq 0x1d8ae(%rip), %rsi     # 0x2b920
subq %rdx, %rsi
addq %rcx, %rsi
movq %rsi, 0x1d8a1(%rip)     # 0x2b920
movq %rcx, %rsi
leaq 0x1(%rdx), %rdi
movq %rdi, 0x1d86b(%rip)     # 0x2b8f8
movb (%rdx), %dl
movb %dl, (%rsi)
incq %rsi
movq %rdi, %rdx
cmpq %rax, %rdi
jne 0xe082
jmp 0xe0a5
leaq 0x1c84c(%rip), %rcx     # 0x2a8f1
movq %rcx, 0x1d84c(%rip)     # 0x2b8f8
movl 0x1d86a(%rip), %edi     # 0x2b91c
leaq 0x1c838(%rip), %rsi     # 0x2a8f1
movl $0x1000, %edx           # imm = 0x1000
callq 0x3100
movl %eax, 0x1d84f(%rip)     # 0x2b918
testl %eax, %eax
js 0xe0e8
addl $0x21, %eax
leaq 0x1c7f9(%rip), %rcx     # 0x2a8d0
leaq (%rcx,%rax), %rdx
movq %rdx, 0x1d81e(%rip)     # 0x2b900
movb $0xa, (%rax,%rcx)
popq %rax
retq
leaq 0x115ec(%rip), %rdi     # 0x1f6db
leaq 0x115c7(%rip), %rsi     # 0x1f6bd
leaq 0x115cf(%rip), %rcx     # 0x1f6cc
movl $0x38, %edx
callq 0x30d0
leaq 0x115a3(%rip), %rdi     # 0x1f6b1
leaq 0x115a8(%rip), %rsi     # 0x1f6bd
leaq 0x115b0(%rip), %rcx     # 0x1f6cc
movl $0x31, %edx
callq 0x30d0
nop
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/lex.c
// Function: getchr
int getchr() {
	while (*cp) {
		while (map[*cp]&BLANK)
			cp++;
		if (!(map[*cp]&NEWLINE))
			return *cp;
		cp++;
		nextline();
	}
	return EOI;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x1d7c4(%rip), %r14     # 0x2b8f8
movq (%r14), %rax
movb (%rax), %cl
movl $0x7f, %ebx
testb %cl, %cl
je 0xe18d
leaq 0x11807(%rip), %r15     # 0x1f950
movzbl %cl, %edx
movzbl (%rdx,%r15), %edx
testb $0x1, %dl
je 0xe16f
incq %rax
movq %rax, (%r14)
movzbl (%rax), %ecx
movzbl (%rcx,%r15), %edx
incq %rax
testb $0x1, %dl
jne 0xe159
decq %rax
testb $0x2, %dl
je 0xe18a
incq %rax
movq %rax, (%r14)
callq 0xdbbb
movq (%r14), %rax
movb (%rax), %cl
testb %cl, %cl
jne 0xe149
jmp 0xe18d
movzbl %cl, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/lex.c
// Function: icon
static Symbol icon(unsigned n, int overflow) {
	int u = 0;

	if (*cp == 'u' || *cp == 'U')
		u = *cp++;
	if (*cp == 'l' || *cp == 'L')
		cp++;
	if ((u == 0 && *cp == 'u') || *cp == 'U')
		u = *cp++;
	if (overflow) {
		char c = *cp;
		*cp = 0;
		warning("overflow in constant `%s'\n", token);
		*cp = c;
		n = INT_MAX;
	}
	if (u || n > (unsigned)INT_MAX) {
		tval.type = unsignedtype;
		tval.u.c.v.u = n;
	} else {
		tval.type = inttype;
		tval.u.c.v.i = n;
	}
	return &tval;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
leaq 0x1bfbb(%rip), %r14     # 0x2b8f8
movq (%r14), %rax
movzbl (%rax), %ecx
movl %ecx, %edx
orl $0x20, %edx
cmpl $0x75, %edx
jne 0xf95f
leaq 0x1(%rax), %rdx
movq %rdx, (%r14)
movzbl (%rax), %ebx
movb 0x1(%rax), %cl
movq %rdx, %rax
jmp 0xf961
xorl %ebx, %ebx
movzbl %cl, %edx
orl $0x20, %edx
cmpl $0x6c, %edx
jne 0xf979
leaq 0x1(%rax), %rdx
movq %rdx, (%r14)
movb 0x1(%rax), %cl
movq %rdx, %rax
testl %ebx, %ebx
sete %dl
cmpb $0x75, %cl
sete %r8b
andb %dl, %r8b
cmpb $0x55, %cl
sete %cl
orb %r8b, %cl
cmpb $0x1, %cl
jne 0xf9a3
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
movzbl (%rax), %ebx
movq %rcx, %rax
testl %esi, %esi
je 0xf9cd
movb (%rax), %bpl
movb $0x0, (%rax)
movq 0x1cf94(%rip), %rsi     # 0x2c948
leaq 0x103cc(%rip), %rdi     # 0x1fd87
xorl %eax, %eax
callq 0x9bfd
movq (%r14), %rax
movb %bpl, (%rax)
movl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
leaq 0x23604(%rip), %rax     # 0x32fd8
movq %rax, %rcx
testl %edi, %edi
js 0xf9e2
leaq 0x235b6(%rip), %rcx     # 0x32f98
testl %ebx, %ebx
cmovneq %rax, %rcx
movq (%rcx), %rax
movq %rax, 0x1cf86(%rip)     # 0x2c978
movl %edi, 0x1cfa8(%rip)     # 0x2c9a0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: apply
void apply(list, arg1, arg2) List list; Generic arg1, arg2; {
	if (list) {
		List lp = list;
		do {
			struct entry *p = (struct entry *)lp->x;
			(*p->func)(p->cl, arg1, arg2);
			lp = lp->link;
		} while (lp != list);
	}
}

// Assembly:
testq %rdi, %rdi
je 0x10259
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdi, %r12
movq (%r12), %rax
movq 0x8(%rax), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq *(%rax)
movq 0x8(%r12), %r12
cmpq %r15, %r12
jne 0x10234
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: mkstr
Symbol mkstr(str) char *str; {
	Value v;
	Symbol p;

	v.p = str;
	p = constant(array(chartype, strlen(v.p) + 1, 0), v);
	if (p->u.c.loc == 0)
		p->u.c.loc = genident(STATIC, p->type, GLOBAL);
	return p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x22d00(%rip), %rax     # 0x32f80
movq (%rax), %r14
callq 0x30a0
leal 0x1(%rax), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x188ea
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16dcc
movq %rax, %rbx
cmpq $0x0, 0x50(%rax)
jne 0x102c1
movq 0x20(%rbx), %rsi
movl $0x51, %edi
movl $0x3, %edx
callq 0x17456
movq %rax, 0x50(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: mksymbol
Symbol mksymbol(sclass, name, ty) int sclass; char *name; Type ty; {
	Symbol p;

	if (sclass == EXTERN)
		p = install(string(name), &globals, 1);
	else {
		p = (Symbol)alloc(sizeof *p);
		BZERO(p, struct symbol);
		p->name = string(name);
		p->scope = GLOBAL;
	}
	p->sclass = sclass;
	p->type = ty;
	defsymbol(p);
	p->defined = 1;
	return p;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movl %edi, %ebp
cmpl $0x4a, %edi
jne 0x10301
movq %r15, %rdi
callq 0x16b3d
leaq 0x1a001(%rip), %rsi     # 0x2a2f0
movq %rax, %rdi
movl $0x1, %edx
callq 0x172de
movq %rax, %r14
jmp 0x1035e
leaq 0x1a468(%rip), %rax     # 0x2a770
movq (%rax), %rax
movl $0x88, (%rax)
movq 0x8(%rax), %r14
leaq 0x88(%r14), %rcx
cmpq 0x10(%rax), %rcx
jae 0x10328
movq %rcx, 0x8(%rax)
jmp 0x1033c
leaq 0x1a441(%rip), %rsi     # 0x2a770
movl $0x88, %edi
callq 0x17800
movq %rax, %r14
movl $0x88, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x30e0
movq %r15, %rdi
callq 0x16b3d
movq %rax, 0x10(%r14)
movw $0x3, 0x18(%r14)
movb %bpl, 0x1a(%r14)
movq %rbx, 0x20(%r14)
movq %r14, %rdi
callq 0x1a458
orb $0x1, 0x1b(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: attach
void attach(func, cl, list) Apply func; Generic cl; List *list; {
	struct entry *p = (struct entry *)alloc(sizeof *p);

	p->func = func;
	p->cl = cl;
	*list = append((Generic)p, *list);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1a1fa(%rip), %rax     # 0x2a770
movq (%rax), %rax
movl $0x10, (%rax)
movq 0x8(%rax), %rdi
leaq 0x10(%rdi), %rcx
cmpq 0x10(%rax), %rcx
jae 0x10593
movq %rcx, 0x8(%rax)
jmp 0x105a7
leaq 0x1a1d6(%rip), %rsi     # 0x2a770
movl $0x10, %edi
callq 0x17800
movq %rax, %rdi
movq %r15, (%rdi)
movq %r14, 0x8(%rdi)
movq (%rbx), %rsi
callq 0x16a18
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: bbentry
static void bbentry(yylink, f) Symbol yylink, f; {
	static Symbol p;

	afunc = genident(STATIC, array(voidptype, 4, 0), GLOBAL);
	if (p == 0)
		p = mksymbol(EXTERN, "_prologue", ftype(inttype, voidptype));
	walk(callnode(pointer(idnode(p)), freturn(p->type),
		tree(ARG+P, ptr(unsignedtype), idnode(yylink),
		tree(ARG+P, ptr(unsignedtype), idnode(afunc), 0))), 0, 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x22a1e(%rip), %r14     # 0x32ff0
movq (%r14), %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0x188ea
movl $0x51, %edi
movq %rax, %rsi
movl $0x3, %edx
callq 0x17456
movq %rax, 0x1c48e(%rip)     # 0x2ca88
movq 0x1c47f(%rip), %rdi     # 0x2ca80
testq %rdi, %rdi
jne 0x10636
leaq 0x2298b(%rip), %rax     # 0x32f98
movq (%rax), %rdi
movq (%r14), %rsi
callq 0x10cfa
leaq 0xf973(%rip), %rsi      # 0x1ff92
movl $0x4a, %edi
movq %rax, %rdx
callq 0x102cc
movq %rax, %rdi
movq %rax, 0x1c44a(%rip)     # 0x2ca80
callq 0x9d8b
movq %rax, %rdi
callq 0xac23
movq %rax, %r14
movq 0x1c433(%rip), %rax     # 0x2ca80
movq 0x20(%rax), %rdi
callq 0x195c1
movq %rax, %r15
leaq 0x22978(%rip), %r13     # 0x32fd8
movq (%r13), %rdi
callq 0x188cc
movq %rax, %r12
movq %rbx, %rdi
callq 0x9d8b
movq %rax, %rbx
movq (%r13), %rdi
callq 0x188cc
movq %rax, %r13
movq 0x1c3fe(%rip), %rdi     # 0x2ca88
callq 0x9d8b
movl $0x27, %edi
movq %r13, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x179e5
movl $0x27, %edi
movq %r12, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x179e5
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x9161
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x394a
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: bbexit
static void bbexit(yylink, f, e) Symbol yylink, f; Tree e; {
	static Symbol p;

	if (p == 0)
		p = mksymbol(EXTERN, "_epilogue", ftype(inttype, voidptype));
	walk(callnode(pointer(idnode(p)), freturn(p->type),
		tree(ARG+P, ptr(unsignedtype), idnode(afunc), 0)), 0, 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x1c3ad(%rip), %rdi     # 0x2ca90
testq %rdi, %rdi
jne 0x1071f
leaq 0x228a9(%rip), %rax     # 0x32f98
movq (%rax), %rdi
leaq 0x228f7(%rip), %rax     # 0x32ff0
movq (%rax), %rsi
callq 0x10cfa
leaq 0xf894(%rip), %rsi      # 0x1ff9c
movl $0x4a, %edi
movq %rax, %rdx
callq 0x102cc
movq %rax, %rdi
movq %rax, 0x1c371(%rip)     # 0x2ca90
callq 0x9d8b
movq %rax, %rdi
callq 0xac23
movq %rax, %rbx
movq 0x1c35a(%rip), %rax     # 0x2ca90
movq 0x20(%rax), %rdi
callq 0x195c1
movq %rax, %r14
leaq 0x2288f(%rip), %rax     # 0x32fd8
movq (%rax), %rdi
callq 0x188cc
movq %rax, %r15
movq 0x1c32d(%rip), %rdi     # 0x2ca88
callq 0x9d8b
movl $0x27, %edi
movq %r15, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x179e5
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x9161
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x394a
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: bbfunc
static void bbfunc(yylink, f) Symbol yylink, f; {
	Value v;
	union coordinate u;

	defglobal(afunc, DATA);
	defpointer(funclist);
	defpointer(0);
	defpointer(mkstr(f->name)->u.c.loc);
	u.c.x = f->u.f.pt[2].x;
	u.c.y = f->u.f.pt[2].y;
	u.c.index = bbfile(f->u.f.pt[2].file);
	defconst(U, (v.u = u.coord, v));
	funclist = afunc;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x1c2e9(%rip), %rdi     # 0x2ca88
movl $0x3, %esi
callq 0xc9a8
movq 0x1c2e8(%rip), %rdi     # 0x2ca98
callq 0xca2e
xorl %edi, %edi
callq 0xca2e
movq 0x10(%rbx), %rdi
callq 0x10272
movq 0x50(%rax), %rdi
callq 0xca2e
movzwl 0x70(%rbx), %eax
andl $0x3ff, %eax            # imm = 0x3FF
shll $0x10, %eax
movzwl 0x72(%rbx), %r14d
orl %eax, %r14d
movq 0x68(%rbx), %rdi
callq 0x10f83
shll $0x1a, %eax
orl %eax, %r14d
movl $0x6, %edi
movq %r14, %rsi
callq 0x1a672
movq 0x1c283(%rip), %rax     # 0x2ca88
movq %rax, 0x1c28c(%rip)     # 0x2ca98
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: bbcall
static void bbcall(yycounts, cp, e) Symbol yycounts; Coordinate *cp; Tree *e; {
	static Symbol caller;
	Value v;
	union coordinate u;
	Symbol p = genident(STATIC, array(voidptype, 0, 0), GLOBAL);

	defglobal(p, LIT);
	defpointer(cp->file ? mkstr(cp->file)->u.c.loc : 0);
	defpointer(mkstr(cfunc->name)->u.c.loc);
	u.c.x = cp->x;
	u.c.y = cp->y;
	defconst(U, (v.u = u.coord, v));
	if (caller == 0)
		caller = mksymbol(EXTERN, "_caller", ptr(voidptype));
	*e = right(asgn(caller, idnode(p)), *e);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
leaq 0x225e3(%rip), %r13     # 0x32ff0
movq (%r13), %rdi
xorl %r12d, %r12d
xorl %esi, %esi
xorl %edx, %edx
callq 0x188ea
movl $0x51, %edi
movq %rax, %rsi
movl $0x3, %edx
callq 0x17456
movq %rax, %r14
movq %rax, %rdi
movl $0x4, %esi
callq 0xc9a8
movq (%r15), %rdi
testq %rdi, %rdi
je 0x10a50
callq 0x10272
movq 0x50(%rax), %r12
movq %r12, %rdi
callq 0xca2e
leaq 0x19e19(%rip), %rax     # 0x2a878
movq (%rax), %rax
movq 0x10(%rax), %rdi
callq 0x10272
movq 0x50(%rax), %rdi
callq 0xca2e
movzwl 0x8(%r15), %eax
andl $0x3ff, %eax            # imm = 0x3FF
shll $0x10, %eax
movzwl 0xa(%r15), %esi
orq %rax, %rsi
movl $0x6, %edi
callq 0x1a672
movq 0x1c00e(%rip), %r15     # 0x2caa8
testq %r15, %r15
jne 0x10ac6
movq (%r13), %rdi
callq 0x188cc
leaq 0xf4f7(%rip), %rsi      # 0x1ffa6
movl $0x4a, %edi
movq %rax, %rdx
callq 0x102cc
movq %rax, %r15
movq %rax, 0x1bfe2(%rip)     # 0x2caa8
movq %r14, %rdi
callq 0x9d8b
movq %r15, %rdi
movq %rax, %rsi
callq 0x9f07
movq (%rbx), %rsi
movq %rax, %rdi
callq 0xb36d
movq %rax, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: bbincr
static void bbincr(yycounts, cp, e) Symbol yycounts; Coordinate *cp; Tree *e; {
	struct map *mp = (struct map *)maplist->x;

	/* append *cp to source map */
	if (mp->size >= sizeof mp->u/sizeof mp->u[0]) {
		mp = (struct map *)alloc(sizeof *mp);
		mp->size = 0;
		maplist = append((Generic *)mp, maplist);
	}
	mp->u[mp->size].c.x = cp->x;
	mp->u[mp->size].c.y = cp->y;
	mp->u[mp->size++].c.index = bbfile(cp->file);
	*e = right(incr('+', rvalue((*opnode['+'])(ADD, pointer(idnode(yycounts)),
		constnode(npoints++, inttype))), constnode(1, inttype)), *e);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq 0x1bf3f(%rip), %rsi     # 0x2ca48
movq (%rsi), %r15
movl (%r15), %eax
cmpl $0xc8, %eax
jb 0x10b71
leaq 0x19c53(%rip), %rax     # 0x2a770
movq (%rax), %rax
movl $0x328, (%rax)          # imm = 0x328
movq 0x8(%rax), %r15
leaq 0x328(%r15), %rcx
cmpq 0x10(%rax), %rcx
jae 0x10b3d
movq %rcx, 0x8(%rax)
jmp 0x10b58
leaq 0x19c2c(%rip), %rsi     # 0x2a770
movl $0x328, %edi            # imm = 0x328
callq 0x17800
movq %rax, %r15
movq 0x1bef0(%rip), %rsi     # 0x2ca48
movl $0x0, (%r15)
movq %r15, %rdi
callq 0x16a18
movq %rax, 0x1beda(%rip)     # 0x2ca48
movl (%r15), %eax
movzwl 0x8(%r12), %ecx
cltq
andl $0x3ff, %ecx            # imm = 0x3FF
shll $0x10, %ecx
movl $0xfc00ffff, %edx       # imm = 0xFC00FFFF
andl 0x4(%r15,%rax,4), %edx
orl %ecx, %edx
movl %edx, 0x4(%r15,%rax,4)
movzwl 0xa(%r12), %eax
movslq (%r15), %rcx
movw %ax, 0x4(%r15,%rcx,4)
movq (%r12), %rdi
callq 0x10f83
movslq (%r15), %rcx
leal 0x1(%rcx), %edx
movl %edx, (%r15)
shll $0x1a, %eax
movl $0x3ffffff, %edx        # imm = 0x3FFFFFF
andl 0x4(%r15,%rcx,4), %edx
orl %eax, %edx
movl %edx, 0x4(%r15,%rcx,4)
leaq 0x18591(%rip), %rax     # 0x29160
movq 0x158(%rax), %r15
movq %r14, %rdi
callq 0x9d8b
movq %rax, %rdi
callq 0xac23
movq %rax, %r14
movl 0x1be89(%rip), %edi     # 0x2ca78
leal 0x1(%rdi), %eax
movl %eax, 0x1be80(%rip)     # 0x2ca78
leaq 0x22399(%rip), %r12     # 0x32f98
movq (%r12), %rsi
callq 0x908f
movl $0x130, %edi            # imm = 0x130
movq %r14, %rsi
movq %rax, %rdx
callq *%r15
movq %rax, %rdi
callq 0xaaaa
movq %rax, %r14
movq (%r12), %rsi
movl $0x1, %edi
callq 0x908f
movl $0x2b, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0xb0f3
movq (%rbx), %rsi
movq %rax, %rdi
callq 0xb36d
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: traceinit
void traceinit(print) char *print; {
	static Symbol printer;

	if (!printer) {
		printer = mksymbol(STATIC, print && *print ? print : "printf",
			ftype(voidtype, ptr(chartype)));
		printer->sclass = EXTERN;
		attach((Apply)tracecall,   (Generic)printer, &events.entry);
		attach((Apply)tracereturn, (Generic)printer, &events.returns);
	}
}

// Assembly:
cmpq $0x0, 0x1bdef(%rip)     # 0x2ca50
je 0x10c64
retq
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x10c7d
cmpb $0x0, (%rdi)
leaq 0xf233(%rip), %rbx      # 0x1feaa
cmovneq %rdi, %rbx
jmp 0x10c84
leaq 0xf226(%rip), %rbx      # 0x1feaa
leaq 0x22355(%rip), %rax     # 0x32fe0
movq (%rax), %r14
leaq 0x222eb(%rip), %rax     # 0x32f80
movq (%rax), %rdi
callq 0x188cc
movq %r14, %rdi
movq %rax, %rsi
callq 0x10cfa
movl $0x51, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x102cc
movq %rax, 0x1bd91(%rip)     # 0x2ca50
movb $0x4a, 0x1a(%rax)
leaq 0xb0(%rip), %rdi        # 0x10d7a
leaq 0x1bd2f(%rip), %rdx     # 0x2ca00
movq %rax, %rsi
callq 0x10561
movq 0x1bd70(%rip), %rsi     # 0x2ca50
leaq 0x20e(%rip), %rdi       # 0x10ef5
leaq 0x1bd22(%rip), %rdx     # 0x2ca10
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10561
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: tracecall
static void tracecall(printer, f) Symbol printer, f; {
	int i;
	Symbol counter = genident(STATIC, inttype, GLOBAL);

	defglobal(counter, BSS);
	space(counter->type->size);
	frameno = genident(AUTO, inttype, level);
	addlocal(frameno);
	appendstr(f->name); appendstr("#");
	tracevalue(asgn(frameno, incr(INCR, idnode(counter), constnode(1, inttype))), 0);
	appendstr("(");
	for (i = 0; f->u.f.callee[i]; i++) {
		if (i)
			appendstr(",");
		appendstr(f->u.f.callee[i]->name); appendstr("=");
		tracevalue(idnode(f->u.f.callee[i]), 0);
	}
	if (variadic(f->type))
		appendstr(",...");
	appendstr(") called\n");
	tracefinis(printer);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x22208(%rip), %r13     # 0x32f98
movq (%r13), %rsi
movl $0x51, %edi
movl $0x3, %edx
callq 0x17456
movq %rax, %r15
movq %rax, %rdi
movl $0x2, %esi
callq 0xc9a8
movq 0x20(%r15), %rax
movl 0x8(%rax), %edi
callq 0x1a74a
movq (%r13), %rsi
leaq 0x1ef66(%rip), %rax     # 0x2fd30
movl (%rax), %edx
movl $0x43, %edi
callq 0x17456
movq %rax, 0x1bcd3(%rip)     # 0x2cab0
movq %rax, %rdi
callq 0x343c
movq 0x10(%r14), %rdi
callq 0x10fd4
leaq 0xf1b9(%rip), %rdi      # 0x1ffae
callq 0x10fd4
movq 0x1bcaf(%rip), %r12     # 0x2cab0
movq %r15, %rdi
callq 0x9d8b
movq %rax, %r15
movq (%r13), %rsi
movl $0x1, %edi
callq 0x908f
movl $0x27, %edi
movq %r15, %rsi
movq %rax, %rdx
callq 0xb0f3
movq %r12, %rdi
movq %rax, %rsi
callq 0x9f07
movq %rax, %rdi
xorl %esi, %esi
callq 0x110de
leaq 0xf16a(%rip), %rdi      # 0x1ffb0
callq 0x10fd4
movq 0x80(%r14), %rax
cmpq $0x0, (%rax)
je 0x10ebf
xorl %r13d, %r13d
leaq 0xddfd(%rip), %r15      # 0x1ec5f
leaq 0xf149(%rip), %r12      # 0x1ffb2
testq %r13, %r13
je 0x10e7d
movq %r12, %rdi
callq 0x10fd4
movq 0x80(%r14), %rax
movq (%rax,%r13), %rax
movq 0x10(%rax), %rdi
callq 0x10fd4
movq %r15, %rdi
callq 0x10fd4
movq 0x80(%r14), %rax
movq (%rax,%r13), %rdi
callq 0x9d8b
movq %rax, %rdi
xorl %esi, %esi
callq 0x110de
movq 0x80(%r14), %rax
cmpq $0x0, 0x8(%rax,%r13)
leaq 0x8(%r13), %r13
jne 0x10e69
movq 0x20(%r14), %rdi
callq 0x1a21e
testl %eax, %eax
je 0x10ed8
leaq 0xf0e1(%rip), %rdi      # 0x1ffb4
callq 0x10fd4
leaq 0xf0da(%rip), %rdi      # 0x1ffb9
callq 0x10fd4
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x114cf
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: tracereturn
static void tracereturn(printer, f, e) Symbol printer, f; Tree e; {
	appendstr(f->name); appendstr("#");
	tracevalue(idnode(frameno), 0);
	appendstr(" returned");
	if (freturn(f->type) != voidtype && e) {
		appendstr(" ");
		tracevalue(e, 0);
	}
	appendstr("\n");
	tracefinis(printer);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rsi), %rdi
callq 0x10fd4
leaq 0xf09b(%rip), %rdi      # 0x1ffae
callq 0x10fd4
movq 0x1bb91(%rip), %rdi     # 0x2cab0
callq 0x9d8b
movq %rax, %rdi
xorl %esi, %esi
callq 0x110de
leaq 0xf0d1(%rip), %rdi      # 0x20006
callq 0x10fd4
movq 0x20(%r15), %rdi
callq 0x195c1
testq %r14, %r14
je 0x10f6a
leaq 0x22091(%rip), %rcx     # 0x32fe0
cmpq (%rcx), %rax
je 0x10f6a
leaq 0xd369(%rip), %rdi      # 0x1e2c4
callq 0x10fd4
movq %r14, %rdi
xorl %esi, %esi
callq 0x110de
leaq 0xec23(%rip), %rdi      # 0x1fb94
callq 0x10fd4
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x114cf
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: bbfile
static int bbfile(file) char *file; {
	if (file) {
		List lp;
		int i = 1;
		lp = filelist;
		if (lp)
			do {
				lp = lp->link;
				if (((Symbol)lp->x)->u.c.v.p == file)
					return i;
				i++;
			} while (lp != filelist);
		filelist = append(mkstr(file), filelist);
		return i;
	}
	return 0;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x10fce
movq 0x1bb10(%rip), %rax     # 0x2caa0
movl $0x1, %ebx
testq %rax, %rax
je 0x10fb1
movq %rax, %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rdx
cmpq %rdi, 0x48(%rdx)
je 0x10fd0
incl %ebx
cmpq %rax, %rcx
jne 0x10f9d
callq 0x10272
movq 0x1bae3(%rip), %rsi     # 0x2caa0
movq %rax, %rdi
callq 0x16a18
movq %rax, 0x1bad4(%rip)     # 0x2caa0
jmp 0x10fd0
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: appendstr
static void appendstr(str) char *str; {
	do {
		if (fp == fmtend) {
			if (fp) {
				char *s = (char *)talloc(2*(fmtend - fmt));
				strncpy(s, fmt, fmtend - fmt);
				fp = s + (fmtend - fmt);
				fmtend = s + 2*(fmtend - fmt);
				fmt = s;
			} else {
				fp = fmt = (char *)talloc(80);
				fmtend = fmt + 80;
			}
		}
		*fp++ = *str;
	} while (*str++);
	fp--;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x1bad2(%rip), %rcx     # 0x2cab8
movq 0x1bad3(%rip), %r15     # 0x2cac0
leaq 0x19784(%rip), %r14     # 0x2a778
cmpq %r15, %rcx
je 0x11001
movq %rcx, %rax
jmp 0x110b1
testq %r15, %r15
je 0x11036
movq 0x1babb(%rip), %rsi     # 0x2cac8
subq %rsi, %r15
leal 0x7(,%r15,2), %edi
andl $-0x8, %edi
movq (%r14), %rax
movl %edi, (%rax)
movq 0x8(%rax), %r12
movslq %edi, %rcx
addq %r12, %rcx
cmpq 0x10(%rax), %rcx
jae 0x11053
movq %rcx, 0x8(%rax)
jmp 0x1106f
movq (%r14), %rcx
movl $0x50, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x50(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x11092
movq %rdx, 0x8(%rcx)
jmp 0x1109f
movq %r14, %rsi
callq 0x17800
movq %rax, %r12
movq 0x1ba63(%rip), %rsi     # 0x2cac8
movq 0x1ba54(%rip), %r15     # 0x2cac0
subq %rsi, %r15
movq %r12, %rdi
movq %r15, %rdx
callq 0x3040
leaq (%r12,%r15), %rax
leaq (%r12,%r15,2), %r15
movq %r15, 0x1ba37(%rip)     # 0x2cac0
movq %r12, 0x1ba38(%rip)     # 0x2cac8
jmp 0x110b1
movl $0x50, %edi
movq %r14, %rsi
callq 0x17800
movq %rax, 0x1ba22(%rip)     # 0x2cac8
leaq 0x50(%rax), %r15
movq %r15, 0x1ba0f(%rip)     # 0x2cac0
movb (%rbx), %dl
leaq 0x1(%rax), %rcx
movq %rcx, 0x1b9fa(%rip)     # 0x2cab8
movb %dl, (%rax)
incq %rbx
testb %dl, %dl
jne 0x10ff4
movq %rax, 0x1b9e6(%rip)     # 0x2cab8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/main.c
// Function: tracefinis
static void tracefinis(printer) Symbol printer; {
	Tree *ap;
	Symbol p;

	*fp = 0;
	p = mkstr(string(fmt));
	for (ap = &args; *ap; ap = &(*ap)->kids[1])
		;
	*ap = tree(ARG+P, ptr(chartype), pointer(idnode(p->u.c.loc)), 0);
	walk(callnode(pointer(idnode(printer)), freturn(printer->type), args), 0, 0);
	args = 0;
	fp = fmtend = 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x1b5d6(%rip), %rax     # 0x2cab8
movb $0x0, (%rax)
movq 0x1b5dc(%rip), %rdi     # 0x2cac8
callq 0x16b3d
movq %rax, %rdi
callq 0x10272
movq %rax, %r14
leaq 0x1b5d5(%rip), %rax     # 0x2cad8
movq %rax, %r13
movq (%rax), %rcx
leaq 0x18(%rcx), %rax
testq %rcx, %rcx
jne 0x11503
leaq 0x21a67(%rip), %rax     # 0x32f80
movq (%rax), %rdi
callq 0x188cc
movq %rax, %r15
movq 0x50(%r14), %rdi
callq 0x9d8b
movq %rax, %rdi
callq 0xac23
xorl %r12d, %r12d
movl $0x27, %edi
movq %r15, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x179e5
movq %rax, (%r13)
movq %rbx, %rdi
callq 0x9d8b
movq %rax, %rdi
callq 0xac23
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x195c1
movq 0x1b567(%rip), %rdx     # 0x2cad8
movq %r14, %rdi
movq %rax, %rsi
callq 0x9161
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x394a
movq %r12, 0x1b549(%rip)     # 0x2cad8
movq %r12, 0x1b52a(%rip)     # 0x2cac0
movq %r12, 0x1b51b(%rip)     # 0x2cab8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/output.c
// Function: vfprint
void vfprint(f, fmt, ap) int f; char *fmt; va_list ap; {
	if (f == 1)
		vprint(fmt, ap);
	else {
		fd = 2;
		io[1]->bp = bp;
		io[2]->fd = f;
		bp = io[2]->bp;
		vprint(fmt, ap);
		outflush();
		bp = io[1]->bp;
		fd = 1;
	}
}

// Assembly:
cmpl $0x1, %edi
jne 0x1163c
movq %rsi, %rdi
movq %rdx, %rsi
jmp 0x117ba
pushq %rax
movl $0x2, 0x17fd1(%rip)     # 0x29618
movq 0x17fc2(%rip), %rax     # 0x29610
movq %rax, 0x17ff3(%rip)     # 0x29648
movl %edi, 0x18005(%rip)     # 0x29660
movq 0x18006(%rip), %rax     # 0x29668
movq %rax, 0x17fa7(%rip)     # 0x29610
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x117ba
callq 0x11693
movq 0x17fc8(%rip), %rax     # 0x29648
movq %rax, 0x17f89(%rip)     # 0x29610
movl $0x1, 0x17f87(%rip)     # 0x29618
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/output.c
// Function: outflush
void outflush() {
	struct io *iop = io[fd];

	assert(fd);
	if (bp > iop->buffer)
		write(iop->fd, iop->buffer, bp - iop->buffer);
	bp = iop->bp = iop->buffer;
}

// Assembly:
pushq %rbx
movl 0x17f7e(%rip), %eax     # 0x29618
testq %rax, %rax
je 0x116d2
leaq 0x16e8a(%rip), %rcx     # 0x28530
movq (%rcx,%rax,8), %rbx
movq 0x17f5f(%rip), %rdx     # 0x29610
movq 0x10(%rbx), %rsi
subq %rsi, %rdx
jbe 0x116c5
movl (%rbx), %edi
callq 0x3090
movq 0x10(%rbx), %rsi
movq %rsi, 0x8(%rbx)
movq %rsi, 0x17f40(%rip)     # 0x29610
popq %rbx
retq
leaq 0xe96f(%rip), %rdi      # 0x20048
leaq 0xe96b(%rip), %rsi      # 0x2004b
leaq 0xe974(%rip), %rcx      # 0x2005b
movl $0x2b, %edx
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/output.c
// Function: outs
void outs(s) char *s; {
	char *p = bp;

	while (*s) *p++ = *s++;
	bp = p;
	if (bp > io[fd]->limit)
		outflush();
}

// Assembly:
movq 0x17f18(%rip), %rax     # 0x29610
movb (%rdi), %cl
testb %cl, %cl
je 0x1170f
incq %rdi
movb %cl, (%rax)
incq %rax
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x11701
movq %rax, 0x17efa(%rip)     # 0x29610
movl 0x17efc(%rip), %ecx     # 0x29618
leaq 0x16e0d(%rip), %rdx     # 0x28530
movq (%rdx,%rcx,8), %rcx
cmpq 0x18(%rcx), %rax
ja 0x11693
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/profio.c
// Function: findcount
int findcount(file, x, y) char *file; int x,y; {
	static struct file *cursor;

	if (cursor == 0 || cursor->name != file)
		cursor = findfile(file);
	if (cursor) {
		int l, u;
		struct count *c = cursor->counts;
		for (l = 0, u = cursor->count - 1; l <= u; ) {
			int k = (l + u)/2;
			if (c[k].y > y || c[k].y == y && c[k].x > x)
				u = k - 1;
			else if (c[k].y < y || c[k].y == y && c[k].x < x)
				l = k + 1;
			else
				return c[k].count;
		}
	}
	return -1;
}

// Assembly:
movq 0x1c0ad(%rip), %r8      # 0x2dce0
testq %r8, %r8
je 0x11c3e
cmpq %rdi, 0x8(%r8)
je 0x11c5a
leaq 0x1c0ab(%rip), %r8      # 0x2dcf0
movq (%r8), %r8
testq %r8, %r8
je 0x11ca6
cmpq %rdi, 0x8(%r8)
jne 0x11c45
movq %r8, 0x1c086(%rip)      # 0x2dce0
movl 0x14(%r8), %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jle 0x11ca5
movq 0x18(%r8), %rdi
decl %ecx
xorl %r8d, %r8d
leal (%r8,%rcx), %r9d
shrl %r9d
leaq (%r9,%r9,2), %r10
movl 0x4(%rdi,%r10,4), %r11d
cmpl %edx, %r11d
jle 0x11c8d
decl %r9d
movl %r9d, %ecx
jmp 0x11ca0
leaq (%rdi,%r10,4), %r10
jne 0x11c98
cmpl %esi, (%r10)
jg 0x11c85
jge 0x11cb7
incl %r9d
movl %r9d, %r8d
cmpl %ecx, %r8d
jle 0x11c70
retq
movq $0x0, 0x1c02f(%rip) # 0x2dce0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
movl 0x8(%r10), %eax
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/profio.c
// Function: findfunc
int findfunc(name, file) char *name, *file; {
	static struct file *cursor;

	if (cursor == 0 || cursor->name != file)
		cursor = findfile(file);
	if (cursor) {
		struct func *p;
		for (p = cursor->funcs; p; p = p->link)
			if (p->name == name)
				return p->count.count;
	}
	return -1;
}

// Assembly:
movq 0x1c025(%rip), %rax     # 0x2dce8
testq %rax, %rax
je 0x11cce
cmpq %rsi, 0x8(%rax)
je 0x11cea
leaq 0x1c01b(%rip), %rax     # 0x2dcf0
movq (%rax), %rax
testq %rax, %rax
je 0x11d00
cmpq %rsi, 0x8(%rax)
jne 0x11cd5
movq %rax, 0x1bffe(%rip)     # 0x2dce8
addq $0x20, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x11d0b
cmpq %rdi, 0x8(%rax)
jne 0x11cee
movl 0x18(%rax), %eax
retq
movq $0x0, 0x1bfdd(%rip) # 0x2dce8
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/profio.c
// Function: getd
static int getd() {
	int c, n = 0;

	while ((c = ngetc()) != EOF && (c == ' ' || c == '\n' || c == '\t'))
		;
	if (c >= '0' && c <= '9') {
		do
			n = 10*n + (c - '0');
		while ((c = ngetc()) >= '0' && c <= '9');
		return n;
	}
	return -1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x1960c(%rip), %r14     # 0x2b8f8
movq (%r14), %rdx
movabsq $0x100000600, %rbx      # imm = 0x100000600
movq %rdx, %rax
movzbl (%rdx), %ecx
cmpl $0xa, %ecx
je 0x12320
testl %ecx, %ecx
je 0x12330
leaq 0x1(%rax), %rdx
movq %rdx, (%r14)
movzbl (%rax), %ecx
cmpq $0x20, %rcx
ja 0x1233f
btq %rcx, %rbx
jb 0x122f9
jmp 0x1233f
incq %rax
movq %rax, (%r14)
callq 0xdbbb
movq (%r14), %rdx
jmp 0x122f9
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leal -0x30(%rcx), %edx
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x9, %edx
ja 0x12335
addq $0x2, %rax
xorl %ebx, %ebx
leal (%rbx,%rbx,4), %edx
leal (%rcx,%rdx,2), %ebx
addl $-0x30, %ebx
movzbl -0x1(%rax), %ecx
testl %ecx, %ecx
je 0x12335
cmpl $0xa, %ecx
je 0x12383
leaq -0x1(%rax), %rcx
incq %rcx
movq %rcx, (%r14)
movzbl -0x1(%rax), %ecx
leal -0x30(%rcx), %edx
incq %rax
cmpl $0xa, %edx
jb 0x12352
jmp 0x12335
movq %rax, (%r14)
callq 0xdbbb
jmp 0x12335
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/profio.c
// Function: getstr
static char *getstr() {
	int c;
	char buf[MAXTOKEN], *s = buf;

	while ((c = ngetc()) != EOF && c != ' ' && c != '\n' && c != '\t')
		if (s - buf < sizeof buf - 2)
			*s++ = c;
	*s = 0;
	return s == buf ? 0 : string(buf);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
leaq 0x1955f(%rip), %rax     # 0x2b8f8
movq (%rax), %rsi
movq %rsp, %rcx
movabsq $0x100000600, %rdx      # imm = 0x100000600
movq %rcx, %rbx
movq %rbx, %rdi
subq %rcx, %rdi
movq %rsi, %r8
movzbl (%r8), %esi
testl %esi, %esi
je 0x123f5
cmpl $0xa, %esi
je 0x123ea
leaq 0x1(%r8), %rsi
movq %rsi, (%rax)
movzbl (%r8), %r9d
cmpq $0x20, %r9
ja 0x123d9
btq %r9, %rdx
jb 0x123f5
movq %rsi, %r8
cmpq $0x1d, %rdi
ja 0x123b5
movb %r9b, (%rbx)
incq %rbx
jmp 0x123ac
incq %r8
movq %r8, (%rax)
callq 0xdbbb
movb $0x0, (%rbx)
movq %rsp, %rax
cmpq %rax, %rbx
je 0x1240a
movq %rsp, %rdi
callq 0x16b3d
jmp 0x1240c
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/simp.c
// Function: ispow2
int ispow2(u) unsigned u; {
	int n;

	if (u > 1 && (u&(u-1)) == 0)
		for (n = 0; u; u >>= 1, n++)
			if (u&1)
				return n;
	return 0;
}

// Assembly:
cmpl $0x2, %edi
setb %cl
leal -0x1(%rdi), %eax
testl %eax, %edi
setne %dl
xorl %eax, %eax
movl %edi, %esi
orb %cl, %sil
orb %dl, %sil
testb $0x1, %sil
jne 0x12442
xorl %eax, %eax
movl %edi, %ecx
shrl %ecx
incl %eax
testb $0x2, %dil
movl %ecx, %edi
je 0x12436
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/simp.c
// Function: add
static int add(x, y, min, max, needconst) double x, y, min, max;  int needconst; {
	int cond =
        x == 0
    ||  y == 0
	|| (x < 0 && y < 0 && x >= min - y)
	|| (x < 0 && y > 0)
	|| (x > 0 && y < 0)
	|| (x > 0 && y > 0 && x <= max - y);
	if (!cond && needconst) {
		warning("overflow in constant expression\n");
		cond = 1;
	}
	return cond;
}

// Assembly:
pushq %rbx
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm0
movl $0x1, %ebx
jne 0x149d5
jnp 0x14a52
ucomisd %xmm4, %xmm1
jne 0x149dd
jnp 0x14a52
ucomisd %xmm0, %xmm4
jbe 0x149f3
ucomisd %xmm1, %xmm4
jbe 0x149f3
subsd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jae 0x14a52
ucomisd %xmm0, %xmm4
jbe 0x14a03
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
ja 0x14a52
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x14a13
ucomisd %xmm1, %xmm2
ja 0x14a52
subsd %xmm1, %xmm3
ucomisd %xmm0, %xmm3
setae %cl
xorpd %xmm3, %xmm3
cmpltpd %xmm0, %xmm3
cmpltpd %xmm1, %xmm2
andpd %xmm3, %xmm2
movd %xmm2, %eax
andb %cl, %al
testl %edi, %edi
sete %cl
orb %al, %cl
je 0x14a44
movzbl %al, %ebx
jmp 0x14a52
leaq 0xb9ed(%rip), %rdi      # 0x20438
xorl %eax, %eax
callq 0x9bfd
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/simp.c
// Function: addrnode
static Tree addrnode(p, n, ty) Symbol p; int n; Type ty; {
	Symbol q = (Symbol)talloc(sizeof *q);
	Tree e;
	static struct symbol z;

	*q = z;
	q->name = stringd(genlabel(1));
	q->sclass = p->sclass;
	q->scope = p->scope;
	q->type = ty;
	q->defined = 1;
	q->temporary = p->temporary;
	q->generated = p->generated;
	q->computed = 1;
	q->addressed = p->addressed;
	q->initialized = p->initialized;
	q->ref = 1;
	if (p->scope == GLOBAL || p->sclass == STATIC || p->sclass == EXTERN) {
		q->sclass = p->sclass == AUTO ? STATIC : p->sclass;
		address(q, p, n);
		e = tree(ADDRG+P, ty, 0, 0);
	} else {
		Code cp;
		if (!p->defined)
			addlocal(p);
		cp = code(Address);
		cp->u.addr.sym = q;
		cp->u.addr.base = p;
		cp->u.addr.offset = n;
		e = tree(p->scope == PARAM ? ADDRF+P : ADDRL+P, ty, 0, 0);
	}
	e->u.sym = q;
	return e;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
leaq 0x15d0c(%rip), %rax     # 0x2a778
movq (%rax), %rax
movl $0x88, (%rax)
movq 0x8(%rax), %r14
leaq 0x88(%r14), %rcx
cmpq 0x10(%rax), %rcx
jae 0x14a8c
movq %rcx, 0x8(%rax)
jmp 0x14aa0
leaq 0x15ce5(%rip), %rsi     # 0x2a778
movl $0x88, %edi
callq 0x17800
movq %rax, %r14
movl $0x88, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x30e0
movl $0x1, %edi
callq 0x17522
movl %eax, %edi
callq 0x16d50
movq %rax, 0x10(%r14)
movb 0x1a(%r15), %al
movb %al, 0x1a(%r14)
movzwl 0x18(%r15), %eax
movw %ax, 0x18(%r14)
movq %rbx, 0x20(%r14)
movb 0x1b(%r14), %al
orb $0x1, %al
movb %al, 0x1b(%r14)
movb 0x1b(%r15), %cl
andb $0x2, %cl
andb $-0x3, %al
orb %cl, %al
movb %al, 0x1b(%r14)
movb 0x1b(%r15), %cl
andb $0x4, %cl
andb $-0xd, %al
orb %cl, %al
orb $0x8, %al
movb %al, 0x1b(%r14)
movb 0x1b(%r15), %cl
andb $0x10, %cl
andb $-0x11, %al
orb %cl, %al
movb %al, 0x1b(%r14)
movb 0x1b(%r15), %cl
andb $0x20, %cl
andb $-0x21, %al
orb %cl, %al
movb %al, 0x1b(%r14)
movl $0x1, 0x1c(%r14)
cmpw $0x3, 0x18(%r15)
movzbl 0x1a(%r15), %eax
je 0x14b41
cmpl $0x51, %eax
je 0x14b41
cmpl $0x4a, %eax
jne 0x14b7d
cmpl $0x43, %eax
movl $0x51, %ecx
cmovnel %eax, %ecx
movb %cl, 0x1a(%r14)
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x1aacc
movl $0x107, %edi            # imm = 0x107
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x179e5
movq %r14, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testb $0x1, 0x1b(%r15)
jne 0x14b8c
movq %r15, %rdi
callq 0x343c
movl $0x3, %edi
callq 0x3468
movq %r14, 0x18(%rax)
movq %r15, 0x20(%rax)
movl %ebp, 0x28(%rax)
xorl %edi, %edi
cmpw $0x4, 0x18(%r15)
setne %dil
shll $0x4, %edi
addl $0x117, %edi            # imm = 0x117
jmp 0x14b62
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/simp.c
// Function: div
static int div(x, y, min, max, needconst) double x, y, min, max; int needconst; {
	int cond;

	if (x < 0) x = -x;
	if (y < 0) y = -y;
	cond = y != 0 && (y > 1 || x <= max*y);
	if (!cond && y != 0 && needconst) {
		warning("overflow in constant expression\n");
		cond = 1;
	}
	return cond;
}

// Assembly:
movapd 0xb670(%rip), %xmm3     # 0x20230
movapd %xmm1, %xmm4
xorpd %xmm3, %xmm4
ucomisd %xmm4, %xmm1
jne 0x14bd0
jnp 0x14c1b
maxsd %xmm1, %xmm4
movl $0x1, %eax
ucomisd 0xb697(%rip), %xmm4     # 0x20278
ja 0x14c1a
xorpd %xmm0, %xmm3
maxsd %xmm0, %xmm3
mulsd %xmm2, %xmm4
xorl %eax, %eax
ucomisd %xmm3, %xmm4
setae %al
testl %edi, %edi
je 0x14c1a
ucomisd %xmm3, %xmm4
jae 0x14c1a
pushq %rax
leaq 0xb82e(%rip), %rdi      # 0x20438
xorl %eax, %eax
callq 0x9bfd
movl $0x1, %eax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq