LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2efc
movsd 0x8(%rbx), %xmm1
xorpd %xmm0, %xmm0
movsd %xmm1, (%rsp)
ucomisd %xmm0, %xmm1
jne 0x30b9
jp 0x30b9
leaq 0x60bb(%rip), %rdi      # 0x916d
xorl %eax, %eax
callq 0x2625
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2efc
movsd 0x8(%rbx), %xmm0
movq 0x10(%rbx), %rbx
movsd (%rsp), %xmm1
callq 0x2140
movsd %xmm0, (%rsp)
pushq $0x18
popq %rdi
callq 0x275c
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq 0xd235(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xd22b(%rip)      # 0x10330
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2efc
movq 0x10(%rbx), %r14
movsd 0x8(%rbx), %xmm0
xorps 0x5fa1(%rip), %xmm0     # 0x90d0
movaps %xmm0, (%rsp)
pushq $0x18
popq %rdi
callq 0x275c
movaps (%rsp), %xmm0
movlps %xmm0, 0x8(%rax)
movq %r14, 0x10(%rax)
movq 0xd1e2(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xd1d8(%rip)      # 0x10330
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2efc
movsd 0x8(%rbx), %xmm0
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2efc
movsd 0x8(%rbx), %xmm0
movq 0x10(%rbx), %rbx
movsd (%rsp), %xmm1
callq 0x20d0
movsd %xmm0, (%rsp)
pushq $0x18
popq %rdi
callq 0x275c
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq 0xd172(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xd168(%rip)      # 0x10330
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2efc
cvttsd2si 0x8(%rbx), %eax
testl %eax, %eax
setns %cl
cmpl %eax, 0xd0c5(%rip)      # 0x102b8
movl 0x14(%rbx), %ebx
setg %dl
andb %cl, %dl
movl %eax, %eax
imulq $0x28, %rax, %rax
addq 0xd0b8(%rip), %rax      # 0x102c0
xorl %r14d, %r14d
testb %dl, %dl
cmovneq %rax, %r14
movzbl %dl, %ebp
pushq $0x18
popq %rdi
callq 0x275c
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
movl %ebx, 0x14(%rax)
movq 0xd103(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xd0f9(%rip)      # 0x10330
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq 0xd09d(%rip), %rax      # 0x102e8
movq (%rax), %rcx
movq 0x10(%rax), %rax
movq %rcx, 0xd08f(%rip)      # 0x102e8
movq 0xd0c0(%rip), %rdi      # 0x10320
movq 0x8(%rax), %rbx
movq %rbx, %rsi
callq 0x32c5
testq %rax, %rax
jne 0x3285
movq 0xd0b0(%rip), %rdi      # 0x10328
movq %rbx, %rsi
callq 0x32c5
testq %rax, %rax
je 0x32b4
movl 0x18(%rax), %ebx
movq 0x8(%rax), %r14
pushq $0x18
popq %rdi
callq 0x275c
movq %r14, 0x8(%rax)
movl %ebx, 0x10(%rax)
movq 0xd08e(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xd084(%rip)      # 0x10330
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5ec1(%rip), %rdi      # 0x917c
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2625
// File: /workspace/github_c_makefile_star2_O2/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 %rax
pushq $0x1
popq %rdi
callq 0x333d
movsd 0x8(%rax), %xmm0
addsd 0x5dd6(%rip), %xmm0     # 0x90e0
movsd %xmm0, (%rsp)
movsd %xmm0, 0x8(%rax)
pushq $0x18
popq %rdi
callq 0x275c
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
andl $0x0, 0x10(%rax)
movq 0xcfff(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xcff5(%rip)      # 0x10330
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xcf9a(%rip), %rax      # 0x102e8
movq (%rax), %rcx
movq 0x10(%rax), %r12
movq %rcx, 0xcf8c(%rip)      # 0x102e8
testl %edi, %edi
je 0x337e
cmpl $0x107, 0x10(%r12)      # imm = 0x107
jne 0x337e
movq 0x8(%r12), %rsi
leaq 0x60c6(%rip), %rdi      # 0x943d
xorl %eax, %eax
callq 0x2625
movl 0x10(%r12), %eax
orl $0x2, %eax
cmpl $0x107, %eax            # imm = 0x107
je 0x33a0
movq 0x8(%r12), %rsi
leaq 0x60bb(%rip), %rdi      # 0x9454
xorl %eax, %eax
callq 0x2625
movq 0xcf79(%rip), %rdi      # 0x10320
movq 0x8(%r12), %r15
movq %r15, %rsi
callq 0x32c5
testq %rax, %rax
jne 0x33cd
movq 0xcf68(%rip), %rdi      # 0x10328
movq %r15, %rsi
callq 0x32c5
testq %rax, %rax
je 0x341d
movq %rax, %r14
movl $0x105, 0x10(%r12)      # imm = 0x105
testl %ebx, %ebx
je 0x340e
cmpl $0x0, 0x18(%r14)
je 0x340e
movq 0x8(%r14), %rbx
movq 0x18(%rbx), %rdi
callq 0x20c0
movsd %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x35a5
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%r14)
andl $0x0, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0x49e0
movq %rax, %r14
movq 0xcef9(%rip), %rax      # 0x10328
movq %rax, (%r14)
movq %r14, 0xceef(%rip)      # 0x10328
jmp 0x33d0
// File: /workspace/github_c_makefile_star2_O2/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 %rax
pushq $0x1
popq %rdi
callq 0x333d
movsd 0x8(%rax), %xmm0
addsd 0x5c97(%rip), %xmm0     # 0x90e8
movsd %xmm0, (%rsp)
movsd %xmm0, 0x8(%rax)
pushq $0x18
popq %rdi
callq 0x275c
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
andl $0x0, 0x10(%rax)
movq 0xceb8(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xceae(%rip)      # 0x10330
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
pushq $0x1
popq %rdi
callq 0x333d
movsd 0x8(%rax), %xmm1
movsd %xmm1, (%rsp)
movsd 0x5c41(%rip), %xmm0     # 0x90e0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
pushq $0x18
popq %rdi
callq 0x275c
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
andl $0x0, 0x10(%rax)
movq 0xce6b(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xce61(%rip)      # 0x10330
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rax
pushq $0x1
popq %rdi
callq 0x333d
movsd 0x8(%rax), %xmm1
movsd %xmm1, (%rsp)
movsd 0x5bfc(%rip), %xmm0     # 0x90e8
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rax)
pushq $0x18
popq %rdi
callq 0x275c
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
andl $0x0, 0x10(%rax)
movq 0xce1e(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xce14(%rip)      # 0x10330
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2d0f
movq 0x8(%r14), %rbx
movsd 0x10(%r14), %xmm0
movaps %xmm0, (%rsp)
xorl %edi, %edi
callq 0x333d
movq %rax, %r14
cmpl $0x0, 0x18(%rax)
je 0x355a
movq 0x8(%r14), %rdi
callq 0x35a5
movdqa (%rsp), %xmm0
movd %xmm0, %ebp
testl %ebp, %ebp
je 0x356f
movq %rbx, %rdi
callq 0x2e20
movq %rbx, 0x8(%r14)
movl %ebp, 0x18(%r14)
pushq $0x18
popq %rdi
callq 0x275c
movq %rbx, 0x8(%rax)
movaps (%rsp), %xmm0
movlps %xmm0, 0x10(%rax)
movq 0xcd9e(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xcd94(%rip)      # 0x10330
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x35c0
movq %rdi, %rbx
movq 0x20(%rdi), %rax
cmpq $0x2, %rax
jb 0x35c2
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 0x35da
movq %rcx, (%rax)
leaq 0x8(%rcx), %rdx
testq %rcx, %rcx
leaq 0xccc0(%rip), %rcx      # 0x102a8
cmovneq %rdx, %rcx
movq %rax, (%rcx)
movq %rbx, %rdi
popq %rbx
jmp 0x2030
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2efc
movsd 0x8(%rbx), %xmm0
movsd %xmm0, (%rsp)
movq 0x10(%rbx), %rbx
pushq $0x1
popq %rdi
callq 0x333d
movsd (%rsp), %xmm0
addsd 0x8(%rax), %xmm0
movsd %xmm0, (%rsp)
movsd %xmm0, 0x8(%rax)
pushq $0x18
popq %rdi
callq 0x275c
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq 0xccdf(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xccd5(%rip)      # 0x10330
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x20, %rsp
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2efc
movsd 0x8(%rbx), %xmm0
movsd %xmm0, (%rsp)
movq 0x10(%rbx), %rbx
pushq $0x1
popq %rdi
callq 0x333d
movsd 0x8(%rax), %xmm0
subsd (%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd %xmm0, 0x8(%rax)
pushq $0x18
popq %rdi
callq 0x275c
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq 0xcc76(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xcc6c(%rip)      # 0x10330
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2efc
movsd 0x8(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x10(%rbx), %r14
pushq $0x1
popq %rdi
callq 0x333d
movq %rax, %rbx
movsd 0x8(%rax), %xmm0
movsd 0x8(%rsp), %xmm1
callq 0x2140
movsd %xmm0, 0x8(%rsp)
movsd %xmm0, 0x8(%rbx)
pushq $0x18
popq %rdi
callq 0x275c
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movq %r14, 0x10(%rax)
movq 0xcb2d(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xcb23(%rip)      # 0x10330
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x30, %rsp
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x2d0f
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rsp)
movups (%rbx), %xmm0
movups %xmm0, (%rsp)
callq 0x3888
pushq $0xa
popq %rdi
callq 0x2040
cmpl $0x0, 0xcafd(%rip)      # 0x10348
je 0x3859
movq 0xcaec(%rip), %rdi      # 0x10340
callq 0x35a5
cmpl $0x0, 0x28(%rsp)
je 0x386a
movq 0x20(%rsp), %rdi
callq 0x2e20
movq 0x28(%rsp), %rax
movq %rax, 0xcad2(%rip)      # 0x10348
movups 0x18(%rsp), %xmm0
movups %xmm0, 0xcab6(%rip)     # 0x10338
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
callq 0x3917
movq %rax, %rbx
pushq $0xa
popq %rbp
pushq $0x20
popq %r14
movq %rax, %r15
testq %r15, %r15
je 0x3908
movq 0x10(%r15), %rax
movq %rax, 0x10(%rsp)
movups (%r15), %xmm0
movups %xmm0, (%rsp)
callq 0x3888
cmpq $0x0, (%r15)
movl %ebp, %edi
je 0x38fe
movl %r14d, %edi
callq 0x2040
movq (%r15), %r15
jmp 0x38d8
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x397e
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
movq 0xc9c6(%rip), %rax      # 0x102e8
movl 0x10(%rax), %ebp
movq (%rax), %rax
movq %rax, 0xc9b9(%rip)      # 0x102e8
leaq 0x5af7(%rip), %rbx      # 0x942d
xorl %r14d, %r14d
testl %ebp, %ebp
jle 0x3976
movq 0xc9ec(%rip), %rax      # 0x10330
testq %rax, %rax
jne 0x3962
movq %r14, %rdi
callq 0x397e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2625
movq 0xc9ce(%rip), %rax      # 0x10330
movq (%rax), %rcx
movq %rcx, 0xc9c4(%rip)      # 0x10330
movq %r14, (%rax)
decl %ebp
movq %rax, %r14
jmp 0x3939
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3917
movq %rax, %rbx
testq %rax, %rax
je 0x39f5
cmpl $0x0, 0x10(%rbx)
je 0x39e7
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rdi
callq 0x3a09
testq %rax, %rax
je 0x39f5
movq %rax, %r14
leaq 0x5769(%rip), %rdi      # 0x9132
movq %rax, %rsi
xorl %eax, %eax
callq 0x2110
movq %r14, %rdi
callq 0x2030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x397e
leaq 0x57a9(%rip), %rdi      # 0x9197
xorl %eax, %eax
callq 0x2564
movq %rbx, %rdi
callq 0x397e
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2554
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
callq 0x3917
movq %rax, %rbx
testq %rax, %rax
je 0x3d56
cmpl $0x0, 0x10(%rbx)
je 0x3d3f
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
movq 0x18(%rax), %rdi
callq 0x3a09
testq %rax, %rax
je 0x3d56
movq %rax, %rdi
xorl %esi, %esi
callq 0x27d4
testq %rax, %rax
je 0x3d48
movq %rax, %r14
movq %rbx, %rdi
callq 0x397e
pushq $0x18
popq %rdi
callq 0x275c
movq %r14, 0x8(%rax)
movl $0x1, 0x10(%rax)
movq 0xc603(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xc5f9(%rip)      # 0x10330
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x5451(%rip), %rdi      # 0x9197
jmp 0x3d4f
leaq 0x53b1(%rip), %rdi      # 0x9100
xorl %eax, %eax
callq 0x2564
movq %rbx, %rdi
callq 0x397e
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2554
// File: /workspace/github_c_makefile_star2_O2/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 0x333d
movq %rax, %rbx
leaq 0x542a(%rip), %rdi      # 0x91aa
leaq 0x8(%rsp), %rsi
xorl %eax, %eax
callq 0x2280
cmpl $-0x1, %eax
je 0x3da9
testl %eax, %eax
jne 0x3dae
movq 0x10(%rbx), %rsi
leaq 0x540e(%rip), %rdi      # 0x91ae
xorl %eax, %eax
callq 0x2625
jmp 0x3dca
xorps %xmm0, %xmm0
jmp 0x3dc5
andl $0x0, 0x18(%rbx)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rbx)
movsd 0x531b(%rip), %xmm0     # 0x90e0
movsd %xmm0, (%rsp)
pushq $0x18
popq %rdi
callq 0x275c
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
andl $0x0, 0x10(%rax)
movq 0xc549(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xc53f(%rip)      # 0x10330
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x333d
movq %rax, %rbx
movq 0xa1b6(%rip), %rax      # 0xdfc8
movq (%rax), %rdx
leaq 0x10(%rsp), %rdi
movl $0x2000, %esi           # imm = 0x2000
callq 0x2190
testq %rax, %rax
je 0x3e69
leaq 0x10(%rsp), %rdi
callq 0x22c0
movq %rax, %r14
testq %rax, %rax
jne 0x3e49
leaq 0x52be(%rip), %rdi      # 0x9100
xorl %eax, %eax
callq 0x2625
movl $0x1, 0x18(%rbx)
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0x27d4
movq %rax, 0x8(%rbx)
movsd 0x5279(%rip), %xmm0     # 0x90e0
jmp 0x3e6c
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
pushq $0x18
popq %rdi
callq 0x275c
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
andl $0x0, 0x10(%rax)
movq 0xc4a0(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xc496(%rip)      # 0x10330
addq $0x2018, %rsp           # imm = 0x2018
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x28, %rsp
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x2efc
movsd 0x8(%rbx), %xmm0
movaps %xmm0, (%rsp)
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x2efc
movq 0x10(%rbx), %r14
movapd (%rsp), %xmm0
cmpltsd 0x8(%rbx), %xmm0
movsd 0x51fa(%rip), %xmm1     # 0x90e0
andpd %xmm0, %xmm1
movapd %xmm1, (%rsp)
pushq $0x18
popq %rdi
callq 0x275c
movaps (%rsp), %xmm0
movlps %xmm0, 0x8(%rax)
movq %r14, 0x10(%rax)
movq 0xc426(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xc41c(%rip)      # 0x10330
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x28, %rsp
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x2efc
movsd 0x8(%rbx), %xmm0
movaps %xmm0, (%rsp)
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x2efc
movq 0x10(%rbx), %r14
movapd (%rsp), %xmm0
cmplesd 0x8(%rbx), %xmm0
movsd 0x5183(%rip), %xmm1     # 0x90e0
andpd %xmm0, %xmm1
movapd %xmm1, (%rsp)
pushq $0x18
popq %rdi
callq 0x275c
movaps (%rsp), %xmm0
movlps %xmm0, 0x8(%rax)
movq %r14, 0x10(%rax)
movq 0xc3af(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xc3a5(%rip)      # 0x10330
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
subq $0x30, %rsp
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x2efc
movsd 0x8(%rbx), %xmm0
movsd %xmm0, (%rsp)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x2efc
movsd 0x8(%rbx), %xmm0
movq 0x10(%rbx), %rbx
cmpltsd (%rsp), %xmm0
movsd 0x510d(%rip), %xmm1     # 0x90e0
andpd %xmm0, %xmm1
movapd %xmm1, (%rsp)
pushq $0x18
popq %rdi
callq 0x275c
movaps (%rsp), %xmm0
movlps %xmm0, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq 0xc339(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xc32f(%rip)      # 0x10330
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 $0x28, %rsp
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x2efc
movsd 0x8(%rbx), %xmm0
movaps %xmm0, (%rsp)
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x2efc
movq 0x10(%rbx), %r14
movapd (%rsp), %xmm0
cmpeqsd 0x8(%rbx), %xmm0
movsd 0x5024(%rip), %xmm1     # 0x90e0
andpd %xmm0, %xmm1
movapd %xmm1, (%rsp)
pushq $0x18
popq %rdi
callq 0x275c
movaps (%rsp), %xmm0
movlps %xmm0, 0x8(%rax)
movq %r14, 0x10(%rax)
movq 0xc250(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xc246(%rip)      # 0x10330
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2efc
movq 0x10(%rbx), %r14
xorpd %xmm0, %xmm0
cmpeqsd 0x8(%rbx), %xmm0
movsd 0x4f4d(%rip), %xmm1     # 0x90e0
andpd %xmm0, %xmm1
movapd %xmm1, (%rsp)
pushq $0x18
popq %rdi
callq 0x275c
movaps (%rsp), %xmm0
movlps %xmm0, 0x8(%rax)
movq %r14, 0x10(%rax)
movq 0xc179(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xc16f(%rip)      # 0x10330
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq 0xc111(%rip), %r14      # 0x102e8
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x2efc
movsd 0x8(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x41f5
jnp 0x421a
movq 0x10(%r14), %rdi
callq 0x2c63
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x2efc
xorpd %xmm1, %xmm1
movsd 0x8(%rbx), %xmm0
movq 0x10(%rbx), %rbx
jmp 0x421f
movq 0x20(%rsp), %rbx
cmpneqsd %xmm1, %xmm0
movsd 0x4eb4(%rip), %xmm1     # 0x90e0
andpd %xmm0, %xmm1
movapd %xmm1, (%rsp)
pushq $0x18
popq %rdi
callq 0x275c
movaps (%rsp), %xmm0
movlps %xmm0, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq 0xc0e0(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xc0d6(%rip)      # 0x10330
movq (%r14), %rax
movq 0x10(%rax), %rax
movq %rax, 0xc080(%rip)      # 0x102e8
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq 0xc06a(%rip), %r14      # 0x102e8
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x2efc
movsd 0x8(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x429c
jnp 0x42a3
movq 0x20(%rsp), %rbx
jmp 0x42c6
movq 0x10(%r14), %rdi
callq 0x2c63
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x2efc
xorpd %xmm1, %xmm1
movsd 0x8(%rbx), %xmm0
movq 0x10(%rbx), %rbx
cmpneqsd %xmm1, %xmm0
movsd 0x4e0d(%rip), %xmm1     # 0x90e0
andpd %xmm0, %xmm1
movapd %xmm1, (%rsp)
pushq $0x18
popq %rdi
callq 0x275c
movaps (%rsp), %xmm0
movlps %xmm0, 0x8(%rax)
movq %rbx, 0x10(%rax)
movq 0xc039(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xc02f(%rip)      # 0x10330
movq (%r14), %rax
movq 0x10(%rax), %rax
movq %rax, 0xbfd9(%rip)      # 0x102e8
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xbfc3(%rip), %r14      # 0x102e8
movq (%r14), %rax
movq (%rax), %rax
movq (%rax), %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x4383
movsd 0x8(%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x434a
jnp 0x4350
movq 0x10(%r14), %rdi
jmp 0x435c
movq (%r14), %rax
movq 0x10(%rax), %rdi
testq %rdi, %rdi
je 0x4361
callq 0x2c63
cmpb $0x0, 0xbfa8(%rip)      # 0x10310
jne 0x437b
movq (%r14), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0xbf6d(%rip)      # 0x102e8
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x43a5
cmpq $0x0, 0x10(%rsi)
je 0x43a5
movq %rsi, %rdi
callq 0x2c63
movq %rbx, %rdi
callq 0x2efc
jmp 0x43aa
andq $0x0, 0x8(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xbf31(%rip), %rbx      # 0x102e8
movq (%rbx), %rax
movq (%rax), %rdi
callq 0x2c63
cmpb $0x0, 0xbf47(%rip)      # 0x10310
jne 0x441b
cmpb $0x1, 0xbf46(%rip)      # 0x10318
jne 0x43dd
movb $0x0, 0xbf3d(%rip)      # 0x10318
jmp 0x43e6
cmpb $0x1, 0xbf30(%rip)      # 0x10314
je 0x4406
movq 0x10(%rbx), %rdi
callq 0x441d
ucomisd 0x4cf9(%rip), %xmm0     # 0x90f0
jne 0x43b7
jp 0x43b7
cmpb $0x0, 0xbf0e(%rip)      # 0x10310
je 0x440d
jmp 0x441b
movb $0x0, 0xbf07(%rip)      # 0x10314
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0xbecd(%rip)      # 0x102e8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xbe93(%rip), %rbx      # 0x102e8
movq (%rbx), %rax
movq (%rax), %rdi
callq 0x441d
ucomisd 0x4c88(%rip), %xmm0     # 0x90f0
jne 0x446c
jnp 0x44a2
movq 0x10(%rbx), %rdi
callq 0x2c63
cmpb $0x0, 0xbe94(%rip)      # 0x10310
jne 0x44b9
cmpb $0x1, 0xbe93(%rip)      # 0x10318
jne 0x4490
movb $0x0, 0xbe8a(%rip)      # 0x10318
jmp 0x4455
cmpb $0x1, 0xbe7d(%rip)      # 0x10314
jne 0x4455
movb $0x0, 0xbe74(%rip)      # 0x10314
jmp 0x44ab
cmpb $0x0, 0xbe67(%rip)      # 0x10310
jne 0x44b9
movq (%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0xbe2f(%rip)      # 0x102e8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xbe1f(%rip), %r14      # 0x102e8
movq (%r14), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x4383
movq 0x10(%r14), %rdi
callq 0x441d
ucomisd 0x4bff(%rip), %xmm0     # 0x90f0
jne 0x44f5
jnp 0x4531
movq (%r14), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
callq 0x2c63
cmpb $0x0, 0xbe05(%rip)      # 0x10310
jne 0x4557
cmpb $0x1, 0xbe04(%rip)      # 0x10318
jne 0x451f
movb $0x0, 0xbdfb(%rip)      # 0x10318
jmp 0x4528
cmpb $0x1, 0xbdee(%rip)      # 0x10314
je 0x453c
movq (%r14), %rax
movq 0x10(%rax), %rsi
jmp 0x44d8
cmpb $0x0, 0xbdd8(%rip)      # 0x10310
je 0x4543
jmp 0x4557
movb $0x0, 0xbdd1(%rip)      # 0x10314
movq (%r14), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0xbd91(%rip)      # 0x102e8
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/code.c
// Function: bltin
void
bltin(void)
{
	Datum d1, d2;
	Name *name;
	int narg, i;

	name = getnamearg();
	i = name->u.bltin;
	if (i == 0) {   /* sprintf */
		_sprintf();
		return;
	}
	narg = getintarg();
	if (narg == 0 && bltins[i].n == -1)
		narg = -1;
	if (narg != bltins[i].n)
		yyerror("%s: wrong arity", bltins[i].s);
	errno = 0;
	switch (narg) {
	case -1:
		d1.u.val = bltins[i].u.d;
		break;
	case 0:
		d1.u.val = (*bltins[i].u.f0)();
		break;
	case 1:
		d1 = popnum();
		d1.u.val = (*bltins[i].u.f1)(d1.u.val);
		break;
	case 2:
		d2 = popnum();
		d1 = popnum();
		d1.u.val = (*bltins[i].u.f2)(d1.u.val, d2.u.val);
		break;
	}
	d1.u.val = errcheck(d1.u.val, bltins[i].s);
	d1.isstr = 0;
	push(d1);
}

// Assembly:
movq 0xbd72(%rip), %rcx      # 0x102e8
movq (%rcx), %rax
movq 0x10(%rcx), %rcx
movq %rax, 0xbd64(%rip)      # 0x102e8
movslq 0x18(%rcx), %rcx
testq %rcx, %rcx
je 0x3ccd
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl 0x10(%rax), %edx
movq (%rax), %rax
movq %rax, 0xbd40(%rip)      # 0x102e8
imulq $0x18, %rcx, %rax
leaq 0x934d(%rip), %rcx      # 0xd900
leaq (%rcx,%rax), %r15
movl 0x8(%rax,%rcx), %eax
xorl %r14d, %r14d
cmpl $-0x1, %eax
sete %r14b
negl %r14d
testl %edx, %edx
cmovnel %edx, %r14d
cmpl %eax, %r14d
je 0x45e4
movq (%r15), %rsi
leaq 0x4be9(%rip), %rdi      # 0x91c6
xorl %eax, %eax
callq 0x2625
callq 0x2050
andl $0x0, (%rax)
incl %r14d
cmpl $0x3, %r14d
ja 0x46bb
movq %rax, %rbx
leaq 0x4abd(%rip), %rax      # 0x90c0
movslq (%rax,%r14,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movsd 0x10(%r15), %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0x46bb
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x2efc
movsd 0x8(%r14), %xmm0
movl 0x14(%r14), %ebp
callq *0x10(%r15)
jmp 0x467a
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x2efc
movsd 0x8(%r14), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x2efc
movsd 0x8(%r14), %xmm0
movl 0x14(%r14), %ebp
movsd 0x8(%rsp), %xmm1
callq *0x10(%r15)
jmp 0x467a
callq *0x10(%r15)
movsd %xmm0, 0x8(%rsp)
movl (%rbx), %eax
movq (%r15), %r14
cmpl $0x21, %eax
jne 0x46a0
andl $0x0, (%rbx)
leaq 0x4df2(%rip), %rdi      # 0x9486
movq %r14, %rsi
xorl %eax, %eax
callq 0x2625
movl (%rbx), %eax
cmpl $0x22, %eax
jne 0x46bb
andl $0x0, (%rbx)
leaq 0x4df2(%rip), %rdi      # 0x94a1
movq %r14, %rsi
xorl %eax, %eax
callq 0x2625
jmp 0x46bb
pushq $0x18
popq %rdi
callq 0x275c
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
andl $0x0, 0x10(%rax)
movl %ebp, 0x14(%rax)
movq 0xbc54(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xbc4a(%rip)      # 0x10330
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/code.c
// Function: verifydef
void
verifydef(Name *name, int type)
{
	if (name->type != UNDEF)
		yyerror("assigning %s to an already used name: %d",
		        (type == FUNCTION) ? "function" : "procedure",
		        name->type);
	name->type = type;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x10(%rdi), %edx
cmpl $0x107, %edx            # imm = 0x107
je 0x472b
cmpl $0x115, %ebx            # imm = 0x115
leaq 0x4aed(%rip), %rax      # 0x91ff
leaq 0x4b06(%rip), %rsi      # 0x921f
cmoveq %rax, %rsi
leaq 0x4ab2(%rip), %rdi      # 0x91d6
xorl %eax, %eax
callq 0x2625
movl %ebx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/code.c
// Function: define
void
define(Name *name, Name *params)
{
	Function *fun;
	int n;

	if (DEBUG)
		debug();
	fun = emalloc(sizeof *fun);
	fun->code = prog.base;          /* start of code */
	prog.base = prog.progp;         /* next code starts here */
	fun->params = params;
	for (n = 0; params; params = params->next)
		n++;
	fun->nparams = n;
	name->u.fun = fun;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x18
popq %rdi
callq 0x275c
movq 0xbb90(%rip), %rcx      # 0x102e0
movq %rcx, (%rax)
movq 0xbb7e(%rip), %rcx      # 0x102d8
movq %rcx, 0xbb7f(%rip)      # 0x102e0
movq %r14, 0x8(%rax)
xorl %ecx, %ecx
testq %r14, %r14
je 0x4773
incl %ecx
movq (%r14), %r14
jmp 0x4767
movl %ecx, 0x10(%rax)
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/code.c
// Function: call
void
call(void)
{
	Symbol *local;
	Frame *f;
	Datum d;
	Name *name, *tmp;
	int nargs;

	name = getnamearg();
	if (name->type != FUNCTION && name->type != PROCEDURE)
		yyerror("%s is not function nor procedure", name->s);
	nargs = getintarg();
	if (!frame.next->next) {
		f = emalloc(sizeof *f);
		f->next = NULL;
		frame.next->next = f;
	}
	frame.curr = f = frame.next;
	frame.tail = frame.next = frame.next->next;
	frame.next->prev = frame.curr;
	if (nargs > name->u.fun->nparams)
		yyerror("function %s called with wrong number of parameters", name->s);
	nargs = name->u.fun->nparams - nargs;
	local = NULL;
	for (tmp = name->u.fun->params; tmp; tmp = tmp->next) {
		if (nargs > 0) {
			d.u.val = 0.0;
			d.isstr = 0;
			nargs--;
		} else {
			d = pop();
		}
		local = installlocalsym(tmp->s, local);
		local->u = d.u;
		local->isstr = d.isstr;
	}
	f->name = name;
	f->retsymtab = currsymtab;
	currsymtab = f->local = local;
	f->retpc = prog.pc;
	execute(name->u.fun->code);
	returning = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0xbb51(%rip), %rcx      # 0x102e8
movq (%rcx), %rax
movq 0x10(%rcx), %r14
movq %rax, 0xbb43(%rip)      # 0x102e8
movl $0xfffffeeb, %ecx       # imm = 0xFFFFFEEB
addl 0x10(%r14), %ecx
cmpl $0x2, %ecx
jb 0x47cc
movq 0x8(%r14), %rsi
leaq 0x4a4a(%rip), %rdi      # 0x9208
xorl %eax, %eax
callq 0x2625
movq 0xbb1c(%rip), %rax      # 0x102e8
movl 0x10(%rax), %ebx
movq (%rax), %rax
movq %rax, 0xbb0f(%rip)      # 0x102e8
movq 0xbb28(%rip), %r15      # 0x10308
movq 0x8(%r15), %rax
testq %rax, %rax
jne 0x4801
pushq $0x30
popq %rdi
callq 0x275c
andq $0x0, 0x8(%rax)
movq 0xbb0b(%rip), %r15      # 0x10308
movq %rax, 0x8(%r15)
movq %r15, 0xbaf8(%rip)      # 0x10300
movq %rax, 0xbaf9(%rip)      # 0x10308
movq %rax, 0xbae2(%rip)      # 0x102f8
movq %r15, (%rax)
movq 0x18(%r14), %r12
movl 0x10(%r12), %ebp
cmpl %ebp, %ebx
jle 0x4841
movq 0x8(%r14), %rsi
leaq 0x49f8(%rip), %rdi      # 0x9229
xorl %eax, %eax
callq 0x2625
movq 0x18(%r14), %r12
movl 0x10(%r12), %ebp
movq %r14, 0x8(%rsp)
subl %ebx, %ebp
addq $0x8, %r12
xorl %r13d, %r13d
leaq 0x10(%rsp), %rbx
movq (%r12), %r12
testq %r12, %r12
je 0x48a8
testl %ebp, %ebp
jle 0x4870
decl %ebp
xorps %xmm0, %xmm0
movsd %xmm0, (%rsp)
xorl %r14d, %r14d
jmp 0x4888
movq %rbx, %rdi
callq 0x2d0f
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rsp)
movl 0x20(%rsp), %r14d
movq 0x8(%r12), %rdi
callq 0x49e0
movq %r13, (%rax)
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movl %r14d, 0x18(%rax)
movq %rax, %r13
jmp 0x4854
movq 0x8(%rsp), %rcx
movq %rcx, 0x20(%r15)
movq 0xba68(%rip), %rax      # 0x10320
movq %rax, 0x18(%r15)
movq %r13, 0x10(%r15)
movq %r13, 0xba59(%rip)      # 0x10320
movq 0xba1a(%rip), %rax      # 0x102e8
movq %rax, 0x28(%r15)
movq 0x18(%rcx), %rax
movq (%rax), %rdi
callq 0x2c63
movb $0x0, 0xba2b(%rip)      # 0x10310
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/code.c
// Function: funcret
void
funcret(void)
{
	Datum d;

	if (frame.curr->name->type == PROCEDURE)
		yyerror("%s (proc) returns value", frame.curr->name->s);
	d = pop();
	ret();
	push(d);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq 0xba00(%rip), %rax      # 0x10300
movq 0x20(%rax), %rax
cmpl $0x116, 0x10(%rax)      # imm = 0x116
jne 0x491f
movq 0x8(%rax), %rsi
leaq 0x4944(%rip), %rdi      # 0x925c
xorl %eax, %eax
callq 0x2625
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x2d0f
callq 0x495e
pushq $0x18
popq %rdi
callq 0x275c
movups (%rbx), %xmm0
movups %xmm0, (%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0xb9e2(%rip), %rcx      # 0x10330
movq %rcx, (%rax)
movq %rax, 0xb9d8(%rip)      # 0x10330
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/code.c
// Function: ret
static void
ret(void)
{
	currsymtab = frame.curr->retsymtab;
	prog.pc = frame.curr->retpc;
	frame.next = frame.curr;
	frame.curr = frame.curr->prev;
	returning = 1;
}

// Assembly:
movq 0xb99b(%rip), %rax      # 0x10300
movq 0x18(%rax), %rcx
movq %rcx, 0xb9b0(%rip)      # 0x10320
movq 0x28(%rax), %rcx
movq %rcx, 0xb96d(%rip)      # 0x102e8
movq %rax, 0xb986(%rip)      # 0x10308
movq (%rax), %rax
movq %rax, 0xb974(%rip)      # 0x10300
movb $0x1, 0xb97d(%rip)      # 0x10310
retq
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/code.c
// Function: eallocsym
static Symbol *
eallocsym(char *s)
{
	Symbol *sym;

	sym = emalloc(sizeof *sym);
	sym->name = s;
	sym->isstr = 0;
	sym->u.val = 0.0;
	return sym;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x20
popq %rdi
callq 0x275c
movq %rbx, 0x10(%rax)
andl $0x0, 0x18(%rax)
andq $0x0, 0x8(%rax)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/lex.c
// Function: yy_create_buffer
YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
{
	YY_BUFFER_STATE b;
    
	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state )  );
	if ( ! b )
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

	b->yy_buf_size = size;

	/* yy_ch_buf has to be 2 characters longer than the size given because
	 * we need to put in 2 end-of-buffer characters.
	 */
	b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2)  );
	if ( ! b->yy_ch_buf )
		YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );

	b->yy_is_our_buffer = 1;

	yy_init_buffer( b, file );

	return b;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
pushq $0x40
popq %rdi
callq 0x2230
testq %rax, %rax
je 0x7b0e
movq %rax, %r14
movl %ebp, 0x18(%rax)
addl $0x2, %ebp
movslq %ebp, %rdi
callq 0x2230
movq %rax, 0x8(%r14)
testq %rax, %rax
je 0x7b0e
movl $0x1, 0x20(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7c9d
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x291c(%rip), %rdi      # 0xa431
callq 0x7c79
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/lex.c
// Function: yy_get_previous_state
static yy_state_type yy_get_previous_state (void)
{
	yy_state_type yy_current_state;
	char *yy_cp;
    
	yy_current_state = (yy_start);

	for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
		{
		YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
		if ( yy_accept[yy_current_state] )
			{
			(yy_last_accepting_state) = yy_current_state;
			(yy_last_accepting_cpos) = yy_cp;
			}
		while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
			{
			yy_current_state = (int) yy_def[yy_current_state];
			if ( yy_current_state >= 56 )
				yy_c = yy_meta[yy_c];
			}
		yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
		}

	return yy_current_state;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movzbl 0x881b(%rip), %eax      # 0x10388
movq 0x8844(%rip), %rcx      # 0x103b8
movq 0x8825(%rip), %rdx      # 0x103a0
movabsq $0xf980000a000007, %rsi # imm = 0xF980000A000007
leaq 0x2624(%rip), %rdi      # 0xa1b0
leaq 0x24ed(%rip), %r8       # 0xa080
leaq 0x2736(%rip), %r9       # 0xa2d0
leaq 0x268f(%rip), %r10      # 0xa230
movabsq $0x3990001a200300, %r11 # imm = 0x3990001A200300
leaq 0x26fe(%rip), %rbx      # 0xa2b0
leaq 0x2357(%rip), %r14      # 0x9f10
cmpq %rdx, %rcx
jae 0x7c17
movzbl (%rcx), %r15d
testq %r15, %r15
je 0x7bcd
movb (%r15,%r14), %bpl
jmp 0x7bd0
movb $0x1, %bpl
btq %rax, %rsi
jb 0x7be3
movl %eax, 0x87d0(%rip)      # 0x103ac
movq %rcx, 0x87cd(%rip)      # 0x103b0
movzbl %bpl, %r15d
movslq %eax, %r12
movswq (%rdi,%r12,2), %rax
addq %r15, %rax
movswl (%r8,%rax,2), %ebp
cmpl %ebp, %r12d
je 0x7c0d
movswl (%r10,%r12,2), %eax
btq %r12, %r11
jae 0x7be7
movb (%r15,%rbx), %bpl
jmp 0x7be3
movswl (%r9,%rax,2), %eax
incq %rcx
jmp 0x7bb9
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/lex.c
// Function: yyrestart
void yyrestart  (FILE * input_file )
{
    
	if ( ! YY_CURRENT_BUFFER ){
        yyensure_buffer_stack ();
		YY_CURRENT_BUFFER_LVALUE =
            yy_create_buffer( yyin, YY_BUF_SIZE );
	}

	yy_init_buffer( YY_CURRENT_BUFFER, input_file );
	yy_load_buffer_state(  );
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8765(%rip), %rax      # 0x10390
testq %rax, %rax
je 0x7c40
movq 0x8761(%rip), %rcx      # 0x10398
movq (%rax,%rcx,8), %rdi
testq %rdi, %rdi
jne 0x7c6b
callq 0x7a2d
movq 0x8724(%rip), %rdi      # 0x10370
movl $0x4000, %esi           # imm = 0x4000
callq 0x7ac3
movq %rax, %rdi
movq 0x8730(%rip), %rax      # 0x10390
movq 0x8731(%rip), %rcx      # 0x10398
movq %rdi, (%rax,%rcx,8)
movq %rbx, %rsi
callq 0x7c9d
popq %rbx
jmp 0x7b1a
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/lex.c
// Function: yy_scan_buffer
YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
{
	YY_BUFFER_STATE b;
    
	if ( size < 2 ||
	     base[size-2] != YY_END_OF_BUFFER_CHAR ||
	     base[size-1] != YY_END_OF_BUFFER_CHAR )
		/* They forgot to leave room for the EOB's. */
		return NULL;

	b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state )  );
	if ( ! b )
		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );

	b->yy_buf_size = (int) (size - 2);	/* "- 2" to take care of EOB's */
	b->yy_buf_pos = b->yy_ch_buf = base;
	b->yy_is_our_buffer = 0;
	b->yy_input_file = NULL;
	b->yy_n_chars = b->yy_buf_size;
	b->yy_is_interactive = 0;
	b->yy_at_bol = 1;
	b->yy_fill_buffer = 0;
	b->yy_buffer_status = YY_BUFFER_NEW;

	yy_switch_to_buffer( b  );

	return b;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpq $0x2, %rsi
jb 0x7f16
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x0, -0x2(%rdi,%rsi)
jne 0x7f16
cmpb $0x0, -0x1(%r15,%r14)
je 0x7f21
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
pushq $0x40
popq %rdi
callq 0x2230
testq %rax, %rax
je 0x7f6a
movq %rax, %rbx
addq $-0x2, %r14
movl %r14d, 0x18(%rax)
movq %r15, 0x8(%rax)
movq %r15, 0x10(%rax)
andl $0x0, 0x20(%rax)
andq $0x0, (%rax)
movl %r14d, 0x1c(%rax)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x24(%rbx)
andq $0x0, 0x34(%rbx)
movq %rbx, %rdi
callq 0x7d1e
jmp 0x7f18
leaq 0x24ec(%rip), %rdi      # 0xa45d
callq 0x7c79
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/lex.c
// Function: yy_scan_bytes
YY_BUFFER_STATE yy_scan_bytes  (const char * yybytes, int  _yybytes_len )
{
	YY_BUFFER_STATE b;
	char *buf;
	yy_size_t n;
	int i;
    
	/* Get memory for full buffer, including space for trailing EOB's. */
	n = (yy_size_t) (_yybytes_len + 2);
	buf = (char *) yyalloc( n  );
	if ( ! buf )
		YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );

	for ( i = 0; i < _yybytes_len; ++i )
		buf[i] = yybytes[i];

	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;

	b = yy_scan_buffer( buf, n );
	if ( ! b )
		YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );

	/* It's okay to grow etc. this buffer, and we should throw it
	 * away when we're done.
	 */
	b->yy_is_our_buffer = 1;

	return b;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %r15
leal 0x2(%r14), %eax
movslq %eax, %rbx
movq %rbx, %rdi
callq 0x2230
testq %rax, %rax
je 0x7fee
xorl %ecx, %ecx
testl %r14d, %r14d
movl $0x0, %edx
cmovgl %r14d, %edx
cmpq %rcx, %rdx
je 0x7fc9
movb (%r15,%rcx), %sil
movb %sil, (%rax,%rcx)
incq %rcx
jmp 0x7fb7
movslq %r14d, %rcx
andw $0x0, (%rax,%rcx)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7ef6
testq %rax, %rax
je 0x7ffa
movl $0x1, 0x20(%rax)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2492(%rip), %rdi      # 0xa487
callq 0x7c79
leaq 0x24af(%rip), %rdi      # 0xa4b0
callq 0x7c79
// File: /workspace/github_c_makefile_star2_O2/phillbush[P]hoc/lex.c
// Function: yylex_destroy
int yylex_destroy  (void)
{
    
    /* Pop the buffer stack, destroying each element. */
	while(YY_CURRENT_BUFFER){
		yy_delete_buffer( YY_CURRENT_BUFFER  );
		YY_CURRENT_BUFFER_LVALUE = NULL;
		yypop_buffer_state();
	}

	/* Destroy the stack itself. */
	yyfree((yy_buffer_stack) );
	(yy_buffer_stack) = NULL;

    /* Reset the globals. This is important in a non-reentrant scanner so the next time
     * yylex() is called, initialization will occur. */
    yy_init_globals( );

    return 0;
}

// Assembly:
pushq %rax
movq 0x8337(%rip), %rdi      # 0x10390
testq %rdi, %rdi
je 0x8090
movq 0x8333(%rip), %rax      # 0x10398
movq (%rdi,%rax,8), %rax
testq %rax, %rax
je 0x8090
movq %rax, %rdi
callq 0x7d91
movq 0x8313(%rip), %rax      # 0x10390
movq 0x8314(%rip), %rcx      # 0x10398
andq $0x0, (%rax,%rcx,8)
callq 0x7e98
jmp 0x8052
callq 0x2030
andq $0x0, 0x82f3(%rip)      # 0x10390
andq $0x0, 0x82f3(%rip)      # 0x10398
andq $0x0, 0x8323(%rip)      # 0x103d0
andq $0x0, 0x82eb(%rip)      # 0x103a0
movl $0x1, 0x60d1(%rip)      # 0xe190
xorl %eax, %eax
movb %al, 0x82bd(%rip)       # 0x10384
movb %al, 0x82bb(%rip)       # 0x10388
andq $0x0, 0x829b(%rip)      # 0x10370
andq $0x0, 0x829b(%rip)      # 0x10378
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/dropletzhu[P]msuite/tcpclient.c
// Function: short_lived_connection
void short_lived_connection(int sockfd)
{
	char buffer[512];
	int retcode;

	memset(buffer, 0, 512);
	retcode = send(sockfd, buffer, 512, 0);
	printf("send %d bytes\n", retcode);

	retcode = recv(sockfd, buffer, 512, 0);
	printf("recv %d bytes\n", retcode);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movl %edi, %ebx
movq %rsp, %r14
movl $0x200, %edx            # imm = 0x200
movq %r14, %rdi
xorl %esi, %esi
callq 0x1070
movl $0x200, %edx            # imm = 0x200
movl %ebx, %edi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x1050
leaq 0xdd2(%rip), %rdi       # 0x2004
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
movl $0x200, %edx            # imm = 0x200
movl %ebx, %edi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x1030
leaq 0xdc0(%rip), %rdi       # 0x2013
movl %eax, %esi
xorl %eax, %eax
callq 0x1060
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq