LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: CominLab[P]QCluster/dists.cc
// Function: symkl_distance(double*, double*, int, double*, double*, double*, double*)
double symkl_distance(double *centroid, double *p, int L, double* centroid_tilde, 
					  double *quality, double *expected_qual, double *expected_freq)
{
	double total_count = 0;
	for(int i=0; i<L; ++i){
		total_count += quality[i];
	}
	double S = 0;
	for(int i=0; i<L; i++){
		S += (quality[i]-total_count*centroid[i]) * log(quality[i]/(total_count*centroid[i]));
	}
	return S;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x70fc
movq -0x28(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x70d2
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x71aa
movq -0x28(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movsd -0x38(%rbp), %xmm0
movq -0x8(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
movq -0x28(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd -0x38(%rbp), %xmm1
movq -0x8(%rbp), %rax
movslq -0x4c(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm1
divsd %xmm1, %xmm0
callq 0x31f0
movaps %xmm0, %xmm2
movsd -0x58(%rbp), %xmm0
movsd -0x48(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x710b
movsd -0x48(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CominLab[P]QCluster/dists.cc
// Function: d2_distance(double*, double*, int, double*, double*, double*, double*)
double d2_distance(double *centroid, double *p, int L, double* centroid_tilde, 
				   double *quality, double *expected_qual, double *expected_freq)
{
	double norm = 0;
	double S = 0;
	for(int i=0; i<L; i++){
		norm += quality[i] * quality[i];
	}
	norm = sqrt(norm);
	for(int i=0; i<L; i++){
		S += centroid[i] * quality[i] / norm;
	}
	return 1 - S;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x7239
movq -0x28(%rbp), %rax
movslq -0x44(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movslq -0x44(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x38(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x71fa
movsd -0x38(%rbp), %xmm0
callq 0x31d0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x728b
movq -0x8(%rbp), %rax
movslq -0x48(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movslq -0x48(%rbp), %rcx
mulsd (%rax,%rcx,8), %xmm0
divsd -0x38(%rbp), %xmm0
addsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x724f
movsd 0x3d75(%rip), %xmm0     # 0xb008
subsd -0x40(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: CominLab[P]QCluster/dists.cc
// Function: chi2_distance(double*, double*, int, double*, double*, double*, double*)
double chi2_distance(double *centroid, double *p, int L, double* centroid_tilde, 
					 double *quality, double *expected_qual, double *expected_freq)
{
	double chi2 = 0;
	double total_count = 0;
	for(int i=0; i<L; i++){
		total_count += quality[i];
	}
	for(int i=0; i<L; i++){
		double exp_count = centroid[i] * total_count;
		chi2 += (quality[i] - exp_count) * (quality[i] - exp_count) / exp_count;
	}
	//return (chi2 - (L-3) * log(chi2))/2;
	return chi2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x40(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x7300
movq -0x28(%rbp), %rax
movslq -0x44(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x72d6
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x7368
movq -0x8(%rbp), %rax
movslq -0x48(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
mulsd -0x40(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x28(%rbp), %rax
movslq -0x48(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd -0x50(%rbp), %xmm0
movq -0x28(%rbp), %rax
movslq -0x48(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
subsd -0x50(%rbp), %xmm1
mulsd %xmm1, %xmm0
divsd -0x50(%rbp), %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x7307
movsd -0x38(%rbp), %xmm0
popq %rbp
retq
nop
// File: CominLab[P]QCluster/centroid.cc
// Function: mean_centroid(int, int, double**, int, double**, double*, double*, double**, double*, double**, double*)
void mean_centroid(int N, int row_length, double** freq, int num_nt,
double** freq_1, double* centroid, double* centroid_tilde, 
double **quality, double *expected_qual, double **quality_1,
double *expected_freq)
{
	memset(centroid, 0, row_length * sizeof(*centroid));
	for(int n=0; n<N; n++){
		for(int l=0; l<row_length; l++){
			centroid[l] += quality[n][l];
		}
	}

	for(int l=0; l<row_length; l++){
		centroid[l] /= N;
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x8(%rbp), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x3150
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x7651
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x7644
movq 0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x760a
jmp 0x7646
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x75fb
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x7686
cvtsi2sdl -0x4(%rbp), %xmm1
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x7658
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: CominLab[P]QCluster/centroid.cc
// Function: d2_centroid(int, int, double**, int, double**, double*, double*, double**, double*, double**, double*)
void d2_centroid(int N, int row_length, double** freq, int num_nt,
double** freq_1, double* centroid, double* centroid_tilde, 
double **quality, double *expected_qual, double **quality_1,
double *expected_freq)
{
	// add the total counts
	memset(centroid, 0, row_length * sizeof(*centroid));
	for(int n=0; n<N; ++n){
		for(int l=0; l<row_length; ++l){
			centroid[l] += quality[n][l];
		}
	}
	// now normalize the entries
	double total_sq_count = 0;
	for(int l=0; l<row_length; ++l){
		total_sq_count += centroid[l] * centroid[l];
	}
	double norm = sqrt(total_sq_count);
	for(int l=0; l<row_length; ++l){
		centroid[l] /= norm;
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x8(%rbp), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x3150
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x7731
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x7724
movq 0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x76ea
jmp 0x7726
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x76db
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x777f
movq -0x28(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd -0x38(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x7740
movsd -0x38(%rbp), %xmm0
callq 0x31d0
movsd %xmm0, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x77c3
movsd -0x48(%rbp), %xmm1
movq -0x28(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x7795
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: CominLab[P]QCluster/centroid.cc
// Function: kl_centroid(int, int, double**, int, double**, double*, double*, double**, double*, double**, double*)
void kl_centroid(int N, int row_length, double** freq, int num_nt,
double** freq_1, double* centroid, double* centroid_tilde, 
double **quality, double *expected_qual, double **quality_1,
double *expected_freq)
{
	// add the total counts
	memset(centroid, 0, row_length * sizeof(*centroid));
	for(int n=0; n<N; ++n){
		for(int l=0; l<row_length; ++l){
			centroid[l] += quality[n][l];
		}
	}
	// now normalize the entries
	double total_count = 0;
	for(int l=0; l<row_length; ++l){
		total_count += centroid[l];
	}
	for(int l=0; l<row_length; ++l){
		centroid[l] /= total_count;
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x8(%rbp), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x3150
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x7871
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x7864
movq 0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x28(%rbp), %rax
movslq -0x30(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x782a
jmp 0x7866
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x781b
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x78aa
movq -0x28(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x7880
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x78df
movsd -0x38(%rbp), %xmm1
movq -0x28(%rbp), %rax
movslq -0x40(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x78b1
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CominLab[P]QCluster/freqs.cc
// Function: normalize_row(double*, int)
void normalize_row(double* fv, int L)
{
	double total = 0;
	for (int l=0; l<L; l++){
		total += fv[l];	// ||fv||1
	}
	for (int l=0; l<L; l++){
		fv[l] /= total;
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x7d64
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x7d3a
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x7d99
movsd -0x18(%rbp), %xmm1
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x7d6b
popq %rbp
retq
nopl (%rax,%rax)
// File: CominLab[P]QCluster/freqs.cc
// Function: normalize_row_against(double*, double*, int)
void normalize_row_against(double* freq, double* qual, int L)
{
	double total = 0;
	for (int l=0; l<L; l++){
		total += freq[l]; // ||freq||1
	}
	for (int l=0; l<L; l++){
		qual[l] /= total;
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x7de8
movq -0x8(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7dbe
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x7e1d
movsd -0x20(%rbp), %xmm1
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x7def
popq %rbp
retq
nop
// File: CominLab[P]QCluster/freqs.cc
// Function: normalize_row_projection(double*, double*, int)
void normalize_row_projection(double* freq, double* qual, int L)
{
	double total = 0, total_qual = 0;
	for (int l=0; l<L; l++){
		total += freq[l];
		total_qual += qual[l];
	}
	double parziale = (total - total_qual) / L;
	for (int l=0; l<L; l++){
		qual[l] += parziale;
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x7e87
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x7e46
movsd -0x20(%rbp), %xmm0
subsd -0x28(%rbp), %xmm0
cvtsi2sdl -0x14(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x7ed0
movsd -0x38(%rbp), %xmm0
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x7ea6
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CominLab[P]QCluster/freqs.cc
// Function: is_valid_nt(char)
static bool is_valid_nt(char c)
{
	c = toupper(c);
	if (c == 'A') {
		return true;
	} 
	if (c == 'C') {
		return true;
	} 
	if (c == 'G') {
		return true;
	} 
	if (c == 'T') {
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x2(%rbp)
movsbl -0x2(%rbp), %edi
callq 0x3470
movb %al, -0x2(%rbp)
movsbl -0x2(%rbp), %eax
cmpl $0x41, %eax
jne 0x86c9
movb $0x1, -0x1(%rbp)
jmp 0x86fa
movsbl -0x2(%rbp), %eax
cmpl $0x43, %eax
jne 0x86d8
movb $0x1, -0x1(%rbp)
jmp 0x86fa
movsbl -0x2(%rbp), %eax
cmpl $0x47, %eax
jne 0x86e7
movb $0x1, -0x1(%rbp)
jmp 0x86fa
movsbl -0x2(%rbp), %eax
cmpl $0x54, %eax
jne 0x86f6
movb $0x1, -0x1(%rbp)
jmp 0x86fa
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CominLab[P]QCluster/freqs.cc
// Function: nt2int(char)
static int nt2int(char c)
{
	switch (c) {
		case 'A':
		case 'a': 
			return 0;
		case 'C':
		case 'c': 
			return 1;
		case 'G':
		case 'g': 
			return 2;
		case 'T':
		case 't': 
			return 3;
	}
	// should never get here
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
addl $-0x41, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rbp)
subl $0x33, %eax
ja 0x8764
movq -0x10(%rbp), %rax
leaq 0x35c1(%rip), %rcx      # 0xbcf8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x876b
movl $0x1, -0x4(%rbp)
jmp 0x876b
movl $0x2, -0x4(%rbp)
jmp 0x876b
movl $0x3, -0x4(%rbp)
jmp 0x876b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: CominLab[P]QCluster/freqs.cc
// Function: expected_frequency_p2global(int, int, int, double*, double**)
void expected_frequency_p2global(int N, int K, int L, double *expected_freq,
								double **freq_1)
{
	double nt_freq[NUM_NT];
	memset(nt_freq, 0, NUM_NT * sizeof(nt_freq[0]));
	double S=0;
	// compute frequencies of individual nucleotides
	for (int n=0; n<N; n++){
		for (int l=0; l<NUM_NT; l++){
			nt_freq[l] += freq_1[n][l]; //= count of letter l on the dataset
		}
	}
	for (int l=0; l<NUM_NT; l++)
		S += nt_freq[l];	//S = total number of letters in the dataset

	for (int l=0; l<NUM_NT; l++){
		nt_freq[l] /= S;	//Average frequency of each letter in the dataset
	}
	// compute frequencies of words using Markov model
	for(int l=0; l<L; l++){
		double p = 1;
		for(int M=1; M<L; M*=NUM_NT){
			int digit = l/M % NUM_NT;
			p *= nt_freq[digit];
		}
		expected_freq[l] = p;
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x3150
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x8d0a
movl $0x0, -0x50(%rbp)
cmpl $0x4, -0x50(%rbp)
jge 0x8cfd
movq -0x20(%rbp), %rax
movslq -0x4c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x50(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movslq -0x50(%rbp), %rax
addsd -0x40(%rbp,%rax,8), %xmm0
movsd %xmm0, -0x40(%rbp,%rax,8)
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x8cc7
jmp 0x8cff
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x8cb8
movl $0x0, -0x54(%rbp)
cmpl $0x4, -0x54(%rbp)
jge 0x8d36
movslq -0x54(%rbp), %rax
movsd -0x40(%rbp,%rax,8), %xmm0
addsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x48(%rbp)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x8d11
movl $0x0, -0x58(%rbp)
cmpl $0x4, -0x58(%rbp)
jge 0x8d67
movsd -0x48(%rbp), %xmm1
movslq -0x58(%rbp), %rax
movsd -0x40(%rbp,%rax,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x40(%rbp,%rax,8)
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x8d3d
movl $0x0, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x8de0
movsd 0x228a(%rip), %xmm0     # 0xb008
movsd %xmm0, -0x68(%rbp)
movl $0x1, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x8dc3
movl -0x5c(%rbp), %eax
cltd
idivl -0x6c(%rbp)
movl $0x4, %ecx
cltd
idivl %ecx
movl %edx, -0x70(%rbp)
movslq -0x70(%rbp), %rax
movsd -0x40(%rbp,%rax,8), %xmm0
mulsd -0x68(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movl -0x6c(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x6c(%rbp)
jmp 0x8d8a
movsd -0x68(%rbp), %xmm0
movq -0x18(%rbp), %rax
movslq -0x5c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
jmp 0x8d6e
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CominLab[P]QCluster/freqs.cc
// Function: expected_frequency_p1global(int, int, int, double*, double**)
void expected_frequency_p1global(int N, int K, int L, double *expected_freq,
								double **freq)
{
	int tot_parole = 0;
	for (int l=0; l<L; l++) {
		expected_freq[l] = 0;
		for (int n=0; n<N; n++)
			expected_freq[l] += freq[n][l];
		tot_parole += expected_freq[l];
	}	
	for (int l=0; l<L; l++) {
		expected_freq[l] /= tot_parole;
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x8e97
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x8e6c
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
addsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x8e32
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
cvtsi2sdl -0x24(%rbp), %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x8e13
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x8ecc
cvtsi2sdl -0x24(%rbp), %xmm1
movq -0x18(%rbp), %rax
movslq -0x30(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x8e9e
popq %rbp
retq
nop
// File: CominLab[P]QCluster/seqio.cc
// Function: SeqRecord::toupper() const
SeqRecord SeqRecord::toupper() const
{
	string upper_seq; 
	unsigned int L = sequence.length();
	upper_seq.resize(L);
	for (unsigned int i=0; i<L; i++) {
		upper_seq[i] = std::toupper(sequence[i]); // need to specify std
		// namespace explicitly to avoid conflict with our member function
	}
	return SeqRecord(header, description, upper_seq, quality);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x3370
movq -0xd8(%rbp), %rdi
addq $0x40, %rdi
callq 0x33a0
movq -0xd0(%rbp), %rdi
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x3360
jmp 0x9315
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
cmpl -0x34(%rbp), %eax
jae 0x9389
movq -0xd8(%rbp), %rdi
addq $0x40, %rdi
movl -0x48(%rbp), %eax
movl %eax, %esi
callq 0x32f0
movsbl (%rax), %edi
callq 0x3470
movb %al, -0xf1(%rbp)
movl -0x48(%rbp), %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x34b0
movq %rax, -0xf0(%rbp)
jmp 0x935e
movq -0xf0(%rbp), %rax
movb -0xf1(%rbp), %cl
movb %cl, (%rax)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x931c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x94af
movq -0xd8(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x3110
jmp 0x939b
movq -0xd8(%rbp), %rsi
addq $0x20, %rsi
leaq -0x88(%rbp), %rdi
callq 0x3110
jmp 0x93b4
leaq -0xa8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3110
jmp 0x93c6
movq -0xd8(%rbp), %rsi
addq $0x60, %rsi
leaq -0xc8(%rbp), %rdi
callq 0x3110
jmp 0x93df
movq -0xe8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x88(%rbp), %rdx
leaq -0xa8(%rbp), %rcx
leaq -0xc8(%rbp), %r8
callq 0x9190
jmp 0x9406
leaq -0xc8(%rbp), %rdi
callq 0x3180
leaq -0xa8(%rbp), %rdi
callq 0x3180
leaq -0x88(%rbp), %rdi
callq 0x3180
leaq -0x68(%rbp), %rdi
callq 0x3180
leaq -0x30(%rbp), %rdi
callq 0x3180
movq -0xe0(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x94a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x949a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x948e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x3180
leaq -0xa8(%rbp), %rdi
callq 0x3180
leaq -0x88(%rbp), %rdi
callq 0x3180
leaq -0x68(%rbp), %rdi
callq 0x3180
leaq -0x30(%rbp), %rdi
callq 0x3180
movq -0x40(%rbp), %rdi
callq 0x3420
nopw %cs:(%rax,%rax)
// File: CominLab[P]QCluster/seqio.cc
// Function: reverse_complement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static string reverse_complement(string seq)
{
	size_t L = seq.length();
	string rc_seq;
	rc_seq.resize(L);
	for(size_t i=0; i<L; i++) {
		rc_seq[i] = reverse_complement(seq[L-1-i]);
	}
	return rc_seq;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x50(%rbp)
movq %rdi, %rax
movq -0x50(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq %rax, %rcx
movq %rcx, -0x48(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x33a0
movq -0x40(%rbp), %rdi
movq %rax, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x3370
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3360
jmp 0x969b
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x971c
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rax
movq -0x38(%rbp), %rsi
notq %rsi
addq %rax, %rsi
callq 0x34b0
movq %rax, -0x58(%rbp)
jmp 0x96ca
movq -0x58(%rbp), %rax
movsbl (%rax), %edi
callq 0xa290
movb %al, -0x59(%rbp)
jmp 0x96db
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x34b0
movq %rax, -0x68(%rbp)
jmp 0x96ee
movq -0x68(%rbp), %rax
movb -0x59(%rbp), %cl
movb %cl, (%rax)
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x96a3
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x3180
jmp 0x9739
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x972f
movq -0x40(%rbp), %rdi
callq 0x3180
movq -0x48(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3420
nopw %cs:(%rax,%rax)
// File: CominLab[P]QCluster/seqio.cc
// Function: removeWhiteSpace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
static void removeWhiteSpace(string& line)
{
	size_t pos = 0;
	while (pos < line.length()) {
		if (isspace(line[pos])) {
			line.erase(pos, 1);
		} else {
			pos++;
		}
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x33a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jae 0x9e9d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x34b0
movsbl (%rax), %edi
callq 0x3050
cmpl $0x0, %eax
je 0x9e8f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x30a0
jmp 0x9e9b
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x9e44
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CominLab[P]QCluster/seqio.cc
// Function: FastqRead(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<SeqRecord, std::allocator<SeqRecord>>&)
void FastqRead(string fname, vector<SeqRecord>& recs)
{
	int N = CountReads(fname);
	RecordGenerator rec_gen(fname);
	for (int i=0; i<N; i++) {
		recs.push_back(rec_gen.next());
	}
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x370, %rsp            # imm = 0x370
movq %rsi, %rax
movq %rdi, %rsi
movq %rsi, -0x358(%rbp)
movq %rsi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x350(%rbp)
callq 0x3110
movq -0x350(%rbp), %rdi
callq 0xa070
movl %eax, -0x344(%rbp)
jmp 0x9f34
leaq -0x38(%rbp), %rdi
callq 0x3180
movl -0x344(%rbp), %eax
movq -0x358(%rbp), %rsi
movl %eax, -0x14(%rbp)
leaq -0x2b8(%rbp), %rdi
movq %rdi, -0x360(%rbp)
callq 0x3110
movq -0x360(%rbp), %rsi
leaq -0x298(%rbp), %rdi
callq 0x9750
jmp 0x9f75
leaq -0x2b8(%rbp), %rdi
callq 0x3180
movl $0x0, -0x2bc(%rbp)
movl -0x2bc(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xa045
movq -0x10(%rbp), %rax
movq %rax, -0x368(%rbp)
leaq -0x340(%rbp), %rdi
leaq -0x298(%rbp), %rsi
callq 0x98a0
jmp 0x9fba
movq -0x368(%rbp), %rdi
leaq -0x340(%rbp), %rsi
callq 0xa3b0
jmp 0x9fcf
leaq -0x340(%rbp), %rdi
callq 0x9260
movl -0x2bc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2bc(%rbp)
jmp 0x9f8b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3180
jmp 0xa066
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x2b8(%rbp), %rdi
callq 0x3180
jmp 0xa066
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xa05a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x340(%rbp), %rdi
callq 0x9260
jmp 0xa05a
leaq -0x298(%rbp), %rdi
callq 0x9860
addq $0x370, %rsp            # imm = 0x370
popq %rbp
retq
leaq -0x298(%rbp), %rdi
callq 0x9860
movq -0x40(%rbp), %rdi
callq 0x3420
nop
// File: CominLab[P]QCluster/seqio.cc
// Function: CountReads(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int CountReads(string fname)
{
	int num_reads = 0;
	int indice_riga = 0;
	string line="";
	
	ifstream ifs(fname.c_str());
	
	//Skip rows until first "@" character
	while (ifs.good() && (!line.length() || line[0] != '@')) {
		getline(ifs, line);
	}
	
	while (ifs.good()) {
		indice_riga = (indice_riga+1) % 4;
		if (indice_riga % 4 == 0) num_reads++;	//Couno 1 read every 4 row
		getline(ifs, line);
	}
	
	return num_reads;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x260(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x258(%rbp)
callq 0x3430
movq -0x258(%rbp), %rdx
leaq 0x1a7c(%rip), %rsi      # 0xbb2e
leaq -0x30(%rbp), %rdi
callq 0x5360
jmp 0xa0bd
leaq -0x31(%rbp), %rdi
callq 0x32c0
movq -0x260(%rbp), %rdi
callq 0x3100
movq %rax, %rsi
leaq -0x250(%rbp), %rdi
movl $0x8, %edx
callq 0x3460
jmp 0xa0e8
jmp 0xa0ea
movq -0x250(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x250(%rbp,%rax), %rdi
callq 0x33f0
movb %al, -0x261(%rbp)
jmp 0xa10a
movb -0x261(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x262(%rbp)
jne 0xa11f
jmp 0xa171
leaq -0x30(%rbp), %rdi
callq 0x33a0
movq %rax, %rcx
movb $0x1, %al
cmpq $0x0, %rcx
movb %al, -0x263(%rbp)
je 0xa165
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x34b0
movq %rax, -0x270(%rbp)
jmp 0xa14f
movq -0x270(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x40, %eax
setne %al
movb %al, -0x263(%rbp)
movb -0x263(%rbp), %al
movb %al, -0x262(%rbp)
movb -0x262(%rbp), %al
testb $0x1, %al
jne 0xa17d
jmp 0xa1dc
leaq -0x250(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3080
jmp 0xa18f
jmp 0xa0ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x32c0
jmp 0xa27e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xa275
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x30b0
jmp 0xa275
jmp 0xa1de
movq -0x250(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x250(%rbp,%rax), %rdi
callq 0x33f0
movb %al, -0x271(%rbp)
jmp 0xa1fe
movb -0x271(%rbp), %al
testb $0x1, %al
jne 0xa20a
jmp 0xa248
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0xa234
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
leaq -0x250(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3080
jmp 0xa246
jmp 0xa1de
movl -0xc(%rbp), %eax
movl %eax, -0x278(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x30b0
leaq -0x30(%rbp), %rdi
callq 0x3180
movl -0x278(%rbp), %eax
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x3180
movq -0x40(%rbp), %rdi
callq 0x3420
nopw (%rax,%rax)
// File: suyash[P]chan/examples/go/tree.cc
// Function: walk(tree*, chan::chan<int>*)
void walk(tree* t, chan::chan<int>* ch) {
	if (!t) {
		return ;
	}

	walk(t->left, ch);
	ch->send(t->value);
	walk(t->right, ch);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x2499
jmp 0x24cf
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2480
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
callq 0x2f40
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2480
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: suyash[P]chan/examples/go/tree.cc
// Function: walker(tree*)
chan::chan<int>* walker(tree* t) {
	auto ch = new chan::unbuffered_chan<int>();

	std::thread([ch, t](){
		walk(t, ch);
		ch->close();
	}).detach();

	return ch;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl $0x100, %edi            # imm = 0x100
callq 0x2170
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x2f70
jmp 0x2507
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x2590
movq -0x48(%rbp), %rdi
callq 0x2260
jmp 0x253b
leaq -0x28(%rbp), %rdi
callq 0x2fe0
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x100, %esi            # imm = 0x100
callq 0x2180
jmp 0x257f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2fe0
movq -0x18(%rbp), %rdi
callq 0x2270
nopl (%rax,%rax)
// File: suyash[P]chan/examples/go/tree.cc
// Function: compare(chan::chan<int>*, chan::chan<int>*)
bool compare(chan::chan<int>* walker1, chan::chan<int>* walker2) {
	while (true) {
		int v1 = 0;
		auto ok1 = walker1->recv(v1);

		int v2 = 0;
		auto ok2 = walker2->recv(v2);

		if (!ok1 || !ok2) {
			return ok1 == ok2;
		}

		if (v1 != v2) {
			break;
		}
	}

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x3010
andb $0x1, %al
movb %al, -0x1d(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x3010
andb $0x1, %al
movb %al, -0x25(%rbp)
testb $0x1, -0x1d(%rbp)
je 0x269e
testb $0x1, -0x25(%rbp)
jne 0x26bb
movb -0x1d(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movb -0x25(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x26cb
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
je 0x26c5
jmp 0x26c7
jmp 0x2660
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: suyash[P]chan/examples/go/tree.cc
// Function: insert(tree*, int)
tree* insert(tree* t, int val) {
	if (!t) {
		return new tree(nullptr, val, nullptr);
	}

	if (t->value <= val) {
		return insert(t->left, val);
	}

	return insert(t->right, val);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2741
movl $0x18, %edi
callq 0x2170
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %edx
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rsi
callq 0x3040
jmp 0x271b
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x2776
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x18, %esi
callq 0x2180
jmp 0x2780
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rbp), %eax
jg 0x2762
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x26e0
movq %rax, -0x8(%rbp)
jmp 0x2776
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x14(%rbp), %esi
callq 0x26e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2270
nopl (%rax)
// File: suyash[P]chan/examples/go/tree.cc
// Function: deleteTree(tree*)
void deleteTree(tree* t) {
	if (!t) {
		return ;
	}

	deleteTree(t->left);
	t->left = nullptr;

	deleteTree(t->right);
	t->right = nullptr;

	delete t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x27a5
jmp 0x27f1
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2790
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2790
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x27f1
movq -0x10(%rbp), %rdi
movl $0x18, %esi
callq 0x2180
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: suyash[P]chan/examples/go/tree.cc
// Function: tree* newTree<std::mersenne_twister_engine<unsigned long, 32ul, 624ul, 397ul, 31ul, 2567483615ul, 11ul, 4294967295ul, 7ul, 2636928640ul, 15ul, 4022730752ul, 18ul, 1812433253ul>>(int, int, std::mersenne_twister_engine<unsigned long, 32ul, 624ul, 397ul, 31ul, 2567483615ul, 11ul, 4294967295ul, 7ul, 2636928640ul, 15ul, 4022730752ul, 18ul, 1812433253ul>&&)
tree* newTree(int n, int k, URNG&& g) {
	int a[n];
	int x = 1;
	std::generate(a, a + n, [&](){ return x++; });
	std::shuffle(a, a + n, g);

	tree* t = nullptr;
	for (int i = 0 ; i < n ; i++) {
		t = insert(t, (a[i] + 1) * k);
	}

	return t;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl -0x4(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x18(%rbp)
leaq 0xf(,%rax,4), %rcx
andq $-0x10, %rcx
movq %rsp, %rdi
subq %rcx, %rdi
movq %rdi, -0x48(%rbp)
movq %rdi, %rsp
movq %rax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movslq -0x4(%rbp), %rax
shlq $0x2, %rax
movq %rdi, %rsi
addq %rax, %rsi
leaq -0x24(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdx
callq 0x44d0
movq -0x48(%rbp), %rdi
movslq -0x4(%rbp), %rax
shlq $0x2, %rax
movq %rdi, %rsi
addq %rax, %rsi
movq -0x10(%rbp), %rdx
callq 0x4520
movq $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x312b
movq -0x48(%rbp), %rax
movq -0x38(%rbp), %rdi
movslq -0x3c(%rbp), %rcx
movl (%rax,%rcx,4), %esi
addl $0x1, %esi
imull -0x8(%rbp), %esi
callq 0x26e0
movq %rax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x30f9
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: MPSLab-ASU[P]DiRAC/./src/baseAccelSim.cc
// Function: baseAccelSim::read_inputs()
void baseAccelSim::read_inputs()
{
	read_file_kernels(kernelFileName);
	set_kernel_parameters();
	readArchSpec(archSpecFileName);
	readConfig(configFileName);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq 0x219abf(%rip), %rsi    # 0x61e800
leaq -0x28(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x4a4ec0
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x404e40
jmp 0x404d60
leaq -0x28(%rbp), %rdi
callq 0x4a2730
movq -0x88(%rbp), %rdi
callq 0x405150
leaq 0x219a64(%rip), %rsi    # 0x61e7e0
leaq -0x58(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x4a4ec0
movq -0x88(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x405650
jmp 0x404da1
leaq -0x58(%rbp), %rdi
callq 0x4a2730
leaq 0x219a0f(%rip), %rsi    # 0x61e7c0
leaq -0x78(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x4a4ec0
movq -0x88(%rbp), %rdi
movq -0x98(%rbp), %rsi
callq 0x406bd0
jmp 0x404dd6
leaq -0x78(%rbp), %rdi
callq 0x4a2730
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4a2730
jmp 0x404e2b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x4a2730
jmp 0x404e2b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x4a2730
movq -0x30(%rbp), %rdi
callq 0x4d0770
nopw %cs:(%rax,%rax)
// File: MPSLab-ASU[P]DiRAC/./src/baseAccelSim.cc
// Function: baseAccelSim::read_data_operand(unsigned char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void baseAccelSim::read_data_operand(uint8_t op, string fileName) {
	ifstream inFile(fileName.c_str());
	if(!inFile)
	{
		cout << "Cannot open and read file: " << fileName.c_str() << endl;
		exit (EXIT_FAILURE);
	}

	for(int i=0; i < size_tensors[op]; i++) {
		inFile >> tensor_operands[op][i];
	}
	inFile.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdx, -0x240(%rbp)
movq %rdi, %rcx
movq -0x240(%rbp), %rdi
movb %sil, %al
movq %rcx, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdi, -0x18(%rbp)
callq 0x4a4170
movq %rax, %rsi
leaq -0x220(%rbp), %rdi
movl $0x8, %edx
callq 0x46e8c0
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x472d80
movb %al, -0x231(%rbp)
jmp 0x409213
movb -0x231(%rbp), %al
testb $0x1, %al
jne 0x409222
jmp 0x4092a4
movq $0x61f900, %rdi         # imm = 0x61F900
leaq 0x197de0(%rip), %rsi    # 0x5a1010
callq 0x492450
movq %rax, -0x248(%rbp)
jmp 0x40923e
movq -0x240(%rbp), %rdi
callq 0x4a4170
movq -0x248(%rbp), %rdi
movq %rax, %rsi
callq 0x492450
movq %rax, -0x250(%rbp)
jmp 0x409262
movq -0x250(%rbp), %rdi
movq $0x491d30, %rsi         # imm = 0x491D30
callq 0x490f40
jmp 0x409277
movl $0x1, %edi
callq 0x4ec1e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x46f220
jmp 0x409324
movl $0x0, -0x230(%rbp)
movslq -0x230(%rbp), %rax
movq 0x2152b4(%rip), %rcx    # 0x61e570
movzbl -0x9(%rbp), %edx
cmpq (%rcx,%rdx,8), %rax
jae 0x409301
movq 0x215293(%rip), %rax    # 0x61e560
movzbl -0x9(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movslq -0x230(%rbp), %rcx
leaq (%rax,%rcx,2), %rsi
leaq -0x220(%rbp), %rdi
callq 0x478400
jmp 0x4092ee
jmp 0x4092f0
movl -0x230(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x230(%rbp)
jmp 0x4092ae
leaq -0x220(%rbp), %rdi
callq 0x46ee70
jmp 0x40930f
leaq -0x220(%rbp), %rdi
callq 0x46f220
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq -0x228(%rbp), %rdi
callq 0x4d0770
// File: MPSLab-ASU[P]DiRAC/./src/baseAccelSim.cc
// Function: baseAccelSim::write_data_operand(unsigned char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void baseAccelSim::write_data_operand(uint8_t op, string fileName)
{
	std::ofstream outFile;
  outFile.open (fileName.c_str(), std::ofstream::out | std::ofstream::trunc);

	for(uint64_t idx = 0; idx < size_tensors[op]; idx++)
    outFile << tensor_operands[op][idx] << "\n";

	outFile.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdx, -0x248(%rbp)
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x46d530
movq -0x248(%rbp), %rdi
callq 0x4a4170
movq %rax, -0x240(%rbp)
movl $0x10, %edi
movl $0x20, %esi
callq 0x40f560
movl %eax, -0x234(%rbp)
jmp 0x409546
movl -0x234(%rbp), %edx
movq -0x240(%rbp), %rsi
leaq -0x218(%rbp), %rdi
callq 0x46de50
jmp 0x409561
movq $0x0, -0x230(%rbp)
movq -0x230(%rbp), %rax
movq 0x214ff6(%rip), %rcx    # 0x61e570
movzbl -0x9(%rbp), %edx
cmpq (%rcx,%rdx,8), %rax
jae 0x4095fe
movq 0x214fd5(%rip), %rax    # 0x61e560
movzbl -0x9(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq -0x230(%rbp), %rcx
movzwl (%rax,%rcx,2), %esi
leaq -0x218(%rbp), %rdi
callq 0x492a70
movq %rax, -0x250(%rbp)
jmp 0x4095b3
movq -0x250(%rbp), %rdi
leaq 0x1a2689(%rip), %rsi    # 0x5abc4a
callq 0x492450
jmp 0x4095c8
jmp 0x4095ca
movq -0x230(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x230(%rbp)
jmp 0x40956c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x46f0e0
jmp 0x409621
leaq -0x218(%rbp), %rdi
callq 0x46eeb0
jmp 0x40960c
leaq -0x218(%rbp), %rdi
callq 0x46f0e0
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0x4d0770
nopl (%rax)
// File: MPSLab-ASU[P]DiRAC/./src/baseAccelSim.cc
// Function: baseAccelSim::compare_golden_outputs()
void baseAccelSim::compare_golden_outputs()
{
	if(compare_golden)
	{
		read_golden_outputs();

		for(uint8_t op=(total_operands-output_operands); op < total_operands; op++)
		{
			for(int i=0; i < size_tensors[op]; i++)
			{
				if(golden_outputs[op-input_operands][i] - tensor_operands[op][i] > 0.001)
				{
					printf("Operand %d: Golden output does not match with generated output.\n", op);
					exit (EXIT_FAILURE);
				}
			}
		}
		cout << "Generated output operands consist of expected values.\n";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x215095(%rip)    # 0x61e980
je 0x4099d8
movq -0x18(%rbp), %rdi
callq 0x409630
movzbl 0x214c55(%rip), %eax    # 0x61e556
movzbl 0x214c4f(%rip), %ecx    # 0x61e557
subl %ecx, %eax
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
movzbl 0x214c3e(%rip), %ecx    # 0x61e556
cmpl %ecx, %eax
jge 0x4099c5
movl $0x0, -0x10(%rbp)
movslq -0x10(%rbp), %rax
movq 0x214c3e(%rip), %rcx    # 0x61e570
movzbl -0x9(%rbp), %edx
cmpq (%rcx,%rdx,8), %rax
jae 0x4099b6
movq 0x214c25(%rip), %rax    # 0x61e568
movzbl -0x9(%rbp), %ecx
movzbl 0x214c0a(%rip), %edx    # 0x61e558
subl %edx, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movzwl (%rax,%rcx,2), %eax
movq 0x214bfa(%rip), %rcx    # 0x61e560
movzbl -0x9(%rbp), %edx
movq (%rcx,%rdx,8), %rcx
movslq -0x10(%rbp), %rdx
movzwl (%rcx,%rdx,2), %ecx
subl %ecx, %eax
cvtsi2sd %eax, %xmm0
movsd 0x197684(%rip), %xmm1   # 0x5a1008
ucomisd %xmm1, %xmm0
jbe 0x4099a6
movzbl -0x9(%rbp), %esi
leaq 0x198ef2(%rip), %rdi    # 0x5a2887
movb $0x0, %al
callq 0x4f74b0
movl $0x1, %edi
callq 0x4ec1e0
jmp 0x4099a8
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x409927
jmp 0x4099b8
movb -0x9(%rbp), %al
addb $0x1, %al
movb %al, -0x9(%rbp)
jmp 0x40990d
movq $0x61f900, %rdi         # imm = 0x61F900
leaq 0x198ef5(%rip), %rsi    # 0x5a28c8
callq 0x492450
addq $0x20, %rsp
popq %rbp
retq
nop