LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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:
cmpl $0x0, 0xc08d(%rip)      # 0x143d0
jle 0x848b
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %r15d, %r15d
leaq 0x315f(%rip), %rbx      # 0xb4c3
movl 0xbec6(%rip), %ecx      # 0x14230
movl 0xd480(%rip), %eax      # 0x157f0
movl %eax, -0x30(%rbp)
movl 0xc787(%rip), %eax      # 0x14b00
movl %eax, -0x2c(%rbp)
testq %r15, %r15
movq %rcx, -0x38(%rbp)
je 0x83b8
testl %ecx, %ecx
jle 0x841f
movl -0x2c(%rbp), %eax
imull -0x30(%rbp), %eax
movslq %eax, %r14
movq -0x38(%rbp), %r12
movq %rbx, %rdi
callq 0x2220
movq 0xd43e(%rip), %rcx      # 0x157e8
movq %rax, (%rcx,%r14,8)
incq %r14
decq %r12
jne 0x839b
jmp 0x841f
testl %ecx, %ecx
jle 0x841f
movl -0x2c(%rbp), %eax
imull -0x30(%rbp), %eax
movslq %eax, %r13
shlq $0x3, %r13
movq -0x38(%rbp), %rax
leaq (,%rax,4), %r14
xorl %r12d, %r12d
leaq 0xbcc0(%rip), %rax      # 0x140a0
movslq (%r12,%rax), %rax
leaq 0xd495(%rip), %rcx      # 0x15880
movslq (%r12,%rcx), %rcx
movq 0xbae2(%rip), %rdx      # 0x13ed8
leaq (%rax,%rax,4), %rax
movq 0x30(%rdx,%rax,8), %rax
movq (%rax,%rcx,8), %rdi
callq 0x2220
movq 0xd3d9(%rip), %rcx      # 0x157e8
addq %r13, %rcx
movq %rax, (%rcx,%r12,2)
addq $0x4, %r12
cmpq %r12, %r14
jne 0x83d9
movslq -0x38(%rbp), %r12
leaq 0xbe16(%rip), %rax      # 0x14240
movslq (%rax,%r15,4), %r14
movq 0xbaa3(%rip), %rax      # 0x13ed8
leaq (%r14,%r14,4), %rcx
movq 0x20(%rax,%rcx,8), %rdi
callq 0x2220
movl -0x2c(%rbp), %ecx
imull -0x30(%rbp), %ecx
movslq %ecx, %rcx
shlq $0x3, %rcx
addq 0xd390(%rip), %rcx      # 0x157e8
movq %rax, (%rcx,%r12,8)
movl %r14d, %edi
callq 0x848c
incl 0xd386(%rip)            # 0x157f0
incq %r15
movslq 0xbf5c(%rip), %rax      # 0x143d0
cmpq %rax, %r15
jl 0x8364
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x88fe
cmpq $0x0, 0xb609(%rip)      # 0x13ed8
je 0x88dc
callq 0x895a
popq %rbp
jmp 0x89a2
callq 0xa7e0
leaq 0x2d64(%rip), %rdi      # 0xb64c
callq 0x4039
leaq 0xd2fc(%rip), %rdi      # 0x15bf0
movl $0x1, %esi
callq 0x21c0
// File: /workspace/github_c_makefile_star2_O3/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
callq 0x2b82
movl 0x6f97(%rip), %eax      # 0xf8a4
cmpl $0x3e9, %eax            # imm = 0x3E9
jne 0x891f
callq 0x259c
movl 0x6f85(%rip), %eax      # 0xf8a4
cmpl $0x135, %eax            # imm = 0x135
jne 0x892d
callq 0x4339
jmp 0x8902
cmpl $0x3b, %eax
jne 0x8938
popq %rbp
jmp 0x2b82
callq 0xa7e0
leaq 0x2b90(%rip), %rdi      # 0xb4d4
callq 0x4039
leaq 0xd2a0(%rip), %rdi      # 0x15bf0
movl $0x1, %esi
callq 0x21c0
// File: /workspace/github_c_makefile_star2_O3/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 0x259c
movl 0x6f3b(%rip), %eax      # 0xf8a4
cmpl $0x149, %eax            # imm = 0x149
jle 0x897e
cmpl $0x157, %eax            # imm = 0x157
jne 0x8992
callq 0x4624
jmp 0x895e
testl %eax, %eax
je 0x89a0
cmpl $0x135, %eax            # imm = 0x135
je 0x89a0
cmpl $0x147, %eax            # imm = 0x147
jne 0x8999
jmp 0x89a0
cmpl $0x14a, %eax            # imm = 0x14A
je 0x89a0
callq 0x2ac3
jmp 0x895e
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
xorl %eax, %eax
movl %eax, 0xcd71(%rip)      # 0x15a10
movl %eax, 0xcd6f(%rip)      # 0x15a14
callq 0x8d21
cmpq $0x0, 0xb226(%rip)      # 0x13ed8
je 0x8cff
callq 0x8d68
callq 0x8db0
callq 0x4a3d
leaq 0x2b4b(%rip), %rdi      # 0xb815
callq 0x4043
movl $0xa, %edi
callq 0x2050
callq 0x913c
callq 0x9458
leaq 0x2ceb(%rip), %rdi      # 0xb9d5
callq 0x4043
movl $0xa, %edi
callq 0x2050
popq %rbp
jmp 0x95fa
callq 0xa7e0
leaq 0x2941(%rip), %rdi      # 0xb64c
callq 0x4039
leaq 0xced9(%rip), %rdi      # 0x15bf0
movl $0x1, %esi
callq 0x21c0
// File: /workspace/github_c_makefile_star2_O3/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 0x259c
movl 0x6b2d(%rip), %eax      # 0xf8a4
cmpl $0x142, %eax            # imm = 0x142
jle 0x8d9c
cmpl $0x143, %eax            # imm = 0x143
jne 0x8d8c
callq 0x994f
jmp 0x8d6c
cmpl $0x14a, %eax            # imm = 0x14A
je 0x8dae
cmpl $0x147, %eax            # imm = 0x147
jne 0x8da7
jmp 0x8dae
testl %eax, %eax
je 0x8dae
cmpl $0x135, %eax            # imm = 0x135
je 0x8dae
callq 0x2ac3
jmp 0x8d6c
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x2410(%rip), %rax      # 0xb883
leaq -0xa0(%rbp), %rbx
movq %rax, (%rbx)
leaq 0x25ee(%rip), %rax      # 0xba72
movq %rax, 0x20(%rbx)
leaq 0x23ea(%rip), %rax      # 0xb879
movq %rax, 0x40(%rbx)
leaq 0x23d6(%rip), %rax      # 0xb870
movq %rax, 0x10(%rbx)
leaq 0x25dc(%rip), %rax      # 0xba81
movq %rax, 0x30(%rbx)
leaq 0x2013(%rip), %rax      # 0xb4c3
movq %rax, 0x50(%rbx)
movsd 0xb5bc(%rip), %xmm0     # 0x14a78
leaq 0x1ea3(%rip), %r15      # 0xb366
leaq -0x110(%rbp), %r14
movl $0x64, %esi
movq %r14, %rdi
movq %r15, %rdx
movb $0x1, %al
callq 0x20e0
movq %r14, %rdi
callq 0x2220
movq %rax, -0x38(%rbp)
movq %rax, 0x8(%rbx)
movsd 0xb5c4(%rip), %xmm0     # 0x14ab8
movl $0x64, %esi
movq %r14, %rdi
movq %r15, %rdx
movb $0x1, %al
callq 0x20e0
movq %r14, %rdi
callq 0x2220
movq %rax, -0x30(%rbp)
movq %rax, 0x28(%rbx)
movsd 0xb5a2(%rip), %xmm0     # 0x14ac0
movl $0x64, %esi
movq %r14, %rdi
movq %r15, %rdx
movb $0x1, %al
callq 0x20e0
movq %r14, %rdi
callq 0x2220
movq %rax, %r13
movq %rax, 0x48(%rbx)
movsd 0xb561(%rip), %xmm0     # 0x14aa8
leaq 0x1e12(%rip), %r12      # 0xb360
movl $0x64, %esi
movq %r14, %rdi
movq %r12, %rdx
movb $0x1, %al
callq 0x20e0
movq %r14, %rdi
callq 0x2220
movq %rax, %r15
movq %rax, 0x18(%rbx)
movsd 0xb539(%rip), %xmm0     # 0x14ab0
movl $0x64, %esi
movq %r14, %rdi
movq %r12, %rdx
movb $0x1, %al
callq 0x20e0
movq %r14, %rdi
callq 0x2220
movq %rax, %r12
movq %rax, 0x38(%rbx)
leaq 0x1f24(%rip), %rax      # 0xb4c3
movq %rax, 0x58(%rbx)
movl $0x10001, (%r14)        # imm = 0x10001
movq %rbx, %rdi
movl $0x3, %esi
movl $0x4, %edx
movq %r14, %rcx
callq 0x4789
movq -0x38(%rbp), %rdi
callq 0x2040
movq -0x30(%rbp), %rdi
callq 0x2040
movq %r13, %rdi
callq 0x2040
movq %r15, %rdi
callq 0x2040
movq %r12, %rdi
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2040
// File: /workspace/github_c_makefile_star2_O3/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
movslq 0xbc3e(%rip), %rax      # 0x157e0
testq %rax, %rax
jle 0x9d12
movslq 0xbe6e(%rip), %rdx      # 0x15a20
movq 0xa31f(%rip), %rcx      # 0x13ed8
leaq (%rdx,%rdx,4), %rdx
movq 0x40(%rcx,%rdx,8), %rdx
movq %rdx, -0x48(%rbp)
addq $0x20, %rcx
movq 0xaf1f(%rip), %rdx      # 0x14af0
movq %rdx, -0x40(%rbp)
movl 0xbe3d(%rip), %edx      # 0x15a18
movl %edx, -0x2c(%rbp)
movq 0xaf03(%rip), %rdx      # 0x14ae8
movq %rdx, -0x38(%rbp)
movl 0xaf10(%rip), %r9d      # 0x14b00
movl 0xbe19(%rip), %r10d     # 0x15a10
xorl %r11d, %r11d
leaq 0xab2f(%rip), %r15      # 0x14730
movsd 0x16bf(%rip), %xmm0     # 0xb2c8
xorl %ebx, %ebx
movq -0x48(%rbp), %rdx
movsd (%rdx,%r11,8), %xmm1
ucomisd %xmm1, %xmm1
jp 0x9d04
xorl %r12d, %r12d
movslq %ebx, %rdx
movq -0x40(%rbp), %rsi
movsd %xmm1, (%rsi,%rdx,8)
movl $0x0, %r13d
cmpl $0x0, -0x2c(%rbp)
jne 0x9c5b
movl %r9d, %edx
imull %ebx, %edx
movslq %edx, %rdx
movq -0x38(%rbp), %rsi
movabsq $0x3ff0000000000000, %rdi # imm = 0x3FF0000000000000
movq %rdi, (%rsi,%rdx,8)
movl $0x1, %r13d
testl %r10d, %r10d
jle 0x9cfa
movl %r9d, %edx
imull %ebx, %edx
movslq %edx, %r14
shlq $0x3, %r14
movq 0xae70(%rip), %r8       # 0x14ae8
addq %r14, %r8
xorl %r12d, %r12d
movslq (%r15,%r12,4), %rdx
leaq (%rdx,%rdx,4), %rdx
movq 0x20(%rcx,%rdx,8), %rsi
movsd (%rsi,%r11,8), %xmm1
ucomisd %xmm1, %xmm1
jp 0x9cfa
leaq (%rcx,%rdx,8), %rdx
cmpq $0x0, 0x10(%rdx)
je 0x9ce3
movslq 0xc(%rdx), %rdx
testq %rdx, %rdx
jle 0x9cdb
movq 0xae36(%rip), %rsi      # 0x14ae8
addq %r14, %rsi
movslq %r13d, %rdi
leaq (%rsi,%rdi,8), %rsi
xorl %edi, %edi
xorps %xmm2, %xmm2
cvtsi2sd %edi, %xmm2
cmpeqsd %xmm1, %xmm2
andpd %xmm0, %xmm2
movlpd %xmm2, (%rsi,%rdi,8)
incq %rdi
cmpq %rdi, %rdx
jne 0x9cbe
addl %r13d, %edx
movl %edx, %r13d
jmp 0x9cef
movslq %r13d, %rdx
incl %r13d
movsd %xmm1, (%r8,%rdx,8)
incq %r12
cmpq %r10, %r12
jne 0x9c7e
movl %r10d, %r12d
xorl %edx, %edx
cmpl %r10d, %r12d
sete %dl
addl %edx, %ebx
incq %r11
cmpq %rax, %r11
jne 0x9c0b
jmp 0x9d14
xorl %ebx, %ebx
movl %ebx, 0xbac6(%rip)      # 0x157e0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movslq 0xadd4(%rip), %rax      # 0x14b00
testq %rax, %rax
jle 0x9dee
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0xbe67(%rip), %rcx      # 0x15bb0
movl 0xba91(%rip), %edx      # 0x157e0
leaq (,%rax,8), %rsi
xorl %edi, %edi
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpl $0x0, (%rcx,%r8,4)
jne 0x9dd4
movl %eax, %r10d
imull %r9d, %r10d
movslq %r10d, %r10
shlq $0x3, %r10
addq 0xad65(%rip), %r10      # 0x14ae0
movq 0xad66(%rip), %r11      # 0x14ae8
xorl %ebx, %ebx
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpl $0x0, (%rcx,%r14,4)
jne 0x9dc5
xorpd %xmm0, %xmm0
testl %edx, %edx
jle 0x9db9
movq %rdx, %r12
movq %r11, %r13
movsd (%r13,%rdi), %xmm1
mulsd (%r13,%rbx), %xmm1
addsd %xmm1, %xmm0
addq %rsi, %r13
decq %r12
jne 0x9d9f
movslq %r15d, %r15
movsd %xmm0, (%r10,%r15,8)
incl %r15d
incq %r14
addq $0x8, %rbx
cmpq %rax, %r14
jne 0x9d8a
incl %r9d
incq %r8
addq $0x8, %rdi
cmpq %rax, %r8
jne 0x9d5f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa954(%rip), %rax      # 0x14b00
testq %rax, %rax
jle 0xa227
movq 0xb9f8(%rip), %rcx      # 0x15bb0
movl 0xb622(%rip), %edx      # 0x157e0
movq 0xa923(%rip), %rsi      # 0x14ae8
movq 0xa924(%rip), %rdi      # 0x14af0
movq 0xa90d(%rip), %r8       # 0x14ae0
leaq (,%rax,8), %r9
xorl %r10d, %r10d
xorl %r11d, %r11d
cmpl $0x0, (%rcx,%r10,4)
jne 0xa21b
xorpd %xmm0, %xmm0
testl %edx, %edx
jle 0xa20f
movq %rsi, %rbx
xorl %r14d, %r14d
movsd (%rbx), %xmm1
mulsd (%rdi,%r14,8), %xmm1
addsd %xmm1, %xmm0
incq %r14
addq %r9, %rbx
cmpq %r14, %rdx
jne 0xa1f6
movslq %r11d, %rbx
incl %r11d
movsd %xmm0, (%r8,%rbx,8)
incq %r10
addq $0x8, %rsi
cmpq %rax, %r10
jne 0xa1e1
movslq 0xa82a(%rip), %rcx      # 0x14a58
testq %rcx, %rcx
jle 0xa27f
movq 0xa89e(%rip), %rdx      # 0x14ad8
movq 0xa89f(%rip), %rsi      # 0x14ae0
movq 0xa888(%rip), %rdi      # 0x14ad0
shlq $0x3, %rax
xorl %r8d, %r8d
xorpd %xmm0, %xmm0
xorl %r9d, %r9d
movsd (%rdx,%r9,8), %xmm1
mulsd (%rsi,%r9,8), %xmm1
addsd %xmm1, %xmm0
incq %r9
cmpq %r9, %rcx
jne 0xa256
movsd %xmm0, (%rdi,%r8,8)
incq %r8
addq %rax, %rdx
cmpq %rcx, %r8
jne 0xa24f
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movslq 0xb555(%rip), %rax      # 0x157e0
testq %rax, %rax
jle 0xa31e
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
movl 0xa85d(%rip), %ecx      # 0x14b00
movq 0xb906(%rip), %rdx      # 0x15bb0
movq 0xa847(%rip), %rsi      # 0x14af8
leaq (,%rcx,8), %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
testl %ecx, %ecx
jle 0xa303
movq 0xa806(%rip), %r10      # 0x14ad0
movq 0xa817(%rip), %r11      # 0x14ae8
addq %r8, %r11
xorl %ebx, %ebx
xorpd %xmm0, %xmm0
xorl %r14d, %r14d
cmpl $0x0, (%rdx,%rbx,4)
jne 0xa2f9
movsd (%r11,%rbx,8), %xmm1
movslq %r14d, %r15
incl %r14d
mulsd (%r10,%r15,8), %xmm1
addsd %xmm1, %xmm0
incq %rbx
cmpq %rbx, %rcx
jne 0xa2dd
jmp 0xa307
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsi,%r9,8)
incq %r9
addq %rdi, %r8
cmpq %rax, %r9
jne 0xa2bf
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
movl 0xa462(%rip), %eax      # 0x14a58
testl %eax, %eax
jle 0xa662
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl 0xb1da(%rip), %ecx      # 0x157e0
subl %eax, %ecx
cvtsi2sd %ecx, %xmm0
movsd %xmm0, -0x10(%rbp)
xorl %ebx, %ebx
movq 0xb5a6(%rip), %rax      # 0x15bc0
movsd (%rax,%rbx,8), %xmm0
andpd 0xc79(%rip), %xmm0      # 0xb2a0
movsd -0x10(%rbp), %xmm1
callq 0x7c2b
movsd 0xc8f(%rip), %xmm1      # 0xb2c8
subsd %xmm0, %xmm1
addsd %xmm1, %xmm1
movq 0xb580(%rip), %rax      # 0x15bc8
movsd %xmm1, (%rax,%rbx,8)
incq %rbx
movslq 0xa401(%rip), %rax      # 0x14a58
cmpq %rax, %rbx
jl 0xa613
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
xorl %eax, %eax
movl %eax, 0x9a21(%rip)      # 0x14090
movl %eax, 0x9d5b(%rip)      # 0x143d0
movl %eax, 0xb125(%rip)      # 0x157a0
movl %eax, 0x9baf(%rip)      # 0x14230
movl $0x3, 0x9865(%rip)      # 0x13ef0
movabsq $0x3fa999999999999a, %rax # imm = 0x3FA999999999999A
movq %rax, 0x984c(%rip)      # 0x13ee8
movq 0x59ed(%rip), %rax      # 0x10090
movq %rax, 0x982e(%rip)      # 0x13ed8
callq 0x2b82
callq 0x259c
movl 0x51ea(%rip), %eax      # 0xf8a4
cmpl $0x145, %eax            # imm = 0x145
jg 0xa6d5
cmpl $0x12e, %eax            # imm = 0x12E
je 0xa6e9
cmpl $0x141, %eax            # imm = 0x141
jne 0xa6f5
popq %rbp
jmp 0x7d77
cmpl $0x146, %eax            # imm = 0x146
je 0xa6ef
cmpl $0x149, %eax            # imm = 0x149
jne 0xa6f5
popq %rbp
jmp 0x8c93
popq %rbp
jmp 0x4ac3
popq %rbp
jmp 0x88be
leaq 0x138e(%rip), %rdi      # 0xba8a
callq 0x25fb
// File: /workspace/github_c_makefile_star2_O3/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 0xb4df(%rip), %rdi      # 0x15bf0
callq 0x2150
testl %eax, %eax
je 0xa721
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, 0xb590(%rip)      # 0x15cb8
movq %rbx, 0x5179(%rip)      # 0xf8a8
callq 0x2b82
xorl %ebx, %ebx
callq 0x259c
movl 0x5163(%rip), %eax      # 0xf8a4
cmpl $0x146, %eax            # imm = 0x146
jle 0xa76b
cmpl $0x147, %eax            # imm = 0x147
je 0xa7a5
cmpl $0x14a, %eax            # imm = 0x14A
jne 0xa7b4
callq 0x2b82
cmpl $0x3b, 0x5142(%rip)     # 0xf8a4
jne 0xa7be
callq 0x2b82
jmp 0xa736
cmpl $0x135, %eax            # imm = 0x135
jne 0xa7ac
movl %ebx, 0x4cc8(%rip)      # 0xf440
movl $0x1, 0x4cc2(%rip)      # 0xf444
movl %ebx, 0x4cc0(%rip)      # 0xf448
movb $0x0, 0x4cc1(%rip)      # 0xf450
movl $0x2c2009, 0x50a7(%rip) # imm = 0x2C2009
callq 0x2384
callq 0x240c
jmp 0xa736
callq 0xa663
jmp 0xa736
testl %eax, %eax
je 0xa71a
callq 0x2ac3
jmp 0xa736
callq 0xa7e0
leaq 0xd0a(%rip), %rdi       # 0xb4d4
callq 0x4039
leaq 0xb41a(%rip), %rdi      # 0x15bf0
movl $0x1, %esi
callq 0x21c0
// File: /workspace/github_c_makefile_star2_O3/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 0xb4c7(%rip), %r15      # 0x15cb8
movq 0x50b0(%rip), %rax      # 0xf8a8
movb (%r15), %bl
testb %bl, %bl
sete %cl
cmpq %rax, %r15
sete %dl
orb %cl, %dl
je 0xa815
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x2401, %r14d          # imm = 0x2401
incq %r15
movq %r15, %rdi
cmpb $0xa, %bl
je 0xa82e
movzbl %bl, %ecx
cmpl $0xd, %ecx
jne 0xa842
movb (%rdi), %bl
testb %bl, %bl
je 0xa80a
leaq 0x1(%rdi), %rcx
cmpq %rax, %rdi
movq %rcx, %rdi
jne 0xa821
jmp 0xa80a
decq %rdi
movq %rdi, %r15
cmpq %rax, %rdi
je 0xa86a
cmpb $0xd, %bl
ja 0xa85b
movzbl %bl, %ecx
btl %ecx, %r14d
jb 0xa86a
movb 0x1(%r15), %bl
incq %r15
cmpq %rax, %r15
jne 0xa84d
movq %rax, %r15
movb $0x0, (%r15)
callq 0x2070
movb %bl, (%r15)
testb %bl, %bl
je 0xa80a
movq 0x5027(%rip), %rax      # 0xf8a8
cmpq %rax, %r15
jne 0xa81b
jmp 0xa80a
// File: /workspace/github_c_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x1, %edi
movl $0x20, %esi
callq 0x437310
movq %rax, %r14
movq $-0x60, %rax
movq %r14, %fs:(%rax)
movl $0x1, %edi
movl $0x30, %esi
callq 0x437310
movq $-0x58, %rcx
movq %rax, %fs:(%rcx)
testq %rax, %rax
je 0x402ee7
movl $0x20, %edx
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rcx
callq 0x4130a0
testl %eax, %eax
jne 0x402f06
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xd00b3(%rip), %rdi     # 0x4d2fa1
leaq 0xd00b7(%rip), %rsi     # 0x4d2fac
leaq 0xd00c0(%rip), %rcx     # 0x4d2fbc
movl $0x5d, %edx
callq 0x40c5b0
callq 0x401140
// File: /workspace/github_c_makefile_star2_O3/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 0x4040a7
movq %rax, 0x8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4041f6
movl %r14d, 0x60(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/google[P]multichase/permutation.c
// Function: gen_random_permutation
void gen_random_permutation(perm_t *perm, size_t nr, size_t base) {
  size_t i;

  for (i = 0; i < nr; ++i) {
    size_t t = rng_int(i);
    perm[i] = perm[t];
    perm[t] = base + i;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
je 0x4084d8
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
negq %r14
movl $0x1, %r13d
leaq 0xc(%rsp), %rbp
leaq 0x8(%rsp), %r12
movq %fs:-0x58, %rdi
leaq 0x14(%rsp), %rsi
callq 0x413340
testl %eax, %eax
jne 0x4084e7
movq %fs:-0x58, %rdi
leaq 0x10(%rsp), %rsi
callq 0x413340
testl %eax, %eax
jne 0x4084e7
movq %fs:-0x58, %rdi
movq %rbp, %rsi
callq 0x413340
testl %eax, %eax
jne 0x4084e7
movq %fs:-0x58, %rdi
movq %r12, %rsi
callq 0x413340
testl %eax, %eax
jne 0x4084e7
movzwl 0x14(%rsp), %eax
movl 0x10(%rsp), %ecx
shll $0x10, %ecx
orq %rax, %rcx
movl 0xc(%rsp), %eax
movzwl %ax, %edx
shlq $0x20, %rdx
orq %rcx, %rdx
movl 0x8(%rsp), %eax
shlq $0x30, %rax
orq %rdx, %rax
xorl %edx, %edx
divq %r13
movq (%r15,%rdx,8), %rax
movq %rax, -0x8(%r15,%r13,8)
movq %rbx, (%r15,%rdx,8)
incq %rbx
leaq (%r14,%r13), %rax
incq %rax
incq %r13
cmpq $0x1, %rax
jne 0x408427
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4011b9
// File: /workspace/github_c_makefile_star2_O3/google[P]multichase/permutation.c
// Function: is_a_permutation
int is_a_permutation(const perm_t *perm, size_t nr_elts) {
  uint8_t *vec;
  size_t vec_len = (nr_elts + 7) / 8;
  size_t i;

  vec = malloc(vec_len);
  memset(vec, 0, vec_len);

  for (i = 0; i < nr_elts; ++i) {
    size_t vec_elt = perm[i] / 8;
    size_t test_bit = 1u << (perm[i] % 8);
    if (vec[vec_elt] & test_bit) {
      free(vec);
      return 0;
    }
    vec[vec_elt] |= test_bit;
  }
  for (i = 0; i < nr_elts / 8; ++i) {
    if (vec[i] != 0xff) {
      free(vec);
      return 0;
    }
  }
  if (nr_elts % 8) {
    if (vec[vec_len - 1] != ((1u << (nr_elts % 8)) - 1)) {
      free(vec);
      return 0;
    }
  }
  free(vec);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x7(%rsi), %rbx
shrq $0x3, %rbx
movl $0x1, %edi
movq %rbx, %rsi
callq 0x437310
testq %r14, %r14
je 0x408634
xorl %edx, %edx
movq (%r15,%rdx,8), %r8
movq %r8, %rsi
movl %r8d, %ecx
andb $0x7, %cl
movl $0x1, %edi
shll %cl, %edi
shrq $0x3, %rsi
movzbl (%rax,%rsi), %ecx
andl $0x7, %r8d
btl %r8d, %ecx
jb 0x408628
orb %cl, %dil
movb %dil, (%rax,%rsi)
incq %rdx
cmpq %rdx, %r14
jne 0x4085ba
cmpq $0x8, %r14
jb 0x40860c
movq %r14, %rcx
shrq $0x3, %rcx
xorl %edx, %edx
cmpb $-0x1, (%rax,%rdx)
jne 0x408628
incq %rdx
cmpq %rdx, %rcx
jne 0x4085fe
andq $0x7, %r14
je 0x408634
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl %r14d, %ecx
shll %cl, %edx
movzbl -0x1(%rax,%rbx), %ecx
xorl %ecx, %edx
cmpl $-0x1, %edx
je 0x408634
movq %rax, %rdi
callq 0x436200
xorl %eax, %eax
jmp 0x408641
movq %rax, %rdi
callq 0x436200
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/google[P]multichase/permutation.c
// Function: generate_chase_mixer
void generate_chase_mixer(struct generate_chase_common_args *args,
                          size_t nr_mixers) {
  size_t nr_mixer_indices = args->nr_mixer_indices;
  void (*gen_permutation)(perm_t *, size_t, size_t) = args->gen_permutation;

  /* Set number of mixers rounded up to the power of two */
  if (nr_mixers > 1) {
    args->nr_mixers = 1 << (CHAR_BIT * sizeof(long) -
                            __builtin_clzl(nr_mixers - 1));
  } else {
    args->nr_mixers = 1;
  }

  if (args->nr_mixers < 64) {
    args->nr_mixers = 64;
  }

  if (verbosity > 1)
    printf("nr_mixers = %zu\n", args->nr_mixers);
  perm_t *t = malloc(nr_mixer_indices * sizeof(*t));
  if (t == NULL) {
    fprintf(stderr, "Could not allocate %lu bytes, check stride/memory size?\n",
            nr_mixer_indices * sizeof(*t));
    exit(1);
  }
  perm_t *r = malloc(nr_mixer_indices * args->nr_mixers * sizeof(*r));
  if (r == NULL) {
    fprintf(stderr, "Could not allocate %lu bytes, check stride/memory size?\n",
            nr_mixer_indices * args->nr_mixers * sizeof(*r));
    exit(1);
  }
  size_t i;
  size_t j;

  // we arrange r in a transposed manner so that all of the
  // data for a particular mixer_idx is packed together.
  for (i = 0; i < args->nr_mixers; ++i) {
    gen_permutation(t, nr_mixer_indices, 0);
    for (j = 0; j < nr_mixer_indices; ++j) {
      r[j * args->nr_mixers + i] = t[j];
    }
  }
  free(t);

  args->mixer = r;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movl $0x40, %esi
cmpq $0x2, %rax
jb 0x408684
decq %rax
bsrq %rax, %rcx
xorl $0x3f, %ecx
negb %cl
movl $0x1, %eax
shll %cl, %eax
cmpl $0x41, %eax
movl $0x40, %ecx
cmovael %eax, %ecx
movslq %ecx, %rsi
movq 0x28(%rbx), %rbp
movq 0x30(%rbx), %r14
movq %rsi, 0x20(%rbx)
movq $0x50b310, %rax         # imm = 0x50B310
cmpl $0x2, (%rax)
jl 0x4086aa
leaq 0xca9db(%rip), %rdi     # 0x4d307e
xorl %eax, %eax
callq 0x413ce0
leaq (,%r14,8), %r13
movq %r13, %rdi
callq 0x435ec0
testq %rax, %rax
je 0x408748
movq %rax, %r15
movq 0x20(%rbx), %r12
imulq %r12, %r13
movq %r13, %rdi
callq 0x435ec0
movq %rax, (%rsp)
testq %rax, %rax
je 0x408750
testq %r12, %r12
je 0x408729
xorl %r13d, %r13d
movq (%rsp), %r12
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq *%rbp
movq 0x20(%rbx), %rax
testq %r14, %r14
je 0x40871d
leaq (,%rax,8), %rcx
movq %r12, %rdx
xorl %esi, %esi
movq (%r15,%rsi,8), %rdi
movq %rdi, (%rdx)
incq %rsi
addq %rcx, %rdx
cmpq %rsi, %r14
jne 0x40870b
incq %r13
addq $0x8, %r12
cmpq %rax, %r13
jb 0x4086eb
movq %r15, %rdi
callq 0x436200
movq (%rsp), %rax
movq %rax, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
callq 0x4011f2
movq %r13, %rdi
callq 0x4011ce
// File: /workspace/github_c_makefile_star2_O3/google[P]multichase/arena.c
// Function: print_page_size
void print_page_size(size_t page_size, bool use_thp) {
  FILE *f;
  size_t read;
  /* Big enough to fit UINT64_MAX + '\n' + '\0'. */
  char buf[22];

  if (!use_thp) {
    printf("page_size = %zu bytes\n", page_size);
    return;
  }

  f = fopen("/sys/kernel/mm/transparent_hugepage/hpage_pmd_size", "r");
  if (!f) goto err;

  read = fread(buf, 1, sizeof(buf) - 1, f);
  if (!feof(f) || (ferror(f) && !feof(f))) goto err;

  if (fclose(f)) goto err;

  if (buf[read - 1] == '\n') --read;
  buf[read] = '\0';

  printf("page_size = %s bytes (THP)\n", buf);
  return;

err:
  perror(
      "page_size = <failed to read "
      "/sys/kernel/mm/transparent_hugepage/hpage_pmd_size>");
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
testl %esi, %esi
je 0x408e01
leaq 0xca4fd(%rip), %rdi     # 0x4d3273
leaq 0xca265(%rip), %rsi     # 0x4d2fe2
callq 0x422a90
testq %rax, %rax
je 0x408e1c
movq %rax, %rbx
movq %rsp, %rdi
movl $0x1, %esi
movl $0x15, %edx
movq %rax, %rcx
callq 0x422b90
movq %rax, %r14
movq %rbx, %rdi
callq 0x425250
testl %eax, %eax
je 0x408e1c
movq %rbx, %rdi
callq 0x425320
testl %eax, %eax
je 0x408dca
movq %rbx, %rdi
callq 0x425250
testl %eax, %eax
je 0x408e1c
movq %rbx, %rdi
callq 0x422360
testl %eax, %eax
jne 0x408e1c
cmpb $0xa, -0x1(%rsp,%r14)
leaq -0x1(%r14), %rax
cmovneq %r14, %rax
movb $0x0, (%rsp,%rax)
leaq 0xca4b7(%rip), %rdi     # 0x4d32a6
movq %rsp, %rsi
xorl %eax, %eax
callq 0x413ce0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rdi, %rax
leaq 0xca451(%rip), %rdi     # 0x4d325c
movq %rax, %rsi
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x413ce0
leaq 0xca49f(%rip), %rdi     # 0x4d32c2
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x413f10
// File: /workspace/github_c_makefile_star2_O3/google[P]multichase/arena.c
// Function: read_sysfs_state_file
static char *read_sysfs_state_file(char const *path) {
  FILE *f = fopen(path, "r");
  char *token = NULL;
  int ret;

  if (f == NULL) {
    perror("open sysfs state file");
    exit(1);
  }

  while ((ret = fscanf(f, "%ms", &token)) == 1) {
    if (token[0] == '[') break;

    free(token);
    token = NULL;
  }

  if (ferror(f) && !feof(f)) {
    perror("read sysfs state file");
    exit(1);
  }

  if (fclose(f)) {
    perror("close sysfs state file");
    exit(1);
  }

  return token;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0xc9dc8(%rip), %rsi     # 0x4d2fe2
callq 0x422a90
movq $0x0, 0x8(%rsp)
testq %rax, %rax
je 0x4092bb
movq %rax, %rbx
leaq 0xca1eb(%rip), %rsi     # 0x4d3426
leaq 0x8(%rsp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x413fd0
cmpl $0x1, %eax
jne 0x409288
leaq 0xca1d0(%rip), %r14     # 0x4d3426
leaq 0x8(%rsp), %r15
movq 0x8(%rsp), %rdi
cmpb $0x5b, (%rdi)
je 0x409288
callq 0x436200
movq $0x0, 0x8(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x413fd0
cmpl $0x1, %eax
je 0x40925b
movq %rbx, %rdi
callq 0x425320
testl %eax, %eax
je 0x4092a0
movq %rbx, %rdi
callq 0x425250
testl %eax, %eax
je 0x4092c5
movq %rbx, %rdi
callq 0x422360
testl %eax, %eax
jne 0x4092c0
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x401398
callq 0x401383
callq 0x40136e
// File: /workspace/github_c_makefile_star2_O3/google[P]multichase/arena.c
// Function: write_sysfs_file
static void write_sysfs_file(char const *path, char const *value) {
  FILE *f = fopen(path, "w");

  if (f == NULL) {
    perror("open sysfs file for write");
    exit(1);
  }

  if (fprintf(f, "%s\n", value) < 0) {
    perror("write value to sysfs file");
    exit(1);
  }

  if (fclose(f)) {
    perror("close sysfs file");
    exit(1);
  }
}

// Assembly:
pushq %rbx
leaq 0xca185(%rip), %rsi     # 0x4d3457
callq 0x422a90
testq %rax, %rax
je 0x409309
movq %rax, %rbx
leaq 0xc8ee4(%rip), %rsi     # 0x4d21ca
leaq 0xca02a(%rip), %rdx     # 0x4d3317
movq %rax, %rdi
xorl %eax, %eax
callq 0x413c20
testl %eax, %eax
js 0x40930e
movq %rbx, %rdi
callq 0x422360
testl %eax, %eax
jne 0x409313
popq %rbx
retq
callq 0x4013d7
callq 0x4013c2
callq 0x4013ad
// File: /workspace/github_c_makefile_star2_O3/google[P]multichase/br_asm.c
// Function: convert_pointers_to_branches
int convert_pointers_to_branches(void *head, int chunk_size) {
  int remain = cycle_len(head);
  chunk_size = (remain < chunk_size)
                   ? remain
                   : remain / (1 << lround(log2(1.0 * remain / chunk_size)));
  int base_chunk_size = chunk_size;
  int chunks_remaining = remain / chunk_size;
  int chunk_count = 0;
  const int br_code_len = 12;  // len(mov_imm64) + max(len(jmp), len(ret))
  char *p = (char *)head;
  do {
    if (!chunk_count) chunk_count = remain / chunks_remaining;
    char *next = *((char **)p);
    for (int i = 8; i < br_code_len; i++) {
      if (p[i]) {
        fprintf(stderr, "not enough space to convert a pointer to branches\n");
        exit(1);
      }
    }
    p = x64_emit_mov_imm64_rax(p, (intptr_t)next);
    // At end of branch chunk, return with a pointer to the next chunk.
    --remain;
    if (--chunk_count == 0) {
      p = x64_emit_ret(p);
      --chunks_remaining;
    } else {
      p = x64_emit_jmp_to_rax(p);
    }
    p = next;
  } while (p != head);
  return base_chunk_size;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ebp, %ebp
movq %rdi, %rax
incl %ebp
movq (%rax), %rax
cmpq %rbx, %rax
jne 0x409323
movl %ebp, %r8d
cmpl %esi, %ebp
jl 0x409352
cvtsi2sd %ebp, %xmm0
cvtsi2sd %esi, %xmm1
divsd %xmm1, %xmm0
callq 0x409460
callq 0x409760
movl %ebp, %r8d
movl %eax, %ecx
shrl %cl, %r8d
movl %ebp, %eax
cltd
idivl %r8d
movl %eax, %edi
xorl %eax, %eax
movq %rbx, %rsi
testl %eax, %eax
jne 0x409368
movl %ebp, %eax
cltd
idivl %edi
movq (%rsi), %rdx
movl $0x8, %ecx
cmpb $0x0, (%rsi,%rcx)
jne 0x4093c6
incq %rcx
cmpq $0xc, %rcx
jne 0x409370
movw $0xb848, (%rsi)         # imm = 0xB848
addq $0x2, %rsi
xorl %ecx, %ecx
movq %rdx, %r9
shrq %cl, %r9
movb %r9b, (%rsi)
incq %rsi
addq $0x8, %rcx
cmpq $0x40, %rcx
jne 0x40938a
decl %eax
je 0x4093ac
movb $-0x20, 0x1(%rsi)
movb $-0x1, %cl
jmp 0x4093b0
decl %edi
movb $-0x3d, %cl
decl %ebp
movb %cl, (%rsi)
movq %rdx, %rsi
cmpq %rbx, %rdx
jne 0x40935f
movl %r8d, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x4013ec
nop
// File: /workspace/github_c_makefile_star2_O3/google[P]multichase/util.c
// Function: parse_mem_arg
int parse_mem_arg(const char *str, size_t *result) {
  size_t r;
  char *p;

  r = strtoull(str, &p, 0);
  switch (*p) {
    case 'k':
    case 'K':
      r *= 1024;
      ++p;
      break;
    case 'm':
    case 'M':
      r *= 1024 * 1024;
      ++p;
      break;
    case 'g':
    case 'G':
      r *= 1024 * 1024 * 1024;
      ++p;
      break;
  }
  if (*p) {
    return -1;
  }
  *result = r;
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsp, %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0x413400
movq (%r14), %rdx
movzbl (%rdx), %esi
movl %esi, %edi
addl $-0x47, %edi
cmpl $0x26, %edi
ja 0x409438
movabsq $0x100000001, %rcx      # imm = 0x100000001
btq %rdi, %rcx
jb 0x40942c
movl $0xa, %ecx
movabsq $0x1000000010, %r8      # imm = 0x1000000010
btq %rdi, %r8
jb 0x409431
movabsq $0x4000000040, %rcx     # imm = 0x4000000040
btq %rdi, %rcx
jae 0x409438
movl $0x14, %ecx
jmp 0x409431
movl $0x1e, %ecx
shlq %cl, %rax
movb 0x1(%rdx), %sil
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb %sil, %sil
jne 0x409447
movq %rax, (%rbx)
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/hs1sivv2/ref/encrypt.c
// Function: hs1siv_subkeygen
void hs1siv_subkeygen(hs1siv_ctx_t *ctx, void *user_key, unsigned key_bytes)
{
    unsigned char chacha_key[32];
    unsigned char iv[12];
    unsigned i=0;

    /* Copy user_key as many times as needed to fill 32 byte chacha key */
    while (i < 32) {
        unsigned nbytes = 32-i;
        if (nbytes > key_bytes) nbytes = key_bytes;
        memcpy(chacha_key+i,user_key,nbytes);
        i += nbytes;
    }

    /* Build key-derivation nonce and fill context */
    memset(iv,0,12);
    iv[0] = key_bytes;
    iv[2] = HS1_SIV_SIV_LEN;
    iv[4] = HS1_SIV_CHACHA_RNDS;
    iv[5] = HS1_SIV_HASH_RNDS;
    iv[6] = HS1_SIV_NH_LEN;
    hs1siv_chacha256(ctx, sizeof(hs1siv_ctx_t), iv, chacha_key);

    /* Pre-process internal keys: make future reads little-endian, mod poly */
    for (i=0; i<sizeof(ctx->nh_key)/4; i++)
        ((uint32_t *)ctx->nh_key)[i] = read32le(((uint32_t *)ctx->nh_key)+i);
    for (i=0; i<sizeof(ctx->poly_key)/8; i++)
        ((uint64_t *)ctx->poly_key)[i] = read64le(((uint64_t *)ctx->poly_key)+i)
                                       & m60;
    #if (HS1_SIV_HASH_RNDS > 4)
    for (i=0; i<sizeof(ctx->asu_key)/8; i++)
        ((uint64_t *)ctx->asu_key)[i] = read64le(((uint64_t *)ctx->asu_key)+i);
    #endif
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
xorl %r12d, %r12d
movl $0x20, %r15d
subl %r12d, %r15d
cmpl %ebp, %r15d
cmovael %ebp, %r15d
movl %r12d, %eax
leaq (%rsp,%rax), %rdi
addq $0x10, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1100
addl %r12d, %r15d
movl %r15d, %r12d
cmpl $0x20, %r15d
jb 0x1815
leaq 0x4(%rsp), %rdx
movq $0x0, 0x1(%rdx)
movl $0x0, 0x8(%rdx)
movb %bpl, (%rdx)
movb $0x10, 0x2(%rdx)
movw $0x40c, 0x4(%rdx)       # imm = 0x40C
movb $0x40, 0x6(%rdx)
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
movl $0xb0, %esi
callq 0x1090
vmovupd 0x90(%rbx), %ymm0
vandpd 0x780(%rip){1to4}, %ymm0, %ymm0 # 0x2010
vmovupd %ymm0, 0x90(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/hs1sivv2/ref/encrypt.c
// Function: hs1siv_encrypt
void hs1siv_encrypt(hs1siv_ctx_t *ctx, void *m, unsigned mbytes,
                    void *a, unsigned abytes, void *n, void *t, void *c)
{
    unsigned i;
    unsigned abuflen = (abytes+HS1_SIV_NH_LEN-1)/HS1_SIV_NH_LEN*HS1_SIV_NH_LEN;
    unsigned buflen = abuflen + (mbytes+15)/16*16 + 16;
    unsigned char tmp_t[HS1_SIV_SIV_LEN];
    unsigned char *buf = (unsigned char *)malloc(buflen);
    memset(buf, 0, buflen);
    memcpy(buf, a, abytes);
    memcpy(buf+abuflen, m, mbytes);
    write32le((uint32_t *)(buf+buflen-16), abytes);
    write32le((uint32_t *)(buf+buflen-8), mbytes);
    hs1(ctx, buf, buflen, n, tmp_t, HS1_SIV_SIV_LEN);
    free(buf);
    buf = (unsigned char *)malloc(mbytes+64);
    hs1(ctx, tmp_t, HS1_SIV_SIV_LEN, n, buf, mbytes+64);
    for (i=0; i<mbytes; i++)
        buf[64+i] ^= ((unsigned char *)m)[i];
    memcpy(c,buf+64,mbytes);
    memcpy(t,tmp_t,HS1_SIV_SIV_LEN);
    free(buf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, 0x18(%rsp)
movl %r8d, %ebx
movq %rcx, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x28(%rsp)
leal 0x3f(%rbx), %r13d
andl $-0x40, %r13d
leal 0xf(%rdx), %eax
movq %rdx, %r15
andl $-0x10, %eax
leal (%rax,%r13), %r12d
addl $0x10, %r12d
movl $0x1, %edi
movq %r12, %rsi
callq 0x10d0
movq %rax, %rbp
movl %ebx, %edx
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x1100
addq %rbp, %r13
movl %r15d, %edx
movq %rdx, 0x8(%rsp)
movq %r13, %rdi
movq %r14, %rsi
callq 0x1100
movl %ebx, -0x10(%rbp,%r12)
movl %r15d, -0x8(%rbp,%r12)
movq %r15, %rbx
leaq 0x30(%rsp), %r8
movq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbp, %rsi
movl %r12d, %edx
movq 0x18(%rsp), %r13
movq %r13, %rcx
movl $0x10, %r9d
callq 0x10f0
movq %rbp, %rdi
callq 0x1070
movq %rbx, %rbp
leal 0x40(%rbx), %r12d
movq %r12, %rdi
callq 0x1050
movq %rax, %rbx
movq %r15, %rdi
leaq 0x30(%rsp), %rsi
movl $0x10, %edx
movq %r13, %rcx
movq %rax, %r8
movl %r12d, %r9d
callq 0x10f0
movq 0x8(%rsp), %rdx
testl %ebp, %ebp
je 0x1a71
movq %rdx, %rax
negq %rax
movl $0x40, %ecx
movb -0x40(%r14,%rcx), %dil
movl %ecx, %esi
xorb %dil, (%rbx,%rsi)
leaq (%rax,%rcx), %rsi
incq %rsi
incq %rcx
cmpq $0x40, %rsi
jne 0x1a56
movq %rbx, %rsi
addq $0x40, %rsi
movq 0x20(%rsp), %rdi
callq 0x1100
vmovaps 0x30(%rsp), %xmm0
movq 0x28(%rsp), %rax
vmovups %xmm0, (%rax)
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/hs1sivv2/ref/encrypt.c
// Function: hs1siv_decrypt
int hs1siv_decrypt(hs1siv_ctx_t *ctx, void *c, unsigned cbytes,
                   void *a, unsigned abytes, void *n, void *t, void *m)
{
    unsigned i;
    unsigned abuflen = (abytes+HS1_SIV_NH_LEN-1)/HS1_SIV_NH_LEN*HS1_SIV_NH_LEN;
    unsigned buflen = abuflen + (cbytes+15)/16*16 + 16;
    unsigned char *maybe_m = (unsigned char *)malloc(cbytes);
    unsigned char maybe_t[HS1_SIV_SIV_LEN];
    unsigned char *buf = (unsigned char *)malloc(cbytes+64);
    hs1(ctx, t, HS1_SIV_SIV_LEN, n, buf, cbytes+64);
    for (i=0; i<cbytes; i++)
        ((unsigned char *)maybe_m)[i] = ((unsigned char *)c)[i] ^ buf[64+i];
    free(buf);
    buf = (unsigned char *)malloc(buflen);
    memset(buf, 0, buflen);
    memcpy(buf, a, abytes);
    memcpy(buf+abuflen, maybe_m, cbytes);
    write32le((uint32_t *)(buf+buflen-16), abytes);
    write32le((uint32_t *)(buf+buflen-8), cbytes);
    hs1(ctx, buf, buflen, n, maybe_t, HS1_SIV_SIV_LEN);
    free(buf);
    if (memcmp(t,maybe_t,HS1_SIV_SIV_LEN) == 0) {
        memcpy(m,maybe_m,cbytes);
        free(maybe_m);
        return 0;
    } else {
        free(maybe_m);
        return -1;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, 0x18(%rsp)
movq %rcx, 0x28(%rsp)
movl %edx, %r15d
movq %rsi, %r13
movq %rdi, %rbp
movq %r8, 0x30(%rsp)
leal 0x3f(%r8), %ecx
andl $-0x40, %ecx
leal 0xf(%r15), %eax
andl $-0x10, %eax
movq %rcx, 0x20(%rsp)
addl %ecx, %eax
addl $0x10, %eax
movl %eax, 0x14(%rsp)
movl %edx, %edi
movq %rdi, 0x8(%rsp)
callq 0x1050
movq %rax, %rbx
leal 0x40(%r15), %r14d
movq %r14, %rdi
callq 0x1050
movq %rax, %r12
movq %rbp, 0x38(%rsp)
movq %rbp, %rdi
movq 0x90(%rsp), %rsi
movl $0x10, %edx
movq 0x18(%rsp), %rcx
movq %rax, %r8
movl %r14d, %r9d
callq 0x10f0
testl %r15d, %r15d
je 0x1b5d
movq 0x8(%rsp), %rax
negq %rax
movl $0x40, %ecx
movl %ecx, %edx
movb (%r12,%rdx), %dl
xorb -0x40(%r13,%rcx), %dl
movb %dl, -0x40(%rbx,%rcx)
leaq (%rax,%rcx), %rdx
incq %rdx
incq %rcx
cmpq $0x40, %rdx
jne 0x1b3e
movq %r12, %rdi
callq 0x1070
movl 0x14(%rsp), %r13d
movl %r13d, %r14d
movl $0x1, %edi
movq %r14, %rsi
callq 0x10d0
movq %rax, %r12
movq 0x30(%rsp), %rbp
movl %ebp, %edx
movq %rax, %rdi
movq 0x28(%rsp), %rsi
callq 0x1100
movl 0x20(%rsp), %edi
addq %r12, %rdi
movq %rbx, %rsi
movq 0x8(%rsp), %rdx
callq 0x1100
movl %ebp, -0x10(%r12,%r14)
movl %r15d, -0x8(%r12,%r14)
leaq 0x40(%rsp), %r14
movq 0x38(%rsp), %rdi
movq %r12, %rsi
movl %r13d, %edx
movq 0x18(%rsp), %rcx
movq %r14, %r8
movl $0x10, %r9d
callq 0x10f0
movq %r12, %rdi
callq 0x1070
movq 0x90(%rsp), %rax
vmovdqu (%rax), %xmm0
vpxor (%r14), %xmm0, %xmm0
vptest %xmm0, %xmm0
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jne 0x1c0e
movq 0x98(%rsp), %rdi
movq %rbx, %rsi
movq 0x8(%rsp), %rdx
callq 0x1100
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x1070
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mjosaarinen[P]brutus/crypto_aead/hs1sivv2/ref/encrypt.c
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(
    unsigned char *m,unsigned long long *mlen,
    unsigned char *nsec,
    const unsigned char *c,unsigned long long clen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *npub,
    const unsigned char *k
)
{
    hs1siv_ctx_t ctx;
    (void)nsec;
    if (mlen) *mlen = clen-CRYPTO_ABYTES;
    hs1siv_subkeygen(&ctx, (void *)k, CRYPTO_KEYBYTES);
    return hs1siv_decrypt(&ctx, (void *)c, clen-CRYPTO_ABYTES,
    	(void *)ad, adlen, (void *)npub, (void *)(c+clen-CRYPTO_ABYTES), m);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r9, %rbx
movq %r8, %rbp
movq %rcx, %r15
movq %rsi, %rax
movq %rdi, %r14
movq 0x100(%rsp), %rsi
movq 0xf0(%rsp), %r13
testq %rax, %rax
je 0x1ce6
leaq -0x10(%rbp), %rcx
movq %rcx, (%rax)
movq %rsp, %r12
movq %r12, %rdi
movl $0x10, %edx
callq 0x10b0
leal -0x10(%rbp), %edx
leaq (%r15,%rbp), %rax
addq $-0x10, %rax
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rcx
movl %r13d, %r8d
movq 0xf8(%rsp), %r9
pushq %r14
pushq %rax
callq 0x1040
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop