LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]sassafras/sassafras.c
// Function: infile_stmt
void
infile_stmt(void)
{
	if (dfilename[0])
		stop("Multiple INFILE statements");

	get_next_token();

	switch (token) {
	case STRING:
		strcpy(dfilename, strbuf);
		break;
	case KCARDS:
	case KDATALINES:
		break;
	default:
		expected("file name");
	}

	for (;;) {

		scan();
		keyword();

		switch (token) {

		case ';':
			scan();
			return;

		case KDLM:
		case KDELIMITER:
			scan();
			if (token != '=')
				expected("equals sign");
			scan();
			if (token != STRING)
				expected("string");
			if (strlen(strbuf) >= sizeof delim)
				stop("string too long");
			strcpy(delim, strbuf);
			break;

		case KFIRSTOBS:
			scan();
			if (token != '=')
				expected("equals sign");
			scan();
			if (token != NUMBER)
				expected("number");
			if (sscanf(strbuf, "%d", &firstobs) != 1)
				stop("Error in number syntax");
			break;

		default:
			expected("end of statement");
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, 0xcb08(%rip)      # 0xf440
jne 0x2974
callq 0x2b84
cmpl $0x3e9, 0xcf4b(%rip)    # imm = 0x3E9
jne 0x2950
callq 0x2593
movl 0xcf3e(%rip), %eax      # 0xf894
cmpl $0x130, %eax            # imm = 0x130
je 0x29b0
cmpl $0x136, %eax            # imm = 0x136
je 0x29b0
cmpl $0x3eb, %eax            # imm = 0x3EB
jne 0x2982
leaq 0xcace(%rip), %rdi      # 0xf440
jmp 0x29a4
callq 0xa74a
leaq 0x8a8c(%rip), %rdi      # 0xb40c
jmp 0x298e
leaq 0x8a9e(%rip), %rdi      # 0xb427
callq 0x25f2
callq 0x4081
leaq 0x13246(%rip), %rdi     # 0x15be0
movl $0x1, %esi
callq 0x21b0
leaq 0xd6e5(%rip), %rsi      # 0x10090
callq 0x2060
leaq 0xd6d9(%rip), %rbx      # 0x10090
leaq 0x8a96(%rip), %r14      # 0xb454
leaq 0xca6f(%rip), %r15      # 0xf434
callq 0x2b84
callq 0x2593
movl 0xcebf(%rip), %eax      # 0xf894
cmpl $0x139, %eax            # imm = 0x139
jne 0x2a29
callq 0x2b84
cmpl $0x3d, 0xceac(%rip)     # 0xf894
jne 0x2a95
callq 0x2b84
cmpl $0x3ea, 0xce97(%rip)    # imm = 0x3EA
jne 0x2aa1
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2190
cmpl $0x1, %eax
je 0x29c5
callq 0xa74a
leaq 0x8a33(%rip), %rdi      # 0xb457
jmp 0x298e
leal -0x137(%rax), %ecx
cmpl $0x2, %ecx
jae 0x2a81
callq 0x2b84
cmpl $0x3d, 0xce54(%rip)     # 0xf894
jne 0x2a95
callq 0x2b84
cmpl $0x3eb, 0xce43(%rip)    # imm = 0x3EB
jne 0x2ab9
leaq 0xd636(%rip), %rdi      # 0x10090
callq 0x20b0
leaq 0xcdca(%rip), %rdi      # 0xf830
cmpq $0x64, %rax
jb 0x29a4
callq 0xa74a
leaq 0x89c1(%rip), %rdi      # 0xb43d
jmp 0x298e
cmpl $0x3b, %eax
jne 0x2aad
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2b84
leaq 0x8995(%rip), %rdi      # 0xb431
callq 0x25f2
leaq 0x89a5(%rip), %rdi      # 0xb44d
callq 0x25f2
leaq 0x904a(%rip), %rdi      # 0xbafe
callq 0x25f2
leaq 0x9090(%rip), %rdi      # 0xbb50
callq 0x25f2
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]sassafras/sassafras.c
// Function: parse_default
void
parse_default(void)
{
	switch (token) {
	case ';':
		scan();
		break;
	case '*':
		parse_comment_stmt();
		break;
	case KTITLE:
		title_stmt();
		break;
	case KTITLE1:
		title1_stmt();
		break;
	case KTITLE2:
		title2_stmt();
		break;
	case KTITLE3:
		title3_stmt();
		break;
	default:
		stop("Unexpected token, did you mean proc?");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0xcdc5(%rip), %eax      # 0xf894
leal -0x151(%rax), %ecx
cmpl $0x3, %ecx
ja 0x2af0
leaq 0x853f(%rip), %rax      # 0xb020
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
popq %rbp
jmp 0x4101
cmpl $0x2a, %eax
je 0x2b06
cmpl $0x3b, %eax
jne 0x2b32
popq %rbp
jmp 0x2b84
popq %rbp
jmp 0x4211
movq 0xcd8b(%rip), %rax      # 0xf898
incq %rax
movzbl -0x1(%rax), %ecx
testl %ecx, %ecx
je 0x2afa
cmpl $0x3b, %ecx
je 0x2afa
movq %rax, 0xcd74(%rip)      # 0xf898
jmp 0x2b0d
popq %rbp
jmp 0x4299
popq %rbp
jmp 0x4189
callq 0xa74a
leaq 0x8a5d(%rip), %rdi      # 0xb59b
callq 0x4081
leaq 0x13096(%rip), %rdi     # 0x15be0
movl $0x1, %esi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]sassafras/sassafras.c
// Function: get_data
void
get_data(void)
{
	alloc_data_vectors();
	getbuf();
	while (inb) {
		check_data_vectors();
		get_data1();
		dd->nobs++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x2c5e
callq 0x2cb3
cmpq $0x0, 0xd90e(%rip)      # 0x10478
je 0x2b82
callq 0x2d92
callq 0x2dfc
movq 0xd503(%rip), %rax      # 0x10080
incl 0x14(%rax)
jmp 0x2b62
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]sassafras/sassafras.c
// Function: scan
void
scan(void)
{
	static int t;

	if (inp == pgm)
		t = 0; // initial state
	else
		t = token;

	token = scan1();

	// ensure last token is semicolon

	if (token == 0 && t && t != ';') {
		strbuf[0] = ';';
		strbuf[1] = 0;
		token = ';';
	}
}

// Assembly:
movq 0xcd0d(%rip), %rcx      # 0xf898
xorl %eax, %eax
cmpq 0x13114(%rip), %rcx     # 0x15ca8
je 0x2b9c
movl 0xccf8(%rip), %eax      # 0xf894
pushq %rbp
movq %rsp, %rbp
movl %eax, 0x1310a(%rip)     # 0x15cb0
callq 0xa814
movl %eax, 0xcce3(%rip)      # 0xf894
testl %eax, %eax
popq %rbp
je 0x2bb7
retq
movl 0x130f3(%rip), %eax     # 0x15cb0
testl %eax, %eax
je 0x2bb6
cmpl $0x3b, %eax
je 0x2bb6
movw $0x3b, 0xd4c1(%rip)     # 0x10090
movl $0x3b, 0xccbb(%rip)     # 0xf894
retq
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]sassafras/sassafras.c
// Function: xmalloc
void *
xmalloc(int size)
{
	void *p = malloc(size);
	if (p == NULL)
		exit(1);
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq %edi, %rdi
callq 0x2180
testq %rax, %rax
je 0x2bed
popq %rbp
retq
movl $0x1, %edi
callq 0x21f0
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]sassafras/sassafras.c
// Function: alloc_data_vectors
void
alloc_data_vectors(void)
{
	int i;
	for (i = 0; i < dd->nvar; i++)
		if (dd->spec[i].v == NULL)
			dd->spec[i].v = (double *) xmalloc(dd->max * sizeof (double));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0xd414(%rip), %rax      # 0x10080
cmpl $0x0, 0x10(%rax)
jle 0x2cae
movl $0x40, %ebx
xorl %r14d, %r14d
cmpq $0x0, (%rax,%rbx)
jne 0x2c97
movl 0x18(%rax), %edi
shll $0x3, %edi
callq 0x2bda
movq 0xd3ed(%rip), %rcx      # 0x10080
movq %rax, (%rcx,%rbx)
incq %r14
movq 0xd3df(%rip), %rax      # 0x10080
movslq 0x10(%rax), %rcx
addq $0x28, %rbx
cmpq %rcx, %r14
jl 0x2c7a
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]sassafras/sassafras.c
// Function: getbuf
void
getbuf(void)
{
	do {
		if (infile)
			for (;;) {
				inb = fgets(bigbuf, BIGBUFLEN, infile);
				if (inb == NULL || firstobs < 2)
					break;
				firstobs--;
			}
		else
			inb = get_dataline(bigbuf, BIGBUFLEN);

		if (inb == NULL)
			return;

		// skip spaces

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

	} while (*inb == 0); // skip blank lines
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x10200(%rip), %rbx     # 0x12ec0
cmpq $0x0, 0xcbd8(%rip)      # 0xf8a0
je 0x2d30
movq 0xcbcf(%rip), %rdx      # 0xf8a0
movq %rbx, %rdi
movl $0xfa0, %esi            # imm = 0xFA0
callq 0x2140
movq %rax, 0xd793(%rip)      # 0x10478
testq %rax, %rax
sete %cl
movl 0xc743(%rip), %eax      # 0xf434
cmpl $0x2, %eax
setl %dl
orb %cl, %dl
jne 0x2d44
decl %eax
movl %eax, 0xc731(%rip)      # 0xf434
movq 0xcb96(%rip), %rdx      # 0xf8a0
movq %rbx, %rdi
movl $0xfa0, %esi            # imm = 0xFA0
callq 0x2140
movq %rax, 0xd75a(%rip)      # 0x10478
testq %rax, %rax
je 0x2d44
movl 0xc70b(%rip), %eax      # 0xf434
cmpl $0x2, %eax
jge 0x2cfb
jmp 0x2d44
movq %rbx, %rdi
movl $0xfa0, %esi            # imm = 0xFA0
callq 0x3600
movq %rax, 0xd734(%rip)      # 0x10478
cmpq $0x0, 0xd72c(%rip)      # 0x10478
je 0x2d8b
callq 0x2230
movq (%rax), %rsi
movq 0xd71b(%rip), %rcx      # 0x10478
movsbq (%rcx), %rdx
testb $0x20, 0x1(%rsi,%rdx,2)
je 0x2d83
incq %rcx
movq %rcx, 0xd706(%rip)      # 0x10478
movq (%rax), %rsi
movsbq (%rcx), %rdx
incq %rcx
testb $0x20, 0x1(%rsi,%rdx,2)
jne 0x2d6b
testb %dl, %dl
je 0x2cc0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]sassafras/sassafras.c
// Function: check_data_vectors
void
check_data_vectors(void)
{
	int i;
	if (dd->nobs < dd->max)
		return;
	dd->max += 1000;
	for (i = 0; i < dd->nvar; i++)
		dd->spec[i].v = xrealloc(dd->spec[i].v, dd->max * sizeof (double));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0xd2e0(%rip), %rax      # 0x10080
movl 0x18(%rax), %ecx
cmpl %ecx, 0x14(%rax)
jl 0x2df7
addl $0x3e8, %ecx            # imm = 0x3E8
movl %ecx, 0x18(%rax)
movq 0xd2c8(%rip), %rax      # 0x10080
cmpl $0x0, 0x10(%rax)
jle 0x2df7
movl $0x40, %ebx
xorl %r14d, %r14d
movq (%rax,%rbx), %rdi
movl 0x18(%rax), %esi
shll $0x3, %esi
callq 0x35e3
movq 0xd2a4(%rip), %rcx      # 0x10080
movq %rax, (%rcx,%rbx)
incq %r14
movq 0xd296(%rip), %rax      # 0x10080
movslq 0x10(%rax), %rcx
addq $0x28, %rbx
cmpq %rcx, %r14
jl 0x2dc6
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xd32e(%rip), %r15      # 0x10478
leaq 0xc6df(%rip), %rbx      # 0xf830
movsbl (%r15), %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x20c0
incq %r15
cmpl $0x2e, %r14d
je 0x316e
testq %rax, %rax
je 0x3151
xorl %eax, %eax
cmpb $0x2e, %r14b
jne 0x319a
callq 0x2230
movq (%rax), %rcx
xorl %edx, %edx
movsbq (%r15,%rdx), %rsi
leaq 0x1(%rdx), %rax
testb $0x8, 0x1(%rcx,%rsi,2)
je 0x3198
cmpl $0x8, %edx
movq %rax, %rdx
jb 0x3180
decl %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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)
movsd 0x812b(%rip), %xmm0     # 0xb2f0
cmpq $0x0, 0xd2ab(%rip)      # 0x10478
je 0x32b6
callq 0x2230
movq (%rax), %rdx
movq 0xd296(%rip), %rbx      # 0x10478
movsbq (%rbx), %rcx
testb $0x20, 0x1(%rdx,%rcx,2)
je 0x320b
incq %rbx
movq %rbx, 0xd281(%rip)      # 0x10478
movq (%rax), %rdx
movsbq (%rbx), %rcx
incq %rbx
testb $0x20, 0x1(%rdx,%rcx,2)
jne 0x31f0
decq %rbx
movsd 0x80dd(%rip), %xmm0     # 0xb2f0
testb %cl, %cl
je 0x32b6
movsbl %cl, %esi
leaq 0xc60b(%rip), %rdi      # 0xf830
callq 0x20c0
testq %rax, %rax
je 0x3243
incq %rbx
movq %rbx, 0xd23f(%rip)      # 0x10478
movsd 0x80af(%rip), %xmm0     # 0xb2f0
jmp 0x32b6
leaq 0x8260(%rip), %rsi      # 0xb4aa
leaq -0x20(%rbp), %rdx
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2190
movq 0xd219(%rip), %r14      # 0x10478
movb (%r14), %r15b
movsbl %r15b, %esi
leaq 0xc5c3(%rip), %rdi      # 0xf830
callq 0x20c0
testq %rax, %rax
jne 0x32a2
incq %r14
leaq 0xc5af(%rip), %rbx      # 0xf830
movq %r14, 0xd1f0(%rip)      # 0x10478
movb (%r14), %r15b
movsbl %r15b, %esi
movq %rbx, %rdi
callq 0x20c0
incq %r14
testq %rax, %rax
je 0x3281
decq %r14
testb %r15b, %r15b
je 0x32b1
incq %r14
movq %r14, 0xd1c7(%rip)      # 0x10478
movsd -0x20(%rbp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
movb $0x0, 0x10b8d(%rip)     # 0x13e60
cmpq $0x0, 0xd19d(%rip)      # 0x10478
je 0x3441
callq 0x2230
movq %rax, %rbx
movq (%rax), %rcx
movq 0xd185(%rip), %r15      # 0x10478
movsbq (%r15), %rax
testb $0x20, 0x1(%rcx,%rax,2)
je 0x331c
incq %r15
movq %r15, 0xd170(%rip)      # 0x10478
movq (%rbx), %rcx
movsbq (%r15), %rax
incq %r15
testb $0x20, 0x1(%rcx,%rax,2)
jne 0x3301
decq %r15
testb %al, %al
je 0x3441
movsbl %al, %esi
leaq 0xc502(%rip), %rdi      # 0xf830
callq 0x20c0
testq %rax, %rax
je 0x3340
movq %r15, %r12
jmp 0x3437
movq 0xd131(%rip), %r12      # 0x10478
movsbl (%r12), %esi
leaq 0xc4dd(%rip), %rdi      # 0xf830
callq 0x20c0
testq %rax, %rax
jne 0x3386
incq %r12
leaq 0xc4c9(%rip), %r14      # 0xf830
movq %r12, 0xd10a(%rip)      # 0x10478
movsbl (%r12), %esi
movq %r14, %rdi
callq 0x20c0
incq %r12
testq %rax, %rax
je 0x3367
decq %r12
movabsq $0x100000000, %rax      # imm = 0x100000000
movq (%rbx), %rsi
movq %r15, %rdx
shlq $0x20, %rdx
movq %r12, %rcx
shlq $0x20, %rcx
subq %rcx, %rdx
xorl %ecx, %ecx
movsbq -0x1(%r12,%rcx), %rdi
decq %rcx
addq %rax, %rdx
testb $0x20, 0x1(%rsi,%rdi,2)
jne 0x33a6
movabsq $-0x6200000001, %rsi    # imm = 0xFFFFFF9DFFFFFFFF
subq %rdx, %rsi
movabsq $-0x6400000002, %rdi    # imm = 0xFFFFFF9BFFFFFFFE
cmpq %rdi, %rsi
jbe 0x344a
movl %r12d, %esi
subl %r15d, %esi
leaq (%rsi,%rcx), %rdi
testl %edi, %edi
jne 0x33e9
cmpb $0x2e, (%r15)
je 0x3441
addq %rcx, %rsi
incq %rsi
subq %rdx, %rax
testl %esi, %esi
jle 0x3421
movq %r12, %rdx
subq %r15, %rdx
addq %rdx, %rcx
incq %rcx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
leaq 0x10a4f(%rip), %rsi     # 0x13e60
movb (%r15,%rdx), %dil
movb %dil, (%rdx,%rsi)
incq %rdx
cmpq %rcx, %rdx
jb 0x3411
sarq $0x20, %rax
leaq 0x10a34(%rip), %rcx     # 0x13e60
movb $0x0, (%rax,%rcx)
cmpb $0x0, (%r12)
je 0x3441
incq %r12
movq %r12, 0xd037(%rip)      # 0x10478
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0xa74a
leaq 0x8058(%rip), %rdi      # 0xb4ae
callq 0x4081
leaq 0x1277e(%rip), %rdi     # 0x15be0
movl $0x1, %esi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/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 $0x18, %rsp
movl %esi, %r14d
movq 0xcbf9(%rip), %r12      # 0x10080
cmpb $0x0, 0x109d2(%rip)     # 0x13e60
movslq %edi, %r15
je 0x34ed
addq $0x20, %r12
leaq (%r15,%r15,4), %rax
movl 0x8(%r12,%rax,8), %edx
movl 0xc(%r12,%rax,8), %ebx
testl %ebx, %ebx
jle 0x34f7
movq %rdx, -0x38(%rbp)
movq %r15, -0x40(%rbp)
movl %r14d, -0x2c(%rbp)
movq 0x10(%r12,%rax,8), %r15
xorl %r13d, %r13d
leaq 0x1099c(%rip), %r14     # 0x13e60
movq (%r15,%r13,8), %rdi
movq %r14, %rsi
callq 0x2160
testl %eax, %eax
je 0x34df
incq %r13
cmpq %r13, %rbx
jne 0x34c4
movl %ebx, %r13d
movl -0x2c(%rbp), %r14d
movq -0x40(%rbp), %r15
movq -0x38(%rbp), %rdx
jmp 0x34fa
movsd 0x7dfb(%rip), %xmm0     # 0xb2f0
jmp 0x3576
xorl %r13d, %r13d
cmpl %ebx, %r13d
jne 0x356a
cmpl %ebx, %edx
jne 0x3534
leal 0x64(%rdx), %eax
leaq (,%r15,8), %rcx
leaq (%rcx,%rcx,4), %rbx
movl %eax, 0x8(%r12,%rbx)
movq 0x10(%r12,%rbx), %rdi
leal 0x320(,%rdx,8), %esi
callq 0x35e3
movq 0xcb51(%rip), %rcx      # 0x10080
movq %rax, 0x30(%rcx,%rbx)
leaq 0x10925(%rip), %rdi     # 0x13e60
callq 0x2210
movq 0xcb39(%rip), %rcx      # 0x10080
leaq (,%r15,8), %rdx
leaq (%rdx,%rdx,4), %rdx
movq 0x30(%rcx,%rdx), %rcx
movl %r13d, %esi
movq %rax, (%rcx,%rsi,8)
movq 0xcb1a(%rip), %rax      # 0x10080
incl 0x2c(%rax,%rdx)
cvtsi2sd %r13d, %xmm0
movq 0xcb0a(%rip), %r12      # 0x10080
leaq (%r15,%r15,4), %rax
movq 0x40(%r12,%rax,8), %rax
movslq %r14d, %rcx
movsd %xmm0, (%rax,%rcx,8)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
cmpq $0x0, 0xceda(%rip)      # 0x10478
je 0x35e2
pushq %rbp
movq %rsp, %rbp
callq 0x2230
movq (%rax), %rsi
movq 0xcec5(%rip), %rcx      # 0x10478
movsbq (%rcx), %rdx
testb $0x20, 0x1(%rsi,%rdx,2)
je 0x35d9
incq %rcx
movq %rcx, 0xceb0(%rip)      # 0x10478
movq (%rax), %rsi
movsbq (%rcx), %rdx
incq %rcx
testb $0x20, 0x1(%rsi,%rdx,2)
jne 0x35c1
testb %dl, %dl
popq %rbp
je 0x2cb3
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x35f6
popq %rbp
retq
movl $0x1, %edi
callq 0x21f0
// File: /workspace/github_c_makefile_star2_O1/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 0xc281(%rip), %rax      # 0xf898
incq %rax
movzbl -0x1(%rax), %ecx
cmpl $0xc, %ecx
jg 0x362e
testl %ecx, %ecx
je 0x36a0
cmpl $0xa, %ecx
jne 0x3638
jmp 0x364b
cmpl $0xd, %ecx
je 0x3641
cmpl $0x3b, %ecx
je 0x36a0
movq %rax, 0xc259(%rip)      # 0xf898
jmp 0x3617
movl $0x2, %ecx
cmpb $0xa, (%rax)
je 0x3650
movl $0x1, %ecx
leaq (%rax,%rcx), %r15
decq %r15
callq 0x2230
movq %r15, 0xc235(%rip)      # 0xf898
movq (%rax), %rcx
movsbq (%r15), %rsi
movzbl %sil, %edx
movzwl (%rcx,%rsi,2), %ecx
btl $0xd, %ecx
jae 0x3687
cmpl $0xa, %edx
je 0x36a0
incq %r15
cmpl $0xd, %edx
jne 0x365c
jmp 0x36a0
xorl %eax, %eax
movabsq $0x800000000002401, %rcx # imm = 0x800000000002401
cmpl $0x3b, %edx
ja 0x36b0
movl %edx, %edx
btq %rdx, %rcx
jae 0x36b0
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leal -0x1(%r14), %edx
cmpl $0x2, %r14d
jl 0x36f7
movl %edx, %esi
xorl %eax, %eax
movq 0xc1d3(%rip), %rdi      # 0xf898
leaq 0x1(%rdi), %r8
movq %r8, 0xc1c8(%rip)       # 0xf898
movb (%rdi), %dil
movb %dil, (%rbx,%rax)
movq 0xc1ba(%rip), %rdi      # 0xf898
movzbl (%rdi), %edi
cmpq $0x3b, %rdi
ja 0x36ed
btq %rdi, %rcx
jb 0x36f7
incq %rax
cmpq %rax, %rsi
jne 0x36be
movl %edx, %eax
cmpl %edx, %eax
je 0x3704
movl %eax, %eax
movb $0x0, 0x1(%rbx,%rax)
jmp 0x36a2
callq 0xa74a
leaq 0x7fb6(%rip), %rdi      # 0xb6c6
callq 0x4081
leaq 0x124c4(%rip), %rdi     # 0x15be0
movl $0x1, %esi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/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 0xc945(%rip), %rax      # 0x10080
movq 0x8(%rax), %rsi
movl 0x10(%rax), %edx
leaq 0x7d94(%rip), %rdi      # 0xb4dd
xorl %eax, %eax
callq 0x20d0
movq 0xc929(%rip), %rax      # 0x10080
cmpl $0x0, 0x10(%rax)
jle 0x3792
movl $0x20, %r14d
leaq 0x81ca(%rip), %rbx      # 0xb934
xorl %r15d, %r15d
movq (%rax,%r14), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x20d0
incq %r15
movq 0xc8fb(%rip), %rax      # 0x10080
movslq 0x10(%rax), %rcx
addq $0x28, %r14
cmpq %rcx, %r15
jl 0x376d
movl $0xa, %edi
callq 0x2050
movq 0xc8dd(%rip), %rax      # 0x10080
cmpl $0x0, 0x14(%rax)
jle 0x383c
leaq 0x7d40(%rip), %rbx      # 0xb4f4
leaq 0x8179(%rip), %r14      # 0xb934
xorl %r15d, %r15d
movq 0xc8bb(%rip), %rax      # 0x10080
cmpl $0x0, 0x10(%rax)
jle 0x381f
movl $0x40, %r12d
xorl %r13d, %r13d
movq -0x10(%rax,%r12), %rcx
movq (%rax,%r12), %rax
movsd (%rax,%r15,8), %xmm0
testq %rcx, %rcx
je 0x37fe
cvttsd2si %xmm0, %eax
cltq
movq (%rcx,%rax,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x20d0
jmp 0x3808
movq %rbx, %rdi
movb $0x1, %al
callq 0x20d0
incq %r13
movq 0xc86e(%rip), %rax      # 0x10080
movslq 0x10(%rax), %rcx
addq $0x28, %r12
cmpq %rcx, %r13
jl 0x37d4
movl $0xa, %edi
callq 0x2050
incq %r15
movq 0xc84d(%rip), %rax      # 0x10080
movslq 0x14(%rax), %rax
cmpq %rax, %r15
jl 0x37be
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
movq 0xc827(%rip), %rbx      # 0x10080
testq %rbx, %rbx
je 0x38bf
movq (%rbx), %rax
movq %rax, 0xc818(%rip)      # 0x10080
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3876
callq 0x2040
movl $0x40, %r14d
movq -0x20(%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x388b
callq 0x2040
movq (%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x3899
callq 0x2040
movq -0x10(%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x38a8
callq 0x2040
addq $0x28, %r14
cmpq $0xfe0, %r14            # imm = 0xFE0
jne 0x387c
movq %rbx, %rdi
callq 0x2040
jmp 0x3852
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xc7ae(%rip), %rax      # 0x10080
movq %rax, 0x105ef(%rip)     # 0x13ec8
testq %rdi, %rdi
je 0x390e
movq %rdi, %rbx
movq 0x105e0(%rip), %r14     # 0x13ec8
testq %r14, %r14
je 0x3913
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x3902
movq %rbx, %rsi
callq 0x2160
testl %eax, %eax
je 0x390e
movq (%r14), %r14
movq %r14, 0x105bc(%rip)     # 0x13ec8
jmp 0x38e8
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xbf96(%rip), %r14      # 0xf8b0
leaq 0x7bd7(%rip), %rdx      # 0xb4f8
movl $0x7d0, %esi            # imm = 0x7D0
movq %r14, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x20e0
callq 0xa74a
movq %r14, %rdi
callq 0x4081
leaq 0x12299(%rip), %rdi     # 0x15be0
movl $0x1, %esi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
pushq %rax
callq 0x39fa
movl $0x5, %ebx
movl 0xbec3(%rip), %eax      # 0xf894
cmpl $0x2a, %eax
je 0x39e0
cmpl $0x2f, %eax
jne 0x39f3
movl $0x6, %ebx
callq 0x2b84
callq 0x39fa
movl %ebx, %edi
callq 0x2bf7
jmp 0x39c6
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xbe90(%rip), %eax      # 0xf894
cmpl $0x28, %eax
je 0x3a31
cmpl $0x3ea, %eax            # imm = 0x3EA
je 0x3a2a
cmpl $0x3e9, %eax            # imm = 0x3E9
jne 0x3a44
cmpl $0x474f4c, 0xc66f(%rip) # imm = 0x474F4C
jne 0x3a66
callq 0x3abe
jmp 0x3a70
callq 0x3c0b
jmp 0x3a6b
callq 0x2b84
callq 0x3951
cmpl $0x29, 0xbe52(%rip)     # 0xf894
je 0x3a6b
callq 0xa74a
leaq 0x7ac1(%rip), %rdi      # 0xb511
callq 0x4081
leaq 0x12184(%rip), %rdi     # 0x15be0
movl $0x1, %esi
callq 0x21b0
callq 0x3b5b
callq 0x2b84
cmpl $0x3ed, 0xbe1a(%rip)    # imm = 0x3ED
jne 0x3a9d
callq 0x2b84
movl 0xbe0d(%rip), %eax      # 0xf894
cmpl $0x2d, %eax
je 0x3a9f
cmpl $0x2b, %eax
jne 0x3a96
callq 0x2b84
callq 0x39fa
jmp 0x3ab3
popq %rbp
retq
callq 0x2b84
callq 0x39fa
movl $0x2, %edi
callq 0x2bf7
movl $0x7, %edi
popq %rbp
jmp 0x2bf7
// File: /workspace/github_c_makefile_star2_O1/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 (%rax), %rsi
movq 0xbdc7(%rip), %rdx      # 0xf898
movsbq (%rdx), %rcx
movzwl (%rsi,%rcx,2), %esi
btl $0xd, %esi
jae 0x3b17
movzbl %cl, %esi
cmpl $0xa, %esi
je 0x3b17
cmpl $0xd, %esi
je 0x3b17
incq %rdx
movq %rdx, 0xbda2(%rip)      # 0xf898
movq (%rax), %rsi
movsbq (%rdx), %rcx
movzwl (%rsi,%rcx,2), %esi
btl $0xd, %esi
jae 0x3b17
movzbl %cl, %esi
cmpl $0xd, %esi
je 0x3b17
incq %rdx
cmpl $0xa, %esi
jne 0x3aef
cmpb $0x28, %cl
jne 0x3b44
callq 0x2b84
callq 0x2b84
callq 0x3951
cmpl $0x29, 0xbd62(%rip)     # 0xf894
jne 0x3b4f
callq 0x2b84
movl $0x8, %edi
popq %rbp
jmp 0x2bf7
callq 0x3b5b
popq %rbp
jmp 0x2b84
leaq 0x79c8(%rip), %rdi      # 0xb51e
callq 0x25f2
// File: /workspace/github_c_makefile_star2_O1/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 0xc510(%rip), %r15      # 0x10080
movl 0x10(%r15), %r12d
testl %r12d, %r12d
jle 0x3ba7
leaq 0x20(%r15), %r13
xorl %ebx, %ebx
leaq 0xc50a(%rip), %r14      # 0x10090
movq (%r13), %rdi
movq %r14, %rsi
callq 0x2160
testl %eax, %eax
je 0x3ba9
incq %rbx
addq $0x28, %r13
cmpq %rbx, %r12
jne 0x3b86
movl %r12d, %ebx
jmp 0x3ba9
xorl %ebx, %ebx
cmpl %r12d, %ebx
je 0x3bdb
movl %ebx, %eax
leaq (%rax,%rax,4), %rax
cmpq $0x0, 0x30(%r15,%rax,8)
jne 0x3be9
movl $0xa, %edi
callq 0x2bf7
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2bf7
callq 0xa74a
leaq 0x7951(%rip), %rdi      # 0xb538
jmp 0x3bf5
callq 0xa74a
leaq 0x7956(%rip), %rdi      # 0xb54b
callq 0x4081
leaq 0x11fdf(%rip), %rdi     # 0x15be0
movl $0x1, %esi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/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 0x3f45
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
callq 0x3f6f
testq %rax, %rax
je 0x3f53
movq %rax, %r14
movq %rax, %rdi
callq 0x4007
movq %r14, %rdi
callq 0x2040
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7cee(%rip), %rdi      # 0xbc3a
callq 0x2070
jmp 0x3f65
movq 0x8(%rbx), %rsi
leaq 0x7626(%rip), %rdi      # 0xb584
xorl %eax, %eax
callq 0x20d0
movl $0x1, %edi
callq 0x21f0
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]sassafras/sassafras.c
// Function: run
void
run(char *s)
{
	if (s == NULL)
		return;

	emit_line_init();

	run_nib(s);

	// clean up (always gets here, even on stop)

	if (infile) {
		fclose(infile);
		infile = NULL;
	}

	free_datasets();

	xfree(title);
	xfree(title1);
	xfree(title2);
	xfree(title3);
}

// Assembly:
testq %rdi, %rdi
je 0x407a
pushq %rbp
movq %rsp, %rbp
callq 0xa66b
movq 0xb884(%rip), %rdi      # 0xf8a0
testq %rdi, %rdi
je 0x4031
callq 0x20a0
movq $0x0, 0xb86f(%rip) # 0xf8a0
callq 0x384b
movq 0x1038b(%rip), %rdi     # 0x143c8
testq %rdi, %rdi
je 0x4047
callq 0x2040
movq 0x10382(%rip), %rdi     # 0x143d0
testq %rdi, %rdi
je 0x4058
callq 0x2040
movq 0x10379(%rip), %rdi     # 0x143d8
testq %rdi, %rdi
je 0x4069
callq 0x2040
movq 0x10370(%rip), %rdi     # 0x143e0
testq %rdi, %rdi
popq %rbp
jne 0x2040
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
movq %rdi, %rbx
callq 0x20b0
cmpl $0x4e, %eax
jg 0x40cb
movl $0x50, %ecx
subl %eax, %ecx
movl %ecx, %eax
shrl $0x1f, %eax
addl %ecx, %eax
sarl %eax
cmpl $0x2, %eax
movl $0x1, %r14d
cmovgel %eax, %r14d
movl $0x20, %edi
callq 0x2050
decl %r14d
jne 0x40bc
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2070
// File: /workspace/github_c_makefile_star2_O1/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 0x2b84
cmpl $0x3eb, 0xb780(%rip)    # imm = 0x3EB
jne 0x415b
movq 0x102ab(%rip), %rdi     # 0x143c8
testq %rdi, %rdi
je 0x4127
callq 0x2040
cmpb $0x0, 0xbf62(%rip)      # 0x10090
je 0x413e
leaq 0xbf59(%rip), %rdi      # 0x10090
callq 0x2210
jmp 0x4140
xorl %eax, %eax
movq %rax, 0x10281(%rip)     # 0x143c8
callq 0x2b84
cmpl $0x3b, 0xb741(%rip)     # 0xf894
jne 0x4167
popq %rbp
jmp 0x2b84
leaq 0x79ee(%rip), %rdi      # 0xbb50
callq 0x25f2
callq 0xa74a
leaq 0x7391(%rip), %rdi      # 0xb504
callq 0x4081
leaq 0x11a61(%rip), %rdi     # 0x15be0
movl $0x1, %esi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/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 0x2b84
cmpl $0x3eb, 0xb6f8(%rip)    # imm = 0x3EB
jne 0x41e3
movq 0x1022b(%rip), %rdi     # 0x143d0
testq %rdi, %rdi
je 0x41af
callq 0x2040
cmpb $0x0, 0xbeda(%rip)      # 0x10090
je 0x41c6
leaq 0xbed1(%rip), %rdi      # 0x10090
callq 0x2210
jmp 0x41c8
xorl %eax, %eax
movq %rax, 0x10201(%rip)     # 0x143d0
callq 0x2b84
cmpl $0x3b, 0xb6b9(%rip)     # 0xf894
jne 0x41ef
popq %rbp
jmp 0x2b84
leaq 0x7966(%rip), %rdi      # 0xbb50
callq 0x25f2
callq 0xa74a
leaq 0x7309(%rip), %rdi      # 0xb504
callq 0x4081
leaq 0x119d9(%rip), %rdi     # 0x15be0
movl $0x1, %esi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/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 0x2b84
cmpl $0x3eb, 0xb670(%rip)    # imm = 0x3EB
jne 0x426b
movq 0x101ab(%rip), %rdi     # 0x143d8
testq %rdi, %rdi
je 0x4237
callq 0x2040
cmpb $0x0, 0xbe52(%rip)      # 0x10090
je 0x424e
leaq 0xbe49(%rip), %rdi      # 0x10090
callq 0x2210
jmp 0x4250
xorl %eax, %eax
movq %rax, 0x10181(%rip)     # 0x143d8
callq 0x2b84
cmpl $0x3b, 0xb631(%rip)     # 0xf894
jne 0x4277
popq %rbp
jmp 0x2b84
leaq 0x78de(%rip), %rdi      # 0xbb50
callq 0x25f2
callq 0xa74a
leaq 0x7281(%rip), %rdi      # 0xb504
callq 0x4081
leaq 0x11951(%rip), %rdi     # 0x15be0
movl $0x1, %esi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/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 0x2b84
cmpl $0x3eb, 0xb5e8(%rip)    # imm = 0x3EB
jne 0x42f3
movq 0x1012b(%rip), %rdi     # 0x143e0
testq %rdi, %rdi
je 0x42bf
callq 0x2040
cmpb $0x0, 0xbdca(%rip)      # 0x10090
je 0x42d6
leaq 0xbdc1(%rip), %rdi      # 0x10090
callq 0x2210
jmp 0x42d8
xorl %eax, %eax
movq %rax, 0x10101(%rip)     # 0x143e0
callq 0x2b84
cmpl $0x3b, 0xb5a9(%rip)     # 0xf894
jne 0x42ff
popq %rbp
jmp 0x2b84
leaq 0x7856(%rip), %rdi      # 0xbb50
callq 0x25f2
callq 0xa74a
leaq 0x71f9(%rip), %rdi      # 0xb504
callq 0x4081
leaq 0x118c9(%rip), %rdi     # 0x15be0
movl $0x1, %esi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/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 0x2b84
cmpl $0x3d, 0xb563(%rip)     # 0xf894
jne 0x436e
callq 0x2b84
cmpl $0x3ea, 0xb552(%rip)    # imm = 0x3EA
jne 0x437a
leaq 0xbd45(%rip), %rdi      # 0x10090
callq 0x2080
movsd %xmm0, 0xfb80(%rip)     # 0x13ed8
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x4386
ucomisd 0x6f8e(%rip), %xmm0     # 0xb2f8
ja 0x4386
popq %rbp
retq
leaq 0x70bc(%rip), %rdi      # 0xb431
callq 0x25f2
leaq 0x70cc(%rip), %rdi      # 0xb44d
callq 0x25f2
leaq 0x7233(%rip), %rdi      # 0xb5c0
callq 0x25f2
// File: /workspace/github_c_makefile_star2_O1/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 0x2b84
cmpl $0x3d, 0xb4f2(%rip)     # 0xf894
jne 0x43c2
callq 0x2b84
cmpl $0x3e9, 0xb4e1(%rip)    # imm = 0x3E9
jne 0x43d0
leaq 0xbcd4(%rip), %rdi      # 0x10090
popq %rbp
jmp 0x38c4
callq 0xa74a
leaq 0x7209(%rip), %rdi      # 0xb5d7
jmp 0x43dc
callq 0xa74a
leaq 0x7208(%rip), %rdi      # 0xb5e4
callq 0x4081
leaq 0x117f8(%rip), %rdi     # 0x15be0
movl $0x1, %esi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/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 0x2b84
cmpl $0x3d, 0xb492(%rip)     # 0xf894
jne 0x4437
callq 0x2b84
cmpl $0x3ea, 0xb481(%rip)    # imm = 0x3EA
jne 0x4445
cvttsd2si 0xfab3(%rip), %eax # 0x13ed0
xorl %ecx, %ecx
testl %eax, %eax
cmovgl %eax, %ecx
cmpl $0x8, %ecx
movl $0x8, %eax
cmovll %ecx, %eax
movl %eax, 0xfaab(%rip)      # 0x13ee0
popq %rbp
retq
callq 0xa74a
leaq 0x7194(%rip), %rdi      # 0xb5d7
jmp 0x4451
callq 0xa74a
leaq 0x71a6(%rip), %rdi      # 0xb5f7
callq 0x4081
leaq 0x11783(%rip), %rdi     # 0x15be0
movl $0x1, %esi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/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 0xbc14(%rip), %rbx      # 0x10090
callq 0x2b84
movl 0xb40d(%rip), %eax      # 0xf894
cmpl $0x3e9, %eax            # imm = 0x3E9
jne 0x44f9
movq 0xfa33(%rip), %r15      # 0x13ec8
movl 0x10(%r15), %r13d
testl %r13d, %r13d
jle 0x44c5
leaq 0x20(%r15), %r14
xorl %r12d, %r12d
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x2160
testl %eax, %eax
je 0x44c8
incq %r12
addq $0x28, %r14
cmpq %r12, %r13
jne 0x44a5
movl %r13d, %r12d
jmp 0x44c8
xorl %r12d, %r12d
cmpl %r13d, %r12d
je 0x4511
movl %r12d, %eax
leaq (%rax,%rax,4), %rax
cmpq $0x0, 0x30(%r15,%rax,8)
je 0x4521
movslq 0xfb9d(%rip), %rax      # 0x14080
leal 0x1(%rax), %ecx
movl %ecx, 0xfb94(%rip)      # 0x14080
leaq 0xf9fd(%rip), %rcx      # 0x13ef0
movl %r12d, (%rcx,%rax,4)
jmp 0x447c
cmpl $0x3b, %eax
jne 0x454f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b84
leaq 0xb398(%rip), %rbx      # 0xf8b0
leaq 0x70ff(%rip), %rdx      # 0xb61e
jmp 0x452f
leaq 0xb388(%rip), %rbx      # 0xf8b0
leaq 0x7112(%rip), %rdx      # 0xb641
leaq 0xbb5a(%rip), %rcx      # 0x10090
movl $0x7d0, %esi            # imm = 0x7D0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x20e0
callq 0xa74a
movq %rbx, %rdi
jmp 0x455b
callq 0xa74a
leaq 0x70ac(%rip), %rdi      # 0xb607
callq 0x4081
leaq 0x11679(%rip), %rdi     # 0x15be0
movl $0x1, %esi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/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 0xbb0a(%rip), %rbx      # 0x10090
callq 0x2b84
movl 0xb303(%rip), %eax      # 0xf894
cmpl $0x3e9, %eax            # imm = 0x3E9
jne 0x4603
movq 0xf929(%rip), %r15      # 0x13ec8
movl 0x10(%r15), %r13d
testl %r13d, %r13d
jle 0x45cf
leaq 0x20(%r15), %r14
xorl %r12d, %r12d
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x2160
testl %eax, %eax
je 0x45d2
incq %r12
addq $0x28, %r14
cmpq %r12, %r13
jne 0x45af
movl %r13d, %r12d
jmp 0x45d2
xorl %r12d, %r12d
cmpl %r13d, %r12d
je 0x461b
movl %r12d, %eax
leaq (%rax,%rax,4), %rax
cmpq $0x0, 0x30(%r15,%rax,8)
je 0x462b
movslq 0xfc33(%rip), %rax      # 0x14220
leal 0x1(%rax), %ecx
movl %ecx, 0xfc2a(%rip)      # 0x14220
leaq 0xfa93(%rip), %rcx      # 0x14090
movl %r12d, (%rcx,%rax,4)
jmp 0x4586
cmpl $0x3b, %eax
jne 0x4659
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b84
leaq 0xb28e(%rip), %rbx      # 0xf8b0
leaq 0x6ff5(%rip), %rdx      # 0xb61e
jmp 0x4639
leaq 0xb27e(%rip), %rbx      # 0xf8b0
leaq 0x7008(%rip), %rdx      # 0xb641
leaq 0xba50(%rip), %rcx      # 0x10090
movl $0x7d0, %esi            # imm = 0x7D0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x20e0
callq 0xa74a
movq %rbx, %rdi
jmp 0x4665
callq 0xa74a
leaq 0x6fa2(%rip), %rdi      # 0xb607
callq 0x4081
leaq 0x1156f(%rip), %rdi     # 0x15be0
movl $0x1, %esi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/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 0xba00(%rip), %rbx      # 0x10090
leaq 0xfb99(%rip), %r14      # 0x14230
callq 0x2b84
movl 0xb1f2(%rip), %eax      # 0xf894
cmpl $0x3e9, %eax            # imm = 0x3E9
jne 0x46ff
movq 0xf818(%rip), %r13      # 0x13ec8
movl 0x10(%r13), %r15d
testl %r15d, %r15d
jle 0x46e1
addq $0x20, %r13
xorl %r12d, %r12d
movq (%r13), %rdi
movq %rbx, %rsi
callq 0x2160
testl %eax, %eax
je 0x46e4
incq %r12
addq $0x28, %r13
cmpq %r12, %r15
jne 0x46c0
movl %r15d, %r12d
jmp 0x46e4
xorl %r12d, %r12d
cmpl %r15d, %r12d
je 0x4725
movslq 0xfcd0(%rip), %rax      # 0x143c0
leal 0x1(%rax), %ecx
movl %ecx, 0xfcc7(%rip)      # 0x143c0
movl %r12d, (%r14,%rax,4)
jmp 0x4697
cmpl $0x3b, %eax
jne 0x4717
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b84
callq 0xa74a
leaq 0x6ee4(%rip), %rdi      # 0xb607
jmp 0x4751
leaq 0xb184(%rip), %rbx      # 0xf8b0
leaq 0x6f3c(%rip), %rdx      # 0xb66f
leaq 0xb956(%rip), %rcx      # 0x10090
movl $0x7d0, %esi            # imm = 0x7D0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x20e0
callq 0xa74a
movq %rbx, %rdi
callq 0x4081
leaq 0x11483(%rip), %rdi     # 0x15be0
movl $0x1, %esi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/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 %esi, %r15d
movq %rdi, -0x38(%rbp)
movl %edx, -0x2c(%rbp)
callq 0x47e3
testl %r15d, %r15d
jle 0x47cc
movl -0x2c(%rbp), %r12d
movl %r15d, %eax
movq %rax, -0x40(%rbp)
leaq (,%r12,8), %r13
xorl %r14d, %r14d
movq -0x38(%rbp), %rbx
cmpl $0x0, -0x2c(%rbp)
jle 0x47c0
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x2040
incq %r15
cmpq %r15, %r12
jne 0x47af
incq %r14
addq %r13, %rbx
cmpq -0x40(%rbp), %r14
jne 0x47a6
movq -0x38(%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_O1/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 0xf949(%rip), %rdi      # 0x143c8
testq %rdi, %rdi
je 0x4a89
callq 0x408b
movq 0xf940(%rip), %rdi      # 0x143d0
testq %rdi, %rdi
je 0x4a9a
callq 0x408b
movq 0xf937(%rip), %rdi      # 0x143d8
testq %rdi, %rdi
je 0x4aab
callq 0x408b
movq 0xf92e(%rip), %rdi      # 0x143e0
testq %rdi, %rdi
je 0x4abc
callq 0x408b
cmpq $0x0, 0xf904(%rip)      # 0x143c8
jne 0x4ae6
cmpq $0x0, 0xf902(%rip)      # 0x143d0
jne 0x4ae6
cmpq $0x0, 0xf900(%rip)      # 0x143d8
jne 0x4ae6
cmpq $0x0, 0xf8fe(%rip)      # 0x143e0
jne 0x4ae6
popq %rbp
retq
movl $0xa, %edi
popq %rbp
jmp 0x2050
// File: /workspace/github_c_makefile_star2_O1/georgeweigt[P]sassafras/sassafras.c
// Function: proc_anova
void
proc_anova(void)
{
	nx = 0;

	proc_anova_parse_stmt();

	if (dataset == NULL)
		stop("No data set");

	proc_anova_parse_body();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, 0xf8e9(%rip)      # 0x143e8
callq 0x4b36
cmpq $0x0, 0xf3bc(%rip)      # 0x13ec8
je 0x4b14
popq %rbp
jmp 0x4b6f
callq 0xa74a
leaq 0x6b5c(%rip), %rdi      # 0xb67c
callq 0x4081
leaq 0x110b4(%rip), %rdi     # 0x15be0
movl $0x1, %esi
callq 0x21b0
// File: /workspace/github_c_makefile_star2_O1/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 0x64ec(%rip), %rbx      # 0xb068
callq 0x2593
movl 0xad0d(%rip), %eax      # 0xf894
cmpl $0x140, %eax            # imm = 0x140
jle 0x4ba8
addl $0xfffffebf, %eax       # imm = 0xFFFFFEBF
cmpl $0x9, %eax
ja 0x4bcd
movslq (%rbx,%rax,4), %rax
addq %rbx, %rax
jmpq *%rax
callq 0x4bdb
jmp 0x4b7c
cmpl $0x131, %eax            # imm = 0x131
jne 0x4bc2
callq 0x4571
jmp 0x4b7c
callq 0x4dd3
callq 0x4ed5
jmp 0x4b7c
testl %eax, %eax
je 0x4bd4
cmpl $0x135, %eax            # imm = 0x135
je 0x4bd4
callq 0x2ac5
jmp 0x4b7c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq