LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x1e155(%rip), %r12     # 0x2b9e0
xorl %ebx, %ebx
cmpq $0x0, 0x1c023(%rip)     # 0x298b8
je 0xd8cd
xorl %edi, %edi
callq 0xaeb9
movq %rax, %r13
movq %r14, %rdi
movq %rax, %rsi
callq 0x9fe1
testq %rax, %rax
je 0xd8f8
movq %r13, %rdi
movq %rax, %rsi
callq 0xa341
movq 0x1bff5(%rip), %rsi     # 0x298b8
movq %rax, %rdi
callq 0xd38c
jmp 0xd90d
movq %r14, %rdi
callq 0xdb2b
movb 0x28(%rax), %al
movb %al, (%r15)
incl %ebx
leaq 0x246b4(%rip), %rax     # 0x31f98
movq (%rax), %rax
movl 0x8(%rax), %edi
movl %ebx, %eax
cltd
idivl %edi
testl %edx, %edx
je 0xd932
incq %r15
jmp 0xd90f
movq 0x8(%r13), %rsi
leaq 0x11d02(%rip), %rdi     # 0x1f605
movq %r14, %rdx
xorl %eax, %eax
callq 0x9720
incl %ebx
testl %ebp, %ebp
jle 0xd917
cmpl %ebp, %ebx
jge 0xd93f
cmpl $0x2c, (%r12)
jne 0xd93f
callq 0xe1c6
movl %eax, (%r12)
cmpl $0x7d, %eax
jne 0xd88d
jmp 0xd93f
movq %rsp, %r15
movq %r15, %rsi
callq 0x1a936
jmp 0xd90f
movq %rsp, %rax
cmpq %rax, %r15
jbe 0xd955
movq %rsp, %rsi
subl %esi, %r15d
movl %r15d, %edi
callq 0x1a936
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_O1/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 0x1e061(%rip), %r12     # 0x2b9e0
movq %r14, %rdi
movl %ebx, %esi
callq 0xcd39
addl 0x8(%r14), %ebp
testl %r15d, %r15d
jle 0xd997
cmpl %r15d, %ebp
jge 0xd9ac
cmpl $0x2c, (%r12)
jne 0xd9ac
callq 0xe1c6
movl %eax, (%r12)
cmpl $0x7d, %eax
jne 0xd97f
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xdaaa
movq %rsi, %rbx
leaq 0x245c8(%rip), %rax     # 0x31f98
movq (%rax), %rax
cmpl %ebp, 0x8(%rax)
jge 0xdab5
cmpq $0x0, 0x1bee4(%rip)     # 0x298c8
jne 0xda3d
movl $0x1, %edi
callq 0x1769a
movl %eax, %edi
callq 0x16e2f
leaq 0x1b8f2(%rip), %rsi     # 0x292f0
movq %rax, %rdi
movl $0x1, %edx
callq 0x17429
movq %rax, 0x1beb6(%rip)     # 0x298c8
movb $0x51, 0x1a(%rax)
leaq 0x24563(%rip), %rax     # 0x31f80
movq (%rax), %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18a62
movq 0x1be98(%rip), %rdi     # 0x298c8
movq %rax, 0x20(%rdi)
orb $0x4, 0x1b(%rdi)
callq 0x1a687
movq 0x1be84(%rip), %rax     # 0x298c8
movq 0x20(%rax), %rax
cmpl %ebp, 0x8(%rax)
jge 0xda6b
leaq 0x2452c(%rip), %rax     # 0x31f80
movq (%rax), %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x18a62
movq 0x1be61(%rip), %rcx     # 0x298c8
movq %rax, 0x20(%rcx)
movq 0x1be56(%rip), %rdi     # 0x298c8
movq 0x20(%rdi), %r14
callq 0x9d77
movl $0x49, %edi
movq %r14, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x17b61
movq %rax, %r14
movl %ebp, %edi
callq 0x1774b
movq %rax, 0x28(%r14)
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xd38c
movl %ebp, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x1a98c
testl %ebp, %ebp
jle 0xdade
incl %ebp
leaq 0x244be(%rip), %r14     # 0x31f80
movq (%r14), %rsi
xorl %edi, %edi
callq 0x9044
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd38c
decl %ebp
cmpl $0x1, %ebp
jg 0xdac2
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1bdb4(%rip), %rax     # 0x298b8
movq %rax, 0x18(%rbx)
movq %rbx, 0x1bda9(%rip)     # 0x298b8
xorl %esi, %esi
callq 0xcd39
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
movq %rcx, 0x1bd93(%rip)     # 0x298b8
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1f1be(%rip), %r15     # 0x2ccf8
incl (%r15)
xorl %edi, %edi
callq 0xaeb9
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9fe1
testq %rax, %rax
je 0xdb64
movq %r14, %rdi
movq %rax, %rsi
callq 0xa341
jmp 0xdb83
movq 0x8(%r14), %rsi
leaq 0x11a96(%rip), %rdi     # 0x1f605
movq %rbx, %rdx
xorl %eax, %eax
callq 0x9720
xorl %edi, %edi
movq %rbx, %rsi
callq 0x9044
decl (%r15)
movl (%rax), %ecx
andl $-0x10, %ecx
cmpl $0x10, %ecx
jne 0xdb96
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1197a(%rip), %rdi     # 0x1f517
xorl %eax, %eax
callq 0x9720
xorl %edi, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x9044
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x1bd36(%rip), %rax     # 0x298f1
movq %rax, 0x1cd36(%rip)     # 0x2a8f8
movq %rax, 0x1cd37(%rip)     # 0x2a900
movl $0x0, 0x1cd35(%rip)     # 0x2a908
movq $0x0, 0x1cd32(%rip) # 0x2a910
movl $0xffffffff, 0x1cd30(%rip) # imm = 0xFFFFFFFF
movl %edi, 0x1cd2e(%rip)     # 0x2a91c
jmp 0xdbf3
// File: /workspace/github_c_makefile_star2_O1/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 0x1b8e5(%rip), %rax     # 0x298f1
movq %rax, 0x1c8e5(%rip)     # 0x2a8f8
movq %rax, 0x1c8e6(%rip)     # 0x2a900
movb (%rdi), %al
incq %rdi
movq 0x1c8da(%rip), %rcx     # 0x2a900
leaq 0x1(%rcx), %rdx
movq %rdx, 0x1c8cf(%rip)     # 0x2a900
movb %al, (%rcx)
testb %al, %al
jne 0xe01a
movq 0x1c8c2(%rip), %rax     # 0x2a900
movb $0xa, (%rax)
movl $0x0, 0x1c8cd(%rip)     # 0x2a918
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x1c8c4(%rip)     # 0x2a918
je 0xe117
movq 0x1c89f(%rip), %rax     # 0x2a900
movq 0x1c890(%rip), %rdx     # 0x2a8f8
cmpq %rdx, %rax
jbe 0xe0cf
movl %eax, %ecx
subl %edx, %ecx
movslq %ecx, %rsi
leaq 0x1b855(%rip), %rdi     # 0x298d0
movq %rdi, %rcx
subq %rsi, %rcx
addq $0x21, %rcx
cmpq %rdi, %rcx
jb 0xe138
movq 0x1c88b(%rip), %rsi     # 0x2a920
subq %rdx, %rsi
addq %rcx, %rsi
movq %rsi, 0x1c87e(%rip)     # 0x2a920
movq 0x1c84f(%rip), %rsi     # 0x2a8f8
cmpq %rax, %rsi
jae 0xe0d6
movq %rcx, %rdx
leaq 0x1(%rsi), %rdi
movq %rdi, 0x1c83c(%rip)     # 0x2a8f8
movb (%rsi), %sil
movb %sil, (%rdx)
incq %rdx
movq %rdi, %rsi
cmpq %rax, %rdi
jne 0xe0b1
jmp 0xe0d6
leaq 0x1b81b(%rip), %rcx     # 0x298f1
movq %rcx, 0x1c81b(%rip)     # 0x2a8f8
movl 0x1c839(%rip), %edi     # 0x2a91c
leaq 0x1b807(%rip), %rsi     # 0x298f1
movl $0x1000, %edx           # imm = 0x1000
callq 0x3100
movl %eax, 0x1c81e(%rip)     # 0x2a918
testl %eax, %eax
js 0xe119
addl $0x21, %eax
leaq 0x1b7c8(%rip), %rcx     # 0x298d0
leaq (%rcx,%rax), %rdx
movq %rdx, 0x1c7ed(%rip)     # 0x2a900
movb $0xa, (%rax,%rcx)
popq %rax
retq
leaq 0x1156b(%rip), %rdi     # 0x1f68b
leaq 0x11546(%rip), %rsi     # 0x1f66d
leaq 0x1154e(%rip), %rcx     # 0x1f67c
movl $0x38, %edx
callq 0x30d0
leaq 0x11522(%rip), %rdi     # 0x1f661
leaq 0x11527(%rip), %rsi     # 0x1f66d
leaq 0x1152f(%rip), %rcx     # 0x1f67c
movl $0x31, %edx
callq 0x30d0
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x1c794(%rip), %r14     # 0x2a8f8
movq (%r14), %rax
movl $0x7f, %ebx
cmpb $0x0, (%rax)
je 0xe1be
leaq 0x11788(%rip), %r15     # 0x1f900
movq (%r14), %rax
movzbl (%rax), %ecx
movzbl (%rcx,%r15), %edx
testb $0x1, %dl
je 0xe1a1
incq %rax
movq %rax, (%r14)
movzbl (%rax), %ecx
movzbl (%rcx,%r15), %edx
incq %rax
testb $0x1, %dl
jne 0xe18b
decq %rax
testb $0x2, %dl
je 0xe1bb
incq %rax
movq %rax, (%r14)
callq 0xdbf3
movq (%r14), %rax
cmpb $0x0, (%rax)
jne 0xe178
jmp 0xe1be
movzbl %cl, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1afa4(%rip), %r14     # 0x2a8f8
movq (%r14), %rax
movzbl (%rax), %ecx
orl $0x20, %ecx
cmpl $0x75, %ecx
jne 0xf96e
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
movzbl (%rax), %ebx
jmp 0xf970
xorl %ebx, %ebx
movq (%r14), %rax
movzbl (%rax), %ecx
orl $0x20, %ecx
cmpl $0x6c, %ecx
jne 0xf984
incq %rax
movq %rax, (%r14)
testl %ebx, %ebx
jne 0xf990
movq (%r14), %rax
cmpb $0x75, (%rax)
je 0xf998
movq (%r14), %rax
cmpb $0x55, (%rax)
jne 0xf9a5
movq (%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
movzbl (%rax), %ebx
testl %esi, %esi
je 0xf9d2
movq (%r14), %rax
movb (%rax), %bpl
movb $0x0, (%rax)
movq 0x1bf8f(%rip), %rsi     # 0x2b948
leaq 0x10377(%rip), %rdi     # 0x1fd37
xorl %eax, %eax
callq 0x9be3
movq (%r14), %rax
movb %bpl, (%rax)
movl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
leaq 0x225ff(%rip), %rax     # 0x31fd8
movq %rax, %rcx
testl %edi, %edi
js 0xf9e7
leaq 0x225b1(%rip), %rcx     # 0x31f98
testl %ebx, %ebx
cmovneq %rax, %rcx
movq (%rcx), %rax
movq %rax, 0x1bf81(%rip)     # 0x2b978
movl %edi, 0x1bfa3(%rip)     # 0x2b9a0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10336
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 0x10311
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x21c23(%rip), %rax     # 0x31f80
movq (%rax), %r14
callq 0x30a0
leal 0x1(%rax), %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x18a62
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16eac
movq %rax, %rbx
cmpq $0x0, 0x50(%rax)
jne 0x1039e
movq 0x20(%rbx), %rsi
movl $0x51, %edi
movl $0x3, %edx
callq 0x175a8
movq %rax, 0x50(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x103e1
movq %r15, %rdi
callq 0x16c11
leaq 0x18f24(%rip), %rsi     # 0x292f0
movq %rax, %rdi
movl $0x1, %edx
callq 0x17429
movq %rax, %r14
jmp 0x10464
leaq 0x19388(%rip), %rax     # 0x29770
movq (%rax), %rax
movl $0x88, (%rax)
movq 0x8(%rax), %r14
leaq 0x88(%r14), %rcx
cmpq 0x10(%rax), %rcx
jae 0x10408
movq %rcx, 0x8(%rax)
jmp 0x1041c
leaq 0x19361(%rip), %rsi     # 0x29770
movl $0x88, %edi
callq 0x17978
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%r14)
movups %xmm0, 0x60(%r14)
movups %xmm0, 0x50(%r14)
movups %xmm0, 0x40(%r14)
movups %xmm0, 0x30(%r14)
movups %xmm0, 0x20(%r14)
movups %xmm0, 0x10(%r14)
movups %xmm0, (%r14)
movq $0x0, 0x80(%r14)
movq %r15, %rdi
callq 0x16c11
movq %rax, 0x10(%r14)
movw $0x3, 0x18(%r14)
movb %bpl, 0x1a(%r14)
movq %rbx, 0x20(%r14)
movq %r14, %rdi
callq 0x1a687
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_O1/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 0x190eb(%rip), %rax     # 0x29770
movq (%rax), %rax
movl $0x10, (%rax)
movq 0x8(%rax), %rdi
leaq 0x10(%rdi), %rcx
cmpq 0x10(%rax), %rcx
jae 0x106a2
movq %rcx, 0x8(%rax)
jmp 0x106b6
leaq 0x190c7(%rip), %rsi     # 0x29770
movl $0x10, %edi
callq 0x17978
movq %rax, %rdi
movq %r15, (%rdi)
movq %r14, 0x8(%rdi)
movq (%rbx), %rsi
callq 0x16aec
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2190f(%rip), %r14     # 0x31ff0
movq (%r14), %rdi
movl $0x4, %esi
xorl %edx, %edx
callq 0x18a62
movl $0x51, %edi
movq %rax, %rsi
movl $0x3, %edx
callq 0x175a8
movq %rax, 0x1b37f(%rip)     # 0x2ba88
cmpq $0x0, 0x1b36f(%rip)     # 0x2ba80
jne 0x10740
leaq 0x2187e(%rip), %rax     # 0x31f98
movq (%rax), %rdi
movq (%r14), %rsi
callq 0x10e0b
leaq 0xf7e0(%rip), %rsi      # 0x1ff0c
movl $0x4a, %edi
movq %rax, %rdx
callq 0x103a9
movq %rax, 0x1b340(%rip)     # 0x2ba80
movq 0x1b339(%rip), %rdi     # 0x2ba80
callq 0x9d77
movq %rax, %rdi
callq 0xac81
movq %rax, %r14
movq 0x1b322(%rip), %rax     # 0x2ba80
movq 0x20(%rax), %rdi
callq 0x197d4
movq %rax, %r15
leaq 0x21867(%rip), %r13     # 0x31fd8
movq (%r13), %rdi
callq 0x18a44
movq %rax, %r12
movq %rbx, %rdi
callq 0x9d77
movq %rax, %rbx
movq (%r13), %rdi
callq 0x18a44
movq %rax, %r13
movq 0x1b2ed(%rip), %rdi     # 0x2ba88
callq 0x9d77
movl $0x27, %edi
movq %r13, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x17b61
movl $0x27, %edi
movq %r12, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x17b61
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x910d
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3941
// File: /workspace/github_c_makefile_star2_O1/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
cmpq $0x0, 0x1b29b(%rip)     # 0x2ba90
jne 0x1082b
leaq 0x2179a(%rip), %rax     # 0x31f98
movq (%rax), %rdi
leaq 0x217e8(%rip), %rax     # 0x31ff0
movq (%rax), %rsi
callq 0x10e0b
leaq 0xf6ff(%rip), %rsi      # 0x1ff16
movl $0x4a, %edi
movq %rax, %rdx
callq 0x103a9
movq %rax, 0x1b265(%rip)     # 0x2ba90
movq 0x1b25e(%rip), %rdi     # 0x2ba90
callq 0x9d77
movq %rax, %rdi
callq 0xac81
movq %rax, %rbx
movq 0x1b247(%rip), %rax     # 0x2ba90
movq 0x20(%rax), %rdi
callq 0x197d4
movq %rax, %r14
leaq 0x2177c(%rip), %rax     # 0x31fd8
movq (%rax), %rdi
callq 0x18a44
movq %rax, %r15
movq 0x1b21a(%rip), %rdi     # 0x2ba88
callq 0x9d77
movl $0x27, %edi
movq %r15, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x17b61
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x910d
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x3941
// File: /workspace/github_c_makefile_star2_O1/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 0x1b1d6(%rip), %rdi     # 0x2ba88
movl $0x3, %esi
callq 0xc9dc
movq 0x1b1d5(%rip), %rdi     # 0x2ba98
callq 0xca62
xorl %edi, %edi
callq 0xca62
movq 0x10(%rbx), %rdi
callq 0x1034f
movq 0x50(%rax), %rdi
callq 0xca62
movzwl 0x70(%rbx), %eax
andl $0x3ff, %eax            # imm = 0x3FF
shll $0x10, %eax
movzwl 0x72(%rbx), %r14d
orl %eax, %r14d
movq 0x68(%rbx), %rdi
callq 0x11094
shll $0x1a, %eax
orl %eax, %r14d
movl $0x6, %edi
movq %r14, %rsi
callq 0x1a8a1
movq 0x1b170(%rip), %rax     # 0x2ba88
movq %rax, 0x1b179(%rip)     # 0x2ba98
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x214d0(%rip), %r13     # 0x31ff0
movq (%r13), %rdi
xorl %r12d, %r12d
xorl %esi, %esi
xorl %edx, %edx
callq 0x18a62
movl $0x51, %edi
movq %rax, %rsi
movl $0x3, %edx
callq 0x175a8
movq %rax, %r14
movq %rax, %rdi
movl $0x4, %esi
callq 0xc9dc
movq (%r15), %rdi
testq %rdi, %rdi
je 0x10b63
callq 0x1034f
movq 0x50(%rax), %r12
movq %r12, %rdi
callq 0xca62
leaq 0x18d06(%rip), %rax     # 0x29878
movq (%rax), %rax
movq 0x10(%rax), %rdi
callq 0x1034f
movq 0x50(%rax), %rdi
callq 0xca62
movzwl 0x8(%r15), %eax
andl $0x3ff, %eax            # imm = 0x3FF
shll $0x10, %eax
movzwl 0xa(%r15), %esi
orq %rax, %rsi
movl $0x6, %edi
callq 0x1a8a1
cmpq $0x0, 0x1aefa(%rip)     # 0x2baa8
jne 0x10bd4
movq (%r13), %rdi
callq 0x18a44
leaq 0xf360(%rip), %rsi      # 0x1ff20
movl $0x4a, %edi
movq %rax, %rdx
callq 0x103a9
movq %rax, 0x1aed4(%rip)     # 0x2baa8
movq 0x1aecd(%rip), %r15     # 0x2baa8
movq %r14, %rdi
callq 0x9d77
movq %r15, %rdi
movq %rax, %rsi
callq 0x9efb
movq (%rbx), %rsi
movq %rax, %rdi
callq 0xb38e
movq %rax, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1ae2a(%rip), %rax     # 0x2ba48
movq (%rax), %r15
cmpl $0xc8, (%r15)
jb 0x10c82
leaq 0x18b3f(%rip), %rax     # 0x29770
movq (%rax), %rax
movl $0x328, (%rax)          # imm = 0x328
movq 0x8(%rax), %r15
leaq 0x328(%r15), %rcx
cmpq 0x10(%rax), %rcx
jae 0x10c51
movq %rcx, 0x8(%rax)
jmp 0x10c65
leaq 0x18b18(%rip), %rsi     # 0x29770
movl $0x328, %edi            # imm = 0x328
callq 0x17978
movq %rax, %r15
movl $0x0, (%r15)
movq 0x1add5(%rip), %rsi     # 0x2ba48
movq %r15, %rdi
callq 0x16aec
movq %rax, 0x1adc6(%rip)     # 0x2ba48
movzwl 0x8(%r12), %eax
movslq (%r15), %rcx
andl $0x3ff, %eax            # imm = 0x3FF
shll $0x10, %eax
movl $0xfc00ffff, %edx       # imm = 0xFC00FFFF
andl 0x4(%r15,%rcx,4), %edx
orl %eax, %edx
movl %edx, 0x4(%r15,%rcx,4)
movzwl 0xa(%r12), %eax
movslq (%r15), %rcx
movw %ax, 0x4(%r15,%rcx,4)
movq (%r12), %rdi
callq 0x11094
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 0x17480(%rip), %rax     # 0x28160
movq 0x158(%rax), %r15
movq %r14, %rdi
callq 0x9d77
movq %rax, %rdi
callq 0xac81
movq %rax, %r14
movl 0x1ad78(%rip), %edi     # 0x2ba78
leal 0x1(%rdi), %eax
movl %eax, 0x1ad6f(%rip)     # 0x2ba78
leaq 0x21288(%rip), %r12     # 0x31f98
movq (%r12), %rsi
callq 0x9044
movl $0x130, %edi            # imm = 0x130
movq %r14, %rsi
movq %rax, %rdx
callq *%r15
movq %rax, %rdi
callq 0xab00
movq %rax, %r14
movq (%r12), %rsi
movl $0x1, %edi
callq 0x9044
movl $0x2b, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0xb11e
movq (%rbx), %rsi
movq %rax, %rdi
callq 0xb38e
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x1acde(%rip)     # 0x2ba50
je 0x10d75
retq
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x10d8e
cmpb $0x0, (%rdi)
leaq 0xf07b(%rip), %rbx      # 0x1fe03
cmovneq %rdi, %rbx
jmp 0x10d95
leaq 0xf06e(%rip), %rbx      # 0x1fe03
leaq 0x21244(%rip), %rax     # 0x31fe0
movq (%rax), %r14
leaq 0x211da(%rip), %rax     # 0x31f80
movq (%rax), %rdi
callq 0x18a44
movq %r14, %rdi
movq %rax, %rsi
callq 0x10e0b
movl $0x51, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x103a9
movq %rax, 0x1ac80(%rip)     # 0x2ba50
movb $0x4a, 0x1a(%rax)
leaq 0xb0(%rip), %rdi        # 0x10e8b
leaq 0x1ac1e(%rip), %rdx     # 0x2ba00
movq %rax, %rsi
callq 0x10670
movq 0x1ac5f(%rip), %rsi     # 0x2ba50
leaq 0x20e(%rip), %rdi       # 0x11006
leaq 0x1ac11(%rip), %rdx     # 0x2ba10
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10670
// File: /workspace/github_c_makefile_star2_O1/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 0x210f7(%rip), %r13     # 0x31f98
movq (%r13), %rsi
movl $0x51, %edi
movl $0x3, %edx
callq 0x175a8
movq %rax, %r15
movq %rax, %rdi
movl $0x2, %esi
callq 0xc9dc
movq 0x20(%r15), %rax
movl 0x8(%rax), %edi
callq 0x1a98c
movq (%r13), %rsi
leaq 0x1de55(%rip), %rax     # 0x2ed30
movl (%rax), %edx
movl $0x43, %edi
callq 0x175a8
movq %rax, 0x1abc2(%rip)     # 0x2bab0
movq %rax, %rdi
callq 0x343c
movq 0x10(%r14), %rdi
callq 0x110e5
leaq 0xf022(%rip), %rdi      # 0x1ff28
callq 0x110e5
movq 0x1ab9e(%rip), %r12     # 0x2bab0
movq %r15, %rdi
callq 0x9d77
movq %rax, %r15
movq (%r13), %rsi
movl $0x1, %edi
callq 0x9044
movl $0x27, %edi
movq %r15, %rsi
movq %rax, %rdx
callq 0xb11e
movq %r12, %rdi
movq %rax, %rsi
callq 0x9efb
movq %rax, %rdi
xorl %esi, %esi
callq 0x111ff
leaq 0xefd3(%rip), %rdi      # 0x1ff2a
callq 0x110e5
movq 0x80(%r14), %rax
cmpq $0x0, (%rax)
je 0x10fd0
xorl %r13d, %r13d
leaq 0xdcd3(%rip), %r15      # 0x1ec46
leaq 0xefb2(%rip), %r12      # 0x1ff2c
testq %r13, %r13
je 0x10f87
movq %r12, %rdi
callq 0x110e5
movq 0x80(%r14), %rax
movq (%rax,%r13), %rax
movq 0x10(%rax), %rdi
callq 0x110e5
movq %r15, %rdi
callq 0x110e5
movq 0x80(%r14), %rax
movq (%rax,%r13), %rdi
callq 0x9d77
movq %rax, %rdi
xorl %esi, %esi
callq 0x111ff
movq 0x80(%r14), %rax
cmpq $0x0, 0x8(%rax,%r13)
leaq 0x8(%r13), %r13
jne 0x10f7a
movq 0x20(%r14), %rdi
callq 0x1a43b
testl %eax, %eax
je 0x10fe9
leaq 0xef4a(%rip), %rdi      # 0x1ff2e
callq 0x110e5
leaq 0xef43(%rip), %rdi      # 0x1ff33
callq 0x110e5
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1161c
// File: /workspace/github_c_makefile_star2_O1/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 0x110e5
leaq 0xef04(%rip), %rdi      # 0x1ff28
callq 0x110e5
movq 0x1aa80(%rip), %rdi     # 0x2bab0
callq 0x9d77
movq %rax, %rdi
xorl %esi, %esi
callq 0x111ff
leaq 0xef3a(%rip), %rdi      # 0x1ff80
callq 0x110e5
movq 0x20(%r15), %rdi
callq 0x197d4
testq %r14, %r14
je 0x1107b
leaq 0x20f80(%rip), %rcx     # 0x31fe0
cmpq (%rcx), %rax
je 0x1107b
leaq 0xd258(%rip), %rdi      # 0x1e2c4
callq 0x110e5
movq %r14, %rdi
xorl %esi, %esi
callq 0x111ff
leaq 0xeac2(%rip), %rdi      # 0x1fb44
callq 0x110e5
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1161c
// File: /workspace/github_c_makefile_star2_O1/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 0x110df
movq 0x1a9ff(%rip), %rax     # 0x2baa0
movl $0x1, %ebx
testq %rax, %rax
je 0x110c2
movq %rax, %rcx
movq 0x8(%rcx), %rcx
movq (%rcx), %rdx
cmpq %rdi, 0x48(%rdx)
je 0x110e1
incl %ebx
cmpq %rax, %rcx
jne 0x110ae
callq 0x1034f
movq 0x1a9d2(%rip), %rsi     # 0x2baa0
movq %rax, %rdi
callq 0x16aec
movq %rax, 0x1a9c3(%rip)     # 0x2baa0
jmp 0x110e1
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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, %r14
leaq 0x18681(%rip), %rbx     # 0x29778
movq 0x1a9ba(%rip), %rcx     # 0x2bab8
movq 0x1a9bb(%rip), %rax     # 0x2bac0
cmpq %rax, %rcx
jne 0x111c7
testq %rcx, %rcx
je 0x1113e
subl 0x1a9af(%rip), %eax     # 0x2bac8
leal 0x7(,%rax,2), %edi
andl $-0x8, %edi
movq (%rbx), %rax
movl %edi, (%rax)
movq 0x8(%rax), %r15
movslq %edi, %rcx
addq %r15, %rcx
cmpq 0x10(%rax), %rcx
jae 0x1115b
movq %rcx, 0x8(%rax)
jmp 0x11166
movq (%rbx), %rcx
movl $0x50, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x50(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x111a1
movq %rdx, 0x8(%rcx)
jmp 0x111ae
movq %rbx, %rsi
callq 0x17978
movq %rax, %r15
movq 0x1a95b(%rip), %rsi     # 0x2bac8
movq 0x1a94c(%rip), %r12     # 0x2bac0
subq %rsi, %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x3040
leaq (%r15,%r12), %rax
movq %rax, 0x1a92b(%rip)     # 0x2bab8
leaq (%r15,%r12,2), %rax
movq %rax, 0x1a928(%rip)     # 0x2bac0
movq %r15, 0x1a929(%rip)     # 0x2bac8
jmp 0x111c7
movl $0x50, %edi
movq %rbx, %rsi
callq 0x17978
movq %rax, 0x1a913(%rip)     # 0x2bac8
movq %rax, 0x1a8fc(%rip)     # 0x2bab8
addq $0x50, %rax
movq %rax, 0x1a8f9(%rip)     # 0x2bac0
movb (%r14), %cl
movq 0x1a8e7(%rip), %rax     # 0x2bab8
leaq 0x1(%rax), %rdx
movq %rdx, 0x1a8dc(%rip)     # 0x2bab8
movb %cl, (%rax)
cmpb $0x0, (%r14)
leaq 0x1(%r14), %r14
jne 0x110f7
movq %rax, 0x1a8c5(%rip)     # 0x2bab8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1a489(%rip), %rax     # 0x2bab8
movb $0x0, (%rax)
movq 0x1a48f(%rip), %rdi     # 0x2bac8
callq 0x16c11
movq %rax, %rdi
callq 0x1034f
movq %rax, %r14
leaq 0x1a488(%rip), %rax     # 0x2bad8
movq %rax, %r13
movq (%rax), %rcx
leaq 0x18(%rcx), %rax
testq %rcx, %rcx
jne 0x11650
leaq 0x2091a(%rip), %rax     # 0x31f80
movq (%rax), %rdi
callq 0x18a44
movq %rax, %r15
movq 0x50(%r14), %rdi
callq 0x9d77
movq %rax, %rdi
callq 0xac81
xorl %r12d, %r12d
movl $0x27, %edi
movq %r15, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x17b61
movq %rax, (%r13)
movq %rbx, %rdi
callq 0x9d77
movq %rax, %rdi
callq 0xac81
movq %rax, %r14
movq 0x20(%rbx), %rdi
callq 0x197d4
movq 0x1a41a(%rip), %rdx     # 0x2bad8
movq %r14, %rdi
movq %rax, %rsi
callq 0x910d
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3941
movq %r12, 0x1a3fc(%rip)     # 0x2bad8
movq %r12, 0x1a3dd(%rip)     # 0x2bac0
movq %r12, 0x1a3ce(%rip)     # 0x2bab8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x11788
movq %rsi, %rdi
movq %rdx, %rsi
jmp 0x11906
pushq %rax
movl $0x2, 0x16e85(%rip)     # 0x28618
movq 0x16e76(%rip), %rax     # 0x28610
movq %rax, 0x16ea7(%rip)     # 0x28648
movl %edi, 0x16eb9(%rip)     # 0x28660
movq 0x16eba(%rip), %rax     # 0x28668
movq %rax, 0x16e5b(%rip)     # 0x28610
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x11906
callq 0x117df
movq 0x16e7c(%rip), %rax     # 0x28648
movq %rax, 0x16e3d(%rip)     # 0x28610
movl $0x1, 0x16e3b(%rip)     # 0x28618
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x16e32(%rip), %eax     # 0x28618
testq %rax, %rax
je 0x1181e
leaq 0x15d3e(%rip), %rcx     # 0x27530
movq (%rcx,%rax,8), %rbx
movq 0x16e13(%rip), %rdx     # 0x28610
movq 0x10(%rbx), %rsi
subq %rsi, %rdx
jbe 0x1180d
movl (%rbx), %edi
callq 0x3090
movq 0x10(%rbx), %rax
movq %rax, 0x8(%rbx)
movq %rax, 0x16df4(%rip)     # 0x28610
popq %rbx
retq
leaq 0xe79f(%rip), %rdi      # 0x1ffc4
leaq 0xe79b(%rip), %rsi      # 0x1ffc7
leaq 0xe7a4(%rip), %rcx      # 0x1ffd7
movl $0x2b, %edx
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O1/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 0x16dcc(%rip), %rax     # 0x28610
movb (%rdi), %cl
testb %cl, %cl
je 0x1185b
incq %rdi
movb %cl, (%rax)
incq %rax
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x1184d
movq %rax, 0x16dae(%rip)     # 0x28610
movl 0x16db0(%rip), %ecx     # 0x28618
leaq 0x15cc1(%rip), %rdx     # 0x27530
movq (%rdx,%rcx,8), %rcx
cmpq 0x18(%rcx), %rax
ja 0x117df
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1af61(%rip), %rax     # 0x2cce0
testq %rax, %rax
je 0x11d8a
cmpq %rdi, 0x8(%rax)
je 0x11daa
leaq 0x1af5f(%rip), %rax     # 0x2ccf0
movq (%rax), %rax
testq %rax, %rax
je 0x11da1
cmpq %rdi, 0x8(%rax)
jne 0x11d91
jmp 0x11da3
xorl %eax, %eax
movq %rax, 0x1af36(%rip)     # 0x2cce0
movq 0x1af2f(%rip), %rax     # 0x2cce0
testq %rax, %rax
je 0x11e2a
movq 0x18(%rax), %rcx
movl 0x14(%rax), %r9d
decl %r9d
xorl %r10d, %r10d
movl %r10d, %edi
movl %r9d, %r8d
cmpl %r9d, %r10d
jg 0x11e25
leal (%rdi,%r8), %r9d
shrl %r9d
leaq (%r9,%r9,2), %r10
movl 0x4(%rcx,%r10,4), %r11d
cmpl %edx, %r11d
jle 0x11def
decl %r9d
movb $0x1, %r11b
movl %edi, %r10d
jmp 0x11e0b
leaq (%rcx,%r10,4), %r10
jne 0x11dfa
cmpl %esi, (%r10)
jg 0x11de4
cmpl %edx, %r11d
jge 0x11e12
movl %r9d, %r10d
incl %r10d
movb $0x1, %r11b
movl %r8d, %r9d
testb %r11b, %r11b
jne 0x11dc4
jmp 0x11e25
jne 0x11e19
cmpl %esi, (%r10)
jl 0x11dff
movl 0x8(%r10), %eax
xorl %r11d, %r11d
movl %r8d, %r9d
jmp 0x11dea
cmpl %r8d, %edi
jle 0x11e2f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1aeb1(%rip), %rax     # 0x2cce8
testq %rax, %rax
je 0x11e42
cmpq %rsi, 0x8(%rax)
je 0x11e62
leaq 0x1aea7(%rip), %rax     # 0x2ccf0
movq (%rax), %rax
testq %rax, %rax
je 0x11e59
cmpq %rsi, 0x8(%rax)
jne 0x11e49
jmp 0x11e5b
xorl %eax, %eax
movq %rax, 0x1ae86(%rip)     # 0x2cce8
movq 0x1ae7f(%rip), %rcx     # 0x2cce8
testq %rcx, %rcx
je 0x11e89
addq $0x20, %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x11e83
cmpq %rdi, 0x8(%rcx)
jne 0x11e72
movl 0x18(%rcx), %eax
testq %rcx, %rcx
je 0x11e89
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
leaq 0x1841f(%rip), %r14     # 0x2a8f8
movabsq $0x100000600, %rbx      # imm = 0x100000600
movq (%r14), %rax
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0x12505
cmpl $0xa, %ecx
jne 0x1250d
incq %rax
movq %rax, (%r14)
callq 0xdbf3
movl $0xa, %r15d
jmp 0x12518
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
jmp 0x12518
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
movzbl (%rax), %r15d
cmpl $0x20, %r15d
ja 0x12527
movl %r15d, %eax
btq %rax, %rbx
jb 0x124e3
leal -0x30(%r15), %eax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x9, %eax
ja 0x1257e
xorl %ebx, %ebx
movq (%r14), %rax
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0x12558
cmpl $0xa, %ecx
jne 0x1255f
incq %rax
movq %rax, (%r14)
callq 0xdbf3
movl $0xa, %eax
jmp 0x12569
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x12569
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
movzbl (%rax), %eax
leal (%rbx,%rbx,4), %ecx
leal (%r15,%rcx,2), %ebx
addl $-0x30, %ebx
leal -0x30(%rax), %ecx
movl %eax, %r15d
cmpl $0xa, %ecx
jb 0x12537
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsp, %r14
leaq 0x1835b(%rip), %r15     # 0x2a8f8
movabsq $0x200000c01, %r12      # imm = 0x200000C01
movq %r14, %rbx
movq %rbx, %r13
subq %r14, %r13
movq (%r15), %rax
movzbl (%rax), %ecx
testl %ecx, %ecx
je 0x125d1
cmpl $0xa, %ecx
jne 0x125d8
incq %rax
movq %rax, (%r15)
callq 0xdbf3
movl $0xa, %eax
jmp 0x125e2
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x125e2
leaq 0x1(%rax), %rcx
movq %rcx, (%r15)
movzbl (%rax), %eax
leal 0x1(%rax), %ecx
cmpl $0x21, %ecx
ja 0x125f0
btq %rcx, %r12
jb 0x125fd
cmpq $0x1d, %r13
ja 0x125b0
movb %al, (%rbx)
incq %rbx
jmp 0x125aa
movb $0x0, (%rbx)
movq %rsp, %rax
cmpq %rax, %rbx
je 0x12612
movq %rsp, %rdi
callq 0x16c11
jmp 0x12614
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x12652
xorl %eax, %eax
movl %edi, %ecx
shrl %ecx
incl %eax
testb $0x2, %dil
movl %ecx, %edi
je 0x12646
retq
// File: /workspace/github_c_makefile_star2_O1/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:
xorpd %xmm4, %xmm4
ucomisd %xmm4, %xmm0
movl $0x1, %eax
jne 0x14b0d
jnp 0x14b66
ucomisd %xmm4, %xmm1
jne 0x14b15
jnp 0x14b66
ucomisd %xmm0, %xmm4
jbe 0x14b2b
ucomisd %xmm1, %xmm4
jbe 0x14b2b
subsd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jae 0x14b66
ucomisd %xmm0, %xmm4
jbe 0x14b3b
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm1
ja 0x14b66
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x14b4b
ucomisd %xmm1, %xmm2
ja 0x14b66
xorl %eax, %eax
ucomisd %xmm2, %xmm0
jbe 0x14b66
ucomisd %xmm2, %xmm1
jbe 0x14b66
subsd %xmm1, %xmm3
xorl %eax, %eax
ucomisd %xmm0, %xmm3
setae %al
testl %edi, %edi
sete %cl
orb %al, %cl
jne 0x14b87
pushq %rax
leaq 0xb841(%rip), %rdi      # 0x203b8
xorl %eax, %eax
callq 0x9be3
movl $0x1, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x14bda(%rip), %rax     # 0x29778
movq (%rax), %rax
movl $0x88, (%rax)
movq 0x8(%rax), %r14
leaq 0x88(%r14), %rcx
cmpq 0x10(%rax), %rcx
jae 0x14bbe
movq %rcx, 0x8(%rax)
jmp 0x14bd2
leaq 0x14bb3(%rip), %rsi     # 0x29778
movl $0x88, %edi
callq 0x17978
movq %rax, %r14
movl $0x88, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x30e0
movl $0x1, %edi
callq 0x1769a
movl %eax, %edi
callq 0x16e2f
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)
je 0x14c73
movzbl 0x1a(%r15), %eax
cmpl $0x51, %eax
je 0x14c73
cmpl $0x4a, %eax
jne 0x14cb3
movzbl 0x1a(%r15), %eax
cmpb $0x43, %al
movl $0x51, %ecx
cmovnel %eax, %ecx
movb %cl, 0x1a(%r14)
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0x1ad17
movl $0x107, %edi            # imm = 0x107
movq %rbx, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x17b61
movq %r14, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testb $0x1, 0x1b(%r15)
jne 0x14cc2
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 0x14c98
// File: /workspace/github_c_makefile_star2_O1/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 0xb4ba(%rip), %xmm3     # 0x201b0
movapd %xmm1, %xmm4
xorpd %xmm3, %xmm4
ucomisd %xmm4, %xmm1
jne 0x14d06
jnp 0x14d30
maxsd %xmm1, %xmm4
movl $0x1, %eax
ucomisd 0xb4e1(%rip), %xmm4     # 0x201f8
ja 0x14d32
xorpd %xmm0, %xmm3
maxsd %xmm0, %xmm3
mulsd %xmm2, %xmm4
xorl %eax, %eax
ucomisd %xmm3, %xmm4
setae %al
jmp 0x14d32
xorl %eax, %eax
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x14d3e
jnp 0x14d5e
testl %edi, %edi
je 0x14d5e
testl %eax, %eax
jne 0x14d5e
pushq %rax
leaq 0xb66a(%rip), %rdi      # 0x203b8
xorl %eax, %eax
callq 0x9be3
movl $0x1, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/Oric4ever[P]lcc65/6502/build/../src/simp.c
// Function: mul
static int mul(x, y, min, max, needconst) double x, y, min, max; int needconst; {
	int cond =
	   (x > -1 && x <= 1)
    || (y > -1 && y <= 1)
	|| (x < 0 && y < 0 && -x <= max/-y)
	|| (x < 0 && y > 0 &&  x >= min/y)
	|| (x > 0 && y < 0 &&  x >= min/y)
	|| (x > 0 && y > 0 &&  x <= max/y);
	if (!cond && needconst) {
		warning("overflow in constant expression\n");
		cond = 1;
	}
	return cond;
}

// Assembly:
ucomisd 0xb499(%rip), %xmm0     # 0x20200
movl $0x1, %eax
jbe 0x14d80
movsd 0xb482(%rip), %xmm4     # 0x201f8
ucomisd %xmm0, %xmm4
jae 0x14e1d
ucomisd 0xb478(%rip), %xmm1     # 0x20200
jbe 0x14d9c
movsd 0xb466(%rip), %xmm4     # 0x201f8
ucomisd %xmm1, %xmm4
jae 0x14e1d
xorpd %xmm4, %xmm4
ucomisd %xmm0, %xmm4
jbe 0x14dce
ucomisd %xmm1, %xmm4
jbe 0x14dce
movapd 0xb3fc(%rip), %xmm4     # 0x201b0
movapd %xmm0, %xmm5
xorpd %xmm4, %xmm5
xorpd %xmm1, %xmm4
movapd %xmm3, %xmm6
divsd %xmm4, %xmm6
ucomisd %xmm5, %xmm6
jae 0x14e1d
divsd %xmm1, %xmm2
ucomisd %xmm2, %xmm0
jb 0x14de8
xorpd %xmm4, %xmm4
ucomisd %xmm0, %xmm4
jbe 0x14de8
ucomisd %xmm4, %xmm1
ja 0x14e1d
ucomisd %xmm2, %xmm0
jb 0x14dfe
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x14dfe
ucomisd %xmm1, %xmm2
ja 0x14e1d
xorl %eax, %eax
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jbe 0x14e1d
ucomisd %xmm2, %xmm1
jbe 0x14e1d
divsd %xmm1, %xmm3
xorl %eax, %eax
ucomisd %xmm0, %xmm3
setae %al
testl %edi, %edi
sete %cl
orb %al, %cl
jne 0x14e3e
pushq %rax
leaq 0xb58a(%rip), %rdi      # 0x203b8
xorl %eax, %eax
callq 0x9be3
movl $0x1, %eax
addq $0x8, %rsp
retq