LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: check
static Field check(ty, top, inherited, off) Type ty, top; Field inherited; int off; {
	Field p;

	for (p = ty->u.sym->u.s.flist; p; p = p->link)
		if (p->name && isfield(p->name, inherited))
			error("ambiguous field `%s' of `%t' from `%t'\n", p->name, top, ty);
		else if (p->name && !isfield(p->name, top->u.sym->u.s.flist)) {
			Field new = (Field) talloc(sizeof *new);
			*new = *p;
			new->offset = off + p->offset;
			new->link = inherited;
			inherited = new;
		}
	for (p = ty->u.sym->u.s.flist; p; p = p->link)
		if (p->name == 0)
			inherited = check(p->type, top, inherited,
				off + p->offset);
	return inherited;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x18(%rdi), %rax
movq 0x58(%rax), %r13
testq %r13, %r13
je 0x18baf
movl %ecx, %ebp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x11ca4(%rip), %r12     # 0x2a778
movq (%r13), %rsi
testq %rsi, %rsi
je 0x18b71
testq %rbx, %rbx
je 0x18af7
movq %rbx, %rax
cmpq %rsi, (%rax)
je 0x18b2d
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0x18ae9
movq 0x18(%r14), %rax
movq 0x58(%rax), %rax
testq %rax, %rax
je 0x18b0f
cmpq %rsi, (%rax)
je 0x18b71
movq 0x18(%rax), %rax
jmp 0x18aff
movq (%r12), %rcx
movl $0x20, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x20(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x18b43
movq %rdx, 0x8(%rcx)
jmp 0x18b50
leaq 0x8df1(%rip), %rdi      # 0x21925
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x974c
jmp 0x18b71
movl $0x20, %edi
movq %r12, %rsi
callq 0x17800
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movl 0x10(%r13), %ecx
addl %ebp, %ecx
movl %ecx, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %rax, %rbx
movq 0x18(%r13), %r13
testq %r13, %r13
jne 0x18ad4
movq 0x18(%r15), %rax
movq 0x58(%rax), %r15
testq %r15, %r15
je 0x18baf
cmpq $0x0, (%r15)
jne 0x18ba9
movq 0x8(%r15), %rdi
movl 0x10(%r15), %ecx
addl %ebp, %ecx
movq %r14, %rsi
movq %rbx, %rdx
callq 0x18aa6
movq %rax, %rbx
movq 0x18(%r15), %r15
jmp 0x18b86
movq %rbx, %rax
addq $0x8, %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/types.c
// Function: qual
Type qual(int op, Type ty) {
	if (isarray(ty))
		ty = tynode(ARRAY, qual(op, ty->type), ty->size,
			ty->align, 0);
	else if (isfunc(ty))
		warning("qualified function type ignored\n");
	else if ((isconst(ty) && op == CONST) || (isvolatile(ty) && op == VOLATILE))
		error("illegal type `%k %t'\n", op, ty);
	else {
		int i;
		struct type *tn;
		if (isqual(ty)) {
			op += ty->op;
			ty = ty->type;
		}
		for (i = 0; i < sizeof typetable/sizeof typetable[0]; i++)
			for (tn = typetable[i]; tn; tn = tn->link)
				if (tn->type.op == op && tn->type.type == ty) {
					tn->type.size = ty->size;
					tn->type.align = ty->align;
					return &tn->type;
				}
		return tynode(op, ty, ty->size, ty->align, 0);
	}
	return ty;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movl %edi, %eax
movl (%rsi), %ecx
cmpl $0xf, %ecx
jb 0x18e6b
movq 0x10(%rbx), %rsi
movl (%rsi), %edx
cmpl $0xc, %edx
je 0x18e76
jmp 0x18e95
movl %ecx, %edx
cmpl $0xc, %ecx
jne 0x18e95
movq 0x10(%rbx), %rsi
movl %eax, %edi
callq 0x18e51
movl 0x8(%rbx), %edx
movswl 0x4(%rbx), %ecx
movl $0xc, %edi
movq %rax, %rsi
xorl %r8d, %r8d
popq %rbx
jmp 0x187eb
cmpl $0xb, %edx
jne 0x18eaa
leaq 0x89d4(%rip), %rdi      # 0x21875
xorl %eax, %eax
callq 0x9bfd
jmp 0x18f24
cmpl $0xf, %ecx
jne 0x18ef3
cmpl $0xf, %eax
je 0x18f01
addl %ecx, %eax
movq 0x10(%rbx), %rsi
xorl %ecx, %ecx
leaq 0x1a17d(%rip), %rdx     # 0x33040
movq (%rdx,%rcx,8), %rbx
testq %rbx, %rbx
je 0x18edc
cmpl %eax, (%rbx)
jne 0x18ed6
cmpq %rsi, 0x10(%rbx)
je 0x18f16
movq 0x28(%rbx), %rbx
jmp 0x18ec7
incq %rcx
cmpq $0x80, %rcx
jne 0x18ec3
movl 0x8(%rsi), %edx
movswl 0x4(%rsi), %ecx
movl %eax, %edi
jmp 0x18e8c
movl %ecx, %edx
xorl $0x1f, %edx
movl %eax, %esi
xorl $0xf, %esi
orl %edx, %esi
jne 0x18f29
leaq 0x898e(%rip), %rdi      # 0x21896
movl %eax, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x974c
jmp 0x18f24
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rbx)
movzwl 0x4(%rsi), %eax
movw %ax, 0x4(%rbx)
movq %rbx, %rax
popq %rbx
retq
cmpl $0x10, %ecx
jne 0x18f35
cmpl $0x10, %eax
jne 0x18eb4
jmp 0x18f01
movl %eax, %esi
xorl $0x10, %esi
orl %edx, %esi
je 0x18f01
cmpl $0xf, %ecx
jae 0x18eb4
movq %rbx, %rsi
jmp 0x18eba
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: deftype
Symbol deftype(name, ty, pos) char *name; Type ty; Coordinate *pos; {
	Symbol p = lookup(name, identifiers);

	if (p && p->scope == level)
		error("redeclaration of `%s'\n", name);
	p = install(name, &identifiers, level < LOCAL);
	p->type = ty;
	p->sclass = TYPEDEF;
	p->src = *pos;
	return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x112ca(%rip), %rax     # 0x2a2e8
movq (%rax), %rsi
callq 0x1728e
leaq 0x16d03(%rip), %r12     # 0x2fd30
movl (%r12), %ecx
testq %rax, %rax
je 0x19053
movzwl 0x18(%rax), %eax
cmpl %eax, %ecx
jne 0x19053
leaq 0x8680(%rip), %rdi      # 0x216c5
movq %r15, %rsi
xorl %eax, %eax
callq 0x974c
movl (%r12), %ecx
xorl %edx, %edx
cmpl $0x5, %ecx
setl %dl
leaq 0x11286(%rip), %rsi     # 0x2a2e8
movq %r15, %rdi
callq 0x172de
movq %r14, 0x20(%rax)
movb $0x53, 0x1a(%rax)
movups (%rbx), %xmm0
movups %xmm0, 0x28(%rax)
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/types.c
// Function: deref
Type deref(ty) Type ty; {
	if (isptr(ty))
		ty = ty->type;
	else
		error("type error: %s\n", "pointer expected");
	return isenum(ty) ? unqual(ty)->type : ty;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0xf, %eax
jb 0x19096
movq 0x10(%rbx), %rax
movl (%rax), %eax
cmpl $0x7, %eax
jne 0x190a1
movq 0x10(%rbx), %rbx
jmp 0x190b6
leaq 0x85ed(%rip), %rdi      # 0x21695
leaq 0x862d(%rip), %rsi      # 0x216dc
xorl %eax, %eax
callq 0x974c
movl (%rbx), %ecx
cmpl $0xf, %ecx
jb 0x190c8
movq 0x10(%rbx), %rax
cmpl $0xd, (%rax)
je 0x190d0
jmp 0x190d4
movq %rbx, %rax
cmpl $0xd, %ecx
jne 0x190d4
movq 0x10(%rax), %rbx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: extends
Field extends(ty, fty) Type ty, fty; {
	Field p, q;

	for (p = unqual(ty)->u.sym->u.s.flist; p; p = p->link)
		if (p->name == 0 && unqual(p->type) == unqual(fty))
			return p;
		else if (p->name == 0 && (q = extends(p->type, fty))) {
			static struct field f;
			f = *q;
			f.offset = p->offset + q->offset;
			return &f;
		}
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
cmpl $0xf, (%rdi)
jb 0x1928e
movq 0x10(%rdi), %rdi
movq 0x18(%rdi), %rax
movq 0x58(%rax), %rbx
testq %rbx, %rbx
je 0x192d6
cmpq $0x0, (%rbx)
jne 0x192d0
movq 0x8(%rbx), %rdi
cmpl $0xf, (%rdi)
movq %rdi, %rax
jb 0x192b1
movq 0x10(%rdi), %rax
cmpl $0xf, (%r14)
movq %r14, %rcx
jb 0x192be
movq 0x10(%r14), %rcx
cmpq %rcx, %rax
je 0x192d8
movq %r14, %rsi
callq 0x1927e
testq %rax, %rax
jne 0x192e3
movq 0x18(%rbx), %rbx
jmp 0x19296
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x19d17(%rip)    # 0x33008
movups %xmm0, 0x19d00(%rip)    # 0x32ff8
movl 0x10(%rax), %eax
addl 0x10(%rbx), %eax
leaq 0x19cf3(%rip), %rbx     # 0x32ff8
movl %eax, 0x19cfd(%rip)     # 0x33008
jmp 0x192d8
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: fieldlist
Field fieldlist(ty) Type ty; {
	Field p, q, t, inherited = 0, *r;

	ty = unqual(ty);
	for (p = ty->u.sym->u.s.flist; p; p = p->link)
		if (p->name == 0)
			inherited = check(p->type, ty, inherited, p->offset);
	if (inherited == 0)
		return ty->u.sym->u.s.flist;
	for (q = 0, p = inherited; p; q = p, p = t) {
		t = p->link;
		p->link = q;
	}
	for (r = &inherited, p = ty->u.sym->u.s.flist; p && q; )
		if (p->name == 0)
			p = p->link;
		else if (p->offset <= q->offset) {
			*r = (Field) talloc(sizeof **r);
			**r = *p;
			r = &(*r)->link;
			p = p->link;
		} else {
			*r = q;
			r = &q->link;
			q = q->link;
		}
	for ( ; p; p = p->link)
		if (p->name) {
			*r = (Field) talloc(sizeof **r);
			**r = *p;
			r = &(*r)->link;
		}
	*r = q;
	return inherited;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0xf, (%rdi)
jb 0x19326
movq 0x10(%rbx), %rbx
movq 0x18(%rbx), %rax
movq 0x58(%rax), %r14
testq %r14, %r14
je 0x19472
xorl %eax, %eax
cmpq $0x0, (%r14)
jne 0x19352
movq 0x8(%r14), %rdi
movl 0x10(%r14), %ecx
movq %rbx, %rsi
movq %rax, %rdx
callq 0x18aa6
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0x19339
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x1947b
xorl %ecx, %ecx
movq %rax, %r14
movq 0x18(%rax), %rax
movq %rcx, 0x18(%r14)
movq %r14, %rcx
testq %rax, %rax
jne 0x1936b
movq 0x18(%rbx), %rax
movq 0x58(%rax), %r13
leaq 0x8(%rsp), %r15
testq %r13, %r13
je 0x19485
leaq 0x8(%rsp), %r12
leaq 0x113d8(%rip), %rbx     # 0x2a778
cmpq $0x0, (%r13)
je 0x19409
movl 0x10(%r13), %eax
cmpl 0x10(%r14), %eax
jle 0x193c2
movq %r14, (%r12)
movq %r14, %r12
movq 0x18(%r14), %r14
addq $0x18, %r12
jmp 0x1940d
movq (%rbx), %rcx
movl $0x20, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x20(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x193df
movq %rdx, 0x8(%rcx)
jmp 0x193ec
movl $0x20, %edi
movq %rbx, %rsi
callq 0x17800
movq %rax, (%r12)
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movq (%r12), %r12
addq $0x18, %r12
movq 0x18(%r13), %r13
testq %r13, %r13
je 0x1946b
testq %r14, %r14
jne 0x193a0
jmp 0x1946b
cmpq $0x0, (%r13)
je 0x19467
movq (%rbx), %rcx
movl $0x20, (%rcx)
movq 0x8(%rcx), %rax
leaq 0x20(%rax), %rdx
cmpq 0x10(%rcx), %rdx
jae 0x1943d
movq %rdx, 0x8(%rcx)
jmp 0x1944a
movl $0x20, %edi
movq %rbx, %rsi
callq 0x17800
movq %rax, (%r12)
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
movq (%r12), %r12
addq $0x18, %r12
movq 0x18(%r13), %r13
testq %r13, %r13
jne 0x19419
jmp 0x19488
movq $0x0, 0x8(%rsp)
movq 0x18(%rbx), %r15
addq $0x58, %r15
jmp 0x1948c
movq %r15, %r12
movq %r14, (%r12)
movq (%r15), %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: fieldref
Field fieldref(name, ty) char *name; Type ty; {
	Field p = isfield(name, unqual(ty)->u.sym->u.s.flist);
	if (p) {
		if (xref) {
			Symbol q;
			assert(unqual(ty)->u.sym->u.s.ftab);
			q = lookup(name, unqual(ty)->u.sym->u.s.ftab);
			assert(q);
			use(q, src);
		}
		return p;
	}
	for (p = unqual(ty)->u.sym->u.s.flist; p; p = p->link) {
		Field q;
		if (p->name == 0 && (q = fieldref(name, p->type))) {
			static struct field f;
			f = *q;
			f.offset = p->offset + q->offset;
			return &f;
		}
	}
	return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl (%rsi), %eax
movq %rsi, %rcx
cmpl $0xf, %eax
jb 0x194b3
movq 0x10(%rsi), %rcx
movq 0x18(%rcx), %rcx
movq 0x58(%rcx), %rbx
testq %rbx, %rbx
je 0x194cb
cmpq %r14, (%rbx)
je 0x19504
movq 0x18(%rbx), %rbx
jmp 0x194bb
cmpl $0xf, %eax
jb 0x194d4
movq 0x10(%rsi), %rsi
movq 0x18(%rsi), %rax
movq 0x58(%rax), %r15
xorl %ebx, %ebx
testq %r15, %r15
je 0x1957a
cmpq $0x0, (%r15)
jne 0x194fe
movq 0x8(%r15), %rsi
movq %r14, %rdi
callq 0x1949d
testq %rax, %rax
jne 0x1951f
movq 0x18(%r15), %r15
jmp 0x194de
leaq 0x13529(%rip), %rcx     # 0x2ca34
cmpl $0x0, (%rcx)
je 0x1957a
cmpl $0xf, %eax
jb 0x1954a
movq 0x10(%rsi), %rax
movq 0x18(%rax), %rax
jmp 0x1954e
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm1, 0x19afb(%rip)    # 0x33028
movups %xmm0, 0x19ae4(%rip)    # 0x33018
leaq 0x19add(%rip), %rbx     # 0x33018
movl 0x10(%rax), %eax
addl 0x10(%r15), %eax
movl %eax, 0x19ae0(%rip)     # 0x33028
jmp 0x1957a
movq 0x18(%rsi), %rax
movq 0x50(%rax), %rsi
testq %rsi, %rsi
je 0x195a2
movq %r14, %rdi
callq 0x1728e
testq %rax, %rax
je 0x19583
leaq 0x133cd(%rip), %rcx     # 0x2c938
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
movq %rax, %rdi
callq 0x1778e
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x5ccf(%rip), %rdi      # 0x1f259
leaq 0x7c97(%rip), %rsi      # 0x21228
leaq 0x817e(%rip), %rcx      # 0x21716
movl $0x13f, %edx            # imm = 0x13F
callq 0x30d0
leaq 0x8151(%rip), %rdi      # 0x216fa
leaq 0x7c78(%rip), %rsi      # 0x21228
leaq 0x815f(%rip), %rcx      # 0x21716
movl $0x13d, %edx            # imm = 0x13D
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: hasproto
int hasproto(ty) Type ty; {
	if (Aflag < 1 || ty == 0)
		return 1;
	switch (ty->op) {
	case CONST: case VOLATILE: case CONST+VOLATILE: case POINTER:
	case ARRAY:
		return hasproto(ty->type);
	case FUNCTION:
		return hasproto(ty->type) && ty->u.proto;
	case STRUCT: case UNION:
	case CHAR:   case SHORT: case INT:  case DOUBLE:
	case VOID:   case FLOAT: case ENUM: case UNSIGNED:
		return 1;
	default:
		assert(0);
	}
	return 0;
}

// Assembly:
pushq %rbx
movl $0x1, %eax
testq %rdi, %rdi
je 0x1963b
leaq 0x1344b(%rip), %rcx     # 0x2ca58
cmpl $0x0, (%rcx)
jle 0x1963b
movq %rdi, %rbx
movl $0x80019080, %ecx       # imm = 0x80019080
movl (%rbx), %edx
cmpl $0x1f, %edx
ja 0x1965f
btl %edx, %ecx
jae 0x19631
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x1961a
jmp 0x1963b
movl $0x277e, %ecx           # imm = 0x277E
btl %edx, %ecx
jae 0x1963d
popq %rbx
retq
cmpl $0xb, %edx
jne 0x1965f
movq 0x10(%rbx), %rdi
callq 0x195fb
testl %eax, %eax
je 0x1965b
xorl %eax, %eax
cmpq $0x0, 0x18(%rbx)
setne %al
jmp 0x1963b
xorl %eax, %eax
jmp 0x1963b
leaq 0x4b35(%rip), %rdi      # 0x1e19b
leaq 0x7bbb(%rip), %rsi      # 0x21228
leaq 0x80df(%rip), %rcx      # 0x21753
movl $0x173, %edx            # imm = 0x173
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: newfield
Field newfield(name, ty, fty) char *name; Type ty, fty; {
	Field p, *q = &ty->u.sym->u.s.flist;

	if (name == 0)
		name = stringd(genlabel(1));
	for (p = *q; p; q = &p->link, p = *q)
		if (p->name == name)
			error("duplicate field name `%s' in `%t'\n", name, ty);
	*q = p = (Field)alloc(sizeof *p);
	BZERO(p, struct field);
	p->name = name;
	p->type = fty;
	if (xref) {
		if (ty->u.sym->u.s.ftab == 0)
			ty->u.sym->u.s.ftab = table(0, level);
		install(name, &ty->u.sym->u.s.ftab, 1)->src = src;
	}
	return p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %r13
addq $0x58, %r13
testq %rdi, %rdi
jne 0x196b1
movl $0x1, %edi
callq 0x17522
movl %eax, %edi
callq 0x16d50
movq %rax, %r14
movq (%r13), %rax
testq %rax, %rax
je 0x196e6
leaq 0x80a1(%rip), %r12      # 0x21762
movq %rax, %r13
cmpq %r14, (%rax)
jne 0x196d9
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x974c
movq 0x18(%r13), %rax
testq %rax, %rax
jne 0x196c1
addq $0x18, %r13
leaq 0x11083(%rip), %rax     # 0x2a770
movq (%rax), %rax
movl $0x20, (%rax)
movq 0x8(%rax), %r12
leaq 0x20(%r12), %rcx
cmpq 0x10(%rax), %rcx
jae 0x1970b
movq %rcx, 0x8(%rax)
jmp 0x1971f
leaq 0x1105e(%rip), %rsi     # 0x2a770
movl $0x20, %edi
callq 0x17800
movq %rax, %r12
movq %r12, (%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r12)
movq %r14, (%r12)
movq %r15, 0x8(%r12)
leaq 0x132f8(%rip), %rax     # 0x2ca34
cmpl $0x0, (%rax)
je 0x19787
movq 0x18(%rbx), %rsi
cmpq $0x0, 0x50(%rsi)
jne 0x19768
leaq 0x165dd(%rip), %rax     # 0x2fd30
movl (%rax), %esi
xorl %edi, %edi
callq 0x17531
movq 0x18(%rbx), %rcx
movq %rax, 0x50(%rcx)
movq 0x18(%rbx), %rsi
addq $0x50, %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0x172de
leaq 0x131b8(%rip), %rcx     # 0x2c938
movups (%rcx), %xmm0
movups %xmm0, 0x28(%rax)
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: newstruct
Type newstruct(op, tag) int op; char *tag; {
	Symbol p;

	if (!tag || *tag == '\0')  /* anonymous structure/union/enum */
		tag = stringd(genlabel(1));
	if ((p = lookup(tag, types)) && (p->scope == level
	|| (p->scope == PARAM && level == PARAM+1))) {
		if (p->type->op == op && !p->defined)
			return p->type;
		error("redeclaration of `%s'\n", tag);
	}
	p = install(tag, &types, 1);
	p->type = tynode(op, 0, 0, 0, p);
	if (p->scope > maxlevel)
		maxlevel = p->scope;
	p->src = src;
	return p->type;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
testq %rsi, %rsi
je 0x197a7
movq %rsi, %r14
cmpb $0x0, (%rsi)
jne 0x197bb
movl $0x1, %edi
callq 0x17522
movl %eax, %edi
callq 0x16d50
movq %rax, %r14
leaq 0x10f4e(%rip), %rax     # 0x2a710
movq (%rax), %rsi
movq %r14, %rdi
callq 0x1728e
testq %rax, %rax
je 0x19813
movzwl 0x18(%rax), %edx
leaq 0x16553(%rip), %rcx     # 0x2fd30
movl (%rcx), %ecx
cmpl %edx, %ecx
je 0x197f4
cmpw $0x4, %dx
setne %dl
cmpl $0x5, %ecx
setne %cl
orb %dl, %cl
jne 0x19813
movq 0x20(%rax), %rcx
cmpl %ebx, (%rcx)
jne 0x19802
testb $0x1, 0x1b(%rax)
je 0x19863
leaq 0x7ebc(%rip), %rdi      # 0x216c5
movq %r14, %rsi
xorl %eax, %eax
callq 0x974c
leaq 0x10ef6(%rip), %rsi     # 0x2a710
movq %r14, %rdi
movl $0x1, %edx
callq 0x172de
movq %rax, %r14
movl %ebx, %edi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rax, %r8
callq 0x187eb
movq %rax, %rcx
movq %rax, 0x20(%r14)
movzwl 0x18(%r14), %eax
cmpl %eax, 0x197ec(%rip)     # 0x33038
jge 0x19854
movl %eax, 0x197e4(%rip)     # 0x33038
leaq 0x130dd(%rip), %rax     # 0x2c938
movups (%rax), %xmm0
movups %xmm0, 0x28(%r14)
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: printdecl
void printdecl(p, ty) Symbol p; Type ty; {
	switch (p->sclass) {
	case AUTO:
		fprint(2, "%s;\n", typestring(ty, p->name));
		break;
	case STATIC: case EXTERN:
		fprint(2, "%k %s;\n", p->sclass, typestring(ty, p->name));
	case TYPEDEF: case ENUM:
		break;
	default:
		assert(0);
	}
}

// Assembly:
pushq %rbx
movzbl 0x1a(%rdi), %ebx
cmpl $0x49, %ebx
jle 0x19b2b
cmpl $0x4a, %ebx
je 0x19b5b
cmpl $0x51, %ebx
je 0x19b5b
cmpl $0x53, %ebx
je 0x19b83
jmp 0x19b85
cmpl $0xd, %ebx
je 0x19b83
cmpl $0x43, %ebx
jne 0x19b85
movq 0x10(%rdi), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x19ba4
leaq 0x7cc5(%rip), %rsi      # 0x21810
movl $0x2, %edi
movq %rax, %rdx
xorl %eax, %eax
popq %rbx
jmp 0x115a8
movq 0x10(%rdi), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x19ba4
leaq 0x7c9c(%rip), %rsi      # 0x2180d
movl $0x2, %edi
movl %ebx, %edx
movq %rax, %rcx
xorl %eax, %eax
popq %rbx
jmp 0x115a8
popq %rbx
retq
leaq 0x460f(%rip), %rdi      # 0x1e19b
leaq 0x7695(%rip), %rsi      # 0x21228
leaq 0x7c7b(%rip), %rcx      # 0x21815
movl $0x1f3, %edx            # imm = 0x1F3
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: printproto
void printproto(p, callee) Symbol p, callee[]; {
	if (p->type->u.proto)
		printdecl(p, p->type);
	else {
		int i;
		List list = 0;
		if (callee[0] == 0)
			list = append(voidtype, list);
		else
			for (i = 0; callee[i]; i++)
				list = append(callee[i]->type, list);
		printdecl(p, funcl(freturn(p->type), list));
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq 0x20(%rdi), %rsi
cmpq $0x0, 0x18(%rsi)
je 0x19f53
movq %rbx, %rdi
jmp 0x19fd9
movq (%r15), %rax
testq %rax, %rax
je 0x19f7f
addq $0x8, %r15
xorl %r14d, %r14d
movq 0x20(%rax), %rdi
movq %r14, %rsi
callq 0x16a18
movq %rax, %r14
movq (%r15), %rax
addq $0x8, %r15
testq %rax, %rax
jne 0x19f62
jmp 0x19f90
movq 0x1905a(%rip), %rdi     # 0x32fe0
xorl %esi, %esi
callq 0x16a18
movq %rax, %r14
movq 0x20(%rbx), %rax
movl (%rax), %ecx
cmpl $0xf, %ecx
jb 0x19fa1
movq 0x10(%rax), %rcx
movl (%rcx), %ecx
cmpl $0xb, %ecx
jne 0x19fac
addq $0x10, %rax
jmp 0x19fc8
leaq 0x76e2(%rip), %rdi      # 0x21695
leaq 0x776d(%rip), %rsi      # 0x21727
xorl %eax, %eax
callq 0x974c
leaq 0x18fd0(%rip), %rax     # 0x32f98
movq (%rax), %rdi
movq %r14, %rsi
callq 0x18fa2
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x19b10
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: printtype
void printtype(Type ty, int fd) {
	switch (ty->op) {
	case STRUCT: case UNION: {
		Field p;
		fprint(fd, "%k %s size=%d {\n", ty->op, ty->u.sym->name, ty->size);
		for (p = ty->u.sym->u.s.flist; p; p = p->link) {
			fprint(fd, "field %s: offset=%d", p->name, p->offset);
			if (p->to)
				fprint(fd, " bits=%d..%d", p->from, p->to);
			fprint(fd, " type=%t", p->type);
		}
		fprint(fd, "}\n");
		break;
		}
	case ENUM: {
		int i;
		Symbol p;
		fprint(fd, "enum %s {", ty->u.sym->name);
		for (i = 0; (p = ty->u.sym->u.idlist[i]); i++) {
			if (i > 0)
				fprint(fd, ",");
			fprint(fd, "%s=%d", p->name, p->u.value);
		}
		fprint(fd, "}\n");
		break;
		}
	default:
		fprint(fd, "%t\n", ty);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl (%rdi), %edx
leal -0x9(%rdx), %eax
cmpl $0x2, %eax
jae 0x1a08c
movq 0x18(%r14), %rax
movq 0x10(%rax), %rcx
movl 0x8(%r14), %r8d
leaq 0x7812(%rip), %rsi      # 0x21826
movl %ebx, %edi
xorl %eax, %eax
callq 0x115a8
movq 0x18(%r14), %rax
movq 0x58(%rax), %r13
testq %r13, %r13
je 0x1a107
leaq 0x7802(%rip), %r14      # 0x21837
leaq 0x781c(%rip), %r15      # 0x21858
leaq 0x7808(%rip), %r12      # 0x2184b
movq (%r13), %rdx
movl 0x10(%r13), %ecx
movl %ebx, %edi
movq %r14, %rsi
xorl %eax, %eax
callq 0x115a8
movswl 0x16(%r13), %ecx
testl %ecx, %ecx
je 0x1a071
movswl 0x14(%r13), %edx
movl %ebx, %edi
movq %r12, %rsi
xorl %eax, %eax
callq 0x115a8
movq 0x8(%r13), %rdx
movl %ebx, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x115a8
movq 0x18(%r13), %r13
testq %r13, %r13
jne 0x1a043
jmp 0x1a107
cmpl $0xd, %edx
jne 0x1a125
movq 0x18(%r14), %rax
movq 0x10(%rax), %rdx
leaq 0x77bd(%rip), %rsi      # 0x21861
movl %ebx, %edi
xorl %eax, %eax
callq 0x115a8
movq 0x18(%r14), %rax
movq 0x48(%rax), %rax
movq (%rax), %rbp
testq %rbp, %rbp
je 0x1a107
leaq 0x77a7(%rip), %r15      # 0x2186b
leaq 0x5ee7(%rip), %r12      # 0x1ffb2
xorl %r13d, %r13d
testq %r13, %r13
je 0x1a0df
movl %ebx, %edi
movq %r12, %rsi
xorl %eax, %eax
callq 0x115a8
movq 0x10(%rbp), %rdx
movl 0x48(%rbp), %ecx
movl %ebx, %edi
movq %r15, %rsi
xorl %eax, %eax
callq 0x115a8
movq 0x18(%r14), %rax
movq 0x48(%rax), %rax
movq 0x8(%rax,%r13,8), %rbp
incq %r13
testq %rbp, %rbp
jne 0x1a0ce
leaq 0x5e81(%rip), %rsi      # 0x1ff8f
movl %ebx, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x115a8
leaq 0x7745(%rip), %rsi      # 0x21871
movl %ebx, %edi
movq %r14, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x115a8
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: rmtypes
void rmtypes() {
	if (maxlevel >= level) {
		int i;
		maxlevel = 0;
		for (i = 0; i < sizeof typetable/sizeof typetable[0]; i++) {
			struct type *tn, **tq = &typetable[i];
			for (tn = *tq; tn; tn = *tq)
				if (tn->type.op == FUNCTION)
					tq = &tn->link;
				else if (tn->type.u.sym && tn->type.u.sym->scope == level)
					*tq = tn->link;
				else {
					if (tn->type.u.sym && tn->type.u.sym->scope > maxlevel)
						maxlevel = tn->type.u.sym->scope;
					tq = &tn->link;
				}
		}
	}
}

// Assembly:
leaq 0x15be3(%rip), %rax     # 0x2fd30
movl (%rax), %eax
cmpl %eax, 0x18ee3(%rip)     # 0x33038
jl 0x1a1c8
movl $0x0, 0x18ed7(%rip)     # 0x33038
xorl %ecx, %ecx
leaq 0x18ed6(%rip), %rdx     # 0x33040
xorl %esi, %esi
movq (%rdx,%rcx,8), %rdi
testq %rdi, %rdi
je 0x1a1bc
leaq (%rdx,%rcx,8), %r8
cmpl $0xb, (%rdi)
je 0x1a1a9
movq 0x18(%rdi), %r9
testq %r9, %r9
je 0x1a1a9
movzwl 0x18(%r9), %r9d
cmpl %r9d, %eax
jne 0x1a19a
movq 0x28(%rdi), %r9
movq %r9, (%r8)
jmp 0x1a1b4
cmpl %r9d, %esi
jge 0x1a1a9
movl %r9d, 0x18e92(%rip)     # 0x33038
movl %r9d, %esi
movq 0x28(%rdi), %r9
addq $0x28, %rdi
movq %rdi, %r8
movq %r9, %rdi
testq %r9, %r9
jne 0x1a179
incq %rcx
cmpq $0x80, %rcx
jne 0x1a16c
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: ttob
int ttob(ty) Type ty; {
	switch (ty->op) {
	case CONST: case VOLATILE: case CONST+VOLATILE:
		return ttob(ty->type);
	case VOID: case CHAR: case INT: case SHORT:
	case UNSIGNED: case FLOAT: case DOUBLE:
		return ty->op;
	case POINTER: case FUNCTION:
		return POINTER;
	case ARRAY: case STRUCT: case UNION:
		return STRUCT;
	case ENUM:
		return INT;
	default:
		assert(0);
	}
	return I;
}

// Assembly:
pushq %rax
leaq 0x6f9f(%rip), %rcx      # 0x21170
movl (%rdi), %eax
leal -0x1(%rax), %edx
cmpl $0x1e, %edx
ja 0x1a1ff
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movq 0x10(%rdi), %rdi
jmp 0x1a1d1
movl $0x9, %eax
jmp 0x1a1fd
movl $0x7, %eax
jmp 0x1a1fd
movl $0x5, %eax
popq %rcx
retq
leaq 0x3f95(%rip), %rdi      # 0x1e19b
leaq 0x701b(%rip), %rsi      # 0x21228
leaq 0x7698(%rip), %rcx      # 0x218ac
movl $0x26c, %edx            # imm = 0x26C
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/types.c
// Function: variadic
int variadic(ty) Type ty; {
	if (isfunc(ty) && ty->u.proto) {
		int i;
		for (i = 0; ty->u.proto[i]; i++)
			;
		return i > 1 && ty->u.proto[i-1] == voidtype;
	}
	return 0;
}

// Assembly:
movl (%rdi), %ecx
cmpl $0xf, %ecx
jb 0x1a22b
movq 0x10(%rdi), %rax
movl (%rax), %ecx
xorl %eax, %eax
cmpl $0xb, %ecx
jne 0x1a265
movq 0x18(%rdi), %rcx
testq %rcx, %rcx
je 0x1a265
movq $-0x1, %rdx
cmpq $0x0, 0x8(%rcx,%rdx,8)
leaq 0x1(%rdx), %rdx
jne 0x1a242
cmpq $0x2, %rdx
jb 0x1a265
movq -0x8(%rcx,%rdx,8), %rcx
xorl %eax, %eax
cmpq 0x18d7e(%rip), %rcx     # 0x32fe0
sete %al
retq
nop
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: defsymbol
void defsymbol(Symbol p) {
    if (p->x.name) return;
    if (p->scope == CONSTANTS) {
        p->x.name = p->name;
        if (p->x.name[0]=='0' && p->x.name[1]=='x') {
            p->x.name[0]=' '; p->x.name[1]='$';
        }
    } else if (p->sclass == STATIC)
        p->x.name = stringf("L%s%d", NamePrefix, genlabel(1));
    else if (p->generated)
        p->x.name = stringf("L%s%s", NamePrefix, p->name);
    else
        p->x.name = stringf("_%s", p->name);
    p->x.adrmode = 'C';

}

// Assembly:
cmpq $0x0, (%rdi)
je 0x1a45f
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpw $0x1, 0x18(%rdi)
jne 0x1a48b
movq 0x10(%rbx), %rax
movq %rax, (%rbx)
cmpb $0x30, (%rax)
jne 0x1a4ed
cmpb $0x78, 0x1(%rax)
jne 0x1a4ed
movb $0x20, (%rax)
movq (%rbx), %rax
movb $0x24, 0x1(%rax)
jmp 0x1a4ed
cmpb $0x51, 0x1a(%rbx)
jne 0x1a4b7
movq 0x18fa8(%rip), %r14     # 0x33440
movl $0x1, %edi
callq 0x17522
leaq 0x7ad6(%rip), %rdi      # 0x21f7f
movq %r14, %rsi
movl %eax, %edx
xorl %eax, %eax
callq 0x11b33
jmp 0x1a4ea
testb $0x4, 0x1b(%rbx)
jne 0x1a4d1
movq 0x10(%rbx), %rsi
leaq 0x7ac3(%rip), %rdi      # 0x21f8b
xorl %eax, %eax
callq 0x11b33
jmp 0x1a4ea
movq 0x18f68(%rip), %rsi     # 0x33440
movq 0x10(%rbx), %rdx
leaq 0x7aa2(%rip), %rdi      # 0x21f85
xorl %eax, %eax
callq 0x11b33
movq %rax, (%rbx)
movb $0x43, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: printfloat
void printfloat(double val)
{
    int i,exp=32,negative=0;
    double two_pow31,two_pow32;
    unsigned long mantissa;

    if (val==0.0) {
        print("\tDB(0)\n");
        print("\tDB(0)\n");
        print("\tDB(0)\n");
        print("\tDB(0)\n");
        print("\tDB(0)\n");
        return;
    }
    if (val<0.0) { negative=1; val= -val; }
    for (two_pow31=1.0,i=0;i<31;i++) two_pow31*=2;
    two_pow32=two_pow31*2;
    while (val>=two_pow32) {
        val/=2;
        exp++;
    }
    while (val<two_pow31) {
        val*=2;
        exp--;
    }
    if (!negative) val-=two_pow31;
    mantissa=val;
    print("\tDB($%x)\n",exp+128);
    print("\tDB($%x)\n",(mantissa>>24)&0xFF);
    print("\tDB($%x)\n",(mantissa>>16)&0xFF);
    print("\tDB($%x)\n",(mantissa>>8)&0xFF);
    print("\tDB($%x)\n",mantissa&0xFF);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x1a564
jp 0x1a564
leaq 0x7a61(%rip), %rbx      # 0x21f8f
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11732
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11732
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11732
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11732
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x11732
movapd 0x5cc4(%rip), %xmm3     # 0x20230
xorpd %xmm0, %xmm3
movsd 0x5d00(%rip), %xmm1     # 0x20278
movl $0x1f, %eax
addsd %xmm1, %xmm1
decl %eax
jne 0x1a57d
xorpd %xmm4, %xmm4
movapd %xmm0, %xmm2
cmpnltsd %xmm4, %xmm2
movapd %xmm2, %xmm4
andpd %xmm0, %xmm4
andnpd %xmm3, %xmm2
orpd %xmm4, %xmm2
movapd %xmm1, %xmm3
addsd %xmm1, %xmm3
movl $0x20, %esi
ucomisd %xmm3, %xmm2
jb 0x1a5d1
movsd 0x7393(%rip), %xmm4     # 0x21950
mulsd %xmm4, %xmm2
incl %esi
ucomisd %xmm3, %xmm2
jae 0x1a5bd
jmp 0x1a5d1
addsd %xmm2, %xmm2
decl %esi
ucomisd %xmm2, %xmm1
ja 0x1a5cb
movapd %xmm2, %xmm3
subsd %xmm1, %xmm3
xorpd %xmm1, %xmm1
cmpnltsd %xmm1, %xmm0
andpd %xmm0, %xmm3
andnpd %xmm2, %xmm0
orpd %xmm3, %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
subsd 0x7354(%rip), %xmm0     # 0x21958
cvttsd2si %xmm0, %r14
sarq $0x3f, %rcx
andq %rcx, %r14
orq %rax, %r14
subl $-0x80, %esi
leaq 0x797a(%rip), %rbx      # 0x21f97
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11732
movl %r14d, %esi
shrl $0x18, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11732
movl %r14d, %esi
shrl $0x10, %esi
movl $0xff, %ebp
andl %ebp, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11732
movl %r14d, %esi
shrl $0x8, %esi
andl %ebp, %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x11732
movzbl %r14b, %esi
movq %rbx, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x11732
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: defconst
void defconst(int ty, Value v) {
    if (graph_output) return;
    switch (ty) {
    case C: print("\tDB(%d)\n",   v.uc); break;
    case S: print("\tDB(%d)\n",   v.us); break;
    case I: print("\tDW(%d)\n",   v.i ); break;
    case U: print("\tDW($%x)\n",  v.u ); break;
    case P: print("\tDW($%x)\n",  v.p ); break;
    case F: printfloat(v.f); break;
    case D: printfloat(v.d); break;
    default: assert(0);
    }
}

// Assembly:
cmpb $0x0, 0x18dcf(%rip)     # 0x33448
je 0x1a67c
retq
decl %edi
cmpl $0x6, %edi
ja 0x1a6d4
movq %rsi, %xmm0
leaq 0x72d1(%rip), %rax      # 0x21960
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
jmp 0x1a517
leaq 0x7906(%rip), %rdi      # 0x21faa
jmp 0x1a6bf
movzbl %sil, %esi
jmp 0x1a6af
movzwl %si, %esi
leaq 0x78eb(%rip), %rdi      # 0x21fa1
jmp 0x1a6bf
leaq 0x78f4(%rip), %rdi      # 0x21fb3
xorl %eax, %eax
jmp 0x11732
leaq 0x78e6(%rip), %rdi      # 0x21fb3
xorl %eax, %eax
jmp 0x11732
pushq %rax
leaq 0x3abf(%rip), %rdi      # 0x1e19b
leaq 0x78da(%rip), %rsi      # 0x21fbd
leaq 0x78e0(%rip), %rcx      # 0x21fca
movl $0x122, %edx            # imm = 0x122
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: defstring
void defstring(int len, char *s) {
    if (graph_output) return;
    while (len > 0) {
        print("\tDB($%x)\n",(unsigned char)*s++);
        len--;
    }
}

// Assembly:
testl %edi, %edi
jle 0x1a72e
testb $0x1, 0x18d49(%rip)     # 0x33448
jne 0x1a72e
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
incl %ebp
leaq 0x7884(%rip), %r14      # 0x21f97
movzbl (%rbx), %esi
incq %rbx
movq %r14, %rdi
xorl %eax, %eax
callq 0x11732
decl %ebp
cmpl $0x1, %ebp
ja 0x1a713
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: allocreg
int allocreg(Symbol p) {
    if (nbregs==8 || p->type->size==5) return 0;
    p->x.name=regname[nbregs];
    p->x.adrmode='R';
    nbregs++;
    return 1;
}

// Assembly:
movslq 0x18f25(%rip), %rcx     # 0x33690
xorl %eax, %eax
cmpq $0x8, %rcx
je 0x1a79d
movq 0x20(%rdi), %rdx
cmpl $0x5, 0x8(%rdx)
je 0x1a79d
leaq 0x18ccc(%rip), %rax     # 0x33450
movq (%rax,%rcx,8), %rax
movq %rax, (%rdi)
movb $0x52, 0x8(%rdi)
leal 0x1(%rcx), %eax
movl %eax, 0x18ef8(%rip)     # 0x33690
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: local
void local(Symbol p) {
    if (optimizelevel>1 && p->sclass==REGISTER && allocreg(p))
        return; /* allocreg ok */
    if (p->x.name && p->x.name[0]!='*') return; /* keep previous local (it isn't busy) */
    p->x.name = stringf(graph_output?"local(%d)":"(fp),%d",offset);
    p->x.adrmode = 'A';
    p->sclass = AUTO;
    offset+=p->type->size;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpl $0x2, 0xfd84(%rip)      # 0x2a7c8
jl 0x1aa63
cmpb $0x4e, 0x1a(%rbx)
jne 0x1aa63
movslq 0x18c3d(%rip), %rax     # 0x33690
cmpq $0x8, %rax
je 0x1aa63
movq 0x20(%rbx), %rcx
cmpl $0x5, 0x8(%rcx)
jne 0x1aab0
movq (%rbx), %rax
testq %rax, %rax
je 0x1aa70
cmpb $0x2a, (%rax)
jne 0x1aaae
leaq 0x75dc(%rip), %rax      # 0x22053
cmpb $0x0, 0x189ca(%rip)     # 0x33448
leaq 0x75d8(%rip), %rdi      # 0x2205d
cmovneq %rax, %rdi
movl 0x18c05(%rip), %esi     # 0x33694
xorl %eax, %eax
callq 0x11b33
movq %rax, (%rbx)
movb $0x41, 0x8(%rbx)
movb $0x43, 0x1a(%rbx)
movq 0x20(%rbx), %rax
movl 0x8(%rax), %eax
addl %eax, 0x18be6(%rip)     # 0x33694
popq %rbx
retq
leaq 0x18999(%rip), %rcx     # 0x33450
movq (%rcx,%rax,8), %rcx
movq %rcx, (%rbx)
movb $0x52, 0x8(%rbx)
incl %eax
movl %eax, 0x18bc6(%rip)     # 0x33690
jmp 0x1aaae
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: linearize
static Node *linearize(Node p, Node *last, Node next) {
    if (p && !p->x.visited) {
        if ( optimizelevel>0 ) {
            switch (generic(p->op)) {
            case CNST:
            case ADDRG: case ADDRL: case ADDRF:
                p->x.optimized=1;
                p->x.result=p->syms[0];
                p->x.adrmode=p->syms[0]->x.adrmode;
                p->x.name=p->syms[0]->x.name;
                return last;
            }
        }
        last = linearize(p->kids[0], last, NULL);
        last = linearize(p->kids[1], last, NULL);
        p->x.visited = 1;
        *last = p;
        last = &p->x.next;
    }
    *last = next;
    return last;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x1b0d7
movq %rdi, %rbx
cmpb $0x0, 0x61(%rdi)
jne 0x1b0d7
cmpl $0x0, 0xf756(%rip)      # 0x2a7c8
jle 0x1b0b4
movl (%rbx), %eax
andl $-0x10, %eax
leal -0x100(%rax), %ecx
cmpl $0x20, %ecx
ja 0x1b094
movabsq $0x100010001, %rdx      # imm = 0x100010001
btq %rcx, %rdx
jb 0x1b099
cmpl $0x10, %eax
jne 0x1b0b4
movb $0x1, 0x60(%rbx)
movq 0x8(%rbx), %rax
movq %rax, 0x48(%rbx)
movb 0x8(%rax), %cl
movb %cl, 0x40(%rbx)
movq (%rax), %rax
movq %rax, 0x38(%rbx)
jmp 0x1b0de
movq 0x20(%rbx), %rdi
callq 0x1b05c
movq 0x28(%rbx), %rdi
movq %rax, %rsi
callq 0x1b05c
movb $0x1, 0x61(%rbx)
movq %rbx, (%rax)
addq $0x58, %rbx
movq %rbx, %rsi
movq $0x0, (%rsi)
movq %rsi, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: asmcode
void asmcode(char *str, Symbol argv[]) {
    for ( ; *str; str++)
        if (*str == '%' && str[1] >= 0 && str[1] <= 9)
            print("%s", argv[(int)*++str]->x.name);
        else
            print("%c", *str);
    print("\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x681e(%rip), %r15      # 0x21916
leaq 0x5dec(%rip), %r12      # 0x20eeb
movzbl (%r14), %eax
cmpl $0x25, %eax
je 0x1b10e
testl %eax, %eax
jne 0x1b12f
jmp 0x1b141
movzbl 0x1(%r14), %ecx
cmpq $0x9, %rcx
ja 0x1b12f
incq %r14
movq (%rbx,%rcx,8), %rax
movq (%rax), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x11732
jmp 0x1b13c
movsbl %al, %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x11732
incq %r14
jmp 0x1b0ff
leaq 0x4a4c(%rip), %rdi      # 0x1fb94
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x11732
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: releasetmp
static void releasetmp(Node p) {
    if (!p) return;
    assert(p->count!=0);
    p->count--;
    switch(generic(p->op)) {
        case ADDRG: case ADDRL: case ADDRF: case CNST:
            if (optimizelevel>0) return;
            break;
        case INDIR:
            if (p->x.optimized) return;
    }
    if (p->count==0) {
        int i;
        for (i=0;i<32;i++) {
            if (p->x.result == temp[i])   busy &= ~(1<<i);
            if (p->x.result==flt_temp[i]) busy_flt &= ~(1<<i);
        }
    }
}

// Assembly:
testq %rdi, %rdi
je 0x1d2f9
movzwl 0x4(%rdi), %eax
testw %ax, %ax
je 0x1d30e
decl %eax
movw %ax, 0x4(%rdi)
movl (%rdi), %ecx
andl $-0x10, %ecx
leal -0x100(%rcx), %edx
cmpl $0x20, %edx
ja 0x1d291
movabsq $0x100010001, %rsi      # imm = 0x100010001
btq %rdx, %rsi
jb 0x1d29b
cmpl $0x40, %ecx
je 0x1d2fa
cmpl $0x10, %ecx
jne 0x1d307
testw %ax, %ax
jne 0x1d2f9
cmpl $0x0, 0xd521(%rip)      # 0x2a7c8
jg 0x1d2f9
movq 0x48(%rdi), %rax
movl 0x163e9(%rip), %ecx     # 0x3369c
movl 0x163eb(%rip), %edx     # 0x336a4
xorl %esi, %esi
leaq 0x161ce(%rip), %rdi     # 0x33490
leaq 0x162c7(%rip), %r8      # 0x33590
xorl %r9d, %r9d
cmpq (%rsi,%rdi), %rax
jne 0x1d2dc
btrl %r9d, %ecx
movl %ecx, 0x163c0(%rip)     # 0x3369c
cmpq (%rsi,%r8), %rax
jne 0x1d2ec
btrl %r9d, %edx
movl %edx, 0x163b8(%rip)     # 0x336a4
incq %r9
addq $0x8, %rsi
cmpq $0x20, %r9
jne 0x1d2cc
retq
testw %ax, %ax
jne 0x1d2f9
cmpb $0x0, 0x60(%rdi)
je 0x1d2a9
jmp 0x1d2f9
testw %ax, %ax
jne 0x1d2f9
jmp 0x1d2a9
pushq %rax
leaq 0x4eb3(%rip), %rdi      # 0x221c9
leaq 0x4ca0(%rip), %rsi      # 0x21fbd
leaq 0x4eb1(%rip), %rcx      # 0x221d5
movl $0x199, %edx            # imm = 0x199
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: dereference
static char dereference(char adrmode)
{
    switch (adrmode) {
        case 'C': return 'D';
        case 'R': return 'Z';
        case 'A': return 'Y';
        case 'Z': return 'I';
        default:
            assert(is_dereferenceable(adrmode));
            return 0;
    }

}

// Assembly:
cmpl $0x51, %edi
jg 0x1d340
cmpl $0x41, %edi
je 0x1d34d
movb $0x44, %al
cmpl $0x43, %edi
jne 0x1d353
retq
cmpl $0x5a, %edi
je 0x1d350
cmpl $0x52, %edi
jne 0x1d353
movb $0x5a, %al
retq
movb $0x59, %al
retq
movb $0x49, %al
retq
pushq %rax
leaq 0x4e90(%rip), %rdi      # 0x221eb
leaq 0x4c5b(%rip), %rsi      # 0x21fbd
leaq 0x4e9e(%rip), %rcx      # 0x22207
movl $0x1bd, %edx            # imm = 0x1BD
callq 0x30d0
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: binary
static void binary(char *inst) {
    if (optimizelevel==0)
        print("\t%s(%s,%s,%s)\n"
            ,inst
            ,output_arg(a)
            ,output_arg(b)
            ,output_arg(r));
    else
        print("\t%s_%c%c%c(%s,%s,%s)\n"
            ,inst
            ,simple_adrmode(a->x.adrmode)
            ,simple_adrmode(b->x.adrmode)
            ,simple_adrmode(r->x.adrmode)
            ,output_arg(a)
            ,output_arg(b)
            ,output_arg(r));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xd440(%rip)      # 0x2a7c8
movq 0x16321(%rip), %rax     # 0x336b0
je 0x1d3ab
movzbl 0x40(%rax), %ecx
cmpl $0x49, %ecx
je 0x1d3eb
cmpl $0x5a, %ecx
je 0x1d3e4
cmpl $0x52, %ecx
jne 0x1d3f2
movl $0x43, %ebp
jmp 0x1d3f5
movq 0x38(%rax), %rdx
movq 0x16302(%rip), %rax     # 0x336b8
movq 0x38(%rax), %rcx
movq 0x162ff(%rip), %rax     # 0x336c0
movq 0x38(%rax), %r8
leaq 0x51d8(%rip), %rdi      # 0x225a4
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11732
movl $0x44, %ebp
jmp 0x1d3f5
movl $0x59, %ebp
jmp 0x1d3f5
movsbl %cl, %ebp
movq 0x162bc(%rip), %rdx     # 0x336b8
movzbl 0x40(%rdx), %esi
cmpl $0x49, %esi
je 0x1d41f
cmpl $0x5a, %esi
je 0x1d417
cmpl $0x52, %esi
jne 0x1d427
movl $0x43, %r14d
jmp 0x1d42b
movl $0x44, %r14d
jmp 0x1d42b
movl $0x59, %r14d
jmp 0x1d42b
movsbl %sil, %r14d
movq 0x1628e(%rip), %rsi     # 0x336c0
movzbl 0x40(%rsi), %esi
cmpl $0x49, %esi
je 0x1d455
cmpl $0x5a, %esi
je 0x1d44d
cmpl $0x52, %esi
jne 0x1d45d
movl $0x43, %r15d
jmp 0x1d461
movl $0x44, %r15d
jmp 0x1d461
movl $0x59, %r15d
jmp 0x1d461
movsbl %sil, %r15d
movq 0x38(%rax), %r12
cmpb $0x49, %cl
jne 0x1d48e
leaq 0x5175(%rip), %rdi      # 0x225e6
movq %r12, %rsi
xorl %eax, %eax
callq 0x11b33
movq %rax, %r12
movq 0x16233(%rip), %rdx     # 0x336b8
cmpl $0x0, 0xd33c(%rip)      # 0x2a7c8
je 0x1d4e5
cmpb $0x49, 0x40(%rdx)
movq 0x38(%rdx), %r13
jne 0x1d4be
leaq 0x5147(%rip), %rdi      # 0x225e6
movq %r13, %rsi
xorl %eax, %eax
callq 0x11b33
movq %rax, %r13
movq 0x1620d(%rip), %rax     # 0x336c0
cmpl $0x0, 0xd30e(%rip)      # 0x2a7c8
jne 0x1d4c5
jmp 0x1d4f0
movq 0x161fb(%rip), %rax     # 0x336c0
cmpb $0x49, 0x40(%rax)
movq 0x38(%rax), %r10
jne 0x1d4f7
leaq 0x5110(%rip), %rdi      # 0x225e6
movq %r10, %rsi
xorl %eax, %eax
callq 0x11b33
movq %rax, %r10
jmp 0x1d4f7
movq 0x38(%rdx), %r13
movq 0x161d0(%rip), %rax     # 0x336c0
addq $0x38, %rax
movq (%rax), %r10
leaq 0x50b5(%rip), %rdi      # 0x225b3
movq %rbx, %rsi
movl %ebp, %edx
movl %r14d, %ecx
movl %r15d, %r8d
movq %r12, %r9
xorl %eax, %eax
pushq %r10
pushq %r13
callq 0x11732
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/gen.c
// Function: unary
static void unary(char *inst) {
    if (optimizelevel==0)
        print("\t%s(%s,%s)\n"
            ,inst
            ,output_arg(a)
            ,output_arg(r));
    else
        print("\t%s_%c%c(%s,%s)\n"
            ,inst
            ,simple_adrmode(a->x.adrmode)
            ,simple_adrmode(r->x.adrmode)
            ,output_arg(a)
            ,output_arg(r));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xd291(%rip)      # 0x2a7c8
movq 0x16172(%rip), %rax     # 0x336b0
je 0x1d55a
movzbl 0x40(%rax), %ecx
cmpl $0x49, %ecx
je 0x1d58b
cmpl $0x5a, %ecx
je 0x1d584
cmpl $0x52, %ecx
jne 0x1d592
movl $0x43, %ebp
jmp 0x1d595
movq 0x38(%rax), %rdx
movq 0x1615b(%rip), %rax     # 0x336c0
movq 0x38(%rax), %rcx
leaq 0x5059(%rip), %rdi      # 0x225c9
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x11732
movl $0x44, %ebp
jmp 0x1d595
movl $0x59, %ebp
jmp 0x1d595
movsbl %cl, %ebp
movq 0x16124(%rip), %rdx     # 0x336c0
movzbl 0x40(%rdx), %esi
cmpl $0x49, %esi
je 0x1d5bf
cmpl $0x5a, %esi
je 0x1d5b7
cmpl $0x52, %esi
jne 0x1d5c7
movl $0x43, %r14d
jmp 0x1d5cb
movl $0x44, %r14d
jmp 0x1d5cb
movl $0x59, %r14d
jmp 0x1d5cb
movsbl %sil, %r14d
movq 0x38(%rax), %r15
cmpb $0x49, %cl
jne 0x1d5f8
leaq 0x500b(%rip), %rdi      # 0x225e6
movq %r15, %rsi
xorl %eax, %eax
callq 0x11b33
movq %rax, %r15
movq 0x160d1(%rip), %rdx     # 0x336c0
cmpl $0x0, 0xd1d2(%rip)      # 0x2a7c8
je 0x1d618
cmpb $0x49, 0x40(%rdx)
movq 0x38(%rdx), %r9
jne 0x1d61c
leaq 0x4fdd(%rip), %rdi      # 0x225e6
movq %r9, %rsi
xorl %eax, %eax
callq 0x11b33
movq %rax, %r9
jmp 0x1d61c
movq 0x38(%rdx), %r9
leaq 0x4fb2(%rip), %rdi      # 0x225d5
movq %rbx, %rsi
movl %ebp, %edx
movl %r14d, %ecx
movq %r15, %r8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x11732
// File: /workspace/github_c_makefile_star2_O3/Oric4ever[P]lcc65/6502/build/../src/gen.c
// Function: save_busy
static void save_busy(Node p) {
    int i, offset=p->x.argoffset;
    for (i=0; i<8; i++) {
        if (p->x.busy & (1<<i)) {
            // save on stack and increase the argsize
            print("\tSAVE(tmp%d,(sp),%d)\n", i, offset);
            offset += 2;
        }
    }
    // update the CALL's argoffset so that it is passed to the callee
    p->x.argoffset = offset;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x50(%rdi), %ebp
leaq 0x4f71(%rip), %r14      # 0x225ed
xorl %r15d, %r15d
movl 0x54(%rbx), %eax
btl %r15d, %eax
jae 0x1d69a
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
xorl %eax, %eax
callq 0x11732
addl $0x2, %ebp
incl %r15d
cmpl $0x8, %r15d
jne 0x1d67f
movl %ebp, 0x50(%rbx)
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/gen.c
// Function: compare
static void compare(char *inst) {
     if (optimizelevel==0)
        print("\t%s(%s,%s,%s)\n"
            ,inst
            ,output_arg(a)
            ,output_arg(b)
            ,r->syms[0]->x.name);
    else
        print("\t%s_%c%c(%s,%s,%s)\n"
            ,inst
            ,simple_adrmode(a->x.adrmode)
            ,simple_adrmode(b->x.adrmode)
            ,output_arg(a)
            ,output_arg(b)
            ,r->syms[0]->x.name);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0xd0c0(%rip)      # 0x2a7c8
movq 0x15fa1(%rip), %rax     # 0x336b0
je 0x1d72b
movzbl 0x40(%rax), %ecx
cmpl $0x49, %ecx
je 0x1d76a
cmpl $0x5a, %ecx
je 0x1d763
cmpl $0x52, %ecx
jne 0x1d771
movl $0x43, %ebp
jmp 0x1d774
movq 0x38(%rax), %rdx
movq 0x15f82(%rip), %rax     # 0x336b8
movq 0x38(%rax), %rcx
movq 0x15f7f(%rip), %rax     # 0x336c0
movq 0x8(%rax), %rax
movq (%rax), %r8
leaq 0x4e55(%rip), %rdi      # 0x225a4
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x11732
movl $0x44, %ebp
jmp 0x1d774
movl $0x59, %ebp
jmp 0x1d774
movsbl %cl, %ebp
movq 0x15f3d(%rip), %rdx     # 0x336b8
movzbl 0x40(%rdx), %esi
cmpl $0x49, %esi
je 0x1d79e
cmpl $0x5a, %esi
je 0x1d796
cmpl $0x52, %esi
jne 0x1d7a6
movl $0x43, %r14d
jmp 0x1d7aa
movl $0x44, %r14d
jmp 0x1d7aa
movl $0x59, %r14d
jmp 0x1d7aa
movsbl %sil, %r14d
movq 0x38(%rax), %r15
cmpb $0x49, %cl
jne 0x1d7d7
leaq 0x4e2c(%rip), %rdi      # 0x225e6
movq %r15, %rsi
xorl %eax, %eax
callq 0x11b33
movq %rax, %r15
movq 0x15eea(%rip), %rdx     # 0x336b8
cmpl $0x0, 0xcff3(%rip)      # 0x2a7c8
je 0x1d7f7
cmpb $0x49, 0x40(%rdx)
movq 0x38(%rdx), %r9
jne 0x1d7fb
leaq 0x4dfe(%rip), %rdi      # 0x225e6
movq %r9, %rsi
xorl %eax, %eax
callq 0x11b33
movq %rax, %r9
jmp 0x1d7fb
movq 0x38(%rdx), %r9
movq 0x15ebe(%rip), %rax     # 0x336c0
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, (%rsp)
leaq 0x4e08(%rip), %rdi      # 0x2261c
movq %rbx, %rsi
movl %ebp, %edx
movl %r14d, %ecx
movq %r15, %r8
xorl %eax, %eax
callq 0x11732
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/gen.c
// Function: compare0
static void compare0(char *inst) {
    print("\t%s_%c(%s,%s)\n"
            ,inst
            ,simple_adrmode(a->x.adrmode)
            ,output_arg(a)
            ,r->syms[0]->x.name);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x15e74(%rip), %rax     # 0x336b0
movzbl 0x40(%rax), %ecx
cmpl $0x49, %ecx
je 0x1d85d
cmpl $0x5a, %ecx
je 0x1d856
cmpl $0x52, %ecx
jne 0x1d885
movl $0x43, %edx
jmp 0x1d888
movl $0x44, %edx
jmp 0x1d888
addq $0x38, %rax
cmpl $0x0, 0xcf60(%rip)      # 0x2a7c8
je 0x1d8b6
movq (%rax), %rsi
leaq 0x4d72(%rip), %rdi      # 0x225e6
xorl %eax, %eax
callq 0x11b33
movq %rax, %rcx
movl $0x59, %edx
jmp 0x1d896
movsbl %cl, %edx
addq $0x38, %rax
cmpl $0x0, 0xcf35(%rip)      # 0x2a7c8
movq (%rax), %rcx
movq 0x15e23(%rip), %rax     # 0x336c0
movq 0x8(%rax), %rax
movq (%rax), %r8
leaq 0x4f69(%rip), %rdi      # 0x22814
movq %rbx, %rsi
xorl %eax, %eax
popq %rbx
jmp 0x11732
movl $0x59, %edx
jmp 0x1d893