LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
leaq -0x40(%rbp), %rdi
callq 0x3620
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x1, %edi
callq 0x3c70
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movsd 0x8(%rax), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x2140
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movq -0x8(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movsd %xmm0, -0x18(%rbp)
leaq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x33a0
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
leaq -0x30(%rbp), %rdi
callq 0x32a0
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x4310
leaq 0x6d6f(%rip), %rdi      # 0xb021
movb $0x0, %al
callq 0x2100
cmpl $0x0, 0xe618(%rip)      # 0x128d8
je 0x42ce
movq 0xe607(%rip), %rdi      # 0x128d0
callq 0x3f30
cmpl $0x0, -0x8(%rbp)
je 0x42dd
movq -0x10(%rbp), %rdi
callq 0x34b0
movq -0x18(%rbp), %rax
movq %rax, 0xe5e0(%rip)      # 0x128c8
movq -0x10(%rbp), %rax
movq %rax, 0xe5dd(%rip)      # 0x128d0
movq -0x8(%rbp), %rax
movq %rax, 0xe5da(%rip)      # 0x128d8
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
callq 0x43f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x43d9
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x4310
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x43bc
leaq 0x6dc6(%rip), %rdi      # 0xb179
movb $0x0, %al
callq 0x2100
jmp 0x43ca
leaq 0x6c5e(%rip), %rdi      # 0xb021
movb $0x0, %al
callq 0x2100
jmp 0x43cc
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x4379
movq -0x8(%rbp), %rdi
callq 0x4480
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq $0x0, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
callq 0x5870
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
jle 0x4472
cmpq $0x0, 0xe498(%rip)      # 0x128c0
jne 0x4441
movq -0x10(%rbp), %rdi
callq 0x4480
leaq 0x7053(%rip), %rdi      # 0xb48d
movb $0x0, %al
callq 0x26c0
movq 0xe478(%rip), %rax      # 0x128c0
movq %rax, -0x10(%rbp)
movq 0xe46d(%rip), %rax      # 0x128c0
movq (%rax), %rax
movq %rax, 0xe463(%rip)      # 0x128c0
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4410
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: freelist
static void
freelist(Datum *p)
{
	Datum *tmp;

	while (p) {
		tmp = p;
		p = p->next;
		free(tmp);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x44b1
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2030
jmp 0x448c
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x43f0
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
jne 0x44d9
jmp 0x453d
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x44f3
leaq 0x6d0d(%rip), %rdi      # 0xb1f7
movb $0x0, %al
callq 0x25f0
jmp 0x453d
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
callq 0x4560
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
jne 0x4517
jmp 0x453d
movq -0x10(%rbp), %rsi
leaq 0x6c70(%rip), %rdi      # 0xb192
movb $0x0, %al
callq 0x2100
movq -0x10(%rbp), %rdi
callq 0x2030
movq -0x8(%rbp), %rdi
callq 0x4480
jmp 0x454b
movq -0x8(%rbp), %rdi
callq 0x4480
callq 0x25d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
callq 0x43f0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x4a3c
jmp 0x4ade
movq -0x28(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x4a59
leaq 0x67aa(%rip), %rdi      # 0xb1f7
movb $0x0, %al
callq 0x25f0
jmp 0x4ade
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
callq 0x4560
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x4a7d
jmp 0x4ade
movq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0x2940
movq %rax, -0x8(%rbp)
cmpq $0x0, %rax
jne 0x4aa2
leaq 0x66c7(%rip), %rdi      # 0xb160
movb $0x0, %al
callq 0x25f0
jmp 0x4ade
movq -0x28(%rbp), %rdi
callq 0x4480
movl $0x1, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x33a0
jmp 0x4aec
movq -0x28(%rbp), %rdi
callq 0x4480
callq 0x25d0
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
xorl %edi, %edi
movl %edi, -0x30(%rbp)
callq 0x3c70
movq %rax, %rcx
movl -0x30(%rbp), %eax
movq %rcx, -0x20(%rbp)
leaq 0x66e7(%rip), %rdi      # 0xb20a
leaq -0x28(%rbp), %rsi
callq 0x2260
movl %eax, %ecx
movl %ecx, -0x2c(%rbp)
subl $-0x1, %eax
je 0x4b41
jmp 0x4b38
movl -0x2c(%rbp), %eax
testl %eax, %eax
je 0x4b4b
jmp 0x4b63
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x4b89
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
leaq 0x66b4(%rip), %rdi      # 0xb20e
movb $0x0, %al
callq 0x26c0
jmp 0x4b89
movsd 0x65e5(%rip), %xmm0     # 0xb150
movsd %xmm0, -0x10(%rbp)
movq -0x20(%rbp), %rax
movl $0x0, 0x18(%rax)
movsd -0x28(%rbp), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movl $0x0, -0x8(%rbp)
leaq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x33a0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x2040, %rsp           # imm = 0x2040
xorl %edi, %edi
callq 0x3c70
movq %rax, -0x20(%rbp)
leaq -0x2020(%rbp), %rdi
movq 0xb3ec(%rip), %rax      # 0xffd0
movq (%rax), %rdx
movl $0x2000, %esi           # imm = 0x2000
callq 0x2170
cmpq $0x0, %rax
je 0x4c54
movsd 0x6551(%rip), %xmm0     # 0xb150
movsd %xmm0, -0x10(%rbp)
leaq -0x2020(%rbp), %rdi
callq 0x22a0
movq %rax, -0x2028(%rbp)
cmpq $0x0, %rax
jne 0x4c2b
leaq 0x653c(%rip), %rdi      # 0xb160
movb $0x0, %al
callq 0x26c0
movq -0x20(%rbp), %rax
movl $0x1, 0x18(%rax)
movq -0x2028(%rbp), %rdi
movl $0x1, %esi
callq 0x2940
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x4c5c
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x8(%rbp)
leaq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x33a0
addq $0x2040, %rsp           # imm = 0x2040
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq -0x48(%rbp), %rdi
callq 0x3620
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3620
movq -0x60(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x10(%rbp)
leaq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x33a0
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq -0x48(%rbp), %rdi
callq 0x3620
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3620
movq -0x60(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movsd -0x10(%rbp), %xmm1
movsd -0x28(%rbp), %xmm0
ucomisd %xmm1, %xmm0
seta %al
andb $0x1, %al
movzbl %al, %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x10(%rbp)
leaq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x33a0
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
leaq -0x48(%rbp), %rdi
callq 0x3620
movq -0x48(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3620
movq -0x60(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
sete %al
setnp %cl
andb %cl, %al
andb $0x1, %al
movzbl %al, %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x10(%rbp)
leaq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x33a0
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0xd799(%rip), %rax      # 0x12878
movq %rax, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3620
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x5116
jp 0x5116
jmp 0x5144
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3120
leaq -0x50(%rbp), %rdi
callq 0x3620
movq -0x50(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd 0x5fff(%rip), %xmm3     # 0xb150
xorps %xmm2, %xmm2
cmpneqsd %xmm2, %xmm0
movaps %xmm0, %xmm1
andpd %xmm3, %xmm1
andnpd %xmm2, %xmm0
orpd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
leaq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x33a0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0xd6d7(%rip)      # 0x12878
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq 0xd6b9(%rip), %rax      # 0x12878
movq %rax, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3620
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x5222
jp 0x5222
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3120
leaq -0x50(%rbp), %rdi
callq 0x3620
movq -0x50(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
movsd 0x5f21(%rip), %xmm3     # 0xb150
xorps %xmm2, %xmm2
cmpneqsd %xmm2, %xmm0
movaps %xmm0, %xmm1
andpd %xmm3, %xmm1
andnpd %xmm2, %xmm0
orpd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
leaq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x33a0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0xd5f9(%rip)      # 0x12878
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0xd5d9(%rip), %rax      # 0x12878
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rsi
leaq -0x38(%rbp), %rdi
callq 0x5340
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x52e3
jp 0x52e3
jmp 0x52f2
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3120
jmp 0x5312
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0x5310
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
callq 0x3120
jmp 0x5312
cmpl $0x0, 0xd587(%rip)      # 0x128a0
jne 0x5330
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0xd548(%rip)      # 0x12878
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x28(%rbp)
movq %rsi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x5395
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x5395
movq -0x8(%rbp), %rdi
callq 0x3120
leaq -0x20(%rbp), %rdi
callq 0x3620
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
jmp 0x53a1
movq -0x30(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0xd4b9(%rip), %rax      # 0x12878
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x3120
cmpl $0x0, 0xd4c7(%rip)      # 0x128a0
je 0x53dd
jmp 0x5421
cmpl $0x0, 0xd4c4(%rip)      # 0x128a8
je 0x53f2
movl $0x0, 0xd4b8(%rip)      # 0x128a8
jmp 0x5409
cmpl $0x0, 0xd4ab(%rip)      # 0x128a4
je 0x5407
movl $0x0, 0xd49f(%rip)      # 0x128a4
jmp 0x5421
jmp 0x5409
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x5450
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x53c3
jp 0x53c3
cmpl $0x0, 0xd478(%rip)      # 0x128a0
jne 0x543c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0xd43c(%rip)      # 0x12878
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: cond
static double
cond(Inst *pc)
{
	Datum d;

	if (pc == NULL)
		return 1.0;
	execute(pc);
	d = popnum();
	return d.u.val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5472
movsd 0x5ce5(%rip), %xmm0     # 0xb150
movsd %xmm0, -0x8(%rbp)
jmp 0x54a6
movq -0x10(%rbp), %rdi
callq 0x3120
leaq -0x40(%rbp), %rdi
callq 0x3620
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0xd3a9(%rip), %rax      # 0x12878
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x5450
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x54ef
jp 0x54ef
jmp 0x5533
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3120
cmpl $0x0, 0xd39d(%rip)      # 0x128a0
je 0x5507
jmp 0x5533
cmpl $0x0, 0xd39a(%rip)      # 0x128a8
je 0x551c
movl $0x0, 0xd38e(%rip)      # 0x128a8
jmp 0x54d3
cmpl $0x0, 0xd381(%rip)      # 0x128a4
je 0x5531
movl $0x0, 0xd375(%rip)      # 0x128a4
jmp 0x5533
jmp 0x54d3
cmpl $0x0, 0xd366(%rip)      # 0x128a0
jne 0x554e
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0xd32a(%rip)      # 0x12878
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0xd309(%rip), %rax      # 0x12878
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rsi
leaq -0x20(%rbp), %rdi
callq 0x5340
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x5450
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x55a6
jp 0x55a6
jmp 0x5606
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rdi
callq 0x3120
cmpl $0x0, 0xd2e0(%rip)      # 0x128a0
je 0x55c4
jmp 0x5606
cmpl $0x0, 0xd2dd(%rip)      # 0x128a8
je 0x55d9
movl $0x0, 0xd2d1(%rip)      # 0x128a8
jmp 0x55f0
cmpl $0x0, 0xd2c4(%rip)      # 0x128a4
je 0x55ee
movl $0x0, 0xd2b8(%rip)      # 0x128a4
jmp 0x5606
jmp 0x55f0
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rsi
leaq -0x38(%rbp), %rdi
callq 0x5340
jmp 0x558c
cmpl $0x0, 0xd293(%rip)      # 0x128a0
jne 0x5627
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0xd251(%rip)      # 0x12878
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: errcheck
static double
errcheck(double d, const char *s)
{
	if (errno == EDOM) {
		errno = 0;
		yyerror("%s: argument out of domain", s);
	}
	if (errno == ERANGE) {
		errno = 0;
		yyerror("%s: result out of range", s);
	}
	return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movsd %xmm0, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x2040
cmpl $0x21, (%rax)
jne 0x58d8
callq 0x2040
movl $0x0, (%rax)
movq -0x10(%rbp), %rsi
leaq 0x5c15(%rip), %rdi      # 0xb4e6
movb $0x0, %al
callq 0x26c0
callq 0x2040
cmpl $0x22, (%rax)
jne 0x58ff
callq 0x2040
movl $0x0, (%rax)
movq -0x10(%rbp), %rsi
leaq 0x5c09(%rip), %rdi      # 0xb501
movb $0x0, %al
callq 0x26c0
movsd -0x8(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x107, 0x10(%rax)      # imm = 0x107
je 0x595c
movl -0xc(%rbp), %ecx
leaq 0x5949(%rip), %rsi      # 0xb27f
leaq 0x5922(%rip), %rax      # 0xb25f
cmpl $0x115, %ecx            # imm = 0x115
cmoveq %rax, %rsi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %edx
leaq 0x58e1(%rip), %rdi      # 0xb236
movb $0x0, %al
callq 0x26c0
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x18, %edi
callq 0x2860
movq %rax, -0x18(%rbp)
movq 0xcedb(%rip), %rcx      # 0x12870
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq 0xcec5(%rip), %rax      # 0x12868
movq %rax, 0xcec6(%rip)      # 0x12870
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x59da
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x59bd
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0xcc51(%rip), %rax      # 0x12890
movq 0x20(%rax), %rax
cmpl $0x116, 0x10(%rax)      # imm = 0x116
jne 0x5c69
movq 0xcc3d(%rip), %rax      # 0x12890
movq 0x20(%rax), %rax
movq 0x8(%rax), %rsi
leaq 0x565a(%rip), %rdi      # 0xb2bc
movb $0x0, %al
callq 0x26c0
leaq -0x30(%rbp), %rdi
callq 0x32a0
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
callq 0x5cc0
leaq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x33a0
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq 0xcbc5(%rip), %rax      # 0x12890
movq 0x18(%rax), %rax
movq %rax, 0xcbda(%rip)      # 0x128b0
movq 0xcbb3(%rip), %rax      # 0x12890
movq 0x28(%rax), %rax
movq %rax, 0xcb90(%rip)      # 0x12878
movq 0xcba1(%rip), %rax      # 0x12890
movq %rax, 0xcba2(%rip)      # 0x12898
movq 0xcb93(%rip), %rax      # 0x12890
movq (%rax), %rax
movq %rax, 0xcb89(%rip)      # 0x12890
movl $0x1, 0xcb8f(%rip)      # 0x128a0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: verifyassign
static void
verifyassign(Name *name, int undef)
{
	if (undef && name->type == UNDEF)
		yyerror("undefined variable: %s", name->s);
	if (name->type != VAR && name->type != UNDEF)
		yyerror("assignment to non-variable: %s", name->s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x5dd8
movq -0x8(%rbp), %rax
cmpl $0x107, 0x10(%rax)      # imm = 0x107
jne 0x5dd8
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x56cc(%rip), %rdi      # 0xb49d
movb $0x0, %al
callq 0x26c0
movq -0x8(%rbp), %rax
cmpl $0x105, 0x10(%rax)      # imm = 0x105
je 0x5e08
movq -0x8(%rbp), %rax
cmpl $0x107, 0x10(%rax)      # imm = 0x107
je 0x5e08
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x56b3(%rip), %rdi      # 0xb4b4
movb $0x0, %al
callq 0x26c0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/code.c
// Function: installglobalsym
static Symbol *
installglobalsym(char *s)
{
	Symbol *sym;

	sym = eallocsym(s);
	sym->next = global;
	global = sym;
	return sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5e50
movq %rax, -0x10(%rbp)
movq 0xca88(%rip), %rcx      # 0x128b8
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, 0xca76(%rip)      # 0x128b8
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x20, %edi
callq 0x2860
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/lex.c
// Function: yyensure_buffer_stack
static void yyensure_buffer_stack (void)
{
	yy_size_t num_to_alloc;
    
	if (!(yy_buffer_stack)) {

		/* First allocation is just for 2 elements, since we don't know if this
		 * scanner will even need a stack. We use 2 instead of 1 to avoid an
		 * immediate realloc on the next call.
         */
      num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
		(yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
								(num_to_alloc * sizeof(struct yy_buffer_state*)
								);
		if ( ! (yy_buffer_stack) )
			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );

		memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));

		(yy_buffer_stack_max) = num_to_alloc;
		(yy_buffer_stack_top) = 0;
		return;
	}

	if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){

		/* Increase the buffer to prepare for a possible push. */
		yy_size_t grow_size = 8 /* arbitrary grow size */;

		num_to_alloc = (yy_buffer_stack_max) + grow_size;
		(yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
								((yy_buffer_stack),
								num_to_alloc * sizeof(struct yy_buffer_state*)
								);
		if ( ! (yy_buffer_stack) )
			YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );

		/* zero only the new slots.*/
		memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
		(yy_buffer_stack_max) = num_to_alloc;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x95e0(%rip)      # 0x12920
jne 0x93a5
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rdi
shlq $0x3, %rdi
callq 0xa190
movq %rax, 0x95c2(%rip)      # 0x12920
cmpq $0x0, 0x95ba(%rip)      # 0x12920
jne 0x9374
leaq 0x33d8(%rip), %rdi      # 0xc747
callq 0x9f80
movq 0x95a5(%rip), %rdi      # 0x12920
movq -0x8(%rbp), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x2130
movq -0x8(%rbp), %rax
movq %rax, 0x95cb(%rip)      # 0x12960
movq $0x0, 0x9588(%rip) # 0x12928
jmp 0x9433
movq 0x957c(%rip), %rax      # 0x12928
movq 0x95ad(%rip), %rcx      # 0x12960
subq $0x1, %rcx
cmpq %rcx, %rax
jb 0x9433
movq $0x8, -0x10(%rbp)
movq 0x9595(%rip), %rax      # 0x12960
addq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq 0x9546(%rip), %rdi      # 0x12920
movq -0x8(%rbp), %rsi
shlq $0x3, %rsi
callq 0xa900
movq %rax, 0x9532(%rip)      # 0x12920
cmpq $0x0, 0x952a(%rip)      # 0x12920
jne 0x9404
leaq 0x3348(%rip), %rdi      # 0xc747
callq 0x9f80
movq 0x9515(%rip), %rdi      # 0x12920
movq 0x954e(%rip), %rax      # 0x12960
shlq $0x3, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x2130
movq -0x8(%rbp), %rax
movq %rax, 0x952d(%rip)      # 0x12960
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x40, %edi
callq 0xa190
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x9470
leaq 0x3190(%rip), %rdi      # 0xc5fb
callq 0x9f80
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rax
movl 0x18(%rax), %eax
addl $0x2, %eax
movslq %eax, %rdi
callq 0xa190
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x94ae
leaq 0x3152(%rip), %rdi      # 0xc5fb
callq 0x9f80
movq -0x18(%rbp), %rax
movl $0x1, 0x20(%rax)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x9fc0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
movl 0x91fe(%rip), %eax      # 0x12918
movl %eax, -0x4(%rbp)
movq 0x9224(%rip), %rax      # 0x12948
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x91fd(%rip), %rax      # 0x12930
jae 0x9822
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x975e
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x291b(%rip), %rax      # 0xc070
movzbl (%rax,%rcx), %eax
movl %eax, -0x18(%rbp)
jmp 0x9768
movl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x9768
movl -0x18(%rbp), %eax
movb %al, -0x11(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x29f7(%rip), %rax      # 0xc170
cmpw $0x0, (%rax,%rcx,2)
je 0x9794
movl -0x4(%rbp), %eax
movl %eax, 0x91b3(%rip)      # 0x1293c
movq -0x10(%rbp), %rax
movq %rax, 0x91ac(%rip)      # 0x12940
jmp 0x9796
movslq -0x4(%rbp), %rcx
leaq 0x2b6f(%rip), %rax      # 0xc310
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x2a2b(%rip), %rax      # 0xc1e0
movswl (%rax,%rcx,2), %eax
cmpl -0x4(%rbp), %eax
je 0x97eb
movslq -0x4(%rbp), %rcx
leaq 0x2bc7(%rip), %rax      # 0xc390
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x38, -0x4(%rbp)
jl 0x97e9
movzbl -0x11(%rbp), %eax
movl %eax, %ecx
leaq 0x2c2d(%rip), %rax      # 0xc410
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
jmp 0x9796
movslq -0x4(%rbp), %rcx
leaq 0x2b1a(%rip), %rax      # 0xc310
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x2c26(%rip), %rax      # 0xc430
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x9728
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phillbush[P]hoc/lex.c
// Function: yy_try_NUL_trans
static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
{
	int yy_is_jam;
    	char *yy_cp = (yy_c_buf_p);

	YY_CHAR yy_c = 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];
	yy_is_jam = (yy_current_state == 55);

		return yy_is_jam ? 0 : yy_current_state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq 0x90f2(%rip), %rax      # 0x12930
movq %rax, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0x291f(%rip), %rax      # 0xc170
cmpw $0x0, (%rax,%rcx,2)
je 0x986c
movl -0x4(%rbp), %eax
movl %eax, 0x90db(%rip)      # 0x1293c
movq -0x10(%rbp), %rax
movq %rax, 0x90d4(%rip)      # 0x12940
jmp 0x986e
movslq -0x4(%rbp), %rcx
leaq 0x2a97(%rip), %rax      # 0xc310
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x2953(%rip), %rax      # 0xc1e0
movswl (%rax,%rcx,2), %eax
cmpl -0x4(%rbp), %eax
je 0x98c3
movslq -0x4(%rbp), %rcx
leaq 0x2aef(%rip), %rax      # 0xc390
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x38, -0x4(%rbp)
jl 0x98c1
movzbl -0x11(%rbp), %eax
movl %eax, %ecx
leaq 0x2b55(%rip), %rax      # 0xc410
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
jmp 0x986e
movslq -0x4(%rbp), %rcx
leaq 0x2a42(%rip), %rax      # 0xc310
movswl (%rax,%rcx,2), %eax
movzbl -0x11(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rcx
leaq 0x2b4e(%rip), %rax      # 0xc430
movswl (%rax,%rcx,2), %eax
movl %eax, -0x4(%rbp)
cmpl $0x37, -0x4(%rbp)
sete %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
je 0x9905
xorl %eax, %eax
movl %eax, -0x18(%rbp)
jmp 0x990b
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x8a3c(%rip)      # 0x12920
je 0x9efd
movq 0x8a33(%rip), %rax      # 0x12920
movq 0x8a34(%rip), %rcx      # 0x12928
cmpq $0x0, (%rax,%rcx,8)
jne 0x9f30
jmp 0x9f05
xorl %eax, %eax
testb $0x1, %al
jne 0x9f30
jmp 0x9f05
callq 0x9330
movq 0x89ef(%rip), %rdi      # 0x12900
movl $0x4000, %esi           # imm = 0x4000
callq 0x9440
movq %rax, %rdx
movq 0x89fb(%rip), %rax      # 0x12920
movq 0x89fc(%rip), %rcx      # 0x12928
movq %rdx, (%rax,%rcx,8)
cmpq $0x0, 0x89e8(%rip)      # 0x12920
je 0x9f52
movq 0x89df(%rip), %rax      # 0x12920
movq 0x89e0(%rip), %rcx      # 0x12928
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0x9f5a
xorl %eax, %eax
movq %rax, -0x10(%rbp)
jmp 0x9f5a
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x9fc0
callq 0x94d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x2, -0x18(%rbp)
jb 0xa531
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x2, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0xa531
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0xa53e
movq $0x0, -0x8(%rbp)
jmp 0xa5e5
movl $0x40, %edi
callq 0xa190
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xa55f
leaq 0x20cd(%rip), %rdi      # 0xc627
callq 0x9f80
movq -0x18(%rbp), %rax
subq $0x2, %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x28(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x34(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x38(%rax)
movq -0x20(%rbp), %rdi
callq 0xa0a0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x2, %eax
cltq
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0xa190
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xa65b
leaq 0x1ffb(%rip), %rdi      # 0xc651
callq 0x9f80
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xa68b
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xa662
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xa4f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xa6cc
leaq 0x1fb3(%rip), %rdi      # 0xc67a
callq 0x9f80
movq -0x18(%rbp), %rax
movl $0x1, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
jmp 0xa7da
cmpq $0x0, 0x813e(%rip)      # 0x12920
je 0xa7fc
movq 0x8135(%rip), %rax      # 0x12920
movq 0x8136(%rip), %rcx      # 0x12928
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0xa804
xorl %eax, %eax
movq %rax, -0x8(%rbp)
jmp 0xa804
movq -0x8(%rbp), %rax
cmpq $0x0, %rax
je 0xa861
cmpq $0x0, 0x810a(%rip)      # 0x12920
je 0xa830
movq 0x8101(%rip), %rax      # 0x12920
movq 0x8102(%rip), %rcx      # 0x12928
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
jmp 0xa838
xorl %eax, %eax
movq %rax, -0x10(%rbp)
jmp 0xa838
movq -0x10(%rbp), %rdi
callq 0xa1b0
movq 0x80d8(%rip), %rax      # 0x12920
movq 0x80d9(%rip), %rcx      # 0x12928
movq $0x0, (%rax,%rcx,8)
callq 0xa410
jmp 0xa7da
movq 0x80b8(%rip), %rdi      # 0x12920
callq 0xa240
movq $0x0, 0x80a8(%rip) # 0x12920
callq 0xa890
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movl %edi, -0x4(%rbp)
leaq -0x210(%rbp), %rdi
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x1070
movl -0x4(%rbp), %edi
leaq -0x210(%rbp), %rsi
movl $0x200, %edx            # imm = 0x200
xorl %ecx, %ecx
callq 0x1050
movl %eax, -0x214(%rbp)
movl -0x214(%rbp), %esi
leaq 0xdba(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1060
movl -0x4(%rbp), %edi
leaq -0x210(%rbp), %rsi
movl $0x200, %edx            # imm = 0x200
xorl %ecx, %ecx
callq 0x1030
movl %eax, -0x214(%rbp)
movl -0x214(%rbp), %esi
leaq 0xd99(%rip), %rdi       # 0x2013
movb $0x0, %al
callq 0x1060
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/dropletzhu[P]msuite/tcpclient.c
// Function: long_lived_connection
void long_lived_connection(int sockfd)
{
	char buffer[1024];
	int retcode;

	memset(buffer, 0, 1024);
	while (1) {
		retcode = send(sockfd, buffer, 1024, 0);
		if (retcode < 0) {
			perror("send()");
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp            # imm = 0x420
movl %edi, -0x4(%rbp)
leaq -0x410(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x1070
movl -0x4(%rbp), %edi
leaq -0x410(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
xorl %ecx, %ecx
callq 0x1050
movl %eax, -0x414(%rbp)
cmpl $0x0, -0x414(%rbp)
jge 0x12e4
leaq 0xd45(%rip), %rdi       # 0x2022
callq 0x10a0
jmp 0x12e6
jmp 0x12b1
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/dropletzhu[P]msuite/tcpclient.c
// Function: usage
void usage()
{
	printf("Usage: ./tcpclient -s [server_ip] -p [port] -l\n");
	printf(" -s	server ip address\n");
	printf(" -p  server port\n");
	printf(" -l  long-lived connection, by default, it is short-lived echo connection\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xd2e(%rip), %rdi       # 0x2029
movb $0x0, %al
callq 0x1060
leaq 0xd50(%rip), %rdi       # 0x2059
movb $0x0, %al
callq 0x1060
leaq 0xd59(%rip), %rdi       # 0x2070
movb $0x0, %al
callq 0x1060
leaq 0xd5d(%rip), %rdi       # 0x2082
movb $0x0, %al
callq 0x1060
popq %rbp
retq
nop