LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: get_digits
int
get_digits(void)
{
	int n = 0;
	char *s = inb;

	// scan to decimal point

	while (strchr(delim, *s) == NULL && *s != '.')
		s++;

	if (*s != '.')
		return 0;

	while (isdigit(*++s) && n < 8)
		n++;

	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0xd486(%rip), %r15      # 0x10478
leaq 0xc837(%rip), %rbx      # 0xf830
movsbl (%r15), %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x20c0
incq %r15
cmpl $0x2e, %r14d
je 0x3016
testq %rax, %rax
je 0x2ff9
xorl %eax, %eax
cmpb $0x2e, %r14b
jne 0x3042
callq 0x2230
movq (%rax), %rcx
xorl %edx, %edx
movsbq (%r15,%rdx), %rsi
leaq 0x1(%rdx), %rax
testb $0x8, 0x1(%rcx,%rsi,2)
je 0x3040
cmpl $0x8, %edx
movq %rax, %rdx
jb 0x3028
decl %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: get_number
double
get_number(void)
{
	double d = NAN;

	// check end of input

	if (inb == NULL)
		return d;

	// scan leading spaces

	while (isspace(*inb))
		inb++;

	if (*inb == 0)
		return d;

	if (strchr(delim, *inb)) {
		inb++;
		return d;
	}

	// scan number

	sscanf(inb, "%lg", &d);

	// scan delimiter

	while (strchr(delim, *inb) == NULL)
		inb++;

	if (*inb)
		inb++;

	return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movabsq $0x7ff8000000000000, %rax # imm = 0x7FF8000000000000
movq %rax, -0x20(%rbp)
movq 0xd40c(%rip), %rbx      # 0x10478
movsd 0x824c(%rip), %xmm0     # 0xb2c0
testq %rbx, %rbx
je 0x311e
callq 0x2230
movq (%rax), %rcx
movsbq (%rbx), %rsi
testb $0x20, 0x1(%rcx,%rsi,2)
je 0x309c
incq %rbx
movq %rbx, 0xd3de(%rip)      # 0x10478
jmp 0x3082
testb %sil, %sil
je 0x30bc
leaq 0xc788(%rip), %rdi      # 0xf830
callq 0x20c0
testq %rax, %rax
je 0x30c6
incq %rbx
movq %rbx, 0xd3bc(%rip)      # 0x10478
movsd 0x81fc(%rip), %xmm0     # 0xb2c0
jmp 0x311e
leaq 0x83ad(%rip), %rsi      # 0xb47a
leaq -0x20(%rbp), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2190
movq 0xd396(%rip), %r14      # 0x10478
incq %r14
leaq 0xc744(%rip), %rbx      # 0xf830
movb -0x1(%r14), %r15b
movsbl %r15b, %esi
movq %rbx, %rdi
callq 0x20c0
testq %rax, %rax
jne 0x310d
movq %r14, 0xd370(%rip)      # 0x10478
incq %r14
jmp 0x30ec
testb %r15b, %r15b
je 0x3119
movq %r14, 0xd35f(%rip)      # 0x10478
movsd -0x20(%rbp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: get_string
void
get_string(void)
{
	int i, n;
	char *s, *t;

	lbuf[0] = 0;

	// check end of input

	if (inb == NULL)
		return;

	// scan leading spaces

	while (isspace(*inb))
		inb++;

	if (*inb == 0)
		return;

	if (strchr(delim, *inb)) {
		inb++;
		return;
	}

	// start of string

	s = inb;

	// find end of string

	while (strchr(delim, *inb) == NULL)
		inb++;

	// skip trailing spaces

	t = inb;
	while (isspace(t[-1]))
		t--;

	n = (int) (t - s);

	if (n + 1 > sizeof lbuf)
		stop("In the observed data, a level name is too long");

	// missing data char?

	if (n == 1 && *s == '.')
		return;

	// copy the string into lbuf

	for (i = 0; i < n; i++)
		lbuf[i] = s[i];

	lbuf[n] = 0;

	// scan delimiter

	if (*inb)
		inb++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movb $0x0, 0x10d1f(%rip)     # 0x13e60
movq 0xd330(%rip), %r12      # 0x10478
testq %r12, %r12
je 0x327f
callq 0x2230
movq %rax, %rbx
movq (%rbx), %rax
movsbq (%r12), %r14
testb $0x20, 0x1(%rax,%r14,2)
je 0x3175
incq %r12
movq %r12, 0xd305(%rip)      # 0x10478
jmp 0x3159
testb %r14b, %r14b
je 0x327f
leaq 0xc6ab(%rip), %rdi      # 0xf830
movl %r14d, %esi
callq 0x20c0
testq %rax, %rax
je 0x319a
movq %r12, %rdi
jmp 0x3275
movq %rbx, -0x38(%rbp)
leaq 0x1(%r12), %rax
movq %rax, -0x30(%rbp)
pushq $0x1
popq %r13
movabsq $-0x6200000001, %rbx    # imm = 0xFFFFFF9DFFFFFFFF
movabsq $0x100000000, %r15      # imm = 0x100000000
movsbl %r14b, %esi
leaq 0xc666(%rip), %rdi      # 0xf830
callq 0x20c0
testq %rax, %rax
jne 0x31fe
movq -0x30(%rbp), %rax
movq %rax, 0xd299(%rip)      # 0x10478
movb (%rax), %r14b
incq %r13
movabsq $0x100000000, %rcx      # imm = 0x100000000
addq %rcx, %r15
addq %rcx, %rbx
incq %rax
movq %rax, -0x30(%rbp)
jmp 0x31bf
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
movq -0x30(%rbp), %rdi
leaq -0x2(%rdi), %rdx
decq %rdi
movsbq (%rdx), %rsi
decq %r13
addq %rax, %r15
addq %rax, %rbx
decq %rdx
testb $0x20, 0x1(%rcx,%rsi,2)
jne 0x321a
movabsq $-0x6400000002, %rax    # imm = 0xFFFFFF9BFFFFFFFE
cmpq %rax, %rbx
jbe 0x328e
cmpl $0x1, %r13d
jne 0x324d
cmpb $0x2e, (%r12)
je 0x327f
sarq $0x20, %r15
xorl %eax, %eax
leaq 0x10c06(%rip), %rcx     # 0x13e60
cmpq %r15, %rax
jge 0x326b
movb (%r12,%rax), %dl
movb %dl, (%rax,%rcx)
incq %rax
jmp 0x325a
movb $0x0, (%r15,%rcx)
cmpb $0x0, (%rdi)
je 0x327f
incq %rdi
movq %rdi, 0xd1f9(%rip)      # 0x10478
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x81e9(%rip), %rdi      # 0xb47e
callq 0x267a
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: catvar
void
catvar(int x, int obs)
{
	int i, m, n;

	// missing data?

	if (lbuf[0] == 0) {
		dd->spec[x].v[obs] = NAN;
		return;
	}

	m = dd->spec[x].max_levels;
	n = dd->spec[x].num_levels;

	// search for the level name

	for (i = 0; i < n; i++)
		if (strcmp(dd->spec[x].ltab[i], lbuf) == 0)
			break;

	// check for new level name

	if (i == n) {

		// get space for more levels if necessary

		if (m == n) {
			m += 100;
			dd->spec[x].max_levels = m;
			dd->spec[x].ltab = xrealloc(dd->spec[x].ltab, m * sizeof (char *));
		}

		dd->spec[x].ltab[i] = strdup(lbuf);
		dd->spec[x].num_levels++;
	}

	// save the level number

	dd->spec[x].v[obs] = i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
movq 0xcdcc(%rip), %rcx      # 0x10080
cmpb $0x0, 0x10ba5(%rip)     # 0x13e60
movslq %edi, %r14
je 0x3328
movl %ebx, -0x3c(%rbp)
movq %rcx, -0x38(%rbp)
addq $0x20, %rcx
movq %r14, -0x58(%rbp)
imulq $0x28, %r14, %rax
movq %rax, -0x30(%rbp)
movq %rcx, -0x48(%rbp)
leaq (%rcx,%rax), %r13
addq $0x10, %r13
movl -0x8(%r13), %eax
movq %rax, -0x50(%rbp)
movl -0x4(%r13), %eax
xorl %ebx, %ebx
testl %eax, %eax
movl $0x0, %r15d
cmovgl %eax, %r15d
leaq 0x10b5c(%rip), %r14     # 0x13e60
movq %rax, %r12
cmpq %rbx, %r15
je 0x333b
movq (%r13), %rax
movq (%rax,%rbx,8), %rdi
movq %r14, %rsi
callq 0x2160
testl %eax, %eax
je 0x3335
incq %rbx
movq %r12, %rax
jmp 0x3307
movsd 0x7f90(%rip), %xmm0     # 0xb2c0
jmp 0x33c2
movl %ebx, %r15d
movq %r12, %rax
cmpl %eax, %r15d
movl -0x3c(%rbp), %ebx
movq -0x58(%rbp), %r14
jne 0x33b9
movq -0x50(%rbp), %rcx
cmpl %eax, %ecx
jne 0x338f
movq %rcx, %rax
movq %rcx, %rdx
addl $0x64, %eax
movq -0x48(%rbp), %rcx
movq -0x30(%rbp), %rsi
movl %eax, 0x8(%rcx,%rsi)
movq (%r13), %rdi
leal 0x320(,%rdx,8), %esi
callq 0x342a
movq 0xcd05(%rip), %rcx      # 0x10080
movq -0x30(%rbp), %rdx
movq %rax, 0x30(%rcx,%rdx)
movq 0xccf5(%rip), %rax      # 0x10080
movq %rax, -0x38(%rbp)
leaq 0x10aca(%rip), %rdi     # 0x13e60
callq 0x2210
movq -0x30(%rbp), %rdx
movq -0x38(%rbp), %rcx
movq 0x30(%rcx,%rdx), %rcx
movq %rax, (%rcx,%r12,8)
movq 0xcccd(%rip), %rcx      # 0x10080
incl 0x2c(%rcx,%rdx)
jmp 0x33bd
movq -0x38(%rbp), %rcx
cvtsi2sd %r15d, %xmm0
imulq $0x28, %r14, %rax
movq 0x40(%rcx,%rax), %rax
movslq %ebx, %rcx
movsd %xmm0, (%rax,%rcx,8)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: chkbuf
void
chkbuf(void)
{
	// check for end of input

	if (inb == NULL)
		return;

	// skip spaces

	while (isspace(*inb))
		inb++;

	if (*inb == 0)
		getbuf();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0xd089(%rip), %rbx      # 0x10478
testq %rbx, %rbx
je 0x3418
callq 0x2230
incq %rbx
movq (%rax), %rdx
movsbq -0x1(%rbx), %rcx
testb $0x20, 0x1(%rdx,%rcx,2)
je 0x3414
movq %rbx, 0xd066(%rip)      # 0x10478
jmp 0x33f9
testb %cl, %cl
je 0x341f
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2b56
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: xrealloc
void *
xrealloc(void *p, int size)
{
	p = realloc(p, size);
	if (p == NULL)
		exit(1);
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %esi, %rsi
callq 0x21a0
testq %rax, %rax
je 0x343d
popq %rbp
retq
pushq $0x1
popq %rdi
callq 0x21f0
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: get_dataline
char *
get_dataline(char *buf, int len)
{
	int i;

	// scan to end of current line

	while (*inp && *inp != ';' && *inp != '\n' && *inp != '\r')
		inp++;

	// end of input?

	if (*inp == 0 || *inp == ';')
		return NULL;

	// skip end of line

	if (inp[0] == '\r' && inp[1] == '\n')
		inp += 2;
	else
		inp += 1;

	while (isspace(*inp) && *inp != '\n' && *inp != '\r')
		inp++;

	if (*inp == 0 || *inp == ';' || *inp == '\n' || *inp == '\r')
		return NULL;

	// copy data line into buf

	for (i = 0; i < len - 1; i++) {
		buf[i] = *inp++;
		if (*inp == 0 || *inp == ';' || *inp == '\n' || *inp == '\r')
			break;
	}

	if (i == len - 1)
		stop("Buffer overrun");

	buf[i + 1] = 0;

	return buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movq 0xc43c(%rip), %rax      # 0xf898
incq %rax
movzbl -0x1(%rax), %ecx
testl %ecx, %ecx
je 0x34db
cmpl $0xa, %ecx
je 0x3488
cmpl $0xd, %ecx
je 0x347f
cmpl $0x3b, %ecx
je 0x34db
movq %rax, 0xc41b(%rip)      # 0xf898
jmp 0x345c
cmpb $0xa, (%rax)
jne 0x3488
pushq $0x2
jmp 0x348a
pushq $0x1
popq %rcx
leaq (%rax,%rcx), %r15
decq %r15
callq 0x2230
movq %r15, 0xc3fa(%rip)      # 0xf898
movq (%rax), %rcx
movsbq (%r15), %rsi
movzbl %sil, %edx
movzwl (%rcx,%rsi,2), %ecx
btl $0xd, %ecx
jae 0x34c2
cmpl $0xa, %edx
je 0x34db
incq %r15
cmpl $0xd, %edx
jne 0x3497
jmp 0x34db
xorl %eax, %eax
movabsq $0x800000000002401, %rcx # imm = 0x800000000002401
cmpl $0x3b, %edx
ja 0x34eb
movl %edx, %edx
btq %rdx, %rcx
jae 0x34eb
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
decl %r14d
testl %r14d, %r14d
movl $0x0, %edx
cmovgl %r14d, %edx
cmpq %rax, %rdx
je 0x352f
leaq 0x1(%r15), %rsi
movq %rsi, 0xc38e(%rip)      # 0xf898
movb (%r15), %sil
movb %sil, (%rbx,%rax)
movq 0xc380(%rip), %r15      # 0xf898
movzbl (%r15), %esi
cmpq $0x3b, %rsi
ja 0x3528
btq %rsi, %rcx
jb 0x352d
incq %rax
jmp 0x34fa
movl %eax, %edx
cmpl %r14d, %edx
je 0x353d
movl %edx, %eax
movb $0x0, 0x1(%rbx,%rax)
jmp 0x34dd
leaq 0x8152(%rip), %rdi      # 0xb696
callq 0x267a
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: dump_data
void
dump_data(void)
{
	int i, j;
	double d;

	printf("dump_data: %s nvar=%d\n", dd->name, dd->nvar);

	for (i = 0; i < dd->nvar; i++)
		printf(" %s", dd->spec[i].name);

	printf("\n");

	for (i = 0; i < dd->nobs; i++) {
		for (j = 0; j < dd->nvar; j++) {
			d = dd->spec[j].v[i];
			if (dd->spec[j].ltab)
				printf(" %s", dd->spec[j].ltab[(int) d]);
			else
				printf(" %g", d);
		}
		printf("\n");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xcb22(%rip), %rax      # 0x10080
movq 0x8(%rax), %rsi
movl 0x10(%rax), %edx
leaq 0x7f41(%rip), %rdi      # 0xb4ad
xorl %eax, %eax
callq 0x20d0
pushq $0x20
popq %r14
leaq 0x8386(%rip), %rbx      # 0xb904
xorl %r15d, %r15d
movq 0xcaf8(%rip), %rax      # 0x10080
movslq 0x10(%rax), %rcx
cmpq %rcx, %r15
jge 0x35a8
movq (%rax,%r14), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x20d0
incq %r15
addq $0x28, %r14
jmp 0x3581
pushq $0xa
popq %rdi
callq 0x2050
leaq 0x7f0d(%rip), %r14      # 0xb4c4
leaq 0x8346(%rip), %r15      # 0xb904
xorl %r13d, %r13d
movq 0xcab8(%rip), %rax      # 0x10080
movslq 0x14(%rax), %rcx
cmpq %rcx, %r13
jge 0x3631
pushq $0x40
popq %r12
xorl %ebx, %ebx
movslq 0x10(%rax), %rcx
cmpq %rcx, %rbx
jge 0x3624
movq -0x10(%rax,%r12), %rcx
movq (%rax,%r12), %rax
movsd (%rax,%r13,8), %xmm0
testq %rcx, %rcx
je 0x360a
cvttsd2si %xmm0, %eax
cltq
movq (%rcx,%rax,8), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x20d0
jmp 0x3614
movq %r14, %rdi
movb $0x1, %al
callq 0x20d0
incq %rbx
movq 0xca62(%rip), %rax      # 0x10080
addq $0x28, %r12
jmp 0x35d7
pushq $0xa
popq %rdi
callq 0x2050
incq %r13
jmp 0x35c1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: free_datasets
void
free_datasets(void)
{
	int i;
	struct dataset *t;

	while (dd) {
		t = dd;
		dd = dd->next;
		if (t->name)
			free(t->name);
		for (i = 0; i < MAXVAR; i++) {
			if (t->spec[i].name)
				free(t->spec[i].name);
			if (t->spec[i].v)
				free(t->spec[i].v);
			if (t->spec[i].ltab)
				free(t->spec[i].ltab);
		}
		free(t);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
pushq $0x40
popq %r14
movq 0xca2b(%rip), %rbx      # 0x10080
testq %rbx, %rbx
je 0x36a6
movq (%rbx), %rax
movq %rax, 0xca1c(%rip)      # 0x10080
movq 0x8(%rbx), %rdi
callq 0x2040
movq %r14, %r15
cmpq $0xfe0, %r15            # imm = 0xFE0
je 0x369c
movq -0x20(%rbx,%r15), %rdi
callq 0x2040
movq (%rbx,%r15), %rdi
callq 0x2040
movq -0x10(%rbx,%r15), %rdi
callq 0x2040
addq $0x28, %r15
jmp 0x3670
movq %rbx, %rdi
callq 0x2040
jmp 0x364e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: select_dataset
void
select_dataset(char *s)
{
	dataset = dd;
	if (s == NULL)
		return;
	while (dataset) {
		if (dataset->name && strcmp(dataset->name, s) == 0)
			return;
		dataset = dataset->next;
	}
	snprintf(errbuf, ERRBUFLEN, "Dataset %s?", s);
	stop(errbuf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0xc9c1(%rip), %r14      # 0x10080
movq %r14, 0x10802(%rip)     # 0x13ec8
testq %rdi, %rdi
je 0x36f4
movq %rdi, %rbx
testq %r14, %r14
je 0x36f9
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x36e8
movq %rbx, %rsi
callq 0x2160
testl %eax, %eax
je 0x36f4
movq (%r14), %r14
movq %r14, 0x107d6(%rip)     # 0x13ec8
jmp 0x36ce
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xc1b0(%rip), %r14      # 0xf8b0
leaq 0x7dc1(%rip), %rdx      # 0xb4c8
movl $0x7d0, %esi            # imm = 0x7D0
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x20e0
movq %r14, %rdi
callq 0x267a
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: parse_expr
void
parse_expr(void)
{
	switch (token) {
	case '+':
		scan();
		parse_term();
		break;
	case '-':
		scan();
		parse_term();
		emit(NEG);
		break;
	default:
		parse_term();
		break;
	}

	for (;;) {
		switch (token) {
		case '+':
			scan();
			parse_term();
			emit(ADD);
			break;
		case '-':
			scan();
			parse_term();
			emit(SUB);
			break;
		default:
			return;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0xc163(%rip), %eax      # 0xf894
cmpl $0x2d, %eax
je 0x3747
cmpl $0x2b, %eax
jne 0x3740
callq 0x2a45
callq 0x3795
jmp 0x3759
callq 0x2a45
callq 0x3795
pushq $0x2
popq %rdi
callq 0x2ab6
pushq $0x3
popq %r14
pushq $0x4
popq %r15
movl 0xc12d(%rip), %eax      # 0xf894
movl %r14d, %ebx
cmpl $0x2b, %eax
je 0x3777
cmpl $0x2d, %eax
jne 0x378a
movl %r15d, %ebx
callq 0x2a45
callq 0x3795
movl %ebx, %edi
callq 0x2ab6
jmp 0x3761
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: parse_term
void
parse_term(void)
{
	parse_factor();

	for (;;) {
		switch (token) {
		case '*':
			scan();
			parse_factor();
			emit(MUL);
			break;
		case '/':
			scan();
			parse_factor();
			emit(DIV);
			break;
		default:
			return;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
callq 0x37e0
pushq $0x5
popq %r14
pushq $0x6
popq %r15
movl 0xc0e2(%rip), %eax      # 0xf894
movl %r14d, %ebx
cmpl $0x2a, %eax
je 0x37c2
cmpl $0x2f, %eax
jne 0x37d5
movl %r15d, %ebx
callq 0x2a45
callq 0x37e0
movl %ebx, %edi
callq 0x2ab6
jmp 0x37ac
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: parse_factor
void
parse_factor(void)
{
	switch (token) {
	case NAME:
		if (strcmp(strbuf, "LOG") == 0)
			parse_log();
		else {
			emit_variable();
			scan();
		}
		break;
	case NUMBER:
		emit_number();
		scan();
		break;
	case '(':
		scan();
		parse_expr();
		if (token != ')')
			stop("Syntax error");
		scan();
		break;
	default:
		stop("Syntax error");
	}

	if (token == STARSTAR) {
		scan();
		switch (token) {
		case '+':
			scan();
			parse_factor();
			break;
		case '-':
			scan();
			parse_factor();
			emit(NEG);
			break;
		default:
			parse_factor();
			break;
		}
		emit(POW);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0xc0aa(%rip), %eax      # 0xf894
cmpl $0x28, %eax
je 0x3817
cmpl $0x3ea, %eax            # imm = 0x3EA
je 0x3810
cmpl $0x3e9, %eax            # imm = 0x3E9
jne 0x382a
cmpl $0x474f4c, 0xc889(%rip) # imm = 0x474F4C
jne 0x3836
callq 0x388a
jmp 0x3840
callq 0x39a8
jmp 0x383b
callq 0x2a45
callq 0x3721
cmpl $0x29, 0xc06c(%rip)     # 0xf894
je 0x383b
leaq 0x7cb0(%rip), %rdi      # 0xb4e1
callq 0x267a
callq 0x3908
callq 0x2a45
cmpl $0x3ed, 0xc04a(%rip)    # imm = 0x3ED
jne 0x386d
callq 0x2a45
movl 0xc03d(%rip), %eax      # 0xf894
cmpl $0x2d, %eax
je 0x386f
cmpl $0x2b, %eax
jne 0x3866
callq 0x2a45
callq 0x37e0
jmp 0x3881
popq %rbp
retq
callq 0x2a45
callq 0x37e0
pushq $0x2
popq %rdi
callq 0x2ab6
pushq $0x7
popq %rdi
popq %rbp
jmp 0x2ab6
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: parse_log
void
parse_log(void)
{
	// look ahead

	while (isspace(*inp) && *inp != '\n' && *inp != '\r')
		inp++;

	if (*inp != '(') {
		emit_variable();
		scan();
		return;
	}

	scan();
	scan();

	parse_expr();

	if (token != ')')
		expected(")");

	scan();

	emit(LOG);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x2230
movq 0xbffe(%rip), %rcx      # 0xf898
incq %rcx
movq (%rax), %rsi
movsbq -0x1(%rcx), %rdi
movzbl %dil, %edx
movzwl (%rsi,%rdi,2), %esi
btl $0xd, %esi
jae 0x38c6
cmpl $0xa, %edx
je 0x38f1
cmpl $0xd, %edx
je 0x38f1
movq %rcx, 0xbfd4(%rip)      # 0xf898
jmp 0x389a
cmpl $0x28, %edx
jne 0x38f1
callq 0x2a45
callq 0x2a45
callq 0x3721
cmpl $0x29, 0xbfb3(%rip)     # 0xf894
jne 0x38fc
callq 0x2a45
pushq $0x8
popq %rdi
popq %rbp
jmp 0x2ab6
callq 0x3908
popq %rbp
jmp 0x2a45
leaq 0x7beb(%rip), %rdi      # 0xb4ee
callq 0x25a8
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: emit_variable
void
emit_variable(void)
{
	int i;
	for (i = 0; i < dd->nvar; i++)
		if (strcmp(dd->spec[i].name, strbuf) == 0)
			break;
	if (i == dd->nvar)
		stop("Variable not found");
	if (dd->spec[i].ltab)
		stop("An arithemetic expression cannot use a category variable");
	emit(LOAD);
	emit(i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xc763(%rip), %r12      # 0x10080
movl 0x10(%r12), %eax
addq $0x20, %r12
xorl %r13d, %r13d
testl %eax, %eax
movl $0x0, %ebx
movl %eax, -0x2c(%rbp)
cmovgl %eax, %ebx
leaq 0xc753(%rip), %r14      # 0x10090
movq %r12, %r15
cmpq %r13, %rbx
je 0x3960
movq (%r15), %rdi
movq %r14, %rsi
callq 0x2160
testl %eax, %eax
je 0x395d
incq %r13
addq $0x28, %r15
jmp 0x3940
movl %r13d, %ebx
cmpl -0x2c(%rbp), %ebx
je 0x3990
movl %ebx, %eax
imulq $0x28, %rax, %rax
cmpq $0x0, 0x10(%r12,%rax)
jne 0x399c
pushq $0xa
popq %rdi
callq 0x2ab6
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2ab6
leaq 0x7b71(%rip), %rdi      # 0xb508
callq 0x267a
leaq 0x7b78(%rip), %rdi      # 0xb51b
callq 0x267a
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: emit_number
void
emit_number(void)
{
	int i;
	char *p = (char *) &token_num;
	emit(LIT);
	for (i = 0; i < sizeof (double); i++)
		emit(p[i]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
pushq $0x9
popq %rdi
callq 0x2ab6
xorl %ebx, %ebx
leaq 0x10510(%rip), %r14     # 0x13ed0
cmpq $0x8, %rbx
je 0x39d5
movsbl (%rbx,%r14), %edi
callq 0x2ab6
incq %rbx
jmp 0x39c0
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: main
int
main(int argc, char *argv[])
{
	char *s;

	if (argc < 2) {
		printf("usage: sassafras filename\n");
		exit(1);
	}

	s = read_file(argv[1]);

	if (s == NULL) {
		printf("error reading file %s\n", argv[1]);
		exit(1);
	}

	run(s);

	free(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $0x1, %edi
jle 0x3cca
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
callq 0x3cf2
testq %rax, %rax
je 0x3cd8
movq %rax, %r14
movq %rax, %rdi
callq 0x3d88
movq %r14, %rdi
callq 0x2040
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7f39(%rip), %rdi      # 0xbc0a
callq 0x2070
jmp 0x3cea
movq 0x8(%rbx), %rsi
leaq 0x7871(%rip), %rdi      # 0xb554
xorl %eax, %eax
callq 0x20d0
pushq $0x1
popq %rdi
callq 0x21f0
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: emit_line_center
void
emit_line_center(char *s)
{
	int i, n;

	n = strlen(s);

	n = (80 - n) / 2;

	for (i = 0; i < n; i++)
		printf(" ");

	printf("%s\n", s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x20b0
pushq $0x50
popq %rcx
subl %eax, %ecx
pushq $0x2
popq %rsi
movl %ecx, %eax
cltd
idivl %esi
xorl %r15d, %r15d
testl %eax, %eax
cmovgl %eax, %r15d
pushq $0x20
popq %r14
subl $0x1, %r15d
jb 0x3e32
movl %r14d, %edi
callq 0x2050
jmp 0x3e22
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2070
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: title_stmt
void
title_stmt(void)
{
	scan();
	if (token != STRING)
		expected("string");
	if (title)
		free(title);
	if (strbuf[0] == 0)
		title = NULL;
	else
		title = strdup(strbuf);
	scan();
	if (token != ';')
		stop("';' expected");
	scan();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x2a45
cmpl $0x3eb, 0xba13(%rip)    # imm = 0x3EB
jne 0x3ec3
movq 0x1053e(%rip), %rdi     # 0x143c8
callq 0x2040
cmpb $0x0, 0xc1fa(%rip)      # 0x10090
je 0x3ea6
leaq 0xc1f1(%rip), %rdi      # 0x10090
callq 0x2210
jmp 0x3ea8
xorl %eax, %eax
movq %rax, 0x10519(%rip)     # 0x143c8
callq 0x2a45
cmpl $0x3b, 0xb9d9(%rip)     # 0xf894
jne 0x3ecf
popq %rbp
jmp 0x2a45
leaq 0x7c56(%rip), %rdi      # 0xbb20
callq 0x25a8
leaq 0x75fe(%rip), %rdi      # 0xb4d4
callq 0x267a
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: title1_stmt
void
title1_stmt(void)
{
	scan();
	if (token != STRING)
		expected("string");
	if (title1)
		free(title1);
	if (strbuf[0] == 0)
		title1 = NULL;
	else
		title1 = strdup(strbuf);
	scan();
	if (token != ';')
		stop("';' expected");
	scan();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x2a45
cmpl $0x3eb, 0xb9a6(%rip)    # imm = 0x3EB
jne 0x3f30
movq 0x104d9(%rip), %rdi     # 0x143d0
callq 0x2040
cmpb $0x0, 0xc18d(%rip)      # 0x10090
je 0x3f13
leaq 0xc184(%rip), %rdi      # 0x10090
callq 0x2210
jmp 0x3f15
xorl %eax, %eax
movq %rax, 0x104b4(%rip)     # 0x143d0
callq 0x2a45
cmpl $0x3b, 0xb96c(%rip)     # 0xf894
jne 0x3f3c
popq %rbp
jmp 0x2a45
leaq 0x7be9(%rip), %rdi      # 0xbb20
callq 0x25a8
leaq 0x7591(%rip), %rdi      # 0xb4d4
callq 0x267a
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: title2_stmt
void
title2_stmt(void)
{
	scan();
	if (token != STRING)
		expected("string");
	if (title2)
		free(title2);
	if (strbuf[0] == 0)
		title2 = NULL;
	else
		title2 = strdup(strbuf);
	scan();
	if (token != ';')
		stop("';' expected");
	scan();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x2a45
cmpl $0x3eb, 0xb939(%rip)    # imm = 0x3EB
jne 0x3f9d
movq 0x10474(%rip), %rdi     # 0x143d8
callq 0x2040
cmpb $0x0, 0xc120(%rip)      # 0x10090
je 0x3f80
leaq 0xc117(%rip), %rdi      # 0x10090
callq 0x2210
jmp 0x3f82
xorl %eax, %eax
movq %rax, 0x1044f(%rip)     # 0x143d8
callq 0x2a45
cmpl $0x3b, 0xb8ff(%rip)     # 0xf894
jne 0x3fa9
popq %rbp
jmp 0x2a45
leaq 0x7b7c(%rip), %rdi      # 0xbb20
callq 0x25a8
leaq 0x7524(%rip), %rdi      # 0xb4d4
callq 0x267a
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: title3_stmt
void
title3_stmt(void)
{
	scan();
	if (token != STRING)
		expected("string");
	if (title3)
		free(title3);
	if (strbuf[0] == 0)
		title3 = NULL;
	else
		title3 = strdup(strbuf);
	scan();
	if (token != ';')
		stop("';' expected");
	scan();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x2a45
cmpl $0x3eb, 0xb8cc(%rip)    # imm = 0x3EB
jne 0x400a
movq 0x1040f(%rip), %rdi     # 0x143e0
callq 0x2040
cmpb $0x0, 0xc0b3(%rip)      # 0x10090
je 0x3fed
leaq 0xc0aa(%rip), %rdi      # 0x10090
callq 0x2210
jmp 0x3fef
xorl %eax, %eax
movq %rax, 0x103ea(%rip)     # 0x143e0
callq 0x2a45
cmpl $0x3b, 0xb892(%rip)     # 0xf894
jne 0x4016
popq %rbp
jmp 0x2a45
leaq 0x7b0f(%rip), %rdi      # 0xbb20
callq 0x25a8
leaq 0x74b7(%rip), %rdi      # 0xb4d4
callq 0x267a
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: parse_alpha_option
void
parse_alpha_option(void)
{
	scan(); // skip alpha token

	if (token != '=')
		expected("equals sign");

	scan(); // skip equals sign

	if (token != NUMBER)
		expected("number");

	alpha = atof(strbuf);

	if (alpha < 0 || alpha > 1)
		expected("number between 0 and 1");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x2a45
cmpl $0x3d, 0xb862(%rip)     # 0xf894
jne 0x406f
callq 0x2a45
cmpl $0x3ea, 0xb851(%rip)    # imm = 0x3EA
jne 0x407b
leaq 0xc044(%rip), %rdi      # 0x10090
callq 0x2080
movsd %xmm0, 0xfe7f(%rip)     # 0x13ed8
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x4087
ucomisd 0x725d(%rip), %xmm0     # 0xb2c8
ja 0x4087
popq %rbp
retq
leaq 0x738b(%rip), %rdi      # 0xb401
callq 0x25a8
leaq 0x739b(%rip), %rdi      # 0xb41d
callq 0x25a8
leaq 0x7502(%rip), %rdi      # 0xb590
callq 0x25a8
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: parse_data_option
void
parse_data_option(void)
{
	scan();
	if (token != '=')
		stop("'=' expected");
	scan();
	if (token != NAME)
		stop("DATA=NAME expected");
	select_dataset(strbuf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x2a45
cmpl $0x3d, 0xb7f1(%rip)     # 0xf894
jne 0x40c3
callq 0x2a45
cmpl $0x3e9, 0xb7e0(%rip)    # imm = 0x3E9
jne 0x40cf
leaq 0xbfd3(%rip), %rdi      # 0x10090
popq %rbp
jmp 0x36b1
leaq 0x74dd(%rip), %rdi      # 0xb5a7
callq 0x267a
leaq 0x74de(%rip), %rdi      # 0xb5b4
callq 0x267a
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: parse_maxdec_option
void
parse_maxdec_option(void)
{
	scan();
	if (token != '=')
		stop("'=' expected");

	scan();
	if (token != NUMBER)
		stop("Number expected");

	maxdec = (int) token_num;

	if (maxdec < 0)
		maxdec = 0;

	if (maxdec > 8)
		maxdec = 8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x2a45
cmpl $0x3d, 0xb7a9(%rip)     # 0xf894
jne 0x411e
callq 0x2a45
cmpl $0x3ea, 0xb798(%rip)    # imm = 0x3EA
jne 0x412a
cvttsd2si 0xfdca(%rip), %eax # 0x13ed0
xorl %ecx, %ecx
testl %eax, %eax
cmovgl %eax, %ecx
cmpl $0x8, %ecx
pushq $0x8
popq %rax
cmovll %ecx, %eax
movl %eax, 0xfdc4(%rip)      # 0x13ee0
popq %rbp
retq
leaq 0x7482(%rip), %rdi      # 0xb5a7
callq 0x267a
leaq 0x7496(%rip), %rdi      # 0xb5c7
callq 0x267a
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: parse_by_stmt
void
parse_by_stmt(void)
{
	int i;

	for (;;) {

		scan();

		if (token == ';')
			break;

		if (token != NAME)
			stop("Variable name expected");

		// look for match in dataset

		for (i = 0; i < dataset->nvar; i++)
			if (strcmp(dataset->spec[i].name, strbuf) == 0)
				break;

		if (i == dataset->nvar) {
			snprintf(errbuf, ERRBUFLEN, "The variable %s not in the dataset", strbuf);
			stop(errbuf);
		}

		if (dataset->spec[i].ltab == NULL) {
			snprintf(errbuf, ERRBUFLEN, "The variable %s is not a categorical variable", strbuf);
			stop(errbuf);
		}

		by[nby++] = i;
	}

	scan(); // eat the semicolon
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xbf45(%rip), %rbx      # 0x10090
callq 0x2a45
movl 0xb73e(%rip), %eax      # 0xf894
cmpl $0x3e9, %eax            # imm = 0x3E9
jne 0x41d7
movq 0xfd64(%rip), %r13      # 0x13ec8
movl 0x10(%r13), %eax
addq $0x20, %r13
testl %eax, %eax
movl $0x0, %r14d
movl %eax, -0x2c(%rbp)
cmovgl %eax, %r14d
movq %r13, %r12
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x41a2
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x2160
testl %eax, %eax
je 0x419f
incq %r15
addq $0x28, %r12
jmp 0x4181
movl %r15d, %r14d
cmpl -0x2c(%rbp), %r14d
je 0x41ef
movl %r14d, %eax
imulq $0x28, %rax, %rax
cmpq $0x0, 0x10(%r13,%rax)
je 0x41ff
movslq 0xfec2(%rip), %rax      # 0x14080
leal 0x1(%rax), %ecx
movl %ecx, 0xfeb9(%rip)      # 0x14080
leaq 0xfd22(%rip), %rcx      # 0x13ef0
movl %r14d, (%rcx,%rax,4)
jmp 0x414b
cmpl $0x3b, %eax
jne 0x422b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2a45
leaq 0xb6ba(%rip), %rbx      # 0xf8b0
leaq 0x73f1(%rip), %rdx      # 0xb5ee
jmp 0x420d
leaq 0xb6aa(%rip), %rbx      # 0xf8b0
leaq 0x7404(%rip), %rdx      # 0xb611
leaq 0xbe7c(%rip), %rcx      # 0x10090
movl $0x7d0, %esi            # imm = 0x7D0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x20e0
movq %rbx, %rdi
callq 0x267a
leaq 0x73a5(%rip), %rdi      # 0xb5d7
callq 0x267a
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: parse_class_stmt
void
parse_class_stmt(void)
{
	int i;

	for (;;) {

		scan();

		if (token == ';')
			break;

		if (token != NAME)
			stop("Variable name expected");

		// look for match in dataset

		for (i = 0; i < dataset->nvar; i++)
			if (strcmp(dataset->spec[i].name, strbuf) == 0)
				break;

		if (i == dataset->nvar) {
			snprintf(errbuf, ERRBUFLEN, "The variable %s not in the dataset", strbuf);
			stop(errbuf);
		}

		if (dataset->spec[i].ltab == NULL) {
			snprintf(errbuf, ERRBUFLEN, "The variable %s is not a categorical variable", strbuf);
			stop(errbuf);
		}

		class[nclass++] = i;
	}

	scan(); // eat the semicolon
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xbe44(%rip), %rbx      # 0x10090
callq 0x2a45
movl 0xb63d(%rip), %eax      # 0xf894
cmpl $0x3e9, %eax            # imm = 0x3E9
jne 0x42d8
movq 0xfc63(%rip), %r13      # 0x13ec8
movl 0x10(%r13), %eax
addq $0x20, %r13
testl %eax, %eax
movl $0x0, %r14d
movl %eax, -0x2c(%rbp)
cmovgl %eax, %r14d
movq %r13, %r12
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x42a3
movq (%r12), %rdi
movq %rbx, %rsi
callq 0x2160
testl %eax, %eax
je 0x42a0
incq %r15
addq $0x28, %r12
jmp 0x4282
movl %r15d, %r14d
cmpl -0x2c(%rbp), %r14d
je 0x42f0
movl %r14d, %eax
imulq $0x28, %rax, %rax
cmpq $0x0, 0x10(%r13,%rax)
je 0x4300
movslq 0xff61(%rip), %rax      # 0x14220
leal 0x1(%rax), %ecx
movl %ecx, 0xff58(%rip)      # 0x14220
leaq 0xfdc1(%rip), %rcx      # 0x14090
movl %r14d, (%rcx,%rax,4)
jmp 0x424c
cmpl $0x3b, %eax
jne 0x432c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2a45
leaq 0xb5b9(%rip), %rbx      # 0xf8b0
leaq 0x72f0(%rip), %rdx      # 0xb5ee
jmp 0x430e
leaq 0xb5a9(%rip), %rbx      # 0xf8b0
leaq 0x7303(%rip), %rdx      # 0xb611
leaq 0xbd7b(%rip), %rcx      # 0x10090
movl $0x7d0, %esi            # imm = 0x7D0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x20e0
movq %rbx, %rdi
callq 0x267a
leaq 0x72a4(%rip), %rdi      # 0xb5d7
callq 0x267a
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: parse_var_stmt
void
parse_var_stmt(void)
{
	int i;

	for (;;) {

		scan();

		if (token == ';')
			break;

		if (token != NAME)
			stop("Variable name expected");

		// look for match in dataset

		for (i = 0; i < dataset->nvar; i++)
			if (strcmp(dataset->spec[i].name, strbuf) == 0)
				break;

		if (i == dataset->nvar) {
			snprintf(errbuf, ERRBUFLEN, "Variable %s?", strbuf);
			stop(errbuf);
		}

		var[nvar++] = i;
	}

	scan(); // eat the semicolon
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xbd43(%rip), %rbx      # 0x10090
callq 0x2a45
movl 0xb53c(%rip), %eax      # 0xf894
cmpl $0x3e9, %eax            # imm = 0x3E9
jne 0x43c1
movq 0xfb62(%rip), %r13      # 0x13ec8
movl 0x10(%r13), %r12d
addq $0x20, %r13
testl %r12d, %r12d
movl $0x0, %r14d
cmovgl %r12d, %r14d
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x439f
movq (%r13), %rdi
movq %rbx, %rsi
callq 0x2160
testl %eax, %eax
je 0x439c
incq %r15
addq $0x28, %r13
jmp 0x437e
movl %r15d, %r14d
cmpl %r12d, %r14d
je 0x43e5
movslq 0x10015(%rip), %rax     # 0x143c0
leal 0x1(%rax), %ecx
movl %ecx, 0x1000c(%rip)     # 0x143c0
leaq 0xfe75(%rip), %rcx      # 0x14230
movl %r14d, (%rcx,%rax,4)
jmp 0x434d
cmpl $0x3b, %eax
jne 0x43d9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2a45
leaq 0x71f7(%rip), %rdi      # 0xb5d7
callq 0x267a
leaq 0xb4c4(%rip), %rbx      # 0xf8b0
leaq 0x724c(%rip), %rdx      # 0xb63f
leaq 0xbc96(%rip), %rcx      # 0x10090
movl $0x7d0, %esi            # imm = 0x7D0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x20e0
movq %rbx, %rdi
callq 0x267a
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: print_table_and_free
void
print_table_and_free(char **a, int nrow, int ncol, char *fmt)
{
	int i, j;
	print_table(a, nrow, ncol, fmt);
	for (i = 0; i < nrow; i++)
		for (j = 0; j < ncol; j++)
			free(A(i, j));
	free(a);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r15d
movl %esi, %r14d
movq %rdi, %rbx
callq 0x4491
xorl %r12d, %r12d
testl %r15d, %r15d
movl $0x0, %r13d
cmovgl %r15d, %r13d
movslq %r15d, %r15
testl %r14d, %r14d
cmovlel %r12d, %r14d
movq %r14, -0x38(%rbp)
shlq $0x3, %r15
movq %rbx, -0x30(%rbp)
cmpq -0x38(%rbp), %r12
je 0x447a
xorl %r14d, %r14d
cmpq %r14, %r13
je 0x4472
movq (%rbx,%r14,8), %rdi
callq 0x2040
incq %r14
jmp 0x445f
incq %r12
addq %r15, %rbx
jmp 0x4456
movq -0x30(%rbp), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: print_title
void
print_title(void)
{
	if (title)
		emit_line_center(title);

	if (title1)
		emit_line_center(title1);

	if (title2)
		emit_line_center(title2);

	if (title3)
		emit_line_center(title3);

	if (title || title1 || title2 || title3)
		emit_line("");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xfcdb(%rip), %rdi      # 0x143c8
testq %rdi, %rdi
je 0x46f7
callq 0x3df6
movq 0xfcd2(%rip), %rdi      # 0x143d0
testq %rdi, %rdi
je 0x4708
callq 0x3df6
movq 0xfcc9(%rip), %rdi      # 0x143d8
testq %rdi, %rdi
je 0x4719
callq 0x3df6
movq 0xfcc0(%rip), %rdi      # 0x143e0
testq %rdi, %rdi
je 0x4737
callq 0x3df6
cmpq $0x0, 0xfcae(%rip)      # 0x143e0
setne %al
jmp 0x4739
xorl %eax, %eax
cmpq $0x0, 0xfc87(%rip)      # 0x143c8
jne 0x475d
cmpq $0x0, 0xfc85(%rip)      # 0x143d0
jne 0x475d
cmpq $0x0, 0xfc83(%rip)      # 0x143d8
jne 0x475d
testb %al, %al
jne 0x475d
popq %rbp
retq
pushq $0xa
popq %rdi
popq %rbp
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: proc_anova_parse_body
void
proc_anova_parse_body(void)
{
	for (;;) {
		keyword();
		switch (token) {
		case 0:
		case KDATA:
		case KPROC:
		case KRUN:
			return;
		case KCLASS:
			parse_class_stmt();
			break;
		case KMEANS:
			proc_anova_parse_means_stmt();
			break;
		case KMODEL:
			proc_anova_parse_model_stmt();
			proc_anova_model();
			break;
		default:
			parse_default();
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x6890(%rip), %rbx      # 0xb068
callq 0x254c
movl 0xb0b1(%rip), %eax      # 0xf894
leal -0x141(%rax), %ecx
cmpl $0x9, %ecx
ja 0x47fe
movslq (%rbx,%rcx,4), %rax
addq %rbx, %rax
jmpq *%rax
callq 0x4831
jmp 0x47d8
cmpl $0x131, %eax            # imm = 0x131
je 0x4823
cmpl $0x135, %eax            # imm = 0x135
je 0x482a
testl %eax, %eax
je 0x482a
callq 0x29bd
jmp 0x47d8
callq 0x49ec
callq 0x4af7
jmp 0x47d8
callq 0x4237
jmp 0x47d8
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: proc_anova_parse_model_stmt
void
proc_anova_parse_model_stmt(void)
{
	int i;

	nx = 0;

	// parse dependent variable

	scan();

	if (token != NAME)
		expected("variable name");

	for (i = 0; i < dataset->nvar; i++)
		if (strcmp(dataset->spec[i].name, strbuf) == 0)
			break;

	if (i == dataset->nvar)
		expected("variable in data set");

	if (dataset->spec[i].ltab)
		expected("numeric variable");

	yvar = i;

	scan();

	if (token != '=')
		expected("equals sign");

	scan();

	// parse explanatory variables

	for (;;) {

		if (token == ';' || token == '/')
			break;

		if (token != NAME)
			expected("variable name");

		proc_anova_parse_explanatory_variable();
	}

	if (token == '/')
		proc_anova_parse_model_options();

	scan(); // eat the semicolon
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
andl $0x0, 0xf9e7(%rip)      # 0x143e8
callq 0x2a45
cmpl $0x3e9, 0xae84(%rip)    # imm = 0x3E9
jne 0x4aaf
movq 0xf4ab(%rip), %r12      # 0x13ec8
movl 0x10(%r12), %eax
addq $0x20, %r12
xorl %r13d, %r13d
testl %eax, %eax
movl $0x0, %r15d
movl %eax, -0x2c(%rbp)
cmovgl %eax, %r15d
leaq 0xb651(%rip), %rbx      # 0x10090
movq %r12, %r14
cmpq %r13, %r15
je 0x4a62
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x2160
testl %eax, %eax
je 0x4a5f
incq %r13
addq $0x28, %r14
jmp 0x4a42
movl %r13d, %r15d
cmpl -0x2c(%rbp), %r15d
je 0x4ad3
movl %r15d, %eax
imulq $0x28, %rax, %rax
cmpq $0x0, 0x10(%r12,%rax)
jne 0x4adf
movl %r15d, 0xfb02(%rip)     # 0x14580
callq 0x2a45
cmpl $0x3d, 0xae0a(%rip)     # 0xf894
jne 0x4aeb
callq 0x2a45
movl 0xadfd(%rip), %eax      # 0xf894
cmpl $0x3e9, %eax            # imm = 0x3E9
jne 0x4aa5
callq 0x5b22
jmp 0x4a91
cmpl $0x2f, %eax
je 0x4abb
cmpl $0x3b, %eax
je 0x4ac0
leaq 0x6c00(%rip), %rdi      # 0xb6b6
callq 0x25a8
callq 0x5c82
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2a45
leaq 0x6bea(%rip), %rdi      # 0xb6c4
callq 0x25a8
leaq 0x6bf3(%rip), %rdi      # 0xb6d9
callq 0x25a8
leaq 0x690f(%rip), %rdi      # 0xb401
callq 0x25a8
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: proc_anova_model
void
proc_anova_model(void)
{
	proc_anova_regression();

	print_title();

	if (nmiss) {
		snprintf(bigbuf, BIGBUFLEN, "%d observations deleted due to missing data", nmiss);
		emit_line(bigbuf);
	}

	emit_line_center("Analysis of Variance");
	emit_line("");

	print_anova_table_part1();

	print_anova_table_part2();

	print_anova_table_part3();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
callq 0x6143
callq 0x46e2
movl 0xff33(%rip), %ecx      # 0x14a40
testl %ecx, %ecx
je 0x4b36
leaq 0xe3a8(%rip), %rbx      # 0x12ec0
leaq 0x6cca(%rip), %rdx      # 0xb7e9
movl $0xfa0, %esi            # imm = 0xFA0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x20e0
movq %rbx, %rdi
callq 0x2070
leaq 0x6cd8(%rip), %rdi      # 0xb815
callq 0x3df6
pushq $0xa
popq %rdi
callq 0x2050
callq 0x6269
callq 0x653f
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6684
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: proc_anova_parse_means_item
void
proc_anova_parse_means_item(void)
{
	if (token != NAME)
		expected("variable name");

	if (strlen(strbuf) + 1 > BIGBUFLEN)
		stop("Buffer overrun");

	strcpy(bigbuf, strbuf);

	scan();

	while (token == '*') {
		scan();
		if (token != NAME)
			expected("variable name");
		if (strlen(bigbuf) + strlen(strbuf) + 2 > BIGBUFLEN)
			stop("Buffer overrun");
		strcat(bigbuf, "*");
		strcat(bigbuf, strbuf);
		scan();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x3e9, 0xad21(%rip)    # imm = 0x3E9
jne 0x4c19
leaq 0xb510(%rip), %rdi      # 0x10090
callq 0x20b0
addq $-0xfa0, %rax           # imm = 0xF060
cmpq $-0xfa2, %rax           # imm = 0xF05E
jbe 0x4c25
leaq 0xe322(%rip), %rbx      # 0x12ec0
leaq 0xb4eb(%rip), %r14      # 0x10090
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2060
callq 0x2a45
cmpl $0x2a, 0xacd8(%rip)     # 0xf894
jne 0x4c0e
callq 0x2a45
cmpl $0x3e9, 0xacc7(%rip)    # imm = 0x3E9
jne 0x4c19
movq %rbx, %rdi
callq 0x20b0
movq %rax, %r15
movq %r14, %rdi
callq 0x20b0
addq %r15, %rax
addq $-0xf9f, %rax           # imm = 0xF061
cmpq $-0xfa2, %rax           # imm = 0xF05E
jbe 0x4c25
movq %rbx, %rdi
callq 0x20b0
movw $0x2a, (%rax,%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21e0
jmp 0x4bb0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6a96(%rip), %rdi      # 0xb6b6
callq 0x25a8
leaq 0x6a6a(%rip), %rdi      # 0xb696
callq 0x267a
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: proc_anova_compute_means
void
proc_anova_compute_means(int x)
{
	int i, level, n;
	double t, y;

	n = dataset->spec[x].num_levels;

	if (n > MAXLVL)
		stop("Too many levels");

	for (i = 0; i < n; i++) {
		mean[i] = 0;
		variance[i] = 0;
		count[i] = 0;
	}

	for (i = 0; i < dataset->nobs; i++) {
		if (miss[i])
			continue;
		y = dataset->spec[yvar].v[i];
		level = dataset->spec[x].v[i];
		count[level]++;
		t = mean[level];
		mean[level] += (y - t) / count[level];
		variance[level] += (y - t) * (y - mean[level]);
	}

	for (i = 0; i < n; i++)
		variance[i] /= (count[i] - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0xf289(%rip), %rdx      # 0x13ec8
movslq %edi, %rax
imulq $0x28, %rax, %rdi
movl 0x2c(%rdx,%rdi), %eax
cmpl $0x64, %eax
jg 0x4d5d
leaq 0x20(%rdx), %r10
xorl %r8d, %r8d
testl %eax, %eax
cmovlel %r8d, %eax
leaq (,%rax,8), %r9
leaq 0x10991(%rip), %r11     # 0x15600
leaq 0x1034a(%rip), %rsi     # 0x14fc0
leaq 0x10663(%rip), %rcx     # 0x152e0
cmpq %r8, %r9
je 0x4c9a
andq $0x0, (%r8,%rsi)
andq $0x0, (%r8,%rcx)
andl $0x0, (%r11)
addq $0x8, %r8
addq $0x4, %r11
jmp 0x4c7d
movq 0xfe17(%rip), %r8       # 0x14ab8
movslq 0xf8d8(%rip), %r9       # 0x14580
imulq $0x28, %r9, %r9
addq %r10, %r9
addq $0x20, %r9
addq %rdi, %r10
addq $0x20, %r10
xorl %r11d, %r11d
leaq 0x1093c(%rip), %rdi     # 0x15600
movslq 0x14(%rdx), %rbx
cmpq %rbx, %r11
jge 0x4d2e
cmpl $0x0, (%r8,%r11,4)
jne 0x4d29
movq (%r10), %rbx
cvttsd2si (%rbx,%r11,8), %ebx
movq (%r9), %r14
movsd (%r14,%r11,8), %xmm0
movslq %ebx, %rbx
movl (%rdi,%rbx,4), %r14d
incl %r14d
movl %r14d, (%rdi,%rbx,4)
movsd (%rsi,%rbx,8), %xmm1
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
cvtsi2sd %r14d, %xmm3
movapd %xmm2, %xmm4
divsd %xmm3, %xmm4
addsd %xmm1, %xmm4
movsd %xmm4, (%rsi,%rbx,8)
subsd %xmm4, %xmm0
mulsd %xmm2, %xmm0
addsd (%rcx,%rbx,8), %xmm0
movsd %xmm0, (%rcx,%rbx,8)
incq %r11
jmp 0x4cc4
shlq $0x2, %rax
xorl %edx, %edx
cmpq %rdx, %rax
je 0x4d58
movl (%rdx,%rdi), %esi
decl %esi
cvtsi2sd %esi, %xmm0
movsd (%rcx), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rcx)
addq $0x4, %rdx
addq $0x8, %rcx
jmp 0x4d34
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6b3b(%rip), %rdi      # 0xb89f
callq 0x267a
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: proc_anova_parse_explanatory_variable
void
proc_anova_parse_explanatory_variable(void)
{
	int n = 1;

	xx[0] = proc_anova_get_var_index();

	scan();

	switch (token) {

	case '*': // name * name ...

		do {
			scan();
			if (token != NAME)
				expected("variable name");
			if (n == MAXVAR)
				stop("Too many interaction terms");
			xx[n++] = proc_anova_get_var_index();
			scan();
		} while (token == '*');
		proc_anova_add_interaction(n);
		break;

	case '|': // name | name ...

		do {
			scan();
			if (token != NAME)
				expected("variable name");
			if (n == MAXVAR)
				stop("Too many interaction terms");
			xx[n++] = proc_anova_get_var_index();
			scan();
		} while (token == '|');
		proc_anova_add_factorial(n);
		break;

	case '(': // name(name name ...)

		scan();
		while (token == NAME) {
			if (n == MAXVAR)
				stop("Too many interaction terms");
			xx[n++] = proc_anova_get_var_index();
			scan();
		};
		if (token != ')')
			expected("right parenthesis ')'");
		scan();
		proc_anova_add_nested(n);
		break;

	default:
		if (nx == MAXVAR)
			stop("Too many explanatory variables");
		xtab[nx++] = xx[0];
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
callq 0x5ca7
movl %eax, 0xea5c(%rip)      # 0x14590
callq 0x2a45
movl 0x9d55(%rip), %eax      # 0xf894
cmpl $0x7c, %eax
je 0x5bdc
cmpl $0x2a, %eax
je 0x5b8e
cmpl $0x28, %eax
jne 0x5c19
pushq $0x1
popq %rbx
leaq 0xea30(%rip), %r14      # 0x14590
callq 0x2a45
movl 0x9d29(%rip), %eax      # 0xf894
cmpl $0x3e9, %eax            # imm = 0x3E9
jne 0x5c44
cmpq $0x64, %rbx
je 0x5c52
callq 0x5ca7
movl %eax, (%r14,%rbx,4)
incq %rbx
jmp 0x5b60
pushq $0x1
popq %rbx
leaq 0xe9f8(%rip), %r14      # 0x14590
callq 0x2a45
cmpl $0x3e9, 0x9ced(%rip)    # imm = 0x3E9
jne 0x5c5e
cmpq $0x64, %rbx
je 0x5c52
callq 0x5ca7
movl %eax, (%r14,%rbx,4)
incq %rbx
callq 0x2a45
cmpl $0x2a, 0x9cc5(%rip)     # 0xf894
je 0x5b98
movl %ebx, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x5d5f
pushq $0x1
popq %rbx
leaq 0xe9aa(%rip), %r14      # 0x14590
callq 0x2a45
cmpl $0x3e9, 0x9c9f(%rip)    # imm = 0x3E9
jne 0x5c5e
cmpq $0x64, %rbx
je 0x5c52
callq 0x5ca7
movl %eax, (%r14,%rbx,4)
incq %rbx
callq 0x2a45
cmpl $0x7c, 0x9c7f(%rip)     # 0xf894
je 0x5be6
jmp 0x5c3f
movslq 0xe7c8(%rip), %rax      # 0x143e8
cmpq $0x64, %rax
je 0x5c76
movl 0xe964(%rip), %ecx      # 0x14590
leal 0x1(%rax), %edx
movl %edx, 0xe7b3(%rip)      # 0x143e8
leaq 0xeae4(%rip), %rdx      # 0x14720
movl %ecx, (%rdx,%rax,4)
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x29, %eax
jne 0x5c6a
popq %rbx
popq %r14
popq %rbp
jmp 0x2a45
leaq 0x5aae(%rip), %rdi      # 0xb707
callq 0x267a
leaq 0x5a51(%rip), %rdi      # 0xb6b6
callq 0x25a8
leaq 0x5ab1(%rip), %rdi      # 0xb722
callq 0x25a8
leaq 0x5abb(%rip), %rdi      # 0xb738
callq 0x267a
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: proc_anova_get_var_index
int
proc_anova_get_var_index(void)
{
	int i, n;
	n = dataset->nvar;
	for (i = 0; i < n; i++)
		if (strcmp(dataset->spec[i].name, strbuf) == 0)
			break;
	if (i == n) {
		snprintf(errbuf, ERRBUFLEN, "The variable name \"%s\" is not in the data set", strbuf);
		stop(errbuf);
	}
	if (dataset->spec[i].ltab == NULL) {
		snprintf(errbuf, ERRBUFLEN, "The variable \"%s\" is numeric, please change to categorical in the data step", strbuf);
		stop(errbuf);
	}
	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0xe20c(%rip), %r12      # 0x13ec8
movl 0x10(%r12), %eax
addq $0x20, %r12
xorl %r13d, %r13d
testl %eax, %eax
movl $0x0, %ebx
movl %eax, -0x2c(%rbp)
cmovgl %eax, %ebx
leaq 0xa3b4(%rip), %r14      # 0x10090
movq %r12, %r15
cmpq %r13, %rbx
je 0x5cff
movq (%r15), %rdi
movq %r14, %rsi
callq 0x2160
testl %eax, %eax
je 0x5cfc
incq %r13
addq $0x28, %r15
jmp 0x5cdf
movl %r13d, %ebx
cmpl -0x2c(%rbp), %ebx
je 0x5d23
movl %ebx, %eax
imulq $0x28, %rax, %rax
cmpq $0x0, 0x10(%r12,%rax)
je 0x5d33
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9b86(%rip), %rbx      # 0xf8b0
leaq 0x5a26(%rip), %rdx      # 0xb757
jmp 0x5d41
leaq 0x9b76(%rip), %rbx      # 0xf8b0
leaq 0x5a44(%rip), %rdx      # 0xb785
leaq 0xa348(%rip), %rcx      # 0x10090
movl $0x7d0, %esi            # imm = 0x7D0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x20e0
movq %rbx, %rdi
callq 0x267a