LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movb $0x0, 0xf(%rsp)
movq 0x18(%rsp), %rdi
callq 0xc2a0
subl $0x1, %eax
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jl 0x3efea
movq 0x18(%rsp), %rdi
movslq 0x8(%rsp), %rsi
callq 0xc2c0
movl (%rax), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movslq 0x8(%rsp), %rsi
callq 0xc2c0
movq %rax, %rcx
movl 0x4(%rsp), %eax
cmpl (%rcx), %eax
jge 0x3efc3
movq 0x18(%rsp), %rdi
movslq 0x8(%rsp), %rsi
callq 0xc2c0
movl (%rax), %eax
addl $0x1, %eax
movl %eax, (%rsp)
movq 0x18(%rsp), %rdi
movslq 0x8(%rsp), %rsi
callq 0xc2c0
movl (%rsp), %ecx
movl %ecx, (%rax)
movb $0x1, 0xf(%rsp)
jmp 0x3efea
movq 0x18(%rsp), %rdi
movslq 0x8(%rsp), %rsi
callq 0xc2c0
movl $0x0, (%rax)
jmp 0x3efda
movl 0x8(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x3ef54
testb $0x1, 0xf(%rsp)
jne 0x3eff8
movb $0x0, 0x27(%rsp)
jmp 0x3effd
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x448, %rsp            # imm = 0x448
movl %edi, 0x444(%rsp)
movq %rsi, 0x438(%rsp)
movl $0x0, 0x434(%rsp)
movl 0x434(%rsp), %eax
cmpl 0x444(%rsp), %eax
jg 0x3f1ae
leaq 0x40(%rsp), %rdi
movl 0x434(%rsp), %edx
leaq 0x17821(%rip), %rsi     # 0x56879
movb $0x0, %al
callq 0x2090
leaq 0x40(%rsp), %rdi
leaq 0x13a39(%rip), %rsi     # 0x52aa4
callq 0x21d0
movq %rax, 0x38(%rsp)
movsd 0x12fbb(%rip), %xmm0    # 0x52038
callq 0x2140
movsd %xmm0, 0x30(%rsp)
xorps %xmm0, %xmm0
callq 0x441e0
movsd %xmm0, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x434(%rsp), %eax
jg 0x3f18e
movsd 0x30(%rsp), %xmm0
cvtsi2sdl 0x434(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x438(%rsp), %rax
movslq 0x434(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rsp)
movq 0x438(%rsp), %rax
movslq 0x24(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x438(%rsp), %rax
movl 0x434(%rsp), %ecx
subl 0x24(%rsp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
callq 0x44510
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
callq 0x445a0
movsd %xmm0, 0x10(%rsp)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x44510
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
callq 0x44310
movsd %xmm0, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movl 0x24(%rsp), %edx
movsd 0x28(%rsp), %xmm0
leaq 0x164d4(%rip), %rsi     # 0x5564b
movb $0x1, %al
callq 0x2250
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x3f09e
movq 0x38(%rsp), %rdi
callq 0x2180
movl 0x434(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x434(%rsp)
jmp 0x3f031
addq $0x448, %rsp            # imm = 0x448
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jg 0x3f3f5
movq 0x20(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x3f3e6
movq 0x8(%rsp), %rdi
callq 0x2220
jmp 0x3f3e8
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x3f3b9
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x3f40d
movq (%rsp), %rdi
callq 0x2220
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl 0x24(%rsp), %eax
addl $0x2, %eax
cltq
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2040
movq %rax, 0x18(%rsp)
movsd 0x12bb9(%rip), %xmm0    # 0x52018
callq 0x441e0
movq 0x18(%rsp), %rax
movsd %xmm0, (%rax)
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x24(%rsp), %eax
jg 0x3f4ce
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x8(%rsp)
cvtsi2sdl 0x14(%rsp), %xmm0
callq 0x441e0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
callq 0x44510
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x3f475
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movb $0x0, 0x1b(%rsp)
movq 0x20(%rsp), %rdi
callq 0xc2a0
subl $0x1, %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jl 0x3f581
movq 0x20(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0xc2c0
movl (%rax), %eax
addl $0x1, %eax
cmpl 0x1c(%rsp), %eax
jge 0x3f55d
movq 0x20(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0xc2c0
movl (%rax), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0xc2c0
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
movb $0x1, 0x1b(%rsp)
jmp 0x3f581
movq 0x20(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0xc2c0
movl $0x0, (%rax)
jmp 0x3f574
movl 0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x3f508
testb $0x1, 0x1b(%rsp)
jne 0x3f58f
movb $0x0, 0x37(%rsp)
jmp 0x3f607
movq 0x20(%rsp), %rdi
callq 0x3eea0
testb $0x1, %al
jne 0x3f59f
jmp 0x3f5a1
jmp 0x3f5a6
jmp 0x3f4f2
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0xc2a0
movq %rax, %rcx
movl 0x8(%rsp), %eax
cmpl %ecx, %eax
jge 0x3f602
movq 0x20(%rsp), %rdi
movslq 0x10(%rsp), %rsi
callq 0xc2c0
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x10(%rsp), %rsi
callq 0xc2c0
movl 0x4(%rsp), %ecx
movl %ecx, (%rax)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x3f5ae
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movb %dil, %al
movb %al, 0x6(%rsp)
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x41, %eax
jne 0x3f63e
movb $0x54, 0x7(%rsp)
jmp 0x3f685
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x43, %eax
jne 0x3f654
movb $0x47, 0x7(%rsp)
jmp 0x3f685
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x47, %eax
jne 0x3f66a
movb $0x43, 0x7(%rsp)
jmp 0x3f685
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x54, %eax
jne 0x3f680
movb $0x41, 0x7(%rsp)
jmp 0x3f685
movb $0x4e, 0x7(%rsp)
movb 0x7(%rsp), %al
popq %rcx
retq
nopl (%rax,%rax)
// File: 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 %rax
movb %sil, %al
movb %dil, %cl
movb %cl, 0x6(%rsp)
movb %al, 0x5(%rsp)
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x41, %eax
jne 0x3f6d8
movsbl 0x5(%rsp), %edi
callq 0x2350
cmpl $0x55, %eax
je 0x3f6cc
movsbl 0x5(%rsp), %edi
callq 0x2350
cmpl $0x54, %eax
jne 0x3f6d6
movb $0x1, 0x7(%rsp)
jmp 0x3f7b8
jmp 0x3f6d8
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x43, %eax
jne 0x3f702
movsbl 0x5(%rsp), %edi
callq 0x2350
cmpl $0x47, %eax
jne 0x3f700
movb $0x1, 0x7(%rsp)
jmp 0x3f7b8
jmp 0x3f702
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x47, %eax
jne 0x3f747
movsbl 0x5(%rsp), %edi
callq 0x2350
cmpl $0x55, %eax
je 0x3f73e
movsbl 0x5(%rsp), %edi
callq 0x2350
cmpl $0x54, %eax
je 0x3f73e
movsbl 0x5(%rsp), %edi
callq 0x2350
cmpl $0x43, %eax
jne 0x3f745
movb $0x1, 0x7(%rsp)
jmp 0x3f7b8
jmp 0x3f747
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x54, %eax
jne 0x3f77d
movsbl 0x5(%rsp), %edi
callq 0x2350
cmpl $0x41, %eax
je 0x3f774
movsbl 0x5(%rsp), %edi
callq 0x2350
cmpl $0x47, %eax
jne 0x3f77b
movb $0x1, 0x7(%rsp)
jmp 0x3f7b8
jmp 0x3f77d
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x55, %eax
jne 0x3f7b3
movsbl 0x5(%rsp), %edi
callq 0x2350
cmpl $0x41, %eax
je 0x3f7aa
movsbl 0x5(%rsp), %edi
callq 0x2350
cmpl $0x47, %eax
jne 0x3f7b1
movb $0x1, 0x7(%rsp)
jmp 0x3f7b8
jmp 0x3f7b3
movb $0x0, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
popq %rcx
retq
// File: gersteinlab[P]MUSIC/src/ms_nucleotide.cpp
// Function: is_valid_nuc_char(char)
bool is_valid_nuc_char(char nuc)
{
	if(toupper(nuc) == 'A' ||
		toupper(nuc) == 'C' ||
		toupper(nuc) == 'G' ||
		toupper(nuc) == 'U' ||
		toupper(nuc) == 'T')
	{
		return(true);
	}
	else
	{
		return(false);
	}
}

// Assembly:
pushq %rax
movb %dil, %al
movb %al, 0x6(%rsp)
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x41, %eax
je 0x3f813
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x43, %eax
je 0x3f813
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x47, %eax
je 0x3f813
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x55, %eax
je 0x3f813
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x54, %eax
jne 0x3f81a
movb $0x1, 0x7(%rsp)
jmp 0x3f81f
movb $0x0, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
popq %rcx
retq
nopw (%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_nucleotide.cpp
// Function: nuc_2_num(char)
int nuc_2_num(char nuc)
{
	if(toupper(nuc) == 'A')
	{
		return(0);
	}
	else if(toupper(nuc) == 'C')
	{
		return(1);
	}
	else if(toupper(nuc) == 'G')
	{
		return(2);
	}
	else if(toupper(nuc) == 'U' ||
		toupper(nuc) == 'T')
	{
		return(3);
	}
	else
	{
		return(4);
		//fprintf(stderr, "Cannot convert %c to number.\n", nuc);
		//exit(0);
	}
}

// Assembly:
pushq %rax
movb %dil, %al
movb %al, 0x3(%rsp)
movsbl 0x3(%rsp), %edi
callq 0x2350
cmpl $0x41, %eax
jne 0x3f851
movl $0x0, 0x4(%rsp)
jmp 0x3f8b3
movsbl 0x3(%rsp), %edi
callq 0x2350
cmpl $0x43, %eax
jne 0x3f86a
movl $0x1, 0x4(%rsp)
jmp 0x3f8b3
movsbl 0x3(%rsp), %edi
callq 0x2350
cmpl $0x47, %eax
jne 0x3f883
movl $0x2, 0x4(%rsp)
jmp 0x3f8b3
movsbl 0x3(%rsp), %edi
callq 0x2350
cmpl $0x55, %eax
je 0x3f8a1
movsbl 0x3(%rsp), %edi
callq 0x2350
cmpl $0x54, %eax
jne 0x3f8ab
movl $0x3, 0x4(%rsp)
jmp 0x3f8b3
movl $0x4, 0x4(%rsp)
movl 0x4(%rsp), %eax
popq %rcx
retq
nopl (%rax)
// File: gersteinlab[P]MUSIC/src/ms_nucleotide.cpp
// Function: get_transcribed_rna_nuc_per_dna_nuc(char)
char get_transcribed_rna_nuc_per_dna_nuc(char dna_nuc)
{
	if(toupper(dna_nuc) == 'A' || 
		toupper(dna_nuc) == 'C' || 
		toupper(dna_nuc) == 'G')
	{
		return(toupper(dna_nuc));
	}
	else if(toupper(dna_nuc) == 'T')
	{
		return('U');
	}
	else
	{
		return(toupper(dna_nuc));
	}
}

// Assembly:
pushq %rax
movb %dil, %al
movb %al, 0x6(%rsp)
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x41, %eax
je 0x3f925
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x43, %eax
je 0x3f925
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x47, %eax
jne 0x3f935
movsbl 0x6(%rsp), %edi
callq 0x2350
movb %al, 0x7(%rsp)
jmp 0x3f959
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x54, %eax
jne 0x3f94b
movb $0x55, 0x7(%rsp)
jmp 0x3f959
movsbl 0x6(%rsp), %edi
callq 0x2350
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
popq %rcx
retq
nop
// File: gersteinlab[P]MUSIC/src/ms_nucleotide.cpp
// Function: get_transcribing_dna_nuc_per_rna_nuc(char)
char get_transcribing_dna_nuc_per_rna_nuc(char rna_nuc)
{
	if(toupper(rna_nuc) == 'A' || 
		toupper(rna_nuc) == 'C' || 
		toupper(rna_nuc) == 'G')
	{
		return(toupper(rna_nuc));
	}
	else if(toupper(rna_nuc) == 'U')
	{
		return('T');
	}
	else
	{
		return(toupper(rna_nuc));
	}
}

// Assembly:
pushq %rax
movb %dil, %al
movb %al, 0x6(%rsp)
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x41, %eax
je 0x3f995
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x43, %eax
je 0x3f995
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x47, %eax
jne 0x3f9a5
movsbl 0x6(%rsp), %edi
callq 0x2350
movb %al, 0x7(%rsp)
jmp 0x3f9c9
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x55, %eax
jne 0x3f9bb
movb $0x54, 0x7(%rsp)
jmp 0x3f9c9
movsbl 0x6(%rsp), %edi
callq 0x2350
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
popq %rcx
retq
nop
// File: 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
movb %dil, %al
movb %al, 0x6(%rsp)
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x41, %eax
jne 0x3f9ee
movb $0x54, 0x7(%rsp)
jmp 0x3fa44
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x43, %eax
jne 0x3fa04
movb $0x47, 0x7(%rsp)
jmp 0x3fa44
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x47, %eax
jne 0x3fa1a
movb $0x43, 0x7(%rsp)
jmp 0x3fa44
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x54, %eax
je 0x3fa38
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x55, %eax
jne 0x3fa3f
movb $0x41, 0x7(%rsp)
jmp 0x3fa44
movb $0x4e, 0x7(%rsp)
movb 0x7(%rsp), %al
popq %rcx
retq
nopw (%rax,%rax)
// File: 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
movb %dil, %al
movb %al, 0x6(%rsp)
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x41, %eax
jne 0x3fa6e
movb $0x55, 0x7(%rsp)
jmp 0x3fab5
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x43, %eax
jne 0x3fa84
movb $0x47, 0x7(%rsp)
jmp 0x3fab5
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x47, %eax
jne 0x3fa9a
movb $0x43, 0x7(%rsp)
jmp 0x3fab5
movsbl 0x6(%rsp), %edi
callq 0x2350
cmpl $0x55, %eax
jne 0x3fab0
movb $0x41, 0x7(%rsp)
jmp 0x3fab5
movb $0x4e, 0x7(%rsp)
movb 0x7(%rsp), %al
popq %rcx
retq
nopl (%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_min_max_utils.cpp
// Function: get_extrema_per_plateaus(double*, int, std::vector<t_extrema_node*, std::allocator<t_extrema_node*>>*, std::vector<t_extrema_node*, std::allocator<t_extrema_node*>>*, int*, int)
void get_extrema_per_plateaus(double* data, int l_signal,
	vector<t_extrema_node*>* maxes, 
	vector<t_extrema_node*>* mins,
	int* derivative_sign_map,
	int i_scale)
{
	double zero_deriv = pow(10.0, -10.0);

	get_extrema_per_plateaus(data, l_signal,
		maxes, 
		mins,
		derivative_sign_map,
		i_scale,
		zero_deriv);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movl %r9d, 0xc(%rsp)
movsd 0x143b7(%rip), %xmm0    # 0x54d80
movsd 0x15ebf(%rip), %xmm1    # 0x56890
callq 0x22f0
movsd %xmm0, (%rsp)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movl 0xc(%rsp), %r9d
movsd (%rsp), %xmm0
callq 0x40a10
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_xlog_math.cpp
// Function: xlog(double)
double xlog(double value)
{
	if(value == 0.0)
	{
		return(LOG_OF_ZERO);
	}
	else if (value > 0.0)
	{
		return(log(value));
	}
	else
	{
		printf("log of a negative number @ %s(%d): %.6f", __FILE__, __LINE__, value);
		int* p = NULL;
		*p = 0;
		exit(0);
	}
}

// Assembly:
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x44224
jp 0x44224
movsd 0xde4d(%rip), %xmm0     # 0x52050
movl $0x1e, %edi
callq 0x44b10
movaps %xmm0, %xmm1
movsd 0xde40(%rip), %xmm0     # 0x52058
mulsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x4427f
movsd 0x8(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x44246
movsd 0x8(%rsp), %xmm0
callq 0x2140
movsd %xmm0, 0x10(%rsp)
jmp 0x4427f
movsd 0x8(%rsp), %xmm0
leaq 0x12766(%rip), %rdi     # 0x569b9
leaq 0x12787(%rip), %rsi     # 0x569e1
movl $0x18, %edx
movb $0x1, %al
callq 0x2050
movq $0x0, (%rsp)
movq (%rsp), %rax
movl $0x0, (%rax)
xorl %edi, %edi
callq 0x21f0
movsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movsd %xmm0, 0x28(%rsp)
movsd %xmm1, 0x20(%rsp)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
xorps %xmm0, %xmm0
callq 0x441e0
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x44356
jp 0x44356
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x44422
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
callq 0x441e0
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x4438c
jp 0x4438c
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x44422
movsd 0x28(%rsp), %xmm0
ucomisd 0x20(%rsp), %xmm0
jbe 0x443e0
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x20(%rsp), %xmm0
subsd 0x28(%rsp), %xmm0
callq 0x44290
movaps %xmm0, %xmm1
movsd 0xdc56(%rip), %xmm0     # 0x52018
addsd %xmm1, %xmm0
callq 0x441e0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x44422
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x28(%rsp), %xmm0
subsd 0x20(%rsp), %xmm0
callq 0x44290
movaps %xmm0, %xmm1
movsd 0xdc11(%rip), %xmm0     # 0x52018
addsd %xmm1, %xmm0
callq 0x441e0
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax)
// File: gersteinlab[P]MUSIC/src/ms_xlog_math.cpp
// Function: xlog_sub(double, double)
double xlog_sub(double log1, double log2)
{
	//n_subs++;
	//return(log1 - log2);
	if(log1 < log2)
	{
		printf("%.5f < %.5f in PPF_SUB\n", log1, log2);
		printf("Cannot compute logarithm of a negative number in PPF_SUB @ %s(%d)\n", __FILE__, __LINE__);
		double* p = NULL;
		*p = 0;
		exit(0);
	}
	else if(log1 == log2)
	{
		return(xlog(0.0));
	}
	else // log1 > log2.
	{
		return( log1 + xlog(1 - xexp(log2-log1)) );
	}

	//if(xlog_comp(log1, log2))
	if(log1 == log2)
	{
		return(xlog(0.0));
	}

	if(log1 < log2)
	{
		printf("%.5f < %.5f in PPF_SUB\n", log1, log2);
		printf("Cannot compute logarithm of a negative number in PPF_SUB @ %s(%d)\n", __FILE__, __LINE__);
		double* p = NULL;
		*p = 0;
		exit(0);
	}
	else if(log1 == log2)
	{
		return(xlog(0.0));
	}
	else // log1 > log2.
	{
		return( log1 + xlog(1 - xexp(log2-log1)) );
	}
}

// Assembly:
subq $0x28, %rsp
movsd %xmm0, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd 0x18(%rsp), %xmm1
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x444a2
movsd 0x18(%rsp), %xmm0
movsd 0x10(%rsp), %xmm1
leaq 0x12591(%rip), %rdi     # 0x569f6
movb $0x2, %al
callq 0x2050
leaq 0x1259b(%rip), %rdi     # 0x56a0e
leaq 0x12567(%rip), %rsi     # 0x569e1
movl $0x54, %edx
movb $0x0, %al
callq 0x2050
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
xorl %edi, %edi
callq 0x21f0
movsd 0x18(%rsp), %xmm0
ucomisd 0x10(%rsp), %xmm0
jne 0x444c2
jp 0x444c2
xorps %xmm0, %xmm0
callq 0x441e0
movsd %xmm0, 0x20(%rsp)
jmp 0x44504
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x10(%rsp), %xmm0
subsd 0x18(%rsp), %xmm0
callq 0x44290
movaps %xmm0, %xmm1
movsd 0xdb2f(%rip), %xmm0     # 0x52018
subsd %xmm1, %xmm0
callq 0x441e0
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
nop
// File: gersteinlab[P]MUSIC/src/ms_xlog_math.cpp
// Function: xlog_div(double, double)
double xlog_div(double log1, double log2)
{
	//n_divs++;
	//return(log1 / log2);

	if(log1 == xlog(0.0))
	{
		return(xlog(0.0));
	}

	if(log2 == xlog(0.0))
	{
		double* p = NULL;
		*p = 0;
		printf("Division by zero error at %s(%d)\n", __FILE__, __LINE__);
		exit(0);
	}
	else
	{
		//return(xlog_mul(log1, -1.0 * log2));
		return(log1 - log2);
	}
}

// Assembly:
subq $0x38, %rsp
movsd %xmm0, 0x28(%rsp)
movsd %xmm1, 0x20(%rsp)
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
callq 0x441e0
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x445e5
jp 0x445e5
xorps %xmm0, %xmm0
callq 0x441e0
movsd %xmm0, 0x30(%rsp)
jmp 0x44652
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
callq 0x441e0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x44640
jp 0x44640
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
leaq 0x1242b(%rip), %rdi     # 0x56a51
leaq 0x123b4(%rip), %rsi     # 0x569e1
movl $0x98, %edx
movb $0x0, %al
callq 0x2050
xorl %edi, %edi
callq 0x21f0
movsd 0x28(%rsp), %xmm0
subsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax)
// File: gersteinlab[P]MUSIC/src/ms_xlog_math.cpp
// Function: xlog_geq(double, double)
bool xlog_geq(double log1, double log2)
{
	if(log1 > log2)
	{
		return(true);
	}

	if(xlog_comp(log1, log2))
	{
		return(true);
	}

	return(false);
}

// Assembly:
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, (%rsp)
movsd 0x8(%rsp), %xmm0
ucomisd (%rsp), %xmm0
jbe 0x44763
movb $0x1, 0x17(%rsp)
jmp 0x44785
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
callq 0x44790
testb $0x1, %al
jne 0x44779
jmp 0x44780
movb $0x1, 0x17(%rsp)
jmp 0x44785
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
// File: gersteinlab[P]MUSIC/src/ms_xlog_math.cpp
// Function: xlog_comp(double, double)
bool xlog_comp(double log1, double log2)
{
	// If xlogs can be equated directly, return true.
	if(log1 == log2)
	{
		return(true);
	}

	if(log1 <= log2 + XLOG_EPSILON && log1 >= log2 - XLOG_EPSILON)
	{
		return(true);
	}

	//printf("Values in PPF_COMP:\n%.25f\n%.25f\nXLOG_EPSILON=%.25f\n", log1, log2, XLOG_EPSILON);

	return(false);
}

// Assembly:
subq $0x38, %rsp
movsd %xmm0, 0x28(%rsp)
movsd %xmm1, 0x20(%rsp)
movsd 0x28(%rsp), %xmm0
ucomisd 0x20(%rsp), %xmm0
jne 0x447ba
jp 0x447ba
movb $0x1, 0x37(%rsp)
jmp 0x4484a
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x10576(%rip), %xmm0    # 0x54d50
movl $0xa, %edi
callq 0x44b10
movsd 0x10(%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x18(%rsp), %xmm0
addsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jb 0x44845
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd 0x10534(%rip), %xmm0    # 0x54d50
movl $0xa, %edi
callq 0x44b10
movsd (%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x8(%rsp), %xmm0
subsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jb 0x44845
movb $0x1, 0x37(%rsp)
jmp 0x4484a
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
movsd %xmm1, (%rsp)
movsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
callq 0x44790
testb $0x1, %al
jne 0x44885
jmp 0x44893
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x448b9
movsd 0x8(%rsp), %xmm0
ucomisd (%rsp), %xmm0
jbe 0x448ae
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x448b9
movsd (%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_xlog_math.cpp
// Function: xlog_gt(double, double)
bool xlog_gt(double log1, double log2)
{
	// Do not do logarithmic check if any of the values are 0.
	if(log1 == xlog(0.0) || log2 == xlog(0.0))
	{
		if(log1 == log2)
		{
			return(false);
		}

		if(log1 == xlog(0.0))
		{
			return(false);
		}
		else
		{
			return(true);
		}
	}

	// If xlogs can be equated directly, return true.
	if(log1 == log2)
	{
		return(false);
	}

	if(log1 > log2 + XLOG_EPSILON)
	{
		return(true);
	}
	else
	{
		return(false);
	}
}

// Assembly:
subq $0x48, %rsp
movsd %xmm0, 0x38(%rsp)
movsd %xmm1, 0x30(%rsp)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
xorps %xmm0, %xmm0
callq 0x441e0
movaps %xmm0, %xmm1
movsd 0x28(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x44907
jp 0x44907
jmp 0x4492c
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
xorps %xmm0, %xmm0
callq 0x441e0
movaps %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x44979
jp 0x44979
movsd 0x38(%rsp), %xmm0
ucomisd 0x30(%rsp), %xmm0
jne 0x44946
jp 0x44946
movb $0x0, 0x47(%rsp)
jmp 0x449df
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
xorps %xmm0, %xmm0
callq 0x441e0
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x44972
jp 0x44972
movb $0x0, 0x47(%rsp)
jmp 0x449df
movb $0x1, 0x47(%rsp)
jmp 0x449df
movsd 0x38(%rsp), %xmm0
ucomisd 0x30(%rsp), %xmm0
jne 0x44990
jp 0x44990
movb $0x0, 0x47(%rsp)
jmp 0x449df
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x103a0(%rip), %xmm0    # 0x54d50
movl $0xa, %edi
callq 0x44b10
movsd 0x8(%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x10(%rsp), %xmm0
addsd %xmm2, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x449da
movb $0x1, 0x47(%rsp)
jmp 0x449df
movb $0x0, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: 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 $0x28, %rsp
movsd 0xd5bc(%rip), %xmm0     # 0x52018
callq 0x441e0
movsd %xmm0, 0x20(%rsp)
movsd 0xd5a9(%rip), %xmm0     # 0x52018
callq 0x441e0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x18(%rsp), %xmm0
movsd 0x20(%rsp), %xmm1
callq 0x44310
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
callq 0x44790
testb $0x1, %al
jne 0x44aab
jmp 0x44acd
movsd 0x18(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
movsd 0x20(%rsp), %xmm2
leaq 0x11faf(%rip), %rdi     # 0x56a73
movb $0x3, %al
callq 0x2050
jmp 0x44aff
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0xd56f(%rip), %xmm0     # 0x52050
callq 0x441e0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
callq 0x445a0
movsd %xmm0, 0x20(%rsp)
jmp 0x44a7a
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x11f2e(%rip), %rsi     # 0x56a83
callq 0x49930
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x45c40
cmpq $0x0, %rax
jbe 0x44ba4
movq 0x10(%rsp), %rdi
callq 0x45c60
movq (%rax), %rdi
callq 0x47e10
movq %rax, %rdi
callq 0x47b60
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x49e50
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x44bad
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x11eb2(%rip), %rsi     # 0x56a87
callq 0x49930
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x45c40
cmpq $0x0, %rax
jbe 0x44c24
movq 0x10(%rsp), %rdi
callq 0x45c60
movq (%rax), %rdi
callq 0x47e10
movq %rax, %rdi
callq 0x47b60
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x49e50
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x44c2d
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x11e35(%rip), %rsi     # 0x56a8a
callq 0x49930
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x45c40
cmpq $0x1, %rax
jne 0x44c87
movq 0x20(%rsp), %rdi
callq 0x49e50
movq $0x0, 0x30(%rsp)
jmp 0x44d20
movq 0x28(%rsp), %rdi
callq 0x47640
addl $0x2, %eax
movslq %eax, %rdi
callq 0x2040
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movb $0x0, (%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x45c40
movq %rax, %rcx
movl 0x10(%rsp), %eax
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x44d0c
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x45ca0
movq (%rax), %rdi
callq 0x47e10
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x2310
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x44cb1
movq 0x20(%rsp), %rdi
callq 0x49e50
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x808, %rsp            # imm = 0x808
movq %rdi, 0x800(%rsp)
movq %rsi, 0x7f8(%rsp)
cmpq $0x0, 0x7f8(%rsp)
je 0x44d87
leaq 0x410(%rsp), %rdi
movq 0x800(%rsp), %rdx
movq 0x7f8(%rsp), %rcx
leaq 0x11d1c(%rip), %rsi     # 0x56a8d
movb $0x0, %al
callq 0x2090
leaq 0x410(%rsp), %rdi
callq 0x2150
jmp 0x44db2
leaq 0x410(%rsp), %rdi
movq 0x800(%rsp), %rdx
leaq 0x11d29(%rip), %rsi     # 0x56ac7
movb $0x0, %al
callq 0x2090
leaq 0x410(%rsp), %rdi
callq 0x2150
movl $0x18, %edi
callq 0x2190
movq %rax, %rdi
movq %rdi, (%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x2110
movq (%rsp), %rdi
callq 0xc630
movq (%rsp), %rax
movq %rax, 0x408(%rsp)
leaq 0x11d08(%rip), %rdi     # 0x56af3
leaq 0x102dc(%rip), %rsi     # 0x550ce
callq 0x21d0
movq %rax, 0x400(%rsp)
movq 0x400(%rsp), %rdi
leaq 0x10(%rsp), %rdx
leaq 0x10aeb(%rip), %rsi     # 0x558fe
movb $0x0, %al
callq 0x2340
cmpl $0x1, %eax
jne 0x44e5c
leaq 0x10(%rsp), %rdi
callq 0x47640
addl $0x3, %eax
movslq %eax, %rdi
callq 0x2040
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2160
movq 0x408(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1fbe0
jmp 0x44dff
movq 0x400(%rsp), %rdi
callq 0x2180
leaq 0x410(%rsp), %rdi
leaq 0x11c86(%rip), %rsi     # 0x56afe
movb $0x0, %al
callq 0x2090
leaq 0x410(%rsp), %rdi
callq 0x2150
movq 0x408(%rsp), %rax
addq $0x808, %rsp            # imm = 0x808
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x107ff(%rip), %rsi     # 0x556bd
callq 0x2240
cmpl $0x0, %eax
jne 0x44eee
movq 0x20111(%rip), %rax     # 0x64fe0
movq (%rax), %rdi
leaq 0x11c36(%rip), %rsi     # 0x56b0f
movb $0x0, %al
callq 0x2250
movq $-0x1, 0x20(%rsp)
jmp 0x44f84
movq 0x18(%rsp), %rdi
leaq 0x11406(%rip), %rsi     # 0x56300
callq 0x21d0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x44f34
movq 0x200cd(%rip), %rax     # 0x64fe0
movq (%rax), %rdi
movq 0x18(%rsp), %rdx
leaq 0x1081f(%rip), %rsi     # 0x55741
movb $0x0, %al
callq 0x2250
movq $-0x1, 0x20(%rsp)
jmp 0x44f84
jmp 0x44f36
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x21b0
movq 0x10(%rsp), %rdi
callq 0x2030
movq %rax, 0x8(%rsp)
movq 0x20081(%rip), %rax     # 0x64fe0
movq (%rax), %rdi
movq 0x18(%rsp), %rdx
movq 0x8(%rsp), %rcx
leaq 0x11bb2(%rip), %rsi     # 0x56b25
movb $0x0, %al
callq 0x2250
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movslq 0x14(%rsp), %rdx
xorl %esi, %esi
callq 0x2110
movl $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x20(%rsp), %rdi
callq 0x20b0
movl %eax, 0xc(%rsp)
xorl %eax, %eax
cmpl $0x20, 0xc(%rsp)
movb %al, 0xb(%rsp)
je 0x45274
xorl %eax, %eax
cmpl $-0x1, 0xc(%rsp)
movb %al, 0xb(%rsp)
je 0x45274
xorl %eax, %eax
cmpl $0xa, 0xc(%rsp)
movb %al, 0xb(%rsp)
je 0x45274
cmpl $0x9, 0xc(%rsp)
setne %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x4527e
jmp 0x452ac
movl 0xc(%rsp), %eax
movb %al, %dl
movq 0x18(%rsp), %rax
movslq 0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x20b0
movl %eax, 0xc(%rsp)
jmp 0x45241
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl $0x18, %edi
callq 0x2190
movq %rax, %rdi
movq %rdi, (%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x2110
movq (%rsp), %rdi
callq 0xc630
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x103a8(%rip), %rsi     # 0x556bd
callq 0x2240
cmpl $0x0, %eax
jne 0x45330
movq 0x1fcb2(%rip), %rax     # 0x64fd8
movq (%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x45346
movq 0x28(%rsp), %rdi
leaq 0xfd92(%rip), %rsi      # 0x550ce
callq 0x21d0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x4535c
movq $0x0, 0x30(%rsp)
jmp 0x453f6
jmp 0x4535e
movq 0x10(%rsp), %rdi
callq 0x45400
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x45377
jmp 0x453c1
movq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1fbe0
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
testb $0x1, 0x1fe4c(%rip)     # 0x651e4
je 0x453bf
movl 0x1c(%rsp), %eax
movl $0x2710, %ecx           # imm = 0x2710
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x453bd
movl 0x1c(%rsp), %esi
leaq 0x117b7(%rip), %rdi     # 0x56b6d
movb $0x0, %al
callq 0x2050
jmp 0x453bf
jmp 0x4535e
testb $0x1, 0x1fe1c(%rip)     # 0x651e4
je 0x453e2
movq 0x1fc0f(%rip), %rax     # 0x64fe0
movq (%rax), %rdi
leaq 0xcff3(%rip), %rsi      # 0x523ce
movb $0x0, %al
callq 0x2250
movq 0x10(%rsp), %rdi
callq 0x2180
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movl $0x18, %edi
callq 0x2190
movq %rax, %rdi
movq %rdi, 0x20(%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x2110
movq 0x20(%rsp), %rdi
callq 0x45ce0
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movb $0x0, 0x3f(%rsp)
movq 0x48(%rsp), %rdi
callq 0x20b0
movb %al, 0x3f(%rsp)
movsbl 0x3f(%rsp), %eax
cmpl $-0x1, %eax
jne 0x4545a
jmp 0x45479
movsbl 0x3f(%rsp), %eax
cmpl $0xa, %eax
jne 0x45466
jmp 0x45479
jmp 0x45468
movq 0x40(%rsp), %rdi
leaq 0x3f(%rsp), %rsi
callq 0x45cf0
jmp 0x45440
movsbl 0x3f(%rsp), %eax
cmpl $-0x1, %eax
jne 0x454ca
movq 0x40(%rsp), %rdi
callq 0x45d60
cmpq $0x0, %rax
jne 0x454ca
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x454bc
movq 0x18(%rsp), %rdi
callq 0x45d80
movq 0x18(%rsp), %rdi
movl $0x18, %esi
callq 0x21a0
movq $0x0, 0x50(%rsp)
jmp 0x45590
movq 0x40(%rsp), %rdi
callq 0x45d60
movq %rax, %rdi
addq $0x2, %rdi
callq 0x2040
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
callq 0x45d60
movq 0x10(%rsp), %rdi
movq %rax, %rdx
addq $0x2, %rdx
shlq $0x0, %rdx
xorl %esi, %esi
callq 0x2110
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x40(%rsp), %rdi
callq 0x45d60
movq %rax, %rcx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x45560
movq 0x40(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0x45de0
movb (%rax), %dl
movq 0x30(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x45518
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x45586
movq (%rsp), %rdi
callq 0x45d80
movq (%rsp), %rdi
movl $0x18, %esi
callq 0x21a0
movq 0x30(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0xfb19(%rip), %rsi      # 0x550ce
callq 0x21d0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x455cc
movb $0x0, 0x17(%rsp)
jmp 0x455da
movq (%rsp), %rdi
callq 0x2180
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x4560e
cmpq $0x0, 0x8(%rsp)
jne 0x45628
movq 0x10(%rsp), %rsi
leaq 0x11574(%rip), %rdi     # 0x56b8e
movb $0x0, %al
callq 0x2050
xorl %edi, %edi
callq 0x21f0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x21d0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x456aa
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x72, %eax
jne 0x45669
movq 0x10(%rsp), %rsi
leaq 0x11558(%rip), %rdi     # 0x56bb3
movb $0x0, %al
callq 0x2050
xorl %edi, %edi
callq 0x21f0
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x77, %eax
jne 0x45690
movq 0x10(%rsp), %rsi
leaq 0x11551(%rip), %rdi     # 0x56bd3
movb $0x0, %al
callq 0x2050
xorl %edi, %edi
callq 0x21f0
movq 0x10(%rsp), %rsi
leaq 0x11557(%rip), %rdi     # 0x56bf3
movb $0x0, %al
callq 0x2050
xorl %edi, %edi
callq 0x21f0
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
leaq 0xf9f1(%rip), %rsi      # 0x550ce
callq 0x455f0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x45400
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x45700
jmp 0x45733
movq 0x8(%rsp), %rdi
callq 0x45750
testb $0x1, %al
jne 0x45719
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x45731
movq (%rsp), %rdi
callq 0x2220
jmp 0x456e7
movq 0x10(%rsp), %rdi
callq 0x2180
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x47640
movl %eax, 0x4(%rsp)
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
jge 0x457c1
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x20, %eax
je 0x457b4
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x9, %eax
je 0x457b4
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
je 0x457b4
movb $0x0, 0x17(%rsp)
jmp 0x457c6
jmp 0x457b6
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x4576e
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)