LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: installglobalname
Name *
installglobalname(const char *s, int t)
{
	Name *name;

	name = emalloc(sizeof *name);
	name->s = estrdup(s);
	name->type = t;
	name->next = nametab;
	nametab = name;
	return name;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r15
movl $0x20, %edi
callq 0x2230
movq %rax, %r14
testq %rax, %rax
jne 0x28fb
leaq 0x6814(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movq %r15, %rdi
callq 0x22c0
movq %rax, %r15
testq %rax, %rax
jne 0x2919
leaq 0x67f6(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movq %r15, 0x8(%r14)
movl %ebx, 0x10(%r14)
movq 0xd978(%rip), %rax      # 0x102a0
movq %rax, (%r14)
movq %r14, 0xd96e(%rip)      # 0x102a0
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: installlocalname
Name *
installlocalname(const char *s, Name *tab)
{
	Name *name;

	name = emalloc(sizeof *name);
	name->s = estrdup(s);
	name->type = VAR;
	name->next = tab;
	return name;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movl $0x20, %edi
callq 0x2230
movq %rax, %r14
testq %rax, %rax
jne 0x2966
leaq 0x67a9(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movq %r15, %rdi
callq 0x22c0
movq %rax, %r15
testq %rax, %rax
jne 0x2984
leaq 0x678b(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movq %r15, 0x8(%r14)
movl $0x105, 0x10(%r14)      # imm = 0x105
movq %rbx, (%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: addstr
String *
addstr(char *s, int final)
{
	String **list;
	String *p;

	if ((p = malloc(sizeof *p)) == NULL) {
		free(s);
		yyerror("out of memory");
	}
	if (final) {
		list = &finalstrings;
		p->orig = FINAL;
	} else {
		list = &autostrings;
		p->orig = AUTO;
	}
	p->s = s;
	if (*list)
		(*list)->prev = p;
	p->next = *list;
	p->prev = NULL;
	p->count = 1;
	*list = p;
	return p;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x28, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x29cd
movq %r14, %rdi
callq 0x2030
leaq 0x6742(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
xorl %ecx, %ecx
testl %ebp, %ebp
sete %cl
leaq 0xd8d5(%rip), %rdx      # 0x102b0
leaq 0xd8c6(%rip), %rax      # 0x102a8
cmoveq %rdx, %rax
movl %ecx, 0x10(%rbx)
movq %r14, 0x18(%rbx)
movq (%rax), %rcx
testq %rcx, %rcx
je 0x29fd
movq %rbx, (%rcx)
movq (%rax), %rcx
jmp 0x29ff
xorl %ecx, %ecx
movq %rcx, 0x8(%rbx)
movq $0x0, (%rbx)
movq $0x1, 0x20(%rbx)
movq %rbx, (%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: init
void
init(int c, char *v[])
{
	Name *name;
	int i;

	argc = c;
	argvstrings = emalloc(argc * sizeof *argvstrings);
	for (i = 0; i < argc; i++) {
		argvstrings[i].s = v[i];
		argvstrings[i].orig = ARGV;
	}

	/* initialize program memory */
	prog.head = emalloc(sizeof *prog.head);
	prog.head->next = NULL;
	prog.base = prog.progp = prog.head;

	/* initialize frame stack */
	frame.head = emalloc(sizeof *frame.head);
	frame.head->next = NULL;
	frame.head->prev = NULL;
	frame.next = frame.head;

	/* initialize random function */
	srand(time(NULL));

	/* initialize symbol table with keyword and builtin names */
	for (i = 0; keywords[i].s; i++)
		installglobalname(keywords[i].s, keywords[i].v);
	for (i = 0; bltins[i].s; i++) {
		name = installglobalname(bltins[i].s, BLTIN);
		name->u.bltin = i;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movl %edi, 0xd88c(%rip)      # 0x102b8
movslq %edi, %rax
shlq $0x3, %rax
leaq (%rax,%rax,4), %rdi
callq 0x2230
movq %rax, %r14
testq %rax, %rax
jne 0x2a58
leaq 0x66bd(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movl 0xd860(%rip), %ebp      # 0x102b8
movq %r14, 0xd861(%rip)      # 0x102c0
testl %ebp, %ebp
jle 0x2a86
movl %ebp, %eax
addq $0x18, %r14
xorl %ecx, %ecx
movq (%rbx,%rcx,8), %rdx
movq %rdx, (%r14)
movl $0x2, -0x8(%r14)
incq %rcx
addq $0x28, %r14
cmpq %rcx, %rax
jne 0x2a6b
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x2aa6
leaq 0x6669(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movq %rbx, 0xd81b(%rip)      # 0x102c8
movq $0x0, (%rbx)
movq %rbx, 0xd81d(%rip)      # 0x102d8
movq %rbx, 0xd81e(%rip)      # 0x102e0
movl $0x30, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x2ae2
leaq 0x662d(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movq %rbx, 0xd807(%rip)      # 0x102f0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, 0xd812(%rip)      # 0x10308
xorl %edi, %edi
callq 0x2200
movl %eax, %edi
callq 0x2180
leaq 0x678c(%rip), %rdi      # 0x9297
movl $0x10, %ebx
leaq 0xacf9(%rip), %r14      # 0xd810
movl -0x8(%rbx,%r14), %esi
callq 0x28d1
movq (%rbx,%r14), %rdi
addq $0x10, %rbx
cmpq $0xf0, %rbx
jne 0x2b17
leaq 0x67a6(%rip), %rdi      # 0x92df
leaq 0xadd8(%rip), %rbx      # 0xd918
xorl %r14d, %r14d
movl $0x106, %esi            # imm = 0x106
callq 0x28d1
movl %r14d, 0x18(%rax)
incq %r14
movq (%rbx), %rdi
addq $0x18, %rbx
cmpq $0x11, %r14
jne 0x2b43
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: prepare
void
prepare(void)
{
	Frame *fp;

	continuing = breaking = returning = 0;
	prog.tail = NULL;
	prog.progp = prog.base;
	currsymtab = NULL;
	for (fp = frame.head; fp && fp != frame.tail; fp = fp->next)
		if (fp->local)
			freesymtab(&(fp->local));
	frame.tail = frame.next = frame.head;
	frame.curr = NULL;
	freestrings(&autostrings);
	freestack();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %eax, %eax
movb %al, 0xd79e(%rip)       # 0x10310
movb %al, 0xd79c(%rip)       # 0x10314
movb %al, 0xd79a(%rip)       # 0x10318
movq %rax, 0xd74b(%rip)      # 0x102d0
movq 0xd754(%rip), %rcx      # 0x102e0
movq %rcx, 0xd745(%rip)      # 0x102d8
movq %rax, 0xd786(%rip)      # 0x10320
movq 0xd74f(%rip), %rbx      # 0x102f0
testq %rbx, %rbx
setne %cl
movq 0xd74a(%rip), %rax      # 0x102f8
cmpq %rax, %rbx
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x2bf8
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x2be3
movq (%rdi), %r14
callq 0x2030
movq %r14, %rdi
testq %r14, %r14
jne 0x2bc4
movq $0x0, 0x10(%rbx)
movq 0xd715(%rip), %rax      # 0x102f8
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x2bf1
cmpq %rax, %rbx
jne 0x2bbb
movq 0xd6f8(%rip), %rbx      # 0x102f0
movq %rbx, 0xd709(%rip)      # 0x10308
movq %rbx, 0xd6f2(%rip)      # 0x102f8
movq $0x0, 0xd6ef(%rip) # 0x10300
leaq 0xd698(%rip), %rdi      # 0x102b0
callq 0x2c4c
movq 0xd70c(%rip), %rdi      # 0x10330
testq %rdi, %rdi
je 0x2c39
movq (%rdi), %rbx
callq 0x2030
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x2c29
movq $0x0, 0xd6ec(%rip) # 0x10330
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: freestrings
static void
freestrings(String **strings)
{
	String *tmp, *p;

	p = *strings;
	while (p) {
		tmp = p;
		p = p->next;
		if (DEBUG)
			fprintf(stderr, "FREED STRING: %s\n", tmp->s);
		free(tmp->s);
		free(tmp);
	}
	*strings = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x2c79
movq 0x8(%r14), %r15
movq 0x18(%r14), %rdi
callq 0x2030
movq %r14, %rdi
callq 0x2030
movq %r15, %r14
testq %r15, %r15
jne 0x2c5c
movq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: cleanup
static void
freesymtab(Symbol **symtab)
{
	Symbol *tmp, *p;

	p = *symtab;
	while (p) {
		tmp = p;
		p = p->next;
		if (DEBUG)
			fprintf(stderr, "FREED SYMBOL: %s\n", tmp->name);
		free(tmp);
	}
	*symtab = NULL;
}

// Assembly:
pushq %rbx
movq 0xd69a(%rip), %rdi      # 0x10328
testq %rdi, %rdi
je 0x2ca3
movq (%rdi), %rbx
callq 0x2030
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x2c93
movq $0x0, 0xd67a(%rip) # 0x10328
leaq 0xd5fb(%rip), %rdi      # 0x102b0
callq 0x2c4c
leaq 0xd5e7(%rip), %rdi      # 0x102a8
callq 0x2c4c
leaq 0xd5d3(%rip), %rdi      # 0x102a0
callq 0x2cfb
movq 0xd657(%rip), %rdi      # 0x10330
testq %rdi, %rdi
je 0x2cee
movq (%rdi), %rbx
callq 0x2030
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x2cde
movq $0x0, 0xd637(%rip) # 0x10330
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: freenametab
static void
freenametab(Name **nametab)
{
	Name *tmp, *p;

	p = *nametab;
	while (p) {
		tmp = p;
		p = p->next;
		if (DEBUG)
			fprintf(stderr, "FREED NAME: %s\n", tmp->s);
		if (tmp->type == FUNCTION || tmp->type == PROCEDURE)
			freenametab(&(tmp->u.fun->params));
		free(tmp->s);
		free(tmp);
	}
	*nametab = NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x2d46
movl $0xfffffeeb, %ebp       # imm = 0xFFFFFEEB
movq (%r14), %r15
movl 0x10(%r14), %eax
addl %ebp, %eax
cmpl $0x1, %eax
ja 0x2d2d
movq 0x18(%r14), %rdi
addq $0x8, %rdi
callq 0x2cfb
movq 0x8(%r14), %rdi
callq 0x2030
movq %r14, %rdi
callq 0x2030
movq %r15, %r14
testq %r15, %r15
jne 0x2d12
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: execute
void
execute(Inst *ip)
{
	Inst *opc;

	if (ip == NULL)
		prog.pc = prog.base;
	else
		prog.pc = ip;
	while (prog.pc->u.opr && !breaking && !continuing) {
		opc = prog.pc;
		prog.pc = prog.pc->next;
		opc->u.opr();
	}
}

// Assembly:
pushq %rax
testq %rdi, %rdi
jne 0x2d86
movq 0xd55a(%rip), %rdi      # 0x102e0
movq %rdi, 0xd55b(%rip)      # 0x102e8
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x2dbd
testb $0x1, 0xd577(%rip)      # 0x10314
jne 0x2dbd
testb $0x1, 0xd572(%rip)      # 0x10318
jne 0x2dbd
movq (%rdi), %rcx
movq %rcx, 0xd536(%rip)      # 0x102e8
callq *%rax
movq 0xd52d(%rip), %rdi      # 0x102e8
jmp 0x2d8d
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: code
Inst *
code(Inst inst)
{
	Inst *ip;

	ip = prog.progp->next;
	prog.tail = prog.progp;
	*prog.tail = inst;
	prog.tail->next = ip;
	if (!prog.tail->next) {
		ip = emalloc(sizeof *ip);
		ip->next = NULL;
		prog.tail->next = ip;
	}
	prog.progp = prog.tail->next;
	return prog.tail;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0xd50e(%rip), %r14      # 0x102d8
movq (%r14), %rbx
movq %r14, 0xd4fc(%rip)      # 0x102d0
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%r14)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%r14)
movq %rbx, (%r14)
testq %rbx, %rbx
jne 0x2e1f
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x2e15
leaq 0x6301(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movq 0xd4bb(%rip), %r14      # 0x102d0
movq $0x0, (%rbx)
movq %rbx, (%r14)
movq %rbx, 0xd4b2(%rip)      # 0x102d8
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: pop
static Datum
pop(void)
{
	Datum *tmp, d;

	if (stack == NULL)
		yyerror("stack underflow");
	tmp = stack;
	d = *stack;
	stack = stack->next;
	free(tmp);
	return d;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xd4db(%rip), %rdi      # 0x10330
testq %rdi, %rdi
jne 0x2e6f
leaq 0x65d4(%rip), %rdi      # 0x9435
xorl %eax, %eax
callq 0x27d2
movq 0xd4c1(%rip), %rdi      # 0x10330
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rbx)
movups (%rdi), %xmm0
movups %xmm0, (%rbx)
movq (%rdi), %rax
movq %rax, 0xd4a9(%rip)      # 0x10330
popq %rbx
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: prevpush
static void
push(Datum d)
{
	Datum *p;

	p = emalloc(sizeof *p);
	*p = d;
	p->next = stack;
	stack = p;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq 0xd445(%rip), %rax      # 0x10348
movq %rax, 0x10(%rsp)
movups 0xd429(%rip), %xmm0     # 0x10338
movaps %xmm0, (%rsp)
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x2f33
leaq 0x61dc(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
movq 0xd3e6(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xd3dc(%rip)      # 0x10330
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: strpush
static String *
getstrarg(void)
{
	String *str;

	str = prog.pc->u.str;
	prog.pc = prog.pc->next;
	return str;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0xd383(%rip), %rax      # 0x102e8
movq (%rax), %rcx
movq 0x10(%rax), %r14
movq %rcx, 0xd375(%rip)      # 0x102e8
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x2f93
leaq 0x617c(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movq %r14, 0x8(%rbx)
movl $0x1, 0x10(%rbx)
movq 0xd38b(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xd381(%rip)      # 0x10330
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: movstr
void
movstr(String *str)
{
	if (str->orig == FINAL) {
		str->count++;
	} else if (str->orig == AUTO) {
		if (str->next)
			str->next->prev = str->prev;
		if (str->prev)
			str->prev->next = str->next;
		else
			autostrings = str->next;
		if (finalstrings)
			finalstrings->prev = str;
		str->next = finalstrings;
		str->prev = NULL;
		str->orig = FINAL;
		str->count = 1;
		finalstrings = str;
	}
}

// Assembly:
movl 0x10(%rdi), %eax
cmpl $0x1, %eax
je 0x2fc8
testl %eax, %eax
jne 0x2fc7
incq 0x20(%rdi)
retq
movq (%rdi), %rcx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x2fd7
movq %rcx, (%rax)
leaq 0x8(%rcx), %rdx
testq %rcx, %rcx
leaq 0xd2cb(%rip), %rcx      # 0x102b0
cmovneq %rdx, %rcx
movq %rax, (%rcx)
movq 0xd2b5(%rip), %rax      # 0x102a8
testq %rax, %rax
je 0x3004
movq %rdi, (%rax)
movq 0xd2a6(%rip), %rax      # 0x102a8
jmp 0x3006
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movq $0x0, (%rdi)
movl $0x0, 0x10(%rdi)
movq $0x1, 0x20(%rdi)
movq %rdi, 0xd281(%rip)      # 0x102a8
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: add
void
add(void)
{
	Datum d1, d2;

	d2 = popnum();
	d1 = popnum();
	d1.u.val += d2.u.val;
	push(d1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x30af
movsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x30af
movsd 0x8(%rbx), %xmm0
movsd %xmm0, (%rsp)
movq 0x10(%rbx), %r14
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x3082
leaq 0x608d(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movsd 0x8(%rsp), %xmm0
addsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq 0xd293(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xd289(%rip)      # 0x10330
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: popnum
static Datum
popnum(void)
{
	Datum d;
	double v;

	d = pop();
	if (d.isstr) {
		v = atof(d.u.str->s);
		d.u.val = v;
	}
	d.isstr = 0;
	return d;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x2e4a
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movups (%r14), %xmm0
movups %xmm0, (%rbx)
cmpl $0x0, 0x10(%rbx)
je 0x30eb
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rdi
callq 0x20c0
movsd %xmm0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: sub
void
sub(void)
{
	Datum d1, d2;

	d2 = popnum();
	d1 = popnum();
	d1.u.val -= d2.u.val;
	push(d1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x30af
movsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x30af
movsd 0x8(%rbx), %xmm0
movsd %xmm0, (%rsp)
movq 0x10(%rbx), %r14
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x3154
leaq 0x5fbb(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movsd (%rsp), %xmm0
subsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq 0xd1c1(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xd1b7(%rip)      # 0x10330
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: divd
void
divd(void)
{
	Datum d1, d2;

	d2 = popnum();
	if (d2.u.val == 0.0)
		yyerror("division by zero");
	d1 = popnum();
	d1.u.val /= d2.u.val;
	push(d1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x30af
movsd 0x8(%rbx), %xmm1
xorpd %xmm0, %xmm0
movsd %xmm1, 0x8(%rsp)
ucomisd %xmm0, %xmm1
jne 0x3241
jp 0x3241
leaq 0x5f2a(%rip), %rdi      # 0x9164
xorl %eax, %eax
callq 0x27d2
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x30af
movsd 0x8(%rbx), %xmm0
movsd %xmm0, (%rsp)
movq 0x10(%rbx), %r14
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x327c
leaq 0x5e93(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movsd (%rsp), %xmm0
divsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq 0xd099(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xd08f(%rip)      # 0x10330
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: mod
void
mod(void)
{
	Datum d1, d2;

	d2 = popnum();
	if (d2.u.val == 0.0)
		yyerror("module by zero");
	d1 = popnum();
	d1.u.val = fmod(d1.u.val, d2.u.val);
	push(d1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x30af
movsd 0x8(%rbx), %xmm1
xorpd %xmm0, %xmm0
movsd %xmm1, 0x8(%rsp)
ucomisd %xmm0, %xmm1
jne 0x32e2
jp 0x32e2
leaq 0x5e9a(%rip), %rdi      # 0x9175
xorl %eax, %eax
callq 0x27d2
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x30af
movsd 0x8(%rbx), %xmm0
movq 0x10(%rbx), %r14
movsd 0x8(%rsp), %xmm1
callq 0x2140
movsd %xmm0, 0x8(%rsp)
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x3329
leaq 0x5de6(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq 0xcff1(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xcfe7(%rip)      # 0x10330
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: negate
void
negate(void)
{
	Datum d;

	d = popnum();
	d.u.val = -d.u.val;
	push(d);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x30af
movsd 0x8(%rbx), %xmm0
movaps %xmm0, (%rsp)
movq 0x10(%rbx), %r14
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x3392
leaq 0x5d7d(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movaps (%rsp), %xmm0
xorps 0x5cb3(%rip), %xmm0     # 0x9050
movlps %xmm0, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq 0xcf84(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xcf7a(%rip)      # 0x10330
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: power
void
power(void)
{
	Datum d1, d2;

	d2 = popnum();
	d1 = popnum();
	d1.u.val = pow(d1.u.val, d2.u.val);
	push(d1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x30af
movsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x30af
movsd 0x8(%rbx), %xmm0
movq 0x10(%rbx), %r14
movsd 0x8(%rsp), %xmm1
callq 0x20d0
movsd %xmm0, 0x8(%rsp)
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x3424
leaq 0x5ceb(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq 0xcef6(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xceec(%rip)      # 0x10330
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: cmdarg
void
cmdarg(void)
{
	Datum d;
	int i;

	d = popnum();
	i = (int)d.u.val;
	if (i >= 0 && i < argc) {
		d.u.str = &argvstrings[i];
		d.isstr = 1;
	} else {
		d.u.val = 0.0;
		d.isstr = 0;
	}
	push(d);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x30af
movq 0x8(%rbx), %r12
movl 0x14(%rbx), %ebp
movl 0xce45(%rip), %r15d     # 0x102b8
movq 0xce46(%rip), %r14      # 0x102c0
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x349a
leaq 0x5c75(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movq %r12, %xmm0
cvttsd2si %xmm0, %eax
testl %eax, %eax
setns %cl
cmpl %eax, %r15d
setg %dl
andb %cl, %dl
movzbl %dl, %ecx
movl %eax, %eax
leaq (%rax,%rax,4), %rax
leaq (%r14,%rax,8), %rax
xorl %edx, %edx
testb %cl, %cl
cmovneq %rax, %rdx
movq %rdx, 0x8(%rbx)
movl %ecx, 0x10(%rbx)
movl %ebp, 0x14(%rbx)
movq 0xce5a(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xce50(%rip)      # 0x10330
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: eval
void
eval(void)
{
	Symbol *sym = NULL;
	Name *name;
	Datum d;

	name = getnamearg();
	if ((sym = lookupsym(currsymtab, name->s)) == NULL)
		if ((sym = lookupsym(global, name->s)) == NULL)
			yyerror("could not find variable %s", name->s);
	d.isstr = sym->isstr;
	d.u = sym->u;
	push(d);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq 0xcdf0(%rip), %rax      # 0x102e8
movq (%rax), %rcx
movq 0x10(%rax), %rax
movq %rcx, 0xcde2(%rip)      # 0x102e8
movq 0xce13(%rip), %r14      # 0x10320
movq 0x8(%rax), %rbx
testq %r14, %r14
je 0x352b
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x21b0
testl %eax, %eax
je 0x354c
movq (%r14), %r14
jmp 0x3511
movq 0xcdf6(%rip), %r14      # 0x10328
testq %r14, %r14
je 0x3591
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x21b0
testl %eax, %eax
je 0x354c
movq (%r14), %r14
jmp 0x3532
movl 0x18(%r14), %ebp
movq 0x8(%r14), %r14
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x3574
leaq 0x5b9b(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movq %r14, 0x8(%rbx)
movl %ebp, 0x10(%rbx)
movq 0xcdae(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xcda4(%rip)      # 0x10330
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x5bec(%rip), %rdi      # 0x9184
movq %rbx, %rsi
xorl %eax, %eax
callq 0x27d2
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: preinc
void
preinc(void)
{
	Symbol *sym;
	Datum d;

	sym = getassign(1);
	d.u.val = sym->u.val += 1.0;
	d.isstr = 0;
	push(d);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl $0x1, %edi
callq 0x3612
movsd 0x8(%rax), %xmm0
addsd 0x5aa2(%rip), %xmm0     # 0x9060
movsd %xmm0, 0x8(%rsp)
movsd %xmm0, 0x8(%rax)
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x35e9
leaq 0x5b26(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
movq 0xcd2e(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xcd24(%rip)      # 0x10330
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: getassign
static Symbol *
getassign(int convtonum)
{
	Name *name;
	Symbol *sym;
	double v;

	name = getnamearg();
	verifyassign(name, convtonum);
	if ((sym = lookupsym(currsymtab, name->s)) == NULL)
		if ((sym = lookupsym(global, name->s)) == NULL)
			sym = installglobalsym(name->s);
	name->type = VAR;
	if (convtonum && sym->isstr) {
		v = atof(sym->u.str->s);
		dfree(sym->u.str);
		sym->u.val = v;
		sym->isstr = 0;
	}
	return sym;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0xccc5(%rip), %rax      # 0x102e8
movq (%rax), %rcx
movq 0x10(%rax), %r12
movq %rcx, 0xccb7(%rip)      # 0x102e8
testl %edi, %edi
je 0x3653
cmpl $0x107, 0x10(%r12)      # imm = 0x107
jne 0x3653
movq 0x8(%r12), %rsi
leaq 0x5df9(%rip), %rdi      # 0x9445
xorl %eax, %eax
callq 0x27d2
movl 0x10(%r12), %eax
orl $0x2, %eax
cmpl $0x107, %eax            # imm = 0x107
je 0x3675
movq 0x8(%r12), %rsi
leaq 0x5dee(%rip), %rdi      # 0x945c
xorl %eax, %eax
callq 0x27d2
movq 0xcca4(%rip), %r14      # 0x10320
movq 0x8(%r12), %r15
testq %r14, %r14
je 0x369b
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x21b0
testl %eax, %eax
je 0x36d8
movq (%r14), %r14
jmp 0x3681
movq 0xcc86(%rip), %r14      # 0x10328
testq %r14, %r14
je 0x36bc
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x21b0
testl %eax, %eax
je 0x36d8
movq (%r14), %r14
jmp 0x36a2
movq %r15, %rdi
callq 0x50e8
movq %rax, %r14
movq 0xcc5a(%rip), %rax      # 0x10328
movq %rax, (%r14)
movq %r14, 0xcc50(%rip)      # 0x10328
movl $0x105, 0x10(%r12)      # imm = 0x105
testl %ebx, %ebx
je 0x3719
cmpl $0x0, 0x18(%r14)
je 0x3719
movq 0x8(%r14), %rbx
movq 0x18(%rbx), %rdi
callq 0x20c0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x3920
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%r14)
movl $0x0, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: predec
void
predec(void)
{
	Symbol *sym;
	Datum d;

	sym = getassign(1);
	d.u.val = sym->u.val -= 1.0;
	d.isstr = 0;
	push(d);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl $0x1, %edi
callq 0x3612
movsd 0x8(%rax), %xmm0
addsd 0x5924(%rip), %xmm0     # 0x9068
movsd %xmm0, 0x8(%rsp)
movsd %xmm0, 0x8(%rax)
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x376f
leaq 0x59a0(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
movq 0xcba8(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xcb9e(%rip)      # 0x10330
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: postinc
void
postinc(void)
{
	Symbol *sym;
	Datum d;

	sym = getassign(1);
	d.u.val = sym->u.val;
	d.isstr = 0;
	sym->u.val += 1.0;
	push(d);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl $0x1, %edi
callq 0x3612
movsd 0x8(%rax), %xmm1
movsd 0x58ac(%rip), %xmm0     # 0x9060
movsd %xmm1, 0x8(%rsp)
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x37e3
leaq 0x592c(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
movq 0xcb34(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xcb2a(%rip)      # 0x10330
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: postdec
void
postdec(void)
{
	Symbol *sym;
	Datum d;

	sym = getassign(1);
	d.u.val = sym->u.val;
	d.isstr = 0;
	sym->u.val -= 1.0;
	push(d);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl $0x1, %edi
callq 0x3612
movsd 0x8(%rax), %xmm1
movsd 0x5840(%rip), %xmm0     # 0x9068
movsd %xmm1, 0x8(%rsp)
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x3857
leaq 0x58b8(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
movq 0xcac0(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xcab6(%rip)      # 0x10330
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: assign
void
assign(void)
{
	Datum d;
	Symbol *sym;

	d = pop();
	sym = getassign(0);
	if (sym->isstr)
		dfree(sym->u.str);
	if (d.isstr)
		movstr(d.u.str);
	sym->u = d.u;
	sym->isstr = d.isstr;
	push(d);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x2e4a
movq 0x8(%r14), %rbx
movsd 0x10(%r14), %xmm0
movaps %xmm0, (%rsp)
xorl %edi, %edi
callq 0x3612
movq %rax, %r14
cmpl $0x0, 0x18(%rax)
je 0x38bc
movq 0x8(%r14), %rdi
callq 0x3920
movdqa (%rsp), %xmm0
movd %xmm0, %ebp
testl %ebp, %ebp
je 0x38d1
movq %rbx, %rdi
callq 0x2fb7
movq %rbx, 0x8(%r14)
movl %ebp, 0x18(%r14)
movl $0x18, %edi
callq 0x2230
movq %rax, %r14
testq %rax, %rax
jne 0x38f9
leaq 0x5816(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movq %rbx, 0x8(%r14)
movaps (%rsp), %xmm0
movlps %xmm0, 0x10(%r14)
movq 0xca23(%rip), %rax      # 0x10330
movq %rax, (%r14)
movq %r14, 0xca19(%rip)      # 0x10330
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: dfree
static void
dfree(String *str)
{
	if (str->orig != FINAL)
		return;
	if (str->count > 1) {
		str->count--;
	} else {
		if (DEBUG)
			printf("FREED STRING: %s\n", str->s);
		free(str->s);
		if (str->next)
			str->next->prev = str->prev;
		if (str->prev)
			str->prev->next = str->next;
		else
			finalstrings = str->next;
		free(str);
	}
}

// Assembly:
pushq %rbx
cmpl $0x0, 0x10(%rdi)
jne 0x393b
movq %rdi, %rbx
movq 0x20(%rdi), %rax
cmpq $0x2, %rax
jb 0x393d
decq %rax
movq %rax, 0x20(%rbx)
popq %rbx
retq
movq 0x18(%rbx), %rdi
callq 0x2030
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x3955
movq %rcx, (%rax)
leaq 0x8(%rcx), %rdx
testq %rcx, %rcx
leaq 0xc945(%rip), %rcx      # 0x102a8
cmovneq %rdx, %rcx
movq %rax, (%rcx)
movq %rbx, %rdi
popq %rbx
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: addeq
void
addeq(void)
{
	Symbol *sym;
	Datum d;

	d = popnum();
	sym = getassign(1);
	d.u.val = sym->u.val += d.u.val;
	push(d);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x30af
movsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rbx), %r14
movl $0x1, %edi
callq 0x3612
movsd 0x8(%rsp), %xmm0
addsd 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd %xmm0, 0x8(%rax)
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x39d6
leaq 0x5739(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq 0xc944(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xc93a(%rip)      # 0x10330
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: subeq
void
subeq(void)
{
	Symbol *sym;
	Datum d;

	d = popnum();
	sym = getassign(1);
	d.u.val = sym->u.val -= d.u.val;
	push(d);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x30af
movsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rbx), %r14
movl $0x1, %edi
callq 0x3612
movsd 0x8(%rax), %xmm0
subsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd %xmm0, 0x8(%rax)
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x3a61
leaq 0x56ae(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq 0xc8b9(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xc8af(%rip)      # 0x10330
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: modeq
void
modeq(void)
{
	Symbol *sym;
	Datum d;
	double v;

	d = popnum();
	sym = getassign(1);
	v = fmod(sym->u.val, d.u.val);
	d.u.val = sym->u.val = v;
	push(d);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x30af
movsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rbx), %r14
movl $0x1, %edi
callq 0x3612
movq %rax, %rbx
movsd 0x8(%rax), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x2140
movsd %xmm0, 0x8(%rsp)
movsd %xmm0, 0x8(%rbx)
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x3c0a
leaq 0x5505(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq 0xc710(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xc706(%rip)      # 0x10330
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: println
void
println(void)
{
	Datum d;

	d = pop();
	pr(d);
	printf("\n");
	if (prev.isstr)
		dfree(prev.u.str);
	if (d.isstr)
		movstr(d.u.str);
	prev = d;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x2e4a
movq (%r14), %r15
movq 0x8(%r14), %rbx
movq 0x10(%r14), %r14
testl %r14d, %r14d
je 0x3c6c
movq 0x18(%rbx), %rsi
leaq 0x54d7(%rip), %rdi      # 0x913a
xorl %eax, %eax
callq 0x2110
jmp 0x3c7f
movq %rbx, %xmm0
leaq 0x54b8(%rip), %rdi      # 0x9130
movb $0x1, %al
callq 0x2110
movl $0xa, %edi
callq 0x2040
cmpl $0x0, 0xc6b8(%rip)      # 0x10348
je 0x3c9e
movq 0xc6a7(%rip), %rdi      # 0x10340
callq 0x3920
movq %r14, %xmm0
testl %r14d, %r14d
je 0x3cba
movq %rbx, %rdi
movdqa %xmm0, (%rsp)
callq 0x2fb7
movdqa (%rsp), %xmm0
movq %r15, 0xc677(%rip)      # 0x10338
movq %rbx, 0xc678(%rip)      # 0x10340
movq %xmm0, 0xc678(%rip)     # 0x10348
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: print
void
_print(void)
{
	Datum *beg, *p;

	beg = poplist();
	for (p = beg; p; p = p->next) {
		pr(*p);
		if (p->next)
			printf(" ");
		else
			printf("\n");
	}
	freelist(beg);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
callq 0x3d73
testq %rax, %rax
je 0x3d6b
movq %rax, %rbx
movq %rax, %r14
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
callq 0x3cda
cmpq $0x0, (%r14)
movl $0xa, %edi
je 0x3d4b
movl $0x20, %edi
callq 0x2040
movq (%r14), %r14
testq %r14, %r14
jne 0x3d25
movq (%rbx), %r14
movq %rbx, %rdi
callq 0x2030
movq %r14, %rbx
testq %r14, %r14
jne 0x3d58
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: poplist
static Datum *
poplist(void)
{
	Datum *tmp = NULL, *beg = NULL;
	int narg;

	narg = getintarg();
	while (narg-- > 0) {
		if (stack == NULL) {
			freelist(beg);
			yyerror("stack underflow");
		}
		beg = stack;
		stack = stack->next;
		beg->next = tmp;
		tmp = beg;
	}
	return beg;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0xc566(%rip), %rax      # 0x102e8
movl 0x10(%rax), %r14d
movq (%rax), %rax
movq %rax, 0xc558(%rip)      # 0x102e8
testl %r14d, %r14d
jle 0x3df6
movq 0xc594(%rip), %rcx      # 0x10330
leaq 0x5692(%rip), %rbx      # 0x9435
xorl %r15d, %r15d
testq %rcx, %rcx
jne 0x3dd4
testq %r15, %r15
je 0x3dc3
movq %r15, %rdi
movq (%rdi), %r12
callq 0x2030
movq %r12, %rdi
testq %r12, %r12
jne 0x3db3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x27d2
movq 0xc55c(%rip), %rcx      # 0x10330
movq %rcx, %rax
leal -0x1(%r14), %edx
movq (%rcx), %rcx
movq %rcx, 0xc54b(%rip)      # 0x10330
movq %r15, (%rax)
movq %rax, %r15
cmpl $0x1, %r14d
movl %edx, %r14d
jg 0x3da6
jmp 0x3df8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: printf
void
_printf(void)
{
	Datum *beg;
	char *s;

	if ((beg = poplist()) == NULL)
		goto error;
	if (!beg->isstr) {
		warning("no format supplied");
		goto error;
	}
	if ((s = format(beg->u.str->s, beg->next)) == NULL)
		goto error;
	printf("%s", s);
	free(s);
	freelist(beg);
	return;

error:
	freelist(beg);
	longjump();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x3d73
testq %rax, %rax
je 0x3e88
movq %rax, %rbx
cmpl $0x0, 0x10(%rax)
je 0x3e67
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rdi
callq 0x3e94
testq %rax, %rax
je 0x3e75
movq %rax, %r14
leaq 0x5300(%rip), %rdi      # 0x913a
movq %rax, %rsi
xorl %eax, %eax
callq 0x2110
movq %r14, %rdi
callq 0x2030
movq (%rbx), %r14
movq %rbx, %rdi
callq 0x2030
movq %r14, %rbx
testq %r14, %r14
jne 0x3e4c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5331(%rip), %rdi      # 0x919f
xorl %eax, %eax
callq 0x270e
movq (%rbx), %r14
movq %rbx, %rdi
callq 0x2030
movq %r14, %rbx
testq %r14, %r14
jne 0x3e75
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x26fc
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: sprintf
void
_sprintf(void)
{
	String *str;
	Datum d, *beg;
	char *s;

	if ((beg = poplist()) == NULL)
		goto error;
	if (!beg->isstr) {
		warning("no format supplied");
		goto error;
	}
	if ((s = format(beg->u.str->s, beg->next)) == NULL)
		goto error;
	if ((str = addstr(s, 0)) == NULL) {
		warning("out of memory");
		goto error;
	}
	freelist(beg);
	d.isstr = 1;
	d.u.str = str;
	push(d);
	return;

error:
	freelist(beg);
	longjump();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0x3d73
testq %rax, %rax
je 0x421e
movq %rax, %rbx
cmpl $0x0, 0x10(%rax)
je 0x41f4
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rdi
callq 0x3e94
testq %rax, %rax
je 0x420b
movq %rax, %rdi
xorl %esi, %esi
callq 0x299c
testq %rax, %rax
je 0x41fd
movq %rax, %r14
movq (%rbx), %r15
movq %rbx, %rdi
callq 0x2030
movq %r15, %rbx
testq %r15, %r15
jne 0x419f
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x41d2
leaq 0x4f3d(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movq %r14, 0x8(%rbx)
movl $0x1, 0x10(%rbx)
movq 0xc14c(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xc142(%rip)      # 0x10330
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4fa4(%rip), %rdi      # 0x919f
jmp 0x4204
leaq 0x4f04(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x270e
movq (%rbx), %r14
movq %rbx, %rdi
callq 0x2030
movq %r14, %rbx
testq %r14, %r14
jne 0x420b
popq %rbx
popq %r14
popq %r15
jmp 0x26fc
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: readnum
void
readnum(void)
{
	Datum d;
	Symbol *sym;
	double v;

	sym = getassign(0);
	switch (scanf("%lf", &v)) {
	case EOF:
		d.u.val = 0.0;
		break;
	case 0:
		yyerror("non-number read into %s", sym->name);
		break;
	default:
		d.u.val = 1.0;
		sym->isstr = 0;
		sym->u.val = v;
		break;
	}
	d.isstr = 0;
	push(d);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
xorl %edi, %edi
callq 0x3612
movq %rax, %rbx
leaq 0x4f74(%rip), %rdi      # 0x91b2
leaq 0x8(%rsp), %rsi
xorl %eax, %eax
callq 0x2280
cmpl $-0x1, %eax
je 0x4267
testl %eax, %eax
jne 0x426c
movq 0x10(%rbx), %rsi
leaq 0x4f58(%rip), %rdi      # 0x91b6
xorl %eax, %eax
callq 0x27d2
jmp 0x428b
xorps %xmm0, %xmm0
jmp 0x4286
movl $0x0, 0x18(%rbx)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movsd 0x4dda(%rip), %xmm0     # 0x9060
movsd %xmm0, (%rsp)
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x42ab
leaq 0x4e64(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
movq 0xc06d(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xc063(%rip)      # 0x10330
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: readline
void
readline(void)
{
	Datum d;
	Symbol *sym;
	char buf[BUFSIZ];
	char *s;

	sym = getassign(0);
	if (fgets(buf, sizeof buf, stdin)) {
		d.u.val = 1.0;
		if ((s = strdup(buf)) == NULL)
			yyerror("out of memory");
		sym->isstr = 1;
		sym->u.str = addstr(s, 1);
	} else {
		d.u.val = 0.0;
	}
	d.isstr = 0;
	push(d);
}

// Assembly:
pushq %rbx
subq $0x2010, %rsp           # imm = 0x2010
xorl %edi, %edi
callq 0x3612
movq %rax, %rbx
movq 0x9cdc(%rip), %rax      # 0xdfc8
movq (%rax), %rdx
leaq 0x10(%rsp), %rdi
movl $0x2000, %esi           # imm = 0x2000
callq 0x2190
testq %rax, %rax
je 0x431e
leaq 0x10(%rsp), %rdi
callq 0x22c0
testq %rax, %rax
je 0x4323
movl $0x1, 0x18(%rbx)
movq %rax, %rdi
jmp 0x433a
xorps %xmm0, %xmm0
jmp 0x4350
leaq 0x4dde(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movl $0x1, 0x18(%rbx)
xorl %edi, %edi
movl $0x1, %esi
callq 0x299c
movq %rax, 0x8(%rbx)
movsd 0x4d10(%rip), %xmm0     # 0x9060
movsd %xmm0, 0x8(%rsp)
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x4376
leaq 0x4d99(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
movq 0xbfa1(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xbf97(%rip)      # 0x10330
addq $0x2010, %rsp           # imm = 0x2010
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: gt
void
gt(void)
{
	Datum d1, d2;

	d2 = popnum();
	d1 = popnum();
	d1.u.val = (double)(d1.u.val > d2.u.val);
	push(d1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x30af
movsd 0x8(%rbx), %xmm0
movaps %xmm0, 0x10(%rsp)
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x30af
movsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rbx), %r14
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x43fc
leaq 0x4d13(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movapd 0x10(%rsp), %xmm1
cmpltsd 0x8(%rsp), %xmm1
movsd 0x4c4f(%rip), %xmm0     # 0x9060
andpd %xmm1, %xmm0
movlpd %xmm0, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq 0xbf0b(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xbf01(%rip)      # 0x10330
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: ge
void
ge(void)
{
	Datum d1, d2;

	d2 = popnum();
	d1 = popnum();
	d1.u.val = (double)(d1.u.val >= d2.u.val);
	push(d1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x30af
movsd 0x8(%rbx), %xmm0
movaps %xmm0, 0x10(%rsp)
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x30af
movsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rbx), %r14
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x4491
leaq 0x4c7e(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movapd 0x10(%rsp), %xmm1
cmplesd 0x8(%rsp), %xmm1
movsd 0x4bba(%rip), %xmm0     # 0x9060
andpd %xmm1, %xmm0
movlpd %xmm0, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq 0xbe76(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xbe6c(%rip)      # 0x10330
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: lt
void
lt(void)
{
	Datum d1, d2;

	d2 = popnum();
	d1 = popnum();
	d1.u.val = (double)(d1.u.val < d2.u.val);
	push(d1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x30af
movsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x30af
movsd 0x8(%rbx), %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x10(%rbx), %r14
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x4526
leaq 0x4be9(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movapd 0x10(%rsp), %xmm1
cmpltsd 0x8(%rsp), %xmm1
movsd 0x4b25(%rip), %xmm0     # 0x9060
andpd %xmm1, %xmm0
movlpd %xmm0, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq 0xbde1(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xbdd7(%rip)      # 0x10330
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: eq
void
eq(void)
{
	Datum d1, d2;

	d2 = popnum();
	d1 = popnum();
	d1.u.val = (double)(d1.u.val == d2.u.val);
	push(d1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x30af
movsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x30af
movsd 0x8(%rbx), %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x10(%rbx), %r14
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x4650
leaq 0x4abf(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
movapd 0x10(%rsp), %xmm1
cmpeqsd 0x8(%rsp), %xmm1
movsd 0x49fb(%rip), %xmm0     # 0x9060
andpd %xmm1, %xmm0
movlpd %xmm0, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq 0xbcb7(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xbcad(%rip)      # 0x10330
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: not
void
not(void)
{
	Datum d;

	d = popnum();
	d.u.val = (double)(!d.u.val);
	push(d);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x30af
movsd 0x8(%rbx), %xmm0
movapd %xmm0, (%rsp)
movq 0x10(%rbx), %r14
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x4762
leaq 0x49ad(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
xorpd %xmm0, %xmm0
movapd (%rsp), %xmm1
cmpeqsd %xmm0, %xmm1
movsd 0x48e8(%rip), %xmm0     # 0x9060
andpd %xmm1, %xmm0
movlpd %xmm0, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq 0xbba4(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xbb9a(%rip)      # 0x10330
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: and
void
and(void)
{
	Datum d;
	Inst *savepc;

	savepc = prog.pc;
	d = popnum();
	if (d.u.val) {
		execute(savepc->u.ip);
		d = popnum();
	}
	d.u.val = d.u.val ? 1.0 : 0.0;
	push(d);
	prog.pc = N1(savepc)->u.ip;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq 0xbb3a(%rip), %r14      # 0x102e8
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x30af
movsd 0x8(%rbx), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x47cc
jnp 0x47f2
movq 0x10(%r14), %rdi
callq 0x2d79
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x30af
movsd 0x8(%rbx), %xmm0
movapd %xmm0, (%rsp)
movq 0x10(%rbx), %r15
jmp 0x47fc
movapd %xmm1, (%rsp)
movq 0x28(%rsp), %r15
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x481c
leaq 0x48f3(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
xorpd %xmm0, %xmm0
movapd (%rsp), %xmm1
cmpneqsd %xmm0, %xmm1
movsd 0x482e(%rip), %xmm0     # 0x9060
andpd %xmm1, %xmm0
movlpd %xmm0, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movq 0xbaea(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xbae0(%rip)      # 0x10330
movq (%r14), %rax
movq 0x10(%rax), %rax
movq %rax, 0xba8a(%rip)      # 0x102e8
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: or
void
or(void)
{
	Datum d;
	Inst *savepc;

	savepc = prog.pc;
	d = popnum();
	if (!d.u.val) {
		execute(savepc->u.ip);
		d = popnum();
	}
	d.u.val = d.u.val ? 1.0 : 0.0;
	push(d);
	prog.pc = N1(savepc)->u.ip;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq 0xba70(%rip), %r14      # 0x102e8
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x30af
movsd 0x8(%rbx), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x4896
jnp 0x48a2
movapd %xmm1, (%rsp)
movq 0x28(%rsp), %r15
jmp 0x48c6
movq 0x10(%r14), %rdi
callq 0x2d79
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x30af
movsd 0x8(%rbx), %xmm0
movapd %xmm0, (%rsp)
movq 0x10(%rbx), %r15
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x48e6
leaq 0x4829(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27d2
xorpd %xmm0, %xmm0
movapd (%rsp), %xmm1
cmpneqsd %xmm0, %xmm1
movsd 0x4764(%rip), %xmm0     # 0x9060
andpd %xmm1, %xmm0
movlpd %xmm0, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movq 0xba20(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xba16(%rip)      # 0x10330
movq (%r14), %rax
movq 0x10(%rax), %rax
movq %rax, 0xb9c0(%rip)      # 0x102e8
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: ifcode
void
ifcode(void)
{
	Datum d;
	Inst *savepc;

	savepc = prog.pc;                       /* then part */
	d = execpop(N3(savepc));
	if (d.u.val)
		execute(savepc->u.ip);
	else if (N1(savepc)->u.ip)              /* else part? */
		execute(N1(savepc)->u.ip);
	if (!returning)
		prog.pc = N2(savepc)->u.ip;     /* next statement */
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq 0xb9a8(%rip), %r14      # 0x102e8
movq (%r14), %rax
movq (%rax), %rax
movq (%rax), %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x499e
movsd 0x8(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4965
jnp 0x496b
movq 0x10(%r14), %rdi
jmp 0x4977
movq (%r14), %rax
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0x497c
callq 0x2d79
cmpb $0x0, 0xb98d(%rip)      # 0x10310
jne 0x4996
movq (%r14), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0xb952(%rip)      # 0x102e8
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/phillbush[P]hoc/code.c
// Function: execpop
static Datum
execpop(Inst *pc)
{
	Datum d;

	if (pc && pc->u.opr) {
		execute(pc);
		d = popnum();
	} else {
		d.u.val = 0.0;
	}
	return d;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x49d8
cmpq $0x0, 0x10(%rsi)
je 0x49d8
movq %rsi, %rdi
callq 0x2d79
movq %rsp, %r14
movq %r14, %rdi
callq 0x30af
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movups (%r14), %xmm0
movups %xmm0, (%rbx)
jmp 0x49e0
movq $0x0, 0x8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq