LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_profile_normalization.cpp
// Function: pearson_correlation(double*, double*, int)
double pearson_correlation(double* prof1_total_sigs_per_win, double* prof2_total_sigs_per_win, int n_processed_wins)
{
	double num = 0.0f;
	//double den = 0.0f;

	double prof1_mean = 0.0f;
	double prof2_mean = 0.0f;
	for(int i_win = 0; i_win < n_processed_wins; i_win++)
	{
		//control_mean += control_frag_cnt->at(i_frag);
		prof1_mean += prof1_total_sigs_per_win[i_win];
		prof2_mean += prof2_total_sigs_per_win[i_win];
	} // i_win loop.
	prof1_mean /= n_processed_wins;
	prof2_mean /= n_processed_wins;

    //for(int i_frag = 0; i_frag < chip_seq_frag_cnt->size(); i_frag++)
	for(int i_win = 0; i_win < n_processed_wins; i_win++)
    {
		num += (prof1_total_sigs_per_win[i_win] - prof1_mean) * (prof2_total_sigs_per_win[i_win] - prof2_mean);
	} // i_win loop.
	
	double prof1_var = 0.0f;
    for(int i_win = 0; i_win < n_processed_wins; i_win++)
    {
		prof1_var += (prof1_total_sigs_per_win[i_win] - prof1_mean) * (prof1_total_sigs_per_win[i_win] - prof1_mean);
	}	
	prof1_var = pow(prof1_var, .5);

	double prof2_var = 0.0f;
    for(int i_win = 0; i_win < n_processed_wins; i_win++)
    {
		prof2_var += (prof2_total_sigs_per_win[i_win] - prof2_mean) * (prof2_total_sigs_per_win[i_win] - prof2_mean);
	}
	prof2_var = pow(prof2_var, .5);

	double r = num / (prof1_var * prof2_var);

	return(r);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
testl %edx, %edx
jle 0x23130
movl %edx, %ebp
movq %rsi, %rbx
movl %edx, %r14d
xorpd %xmm4, %xmm4
xorl %eax, %eax
xorpd %xmm1, %xmm1
addsd (%rdi,%rax,8), %xmm1
addsd (%rbx,%rax,8), %xmm4
incq %rax
cmpq %rax, %r14
jne 0x23071
testl %ebp, %ebp
jle 0x23130
cvtsi2sd %ebp, %xmm0
divsd %xmm0, %xmm1
divsd %xmm0, %xmm4
xorpd %xmm3, %xmm3
xorl %eax, %eax
movsd (%rdi,%rax,8), %xmm0
subsd %xmm1, %xmm0
movsd (%rbx,%rax,8), %xmm2
subsd %xmm4, %xmm2
mulsd %xmm0, %xmm2
addsd %xmm2, %xmm3
incq %rax
cmpq %rax, %r14
jne 0x2309d
testl %ebp, %ebp
jle 0x2316a
movsd %xmm4, 0x18(%rsp)
movsd %xmm3, 0x10(%rsp)
xorpd %xmm0, %xmm0
xorl %eax, %eax
movsd (%rdi,%rax,8), %xmm2
subsd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rax
cmpq %rax, %r14
jne 0x230d9
movsd 0x6f5e(%rip), %xmm1     # 0x2a058
callq 0x22d0
testl %ebp, %ebp
movsd %xmm0, 0x8(%rsp)
xorpd %xmm0, %xmm0
jle 0x23140
xorl %eax, %eax
movsd 0x18(%rsp), %xmm2
movsd (%rbx,%rax,8), %xmm1
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq %rax, %r14
jne 0x23115
jmp 0x23140
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
movsd 0x6f10(%rip), %xmm1     # 0x2a058
callq 0x22d0
mulsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd %xmm3, 0x10(%rsp)
jmp 0x23140
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_combinatorics.cpp
// Function: factorial(int)
double factorial(int n)
{
	double cur_fact = 1.0;
	for(int i = 1; i <= n; i++)
	{
		cur_fact *= i;
	} 

	return(cur_fact);
}

// Assembly:
testl %edi, %edi
jle 0x231a1
movsd 0x6e7c(%rip), %xmm1     # 0x2a008
movapd %xmm1, %xmm2
movapd %xmm1, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm2
decl %edi
jne 0x23194
retq
movsd 0x6e5f(%rip), %xmm0     # 0x2a008
retq
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_combinatorics.cpp
// Function: is_gt(std::vector<int, std::allocator<int>>*, std::vector<int, std::allocator<int>>*)
bool is_gt(vector<int>* combinatorial_indices1, vector<int>* combinatorial_indices2)
{
	for(int i = 0; i < (int)combinatorial_indices1->size(); i++)
	{
		if(combinatorial_indices1->at(i) > combinatorial_indices2->at(i))
		{
			return(true);
		}
		else if(combinatorial_indices1->at(i) == combinatorial_indices2->at(i))
		{
			
		}
	} // i loop.

	return(false);
}

// Assembly:
pushq %rax
movq (%rdi), %r9
movq 0x8(%rdi), %rdx
subq %r9, %rdx
sarq $0x2, %rdx
testl %edx, %edx
jle 0x231f8
movl %edx, %edi
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
movb $0x1, %al
xorl %ecx, %ecx
cmpq %rcx, %rdx
je 0x231fe
movq (%rsi), %r10
movq 0x8(%rsi), %r8
subq %r10, %r8
sarq $0x2, %r8
cmpq %rcx, %r8
jbe 0x2320a
movl (%r9,%rcx,4), %r8d
cmpl (%r10,%rcx,4), %r8d
jg 0x231fa
incq %rcx
cmpq %rdi, %rcx
setb %al
jne 0x231c9
jmp 0x231fa
xorl %eax, %eax
andb $0x1, %al
popq %rcx
retq
leaq 0x96cb(%rip), %rdi      # 0x2c8d0
movq %rdx, %rsi
jmp 0x23217
leaq 0x96bf(%rip), %rdi      # 0x2c8d0
movq %rcx, %rsi
movq %r8, %rdx
xorl %eax, %eax
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_combinatorics.cpp
// Function: is_equal(std::vector<int, std::allocator<int>>*, std::vector<int, std::allocator<int>>*)
bool is_equal(vector<int>* combinatorial_indices1, vector<int>* combinatorial_indices2)
{
	for(int i = 0; i < (int)combinatorial_indices1->size(); i++)
	{
		if(combinatorial_indices1->at(i) != combinatorial_indices2->at(i))
		{
			return(false);
		}
	} // i loop.

	return(true);
}

// Assembly:
pushq %rax
movq (%rdi), %r9
movq 0x8(%rdi), %rdx
subq %r9, %rdx
sarq $0x2, %rdx
testl %edx, %edx
jle 0x2326c
movl %edx, %edi
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
xorl %eax, %eax
cmpq %rcx, %rdx
je 0x23272
movq (%rsi), %r10
movq 0x8(%rsi), %r8
subq %r10, %r8
sarq $0x2, %r8
cmpq %rcx, %r8
jbe 0x2327e
movl (%r9,%rcx,4), %r8d
cmpl (%r10,%rcx,4), %r8d
jne 0x2326e
incq %rcx
cmpq %rdi, %rcx
setae %al
jne 0x2323d
jmp 0x2326e
movb $0x1, %al
andb $0x1, %al
popq %rcx
retq
leaq 0x9657(%rip), %rdi      # 0x2c8d0
movq %rdx, %rsi
jmp 0x2328b
leaq 0x964b(%rip), %rdi      # 0x2c8d0
movq %rcx, %rsi
movq %r8, %rdx
xorl %eax, %eax
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_combinatorics.cpp
// Function: is_valid_indexing(std::vector<int, std::allocator<int>>*)
bool is_valid_indexing(vector<int>* sorted_combinatorial_indices)
{
	for(int i = 0; i < (int)sorted_combinatorial_indices->size()-1; i++)
	{
		if(sorted_combinatorial_indices->at(i) == sorted_combinatorial_indices->at(i+1))
		{
			return(false);
		}
	} // i loop.

	return(true);
}

// Assembly:
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
leal -0x1(%rdx), %ecx
cmpq $0x1, %rdx
movq %rdx, %rsi
adcq $0x0, %rsi
xorl %r10d, %r10d
testl %ecx, %ecx
movl $0x0, %edi
cmovgl %ecx, %edi
leaq -0x1(%rsi), %r8
movq %r10, %r9
cmpq %r10, %rdi
je 0x232e1
cmpq %r9, %rdx
je 0x232f5
cmpq %r9, %r8
je 0x232ec
leaq 0x1(%r9), %r10
movl (%rax,%r9,4), %r11d
cmpl 0x4(%rax,%r9,4), %r11d
jne 0x232c0
movslq %ecx, %rax
cmpq %rax, %r9
setge %al
popq %rcx
retq
leaq 0x95dd(%rip), %rdi      # 0x2c8d0
jmp 0x232ff
leaq 0x95d4(%rip), %rdi      # 0x2c8d0
movq %rdx, %rsi
xorl %eax, %eax
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_combinatorics.cpp
// Function: get_next_counting_indices(std::vector<int, std::allocator<int>>*, std::vector<int, std::allocator<int>>*)
bool get_next_counting_indices(vector<int>* counting_indices, 
								vector<int>* n_all_elements_per_digit)
{
	bool updated_comb_indices = false;
	for(int i = (int)counting_indices->size()-1; i >= 0; i--)
	{
		if(counting_indices->at(i)+1 < n_all_elements_per_digit->at(i))
		{
			counting_indices->at(i) = counting_indices->at(i)+1;
			updated_comb_indices = true;
			break;
		}
		else
		{
			counting_indices->at(i) = 0;
		}
	} // i loop.

	// No more updates available.
	if(!updated_comb_indices)
	{
		return(false);
	}
	else
	{
		return(true);
	}
}

// Assembly:
pushq %rax
movq (%rdi), %r8
movq 0x8(%rdi), %rdx
subq %r8, %rdx
sarq $0x2, %rdx
testl %edx, %edx
jle 0x233d2
movl %edx, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
decq %rax
cmpq %rax, %rdx
jbe 0x233ed
movq (%rsi), %rdi
movq 0x8(%rsi), %rcx
subq %rdi, %rcx
sarq $0x2, %rcx
cmpq %rax, %rcx
jbe 0x233de
movl (%r8,%rax,4), %ecx
incl %ecx
cmpl (%rdi,%rax,4), %ecx
jl 0x233d6
movl $0x0, (%r8,%rax,4)
leaq -0x1(%rax), %rcx
incq %rax
cmpq $0x1, %rax
movq %rcx, %rax
ja 0x23397
xorl %eax, %eax
jmp 0x233dc
movl %ecx, (%r8,%rax,4)
movb $0x1, %al
popq %rcx
retq
leaq 0x94eb(%rip), %rdi      # 0x2c8d0
movq %rax, %rsi
movq %rcx, %rdx
jmp 0x233f7
leaq 0x94dc(%rip), %rdi      # 0x2c8d0
movq %rax, %rsi
xorl %eax, %eax
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_combinatorics.cpp
// Function: dump_binomial_p_vals(int, double*)
void dump_binomial_p_vals(int max_grand_total, double* log_factorials)
{
	for(int cur_grand_total = 0; cur_grand_total <= max_grand_total; cur_grand_total++)
	{
		char cur_p_vals_fp[1000];
		sprintf(cur_p_vals_fp, "p_vals_%d.txt", cur_grand_total);
		FILE* f_cur_p_vals = fopen(cur_p_vals_fp, "w");

		double log_flip = log(.5);
		double cur_p_val = xlog(0.0);
		for(int cur_sig = 0; cur_sig <= cur_grand_total; cur_sig++)
		{
			double log_cur_half_pow = log_flip * cur_grand_total;
			double log_cur_perm = 0.0; // = xlog(1.0).

			// Compute the current permutation.
			log_cur_perm = xlog_div(log_factorials[cur_grand_total], xlog_mul(log_factorials[cur_sig], log_factorials[cur_grand_total-cur_sig]));
			cur_p_val = xlog_sum(cur_p_val, xlog_mul(log_cur_perm, log_cur_half_pow));

			// Also get the normal approximation.


			fprintf(f_cur_p_vals, "%d\t%lf\n", cur_sig, cur_p_val);
		} // i loop.

		fclose(f_cur_p_vals);
	} // grand_total
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp            # imm = 0x418
movq %rdi, 0x8(%rsp)
testl %edi, %edi
js 0x23519
movq %rsi, %rbx
movq 0x8(%rsp), %rax
incl %eax
movq %rax, 0x8(%rsp)
movl $0x1, %r14d
movq %rsi, %rbp
xorl %r15d, %r15d
leaq 0x30(%rsp), %r12
movq %r12, %rdi
leaq 0xb032(%rip), %rsi      # 0x2e478
movl %r15d, %edx
xorl %eax, %eax
callq 0x2080
movq %r12, %rdi
leaq 0x764e(%rip), %rsi      # 0x2aaa8
callq 0x21c0
movq %rax, %r13
xorps %xmm0, %xmm0
callq 0x2525c
xorps %xmm1, %xmm1
cvtsi2sd %r15d, %xmm1
movsd %xmm0, 0x10(%rsp)
mulsd 0xac60(%rip), %xmm1     # 0x2e0e0
movsd %xmm1, 0x20(%rsp)
movq %rbp, 0x18(%rsp)
xorl %r12d, %r12d
movsd (%rbx,%r15,8), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd (%rbx,%r12,8), %xmm0
movsd (%rbp), %xmm1
callq 0x253c5
movaps %xmm0, %xmm1
movsd 0x28(%rsp), %xmm0
callq 0x25400
movsd 0x20(%rsp), %xmm1
callq 0x253c5
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
callq 0x252b0
movq %r13, %rdi
leaq 0x9daa(%rip), %rsi      # 0x2d285
movl %r12d, %edx
movsd %xmm0, 0x10(%rsp)
movb $0x1, %al
callq 0x2250
incq %r12
addq $-0x8, %rbp
cmpq %r12, %r14
jne 0x2348e
movq %r13, %rdi
callq 0x2170
incq %r15
incq %r14
movq 0x18(%rsp), %rbp
addq $0x8, %rbp
cmpq 0x8(%rsp), %r15
jne 0x23437
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_combinatorics.cpp
// Function: buffer_binomial_pvalues(int, double*, int)
double** buffer_binomial_pvalues(int max_grand_total, double* log_factorials, int BINOMIAL_P_VAL_BIN_SIZE)
{
	double** binomial_vals = new double*[max_grand_total + 2];

	for(int cur_grand_total = 0; cur_grand_total <= max_grand_total; cur_grand_total++)
	{
		binomial_vals[cur_grand_total] = new double[cur_grand_total / BINOMIAL_P_VAL_BIN_SIZE + 10];

		double log_flip = log(.5);
		double cur_p_val = xlog(0.0);
		for(int cur_sig = 0; cur_sig <= cur_grand_total; cur_sig++)
		{
			double log_cur_half_pow = log_flip * cur_grand_total;
			double log_cur_perm = 0.0; // = xlog(1.0).

			// Compute the current permutation.
			log_cur_perm = xlog_div(log_factorials[cur_grand_total], xlog_mul(log_factorials[cur_sig], log_factorials[cur_grand_total-cur_sig]));
			cur_p_val = xlog_sum(cur_p_val, xlog_mul(log_cur_perm, log_cur_half_pow));

			// Add this value in case.
			if(cur_sig % BINOMIAL_P_VAL_BIN_SIZE == 0)
			{
				binomial_vals[cur_grand_total][cur_sig / BINOMIAL_P_VAL_BIN_SIZE] = cur_p_val;
			}
		} // i loop.
	} // grand_total

	return(binomial_vals);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebx
movq %rsi, %r14
movl %edi, %r15d
leal 0x2(%r15), %edi
shlq $0x3, %rdi
cmpl $-0x2, %r15d
movq $-0x1, %rax
cmovlq %rax, %rdi
callq 0x2040
movq %rax, 0x8(%rsp)
movq %r15, (%rsp)
testl %r15d, %r15d
js 0x23663
movq (%rsp), %rax
incl %eax
movq %rax, (%rsp)
movl $0x1, %r15d
xorl %r13d, %r13d
movq %r14, %rbp
movl %r13d, %eax
cltd
idivl %ebx
cltq
leaq 0x50(,%rax,8), %rdi
cmpl $-0xa, %eax
movq $-0x1, %rax
cmovlq %rax, %rdi
callq 0x2040
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq %rcx, (%rax,%r13,8)
xorps %xmm0, %xmm0
callq 0x2525c
xorps %xmm1, %xmm1
cvtsi2sd %r13d, %xmm1
mulsd 0xab0f(%rip), %xmm1     # 0x2e0e0
movsd %xmm1, 0x20(%rsp)
movq %rbp, 0x10(%rsp)
xorl %r12d, %r12d
movsd %xmm0, 0x30(%rsp)
movsd (%r14,%r13,8), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd (%r14,%r12,8), %xmm0
movsd (%rbp), %xmm1
callq 0x253c5
movaps %xmm0, %xmm1
movsd 0x28(%rsp), %xmm0
callq 0x25400
movsd 0x20(%rsp), %xmm1
callq 0x253c5
movaps %xmm0, %xmm1
movsd 0x30(%rsp), %xmm0
callq 0x252b0
movl %r12d, %eax
cltd
idivl %ebx
testl %edx, %edx
jne 0x2363e
cltq
movq 0x18(%rsp), %rcx
movsd %xmm0, (%rcx,%rax,8)
incq %r12
addq $-0x8, %rbp
cmpq %r12, %r15
jne 0x235df
incq %r13
incq %r15
movq 0x10(%rsp), %rbp
addq $0x8, %rbp
cmpq (%rsp), %r13
jne 0x23585
movq 0x8(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_combinatorics.cpp
// Function: delete_buffered_binomial_pvalues(double**, int, int)
void delete_buffered_binomial_pvalues(double** binomial_p_vals, int max_grand_total, int BINOMIAL_P_VAL_BIN_SIZE)
{
	for(int cur_grand_total = 0; cur_grand_total <= max_grand_total; cur_grand_total++)
	{
		//binomial_p_vals[cur_grand_total] = new double[cur_grand_total / BINOMIAL_P_VAL_BIN_SIZE + 10];
		delete [] binomial_p_vals[cur_grand_total];
	} // cur_grand_total loop.

	delete [] binomial_p_vals;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
js 0x236a4
movl %esi, %r14d
incl %r14d
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
testq %rdi, %rdi
je 0x2369a
callq 0x2220
incq %r15
cmpq %r15, %r14
jne 0x2368c
jmp 0x236a9
testq %rbx, %rbx
je 0x236b6
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2220
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_combinatorics.cpp
// Function: buffer_log_factorials(int)
double* buffer_log_factorials(int n)
{
	double* factorials = new double[n+2];
	factorials[0] = xlog(1.0);
	for(int i = 1; i <= n; i++)
	{
		factorials[i] = xlog_mul(factorials[i-1], xlog(i));
	} // i loop.

	return(factorials);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
leal 0x2(%rbx), %eax
shlq $0x3, %rax
cmpl $-0x2, %edi
movq $-0x1, %rdi
cmovgeq %rax, %rdi
callq 0x2040
movq %rax, %r14
movsd 0x691c(%rip), %xmm0     # 0x2a008
callq 0x2525c
movsd %xmm0, (%r14)
testl %ebx, %ebx
jle 0x23739
incl %ebx
movl $0x1, %r15d
movsd -0x8(%r14,%r15,8), %xmm0
movsd %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
callq 0x2525c
movapd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
callq 0x253c5
movsd %xmm0, (%r14,%r15,8)
incq %r15
cmpq %r15, %rbx
jne 0x23702
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_combinatorics.cpp
// Function: get_next_combination_indices(std::vector<int, std::allocator<int>>*, std::vector<int, std::allocator<int>>*, int)
bool get_next_combination_indices(vector<int>* combination_indices, 
								vector<int>* current_counting_indices,
								int n_all_elements)
{
	while(1)
	{
		// Update the last index in the sorted list.
		bool updated_comb_indices = false;
		for(int i = (int)current_counting_indices->size()-1; i >= 0; i--)
		{
			if(current_counting_indices->at(i)+1 < n_all_elements)
			{
				current_counting_indices->at(i) = current_counting_indices->at(i)+1;
				updated_comb_indices = true;
				break;
			}
			else
			{
				current_counting_indices->at(i) = 0;
			}
		} // i loop.

		// No more updates available.
		if(!updated_comb_indices)
		{
			return(false);
		}

		// Sort the current indices.
		if(is_increasing(current_counting_indices))
		{	
			break;
		}
	} // Get a new permutation.

	// Copy the indices.
	for(int i = 0; i < (int)current_counting_indices->size(); i++)
	{
		combination_indices->at(i) = current_counting_indices->at(i);
	} // i loop.

	return(true);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
testl %edx, %edx
jle 0x237f6
movl %edx, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
decq %rsi
cmpq %rsi, %rdx
jbe 0x237fd
movl (%rax,%rsi,4), %ecx
incl %ecx
cmpl %ebp, %ecx
jl 0x2379e
movl $0x0, (%rax,%rsi,4)
leaq -0x1(%rsi), %rcx
incq %rsi
cmpq $0x1, %rsi
movq %rcx, %rsi
ja 0x23773
jmp 0x237f6
movl %ecx, (%rax,%rsi,4)
movq %r14, %rdi
callq 0x23306
testb %al, %al
je 0x23752
movq (%r14), %rdi
movq 0x8(%r14), %rdx
subq %rdi, %rdx
sarq $0x2, %rdx
movb $0x1, %al
testl %edx, %edx
jle 0x237f8
movl %edx, %r8d
andl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x2380b
movq (%rbx), %r9
movq 0x8(%rbx), %rcx
subq %r9, %rcx
sarq $0x2, %rcx
cmpq %rsi, %rcx
jbe 0x23817
movl (%rdi,%rsi,4), %ecx
movl %ecx, (%r9,%rsi,4)
incq %rsi
cmpq %rsi, %r8
jne 0x237cd
jmp 0x237f8
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x90cc(%rip), %rdi      # 0x2c8d0
xorl %eax, %eax
callq 0x2270
leaq 0x90be(%rip), %rdi      # 0x2c8d0
movq %rdx, %rsi
jmp 0x23804
leaq 0x90b2(%rip), %rdi      # 0x2c8d0
movq %rcx, %rdx
jmp 0x23804
nop
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_nucleotide.cpp
// Function: get_dna_pair(char)
char get_dna_pair(char nuc)
{
	if(toupper(nuc) == 'A')
	{
		return('T');
	}
	else if(toupper(nuc) == 'C')
	{
		return('G');
	}
	else if(toupper(nuc) == 'G')
	{
		return('C');
	}
	else if(toupper(nuc) == 'T')
	{
		return('A');
	}
	else
	{
		return('N');
	}
}

// Assembly:
pushq %rax
callq 0x2330
cmpl $0x46, %eax
jg 0x2383d
cmpl $0x41, %eax
je 0x2384f
cmpl $0x43, %eax
jne 0x2384b
movb $0x47, %al
jmp 0x23855
cmpl $0x47, %eax
je 0x23853
cmpl $0x54, %eax
jne 0x2384b
movb $0x41, %al
jmp 0x23855
movb $0x4e, %al
jmp 0x23855
movb $0x54, %al
jmp 0x23855
movb $0x43, %al
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_nucleotide.cpp
// Function: check_rna_pairing(char, char)
bool check_rna_pairing(char nuc1, char nuc2)
{
	if(toupper(nuc1) == 'A')
	{
		if(toupper(nuc2) == 'U' ||
			toupper(nuc2) == 'T')
		{
			return(true);
		}
	}

	if(toupper(nuc1) == 'C')
	{
		if(toupper(nuc2) == 'G')
		{
			return(true);
		}
	}

	if(toupper(nuc1) == 'G')
	{
		if(toupper(nuc2) == 'U' || 
			toupper(nuc2) == 'T' || 
			toupper(nuc2) == 'C')
		{
			return(true);
		}
	}

	if(toupper(nuc1) == 'T')
	{
		if(toupper(nuc2) == 'A' ||
			toupper(nuc2) == 'G')
		{
			return(true);
		}
	}

	if(toupper(nuc1) == 'U')
	{
		if(toupper(nuc2) == 'A' ||
			toupper(nuc2) == 'G')
		{
			return(true);
		}
	}

	return(false);
}

// Assembly:
pushq %rbx
movl %esi, %ebx
callq 0x2330
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x46, %ecx
jle 0x2388f
cmpl $0x47, %ecx
je 0x238ac
cmpl $0x54, %ecx
je 0x23877
cmpl $0x55, %ecx
jne 0x238dd
movsbl %bl, %edi
callq 0x2330
cmpl $0x41, %eax
sete %cl
cmpl $0x47, %eax
sete %al
orb %cl, %al
jmp 0x238dd
cmpl $0x41, %ecx
je 0x238c7
cmpl $0x43, %ecx
jne 0x238dd
movsbl %bl, %edi
callq 0x2330
movl %eax, %ecx
movb $0x1, %al
cmpl $0x47, %ecx
jne 0x238db
jmp 0x238dd
movsbl %bl, %edi
callq 0x2330
movl %eax, %ecx
addl $-0x43, %ecx
cmpl $0x13, %ecx
jae 0x238db
movl $0x60001, %eax          # imm = 0x60001
shrl %cl, %eax
jmp 0x238dd
movsbl %bl, %edi
callq 0x2330
movl %eax, %ecx
andl $-0x2, %ecx
movb $0x1, %al
cmpl $0x54, %ecx
je 0x238dd
xorl %eax, %eax
andb $0x1, %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_nucleotide.cpp
// Function: get_complementary_dna_nuc_per_dna_nuc(char)
char get_complementary_dna_nuc_per_dna_nuc(char dna_nuc)
{
	if(toupper(dna_nuc) == 'A')
	{
		return('T');
	}
	else if(toupper(dna_nuc) == 'C')
	{
		return('G');
	}
	else if(toupper(dna_nuc) == 'G')
	{
		return('C');
	}
	else if(toupper(dna_nuc) == 'T' ||
		toupper(dna_nuc) == 'U')
	{
		return('A');
	}
	else
	{
		return('N');
	}
}

// Assembly:
pushq %rax
callq 0x2330
cmpl $0x53, %eax
jg 0x239af
cmpl $0x41, %eax
je 0x239bb
cmpl $0x43, %eax
je 0x239bf
cmpl $0x47, %eax
jne 0x239c3
movb $0x43, %al
jmp 0x239c5
addl $-0x54, %eax
cmpl $0x2, %eax
jae 0x239c3
movb $0x41, %al
jmp 0x239c5
movb $0x54, %al
jmp 0x239c5
movb $0x47, %al
jmp 0x239c5
movb $0x4e, %al
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_nucleotide.cpp
// Function: get_complementary_rna_nuc_per_rna_nuc(char)
char get_complementary_rna_nuc_per_rna_nuc(char rna_nuc)
{
	if(toupper(rna_nuc) == 'A')
	{
		return('U');
	}
	else if(toupper(rna_nuc) == 'C')
	{
		return('G');
	}
	else if(toupper(rna_nuc) == 'G')
	{
		return('C');
	}
	else if(toupper(rna_nuc) == 'U')
	{
		return('A');
	}
	else
	{
		return('N');
	}
}

// Assembly:
pushq %rax
callq 0x2330
cmpl $0x46, %eax
jg 0x239e0
cmpl $0x41, %eax
je 0x239f2
cmpl $0x43, %eax
jne 0x239ee
movb $0x47, %al
jmp 0x239f8
cmpl $0x47, %eax
je 0x239f6
cmpl $0x55, %eax
jne 0x239ee
movb $0x41, %al
jmp 0x239f8
movb $0x4e, %al
jmp 0x239f8
movb $0x55, %al
jmp 0x239f8
movb $0x43, %al
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_xlog_math.cpp
// Function: xlog_sum(double, double)
double xlog_sum(double log1, double log2)
{
	//n_sums++;
	//return(log1 + log2);

	if(log1 == xlog(0.0))
	{
		return(log2);
	}
	else if(log2 == xlog(0.0))
	{
		return(log1);
	}
	else
	{
		if(log1 > log2)
		{
			return( log1 + xlog(1 + xexp(log2-log1)) );
		}
		else
		{
			return( log2 + xlog(1 + xexp(log1-log2)) );
		}

		//return(xlog((log1) + (log2)));
	}
}

// Assembly:
ucomisd 0x9370(%rip), %xmm0     # 0x2e628
jne 0x252c0
jnp 0x25341
ucomisd 0x9360(%rip), %xmm1     # 0x2e628
jne 0x252d2
jp 0x252d2
movapd %xmm0, %xmm1
jmp 0x25341
pushq %rax
ucomisd %xmm1, %xmm0
jbe 0x252f8
movsd %xmm0, (%rsp)
subsd %xmm0, %xmm1
ucomisd 0x933e(%rip), %xmm1     # 0x2e628
jne 0x25317
jp 0x25317
movsd 0x4d12(%rip), %xmm0     # 0x2a008
jmp 0x2532f
subsd %xmm1, %xmm0
ucomisd 0x9324(%rip), %xmm0     # 0x2e628
jne 0x2531d
jp 0x2531d
movsd 0x4cf8(%rip), %xmm0     # 0x2a008
movsd %xmm1, (%rsp)
jmp 0x2532f
movapd %xmm1, %xmm0
jmp 0x25322
movsd %xmm1, (%rsp)
callq 0x2300
addsd 0x4cd9(%rip), %xmm0     # 0x2a008
callq 0x2525c
movapd %xmm0, %xmm1
addsd (%rsp), %xmm1
addq $0x8, %rsp
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_xlog_math.cpp
// Function: get_xlog_comp_prec()
double get_xlog_comp_prec()
{
	double log_prec = xlog(1.0f);
	double log_one = xlog(1.0f);
	while(1)
	{
		if(xlog_comp(log_one, xlog_sum(log_one, log_prec)))
		{
			printf("%lf = %lf + %G\n", log_one, log_one, log_prec);
			break;
		}

		log_prec = xlog_div(log_prec, xlog(2.0f));
	}

	return(log_prec);
}

// Assembly:
subq $0x18, %rsp
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
callq 0x252b0
xorpd %xmm1, %xmm1
movapd %xmm1, (%rsp)
ucomisd 0x4b2f(%rip), %xmm0     # 0x2a0b0
jne 0x25585
jnp 0x255f6
xorpd %xmm2, %xmm2
movapd %xmm1, (%rsp)
movapd %xmm0, %xmm1
addsd 0x9096(%rip), %xmm1     # 0x2e630
ucomisd %xmm2, %xmm1
addsd 0x9092(%rip), %xmm0     # 0x2e638
jb 0x255ae
ucomisd %xmm0, %xmm2
jae 0x255f6
movapd (%rsp), %xmm1
movapd %xmm1, %xmm0
addsd 0x8b21(%rip), %xmm0     # 0x2e0e0
movsd 0x9061(%rip), %xmm3     # 0x2e628
cmpeqsd %xmm3, %xmm1
movapd %xmm1, %xmm2
andpd %xmm3, %xmm2
andnpd %xmm0, %xmm1
orpd %xmm2, %xmm1
xorpd %xmm0, %xmm0
movapd %xmm1, (%rsp)
callq 0x252b0
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jne 0x2558e
jp 0x2558e
leaq 0x90db(%rip), %rdi      # 0x2e6d8
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
movaps (%rsp), %xmm2
movb $0x3, %al
callq 0x2050
movaps (%rsp), %xmm0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_utils.cpp
// Function: get_file_extension(char*)
char* get_file_extension(char* fp)
{
	t_string_tokens* tokens = t_string::tokenize_by_chars(fp, "/\\.");
	if(tokens->size() > 0)
	{
		char* fn = t_string::copy_me_str(tokens->back()->str());
		t_string::clean_tokens(tokens);
		return(fn);
	}
	else
	{
		return(NULL);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x90c1(%rip), %rsi      # 0x2e6e8
callq 0x282b0
movq %rax, %rbx
movq 0x8(%rax), %rax
cmpq (%rbx), %rax
je 0x25659
movq -0x8(%rax), %rdi
callq 0x26fb2
movq %rax, %rdi
callq 0x26db4
movq %rax, %r14
movq %rbx, %rdi
callq 0x28630
movq %r14, %rax
jmp 0x2565b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_utils.cpp
// Function: get_file_name(char*)
char* get_file_name(char* fp)
{
	t_string_tokens* tokens = t_string::tokenize_by_chars(fp, "/\\");
	if(tokens->size() > 0)
	{
		char* fn = t_string::copy_me_str(tokens->back()->str());
		t_string::clean_tokens(tokens);
		return(fn);
	}
	else
	{
		return(NULL);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x907e(%rip), %rsi      # 0x2e6ec
callq 0x282b0
movq %rax, %rbx
movq 0x8(%rax), %rax
cmpq (%rbx), %rax
je 0x256a0
movq -0x8(%rax), %rdi
callq 0x26fb2
movq %rax, %rdi
callq 0x26db4
movq %rax, %r14
movq %rbx, %rdi
callq 0x28630
movq %r14, %rax
jmp 0x256a2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_utils.cpp
// Function: get_directory_per_fp(char*)
char* get_directory_per_fp(char* fp)
{
	t_string_tokens* fp_tokens = t_string::tokenize_by_chars(fp, "\\/");

	if(fp_tokens->size() == 1)
	{
		t_string::clean_tokens(fp_tokens);
		return(NULL);
	}
	else
	{
		char* directory = new char[t_string::string_length(fp) + 2];
		directory[0] = 0;

		for(int i = 0; i < (int)fp_tokens->size() - 1; i++)
		{
			strcat(directory, fp_tokens->at(i)->str());
		} // i loop.

		t_string::clean_tokens(fp_tokens);

		return(directory);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x9033(%rip), %rsi      # 0x2e6ef
callq 0x282b0
movq %rax, %rbx
movq 0x8(%rax), %rax
subq (%rbx), %rax
cmpq $0x8, %rax
jne 0x256d6
xorl %r14d, %r14d
jmp 0x2574c
movq %r14, %rdi
callq 0x26856
addl $0x2, %eax
movslq %eax, %rdi
callq 0x2040
movq %rax, %r14
movb $0x0, (%rax)
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpl $0x2, %edx
jl 0x2574c
xorl %r15d, %r15d
movabsq $-0x100000000, %r12     # imm = 0xFFFFFFFF00000000
cmpq %r15, %rdx
jbe 0x25763
movq (%rax,%r15,8), %rdi
callq 0x26fb2
movq %r14, %rdi
movq %rax, %rsi
callq 0x22f0
incq %r15
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
movq %rcx, %rdx
sarq $0x3, %rdx
shlq $0x1d, %rcx
addq %r12, %rcx
sarq $0x20, %rcx
cmpq %rcx, %r15
jl 0x2570f
movq %rbx, %rdi
callq 0x28630
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x7166(%rip), %rdi      # 0x2c8d0
movq %r15, %rsi
xorl %eax, %eax
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_utils.cpp
// Function: load_directory_files(char*, char*)
vector<char*>* load_directory_files(char* root_dir, char* extension)
{
        char ls_cmd[1000];

		if(extension != NULL)
		{
			sprintf(ls_cmd, "ls -d %s/*.%s | xargs -Ifiles basename files > cmd_op.txt", root_dir, extension);
			system(ls_cmd);
		}
		else
		{
			sprintf(ls_cmd, "ls -d %s/* | xargs -Ifiles basename files > cmd_op.txt", root_dir);
			system(ls_cmd);
		}

        vector<char*>* dir_files = new vector<char*>();

        FILE* f_cmd_op = fopen("cmd_op.txt", "r");
        char current_fn[1000];
        while(fscanf(f_cmd_op, "%s", current_fn) == 1)
        {
                char* new_fn = new char[t_string::string_length(current_fn) + 3];
                strcpy(new_fn, current_fn);
                dir_files->push_back(new_fn);
        }
        fclose(f_cmd_op);

		// Erase the file.
        sprintf(ls_cmd, "rm -f cmd_op.txt");
        system(ls_cmd);

        return(dir_files);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7e8, %rsp            # imm = 0x7E8
movq %rdi, %rdx
testq %rsi, %rsi
je 0x257a5
movq %rsi, %rcx
leaq 0x8f5b(%rip), %rsi      # 0x2e6f2
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
callq 0x2080
jmp 0x257b8
leaq 0x8f80(%rip), %rsi      # 0x2e72c
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
callq 0x2080
leaq 0x10(%rsp), %rdi
callq 0x2140
movl $0x18, %edi
callq 0x2180
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq 0x8f74(%rip), %rdi      # 0x2e758
leaq 0x751d(%rip), %rsi      # 0x2cd08
callq 0x21c0
movq %rax, %r14
leaq 0x7d44(%rip), %rsi      # 0x2d53e
leaq 0x400(%rsp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x2320
cmpl $0x1, %eax
jne 0x2587f
leaq 0x400(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x7d19(%rip), %r13      # 0x2d53e
movq %r15, %rdi
callq 0x26856
addl $0x3, %eax
movslq %eax, %rdi
callq 0x2040
movq %rax, %rbp
movq %rax, 0x8(%rsp)
movq %rax, %rdi
movq %r15, %rsi
callq 0x2150
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2585f
movq %rbp, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x2586a
movq %rbx, %rdi
movq %r12, %rdx
callq 0x12a12
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2320
cmpl $0x1, %eax
je 0x25825
movq %r14, %rdi
callq 0x2170
movups 0x8ed5(%rip), %xmm0     # 0x2e763
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movb $0x0, 0x10(%rdi)
callq 0x2140
movq %rbx, %rax
addq $0x7e8, %rsp            # imm = 0x7E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_utils.cpp
// Function: get_file_size(char*)
long int get_file_size(char* fp)
{
	FILE* f = NULL;

	// If the file is "stdin", load the standard input.
	if(strcmp(fp, "stdin") == 0)
	{
		fprintf(stderr, "Cannot buffer stdin.\n");
		return(-1);
	}
	else
	{
		// Open the file if it is not the stdin.
		f = fopen(fp, "rb");
		if (f == NULL) 
		{ 
			fprintf(stderr, "Could not open %s\n", fp);
			return(-1);
		} 
	}

	fseek(f, 0, SEEK_END);
	long int file_size = ftell(f);
	fprintf(stderr, "Loading %s of %ld bytes.\n", fp, file_size);

	return(file_size);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7a3b(%rip), %rsi      # 0x2d2fd
callq 0x2240
testl %eax, %eax
jne 0x258d2
callq 0x5726
jmp 0x25901
leaq 0x8657(%rip), %rsi      # 0x2df30
movq %rbx, %rdi
callq 0x21c0
testq %rax, %rax
jne 0x2590a
movq 0x136f3(%rip), %rax     # 0x38fe0
movq (%rax), %rdi
leaq 0x7a8a(%rip), %rsi      # 0x2d381
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2250
movq $-0x1, %r14
jmp 0x25945
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x21a0
movq %r14, %rdi
callq 0x2030
movq %rax, %r14
movq 0x136b2(%rip), %rax     # 0x38fe0
movq (%rax), %rdi
leaq 0x8e52(%rip), %rsi      # 0x2e78a
movq %rbx, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x2250
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_utils.cpp
// Function: load_file(char*)
t_file_buffer* load_file(char* fp)
{
	FILE* f = NULL;

	// If the file is "stdin", load the standard input.
	if(strcmp(fp, "stdin") == 0)
	{
		fprintf(stderr, "Cannot buffer stdin.\n");
		return(NULL);
	}
	else
	{
		// Open the file if it is not the stdin.
		f = fopen(fp, "rb");
		if (f == NULL) 
		{ 
			fprintf(stderr, "Could not open %s\n", fp);
			return(NULL);
		} 
	}

	fseek(f, 0, SEEK_END);
	long int file_size = ftell(f);
if(__DUMP_UTIL_MESSAGES__)
{
	fprintf(stderr, "Loading %s of %ld bytes.\n", fp, file_size);
}

	fseek(f, 0, SEEK_SET);
	char* file_buff = new char[file_size + 1];

if(__DUMP_UTIL_MESSAGES__)
{
	fprintf(stderr, "Allocated buffer memory.\n");
}

	if (file_size != (long int)fread(file_buff, sizeof(char), file_size, f)) 
	{ 
		delete [] file_buff;
		return NULL;
	}

if(__DUMP_UTIL_MESSAGES__)
{
	fprintf(stderr, "Read successfully.\n");
}

	fclose(f);
	file_buff[file_size] = 0;

	t_file_buffer* file_buffer = new t_file_buffer();
	file_buffer->file_buffer = file_buff;
	file_buffer->f_ptr = 0;
	file_buffer->l_file = file_size;

	return file_buffer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
leaq 0x799e(%rip), %rsi      # 0x2d2fd
callq 0x2240
testl %eax, %eax
je 0x25a36
leaq 0x85bd(%rip), %rsi      # 0x2df30
movq %r15, %rdi
callq 0x21c0
testq %rax, %rax
je 0x25a3d
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x21a0
movq %rbx, %rdi
callq 0x2030
movq %rax, %r14
cmpb $0x1, 0x1382c(%rip)     # 0x391d4
je 0x25a5c
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21a0
leaq 0x1(%r14), %rdi
callq 0x2040
movq %rax, %r15
cmpb $0x1, 0x13807(%rip)     # 0x391d4
je 0x25a7f
movl $0x1, %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2260
cmpq %rax, %r14
jne 0x25a23
cmpb $0x1, 0x137e2(%rip)     # 0x391d4
je 0x25a89
movq %rbx, %rdi
callq 0x2170
movb $0x0, (%r15,%r14)
movl $0x18, %edi
callq 0x2180
movq %rax, %rbx
movq %r15, (%rax)
movq $0x0, 0x8(%rax)
movq %r14, 0x10(%rax)
jmp 0x25a2d
movq %r15, %rdi
callq 0x2220
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x577a
jmp 0x25a2b
movq 0x1359c(%rip), %rax     # 0x38fe0
movq (%rax), %rdi
leaq 0x7933(%rip), %rsi      # 0x2d381
xorl %ebx, %ebx
movq %r15, %rdx
xorl %eax, %eax
callq 0x2250
jmp 0x25a2d
movq 0x1357d(%rip), %rax     # 0x38fe0
movq (%rax), %rdi
leaq 0x8d1d(%rip), %rsi      # 0x2e78a
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x2250
jmp 0x259ae
callq 0x5742
jmp 0x259d3
callq 0x575e
jmp 0x259f8
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_utils.cpp
// Function: get_next_string(_IO_FILE*, char*, int)
int get_next_string(FILE* file, char* buff, int buff_size)
{
	memset(buff, 0, buff_size);

	int i_s = 0;
	int ret = 0;
	ret = getc(file);
	while(ret != ' ' && ret != EOF && ret != '\n' && ret != '\t')
	{		
		buff[i_s] = ret;
		i_s++;
		ret = getc(file);
	} // file reading loop.

	return(ret);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movslq %edx, %rdx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x20f0
movabsq $0x200000c01, %r15      # imm = 0x200000C01
movq %r14, %rdi
callq 0x20a0
movl %eax, %ecx
incl %ecx
cmpl $0x21, %ecx
ja 0x25aeb
btq %rcx, %r15
jb 0x25af2
movb %al, (%rbx)
incq %rbx
jmp 0x25ad4
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_utils.cpp
// Function: buffer_file(char*)
vector<char*>* buffer_file(char* fp)
{
	vector<char*>* file_lines = new vector<char*>();
	//printf("Buffering %s.\n", fp);

	int n_lines = 0;
	FILE* f = NULL;

	if(strcmp(fp, "stdin") == 0)
	{
		f = stdin;	
	}
	else
	{
		f = fopen(fp, "r");
	}

	if(f == NULL)
	{
		//fprintf(stderr, "Could not open %s\n", fp);
		return(NULL);
	}
	while(1)
	{
		char* new_line = getline(f);
		if(new_line == NULL)
		{
			break;
		}
		file_lines->push_back(new_line);

		n_lines++;

if(__DUMP_UTIL_MESSAGES__)
{
		if((n_lines % 10000) == 0)
		{
			printf("Loaded %d lines.               \r", n_lines);
		}
}
	} // file buffering loop.

if(__DUMP_UTIL_MESSAGES__)
{
	fprintf(stderr, "\n");
}

	fclose(f);

	return(file_lines);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0x18, %edi
callq 0x2180
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq 0x77d5(%rip), %rsi      # 0x2d2fd
movq %r14, %rdi
callq 0x2240
testl %eax, %eax
je 0x25b48
leaq 0x71cd(%rip), %rsi      # 0x2cd08
movq %r14, %rdi
callq 0x21c0
movq %rax, %r14
jmp 0x25b52
movq 0x13489(%rip), %rax     # 0x38fd8
movq (%rax), %r14
testq %r14, %r14
je 0x25c0a
movq %r14, %rdi
callq 0x25c1e
movq %rax, (%rsp)
testq %rax, %rax
je 0x25be3
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movl $0x1, %ebp
movl $0xd1b71759, %r15d      # imm = 0xD1B71759
leaq 0x8c4e(%rip), %r12      # 0x2e7d2
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x25b98
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x25ba3
movq %rbx, %rdi
movq %rsp, %rdx
callq 0x12a12
cmpb $0x1, 0x1362a(%rip)     # 0x391d4
jne 0x25bcd
movl %ebp, %eax
imulq %r15, %rax
shrq $0x2d, %rax
imull $0x2710, %eax, %eax     # imm = 0x2710
addl %r13d, %eax
jne 0x25bcd
movq %r12, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x2050
movq %r14, %rdi
callq 0x25c1e
movq %rax, (%rsp)
decl %r13d
incl %ebp
testq %rax, %rax
jne 0x25b84
cmpb $0x1, 0x135ea(%rip)     # 0x391d4
jne 0x25c00
movq 0x133ed(%rip), %rax     # 0x38fe0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x2210
movq %r14, %rdi
callq 0x2170
jmp 0x25c0c
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_utils.cpp
// Function: getline(_IO_FILE*)
char* getline(FILE* file)
{
	vector<char>* line_vec = new vector<char>();

	char ret = 0;
	while(1)
	{
		ret = getc(file);

		if(ret == EOF)
		{
			break;
		}
		else if(ret == '\n')
		{
			break;
		}

		// Add this character to the vector of characters.
		line_vec->push_back(ret);
	} // file reading loop.

	// If the end-of-file is encountered and there was nothing read, return NULL to indicate the there is nothing left to read and EOF is reached.
	if(ret == EOF && 
		line_vec->size() == 0)
	{
		delete(line_vec);
		return(NULL);
	}

	char* buff = new char[line_vec->size() + 2];
	memset(buff, 0, sizeof(char) * (line_vec->size() + 2));

	// Copy the vector to buffer.
	for(int i = 0; i < (int)line_vec->size(); i++)
	{
		buff[i] = line_vec->at(i);
	} // i loop.

	delete(line_vec);

	return(buff);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl $0x18, %edi
callq 0x2180
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
leaq 0xf(%rsp), %r15
movb $0x0, (%r15)
movq %r14, %rdi
callq 0x20a0
movb %al, 0xf(%rsp)
cmpb $0xa, %al
je 0x25ca2
movzbl %al, %ecx
cmpl $0xff, %ecx
je 0x25c8c
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x25c7f
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x25c52
movq %rbx, %rdi
movq %r15, %rdx
callq 0x25fc6
jmp 0x25c52
movq (%rbx), %r14
movq 0x8(%rbx), %r12
cmpq %r14, %r12
jne 0x25ca9
xorl %r15d, %r15d
testq %r12, %r12
jne 0x25cf4
jmp 0x25d03
movq (%rbx), %r14
movq 0x8(%rbx), %r12
subq %r14, %r12
leaq 0x2(%r12), %r13
movq %r13, %rdi
callq 0x2040
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x20f0
testl %r12d, %r12d
jle 0x25cef
movl %r12d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
cmpq %rcx, %r12
je 0x25d21
movb (%r14,%rcx), %dl
movb %dl, (%r15,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x25cd8
jmp 0x25cf4
testq %r14, %r14
je 0x25d03
movq 0x10(%rbx), %rsi
subq %r14, %rsi
movq %r14, %rdi
callq 0x2190
movl $0x18, %esi
movq %rbx, %rdi
callq 0x2190
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x6ba8(%rip), %rdi      # 0x2c8d0
movq %r12, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_utils.cpp
// Function: check_file(char*)
bool check_file(char* fp)
{
	FILE* f_temp = fopen(fp, "r");
	if(f_temp == NULL)
	{		
		return(false);
	}

	fclose(f_temp);
	return(true);
}

// Assembly:
pushq %rbx
leaq 0x6fcb(%rip), %rsi      # 0x2cd08
callq 0x21c0
movq %rax, %rbx
testq %rax, %rax
je 0x25d52
movq %rbx, %rdi
callq 0x2170
testq %rbx, %rbx
setne %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_utils.cpp
// Function: open_f(char const*, char const*)
FILE* open_f(const char* fp, const char* mode)
{
	if(fp == NULL || mode == NULL)
	{
		printf("Invalid arguments to open_f for %s.\n", fp);
		exit(0);
	}

	FILE* f = fopen(fp, mode);

	if(f == NULL)
	{
		if(mode[0] == 'r')
		{
			printf("Could not open %s for reading.\n", fp);
			exit(0);
		}
		else if(mode[0] == 'w')
		{
			printf("Could not open %s for writing.\n", fp);
			exit(0);
		}
		else
		{
			printf("Could not open %s for requested operation.\n", fp);
			exit(0);
		}
	}

	return(f);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x25d86
movq %rsi, %r14
testq %rsi, %rsi
je 0x25d86
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21c0
testq %rax, %rax
je 0x25d8f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x8a66(%rip), %rdi      # 0x2e7f3
jmp 0x25db6
movzbl (%r14), %eax
cmpl $0x77, %eax
je 0x25da6
cmpl $0x72, %eax
jne 0x25daf
leaq 0x8a74(%rip), %rdi      # 0x2e818
jmp 0x25db6
leaq 0x8a8b(%rip), %rdi      # 0x2e838
jmp 0x25db6
leaq 0x8aa2(%rip), %rdi      # 0x2e858
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2050
xorl %edi, %edi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_utils.cpp
// Function: get_n_non_empty_lines(char*)
int get_n_non_empty_lines(char* fp)
{
	int n_lines = 0;
	FILE* f = open_f(fp, "r");
	while(1)
	{
		char* cur_line = getline(f);
		if(cur_line == NULL)
		{
			break;
		}

		if(!line_empty(cur_line))
		{
			n_lines++;
		}

		delete [] cur_line;
	}
	fclose(f);

	return(n_lines);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
leaq 0x6f36(%rip), %rsi      # 0x2cd08
callq 0x25d5a
movq %rax, %rbx
movq %rax, %rdi
callq 0x25c1e
testq %rax, %rax
je 0x25e15
movq %rax, %r14
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x25e26
xorb $0x1, %al
movzbl %al, %eax
addl %eax, %ebp
movq %r14, %rdi
callq 0x2220
movq %rbx, %rdi
callq 0x25c1e
movq %rax, %r14
testq %rax, %rax
jne 0x25dec
jmp 0x25e17
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x2170
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_utils.cpp
// Function: line_empty(char*)
bool line_empty(char* line)
{
	int l = t_string::string_length(line);
	for(int i = 0; i < l; i++)
	{
		if(line[i] != ' ' &&
			line[i] != '\t' &&
			line[i] != '\n')
		{
			return(false);
		}
	}

	return(true);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x26856
testl %eax, %eax
jle 0x25e76
movl %eax, %ecx
movq %rcx, %rdx
negq %rdx
movl $0x1, %esi
xorl %eax, %eax
movabsq $0x100000600, %rdi      # imm = 0x100000600
movzbl -0x1(%rbx,%rsi), %r8d
cmpq $0x20, %r8
ja 0x25e78
btq %r8, %rdi
jae 0x25e78
cmpq %rcx, %rsi
setae %al
leaq (%rdx,%rsi), %r8
incq %r8
incq %rsi
cmpq $0x1, %r8
jne 0x25e4c
jmp 0x25e78
movb $0x1, %al
andb $0x1, %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_utils.cpp
// Function: get_next_char_per_file_buffer(t_file_buffer*, char&)
bool get_next_char_per_file_buffer(t_file_buffer* file_buffer, char& char_val)
{
	if(file_buffer->f_ptr < file_buffer->l_file)
	{
		char_val = file_buffer->file_buffer[file_buffer->f_ptr];
		file_buffer->f_ptr++;
		return(true);
	}
	else
	{
		char_val = 0;
		return(false);
	}
}

// Assembly:
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
cmpq %rcx, %rax
jge 0x25e97
movq (%rdi), %rdx
movb (%rdx,%rax), %dl
movb %dl, (%rsi)
incq 0x8(%rdi)
jmp 0x25e9a
movb $0x0, (%rsi)
cmpq %rcx, %rax
setl %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_utils.cpp
// Function: get_next_token_per_file_till_newline(_IO_FILE*, char*, int, char*, bool&, bool&)
bool get_next_token_per_file_till_newline(FILE* file, char* buffer, int l_buffer, char* delim_char, bool& new_line_check, bool& eof_check)
{
	int i_buff = 0;
	char ret = 0;
	new_line_check = false;
	eof_check = false;
	while(1)
	{
		ret = getc(file);

		if(ret == EOF)
		{
			eof_check = true;
			return(false);
		}

		// If we found a new line, break. The file pointer points to the new line's beginning.
		if(ret == '\n')
		{
			new_line_check = true;
			break;
		}

		// The current character is not a new line, is it the delimiter?
		if(ret == delim_char[0])
		{
			break;
		}
		else if(i_buff < l_buffer)
		{
			// Copy the read character to the buffer, if the buffer did not overflow, otherwise does not copy but keeps reading the file till the next token is found.
			buffer[i_buff] = ret;
			i_buff++;
		}
	} // file reading loop.

	if(i_buff < l_buffer)
	{
		buffer[i_buff] = 0;
	}
	else
	{
		buffer[l_buffer-1] = 0;
	}
	
	if(i_buff == 0)
	{
		return(false);
	}
	else
	{
		return(true);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %r12
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r13
xorl %r14d, %r14d
movb %r14b, (%r8)
movq %r9, (%rsp)
movb %r14b, (%r9)
movq %r13, %rdi
callq 0x20a0
movl %eax, %ecx
shll $0x18, %ecx
cmpl $0xa000000, %ecx        # imm = 0xA000000
je 0x25f3c
cmpl $0xff000000, %ecx       # imm = 0xFF000000
je 0x25f31
sarl $0x18, %ecx
movsbl (%r12), %edx
cmpl %edx, %ecx
je 0x25f40
cmpl %ebp, %r14d
jge 0x25ef8
movl %r14d, %ecx
movb %al, (%rbx,%rcx)
incl %r14d
jmp 0x25ef8
movq (%rsp), %rax
movb $0x1, (%rax)
xorl %eax, %eax
jmp 0x25f5e
movb $0x1, (%r15)
movl %r14d, %eax
addq %rbx, %rax
cmpl %ebp, %r14d
movslq %ebp, %rcx
leaq -0x1(%rbx,%rcx), %rcx
cmovlq %rax, %rcx
movb $0x0, (%rcx)
testl %r14d, %r14d
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_utils.cpp
// Function: x_fgets(char*, int, _IO_FILE*)
char* x_fgets(char* buff, int size, FILE* file)
{
	if(fgets(buff, size, file) == NULL)
	{
		return(NULL);
	}

	if(buff[t_string::string_length(buff) - 1] == '\n')
	{
		int i_new_line_char = (int)t_string::string_length(buff) - 1;
		buff[i_new_line_char] = 0;
	}

	return(buff);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x22a0
testq %rax, %rax
je 0x25fbe
movq %rbx, %rdi
callq 0x26856
cltq
cmpb $0xa, -0x1(%rbx,%rax)
jne 0x25fc0
movq %rbx, %rdi
callq 0x26856
cltq
movb $0x0, -0x1(%rbx,%rax)
jmp 0x25fc0
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
nop