LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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, 0xd789(%rip)       # 0x10310
movb %al, 0xd787(%rip)       # 0x10314
movb %al, 0xd785(%rip)       # 0x10318
movq %rax, 0xd736(%rip)      # 0x102d0
movq 0xd73f(%rip), %rcx      # 0x102e0
movq %rcx, 0xd730(%rip)      # 0x102d8
movq %rax, 0xd771(%rip)      # 0x10320
movq 0xd73a(%rip), %rbx      # 0x102f0
testq %rbx, %rbx
je 0x2beb
cmpq 0xd736(%rip), %rbx      # 0x102f8
je 0x2beb
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x2be5
movq (%rdi), %r14
callq 0x2030
movq %r14, %rdi
testq %r14, %r14
jne 0x2bcd
movq $0x0, 0x10(%rbx)
movq 0x8(%rbx), %rbx
jmp 0x2bb6
movq 0xd6fe(%rip), %rax      # 0x102f0
movq %rax, 0xd70f(%rip)      # 0x10308
movq %rax, 0xd6f8(%rip)      # 0x102f8
movq $0x0, 0xd6f5(%rip) # 0x10300
leaq 0xd69e(%rip), %rdi      # 0x102b0
callq 0x2c46
movq 0xd712(%rip), %rdi      # 0x10330
testq %rdi, %rdi
je 0x2c33
movq (%rdi), %rbx
callq 0x2030
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x2c23
movq $0x0, 0xd6f2(%rip) # 0x10330
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2c73
movq 0x8(%r14), %r15
movq 0x18(%r14), %rdi
callq 0x2030
movq %r14, %rdi
callq 0x2030
movq %r15, %r14
testq %r15, %r15
jne 0x2c56
movq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd6a0(%rip), %rdi      # 0x10328
testq %rdi, %rdi
je 0x2c9d
movq (%rdi), %rbx
callq 0x2030
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x2c8d
movq $0x0, 0xd680(%rip) # 0x10328
leaq 0xd601(%rip), %rdi      # 0x102b0
callq 0x2c46
leaq 0xd5ed(%rip), %rdi      # 0x102a8
callq 0x2c46
leaq 0xd5d9(%rip), %rdi      # 0x102a0
callq 0x2cf5
movq 0xd65d(%rip), %rdi      # 0x10330
testq %rdi, %rdi
je 0x2ce8
movq (%rdi), %rbx
callq 0x2030
movq %rbx, %rdi
testq %rbx, %rbx
jne 0x2cd8
movq $0x0, 0xd63d(%rip) # 0x10330
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2d40
movl $0xfffffeeb, %ebp       # imm = 0xFFFFFEEB
movq (%r14), %r15
movl 0x10(%r14), %eax
addl %ebp, %eax
cmpl $0x1, %eax
ja 0x2d27
movq 0x18(%r14), %rdi
addq $0x8, %rdi
callq 0x2cf5
movq 0x8(%r14), %rdi
callq 0x2030
movq %r14, %rdi
callq 0x2030
movq %r15, %r14
testq %r15, %r15
jne 0x2d0c
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2d80
movq 0xd560(%rip), %rdi      # 0x102e0
movq %rdi, 0xd561(%rip)      # 0x102e8
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x2db7
testb $0x1, 0xd57d(%rip)      # 0x10314
jne 0x2db7
testb $0x1, 0xd578(%rip)      # 0x10318
jne 0x2db7
movq (%rdi), %rcx
movq %rcx, 0xd53c(%rip)      # 0x102e8
callq *%rax
movq 0xd533(%rip), %rdi      # 0x102e8
jmp 0x2d87
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq 0xd517(%rip), %rax      # 0x102d8
movq (%rax), %rcx
movq %rax, 0xd505(%rip)      # 0x102d0
movaps 0x10(%rsp), %xmm0
movups %xmm0, (%rax)
movq 0x20(%rsp), %rdx
movq %rdx, 0x10(%rax)
movq %rcx, (%rax)
testq %rcx, %rcx
jne 0x2e15
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x2e04
leaq 0x630b(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movq $0x0, (%rbx)
movq 0xd4be(%rip), %rax      # 0x102d0
movq %rbx, (%rax)
movq 0xd4b4(%rip), %rax      # 0x102d0
movq (%rax), %rcx
movq %rcx, 0xd4b2(%rip)      # 0x102d8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpq $0x0, 0xd4e3(%rip)      # 0x10330
jne 0x2e5d
leaq 0x65df(%rip), %rdi      # 0x9435
xorl %eax, %eax
callq 0x27e6
movq 0xd4cc(%rip), %rdi      # 0x10330
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rbx)
movups (%rdi), %xmm0
movups %xmm0, (%rbx)
movq (%rdi), %rax
movq %rax, 0xd4b4(%rip)      # 0x10330
callq 0x2030
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd44c(%rip), %rax      # 0x10348
movq %rax, 0x10(%rsp)
movups 0xd430(%rip), %xmm0     # 0x10338
movaps %xmm0, (%rsp)
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x2f2c
leaq 0x61e3(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
movq 0xd3ed(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xd3e3(%rip)      # 0x10330
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd38a(%rip), %rax      # 0x102e8
movq (%rax), %rcx
movq 0x10(%rax), %r14
movq %rcx, 0xd37c(%rip)      # 0x102e8
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x2f8c
leaq 0x6183(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movq %r14, 0x8(%rbx)
movl $0x1, 0x10(%rbx)
movq 0xd392(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xd388(%rip)      # 0x10330
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2fc1
testl %eax, %eax
jne 0x2fc0
incq 0x20(%rdi)
retq
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x2fd0
movq (%rdi), %rcx
movq %rcx, (%rax)
movq (%rdi), %rcx
leaq 0x8(%rcx), %rdx
testq %rcx, %rcx
leaq 0xd2cf(%rip), %rcx      # 0x102b0
cmovneq %rdx, %rcx
movq %rax, (%rcx)
movq 0xd2b9(%rip), %rax      # 0x102a8
testq %rax, %rax
je 0x2ff7
movq %rdi, (%rax)
movq 0xd2aa(%rip), %rax      # 0x102a8
movq %rax, 0x8(%rdi)
movq $0x0, (%rdi)
movl $0x0, 0x10(%rdi)
movq $0x1, 0x20(%rdi)
movq %rdi, 0xd289(%rip)      # 0x102a8
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b3
movsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b3
movq (%rbx), %r14
movsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rbx), %r15
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x3080
leaq 0x608f(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movsd 0x10(%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
movq %r14, (%rbx)
movsd %xmm0, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movq 0xd291(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xd287(%rip)      # 0x10330
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
callq 0x2e41
cmpl $0x0, 0x10(%rbx)
je 0x30d4
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rdi
callq 0x20c0
movsd %xmm0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b3
movsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b3
movq (%rbx), %r14
movsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rbx), %r15
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x3140
leaq 0x5fcf(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movsd 0x8(%rsp), %xmm0
subsd 0x10(%rsp), %xmm0
movq %r14, (%rbx)
movsd %xmm0, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movq 0xd1d1(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xd1c7(%rip)      # 0x10330
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b3
movsd 0x8(%rbx), %xmm1
xorpd %xmm0, %xmm0
movsd %xmm1, 0x10(%rsp)
ucomisd %xmm0, %xmm1
jne 0x3241
jp 0x3241
leaq 0x5f2a(%rip), %rdi      # 0x9164
xorl %eax, %eax
callq 0x27e6
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b3
movq (%rbx), %r14
movsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rbx), %r15
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x3280
leaq 0x5e8f(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movsd 0x8(%rsp), %xmm0
divsd 0x10(%rsp), %xmm0
movq %r14, (%rbx)
movsd %xmm0, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movq 0xd091(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xd087(%rip)      # 0x10330
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b3
movsd 0x8(%rbx), %xmm1
xorpd %xmm0, %xmm0
movsd %xmm1, (%rsp)
ucomisd %xmm0, %xmm1
jne 0x32ed
jp 0x32ed
leaq 0x5e8f(%rip), %rdi      # 0x9175
xorl %eax, %eax
callq 0x27e6
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b3
movq (%rbx), %r14
movsd 0x8(%rbx), %xmm0
movq 0x10(%rbx), %r15
movsd (%rsp), %xmm1
callq 0x2140
movsd %xmm0, (%rsp)
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x3335
leaq 0x5dda(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movq %r14, (%rbx)
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movq 0xcfe3(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xcfd9(%rip)      # 0x10330
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/phillbush[P]hoc/code.c
// Function: negate
void
negate(void)
{
	Datum d;

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b3
movq (%rbx), %r14
movsd 0x8(%rbx), %xmm0
movaps %xmm0, (%rsp)
movq 0x10(%rbx), %r15
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x33a7
leaq 0x5d68(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movaps (%rsp), %xmm0
xorps 0x5c9e(%rip), %xmm0     # 0x9050
movq %r14, (%rbx)
movlps %xmm0, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movq 0xcf6c(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xcf62(%rip)      # 0x10330
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b3
movsd 0x8(%rbx), %xmm0
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b3
movq (%rbx), %r14
movsd 0x8(%rbx), %xmm0
movq 0x10(%rbx), %r15
movsd (%rsp), %xmm1
callq 0x20d0
movsd %xmm0, (%rsp)
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x3440
leaq 0x5ccf(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movq %r14, (%rbx)
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movq 0xced8(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xcece(%rip)      # 0x10330
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x30b3
movq (%rbx), %r14
movq 0x8(%rbx), %rax
movq %rax, (%rsp)
cvttsd2si (%rsp), %eax
testl %eax, %eax
js 0x34bd
cmpl %eax, 0xce19(%rip)      # 0x102b8
jle 0x34bd
movl %eax, %eax
leaq (%rax,%rax,4), %rax
shlq $0x3, %rax
addq 0xce0e(%rip), %rax      # 0x102c0
movq %rax, (%rsp)
movl $0x1, %ebp
jmp 0x34c7
movq $0x0, (%rsp)
xorl %ebp, %ebp
movl 0x1c(%rsp), %r15d
movq (%rsp), %r12
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x34f0
leaq 0x5c1f(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movq %r14, (%rbx)
movq %r12, 0x8(%rbx)
movl %ebp, 0x10(%rbx)
movl %r15d, 0x14(%rbx)
movq 0xce2b(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xce21(%rip)      # 0x10330
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcdc1(%rip), %rax      # 0x102e8
movq (%rax), %rcx
movq 0x10(%rax), %rax
movq %rcx, 0xcdb3(%rip)      # 0x102e8
movq 0xcde4(%rip), %r14      # 0x10320
movq 0x8(%rax), %rbx
testq %r14, %r14
je 0x355a
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x21b0
testl %eax, %eax
je 0x355d
movq (%r14), %r14
jmp 0x3540
xorl %r14d, %r14d
testq %r14, %r14
jne 0x358b
movq 0xcdbf(%rip), %r14      # 0x10328
testq %r14, %r14
je 0x3583
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x21b0
testl %eax, %eax
je 0x3586
movq (%r14), %r14
jmp 0x3569
xorl %r14d, %r14d
testq %r14, %r14
je 0x35d0
movl 0x18(%r14), %ebp
movq 0x8(%r14), %r14
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x35b3
leaq 0x5b5c(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movq %r14, 0x8(%rbx)
movl %ebp, 0x10(%rbx)
movq 0xcd6f(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xcd65(%rip)      # 0x10330
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x5bad(%rip), %rdi      # 0x9184
movq %rbx, %rsi
xorl %eax, %eax
callq 0x27e6
// File: /workspace/github_c_makefile_star2_O1/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 0x3651
movsd 0x8(%rax), %xmm0
addsd 0x5a63(%rip), %xmm0     # 0x9060
movsd %xmm0, 0x8(%rsp)
movsd %xmm0, 0x8(%rax)
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x3628
leaq 0x5ae7(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
movq 0xccef(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xcce5(%rip)      # 0x10330
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcc86(%rip), %rax      # 0x102e8
movq (%rax), %rcx
movq 0x10(%rax), %r12
movq %rcx, 0xcc78(%rip)      # 0x102e8
testl %edi, %edi
je 0x3692
cmpl $0x107, 0x10(%r12)      # imm = 0x107
jne 0x3692
movq 0x8(%r12), %rsi
leaq 0x5dba(%rip), %rdi      # 0x9445
xorl %eax, %eax
callq 0x27e6
movl 0x10(%r12), %eax
orl $0x2, %eax
cmpl $0x107, %eax            # imm = 0x107
je 0x36b4
movq 0x8(%r12), %rsi
leaq 0x5daf(%rip), %rdi      # 0x945c
xorl %eax, %eax
callq 0x27e6
movq 0xcc65(%rip), %r14      # 0x10320
movq 0x8(%r12), %r15
testq %r14, %r14
je 0x36da
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x21b0
testl %eax, %eax
je 0x36dd
movq (%r14), %r14
jmp 0x36c0
xorl %r14d, %r14d
testq %r14, %r14
jne 0x3727
movq 0xcc3f(%rip), %r14      # 0x10328
testq %r14, %r14
je 0x3703
movq 0x10(%r14), %rdi
movq %r15, %rsi
callq 0x21b0
testl %eax, %eax
je 0x3706
movq (%r14), %r14
jmp 0x36e9
xorl %r14d, %r14d
testq %r14, %r14
jne 0x3727
movq %r15, %rdi
callq 0x51ba
movq %rax, %r14
movq 0xcc0b(%rip), %rax      # 0x10328
movq %rax, (%r14)
movq %r14, 0xcc01(%rip)      # 0x10328
movl $0x105, 0x10(%r12)      # imm = 0x105
testl %ebx, %ebx
je 0x3768
cmpl $0x0, 0x18(%r14)
je 0x3768
movq 0x8(%r14), %rbx
movq 0x18(%rbx), %rdi
callq 0x20c0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x3971
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_O1/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 0x3651
movsd 0x8(%rax), %xmm0
addsd 0x58d5(%rip), %xmm0     # 0x9068
movsd %xmm0, 0x8(%rsp)
movsd %xmm0, 0x8(%rax)
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x37be
leaq 0x5951(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
movq 0xcb59(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xcb4f(%rip)      # 0x10330
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3651
movsd 0x8(%rax), %xmm1
movsd 0x585d(%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 0x3832
leaq 0x58dd(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
movq 0xcae5(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xcadb(%rip)      # 0x10330
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3651
movsd 0x8(%rax), %xmm1
movsd 0x57f1(%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 0x38a6
leaq 0x5869(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
movq 0xca71(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xca67(%rip)      # 0x10330
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2e41
movq (%r14), %r15
movq 0x8(%r14), %rbx
movl 0x10(%r14), %ebp
movl 0x14(%r14), %r12d
xorl %edi, %edi
callq 0x3651
movq %rax, %r14
cmpl $0x0, 0x18(%rax)
je 0x3910
movq 0x8(%r14), %rdi
callq 0x3971
testl %ebp, %ebp
je 0x391c
movq %rbx, %rdi
callq 0x2fb0
movq %rbx, 0x8(%r14)
movl %ebp, 0x18(%r14)
movl $0x18, %edi
callq 0x2230
movq %rax, %r14
testq %rax, %rax
jne 0x3944
leaq 0x57cb(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movq %r15, (%r14)
movq %rbx, 0x8(%r14)
movl %ebp, 0x10(%r14)
movl %r12d, 0x14(%r14)
movq 0xc9d6(%rip), %rax      # 0x10330
movq %rax, (%r14)
movq %r14, 0xc9cc(%rip)      # 0x10330
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x398c
movq %rdi, %rbx
movq 0x20(%rdi), %rax
cmpq $0x2, %rax
jb 0x398e
decq %rax
movq %rax, 0x20(%rbx)
popq %rbx
retq
movq 0x18(%rbx), %rdi
callq 0x2030
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x39a6
movq (%rbx), %rcx
movq %rcx, (%rax)
movq (%rbx), %rcx
leaq 0x8(%rcx), %rdx
testq %rcx, %rcx
leaq 0xc8f1(%rip), %rcx      # 0x102a8
cmovneq %rdx, %rcx
movq %rax, (%rcx)
movq %rbx, %rdi
popq %rbx
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b3
movq (%rbx), %r14
movsd 0x8(%rbx), %xmm0
movsd %xmm0, (%rsp)
movq 0x10(%rbx), %r15
movl $0x1, %edi
callq 0x3651
movsd (%rsp), %xmm0
addsd 0x8(%rax), %xmm0
movsd %xmm0, (%rsp)
movsd %xmm0, 0x8(%rax)
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x3a2c
leaq 0x56e3(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movq %r14, (%rbx)
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movq 0xc8ec(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xc8e2(%rip)      # 0x10330
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b3
movq (%rbx), %r14
movsd 0x8(%rbx), %xmm0
movsd %xmm0, (%rsp)
movq 0x10(%rbx), %r15
movl $0x1, %edi
callq 0x3651
movsd 0x8(%rax), %xmm0
subsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd %xmm0, 0x8(%rax)
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x3abd
leaq 0x5652(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movq %r14, (%rbx)
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movq 0xc85b(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xc851(%rip)      # 0x10330
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b3
movq (%rbx), %r14
movsd 0x8(%rbx), %xmm0
movsd %xmm0, (%rsp)
movq 0x10(%rbx), %r15
movl $0x1, %edi
callq 0x3651
movq %rax, %rbx
movsd 0x8(%rax), %xmm0
movsd (%rsp), %xmm1
callq 0x2140
movsd %xmm0, (%rsp)
movsd %xmm0, 0x8(%rbx)
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x3c78
leaq 0x5497(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movq %r14, (%rbx)
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movq 0xc6a0(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xc696(%rip)      # 0x10330
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x2e41
movq (%r14), %r15
movq 0x8(%r14), %rbx
movl 0x10(%r14), %ebp
movl 0x14(%r14), %r12d
movq %rbx, (%r14)
testl %ebp, %ebp
je 0x3ce7
movq 0x18(%rbx), %rsi
leaq 0x545c(%rip), %rdi      # 0x913a
xorl %eax, %eax
callq 0x2110
jmp 0x3cfb
movsd 0x8(%rsp), %xmm0
leaq 0x543c(%rip), %rdi      # 0x9130
movb $0x1, %al
callq 0x2110
movl $0xa, %edi
callq 0x2040
cmpl $0x0, 0xc63c(%rip)      # 0x10348
je 0x3d1a
movq 0xc62b(%rip), %rdi      # 0x10340
callq 0x3971
testl %ebp, %ebp
je 0x3d26
movq %rbx, %rdi
callq 0x2fb0
movq %r15, 0xc60b(%rip)      # 0x10338
movq %rbx, 0xc60c(%rip)      # 0x10340
movl %ebp, 0xc60e(%rip)      # 0x10348
movl %r12d, 0xc60b(%rip)     # 0x1034c
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3de7
testq %rax, %rax
je 0x3ddf
movq %rax, %rbx
movq %rax, %r14
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
callq 0x3d4e
cmpq $0x0, (%r14)
movl $0xa, %edi
je 0x3dbf
movl $0x20, %edi
callq 0x2040
movq (%r14), %r14
testq %r14, %r14
jne 0x3d99
movq (%rbx), %r14
movq %rbx, %rdi
callq 0x2030
movq %r14, %rbx
testq %r14, %r14
jne 0x3dcc
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc4f2(%rip), %rax      # 0x102e8
movl 0x10(%rax), %r14d
movq (%rax), %rax
movq %rax, 0xc4e4(%rip)      # 0x102e8
testl %r14d, %r14d
jle 0x3e65
leaq 0x5625(%rip), %rbx      # 0x9435
xorl %r15d, %r15d
cmpq $0x0, 0xc515(%rip)      # 0x10330
jne 0x3e3f
testq %r15, %r15
je 0x3e35
movq %r15, %rdi
movq (%rdi), %r12
callq 0x2030
movq %r12, %rdi
testq %r12, %r12
jne 0x3e25
movq %rbx, %rdi
xorl %eax, %eax
callq 0x27e6
leal -0x1(%r14), %ecx
movq 0xc4e6(%rip), %rax      # 0x10330
movq (%rax), %rdx
movq %rdx, 0xc4dc(%rip)      # 0x10330
movq %r15, (%rax)
movq %rax, %r15
cmpl $0x1, %r14d
movl %ecx, %r14d
jg 0x3e13
jmp 0x3e67
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3de7
testq %rax, %rax
je 0x3efc
movq %rax, %rbx
cmpl $0x0, 0x10(%rax)
je 0x3ed6
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rdi
callq 0x3f08
testq %rax, %rax
je 0x3ee4
movq %rax, %r14
leaq 0x5291(%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 0x3ebb
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x52c2(%rip), %rdi      # 0x919f
xorl %eax, %eax
callq 0x2722
testq %rbx, %rbx
je 0x3efc
movq (%rbx), %r14
movq %rbx, %rdi
callq 0x2030
movq %r14, %rbx
testq %r14, %r14
jne 0x3ee9
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2710
// File: /workspace/github_c_makefile_star2_O1/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 0x3de7
testq %rax, %rax
je 0x42a2
movq %rax, %rbx
cmpl $0x0, 0x10(%rax)
je 0x4273
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rdi
callq 0x3f08
testq %rax, %rax
je 0x428a
movq %rax, %rdi
xorl %esi, %esi
callq 0x29b4
testq %rax, %rax
je 0x427c
movq %rax, %r14
movq (%rbx), %r15
movq %rbx, %rdi
callq 0x2030
movq %r15, %rbx
testq %r15, %r15
jne 0x421e
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x4251
leaq 0x4ebe(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movq %r14, 0x8(%rbx)
movl $0x1, 0x10(%rbx)
movq 0xc0cd(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xc0c3(%rip)      # 0x10330
popq %rbx
popq %r14
popq %r15
retq
leaq 0x4f25(%rip), %rdi      # 0x919f
jmp 0x4283
leaq 0x4e85(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x2722
testq %rbx, %rbx
je 0x42a2
movq (%rbx), %r14
movq %rbx, %rdi
callq 0x2030
movq %r14, %rbx
testq %r14, %r14
jne 0x428f
popq %rbx
popq %r14
popq %r15
jmp 0x2710
// File: /workspace/github_c_makefile_star2_O1/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 0x3651
movq %rax, %rbx
leaq 0x4ef0(%rip), %rdi      # 0x91b2
leaq 0x8(%rsp), %rsi
xorl %eax, %eax
callq 0x2280
cmpl $-0x1, %eax
je 0x42eb
testl %eax, %eax
jne 0x42f0
movq 0x10(%rbx), %rsi
leaq 0x4ed4(%rip), %rdi      # 0x91b6
xorl %eax, %eax
callq 0x27e6
jmp 0x430f
xorps %xmm0, %xmm0
jmp 0x430a
movl $0x0, 0x18(%rbx)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movsd 0x4d56(%rip), %xmm0     # 0x9060
movsd %xmm0, (%rsp)
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x432f
leaq 0x4de0(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
movq 0xbfe9(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xbfdf(%rip)      # 0x10330
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x2018, %rsp           # imm = 0x2018
xorl %edi, %edi
callq 0x3651
movq %rax, %rbx
movq 0x9c56(%rip), %rax      # 0xdfc8
movq (%rax), %rdx
leaq 0x10(%rsp), %rdi
movl $0x2000, %esi           # imm = 0x2000
callq 0x2190
testq %rax, %rax
je 0x43cb
leaq 0x10(%rsp), %rdi
callq 0x22c0
movq %rax, %r14
testq %rax, %rax
jne 0x43a9
leaq 0x4d66(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movl $0x1, 0x18(%rbx)
movq %r14, %rdi
movl $0x1, %esi
callq 0x29b4
movq %rax, 0x8(%rbx)
movsd 0x4c97(%rip), %xmm0     # 0x9060
jmp 0x43ce
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x43f4
leaq 0x4d1b(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
movq 0xbf23(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xbf19(%rip)      # 0x10330
addq $0x2018, %rsp           # imm = 0x2018
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b3
movsd 0x8(%rbx), %xmm0
movaps %xmm0, 0x10(%rsp)
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b3
movq (%rbx), %r14
movsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rbx), %r15
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x4481
leaq 0x4c8e(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movapd 0x10(%rsp), %xmm1
cmpltsd 0x8(%rsp), %xmm1
movsd 0x4bca(%rip), %xmm0     # 0x9060
andpd %xmm1, %xmm0
movq %r14, (%rbx)
movlpd %xmm0, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movq 0xbe83(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xbe79(%rip)      # 0x10330
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b3
movsd 0x8(%rbx), %xmm0
movaps %xmm0, 0x10(%rsp)
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b3
movq (%rbx), %r14
movsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rbx), %r15
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x4520
leaq 0x4bef(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movapd 0x10(%rsp), %xmm1
cmplesd 0x8(%rsp), %xmm1
movsd 0x4b2b(%rip), %xmm0     # 0x9060
andpd %xmm1, %xmm0
movq %r14, (%rbx)
movlpd %xmm0, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movq 0xbde4(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xbdda(%rip)      # 0x10330
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b3
movsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b3
movq (%rbx), %r14
movsd 0x8(%rbx), %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x10(%rbx), %r15
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x45bf
leaq 0x4b50(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movapd 0x10(%rsp), %xmm1
cmpltsd 0x8(%rsp), %xmm1
movsd 0x4a8c(%rip), %xmm0     # 0x9060
andpd %xmm1, %xmm0
movq %r14, (%rbx)
movlpd %xmm0, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movq 0xbd45(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xbd3b(%rip)      # 0x10330
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b3
movsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b3
movq (%rbx), %r14
movsd 0x8(%rbx), %xmm0
movaps %xmm0, 0x10(%rsp)
movq 0x10(%rbx), %r15
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x46fd
leaq 0x4a12(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
movapd 0x10(%rsp), %xmm1
cmpeqsd 0x8(%rsp), %xmm1
movsd 0x494e(%rip), %xmm0     # 0x9060
andpd %xmm1, %xmm0
movq %r14, (%rbx)
movlpd %xmm0, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movq 0xbc07(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xbbfd(%rip)      # 0x10330
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b3
movq (%rbx), %r14
movsd 0x8(%rbx), %xmm0
movapd %xmm0, (%rsp)
movq 0x10(%rbx), %r15
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x4823
leaq 0x48ec(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
xorpd %xmm0, %xmm0
movapd (%rsp), %xmm1
cmpeqsd %xmm0, %xmm1
movsd 0x4827(%rip), %xmm0     # 0x9060
andpd %xmm1, %xmm0
movq %r14, (%rbx)
movlpd %xmm0, 0x8(%rbx)
movq %r15, 0x10(%rbx)
movq 0xbae0(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xbad6(%rip)      # 0x10330
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x28, %rsp
movq 0xba72(%rip), %r14      # 0x102e8
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b3
movsd 0x8(%rbx), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x4894
jnp 0x48bd
movq 0x10(%r14), %rdi
callq 0x2d73
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b3
movq (%rbx), %r15
movsd 0x8(%rbx), %xmm0
movapd %xmm0, (%rsp)
movq 0x10(%rbx), %r12
jmp 0x48cc
movapd %xmm1, (%rsp)
movq 0x10(%rsp), %r15
movq 0x20(%rsp), %r12
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x48ec
leaq 0x4823(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
xorpd %xmm0, %xmm0
movapd (%rsp), %xmm1
cmpneqsd %xmm0, %xmm1
movsd 0x475e(%rip), %xmm0     # 0x9060
andpd %xmm1, %xmm0
movq %r15, (%rbx)
movlpd %xmm0, 0x8(%rbx)
movq %r12, 0x10(%rbx)
movq 0xba17(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xba0d(%rip)      # 0x10330
movq (%r14), %rax
movq 0x10(%rax), %rax
movq %rax, 0xb9b7(%rip)      # 0x102e8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x28, %rsp
movq 0xb999(%rip), %r14      # 0x102e8
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b3
movsd 0x8(%rbx), %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x496d
jnp 0x497e
movapd %xmm1, (%rsp)
movq 0x10(%rsp), %r15
movq 0x20(%rsp), %r12
jmp 0x49a5
movq 0x10(%r14), %rdi
callq 0x2d73
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x30b3
movq (%rbx), %r15
movsd 0x8(%rbx), %xmm0
movapd %xmm0, (%rsp)
movq 0x10(%rbx), %r12
movl $0x18, %edi
callq 0x2230
movq %rax, %rbx
testq %rax, %rax
jne 0x49c5
leaq 0x474a(%rip), %rdi      # 0x9108
xorl %eax, %eax
callq 0x27e6
xorpd %xmm0, %xmm0
movapd (%rsp), %xmm1
cmpneqsd %xmm0, %xmm1
movsd 0x4685(%rip), %xmm0     # 0x9060
andpd %xmm1, %xmm0
movq %r15, (%rbx)
movlpd %xmm0, 0x8(%rbx)
movq %r12, 0x10(%rbx)
movq 0xb93e(%rip), %rax      # 0x10330
movq %rax, (%rbx)
movq %rbx, 0xb934(%rip)      # 0x10330
movq (%r14), %rax
movq 0x10(%rax), %rax
movq %rax, 0xb8de(%rip)      # 0x102e8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb8c4(%rip), %r14      # 0x102e8
movq (%r14), %rax
movq (%rax), %rax
movq (%rax), %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x4a82
movsd 0x8(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4a49
jnp 0x4a4f
movq 0x10(%r14), %rdi
jmp 0x4a5b
movq (%r14), %rax
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0x4a60
callq 0x2d73
cmpb $0x0, 0xb8a9(%rip)      # 0x10310
jne 0x4a7a
movq (%r14), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0xb86e(%rip)      # 0x102e8
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x4aa4
cmpq $0x0, 0x10(%rsi)
je 0x4aa4
movq %rsi, %rdi
callq 0x2d73
movq %rbx, %rdi
callq 0x30b3
jmp 0x4aac
movq $0x0, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/phillbush[P]hoc/code.c
// Function: docode
void
docode(void)
{
	Inst *savepc;

	savepc = prog.pc;
	do {
		execute(N2(savepc));
		if (returning) {
			break;
		}
		if (continuing) {
			continuing = 0;
			continue;
		}
		if (breaking) {
			breaking = 0;
			break;
		}
	} while (cond(savepc->u.ip));
	if (!returning)
		prog.pc = N1(savepc)->u.ip;
}

// Assembly:
pushq %rbx
movq 0xb82f(%rip), %rbx      # 0x102e8
movq (%rbx), %rax
movq (%rax), %rdi
callq 0x2d73
cmpb $0x0, 0xb845(%rip)      # 0x10310
jne 0x4b06
cmpb $0x1, 0xb844(%rip)      # 0x10318
jne 0x4adf
movb $0x0, 0xb83b(%rip)      # 0x10318
jmp 0x4ae8
cmpb $0x1, 0xb82e(%rip)      # 0x10314
je 0x4aff
movq 0x10(%rbx), %rdi
callq 0x4b1f
ucomisd 0x4577(%rip), %xmm0     # 0x9070
jne 0x4ab9
jp 0x4ab9
jmp 0x4b06
movb $0x0, 0xb80e(%rip)      # 0x10314
cmpb $0x0, 0xb803(%rip)      # 0x10310
jne 0x4b1d
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0xb7cb(%rip)      # 0x102e8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/phillbush[P]hoc/code.c
// Function: whilecode
void
whilecode(void)
{
	Inst *savepc;

	savepc = prog.pc;
	while (cond(N2(savepc))) {
		execute(savepc->u.ip);
		if (returning) {
			break;
		}
		if (continuing) {
			continuing = 0;
			continue;
		}
		if (breaking) {
			breaking = 0;
			break;
		}
	}
	if (!returning)
		prog.pc = N1(savepc)->u.ip;
}

// Assembly:
pushq %rbx
movq 0xb791(%rip), %rbx      # 0x102e8
movq (%rbx), %rax
movq (%rax), %rdi
callq 0x4b1f
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4b6e
jnp 0x4bb7
movq 0x10(%rbx), %rdi
callq 0x2d73
cmpb $0x0, 0xb792(%rip)      # 0x10310
jne 0x4bb7
cmpb $0x1, 0xb791(%rip)      # 0x10318
jne 0x4b92
movb $0x0, 0xb788(%rip)      # 0x10318
jmp 0x4b9b
cmpb $0x1, 0xb77b(%rip)      # 0x10314
je 0x4bb0
movq (%rbx), %rax
movq (%rax), %rdi
callq 0x4b1f
ucomisd 0x44c2(%rip), %xmm0     # 0x9070
jmp 0x4b6a
movb $0x0, 0xb75d(%rip)      # 0x10314
cmpb $0x0, 0xb752(%rip)      # 0x10310
jne 0x4bce
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0xb71a(%rip)      # 0x102e8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/phillbush[P]hoc/code.c
// Function: forcode
void
forcode(void)
{
	Inst *savepc;

	savepc = prog.pc;
	for ((void)execpop(N4(savepc)); cond(savepc->u.ip); (void)execpop(N1(savepc)->u.ip)) {
		execute(N2(savepc)->u.ip);
		if (returning) {
			break;
		}
		if (continuing) {
			continuing = 0;
			continue;
		}
		if (breaking) {
			breaking = 0;
			break;
		}
	}
	if (!returning)
		prog.pc = N3(savepc)->u.ip;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq 0xb70a(%rip), %r14      # 0x102e8
movq (%r14), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rsi
movq %rsp, %rdi
callq 0x4a82
movq 0x10(%r14), %rdi
callq 0x4b1f
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x4c07
jnp 0x4c6a
movq %rsp, %rbx
movq (%r14), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
callq 0x2d73
cmpb $0x0, 0xb6f0(%rip)      # 0x10310
jne 0x4c6a
cmpb $0x1, 0xb6ef(%rip)      # 0x10318
jne 0x4c34
movb $0x0, 0xb6e6(%rip)      # 0x10318
jmp 0x4c3d
cmpb $0x1, 0xb6d9(%rip)      # 0x10314
je 0x4c63
movq (%r14), %rax
movq 0x10(%rax), %rsi
movq %rbx, %rdi
callq 0x4a82
movq 0x10(%r14), %rdi
callq 0x4b1f
ucomisd 0x4413(%rip), %xmm0     # 0x9070
jne 0x4c0a
jp 0x4c0a
jmp 0x4c6a
movb $0x0, 0xb6aa(%rip)      # 0x10314
cmpb $0x0, 0xb69f(%rip)      # 0x10310
jne 0x4c87
movq (%r14), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0xb661(%rip)      # 0x102e8
addq $0x18, %rsp
popq %rbx
popq %r14
retq