LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/gersteinlab[P]MUSIC/src/ms_genome_sequence_tools.cpp
// Function: get_reverse_strand_RNA(char*, int, int)
char* get_reverse_strand_RNA(char* cur_aln_line, int i_nuc_min, int i_nuc_max)
{
	char* reverse_RNA = new char[i_nuc_max - i_nuc_min + 2];
	memset(reverse_RNA, 0, sizeof(char) * (i_nuc_max - i_nuc_min + 2));

	int i_rna_nuc = 0;
	for(int i_nuc = i_nuc_min; i_nuc <= i_nuc_max; i_nuc++)
	{
		if(cur_aln_line[i_nuc] == 'T')
		{
			reverse_RNA[i_rna_nuc] = 'U';
			i_rna_nuc++;
		}
		else if(cur_aln_line[i_nuc] == 't')
		{
			reverse_RNA[i_rna_nuc] = 'u';
			i_rna_nuc++;
		}
		else if(cur_aln_line[i_nuc] == 'A' || cur_aln_line[i_nuc] == 'a' ||
			cur_aln_line[i_nuc] == 'C' || cur_aln_line[i_nuc] == 'c' ||
			cur_aln_line[i_nuc] == 'G' || cur_aln_line[i_nuc] == 'g' ||
			cur_aln_line[i_nuc] == '-')
		{
			reverse_RNA[i_rna_nuc] = cur_aln_line[i_nuc];
			i_rna_nuc++;
		}
		else
		{
			printf("Found %c in the alignment line @ %s(%d):\n%s\n",  cur_aln_line[i_nuc], __FILE__, __LINE__, cur_aln_line);
			//exit(0);
			reverse_RNA[i_rna_nuc] = cur_aln_line[i_nuc];
			i_rna_nuc++;
		}
	} // i_nuc loop.

	return(reverse_RNA);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movl %edx, %eax
subl %esi, %eax
addl $0x2, %eax
movslq %eax, %r12
movq %r12, %rdi
callq 0x2040
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x20f0
subl %ebp, %ebx
jge 0x23066
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movslq %ebp, %rbp
incl %ebx
addq %r14, %rbp
movabsq $0x4500000045, %r12     # imm = 0x4500000045
xorl %r13d, %r13d
movb (%rbp,%r13), %al
movzbl %al, %ecx
leal -0x41(%rcx), %esi
cmpl $0x33, %esi
ja 0x230b3
btq %rsi, %r12
jae 0x230a1
movl %eax, %edx
movb %dl, (%r15,%r13)
incq %r13
cmpq %r13, %rbx
jne 0x2307b
jmp 0x23054
movb $0x55, %dl
cmpq $0x13, %rsi
je 0x23093
cmpq $0x33, %rsi
jne 0x230b3
movb $0x75, %dl
jmp 0x23093
cmpl $0x2d, %ecx
je 0x23091
movsbl %al, %esi
leaq 0xc2c2(%rip), %rdi      # 0x2f384
leaq 0xc2e8(%rip), %rdx      # 0x2f3b1
movl $0x239, %ecx            # imm = 0x239
movq %r14, %r8
xorl %eax, %eax
callq 0x2050
movb (%rbp,%r13), %dl
jmp 0x23093
// File: /workspace/github_cpp_makefile_star2_O1/gersteinlab[P]MUSIC/src/ms_profile_normalization.cpp
// Function: PeakSeq_slope(double*, double*, int)
double PeakSeq_slope(double* prof1_total_sigs_per_win, double* prof2_total_sigs_per_win, int n_processed_wins)
{
    // Compute the slope from 2 DOF (slope) LLS regression.
    double num = 0.0f;
    double den = 0.0f;

    double sx = 0.0f;
    double sy = 0.0f;
    double sxx = 0.0f;
    double sxy = 0.0f;

    for(int i = 0; i < n_processed_wins; i++)
    {
		sx += prof1_total_sigs_per_win[i];
		sy += prof2_total_sigs_per_win[i];
		sxx += prof1_total_sigs_per_win[i] * prof1_total_sigs_per_win[i];
		sxy += prof1_total_sigs_per_win[i] * prof2_total_sigs_per_win[i];

		//sx += control_frag_cnt->at(i);
		//sy += chip_seq_frag_cnt->at(i);
		//sxx += control_frag_cnt->at(i) * control_frag_cnt->at(i);
		//sxy += control_frag_cnt->at(i) * chip_seq_frag_cnt->at(i);
    } // i loop

    num = n_processed_wins * sxy - sx * sy;
    den = n_processed_wins * sxx - sx * sx;
	
	if(num == 0 || den == 0)
	{
		fprintf(stderr, "Normalization(1): Very low signal mapped.\n");
		return(1.0);
	}

	return(num / den);
}

// Assembly:
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
testl %edx, %edx
jle 0x234cc
movl %edx, %eax
xorl %ecx, %ecx
movsd (%rdi,%rcx,8), %xmm3
movapd %xmm3, %xmm4
movhpd (%rsi,%rcx,8), %xmm4    # xmm4 = xmm4[0],mem[0]
addpd %xmm4, %xmm2
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
mulpd %xmm4, %xmm3
addpd %xmm3, %xmm1
incq %rcx
cmpq %rcx, %rax
jne 0x234a6
xorps %xmm3, %xmm3
cvtsi2sd %edx, %xmm3
movapd %xmm2, %xmm4
unpcklpd %xmm2, %xmm4            # xmm4 = xmm4[0],xmm2[0]
mulpd %xmm2, %xmm4
unpcklpd %xmm3, %xmm3            # xmm3 = xmm3[0,0]
mulpd %xmm1, %xmm3
subpd %xmm4, %xmm3
cmpeqpd %xmm3, %xmm0
movmskpd %xmm0, %eax
testl %eax, %eax
jne 0x23505
movapd %xmm3, %xmm0
unpckhpd %xmm3, %xmm0            # xmm0 = xmm0[1],xmm3[1]
divsd %xmm3, %xmm0
retq
pushq %rax
callq 0x5541
movsd 0x7af5(%rip), %xmm0     # 0x2b008
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gersteinlab[P]MUSIC/src/ms_profile_normalization.cpp
// Function: slope(double*, double*, int)
double slope(double* prof1_total_sigs_per_win, double* prof2_total_sigs_per_win, int n_processed_wins)
{
	// Compute the slope from 1 DOF (slope) LLS regression.
	double num = 0.0f;
	double den = 0.0f;
	for(int i = 0; i < n_processed_wins; i++)
	{
		num += prof1_total_sigs_per_win[i] * prof2_total_sigs_per_win[i];
		den += prof1_total_sigs_per_win[i] * prof1_total_sigs_per_win[i];
		//num += control_frag_cnt->at(i) * chip_seq_frag_cnt->at(i);
		//den += control_frag_cnt->at(i) * control_frag_cnt->at(i);
	} // i loop

	if(num == 0 || den == 0)
	{
		fprintf(stderr, "Normalization(2): Very low signal mapped.\n");
		return(1.0);
	}

	return(num / den);
}

// Assembly:
testl %edx, %edx
jle 0x23548
movl %edx, %eax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
movsd (%rdi,%rcx,8), %xmm1
movsd (%rsi,%rcx,8), %xmm2
unpcklpd %xmm1, %xmm2            # xmm2 = xmm2[0],xmm1[0]
unpcklpd %xmm1, %xmm1            # xmm1 = xmm1[0,0]
mulpd %xmm2, %xmm1
addpd %xmm1, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x23524
jmp 0x2354c
xorpd %xmm0, %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jne 0x23558
jnp 0x2356d
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
ucomisd %xmm2, %xmm1
jne 0x23568
jnp 0x2356d
divsd %xmm1, %xmm0
retq
pushq %rax
callq 0x555d
movsd 0x7a8d(%rip), %xmm0     # 0x2b008
addq $0x8, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %edx, %ebp
movq %rsi, %rbx
xorpd %xmm3, %xmm3
movl %edx, %r14d
xorpd %xmm1, %xmm1
xorpd %xmm4, %xmm4
testl %edx, %edx
jle 0x235b4
xorl %eax, %eax
addsd (%rdi,%rax,8), %xmm1
addsd (%rbx,%rax,8), %xmm4
incq %rax
cmpq %rax, %r14
jne 0x235a2
cvtsi2sd %ebp, %xmm0
divsd %xmm0, %xmm1
divsd %xmm0, %xmm4
testl %ebp, %ebp
jle 0x235ec
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 0x235ca
movsd %xmm4, 0x10(%rsp)
movsd %xmm3, 0x18(%rsp)
xorpd %xmm0, %xmm0
testl %ebp, %ebp
jle 0x2361b
xorl %eax, %eax
movsd (%rdi,%rax,8), %xmm2
subsd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rax
cmpq %rax, %r14
jne 0x23602
movsd 0x7a35(%rip), %xmm1     # 0x2b058
callq 0x22d0
movsd %xmm0, 0x8(%rsp)
testl %ebp, %ebp
movsd 0x10(%rsp), %xmm1
xorpd %xmm0, %xmm0
jle 0x23657
xorl %eax, %eax
movsd (%rbx,%rax,8), %xmm2
subsd %xmm1, %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rax
cmpq %rax, %r14
jne 0x2363e
movsd 0x79f9(%rip), %xmm1     # 0x2b058
callq 0x22d0
movsd 0x8(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
divsd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x236a5
movsd 0x7978(%rip), %xmm1     # 0x2b008
movapd %xmm1, %xmm2
movapd %xmm1, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm2
decl %edi
jne 0x23698
retq
movsd 0x795b(%rip), %xmm0     # 0x2b008
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
setg %al
jle 0x236fb
movl %edx, %edi
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
cmpq %rcx, %rdx
je 0x236ff
movq (%rsi), %r10
movq 0x8(%rsi), %r8
subq %r10, %r8
sarq $0x2, %r8
cmpq %rcx, %r8
jbe 0x2370b
movl (%r9,%rcx,4), %r8d
cmpl (%r10,%rcx,4), %r8d
jg 0x236fb
incq %rcx
cmpq %rdi, %rcx
setb %al
jne 0x236ce
andb $0x1, %al
popq %rcx
retq
leaq 0xa1d0(%rip), %rdi      # 0x2d8d6
movq %rdx, %rsi
jmp 0x23718
leaq 0xa1c4(%rip), %rdi      # 0x2d8d6
movq %rcx, %rsi
movq %r8, %rdx
xorl %eax, %eax
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/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
setle %al
jle 0x2376c
movl %edx, %edi
andl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
xorl %ecx, %ecx
cmpq %rcx, %rdx
je 0x23770
movq (%rsi), %r10
movq 0x8(%rsi), %r8
subq %r10, %r8
sarq $0x2, %r8
cmpq %rcx, %r8
jbe 0x2377c
movl (%r9,%rcx,4), %r8d
cmpl (%r10,%rcx,4), %r8d
jne 0x2376c
incq %rcx
cmpq %rdi, %rcx
setae %al
jne 0x2373f
andb $0x1, %al
popq %rcx
retq
leaq 0xa15f(%rip), %rdi      # 0x2d8d6
movq %rdx, %rsi
jmp 0x23789
leaq 0xa153(%rip), %rdi      # 0x2d8d6
movq %rcx, %rsi
movq %r8, %rdx
xorl %eax, %eax
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/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 0x237df
cmpq %r9, %rdx
je 0x237f3
cmpq %r9, %r8
je 0x237ea
leaq 0x1(%r9), %r10
movl (%rax,%r9,4), %r11d
cmpl 0x4(%rax,%r9,4), %r11d
jne 0x237be
movslq %ecx, %rax
cmpq %rax, %r9
setge %al
popq %rcx
retq
leaq 0xa0e5(%rip), %rdi      # 0x2d8d6
jmp 0x237fd
leaq 0xa0dc(%rip), %rdi      # 0x2d8d6
movq %rdx, %rsi
xorl %eax, %eax
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/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), %r9
movq 0x8(%rdi), %rdx
subq %r9, %rdx
sarq $0x2, %rdx
testl %edx, %edx
setg %al
jle 0x238df
movl %edx, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
decq %rcx
cmpq %rcx, %rdx
jbe 0x238f2
movq (%rsi), %rdi
movq 0x8(%rsi), %r8
subq %rdi, %r8
sarq $0x2, %r8
cmpq %rcx, %r8
jbe 0x238e3
movl (%r9,%rcx,4), %r8d
incl %r8d
cmpl (%rdi,%rcx,4), %r8d
jl 0x238db
movl $0x0, (%r9,%rcx,4)
leaq -0x1(%rcx), %rdi
incq %rcx
cmpq $0x2, %rcx
setge %al
movq %rdi, %rcx
jge 0x23899
jmp 0x238df
movl %r8d, (%r9,%rcx,4)
andb $0x1, %al
popq %rcx
retq
leaq 0x9fec(%rip), %rdi      # 0x2d8d6
movq %rcx, %rsi
movq %r8, %rdx
jmp 0x238fc
leaq 0x9fdd(%rip), %rdi      # 0x2d8d6
movq %rcx, %rsi
xorl %eax, %eax
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/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 0x23a1e
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 0xbb2d(%rip), %rsi      # 0x2f478
movl %r15d, %edx
xorl %eax, %eax
callq 0x2080
movq %r12, %rdi
leaq 0x814f(%rip), %rsi      # 0x2baae
callq 0x21c0
movq %rax, %r13
xorps %xmm0, %xmm0
callq 0x25878
xorps %xmm1, %xmm1
cvtsi2sd %r15d, %xmm1
movsd %xmm0, 0x10(%rsp)
mulsd 0xb75b(%rip), %xmm1     # 0x2f0e0
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 0x259e1
movaps %xmm0, %xmm1
movsd 0x28(%rsp), %xmm0
callq 0x25a1c
movsd 0x20(%rsp), %xmm1
callq 0x259e1
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
callq 0x258cc
movq %r13, %rdi
leaq 0xa8a5(%rip), %rsi      # 0x2e285
movl %r12d, %edx
movsd %xmm0, 0x10(%rsp)
movb $0x1, %al
callq 0x2250
incq %r12
addq $-0x8, %rbp
cmpq %r12, %r14
jne 0x23993
movq %r13, %rdi
callq 0x2170
incq %r15
incq %r14
movq 0x18(%rsp), %rbp
addq $0x8, %rbp
cmpq 0x8(%rsp), %r15
jne 0x2393c
addq $0x418, %rsp            # imm = 0x418
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, (%rsp)
movslq %edi, %r15
leaq 0x10(,%r15,8), %rdi
cmpl $-0x2, %r15d
movq $-0x1, %rax
cmovlq %rax, %rdi
callq 0x2040
movq %rax, 0x8(%rsp)
testl %r15d, %r15d
js 0x23b6e
movq (%rsp), %rax
incl %eax
movq %rax, (%rsp)
movl $0x1, %r12d
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 0x25878
xorps %xmm1, %xmm1
cvtsi2sd %r13d, %xmm1
mulsd 0xb60a(%rip), %xmm1     # 0x2f0e0
movsd %xmm1, 0x20(%rsp)
movq %rbp, 0x10(%rsp)
xorl %r15d, %r15d
movsd %xmm0, 0x30(%rsp)
movsd (%r14,%r13,8), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd (%r14,%r15,8), %xmm0
movsd (%rbp), %xmm1
callq 0x259e1
movaps %xmm0, %xmm1
movsd 0x28(%rsp), %xmm0
callq 0x25a1c
movsd 0x20(%rsp), %xmm1
callq 0x259e1
movaps %xmm0, %xmm1
movsd 0x30(%rsp), %xmm0
callq 0x258cc
movl %r15d, %eax
cltd
idivl %ebx
testl %edx, %edx
jne 0x23b49
movl %r15d, %eax
cltd
idivl %ebx
cltq
movq 0x18(%rsp), %rcx
movsd %xmm0, (%rcx,%rax,8)
incq %r15
addq $-0x8, %rbp
cmpq %r15, %r12
jne 0x23ae4
incq %r13
incq %r12
movq 0x10(%rsp), %rbp
addq $0x8, %rbp
cmpq (%rsp), %r13
jne 0x23a8a
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_O1/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 0x23bad
movl %esi, %r14d
incl %r14d
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
testq %rdi, %rdi
je 0x23ba5
callq 0x2220
incq %r15
cmpq %r15, %r14
jne 0x23b97
testq %rbx, %rbx
je 0x23bbf
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2220
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movslq %edi, %r15
leaq 0x10(,%r15,8), %rax
cmpl $-0x2, %r15d
movq $-0x1, %rdi
cmovgeq %rax, %rdi
callq 0x2040
movq %rax, %r14
movsd 0x740e(%rip), %xmm0     # 0x2b008
callq 0x25878
movsd %xmm0, (%r14)
testl %r15d, %r15d
jle 0x23c48
incl %ebx
movl $0x1, %r15d
movsd -0x8(%r14,%r15,8), %xmm0
movsd %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %r15d, %xmm0
callq 0x25878
movapd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
callq 0x259e1
movsd %xmm0, (%r14,%r15,8)
incq %r15
cmpq %r15, %rbx
jne 0x23c11
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %rcx
movq 0x8(%r14), %rdx
subq %rcx, %rdx
sarq $0x2, %rdx
movl $0x1, %eax
testl %edx, %edx
jle 0x23cbf
movl %edx, %esi
andl $0x7fffffff, %esi       # imm = 0x7FFFFFFF
decq %rsi
cmpq %rsi, %rdx
jbe 0x23d18
movl (%rcx,%rsi,4), %edi
incl %edi
cmpl %ebp, %edi
jl 0x23cae
movl $0x0, (%rcx,%rsi,4)
leaq -0x1(%rsi), %rdi
incq %rsi
cmpq $0x1, %rsi
movq %rdi, %rsi
jg 0x23c83
jmp 0x23cbf
movl %edi, (%rcx,%rsi,4)
movq %r14, %rdi
callq 0x23804
movzbl %al, %eax
leal (%rax,%rax,2), %eax
testl %eax, %eax
je 0x23c61
cmpl $0x1, %eax
jne 0x23ccc
xorl %eax, %eax
jmp 0x23d13
movq (%r14), %rdi
movq 0x8(%r14), %rdx
subq %rdi, %rdx
sarq $0x2, %rdx
movb $0x1, %al
testl %edx, %edx
jle 0x23d13
movl %edx, %r8d
andl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
xorl %esi, %esi
cmpq %rsi, %rdx
je 0x23d26
movq (%rbx), %r9
movq 0x8(%rbx), %rcx
subq %r9, %rcx
sarq $0x2, %rcx
cmpq %rsi, %rcx
jbe 0x23d32
movl (%rdi,%rsi,4), %ecx
movl %ecx, (%r9,%rsi,4)
incq %rsi
cmpq %rsi, %r8
jne 0x23cec
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x9bb7(%rip), %rdi      # 0x2d8d6
xorl %eax, %eax
callq 0x2270
leaq 0x9ba9(%rip), %rdi      # 0x2d8d6
movq %rdx, %rsi
jmp 0x23d1f
leaq 0x9b9d(%rip), %rdi      # 0x2d8d6
movq %rcx, %rdx
jmp 0x23d1f
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x23d59
cmpl $0x41, %eax
je 0x23d6b
cmpl $0x43, %eax
jne 0x23d67
movb $0x47, %al
jmp 0x23d71
cmpl $0x47, %eax
je 0x23d6f
cmpl $0x54, %eax
jne 0x23d67
movb $0x41, %al
jmp 0x23d71
movb $0x4e, %al
jmp 0x23d71
movb $0x54, %al
jmp 0x23d71
movb $0x43, %al
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
callq 0x2330
movl %eax, %ebp
xorl %eax, %eax
cmpl $0x46, %ebp
jle 0x23dbc
cmpl $0x47, %ebp
je 0x23e15
cmpl $0x54, %ebp
je 0x23e41
cmpl $0x55, %ebp
jne 0x23e62
movsbl %bl, %edi
callq 0x2330
cmpl $0x41, %eax
sete %cl
cmpl $0x47, %eax
sete %al
orb %cl, %al
jmp 0x23e62
cmpl $0x41, %ebp
je 0x23df0
cmpl $0x43, %ebp
jne 0x23e62
movsbl %bl, %edi
callq 0x2330
movl %eax, %ecx
movb $0x1, %al
cmpl $0x47, %ecx
je 0x23e62
cmpl $0x55, %ebp
je 0x23da1
cmpl $0x54, %ebp
je 0x23e41
cmpl $0x47, %ebp
je 0x23e15
jmp 0x23e60
movsbl %bl, %edi
callq 0x2330
movl %eax, %ecx
andl $-0x2, %ecx
movb $0x1, %al
cmpl $0x54, %ecx
je 0x23e62
xorl %eax, %eax
cmpl $0x53, %ebp
jg 0x23d8f
cmpl $0x43, %ebp
je 0x23dca
cmpl $0x47, %ebp
jne 0x23e62
movsbl %bl, %edi
callq 0x2330
movl %eax, %ecx
addl $-0x43, %ecx
cmpl $0x12, %ecx
ja 0x23e33
movb $0x1, %al
movl $0x60001, %edx          # imm = 0x60001
btl %ecx, %edx
jb 0x23e62
cmpl $0x55, %ebp
je 0x23da1
cmpl $0x54, %ebp
jne 0x23e60
movsbl %bl, %edi
callq 0x2330
movl %eax, %ecx
movb $0x1, %al
cmpl $0x41, %ecx
je 0x23e62
cmpl $0x47, %ecx
je 0x23e62
cmpl $0x55, %ebp
je 0x23da1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x23f37
cmpl $0x41, %eax
je 0x23f43
cmpl $0x43, %eax
je 0x23f47
cmpl $0x47, %eax
jne 0x23f4b
movb $0x43, %al
jmp 0x23f4d
addl $-0x54, %eax
cmpl $0x2, %eax
jae 0x23f4b
movb $0x41, %al
jmp 0x23f4d
movb $0x54, %al
jmp 0x23f4d
movb $0x47, %al
jmp 0x23f4d
movb $0x4e, %al
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x23f68
cmpl $0x41, %eax
je 0x23f7a
cmpl $0x43, %eax
jne 0x23f76
movb $0x47, %al
jmp 0x23f80
cmpl $0x47, %eax
je 0x23f7e
cmpl $0x55, %eax
jne 0x23f76
movb $0x41, %al
jmp 0x23f80
movb $0x4e, %al
jmp 0x23f80
movb $0x55, %al
jmp 0x23f80
movb $0x43, %al
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9d54(%rip), %xmm0     # 0x2f628
jne 0x258dc
jnp 0x2595d
ucomisd 0x9d44(%rip), %xmm1     # 0x2f628
jne 0x258ee
jp 0x258ee
movapd %xmm0, %xmm1
jmp 0x2595d
pushq %rax
ucomisd %xmm1, %xmm0
jbe 0x25914
movsd %xmm0, (%rsp)
subsd %xmm0, %xmm1
ucomisd 0x9d22(%rip), %xmm1     # 0x2f628
jne 0x25933
jp 0x25933
movsd 0x56f6(%rip), %xmm0     # 0x2b008
jmp 0x2594b
subsd %xmm1, %xmm0
ucomisd 0x9d08(%rip), %xmm0     # 0x2f628
jne 0x25939
jp 0x25939
movsd 0x56dc(%rip), %xmm0     # 0x2b008
movsd %xmm1, (%rsp)
jmp 0x2594b
movapd %xmm1, %xmm0
jmp 0x2593e
movsd %xmm1, (%rsp)
callq 0x2300
addsd 0x56bd(%rip), %xmm0     # 0x2b008
callq 0x25878
movapd %xmm0, %xmm1
addsd (%rsp), %xmm1
addq $0x8, %rsp
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/gersteinlab[P]MUSIC/src/ms_xlog_math.cpp
// Function: xlog_max(double, double)
double xlog_max(double log_val1, double log_val2)
{
	if(xlog_comp(log_val1, log_val2))
	{
		return(log_val1);
	}
	else if(log_val1 > log_val2)
	{
		return(log_val1);
	}
	else
	{
		return(log_val2);
	}
}

// Assembly:
movb $0x1, %al
ucomisd %xmm1, %xmm0
jne 0x25aef
jnp 0x25b1d
movsd 0x9b39(%rip), %xmm2     # 0x2f630
addsd %xmm1, %xmm2
movsd 0x9b35(%rip), %xmm3     # 0x2f638
addsd %xmm1, %xmm3
cmplepd %xmm0, %xmm3
movapd %xmm0, %xmm4
cmplepd %xmm2, %xmm4
andpd %xmm3, %xmm4
movd %xmm4, %eax
movapd %xmm0, %xmm2
testb $0x1, %al
jne 0x25b29
movapd %xmm1, %xmm2
cmpltsd %xmm0, %xmm1
movapd %xmm1, %xmm3
andnpd %xmm2, %xmm3
andpd %xmm0, %xmm1
orpd %xmm3, %xmm1
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x258cc
xorpd %xmm1, %xmm1
movapd %xmm1, (%rsp)
ucomisd 0x54ee(%rip), %xmm0     # 0x2b0b0
jne 0x25bc6
jnp 0x25c37
xorpd %xmm2, %xmm2
movapd %xmm1, (%rsp)
movapd %xmm0, %xmm1
addsd 0x9a55(%rip), %xmm1     # 0x2f630
ucomisd %xmm2, %xmm1
addsd 0x9a51(%rip), %xmm0     # 0x2f638
jb 0x25bef
ucomisd %xmm0, %xmm2
jae 0x25c37
movapd (%rsp), %xmm1
movapd %xmm1, %xmm0
addsd 0x94e0(%rip), %xmm0     # 0x2f0e0
movsd 0x9a20(%rip), %xmm3     # 0x2f628
cmpeqsd %xmm3, %xmm1
movapd %xmm1, %xmm2
andpd %xmm3, %xmm2
andnpd %xmm0, %xmm1
orpd %xmm2, %xmm1
xorpd %xmm0, %xmm0
movapd %xmm1, (%rsp)
callq 0x258cc
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jne 0x25bcf
jp 0x25bcf
leaq 0x9a9a(%rip), %rdi      # 0x2f6d8
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
movaps (%rsp), %xmm2
movb $0x3, %al
callq 0x2050
movaps (%rsp), %xmm0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9a81(%rip), %rsi      # 0x2f6e8
callq 0x289c0
movq %rax, %rbx
movq 0x8(%rax), %rax
cmpq (%rbx), %rax
je 0x25c99
movq -0x8(%rax), %rdi
callq 0x275f2
movq %rax, %rdi
callq 0x273e0
movq %rax, %r14
movq %rbx, %rdi
callq 0x28d48
movq %r14, %rax
jmp 0x25c9b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9a3e(%rip), %rsi      # 0x2f6ec
callq 0x289c0
movq %rax, %rbx
movq 0x8(%rax), %rax
cmpq (%rbx), %rax
je 0x25ce0
movq -0x8(%rax), %rdi
callq 0x275f2
movq %rax, %rdi
callq 0x273e0
movq %rax, %r14
movq %rbx, %rdi
callq 0x28d48
movq %r14, %rax
jmp 0x25ce2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x99f3(%rip), %rsi      # 0x2f6ef
callq 0x289c0
movq %rax, %rbx
movq 0x8(%rax), %rax
subq (%rbx), %rax
cmpq $0x8, %rax
jne 0x25d16
xorl %r14d, %r14d
jmp 0x25d8c
movq %r14, %rdi
callq 0x26e82
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 0x25d8c
xorl %r15d, %r15d
movabsq $-0x100000000, %r12     # imm = 0xFFFFFFFF00000000
cmpq %r15, %rdx
jbe 0x25da3
movq (%rax,%r15,8), %rdi
callq 0x275f2
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 0x25d4f
movq %rbx, %rdi
callq 0x28d48
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x7b2c(%rip), %rdi      # 0x2d8d6
movq %r15, %rsi
xorl %eax, %eax
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/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 0x25de5
movq %rsi, %rcx
leaq 0x991b(%rip), %rsi      # 0x2f6f2
leaq 0x10(%rsp), %rdi
xorl %eax, %eax
callq 0x2080
jmp 0x25df8
leaq 0x9940(%rip), %rsi      # 0x2f72c
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 0x9934(%rip), %rdi      # 0x2f758
leaq 0x7edd(%rip), %rsi      # 0x2dd08
callq 0x21c0
movq %rax, %r14
leaq 0x8704(%rip), %rsi      # 0x2e53e
leaq 0x400(%rsp), %rdx
movq %rax, %rdi
xorl %eax, %eax
callq 0x2320
cmpl $0x1, %eax
jne 0x25ebf
leaq 0x400(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x86d9(%rip), %r13      # 0x2e53e
movq %r15, %rdi
callq 0x26e82
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 0x25e9f
movq %rbp, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x25eaa
movq %rbx, %rdi
movq %r12, %rdx
callq 0x12d32
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x2320
cmpl $0x1, %eax
je 0x25e65
movq %r14, %rdi
callq 0x2170
movups 0x9895(%rip), %xmm0     # 0x2f763
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_O1/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 0x83fb(%rip), %rsi      # 0x2e2fd
callq 0x2240
testl %eax, %eax
jne 0x25f12
callq 0x5883
jmp 0x25f41
leaq 0x9017(%rip), %rsi      # 0x2ef30
movq %rbx, %rdi
callq 0x21c0
testq %rax, %rax
jne 0x25f4a
movq 0x140b3(%rip), %rax     # 0x39fe0
movq (%rax), %rdi
leaq 0x844a(%rip), %rsi      # 0x2e381
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2250
movq $-0x1, %r14
jmp 0x25f85
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x21a0
movq %r14, %rdi
callq 0x2030
movq %rax, %r14
movq 0x14072(%rip), %rax     # 0x39fe0
movq (%rax), %rdi
leaq 0x9812(%rip), %rsi      # 0x2f78a
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_O1/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 0x835e(%rip), %rsi      # 0x2e2fd
callq 0x2240
testl %eax, %eax
je 0x2607c
leaq 0x8f7d(%rip), %rsi      # 0x2ef30
movq %r15, %rdi
callq 0x21c0
testq %rax, %rax
je 0x26083
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x21a0
movq %rbx, %rdi
callq 0x2030
movq %rax, %r14
cmpb $0x1, 0x141ec(%rip)     # 0x3a1d4
je 0x260a2
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x21a0
leaq 0x1(%r14), %rdi
callq 0x2040
movq %rax, %r15
cmpb $0x1, 0x141c7(%rip)     # 0x3a1d4
je 0x260c5
movl $0x1, %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2260
cmpq %rax, %r14
jne 0x26069
cmpb $0x1, 0x141a2(%rip)     # 0x3a1d4
je 0x260cf
movq %rbx, %rdi
callq 0x2170
movb $0x0, (%r15,%r14)
movl $0x18, %edi
callq 0x2180
movq %rax, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq %r15, (%rax)
movq $0x0, 0x8(%rax)
movq %r14, 0x10(%rax)
jmp 0x26073
movq %r15, %rdi
callq 0x2220
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x58d7
jmp 0x26071
movq 0x13f56(%rip), %rax     # 0x39fe0
movq (%rax), %rdi
leaq 0x82ed(%rip), %rsi      # 0x2e381
xorl %ebx, %ebx
movq %r15, %rdx
xorl %eax, %eax
callq 0x2250
jmp 0x26073
movq 0x13f37(%rip), %rax     # 0x39fe0
movq (%rax), %rdi
leaq 0x96d7(%rip), %rsi      # 0x2f78a
movq %r15, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x2250
jmp 0x25fee
callq 0x589f
jmp 0x26013
callq 0x58bb
jmp 0x26038
// File: /workspace/github_cpp_makefile_star2_O1/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 0x26131
btq %rcx, %r15
jb 0x26138
movb %al, (%rbx)
incq %rbx
jmp 0x2611a
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x818f(%rip), %rsi      # 0x2e2fd
movq %r14, %rdi
callq 0x2240
testl %eax, %eax
je 0x2618e
leaq 0x7b87(%rip), %rsi      # 0x2dd08
movq %r14, %rdi
callq 0x21c0
movq %rax, %r14
jmp 0x26198
movq 0x13e43(%rip), %rax     # 0x39fd8
movq (%rax), %r14
testq %r14, %r14
je 0x26244
movq %rsp, %r15
leaq 0x9627(%rip), %r12      # 0x2f7d2
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x26258
movq %rax, %r13
movq %rax, (%rsp)
testq %rax, %rax
je 0x26218
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x261d5
movq %r13, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x261e0
movq %rbx, %rdi
movq %r15, %rdx
callq 0x12d32
incl %ebp
cmpb $0x1, 0x13feb(%rip)     # 0x3a1d4
jne 0x26218
movslq %ebp, %rax
imulq $0x68db8bad, %rax, %rcx # imm = 0x68DB8BAD
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x2c, %rcx
addl %edx, %ecx
imull $0x2710, %ecx, %ecx     # imm = 0x2710
subl %ecx, %eax
jne 0x26218
movq %r12, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x2050
testq %r13, %r13
jne 0x261ad
cmpb $0x1, 0x13fb0(%rip)     # 0x3a1d4
jne 0x2623a
movq 0x13db3(%rip), %rax     # 0x39fe0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x2210
movq %r14, %rdi
callq 0x2170
jmp 0x26246
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_O1/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 0x262cf
movzbl %al, %ecx
cmpl $0xff, %ecx
je 0x262c6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x262b9
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x2628c
movq %rbx, %rdi
movq %r15, %rdx
callq 0x265e4
jmp 0x2628c
movq (%rbx), %r14
cmpq %r14, 0x8(%rbx)
je 0x2631c
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 0x2631f
movl %r12d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %esi, %esi
cmpq %rsi, %r12
je 0x26351
movb (%r14,%rsi), %cl
movb %cl, (%r15,%rsi)
incq %rsi
cmpq %rsi, %rax
jne 0x26305
jmp 0x2631f
xorl %r15d, %r15d
testq %r14, %r14
je 0x26333
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 0x757e(%rip), %rdi      # 0x2d8d6
movq %r12, %rdx
xorl %eax, %eax
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/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 0x799e(%rip), %rsi      # 0x2dd08
callq 0x21c0
movq %rax, %rbx
testq %rax, %rax
je 0x2637f
movq %rbx, %rdi
callq 0x2170
testq %rbx, %rbx
setne %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x263b3
movq %rsi, %r14
testq %rsi, %rsi
je 0x263b3
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21c0
testq %rax, %rax
je 0x263bc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x9439(%rip), %rdi      # 0x2f7f3
jmp 0x263e3
movzbl (%r14), %eax
cmpl $0x77, %eax
je 0x263d3
cmpl $0x72, %eax
jne 0x263dc
leaq 0x9447(%rip), %rdi      # 0x2f818
jmp 0x263e3
leaq 0x945e(%rip), %rdi      # 0x2f838
jmp 0x263e3
leaq 0x9475(%rip), %rdi      # 0x2f858
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2050
xorl %edi, %edi
callq 0x21e0