LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: proc_anova_create_interaction_level_names
void
proc_anova_create_interaction_level_names(int n)
{
	int i, j, k, len, m, x;
	char *name, *s;

	m = dataset->nvar - 1; // index of new interaction column

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

	for (i = 0; i < dataset->spec[m].num_levels; i++) {

		len = n;

		for (j = 0; j < n; j++) {
			x = xx[j];
			k = kk[j];
			s = dataset->spec[x].ltab[k];
			len += strlen(s);
		}

		name = (char *) xmalloc(len);

		name[0] = 0;

		for (j = 0; j < n; j++) {
			if (j > 0)
				strcat(name, "*");
			x = xx[j];
			k = kk[j];
			s = dataset->spec[x].ltab[k];
			strcat(name, s);
		}

		dataset->spec[m].ltab[i] = name;

		// increment indices

		for (j = n - 1; j >= 0; j--) {
			x = xx[j];
			if (++kk[j] < dataset->spec[x].num_levels)
				break;
			kk[j] = 0;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0xdee0(%rip), %rbx      # 0x13ec8
movslq 0x10(%rbx), %rax
xorl %ecx, %ecx
testl %edi, %edi
movl $0x0, %r15d
movl %edi, -0x2c(%rbp)
cmovgl %edi, %r15d
shlq $0x2, %r15
leaq 0xe8a8(%rip), %r12      # 0x148b0
cmpq %rcx, %r15
je 0x6018
andl $0x0, (%rcx,%r12)
addq $0x4, %rcx
jmp 0x6008
decq %rax
movl -0x2c(%rbp), %ecx
movq %rcx, -0x40(%rbp)
xorl %edi, %edi
imulq $0x28, %rax, %r8
movq %r8, -0x38(%rbp)
movslq 0x2c(%rbx,%r8), %rax
cmpq %rax, %rdi
jge 0x6134
movq %rdi, -0x48(%rbp)
addq $0x20, %rbx
xorl %r13d, %r13d
movl -0x2c(%rbp), %r14d
cmpq %r13, %r15
je 0x607a
leaq 0xe53b(%rip), %rax      # 0x14590
movslq (%r13,%rax), %rax
movslq (%r13,%r12), %rcx
imulq $0x28, %rax, %rax
movq 0x10(%rbx,%rax), %rax
movq (%rax,%rcx,8), %rdi
callq 0x20b0
addl %eax, %r14d
addq $0x4, %r13
jmp 0x6049
movl %r14d, %edi
callq 0x2a9b
movq %rax, %r14
movb $0x0, (%rax)
movq 0xde39(%rip), %rbx      # 0x13ec8
addq $0x20, %rbx
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x60db
testq %r13, %r13
je 0x60af
movq %r14, %rdi
callq 0x20b0
movw $0x2a, (%r14,%rax)
leaq 0xe4da(%rip), %rax      # 0x14590
movslq (%r13,%rax), %rax
movslq (%r13,%r12), %rcx
imulq $0x28, %rax, %rax
movq 0x10(%rbx,%rax), %rax
movq (%rax,%rcx,8), %rsi
movq %r14, %rdi
callq 0x21e0
addq $0x4, %r13
jmp 0x6096
movq -0x38(%rbp), %r8
movq 0x10(%rbx,%r8), %rax
movq -0x48(%rbp), %rdi
movq %r14, (%rax,%rdi,8)
movq 0xddd5(%rip), %rbx      # 0x13ec8
leaq 0x20(%rbx), %rax
movq -0x40(%rbp), %rcx
testl %ecx, %ecx
jle 0x612c
leaq 0xe48a(%rip), %rdx      # 0x14590
movslq -0x4(%rdx,%rcx,4), %rdx
movl -0x4(%r12,%rcx,4), %esi
incl %esi
movl %esi, -0x4(%r12,%rcx,4)
imulq $0x28, %rdx, %rdx
cmpl 0xc(%rax,%rdx), %esi
jl 0x612c
andl $0x0, -0x4(%r12,%rcx,4)
decq %rcx
jmp 0x60fb
incq %rdi
jmp 0x602c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: proc_anova_regression
void
proc_anova_regression(void)
{
	proc_anova_prelim();

	proc_anova_fit();

	dfe = nobs - npar;

	mse = sse / dfe;

	rootmse = sqrt(mse);

	msr = ssr / (npar - 1);

	fval = msr / mse;

	pval = 1 - fdist(fval, npar - 1, nobs - npar);

	rsquare = 1 - sse / css;

	adjrsq = 1 - (double) (nobs - 1) / (nobs - npar) * sse / css;

	cv = 100 * rootmse / ybar;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x691e
callq 0x6bcc
movl 0xe8ed(%rip), %eax      # 0x14a44
subl 0xe8eb(%rip), %eax      # 0x14a48
cvtsi2sd %eax, %xmm1
movsd %xmm1, 0xe8e7(%rip)     # 0x14a50
movsd 0xe8e7(%rip), %xmm0     # 0x14a58
divsd %xmm1, %xmm0
movsd %xmm0, 0xe8e3(%rip)     # 0x14a60
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x618d
sqrtsd %xmm0, %xmm0
jmp 0x6192
callq 0x2200
movsd %xmm0, 0xe8ce(%rip)     # 0x14a68
movsd 0xe8ce(%rip), %xmm0     # 0x14a70
movl 0xe8a0(%rip), %eax      # 0x14a48
leal -0x1(%rax), %ecx
cvtsi2sd %ecx, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0xe8bd(%rip)     # 0x14a78
divsd 0xe89d(%rip), %xmm0     # 0x14a60
movsd %xmm0, 0xe8b5(%rip)     # 0x14a80
movl 0xe873(%rip), %ecx      # 0x14a44
subl %eax, %ecx
cvtsi2sd %ecx, %xmm2
callq 0x6cf2
movsd 0x50e4(%rip), %xmm1     # 0xb2c8
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
movsd %xmm2, 0xe894(%rip)     # 0x14a88
movsd 0xe85c(%rip), %xmm0     # 0x14a58
movsd 0xe88c(%rip), %xmm2     # 0x14a90
movl 0xe83a(%rip), %eax      # 0x14a44
leal -0x1(%rax), %ecx
cvtsi2sd %ecx, %xmm3
subl 0xe831(%rip), %eax      # 0x14a48
cvtsi2sd %eax, %xmm4
divsd %xmm4, %xmm3
mulsd %xmm0, %xmm3
divsd %xmm2, %xmm0
movapd %xmm1, %xmm4
subsd %xmm0, %xmm4
movsd %xmm4, 0xe861(%rip)     # 0x14a98
divsd %xmm2, %xmm3
subsd %xmm3, %xmm1
movsd 0xe821(%rip), %xmm0     # 0x14a68
mulsd 0x50b9(%rip), %xmm0     # 0xb308
movsd %xmm1, 0xe849(%rip)     # 0x14aa0
divsd 0xe849(%rip), %xmm0     # 0x14aa8
movsd %xmm0, 0xe849(%rip)     # 0x14ab0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
pushq $0x40
popq %rdi
callq 0x2a9b
movq %rax, %rbx
leaq 0x5315(%rip), %rdi      # 0xb870
callq 0x2210
movq %rax, (%rbx)
leaq 0x530f(%rip), %rdi      # 0xb879
callq 0x2210
movq %rax, 0x8(%rbx)
leaq 0x5309(%rip), %rdi      # 0xb883
callq 0x2210
movq %rax, 0x10(%rbx)
movq 0xd93e(%rip), %rax      # 0x13ec8
movslq 0xdfef(%rip), %rcx      # 0x14580
imulq $0x28, %rcx, %rcx
movq 0x20(%rax,%rcx), %rcx
leaq 0xc91f(%rip), %r14      # 0x12ec0
leaq 0x52e4(%rip), %rdx      # 0xb88c
movl $0xfa0, %esi            # imm = 0xFA0
movq %r14, %rdi
xorl %eax, %eax
callq 0x20e0
movq %r14, %rdi
callq 0x2210
movq %rax, 0x18(%rbx)
movsd 0xe4cd(%rip), %xmm0     # 0x14a98
leaq 0x4d9a(%rip), %r15      # 0xb36c
movl $0xfa0, %esi            # imm = 0xFA0
movq %r14, %rdi
movq %r15, %rdx
movb $0x1, %al
callq 0x20e0
movq %r14, %rdi
callq 0x2210
movq %rax, 0x20(%rbx)
movsd 0xe4b8(%rip), %xmm0     # 0x14ab0
movl $0xfa0, %esi            # imm = 0xFA0
movq %r14, %rdi
movq %r15, %rdx
movb $0x1, %al
callq 0x20e0
movq %r14, %rdi
callq 0x2210
movq %rax, 0x28(%rbx)
movsd 0xe44a(%rip), %xmm0     # 0x14a68
movl $0xfa0, %esi            # imm = 0xFA0
movq %r14, %rdi
movq %r15, %rdx
movb $0x1, %al
callq 0x20e0
movq %r14, %rdi
callq 0x2210
movq %rax, 0x30(%rbx)
movsd 0xe464(%rip), %xmm0     # 0x14aa8
movl $0xfa0, %esi            # imm = 0xFA0
movq %r14, %rdi
movq %r15, %rdx
movb $0x1, %al
callq 0x20e0
movq %r14, %rdi
callq 0x2210
andl $0x0, 0xc85b(%rip)      # 0x12ec0
movq %rax, 0x38(%rbx)
pushq $0x2
popq %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4411
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0xde64(%rip), %esi      # 0x14a44
movq 0xdef1(%rip), %rax      # 0x14ad8
movslq 0xdf02(%rip), %rcx      # 0x14af0
xorl %edx, %edx
testl %esi, %esi
cmovgl %esi, %edx
shlq $0x3, %rcx
movabsq $0x3ff0000000000000, %rsi # imm = 0x3FF0000000000000
subq $0x1, %rdx
jb 0x6c11
movq %rsi, (%rax)
addq %rcx, %rax
jmp 0x6c03
movl $0x1, 0xde2d(%rip)      # 0x14a48
xorl %r13d, %r13d
leaq 0xdedb(%rip), %r12      # 0x14b00
leaq 0xe074(%rip), %rdx      # 0x14ca0
movslq 0xd7b5(%rip), %rax      # 0x143e8
cmpq %rax, %r13
jge 0x6cb5
leaq 0xdae1(%rip), %rax      # 0x14720
movslq (%rax,%r13,4), %rbx
movq 0xd27e(%rip), %rax      # 0x13ec8
imulq $0x28, %rbx, %rcx
movl 0x2c(%rax,%rcx), %r15d
xorl %r14d, %r14d
testl %r15d, %r15d
cmovlel %r14d, %r15d
cmpl %r14d, %r15d
je 0x6c71
movl %ebx, %edi
movl %r14d, %esi
callq 0x6da3
incl %r14d
jmp 0x6c5d
movl 0xddd1(%rip), %eax      # 0x14a48
movl %eax, (%r12,%r13,4)
cmpl $-0x1, 0xe00e(%rip)     # 0x14c90
jne 0x6c89
callq 0x6e49
callq 0x72fb
callq 0x73cf
callq 0x7447
movsd 0xddd0(%rip), %xmm0     # 0x14a70
leaq 0xdff9(%rip), %rdx      # 0x14ca0
movsd %xmm0, (%rdx,%r13,8)
incq %r13
jmp 0x6c2c
movl %eax, %eax
cmpl $0x2, %eax
jl 0x6cdd
movl -0x8(%r12,%rax,4), %ecx
subl %ecx, -0x4(%r12,%rax,4)
movsd -0x8(%rdx,%rax,8), %xmm0
subsd -0x10(%rdx,%rax,8), %xmm0
movsd %xmm0, -0x8(%rdx,%rax,8)
decq %rax
jmp 0x6cb7
decl 0xde1d(%rip)            # 0x14b00
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: 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
movapd %xmm0, %xmm3
ucomisd %xmm0, %xmm0
movq %xmm1, %rcx
setp %dl
btrq $0x3f, %rcx
movabsq $0x7fefffffffffffff, %rax # imm = 0x7FEFFFFFFFFFFFFF
cmpq %rax, %rcx
setg %cl
orb %dl, %cl
movsd 0x459b(%rip), %xmm0     # 0xb2c0
jne 0x6d97
movq %xmm2, %rcx
btrq $0x3f, %rcx
cmpq %rax, %rcx
setg %al
xorpd %xmm4, %xmm4
ucomisd %xmm2, %xmm4
jae 0x6d97
ucomisd %xmm1, %xmm4
jae 0x6d97
testb %al, %al
jne 0x6d97
ucomisd 0x4585(%rip), %xmm3     # 0xb2d8
jb 0x6d5f
movsd 0x456b(%rip), %xmm0     # 0xb2c8
jmp 0x6d97
xorpd %xmm0, %xmm0
ucomisd %xmm3, %xmm0
jae 0x6d97
movsd 0x45a7(%rip), %xmm4     # 0xb318
movapd %xmm1, %xmm0
mulsd %xmm4, %xmm0
mulsd %xmm2, %xmm4
divsd %xmm1, %xmm2
addsd %xmm3, %xmm2
divsd %xmm2, %xmm3
movapd %xmm4, %xmm1
movapd %xmm3, %xmm2
popq %rbp
jmp 0x39da
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq 0xd11a(%rip), %rdx      # 0x13ec8
movslq 0x14(%rdx), %rax
movq 0xdcff(%rip), %rcx      # 0x14ab8
movslq %edi, %rdi
imulq $0x28, %rdi, %rdi
addq %rdi, %rdx
addq $0x40, %rdx
cvtsi2sd %esi, %xmm0
movslq 0xdc76(%rip), %rsi      # 0x14a48
movq %rsi, %rdi
shlq $0x3, %rdi
addq 0xdcf8(%rip), %rdi      # 0x14ad8
movslq 0xdd09(%rip), %r8       # 0x14af0
xorl %r9d, %r9d
movsd 0x44d6(%rip), %xmm1     # 0xb2c8
xorl %r10d, %r10d
cmpq %rax, %r9
jge 0x6e28
cmpl $0x0, (%rcx,%r9,4)
jne 0x6e23
movq (%rdx), %r11
movsd (%r11,%r9,8), %xmm2
cmpeqsd %xmm0, %xmm2
andpd %xmm1, %xmm2
movslq %r10d, %r11
incl %r10d
imulq %r8, %r11
movlpd %xmm2, (%rdi,%r11,8)
incq %r9
jmp 0x6df5
leal 0x1(%rsi), %eax
movl %eax, 0xdc17(%rip)      # 0x14a48
callq 0x6e49
movl %eax, 0xde54(%rip)      # 0x14c90
cmpl $-0x1, %eax
jne 0x6e47
decl 0xdc01(%rip)            # 0x14a48
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
movl 0xd742(%rip), %eax      # 0x14a48
movl 0xd738(%rip), %esi      # 0x14a44
movslq 0xd7dd(%rip), %rcx      # 0x14af0
movq 0xd7b6(%rip), %rdi      # 0x14ad0
xorl %r8d, %r8d
testl %esi, %esi
cmovlel %r8d, %esi
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
shlq $0x3, %rcx
xorl %r9d, %r9d
cmpq %rdx, %r9
je 0x737b
movq 0xd7a0(%rip), %r10      # 0x14ae0
movq 0xd791(%rip), %r11      # 0x14ad8
addq %r8, %r11
xorpd %xmm0, %xmm0
xorl %ebx, %ebx
cmpq %rbx, %rsi
je 0x736c
movsd (%r11), %xmm1
mulsd (%r10,%rbx,8), %xmm1
addsd %xmm1, %xmm0
incq %rbx
addq %rcx, %r11
jmp 0x7350
movsd %xmm0, (%rdi,%r9,8)
incq %r9
addq $0x8, %r8
jmp 0x7334
movq 0xd73e(%rip), %rsi      # 0x14ac0
xorl %edi, %edi
xorl %r8d, %r8d
cmpq %rdx, %r8
je 0x73cc
movq 0xd73d(%rip), %r9       # 0x14ad0
movq 0xd72e(%rip), %r10      # 0x14ac8
addq %rdi, %r10
xorpd %xmm0, %xmm0
xorl %r11d, %r11d
cmpq %r11, %rax
je 0x73be
movsd (%r10,%r11,8), %xmm1
mulsd (%r9,%r11,8), %xmm1
addsd %xmm1, %xmm0
incq %r11
jmp 0x73a4
movsd %xmm0, (%rsi,%r8,8)
incq %r8
addq %rcx, %rdi
jmp 0x7387
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd66b(%rip), %eax      # 0x14a44
movl 0xd669(%rip), %ecx      # 0x14a48
movslq 0xd70a(%rip), %rdx      # 0x14af0
movq 0xd6fb(%rip), %rsi      # 0x14ae8
xorl %edi, %edi
testl %ecx, %ecx
cmovlel %edi, %ecx
testl %eax, %eax
cmovlel %edi, %eax
shlq $0x3, %rdx
xorl %r8d, %r8d
cmpq %rax, %r8
je 0x7445
movq 0xd6b4(%rip), %r9       # 0x14ac0
movq 0xd6c5(%rip), %r10      # 0x14ad8
addq %rdi, %r10
xorpd %xmm0, %xmm0
xorl %r11d, %r11d
cmpq %r11, %rcx
je 0x7437
movsd (%r10,%r11,8), %xmm1
mulsd (%r9,%r11,8), %xmm1
addsd %xmm1, %xmm0
incq %r11
jmp 0x741d
movsd %xmm0, (%rsi,%r8,8)
incq %r8
addq %rdx, %rdi
jmp 0x7400
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, 0xd61d(%rip)      # 0x14a70
andq $0x0, 0xd5fd(%rip)      # 0x14a58
movl 0xd5e3(%rip), %eax      # 0x14a44
movq 0xd680(%rip), %rcx      # 0x14ae8
movsd 0xd638(%rip), %xmm0     # 0x14aa8
movq 0xd669(%rip), %rdx      # 0x14ae0
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
cmpq %rsi, %rax
je 0x74c3
movsd (%rcx,%rsi,8), %xmm3
subsd %xmm0, %xmm3
mulsd %xmm3, %xmm3
addsd %xmm3, %xmm2
movsd %xmm2, 0xd5cc(%rip)     # 0x14a70
movsd (%rdx,%rsi,8), %xmm3
subsd (%rcx,%rsi,8), %xmm3
mulsd %xmm3, %xmm3
addsd %xmm3, %xmm1
movsd %xmm1, 0xd59a(%rip)     # 0x14a58
incq %rsi
jmp 0x7486
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
subq $0x38, %rsp
movapd %xmm0, %xmm2
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
movsd 0x3dde(%rip), %xmm3     # 0xb2c0
jb 0x762f
ucomisd 0x3dd8(%rip), %xmm2     # 0xb2c8
ja 0x762f
movq %xmm1, %rax
movq %rax, %rcx
btrq $0x3f, %rcx
leaq -0x1(%rcx), %rdx
movabsq $0xfffffffffffff, %rsi  # imm = 0xFFFFFFFFFFFFF
cmpq %rsi, %rdx
setb %dl
testq %rax, %rax
sets %al
andb %al, %dl
testq %rcx, %rcx
sete %sil
movabsq $0x7ff0000000000000, %rdi # imm = 0x7FF0000000000000
cmpq %rdi, %rcx
setg %dil
sete %r8b
orb %sil, %r8b
orb %dil, %r8b
orb %dl, %r8b
movabsq $-0x10000000000000, %rdx # imm = 0xFFF0000000000000
addq %rcx, %rdx
shrq $0x35, %rdx
cmpl $0x3ff, %edx            # imm = 0x3FF
setb %cl
andb %al, %cl
orb %r8b, %cl
jne 0x762f
ucomisd %xmm0, %xmm2
jne 0x757e
jp 0x757e
movsd 0x3daf(%rip), %xmm3     # 0xb328
jmp 0x762f
ucomisd 0x3d42(%rip), %xmm2     # 0xb2c8
jne 0x7597
jp 0x7597
movsd 0x3d46(%rip), %xmm3     # 0xb2d8
jmp 0x762f
movsd 0x3d91(%rip), %xmm0     # 0xb330
movsd %xmm0, -0x10(%rbp)
movsd 0x3d8c(%rip), %xmm0     # 0xb338
pushq $0x64
popq %rbx
movq %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
subl $0x1, %ebx
jb 0x762f
movapd %xmm0, -0x40(%rbp)
addsd -0x10(%rbp), %xmm0
mulsd 0x3d48(%rip), %xmm0     # 0xb318
movapd %xmm0, -0x30(%rbp)
callq 0x763a
movsd -0x20(%rbp), %xmm2
movapd %xmm0, %xmm1
subsd %xmm2, %xmm1
andpd 0x3cb1(%rip), %xmm1     # 0xb2a0
movsd 0x3d49(%rip), %xmm3     # 0xb340
ucomisd %xmm1, %xmm3
ja 0x762a
ucomisd %xmm0, %xmm2
movapd -0x30(%rbp), %xmm3
ja 0x760d
movsd %xmm3, -0x10(%rbp)
cmpltsd %xmm2, %xmm0
movapd %xmm0, %xmm1
andpd %xmm3, %xmm1
andnpd -0x40(%rbp), %xmm0
orpd %xmm1, %xmm0
movq -0x18(%rbp), %xmm1
jmp 0x75b9
movapd -0x30(%rbp), %xmm3
movapd %xmm3, %xmm0
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movapd %xmm0, %xmm3
movsd 0x3c7a(%rip), %xmm0     # 0xb2c0
ucomisd %xmm3, %xmm3
jp 0x76e3
movq %xmm1, %rax
movq %rax, %rcx
btrq $0x3f, %rcx
leaq -0x1(%rcx), %rdx
movabsq $0xfffffffffffff, %rsi  # imm = 0xFFFFFFFFFFFFF
cmpq %rsi, %rdx
setb %dl
testq %rax, %rax
sets %al
andb %al, %dl
testq %rcx, %rcx
sete %sil
movabsq $0x7ff0000000000000, %rdi # imm = 0x7FF0000000000000
cmpq %rdi, %rcx
setg %dil
sete %r8b
orb %sil, %r8b
orb %dil, %r8b
orb %dl, %r8b
movabsq $-0x10000000000000, %rdx # imm = 0xFFF0000000000000
addq %rcx, %rdx
shrq $0x35, %rdx
cmpl $0x3ff, %edx            # imm = 0x3FF
setb %cl
andb %al, %cl
orb %r8b, %cl
jne 0x76e3
ucomisd 0x3c11(%rip), %xmm3     # 0xb2d8
jb 0x76d2
movsd 0x3bf7(%rip), %xmm0     # 0xb2c8
retq
xorps %xmm0, %xmm0
movsd 0x3c4b(%rip), %xmm2     # 0xb328
ucomisd %xmm3, %xmm2
jb 0x76e4
retq
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movapd %xmm3, %xmm4
mulsd %xmm3, %xmm4
addsd %xmm1, %xmm4
sqrtsd %xmm4, %xmm0
xorpd %xmm5, %xmm5
ucomisd %xmm5, %xmm4
movapd %xmm0, %xmm2
movsd %xmm1, -0x10(%rbp)
jae 0x7743
movsd %xmm0, -0x20(%rbp)
movapd %xmm4, %xmm0
movsd %xmm3, -0x8(%rbp)
movsd %xmm4, -0x18(%rbp)
callq 0x2200
xorpd %xmm5, %xmm5
movsd -0x18(%rbp), %xmm4
movsd -0x8(%rbp), %xmm3
movsd -0x10(%rbp), %xmm1
movapd %xmm0, %xmm2
movsd -0x20(%rbp), %xmm0
addsd %xmm3, %xmm2
ucomisd %xmm5, %xmm4
jae 0x7765
movapd %xmm4, %xmm0
movsd %xmm2, -0x8(%rbp)
callq 0x2200
movsd -0x8(%rbp), %xmm2
movsd -0x10(%rbp), %xmm1
addsd %xmm0, %xmm0
mulsd 0x3ba7(%rip), %xmm1     # 0xb318
divsd %xmm0, %xmm2
movapd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbp
jmp 0x39da
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0xdfdd(%rip), %rbx      # 0x157a0
leaq 0x38c6(%rip), %r14      # 0xb090
movabsq $0x13400000133, %r15    # imm = 0x13400000133
callq 0x2a45
callq 0x254c
movl 0x80b0(%rip), %eax      # 0xf894
leal -0x12d(%rax), %ecx
cmpl $0x22, %ecx
ja 0x7813
movslq (%r14,%rcx,4), %rcx
addq %r14, %rcx
jmpq *%rcx
movslq 0xdf91(%rip), %rcx      # 0x15790
cmpq $0xc, %rcx
je 0x7865
leal 0x1(%rcx), %edx
movl %edx, 0xdf82(%rip)      # 0x15790
movl %eax, (%rbx,%rcx,4)
jmp 0x77d4
leal -0x156(%rax), %ecx
cmpl $0x2, %ecx
jb 0x77f8
jmp 0x7851
callq 0x40db
jmp 0x77d4
movslq 0xdf62(%rip), %rax      # 0x15790
cmpq $0xb, %rax
jge 0x7865
movq %r15, (%rbx,%rax,4)
addl $0x2, %eax
movl %eax, 0xdf4f(%rip)      # 0x15790
jmp 0x77d4
callq 0x4093
jmp 0x77d4
callq 0x4022
jmp 0x77d4
cmpl $0x3b, %eax
jne 0x7871
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2a45
leaq 0x40d5(%rip), %rdi      # 0xb941
callq 0x267a
leaq 0x40e6(%rip), %rdi      # 0xb95e
callq 0x25a8
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x254c
movl 0x8008(%rip), %eax      # 0xf894
cmpl $0x131, %eax            # imm = 0x131
je 0x78c1
cmpl $0x157, %eax            # imm = 0x157
je 0x78ba
testl %eax, %eax
je 0x78c8
cmpl $0x135, %eax            # imm = 0x135
je 0x78c8
cmpl $0x14a, %eax            # imm = 0x14A
je 0x78c8
cmpl $0x147, %eax            # imm = 0x147
je 0x78c8
callq 0x29bd
jmp 0x7881
callq 0x4338
jmp 0x7881
callq 0x4237
jmp 0x7881
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpl %edi, 0xc5c4(%rip)      # 0x14220
je 0x7cc8
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq %edi, %r14
leaq 0xc416(%rip), %rax      # 0x14090
movslq (%rax,%r14,4), %rax
movq 0xc243(%rip), %rcx      # 0x13ec8
imulq $0x28, %rax, %rax
movl 0x2c(%rcx,%rax), %r15d
leal 0x1(%r14), %ebx
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
leaq 0xdbcd(%rip), %r13      # 0x15870
cmpl %r12d, %r15d
je 0x7cb9
movl %r12d, (%r13,%r14,4)
movl %ebx, %edi
callq 0x7c56
incl %r12d
jmp 0x7ca3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %r12d, %r12d
leaq 0x37e0(%rip), %rbx      # 0xb4c3
movslq 0xc6d6(%rip), %rax      # 0x143c0
cmpq %rax, %r12
jge 0x7dea
movslq 0xc526(%rip), %rdx      # 0x14220
movl 0xcdf0(%rip), %eax      # 0x14af0
imull 0xdad9(%rip), %eax      # 0x157e0
testl %edx, %edx
movl $0x0, %r14d
movq %rdx, -0x30(%rbp)
cmovgl %edx, %r14d
movslq %eax, %r15
movq %r12, -0x38(%rbp)
testq %r12, %r12
je 0x7d44
movq %r15, %r12
subq $0x1, %r14
jb 0x7d9d
movq %rbx, %rdi
callq 0x2210
movq 0xda9d(%rip), %rcx      # 0x157d8
movq %rax, (%rcx,%r12,8)
incq %r12
jmp 0x7d26
shlq $0x2, %r14
leaq (,%r15,8), %r12
xorl %r13d, %r13d
cmpq %r13, %r14
je 0x7d9d
leaq 0xc331(%rip), %rax      # 0x14090
movslq (%r13,%rax), %rax
leaq 0xdb05(%rip), %rcx      # 0x15870
movslq (%r13,%rcx), %rcx
movq 0xc151(%rip), %rdx      # 0x13ec8
imulq $0x28, %rax, %rax
movq 0x30(%rdx,%rax), %rax
movq (%rax,%rcx,8), %rdi
callq 0x2210
movq 0xda48(%rip), %rcx      # 0x157d8
addq %r12, %rcx
movq %rax, (%rcx,%r13,2)
addq $0x4, %r13
jmp 0x7d53
movq -0x38(%rbp), %r12
leaq 0xc488(%rip), %rax      # 0x14230
movslq (%rax,%r12,4), %r14
movq 0xc115(%rip), %rax      # 0x13ec8
imulq $0x28, %r14, %rcx
movq 0x20(%rax,%rcx), %rdi
callq 0x2210
shlq $0x3, %r15
addq 0xda0c(%rip), %r15      # 0x157d8
movq -0x30(%rbp), %rcx
movq %rax, (%r15,%rcx,8)
movl %r14d, %edi
callq 0x7df9
incl 0xd9fe(%rip)            # 0x157e0
incq %r12
jmp 0x7ce3
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: 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
callq 0x254c
movl 0x7648(%rip), %eax      # 0xf894
cmpl $0x157, %eax            # imm = 0x157
je 0x8273
testl %eax, %eax
je 0x827a
cmpl $0x135, %eax            # imm = 0x135
je 0x827a
cmpl $0x14a, %eax            # imm = 0x14A
je 0x827a
cmpl $0x147, %eax            # imm = 0x147
je 0x827a
callq 0x29bd
jmp 0x8241
callq 0x4338
jmp 0x8241
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: proc_reg
void
proc_reg(void)
{
	num_x = 0;
	num_y = 0;

	proc_reg_parse_stmt();

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

	proc_reg_parse_body();

	proc_reg_regress();

	print_title();

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

	proc_reg_print_anova_table();
	proc_reg_print_diag_table();

	emit_line_center("Parameter Estimates");
	emit_line("");

	proc_reg_print_parameter_estimates();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
andl $0x0, 0xd491(%rip)      # 0x15a00
andl $0x0, 0xd48e(%rip)      # 0x15a04
callq 0x85de
cmpq $0x0, 0xb945(%rip)      # 0x13ec8
je 0x85d2
callq 0x8625
callq 0x8664
callq 0x46e2
leaq 0x327a(%rip), %rdi      # 0xb815
callq 0x3df6
pushq $0xa
popq %rbx
movl %ebx, %edi
callq 0x2050
callq 0x895c
callq 0x8c57
leaq 0x341a(%rip), %rdi      # 0xb9d5
callq 0x3df6
movl %ebx, %edi
callq 0x2050
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x8def
leaq 0x3073(%rip), %rdi      # 0xb64c
callq 0x267a
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x254c
movl 0x7260(%rip), %eax      # 0xf894
cmpl $0x143, %eax            # imm = 0x143
je 0x865b
testl %eax, %eax
je 0x8662
cmpl $0x135, %eax            # imm = 0x135
je 0x8662
cmpl $0x14a, %eax            # imm = 0x14A
je 0x8662
cmpl $0x147, %eax            # imm = 0x147
je 0x8662
callq 0x29bd
jmp 0x8629
callq 0x911f
jmp 0x8629
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
leaq 0x2c11(%rip), %rax      # 0xb883
leaq -0xa0(%rbp), %rbx
movq %rax, (%rbx)
leaq 0x2def(%rip), %rax      # 0xba72
movq %rax, 0x20(%rbx)
leaq 0x2beb(%rip), %rax      # 0xb879
movq %rax, 0x40(%rbx)
leaq 0x2bd7(%rip), %rax      # 0xb870
movq %rax, 0x10(%rbx)
leaq 0x2ddd(%rip), %rax      # 0xba81
movq %rax, 0x30(%rbx)
leaq 0x2814(%rip), %rax      # 0xb4c3
movq %rax, 0x50(%rbx)
movsd 0xbdad(%rip), %xmm0     # 0x14a68
leaq 0x26a4(%rip), %r15      # 0xb366
leaq -0x110(%rbp), %r14
pushq $0x64
popq %r12
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movb $0x1, %al
callq 0x20e0
movq %r14, %rdi
callq 0x2210
movq %rax, -0x38(%rbp)
movq %rax, 0x8(%rbx)
movsd 0xbdb3(%rip), %xmm0     # 0x14aa8
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movb $0x1, %al
callq 0x20e0
movq %r14, %rdi
callq 0x2210
movq %rax, -0x30(%rbp)
movq %rax, 0x28(%rbx)
movsd 0xbd93(%rip), %xmm0     # 0x14ab0
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movb $0x1, %al
callq 0x20e0
movq %r14, %rdi
callq 0x2210
movq %rax, %r15
movq %rax, 0x48(%rbx)
movsd 0xbd54(%rip), %xmm0     # 0x14a98
leaq 0x2615(%rip), %r13      # 0xb360
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
movb $0x1, %al
callq 0x20e0
movq %r14, %rdi
callq 0x2210
movq %rax, %r12
movq %rax, 0x18(%rbx)
movsd 0xbd2e(%rip), %xmm0     # 0x14aa0
movq %r14, %rdi
pushq $0x64
popq %rsi
movq %r13, %rdx
movb $0x1, %al
callq 0x20e0
movq %r14, %rdi
callq 0x2210
movq %rax, %r13
movq %rax, 0x38(%rbx)
leaq 0x272b(%rip), %rax      # 0xb4c3
movq %rax, 0x58(%rbx)
movl $0x10001, (%r14)        # imm = 0x10001
pushq $0x3
popq %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq 0x4491
movq -0x38(%rbp), %rdi
callq 0x2040
movq -0x30(%rbp), %rdi
callq 0x2040
movq %r15, %rdi
callq 0x2040
movq %r12, %rdi
callq 0x2040
movq %r13, %rdi
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: proc_reg_compute_X
void
proc_reg_compute_X(void)
{
	int i, j, k, l, m, n, x, y;
	double v;

	l = 0;

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

		// check for missing data

		y = ytab[0];

		v = dataset->spec[y].v[i];

		if (isnan(v))
			continue;

		Y[l] = v;

		if (noint)
			m = 0;
		else {
			m = 1;
			X(l, 0) = 1;
		}

		for (j = 0; j < num_x; j++) {

			x = xtab[j];

			v = dataset->spec[x].v[i];

			if (isnan(v))
				break;

			if (dataset->spec[x].ltab == NULL)
				X(l, m++) = v;
			else {

				// categorical variable

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

				for (k = 0; k < n; k++)
					if (k == v)
						X(l, m + k) = 1;
					else
						X(l, m + k) = 0;

				m += n;
			}
		}

		if (j == num_x)
			l++; // full row, no nans
	}

	// missing data may reduce nrow

	nrow = l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0xc49f(%rip), %r10d     # 0x157d0
movslq 0xc6d8(%rip), %rax      # 0x15a10
movq 0xab89(%rip), %rcx      # 0x13ec8
imulq $0x28, %rax, %rax
addq %rcx, %rax
addq $0x40, %rax
movq %rax, -0x50(%rbp)
addq $0x20, %rcx
movq 0xb787(%rip), %rax      # 0x14ae0
movq %rax, -0x48(%rbp)
movl 0xc6a5(%rip), %eax      # 0x15a08
movl %eax, -0x34(%rbp)
movq 0xb76b(%rip), %rax      # 0x14ad8
movq %rax, -0x40(%rbp)
movl 0xb779(%rip), %eax      # 0x14af0
movl %eax, -0x30(%rbp)
movl 0xc680(%rip), %eax      # 0x15a00
xorl %r11d, %r11d
testl %eax, %eax
movl $0x0, %r8d
movl %eax, -0x2c(%rbp)
cmovgl %eax, %r8d
testl %r10d, %r10d
cmovlel %r11d, %r10d
leaq 0xb380(%rip), %r12      # 0x14720
movsd 0x1f20(%rip), %xmm0     # 0xb2c8
xorl %r13d, %r13d
cmpq %r10, %r11
je 0x94a0
movq -0x50(%rbp), %rax
movq (%rax), %rax
movsd (%rax,%r11,8), %xmm1
ucomisd %xmm1, %xmm1
jp 0x9498
movl -0x30(%rbp), %eax
imull %r13d, %eax
xorl %r15d, %r15d
movslq %r13d, %rdx
movq -0x48(%rbp), %rsi
movsd %xmm1, (%rsi,%rdx,8)
movslq %eax, %r14
cmpl $0x0, -0x34(%rbp)
jne 0x9402
movq -0x40(%rbp), %rax
movabsq $0x3ff0000000000000, %rdx # imm = 0x3FF0000000000000
movq %rdx, (%rax,%r14,8)
movl $0x1, %r15d
shlq $0x3, %r14
movq 0xb6cb(%rip), %rdx      # 0x14ad8
addq %r14, %rdx
xorl %ebx, %ebx
cmpq %r8, %rbx
je 0x948a
movslq (%r12,%rbx,4), %rax
imulq $0x28, %rax, %rsi
movq 0x20(%rcx,%rsi), %rax
movsd (%rax,%r11,8), %xmm1
ucomisd %xmm1, %xmm1
jp 0x948d
addq %rcx, %rsi
cmpq $0x0, 0x10(%rsi)
movslq %r15d, %rax
je 0x947c
movl 0xc(%rsi), %esi
movq 0xb691(%rip), %r9       # 0x14ad8
addq %r14, %r9
testl %esi, %esi
movl $0x0, %edi
cmovgl %esi, %edi
leaq (%r9,%rax,8), %r9
xorl %eax, %eax
cmpq %rax, %rdi
je 0x9477
cvtsi2sd %eax, %xmm2
cmpeqsd %xmm1, %xmm2
andpd %xmm0, %xmm2
movlpd %xmm2, (%r9,%rax,8)
incq %rax
jmp 0x945a
addl %esi, %r15d
jmp 0x9485
leal 0x1(%rax), %r15d
movsd %xmm1, (%rdx,%rax,8)
incq %rbx
jmp 0x9412
movl %r8d, %ebx
xorl %eax, %eax
cmpl -0x2c(%rbp), %ebx
sete %al
addl %eax, %r13d
incq %r11
jmp 0x93ab
movl %r13d, 0xc329(%rip)     # 0x157d0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: 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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0xb62b(%rip), %eax      # 0x14af0
movl 0xc305(%rip), %ecx      # 0x157d0
movslq %eax, %rdx
xorl %esi, %esi
testl %ecx, %ecx
cmovlel %esi, %ecx
testl %edx, %edx
movl $0x0, %edi
cmovgl %edx, %edi
movq 0xc6ba(%rip), %r8       # 0x15ba0
shlq $0x3, %rdx
xorl %r9d, %r9d
xorl %r10d, %r10d
cmpq %rdi, %r9
je 0x956f
cmpl $0x0, (%r8,%r9,4)
jne 0x9566
movl %eax, %r11d
imull %r10d, %r11d
movslq %r11d, %r11
shlq $0x3, %r11
addq 0xb5bf(%rip), %r11      # 0x14ad0
xorl %ebx, %ebx
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpq %rax, %r14
je 0x9563
cmpl $0x0, (%r8,%r14,4)
jne 0x955a
xorpd %xmm0, %xmm0
movq 0xb5a8(%rip), %r12      # 0x14ad8
movq %rcx, %r13
subq $0x1, %r13
jb 0x954e
movsd (%r12,%rsi), %xmm1
mulsd (%r12,%rbx), %xmm1
addsd %xmm1, %xmm0
addq %rdx, %r12
jmp 0x9533
movslq %r15d, %r15
movsd %xmm0, (%r11,%r15,8)
incl %r15d
incq %r14
addq $0x8, %rbx
jmp 0x9519
incl %r10d
incq %r9
addq $0x8, %rsi
jmp 0x94f0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: 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
pushq %r14
pushq %rbx
movslq 0xb13a(%rip), %rax      # 0x14af0
movq 0xc1e3(%rip), %rcx      # 0x15ba0
movl 0xbe0d(%rip), %edx      # 0x157d0
xorl %esi, %esi
testl %edx, %edx
cmovlel %esi, %edx
testl %eax, %eax
movl $0x0, %edi
cmovgl %eax, %edi
movq 0xb0f5(%rip), %r8       # 0x14ad0
shlq $0x3, %rax
xorl %r9d, %r9d
xorl %r10d, %r10d
cmpq %rdi, %r9
je 0x9a39
cmpl $0x0, (%rcx,%r9,4)
jne 0x9a30
movq 0xb0e8(%rip), %r11      # 0x14ae0
movq 0xb0d9(%rip), %rbx      # 0x14ad8
addq %rsi, %rbx
xorpd %xmm0, %xmm0
xorl %r14d, %r14d
cmpq %r14, %rdx
je 0x9a24
movsd (%rbx), %xmm1
mulsd (%r11,%r14,8), %xmm1
addsd %xmm1, %xmm0
incq %r14
addq %rax, %rbx
jmp 0x9a09
movslq %r10d, %r11
incl %r10d
movsd %xmm0, (%r8,%r11,8)
incq %r9
addq $0x8, %rsi
jmp 0x99e5
movl 0xb009(%rip), %ecx      # 0x14a48
movq 0xb07a(%rip), %rdx      # 0x14ac0
xorl %esi, %esi
testl %ecx, %ecx
movl $0x0, %edi
cmovgl %ecx, %edi
xorl %r8d, %r8d
cmpq %rdi, %r8
je 0x9a9a
movq 0xb06f(%rip), %r9       # 0x14ad0
movq 0xb060(%rip), %r10      # 0x14ac8
addq %rsi, %r10
xorpd %xmm0, %xmm0
xorl %r11d, %r11d
cmpq %r11, %rcx
je 0x9a8c
movsd (%r10,%r11,8), %xmm1
mulsd (%r9,%r11,8), %xmm1
addsd %xmm1, %xmm0
incq %r11
jmp 0x9a72
movsd %xmm0, (%rdx,%r8,8)
incq %r8
addq %rax, %rsi
jmp 0x9a55
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
movl 0xbd22(%rip), %eax      # 0x157d0
movslq 0xb03b(%rip), %rcx      # 0x14af0
movq 0xb02c(%rip), %rdx      # 0x14ae8
xorl %esi, %esi
testl %ecx, %ecx
movl $0x0, %edi
cmovgl %ecx, %edi
testl %eax, %eax
cmovlel %esi, %eax
shlq $0x3, %rcx
xorl %r8d, %r8d
cmpq %rax, %r8
je 0x9b2f
movq 0xc0c0(%rip), %r9       # 0x15ba0
movq 0xafd9(%rip), %r10      # 0x14ac0
movq 0xafea(%rip), %r11      # 0x14ad8
addq %rsi, %r11
xorpd %xmm0, %xmm0
xorl %ebx, %ebx
xorl %r14d, %r14d
cmpq %rbx, %rdi
je 0x9b21
cmpl $0x0, (%r9,%rbx,4)
jne 0x9b1c
movsd (%r11,%rbx,8), %xmm1
movslq %r14d, %r15
incl %r14d
mulsd (%r10,%r15,8), %xmm1
addsd %xmm1, %xmm0
incq %rbx
jmp 0x9afa
movsd %xmm0, (%rdx,%r8,8)
incq %r8
addq %rcx, %rsi
jmp 0x9ad4
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/georgeweigt[P]sassafras/sassafras.c
// Function: proc_reg_compute_mse
void
proc_reg_compute_mse(void)
{
	int i;
	double d;

	dfm = npar - 1;
	dfe = nrow - npar;
	dft = nrow - 1;

	ybar = 0;

	for (i = 0; i < nrow; i++)
		ybar += (Y[i] - ybar) / (i + 1);

	ssr = 0;
	sse = 0;
	sst = 0;

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

		d = Yhat[i] - ybar;
		ssr += d * d;

		d = Y[i] - Yhat[i];
		sse += d * d;

		d = Y[i] - ybar;
		sst += d * d;
	}

	mse = sse / dfe;

	rootmse = sqrt(mse);

	msr = ssr / dfm;

	fval = msr / mse;

	pval = 1.0 - fdist(fval, dfm, dfe);

	rsquare = 1.0 - sse / sst;

	adjrsq = 1.0 - dft / dfe * sse / sst;

	cv = 100.0 * rootmse / ybar;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0xaf08(%rip), %ecx      # 0x14a48
leal -0x1(%rcx), %eax
cvtsi2sd %eax, %xmm0
movl 0xbc83(%rip), %eax      # 0x157d0
movl %eax, %edx
subl %ecx, %edx
cvtsi2sd %edx, %xmm1
movsd %xmm0, 0xc063(%rip)     # 0x15bc0
leal -0x1(%rax), %ecx
cvtsi2sd %ecx, %xmm0
movsd %xmm1, 0xaee4(%rip)     # 0x14a50
movsd %xmm0, 0xc054(%rip)     # 0x15bc8
movq 0xaf65(%rip), %rcx      # 0x14ae0
xorl %edx, %edx
testl %eax, %eax
cmovlel %edx, %eax
xorpd %xmm2, %xmm2
movsd %xmm2, 0xaf1a(%rip)     # 0x14aa8
cmpq %rdx, %rax
je 0x9bad
movsd (%rcx,%rdx,8), %xmm0
subsd %xmm2, %xmm0
incq %rdx
cvtsi2sd %edx, %xmm3
divsd %xmm3, %xmm0
addsd %xmm0, %xmm2
jmp 0x9b86
andq $0x0, 0xaebb(%rip)      # 0x14a70
andq $0x0, 0xae9b(%rip)      # 0x14a58
andq $0x0, 0xc00b(%rip)      # 0x15bd0
xorpd %xmm3, %xmm3
movq 0xaf18(%rip), %rdx      # 0x14ae8
xorl %esi, %esi
xorpd %xmm0, %xmm0
xorpd %xmm4, %xmm4
cmpq %rsi, %rax
je 0x9c30
movsd (%rdx,%rsi,8), %xmm5
subsd %xmm2, %xmm5
mulsd %xmm5, %xmm5
addsd %xmm5, %xmm4
movsd %xmm4, 0xae78(%rip)     # 0x14a70
movsd (%rcx,%rsi,8), %xmm5
subsd (%rdx,%rsi,8), %xmm5
mulsd %xmm5, %xmm5
addsd %xmm5, %xmm0
movsd %xmm0, 0xae46(%rip)     # 0x14a58
movsd (%rcx,%rsi,8), %xmm5
subsd %xmm2, %xmm5
mulsd %xmm5, %xmm5
addsd %xmm5, %xmm3
movsd %xmm3, 0xbfa5(%rip)     # 0x15bd0
incq %rsi
jmp 0x9bda
divsd %xmm1, %xmm0
movsd %xmm0, 0xae24(%rip)     # 0x14a60
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x9c4c
sqrtsd %xmm0, %xmm0
jmp 0x9c51
callq 0x2200
movsd %xmm0, 0xae0f(%rip)     # 0x14a68
movsd 0xae0f(%rip), %xmm0     # 0x14a70
movsd 0xbf57(%rip), %xmm1     # 0x15bc0
divsd %xmm1, %xmm0
movsd %xmm0, 0xae03(%rip)     # 0x14a78
divsd 0xade3(%rip), %xmm0     # 0x14a60
movsd %xmm0, 0xadfb(%rip)     # 0x14a80
movsd 0xadc3(%rip), %xmm2     # 0x14a50
callq 0x6cf2
movsd 0x162e(%rip), %xmm1     # 0xb2c8
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
movsd %xmm2, 0xadde(%rip)     # 0x14a88
movsd 0xada6(%rip), %xmm0     # 0x14a58
movsd 0xbf0e(%rip), %xmm2     # 0x15bc8
divsd 0xad8e(%rip), %xmm2     # 0x14a50
movsd 0xbf06(%rip), %xmm3     # 0x15bd0
mulsd %xmm0, %xmm2
divsd %xmm3, %xmm0
movapd %xmm1, %xmm4
subsd %xmm0, %xmm4
movsd %xmm4, 0xadb6(%rip)     # 0x14a98
divsd %xmm3, %xmm2
subsd %xmm2, %xmm1
movsd 0xad76(%rip), %xmm0     # 0x14a68
mulsd 0x160e(%rip), %xmm0     # 0xb308
movsd %xmm1, 0xad9e(%rip)     # 0x14aa0
divsd 0xad9e(%rip), %xmm0     # 0x14aa8
movsd %xmm0, 0xad9e(%rip)     # 0x14ab0
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movl 0xba08(%rip), %ecx      # 0x157d0
movl 0xac7a(%rip), %eax      # 0x14a48
subl %eax, %ecx
cvtsi2sd %ecx, %xmm0
movsd %xmm0, -0x10(%rbp)
xorl %ebx, %ebx
cltq
cmpq %rax, %rbx
jge 0x9e27
movq 0xbdc7(%rip), %rax      # 0x15bb0
movsd (%rax,%rbx,8), %xmm0
andpd 0x14aa(%rip), %xmm0     # 0xb2a0
movsd -0x10(%rbp), %xmm1
callq 0x763a
movsd 0x14c0(%rip), %xmm1     # 0xb2c8
subsd %xmm0, %xmm1
addsd %xmm1, %xmm1
movq 0xbda1(%rip), %rax      # 0x15bb8
movsd %xmm1, (%rax,%rbx,8)
incq %rbx
movl 0xac23(%rip), %eax      # 0x14a48
jmp 0x9ddb
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xbd09(%rip), %rdi      # 0x15be0
callq 0x2150
testl %eax, %eax
je 0x9ee7
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, 0xbdba(%rip)      # 0x15ca8
movq %rbx, 0x59a3(%rip)      # 0xf898
callq 0x2a45
callq 0x254c
movl 0x598f(%rip), %eax      # 0xf894
cmpl $0x135, %eax            # imm = 0x135
je 0x9f2c
cmpl $0x147, %eax            # imm = 0x147
je 0x9f25
cmpl $0x14a, %eax            # imm = 0x14A
je 0x9f33
testl %eax, %eax
je 0x9ee0
callq 0x29bd
jmp 0x9efa
callq 0x9e2e
jmp 0x9efa
callq 0x233c
jmp 0x9efa
callq 0x2a45
cmpl $0x3b, 0x5955(%rip)     # 0xf894
je 0x9ef5
leaq 0x158c(%rip), %rdi      # 0xb4d4
callq 0x267a
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0xbd4a(%rip), %rdi      # 0x15ca8
movl $0x2401, %ebx           # imm = 0x2401
movq 0x592e(%rip), %rax      # 0xf898
movzbl (%rdi), %r14d
testl %r14d, %r14d
je 0x9fbd
cmpq %rax, %rdi
je 0x9fbd
cmpl $0xa, %r14d
je 0x9f84
cmpl $0xd, %r14d
jne 0x9f89
incq %rdi
jmp 0x9f6a
movq %rdi, %r15
cmpq %rax, %r15
je 0x9fa9
cmpb $0xd, %r14b
ja 0x9fa0
movzbl %r14b, %ecx
btl %ecx, %ebx
jb 0x9fac
movb 0x1(%r15), %r14b
incq %r15
jmp 0x9f8c
movq %rax, %r15
movb $0x0, (%r15)
callq 0x2070
movb %r14b, (%r15)
movq %r15, %rdi
jmp 0x9f63
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/google[P]multichase/./permutation.h
// Function: rng_init
static inline void rng_init(unsigned thread_num) {
  rng_buf = (char *)calloc(1, RNG_BUF_SIZE);
  rand_state = (struct random_data *)calloc(1, sizeof(struct random_data));
  assert(rand_state);
  if (initstate_r(thread_num, rng_buf, RNG_BUF_SIZE, rand_state) != 0) {
    perror("initstate_r");
    exit(1);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
pushq $0x1
popq %r15
pushq $0x20
popq %rsi
movq %r15, %rdi
callq 0x4364f0
movq %rax, %r14
movq $-0x60, %rax
movq %r14, %fs:(%rax)
pushq $0x30
popq %rsi
movq %r15, %rdi
callq 0x4364f0
movq $-0x58, %rcx
movq %rax, %fs:(%rcx)
testq %rax, %rax
je 0x402ad5
pushq $0x20
popq %rdx
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rcx
callq 0x412280
testl %eax, %eax
jne 0x402af2
popq %rbx
popq %r14
popq %r15
retq
leaq 0xcf495(%rip), %rdi     # 0x4d1f71
leaq 0xcf499(%rip), %rsi     # 0x4d1f7c
leaq 0xcf4a2(%rip), %rcx     # 0x4d1f8c
pushq $0x5d
popq %rdx
callq 0x40b790
leaq 0xcf4af(%rip), %rdi     # 0x4d1fa8
callq 0x4130f0
pushq $0x1
popq %rdi
callq 0x411e30
// File: /workspace/github_c_makefile_star2_O2/google[P]multichase/multichase.c
// Function: chase_incr
static void chase_incr(per_thread_t *t) {
  struct incr_struct *p = t->x.cycle[0];

  do {
    x50(++p->incme; p = *(void **)p;)
  } while (__sync_add_and_fetch(&t->x.count, 50));

  // we never actually reach here, but the compiler doesn't know that
  t->x.cycle[0] = p;
}

// Assembly:
movq 0x8(%rdi), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
incl 0x8(%rax)
movq (%rax), %rax
lock
subl $-0x32, 0x4(%rdi)
jne 0x4032d5
movq %rax, 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/google[P]multichase/multichase.c
// Function: chase_branch
static void chase_branch(per_thread_t *t) {
  void *p = t->x.cycle[0];
  typedef void* (*fptr)(void);
  fptr fp = p;

  do {
    fp = (fptr)(fp)();
  } while (__sync_add_and_fetch(&t->x.count, t->x.branch_chunk_size));

  // we never actually reach here, but the compiler doesn't know that
  t->x.dummy = (uintptr_t)p;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
leaq 0x4(%rdi), %r15
movq %r14, %rax
callq *%rax
movl 0x94(%rbx), %ecx
lock
addl %ecx, (%r15)
jne 0x403424
movl %r14d, 0x60(%rbx)
popq %rbx
popq %r14
popq %r15
retq