LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: print_anova_table_part2
void
print_anova_table_part2(void)
{
	char **a;

	a = (char **) xmalloc(8 * sizeof (char *));

	A(0, 0) = strdup("R-Square");
	A(0, 1) = strdup("Coeff Var");
	A(0, 2) = strdup("Root MSE");

	snprintf(bigbuf, BIGBUFLEN, "%s Mean", dataset->spec[yvar].name);
	A(0, 3) = strdup(bigbuf);

	snprintf(bigbuf, BIGBUFLEN, "%0.6f", rsquare);
	A(1, 0) = strdup(bigbuf);

	snprintf(bigbuf, BIGBUFLEN, "%0.6f", cv);
	A(1, 1) = strdup(bigbuf);

	snprintf(bigbuf, BIGBUFLEN, "%0.6f", rootmse);
	A(1, 2) = strdup(bigbuf);

	snprintf(bigbuf, BIGBUFLEN, "%0.6f", ybar);
	A(1, 3) = strdup(bigbuf);

	bigbuf[0] = 0; // right justified
	bigbuf[1] = 0;
	bigbuf[2] = 0;
	bigbuf[3] = 0;

	print_table_and_free(a, 2, 4, bigbuf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x40, %edi
callq 0x2da0
movq %rax, -0x8(%rbp)
leaq 0x72ae(%rip), %rdi      # 0xf7ab
callq 0x21f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
leaq 0x72a1(%rip), %rdi      # 0xf7b4
callq 0x21f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
leaq 0x7294(%rip), %rdi      # 0xf7be
callq 0x21f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq 0xf977(%rip), %rax      # 0x17eb8
addq $0x20, %rax
movslq 0x10024(%rip), %rcx     # 0x18570
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
leaq 0xe953(%rip), %rdi      # 0x16eb0
movl $0xfa0, %esi            # imm = 0xFA0
leaq 0x725e(%rip), %rdx      # 0xf7c7
movb $0x0, %al
callq 0x20c0
leaq 0xe939(%rip), %rdi      # 0x16eb0
callq 0x21f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movsd 0x104f9(%rip), %xmm0    # 0x18a88
leaq 0xe91a(%rip), %rdi      # 0x16eb0
movl $0xfa0, %esi            # imm = 0xFA0
leaq 0x6ce2(%rip), %rdx      # 0xf284
movb $0x1, %al
callq 0x20c0
leaq 0xe900(%rip), %rdi      # 0x16eb0
callq 0x21f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movsd 0x104d8(%rip), %xmm0    # 0x18aa0
leaq 0xe8e1(%rip), %rdi      # 0x16eb0
movl $0xfa0, %esi            # imm = 0xFA0
leaq 0x6ca9(%rip), %rdx      # 0xf284
movb $0x1, %al
callq 0x20c0
leaq 0xe8c7(%rip), %rdi      # 0x16eb0
callq 0x21f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movsd 0x10457(%rip), %xmm0    # 0x18a58
leaq 0xe8a8(%rip), %rdi      # 0x16eb0
movl $0xfa0, %esi            # imm = 0xFA0
leaq 0x6c70(%rip), %rdx      # 0xf284
movb $0x1, %al
callq 0x20c0
leaq 0xe88e(%rip), %rdi      # 0x16eb0
callq 0x21f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movsd 0x1045e(%rip), %xmm0    # 0x18a98
leaq 0xe86f(%rip), %rdi      # 0x16eb0
movl $0xfa0, %esi            # imm = 0xFA0
leaq 0x6c37(%rip), %rdx      # 0xf284
movb $0x1, %al
callq 0x20c0
leaq 0xe855(%rip), %rdi      # 0x16eb0
callq 0x21f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movb $0x0, 0xe83e(%rip)      # 0x16eb0
movb $0x0, 0xe838(%rip)      # 0x16eb1
movb $0x0, 0xe832(%rip)      # 0x16eb2
movb $0x0, 0xe82c(%rip)      # 0x16eb3
movq -0x8(%rbp), %rdi
movl $0x2, %esi
movl $0x4, %edx
leaq 0xe814(%rip), %rcx      # 0x16eb0
callq 0x53f0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: proc_anova_fit
void
proc_anova_fit(void)
{
	int i, j, n, x;

	// put in intercept

	for (i = 0; i < nobs; i++)
		X(i, 0) = 1;

	npar = 1;

	// fit explanatory variables

	for (i = 0; i < nx; i++) {
		x = xtab[i];
		n = dataset->spec[x].num_levels;
		for (j = 0; j < n; j++)
			proc_anova_fit1(x, j); // fit next column
		df[i] = npar;
		if (gstate == -1)
			proc_anova_compute_G();
		proc_anova_compute_B();
		proc_anova_compute_Yhat();
		proc_anova_compute_ss();
		ss[i] = ssr;
	}

	// differentials

	for (i = nx - 1; i > 0; i--) {
		df[i] -= df[i - 1];
		ss[i] -= ss[i - 1];
	}

	df[0]--; // subtract 1 for intercept
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xfb5c(%rip), %eax      # 0x18a34
jge 0x8f06
movq 0xfbe7(%rip), %rax      # 0x18ac8
movl -0x4(%rbp), %ecx
imull 0xfbf5(%rip), %ecx      # 0x18ae0
movslq %ecx, %rcx
movsd 0x62ea(%rip), %xmm0     # 0xf1e0
movsd %xmm0, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x8ecf
movl $0x1, 0xfb28(%rip)      # 0x18a38
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xf4b8(%rip), %eax      # 0x183d8
jge 0x8fcf
movslq -0x4(%rbp), %rcx
leaq 0xf7df(%rip), %rax      # 0x18710
movl (%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
movq 0xef7a(%rip), %rax      # 0x17eb8
addq $0x20, %rax
movslq -0x10(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x8f78
movl -0x10(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x91e0
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x8f5a
movl 0xfaba(%rip), %edx      # 0x18a38
movslq -0x4(%rbp), %rcx
leaq 0xfb67(%rip), %rax      # 0x18af0
movl %edx, (%rax,%rcx,4)
cmpl $-0x1, 0xfced(%rip)     # 0x18c80
jne 0x8f9a
callq 0x92e0
callq 0x9aa0
callq 0x9c10
callq 0x9cc0
movsd 0xfaaf(%rip), %xmm0     # 0x18a60
movslq -0x4(%rbp), %rcx
leaq 0xfcd4(%rip), %rax      # 0x18c90
movsd %xmm0, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x8f17
movl 0xf403(%rip), %eax      # 0x183d8
subl $0x1, %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x904e
movl -0x4(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0xfaff(%rip), %rax      # 0x18af0
movl (%rax,%rcx,4), %eax
movslq -0x4(%rbp), %rcx
leaq 0xfaf1(%rip), %rdx      # 0x18af0
movl (%rdx,%rcx,4), %edx
subl %eax, %edx
leaq 0xfae5(%rip), %rax      # 0x18af0
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0xfc72(%rip), %rax      # 0x18c90
movsd (%rax,%rcx,8), %xmm1
movslq -0x4(%rbp), %rcx
leaq 0xfc62(%rip), %rax      # 0x18c90
movsd (%rax,%rcx,8), %xmm0
subsd %xmm1, %xmm0
leaq 0xfc52(%rip), %rax      # 0x18c90
movsd %xmm0, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x8fdb
movl 0xfa9c(%rip), %eax      # 0x18af0
addl $-0x1, %eax
movl %eax, 0xfa93(%rip)      # 0x18af0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: fdist
double
fdist(double t, double df1, double df2)
{
	if (isnan(t) || !isfinite(df1) || !isfinite(df2) || df1 <= 0.0 || df2 <= 0.0)
		return NAN;
	if (t == INFINITY)
		return 1.0; // pf(Inf,1,1) == 1
	if (t <= 0.0)
		return 0.0; // pf(0,1,1) == 0
	return incbeta(df1 / 2.0, df2 / 2.0, t / (t + df2 / df1));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd -0x10(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x9105
movsd -0x18(%rbp), %xmm0
movq %xmm0, %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq %rcx, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
subq %rcx, %rax
setl %al
testb $0x1, %al
jne 0x90c4
jmp 0x9105
movsd -0x20(%rbp), %xmm0
movq %xmm0, %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq %rcx, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
subq %rcx, %rax
setl %al
testb $0x1, %al
jne 0x90f1
jmp 0x9105
xorps %xmm0, %xmm0
ucomisd -0x18(%rbp), %xmm0
jae 0x9105
xorps %xmm0, %xmm0
ucomisd -0x20(%rbp), %xmm0
jb 0x9117
movsd 0x60cb(%rip), %xmm0     # 0xf1d8
movsd %xmm0, -0x8(%rbp)
jmp 0x9197
movsd -0x10(%rbp), %xmm0
movsd 0x60cc(%rip), %xmm1     # 0xf1f0
ucomisd %xmm1, %xmm0
jne 0x913b
jp 0x913b
movsd 0x60ac(%rip), %xmm0     # 0xf1e0
movsd %xmm0, -0x8(%rbp)
jmp 0x9197
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
jb 0x914f
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x9197
movsd -0x18(%rbp), %xmm0
movsd 0x608c(%rip), %xmm1     # 0xf1e8
divsd %xmm1, %xmm0
movsd -0x20(%rbp), %xmm1
movsd 0x607b(%rip), %xmm2     # 0xf1e8
divsd %xmm2, %xmm1
movsd -0x10(%rbp), %xmm2
movsd -0x10(%rbp), %xmm3
movsd -0x20(%rbp), %xmm4
divsd -0x18(%rbp), %xmm4
addsd %xmm4, %xmm3
divsd %xmm3, %xmm2
callq 0x45e0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: proc_anova_fit1
void
proc_anova_fit1(int x, int level)
{
	int i, k = 0;

	for (i = 0; i < dataset->nobs; i++) {
		if (miss[i])
			continue;
		X(k++, npar) = (dataset->spec[x].v[i] == level) ? 1 : 0;
	}

	npar++;

	gstate = proc_anova_compute_G();

	if (gstate == -1)
		npar--; // X'X is singular hence remove column
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq 0xecb2(%rip), %rcx      # 0x17eb8
cmpl 0x14(%rcx), %eax
jge 0x92a3
movq 0xf892(%rip), %rax      # 0x18aa8
movslq -0xc(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x9222
jmp 0x9295
movq 0xec8f(%rip), %rax      # 0x17eb8
addq $0x20, %rax
movslq -0x4(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rax
movslq -0xc(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
cvtsi2sdl -0x8(%rbp), %xmm1
xorl %eax, %eax
movl $0x1, %ecx
ucomisd %xmm1, %xmm0
setnp %sil
sete %dl
testb %sil, %dl
cmovnel %ecx, %eax
cvtsi2sd %eax, %xmm0
movq 0xf85b(%rip), %rax      # 0x18ac8
movl -0x10(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x10(%rbp)
imull 0xf861(%rip), %ecx      # 0x18ae0
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq 0xf7a8(%rip), %rcx      # 0x18a38
movsd %xmm0, (%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x91fc
movl 0xf78f(%rip), %eax      # 0x18a38
addl $0x1, %eax
movl %eax, 0xf786(%rip)      # 0x18a38
callq 0x92e0
movl %eax, 0xf9c3(%rip)      # 0x18c80
cmpl $-0x1, 0xf9bc(%rip)     # 0x18c80
jne 0x92d5
movl 0xf76c(%rip), %eax      # 0x18a38
addl $-0x1, %eax
movl %eax, 0xf763(%rip)      # 0x18a38
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: proc_anova_compute_B
void
proc_anova_compute_B(void)
{
	int i, j;
	double t;

	for (i = 0; i < npar; i++) {
		t = 0;
		for (j = 0; j < nobs; j++)
			t += X(j, i) * Y[j];
		T(0, i) = t;
	}

	for (i = 0; i < npar; i++) {
		t = 0;
		for (j = 0; j < npar; j++)
			t += G(i, j) * T(0, j);
		B[i] = t;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xef84(%rip), %eax      # 0x18a38
jge 0x9b59
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0xef62(%rip), %eax      # 0x18a34
jge 0x9b25
movq 0xefed(%rip), %rax      # 0x18ac8
movl -0x8(%rbp), %ecx
imull 0xeffb(%rip), %ecx      # 0x18ae0
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x4(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0xefd1(%rip), %rax      # 0x18ad0
movslq -0x8(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x10(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x9ac9
movsd -0x10(%rbp), %xmm0
movq 0xef8f(%rip), %rax      # 0x18ac0
imull $0x0, 0xefa8(%rip), %ecx # 0x18ae0
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x4(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x9aab
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xeecf(%rip), %eax      # 0x18a38
jge 0x9c0e
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0xeeb1(%rip), %eax      # 0x18a38
jge 0x9beb
movq 0xef28(%rip), %rax      # 0x18ab8
movl -0x4(%rbp), %ecx
imull 0xef46(%rip), %ecx      # 0x18ae0
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0xef0c(%rip), %rax      # 0x18ac0
imull $0x0, 0xef25(%rip), %ecx # 0x18ae0
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x10(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x9b7e
movsd -0x10(%rbp), %xmm0
movq 0xeeb9(%rip), %rax      # 0x18ab0
movslq -0x4(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x9b60
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: proc_anova_compute_Yhat
void
proc_anova_compute_Yhat(void)
{
	int i, j;
	double t;

	for (i = 0; i < nobs; i++) {
		t = 0;
		for (j = 0; j < npar; j++)
			t += X(i, j) * B[j];
		Yhat[i] = t;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xee10(%rip), %eax      # 0x18a34
jge 0x9cb8
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0xedf6(%rip), %eax      # 0x18a38
jge 0x9c95
movq 0xee7d(%rip), %rax      # 0x18ac8
movl -0x4(%rbp), %ecx
imull 0xee8b(%rip), %ecx      # 0x18ae0
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0xee41(%rip), %rax      # 0x18ab0
movslq -0x8(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x10(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x9c39
movsd -0x10(%rbp), %xmm0
movq 0xee37(%rip), %rax      # 0x18ad8
movslq -0x4(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x9c1b
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: proc_anova_compute_ss
void
proc_anova_compute_ss(void)
{
	int i;

	ssr = 0;
	sse = 0;

	for (i = 0; i < nobs; i++) {
		ssr += (Yhat[i] - ybar) * (Yhat[i] - ybar);
		sse += (Y[i] - Yhat[i]) * (Y[i] - Yhat[i]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorps %xmm0, %xmm0
movsd %xmm0, 0xed91(%rip)     # 0x18a60
xorps %xmm0, %xmm0
movsd %xmm0, 0xed6e(%rip)     # 0x18a48
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xed4a(%rip), %eax      # 0x18a34
jge 0x9d9e
movq 0xede1(%rip), %rax      # 0x18ad8
movslq -0x4(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd 0xed90(%rip), %xmm0     # 0x18a98
movq 0xedc9(%rip), %rax      # 0x18ad8
movslq -0x4(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
subsd 0xed78(%rip), %xmm2     # 0x18a98
movsd 0xed38(%rip), %xmm1     # 0x18a60
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0xed28(%rip)     # 0x18a60
movq 0xed91(%rip), %rax      # 0x18ad0
movslq -0x4(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0xed89(%rip), %rax      # 0x18ad8
movslq -0x4(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movq 0xed71(%rip), %rax      # 0x18ad0
movslq -0x4(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq 0xed69(%rip), %rax      # 0x18ad8
movslq -0x4(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm2
movsd 0xecc8(%rip), %xmm1     # 0x18a48
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0xecb8(%rip)     # 0x18a48
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x9ce1
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: qt
double
qt(double p, double df)
{
	int i;
	double a, t, t1, t2;
	if (isnan(p) || p < 0.0 || p > 1.0 || !isfinite(df) || df <= 0.0)
		return NAN;
	if (p == 0.0)
		return -INFINITY; // qt(0,1) == -Inf
	if (p == 1.0)
		return INFINITY; // qt(1,1) == Inf
	t1 = -1e5;
	t2 = 1e5;
	for (i = 0; i < 100; i++) {
		t = 0.5 * (t1 + t2);
		a = tdist(t, df);
		if (fabs(a - p) < 1e-9)
			break;
		if (a < p)
			t1 = t;
		else
			t2 = t;
	}
	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x9e16
xorps %xmm0, %xmm0
ucomisd -0x10(%rbp), %xmm0
ja 0x9e16
movsd -0x10(%rbp), %xmm0
movsd 0x5407(%rip), %xmm1     # 0xf1e0
ucomisd %xmm1, %xmm0
ja 0x9e16
movsd -0x18(%rbp), %xmm0
movq %xmm0, %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq %rcx, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
subq %rcx, %rax
setl %al
testb $0x1, %al
jne 0x9e0c
jmp 0x9e16
xorps %xmm0, %xmm0
ucomisd -0x18(%rbp), %xmm0
jb 0x9e28
movsd 0x53ba(%rip), %xmm0     # 0xf1d8
movsd %xmm0, -0x8(%rbp)
jmp 0x9f30
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x9e4a
jp 0x9e4a
movsd 0x5400(%rip), %xmm0     # 0xf240
movsd %xmm0, -0x8(%rbp)
jmp 0x9f30
movsd -0x10(%rbp), %xmm0
movsd 0x5389(%rip), %xmm1     # 0xf1e0
ucomisd %xmm1, %xmm0
jne 0x9e71
jp 0x9e71
movsd 0x5389(%rip), %xmm0     # 0xf1f0
movsd %xmm0, -0x8(%rbp)
jmp 0x9f30
movsd 0x53af(%rip), %xmm0     # 0xf228
movsd %xmm0, -0x38(%rbp)
movsd 0x539a(%rip), %xmm0     # 0xf220
movsd %xmm0, -0x40(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x64, -0x1c(%rbp)
jge 0x9f26
movsd -0x38(%rbp), %xmm1
addsd -0x40(%rbp), %xmm1
movsd 0x538a(%rip), %xmm0     # 0xf238
mulsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x9f40
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm1
subsd -0x10(%rbp), %xmm1
movaps 0x5374(%rip), %xmm0     # 0xf250
pand %xmm0, %xmm1
movsd 0x5348(%rip), %xmm0     # 0xf230
ucomisd %xmm1, %xmm0
jbe 0x9ef0
jmp 0x9f26
movsd -0x28(%rbp), %xmm1
movsd -0x10(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x9f0c
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0x9f16
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
jmp 0x9f18
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x9e92
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: tdist
double
tdist(double t, double df)
{
	double x;
	if (isnan(t) || !isfinite(df) || df <= 0.0)
		return NAN;
	if (t == INFINITY)
		return 1.0; // pt(Inf,1) == 1
	if (t == -INFINITY)
		return 0.0; // pt(-Inf,1) == 0
	x = (t + sqrt(t * t + df)) / (2.0 * sqrt(t * t + df));
	return incbeta(df / 2.0, df / 2.0, x);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
ucomisd %xmm0, %xmm0
setp %al
testb $0x1, %al
jne 0x9f99
movsd -0x18(%rbp), %xmm0
movq %xmm0, %rax
movabsq $0x7fffffffffffffff, %rcx # imm = 0x7FFFFFFFFFFFFFFF
andq %rcx, %rax
movabsq $0x7ff0000000000000, %rcx # imm = 0x7FF0000000000000
subq %rcx, %rax
setl %al
testb $0x1, %al
jne 0x9f8f
jmp 0x9f99
xorps %xmm0, %xmm0
ucomisd -0x18(%rbp), %xmm0
jb 0x9fab
movsd 0x5237(%rip), %xmm0     # 0xf1d8
movsd %xmm0, -0x8(%rbp)
jmp 0xa095
movsd -0x10(%rbp), %xmm0
movsd 0x5238(%rip), %xmm1     # 0xf1f0
ucomisd %xmm1, %xmm0
jne 0x9fd2
jp 0x9fd2
movsd 0x5218(%rip), %xmm0     # 0xf1e0
movsd %xmm0, -0x8(%rbp)
jmp 0xa095
movsd -0x10(%rbp), %xmm0
movsd 0x5261(%rip), %xmm1     # 0xf240
ucomisd %xmm1, %xmm0
jne 0x9ff4
jp 0x9ff4
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xa095
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x10(%rbp), %xmm2
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x21e0
movaps %xmm0, %xmm1
movsd -0x30(%rbp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
movsd -0x10(%rbp), %xmm2
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x21e0
movaps %xmm0, %xmm2
movsd -0x28(%rbp), %xmm0
movsd 0x5191(%rip), %xmm1     # 0xf1e8
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x18(%rbp), %xmm0
movsd 0x5177(%rip), %xmm1     # 0xf1e8
divsd %xmm1, %xmm0
movsd -0x18(%rbp), %xmm1
movsd 0x5166(%rip), %xmm2     # 0xf1e8
divsd %xmm2, %xmm1
movsd -0x20(%rbp), %xmm2
callq 0x45e0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: parse_proc_means_stmt
void
parse_proc_means_stmt(void)
{
	for (;;) {
		scan();
		keyword();
		switch (token) {
		case ';':
			scan(); // eat the semicolon
			return;
		case KALPHA:
			parse_alpha_option();
			break;
		case KDATA:
			parse_data_option();
			break;
		case KMAXDEC:
			parse_maxdec_option();
			break;
		case KCLM:
			if (nstats + 2 > MAXSTAT)
				stop("Too many statistics keywords");
			stats[nstats++] = KCLM1;
			stats[nstats++] = KCLM2;
			break;
		case KLCLM:
		case KMAX:
		case KMEAN:
		case KMIN:
		case KN:
		case KSUM:
		case KSTD:
		case KSTDDEV:
		case KSTDERR:
		case KSTDMEAN:
		case KUCLM:
		case KVAR:
			if (nstats == MAXSTAT)
				stop("Too many statistics keywords");
			stats[nstats++] = token;
			break;
		default:
			expected("proc means option");
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
jmp 0xa0da
callq 0x2d30
callq 0x25e0
movl 0x979a(%rip), %eax      # 0x13884
movl %eax, -0x4(%rbp)
subl $0x3b, %eax
je 0xa1ad
jmp 0xa0f8
movl -0x4(%rbp), %eax
subl $0x12d, %eax            # imm = 0x12D
je 0xa1b8
jmp 0xa108
movl -0x4(%rbp), %eax
subl $0x132, %eax            # imm = 0x132
je 0xa1d6
jmp 0xa118
movl -0x4(%rbp), %eax
subl $0x135, %eax            # imm = 0x135
je 0xa1c2
jmp 0xa128
movl -0x4(%rbp), %eax
subl $0x13c, %eax            # imm = 0x13C
je 0xa236
jmp 0xa138
movl -0x4(%rbp), %eax
subl $0x13e, %eax            # imm = 0x13E
je 0xa236
jmp 0xa148
movl -0x4(%rbp), %eax
subl $0x13f, %eax            # imm = 0x13F
je 0xa1cc
jmp 0xa154
movl -0x4(%rbp), %eax
subl $0x140, %eax            # imm = 0x140
je 0xa236
jmp 0xa164
movl -0x4(%rbp), %eax
subl $0x142, %eax            # imm = 0x142
je 0xa236
jmp 0xa174
movl -0x4(%rbp), %eax
subl $0x144, %eax            # imm = 0x144
je 0xa236
jmp 0xa184
movl -0x4(%rbp), %eax
addl $0xfffffeb5, %eax       # imm = 0xFFFFFEB5
subl $0x5, %eax
jb 0xa236
jmp 0xa197
movl -0x4(%rbp), %eax
addl $0xfffffeaa, %eax       # imm = 0xFFFFFEAA
subl $0x2, %eax
jb 0xa236
jmp 0xa271
callq 0x2d30
addq $0x10, %rsp
popq %rbp
retq
callq 0x4f30
jmp 0xa27d
callq 0x4fb0
jmp 0xa27d
callq 0x5000
jmp 0xa27d
movl 0xf5a4(%rip), %eax      # 0x19780
addl $0x2, %eax
cmpl $0xc, %eax
jle 0xa1f0
leaq 0x5691(%rip), %rdi      # 0xf87c
callq 0x2790
movl 0xf58a(%rip), %eax      # 0x19780
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0xf57f(%rip)      # 0x19780
movslq %eax, %rcx
leaq 0xf585(%rip), %rax      # 0x19790
movl $0x133, (%rax,%rcx,4)   # imm = 0x133
movl 0xf568(%rip), %eax      # 0x19780
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0xf55d(%rip)      # 0x19780
movslq %eax, %rcx
leaq 0xf563(%rip), %rax      # 0x19790
movl $0x134, (%rax,%rcx,4)   # imm = 0x134
jmp 0xa27d
cmpl $0xc, 0xf543(%rip)      # 0x19780
jne 0xa24b
leaq 0x5636(%rip), %rdi      # 0xf87c
callq 0x2790
movl 0x9633(%rip), %edx      # 0x13884
movl 0xf529(%rip), %eax      # 0x19780
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0xf51e(%rip)      # 0x19780
movslq %eax, %rcx
leaq 0xf524(%rip), %rax      # 0x19790
movl %edx, (%rax,%rcx,4)
jmp 0xa27d
leaq 0x5621(%rip), %rdi      # 0xf899
callq 0x2670
jmp 0xa0da
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: parse_proc_means_body
void
parse_proc_means_body(void)
{
	for (;;) {
		keyword();
		switch (token) {
		case 0:
		case KDATA:
		case KPROC:
		case KRUN:
			return;
		case KCLASS:
			parse_class_stmt();
			break;
		case KVAR:
			parse_var_stmt();
			break;
		default:
			parse_default();
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
jmp 0xa29a
callq 0x25e0
movl 0x95df(%rip), %eax      # 0x13884
movl %eax, -0x4(%rbp)
testl %eax, %eax
je 0xa2ea
jmp 0xa2ae
movl -0x4(%rbp), %eax
subl $0x131, %eax            # imm = 0x131
je 0xa2f0
jmp 0xa2ba
movl -0x4(%rbp), %eax
subl $0x135, %eax            # imm = 0x135
je 0xa2ea
jmp 0xa2c6
movl -0x4(%rbp), %eax
subl $0x147, %eax            # imm = 0x147
je 0xa2ea
jmp 0xa2d2
movl -0x4(%rbp), %eax
subl $0x14a, %eax            # imm = 0x14A
je 0xa2ea
jmp 0xa2de
movl -0x4(%rbp), %eax
subl $0x157, %eax            # imm = 0x157
je 0xa2f7
jmp 0xa2fe
addq $0x10, %rsp
popq %rbp
retq
callq 0x51c0
jmp 0xa303
callq 0x5300
jmp 0xa303
callq 0x2c60
jmp 0xa29a
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: f
void
f(int k)
{
	int i, n, varnum;

	if (k == nclass) {
		g();
		return;
	}

	varnum = class[k];

	// number of levels

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

	// for each level...

	for (i = 0; i < n; i++) {
		filtertab[k] = i;
		f(k + 1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xd9bc(%rip), %eax      # 0x18210
jne 0xa85d
callq 0xa8d0
jmp 0xa8c0
movslq -0x4(%rbp), %rcx
leaq 0xd818(%rip), %rax      # 0x18080
movl (%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
movq 0xd643(%rip), %rax      # 0x17eb8
addq $0x20, %rax
movslq -0x10(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
movl %eax, -0xc(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xa8c0
movl -0x8(%rbp), %edx
movslq -0x4(%rbp), %rcx
leaq 0xefb9(%rip), %rax      # 0x19860
movl %edx, (%rax,%rcx,4)
movl -0x4(%rbp), %edi
addl $0x1, %edi
callq 0xa840
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xa891
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: g
void
g(void)
{
	int i, j, level, varnum;

	// for each numeric variable...

	for (i = 0; i < nvar; i++) {

		// level names

		if (i == 0)
			for (j = 0; j < nclass; j++) {
				varnum = class[j];
				level = filtertab[j];
				A(row, j) = strdup(dataset->spec[varnum].ltab[level]);
			}
		else
			for (j = 0; j < nclass; j++)
				A(row, j) = strdup("");

		varnum = var[i];

		// name of the variable

		A(row, nclass) = strdup(dataset->spec[varnum].name);

		h(varnum);

		row++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xdac8(%rip), %eax      # 0x183b0
jge 0xaa64
cmpl $0x0, -0x4(%rbp)
jne 0xa990
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0xd908(%rip), %eax      # 0x18210
jge 0xa98e
movslq -0x8(%rbp), %rcx
leaq 0xd767(%rip), %rax      # 0x18080
movl (%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0xef36(%rip), %rax      # 0x19860
movl (%rax,%rcx,4), %eax
movl %eax, -0xc(%rbp)
movq 0xd581(%rip), %rax      # 0x17eb8
addq $0x20, %rax
movslq -0x10(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21f0
movq %rax, %rdx
movq 0xee67(%rip), %rax      # 0x197c8
movl 0xee69(%rip), %ecx      # 0x197d0
imull 0xe172(%rip), %ecx      # 0x18ae0
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xa8ff
jmp 0xa9e4
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0xd870(%rip), %eax      # 0x18210
jge 0xa9e2
leaq 0x4a36(%rip), %rdi      # 0xf3df
callq 0x21f0
movq %rax, %rdx
movq 0xee10(%rip), %rax      # 0x197c8
movl 0xee12(%rip), %ecx      # 0x197d0
imull 0xe11b(%rip), %ecx      # 0x18ae0
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xa997
jmp 0xa9e4
movslq -0x4(%rbp), %rcx
leaq 0xd831(%rip), %rax      # 0x18220
movl (%rax,%rcx,4), %eax
movl %eax, -0x10(%rbp)
movq 0xd4bc(%rip), %rax      # 0x17eb8
addq $0x20, %rax
movslq -0x10(%rbp), %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x21f0
movq %rax, %rdx
movq 0xedab(%rip), %rax      # 0x197c8
movl 0xedad(%rip), %ecx      # 0x197d0
imull 0xe0b6(%rip), %ecx      # 0x18ae0
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq 0xd7d5(%rip), %rcx      # 0x18210
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rbp), %edi
callq 0xaa70
movl 0xed83(%rip), %eax      # 0x197d0
addl $0x1, %eax
movl %eax, 0xed7a(%rip)      # 0x197d0
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xa8df
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: proc_print
void
proc_print(void)
{
	parse_proc_print_stmt();

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

	parse_proc_print_body();

	run_proc_print();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0xb130
cmpq $0x0, 0xcda7(%rip)      # 0x17eb8
jne 0xb11f
leaq 0x446d(%rip), %rdi      # 0xf587
callq 0x2790
callq 0xb180
callq 0xb1f0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: parse_proc_print_stmt
void
parse_proc_print_stmt(void)
{
	for (;;) {
		get_next_token();
		switch (token) {
		case ';':
			scan();
			return;
		case KDATA:
			parse_data_option();
			break;
		default:
			stop("';' expected");
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
jmp 0xb13a
callq 0x2e30
movl 0x873f(%rip), %eax      # 0x13884
movl %eax, -0x4(%rbp)
subl $0x3b, %eax
je 0xb15b
jmp 0xb14f
movl -0x4(%rbp), %eax
subl $0x135, %eax            # imm = 0x135
je 0xb166
jmp 0xb16d
callq 0x2d30
addq $0x10, %rsp
popq %rbp
retq
callq 0x4fb0
jmp 0xb179
leaq 0x427c(%rip), %rdi      # 0xf3f0
callq 0x2790
jmp 0xb13a
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: parse_proc_print_body
void
parse_proc_print_body(void)
{
	for (;;) {
		keyword();
		switch (token) {
		case 0:
		case KDATA:
		case KPROC:
		case KRUN:
			return;
		case KVAR:
			parse_var_stmt();
			break;
		default:
			parse_default();
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
jmp 0xb18a
callq 0x25e0
movl 0x86ef(%rip), %eax      # 0x13884
movl %eax, -0x4(%rbp)
testl %eax, %eax
je 0xb1ce
jmp 0xb19e
movl -0x4(%rbp), %eax
subl $0x135, %eax            # imm = 0x135
je 0xb1ce
jmp 0xb1aa
movl -0x4(%rbp), %eax
subl $0x147, %eax            # imm = 0x147
je 0xb1ce
jmp 0xb1b6
movl -0x4(%rbp), %eax
subl $0x14a, %eax            # imm = 0x14A
je 0xb1ce
jmp 0xb1c2
movl -0x4(%rbp), %eax
subl $0x157, %eax            # imm = 0x157
je 0xb1d4
jmp 0xb1db
addq $0x10, %rsp
popq %rbp
retq
callq 0x5300
jmp 0xb1e0
callq 0x2c60
jmp 0xb18a
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: proc_reg_parse_stmt
void
proc_reg_parse_stmt(void)
{
	for (;;) {
		scan();
		keyword();
		switch (token) {
		case ';':
			scan(); // eat the semicolon
			return;
		case KALPHA:
			parse_alpha_option();
			break;
		case KDATA:
			parse_data_option();
			break;
		default:
			expected("proc reg option");
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
jmp 0xb69a
callq 0x2d30
callq 0x25e0
movl 0x81da(%rip), %eax      # 0x13884
movl %eax, -0x4(%rbp)
subl $0x3b, %eax
je 0xb6cc
jmp 0xb6b4
movl -0x4(%rbp), %eax
subl $0x12d, %eax            # imm = 0x12D
je 0xb6d7
jmp 0xb6c0
movl -0x4(%rbp), %eax
subl $0x135, %eax            # imm = 0x135
je 0xb6de
jmp 0xb6e5
callq 0x2d30
addq $0x10, %rsp
popq %rbp
retq
callq 0x4f30
jmp 0xb6f1
callq 0x4fb0
jmp 0xb6f1
leaq 0x4238(%rip), %rdi      # 0xf924
callq 0x2670
jmp 0xb69a
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: proc_reg_parse_body
void
proc_reg_parse_body(void)
{
	for (;;) {
		keyword();
		switch (token) {
		case 0:
		case KDATA:
		case KPROC:
		case KRUN:
			return;
		case KMODEL:
			proc_reg_parse_model_stmt();
			break;
		default:
			parse_default();
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
jmp 0xb70a
callq 0x25e0
movl 0x816f(%rip), %eax      # 0x13884
movl %eax, -0x4(%rbp)
testl %eax, %eax
je 0xb74e
jmp 0xb71e
movl -0x4(%rbp), %eax
subl $0x135, %eax            # imm = 0x135
je 0xb74e
jmp 0xb72a
movl -0x4(%rbp), %eax
subl $0x143, %eax            # imm = 0x143
je 0xb754
jmp 0xb736
movl -0x4(%rbp), %eax
subl $0x147, %eax            # imm = 0x147
je 0xb74e
jmp 0xb742
movl -0x4(%rbp), %eax
subl $0x14a, %eax            # imm = 0x14A
jne 0xb75b
jmp 0xb74e
addq $0x10, %rsp
popq %rbp
retq
callq 0xc5f0
jmp 0xb760
callq 0x2c60
jmp 0xb70a
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: proc_reg_print_diag_table
void
proc_reg_print_diag_table(void)
{
	char *a[3][4], buf[100];

	a[0][0] = "Root MSE";
	a[1][0] = "Dependent Mean";
	a[2][0] = "Coeff Var";

	a[0][2] = "R-Square";
	a[1][2] = "Adj R-Sq";
	a[2][2] = "";

	snprintf(buf, sizeof buf, "%0.5f", rootmse);
	a[0][1] = strdup(buf);

	snprintf(buf, sizeof buf, "%0.5f", ybar);
	a[1][1] = strdup(buf);

	snprintf(buf, sizeof buf, "%0.5f", cv);
	a[2][1] = strdup(buf);

	snprintf(buf, sizeof buf, "%0.4f", rsquare);
	a[0][3] = strdup(buf);

	snprintf(buf, sizeof buf, "%0.4f", adjrsq);
	a[1][3] = strdup(buf);

	a[2][3] = "";

	buf[0] = 1; // left justify
	buf[1] = 0;
	buf[2] = 1;
	buf[3] = 0;

	print_table(&a[0][0], 3, 4, buf);

	free(a[0][1]);
	free(a[1][1]);
	free(a[2][1]);

	free(a[0][3]);
	free(a[1][3]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
leaq 0x384c(%rip), %rax      # 0xf7be
movq %rax, -0x60(%rbp)
leaq 0x3a30(%rip), %rax      # 0xf9ad
movq %rax, -0x40(%rbp)
leaq 0x382c(%rip), %rax      # 0xf7b4
movq %rax, -0x20(%rbp)
leaq 0x3818(%rip), %rax      # 0xf7ab
movq %rax, -0x50(%rbp)
leaq 0x3a1e(%rip), %rax      # 0xf9bc
movq %rax, -0x30(%rbp)
leaq 0x3436(%rip), %rax      # 0xf3df
movq %rax, -0x10(%rbp)
leaq -0xd0(%rbp), %rdi
movsd 0xca9c(%rip), %xmm0     # 0x18a58
movl $0x64, %esi
leaq 0x32b6(%rip), %rdx      # 0xf27e
movb $0x1, %al
callq 0x20c0
leaq -0xd0(%rbp), %rdi
callq 0x21f0
movq %rax, -0x58(%rbp)
leaq -0xd0(%rbp), %rdi
movsd 0xcaaa(%rip), %xmm0     # 0x18a98
movl $0x64, %esi
leaq 0x3284(%rip), %rdx      # 0xf27e
movb $0x1, %al
callq 0x20c0
leaq -0xd0(%rbp), %rdi
callq 0x21f0
movq %rax, -0x38(%rbp)
leaq -0xd0(%rbp), %rdi
movsd 0xca80(%rip), %xmm0     # 0x18aa0
movl $0x64, %esi
leaq 0x3252(%rip), %rdx      # 0xf27e
movb $0x1, %al
callq 0x20c0
leaq -0xd0(%rbp), %rdi
callq 0x21f0
movq %rax, -0x18(%rbp)
leaq -0xd0(%rbp), %rdi
movsd 0xca36(%rip), %xmm0     # 0x18a88
movl $0x64, %esi
leaq 0x321a(%rip), %rdx      # 0xf278
movb $0x1, %al
callq 0x20c0
leaq -0xd0(%rbp), %rdi
callq 0x21f0
movq %rax, -0x48(%rbp)
leaq -0xd0(%rbp), %rdi
movsd 0xca0c(%rip), %xmm0     # 0x18a90
movl $0x64, %esi
leaq 0x31e8(%rip), %rdx      # 0xf278
movb $0x1, %al
callq 0x20c0
leaq -0xd0(%rbp), %rdi
callq 0x21f0
movq %rax, -0x28(%rbp)
leaq 0x3331(%rip), %rax      # 0xf3df
movq %rax, -0x8(%rbp)
movb $0x1, -0xd0(%rbp)
movb $0x0, -0xcf(%rbp)
movb $0x1, -0xce(%rbp)
movb $0x0, -0xcd(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0xd0(%rbp), %rcx
movl $0x3, %esi
movl $0x4, %edx
callq 0x5480
movq -0x58(%rbp), %rdi
callq 0x2030
movq -0x38(%rbp), %rdi
callq 0x2030
movq -0x18(%rbp), %rdi
callq 0x2030
movq -0x48(%rbp), %rdi
callq 0x2030
movq -0x28(%rbp), %rdi
callq 0x2030
addq $0xd0, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: proc_reg_parse_model_options
void
proc_reg_parse_model_options(void)
{
	for (;;) {

		scan();

		keyword();

		switch (token) {

		case ';':
			return;

		case KNOINT:
			noint = 1;
			break;

		default:
			stop("';' or MODEL option expected");
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
jmp 0xc81a
callq 0x2d30
callq 0x25e0
movl 0x705a(%rip), %eax      # 0x13884
movl %eax, -0x4(%rbp)
subl $0x3b, %eax
je 0xc840
jmp 0xc834
movl -0x4(%rbp), %eax
subl $0x145, %eax            # imm = 0x145
je 0xc846
jmp 0xc852
addq $0x10, %rsp
popq %rbp
retq
movl $0x1, 0xd1a8(%rip)      # 0x199f8
jmp 0xc85e
leaq 0x2dcc(%rip), %rdi      # 0xf625
callq 0x2790
jmp 0xc81a
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: proc_reg_compute_T
void
proc_reg_compute_T(void)
{
	int i, j, k, l, m;
	double t;
	l = 0;
	for (i = 0; i < ncol; i++) {
		if (Z[i])
			continue;
		m = 0;
		for (j = 0; j < ncol; j++) {
			if (Z[j])
				continue;
			t = 0;
			for (k = 0; k < nrow; k++)
				t += X(k, i) * X(k, j);
			T(l, m) = t;
			m++;
		}
		l++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x10(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xbff5(%rip), %eax      # 0x18ae0
jge 0xcc10
movq 0xd098(%rip), %rax      # 0x19b90
movslq -0x4(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0xcb07
jmp 0xcc02
movl $0x0, -0x14(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0xbfc2(%rip), %eax      # 0x18ae0
jge 0xcbf9
movq 0xd065(%rip), %rax      # 0x19b90
movslq -0x8(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0xcb3a
jmp 0xcbeb
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0xcc6e(%rip), %eax      # 0x197c0
jge 0xcbb9
movq 0xbf6d(%rip), %rax      # 0x18ac8
movl -0xc(%rbp), %ecx
imull 0xbf7b(%rip), %ecx      # 0x18ae0
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x4(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0xbf49(%rip), %rax      # 0x18ac8
movl -0xc(%rbp), %ecx
imull 0xbf57(%rip), %ecx      # 0x18ae0
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xcb49
movsd -0x20(%rbp), %xmm0
movq 0xbefb(%rip), %rax      # 0x18ac0
movl -0x10(%rbp), %ecx
imull 0xbf11(%rip), %ecx      # 0x18ae0
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x14(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xcb15
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xcae2
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: proc_reg_compute_B
void
proc_reg_compute_B(void)
{
	int i, j, l;
	double t;

	l = 0;

	for (i = 0; i < ncol; i++) {
		if (Z[i])
			continue;
		t = 0;
		for (j = 0; j < nrow; j++)
			t += X(j, i) * Y[j];
		T(0, l++) = t;
	}

	for (i = 0; i < npar; i++) {
		t = 0;
		for (j = 0; j < npar; j++)
			t += G(i, j) * T(0, j);
		B[i] = t;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0xc(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xb7e5(%rip), %eax      # 0x18ae0
jge 0xd3c0
movq 0xc888(%rip), %rax      # 0x19b90
movslq -0x4(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0xd317
jmp 0xd3b2
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0xc491(%rip), %eax      # 0x197c0
jge 0xd382
movq 0xb790(%rip), %rax      # 0x18ac8
movl -0x8(%rbp), %ecx
imull 0xb79e(%rip), %ecx      # 0x18ae0
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x4(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0xb774(%rip), %rax      # 0x18ad0
movslq -0x8(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xd326
movsd -0x18(%rbp), %xmm0
movq 0xb732(%rip), %rax      # 0x18ac0
imull $0x0, 0xb74b(%rip), %ecx # 0x18ae0
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xd2f2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xb668(%rip), %eax      # 0x18a38
jge 0xd475
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0xb64a(%rip), %eax      # 0x18a38
jge 0xd452
movq 0xb6c1(%rip), %rax      # 0x18ab8
movl -0x4(%rbp), %ecx
imull 0xb6df(%rip), %ecx      # 0x18ae0
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0xb6a5(%rip), %rax      # 0x18ac0
imull $0x0, 0xb6be(%rip), %ecx # 0x18ae0
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xd3e5
movsd -0x18(%rbp), %xmm0
movq 0xb652(%rip), %rax      # 0x18ab0
movslq -0x4(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xd3c7
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: proc_reg_compute_Yhat
void
proc_reg_compute_Yhat(void)
{
	int i, j, k;
	double yhat;
	for (i = 0; i < nrow; i++) {
		yhat = 0;
		k = 0;
		for (j = 0; j < ncol; j++)
			if (Z[j] == 0) // if not zapped
				yhat += X(i, j) * B[k++];
		Yhat[i] = yhat;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xc32c(%rip), %eax      # 0x197c0
jge 0xd54c
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0xb627(%rip), %eax      # 0x18ae0
jge 0xd529
movq 0xc6ce(%rip), %rax      # 0x19b90
movslq -0x8(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0xd51c
movq 0xb5f5(%rip), %rax      # 0x18ac8
movl -0x4(%rbp), %ecx
imull 0xb603(%rip), %ecx      # 0x18ae0
movslq %ecx, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movslq -0x8(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0xb5b9(%rip), %rax      # 0x18ab0
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
jmp 0xd51e
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0xd4b0
movsd -0x18(%rbp), %xmm0
movq 0xb5a3(%rip), %rax      # 0x18ad8
movslq -0x4(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xd48b
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: proc_reg_compute_PVAL
void
proc_reg_compute_PVAL(void)
{
	int i, n;
	n = nrow - npar;
	for (i = 0; i < npar; i++)
		PVAL[i] = 2 * (1 - tdist(fabs(TVAL[i]), n));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl 0xbec2(%rip), %eax      # 0x197c0
subl 0xb134(%rip), %eax      # 0x18a38
movl %eax, -0x8(%rbp)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0xb121(%rip), %eax      # 0x18a38
jge 0xd971
movq 0xc280(%rip), %rax      # 0x19ba0
movslq -0x4(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movaps 0x1920(%rip), %xmm1     # 0xf250
pand %xmm1, %xmm0
cvtsi2sdl -0x8(%rbp), %xmm1
callq 0x9f40
movsd 0x189a(%rip), %xmm1     # 0xf1e0
subsd %xmm0, %xmm1
movsd 0x1896(%rip), %xmm0     # 0xf1e8
mulsd %xmm1, %xmm0
movq 0xc24b(%rip), %rax      # 0x19ba8
movslq -0x4(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0xd90e
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: proc_step
void
proc_step(void)
{
	nby = 0;
	nvar = 0;
	nstats = 0;
	nclass = 0;

	maxdec = 3;
	alpha = 0.05;

	select_dataset(NULL);

	scan(); // get token after PROC

	keyword();

	switch (token) {
	case KANOVA:
		proc_anova();
		break;
	case KMEANS:
		proc_means();
		break;
	case KPRINT:
		proc_print();
		break;
	case KREG:
		proc_reg();
		break;
	default:
		expected("procedure name");
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, 0xa6de(%rip)      # 0x18070
movl $0x0, 0xaa14(%rip)      # 0x183b0
movl $0x0, 0xbdda(%rip)      # 0x19780
movl $0x0, 0xa860(%rip)      # 0x18210
movl $0x3, 0xa516(%rip)      # 0x17ed0
movabsq $0x3fa999999999999a, %rax # imm = 0x3FA999999999999A
movq %rax, 0xa4fd(%rip)      # 0x17ec8
xorl %eax, %eax
movl %eax, %edi
callq 0x4160
callq 0x2d30
callq 0x25e0
movl 0x5ea0(%rip), %eax      # 0x13884
addl $0xfffffed2, %eax       # imm = 0xFFFFFED2
movl %eax, %ecx
movq %rcx, -0x8(%rbp)
subl $0x1b, %eax
ja 0xda24
movq -0x8(%rbp), %rax
leaq 0x1765(%rip), %rcx      # 0xf164
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x5870
jmp 0xda30
callq 0xa0a0
jmp 0xda30
callq 0xb100
jmp 0xda30
callq 0xb600
jmp 0xda30
leaq 0x1f9a(%rip), %rdi      # 0xf9c5
callq 0x2670
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: run_nib
void
run_nib(char *s)
{
	if (setjmp(jmpbuf))
		return;

	pgm = s;

	inp = s;

	scan();

	for (;;) {
		keyword();
		switch (token) {
		case 0:
			return;
		case KDATA:
			data_step();
			break;
		case KPROC:
			proc_step();
			break;
		case KRUN:
			scan();
			if (token != ';')
				stop("';' expected");
			scan();
			break;
		default:
			parse_default();
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0xc17d(%rip), %rdi      # 0x19bd0
callq 0x2130
cmpl $0x0, %eax
je 0xda62
jmp 0xdaed
movq -0x8(%rbp), %rax
movq %rax, 0xc22b(%rip)      # 0x19c98
movq -0x8(%rbp), %rax
movq %rax, 0x5e10(%rip)      # 0x13888
callq 0x2d30
callq 0x25e0
movl 0x5dfc(%rip), %eax      # 0x13884
movl %eax, -0xc(%rbp)
testl %eax, %eax
je 0xdab5
jmp 0xda91
movl -0xc(%rbp), %eax
subl $0x135, %eax            # imm = 0x135
je 0xdab7
jmp 0xda9d
movl -0xc(%rbp), %eax
subl $0x147, %eax            # imm = 0x147
je 0xdabe
jmp 0xdaa9
movl -0xc(%rbp), %eax
subl $0x14a, %eax            # imm = 0x14A
je 0xdac5
jmp 0xdae6
jmp 0xdaed
callq 0x2320
jmp 0xdaeb
callq 0xd980
jmp 0xdaeb
callq 0x2d30
cmpl $0x3b, 0x5db3(%rip)     # 0x13884
je 0xdadf
leaq 0x1916(%rip), %rdi      # 0xf3f0
callq 0x2790
callq 0x2d30
jmp 0xdaeb
callq 0x2c60
jmp 0xda7d
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/georgeweigt[P]sassafras/sassafras.c
// Function: print_pgm
void
print_pgm(void)
{
	char c, *s, *t;

	s = pgm;

	for (;;) {

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

		if (*s == 0 || s == inp)
			break;

		t = s;

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

		c = *s;
		*s = 0;
		emit_line(t);
		*s = c;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq 0xc189(%rip), %rax      # 0x19c98
movq %rax, -0x10(%rbp)
jmp 0xdb15
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0xdb5f
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq 0x5d55(%rip), %rcx      # 0x13888
movb %al, -0x19(%rbp)
je 0xdb5f
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0xa, %ecx
movb %al, -0x1a(%rbp)
je 0xdb59
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
sete %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xdb68
jmp 0xdb76
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xdb15
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0xdb8f
movq -0x10(%rbp), %rax
cmpq 0x5cfb(%rip), %rax      # 0x13888
jne 0xdb94
jmp 0xdc1e
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1b(%rbp)
je 0xdbe0
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpq 0x5cce(%rip), %rcx      # 0x13888
movb %al, -0x1b(%rbp)
je 0xdbe0
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0xa, %ecx
movb %al, -0x1b(%rbp)
je 0xdbe0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0xd, %eax
setne %al
movb %al, -0x1b(%rbp)
movb -0x1b(%rbp), %al
testb $0x1, %al
jne 0xdbe9
jmp 0xdbf7
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xdb9c
movq -0x10(%rbp), %rax
movb (%rax), %al
movb %al, -0x1(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rdi
callq 0x4bf0
movb -0x1(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, (%rax)
jmp 0xdb13
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)