LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: extract_region_mids(std::vector<t_annot_region*, std::allocator<t_annot_region*>>*, int)
vector<t_annot_region*>* extract_region_mids(vector<t_annot_region*>* regions, int l_mid_reg)
{
	vector<t_annot_region*>* region_mids = new vector<t_annot_region*>();
	for(int i = 0; i < (int)regions->size(); i++)
	{
		int cur_mid = (regions->at(i)->start + regions->at(i)->end) / 2;
		t_annot_region* cur_mid_reg = get_empty_region();
		cur_mid_reg->chrom = t_string::copy_me_str(regions->at(i)->chrom);
		cur_mid_reg->start = (cur_mid > l_mid_reg/2)?(cur_mid - l_mid_reg/2):(1);
		cur_mid_reg->end = cur_mid + l_mid_reg/2;
		cur_mid_reg->strand = regions->at(i)->strand;

		region_mids->push_back(cur_mid_reg);
	} // i loop.

	return(region_mids);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl $0x18, %edi
callq 0x2190
movq %rax, %rdi
movq %rdi, 0x18(%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x2110
movq 0x18(%rsp), %rdi
callq 0xc670
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x40(%rsp), %rdi
callq 0xc680
movq %rax, %rcx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jge 0x27af5
movq 0x40(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movl 0xc(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x40(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xc800
movq %rax, %rcx
movl 0xc(%rsp), %eax
movq (%rcx), %rcx
addl 0x20(%rcx), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x28(%rsp)
callq 0x27b00
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movq (%rax), %rdi
callq 0x47b60
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movl 0x28(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x3c(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0x10(%rsp), %eax
cmpl %ecx, %eax
jle 0x27a88
movl 0x28(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x3c(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl 0x4(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x8(%rsp)
jmp 0x27a93
movl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x27a93
movl 0x8(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0xc(%rax)
movl 0x28(%rsp), %ecx
movl 0x3c(%rsp), %eax
movl $0x2, %esi
cltd
idivl %esi
addl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x40(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movb 0x8(%rax), %cl
movq 0x20(%rsp), %rax
movb %cl, 0x8(%rax)
movq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xc8c0
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x279b7
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: get_empty_region()
t_annot_region* get_empty_region()
{
	t_annot_region* new_reg = new t_annot_region();
	new_reg->chrom = NULL;
	new_reg->start = 0;
	new_reg->end = 0;
	new_reg->strand = 0;
	new_reg->intervals = 0;
	new_reg->name = 0;
	new_reg->data = NULL;
	new_reg->sort_info = NULL;

	return(new_reg);
}

// Assembly:
subq $0x18, %rsp
movl $0x50, %edi
callq 0x2190
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0x50, %edx
callq 0x2110
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0xc(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x20(%rax)
movq 0x10(%rsp), %rax
movb $0x0, 0x8(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x48(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x38(%rax)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: get_top_region_per_total_coverage(std::vector<t_annot_region*, std::allocator<t_annot_region*>>*, double)
vector<t_annot_region*>* get_top_region_per_total_coverage(vector<t_annot_region*>* regions, double max_covg)
{
	double cur_total_covg = 0;
	vector<t_annot_region*>* top_regions = new vector<t_annot_region*>();
	for(int i_reg = 0; i_reg < (int)regions->size(); i_reg++)
	{
		cur_total_covg += (regions->at(i_reg)->end - regions->at(i_reg)->start + 1);
		top_regions->push_back(regions->at(i_reg));
		if(max_covg == 0 ||
			max_covg <= cur_total_covg)
		{
			break;
		}
	} // i_reg loop.

	return(top_regions);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movsd %xmm0, 0x38(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
movl $0x18, %edi
callq 0x2190
movq %rax, %rdi
movq %rdi, 0x18(%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x2110
movq 0x18(%rsp), %rdi
callq 0xc670
movq 0x18(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x40(%rsp), %rdi
callq 0xc680
movq %rax, %rcx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jge 0x2842a
movq 0x40(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movl 0x20(%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x40(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0xc800
movq %rax, %rcx
movl 0x4(%rsp), %eax
movq (%rcx), %rcx
subl 0xc(%rcx), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
addsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0xc800
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xc8c0
movsd 0x38(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x28404
jp 0x28404
jmp 0x28416
movsd 0x38(%rsp), %xmm1
movsd 0x30(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x28418
jmp 0x2842a
jmp 0x2841a
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x28362
movq 0x28(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: delete_restructured_annot_regions(t_sorted_annot_region_lists*)
void delete_restructured_annot_regions(t_sorted_annot_region_lists* restructured_region_lists)
{
	for(int i_chr = 0; i_chr < (int)restructured_region_lists->chr_ids->size(); i_chr++)
	{
		delete [] restructured_region_lists->chr_ids->at(i_chr);
		delete restructured_region_lists->neg_strand_regions_per_chrom[i_chr];
		delete restructured_region_lists->pos_strand_regions_per_chrom[i_chr];
		delete restructured_region_lists->regions_per_chrom[i_chr];
	} // i_chr loop.

	delete [] restructured_region_lists->neg_strand_regions_per_chrom;
	delete [] restructured_region_lists->pos_strand_regions_per_chrom;
	delete [] restructured_region_lists->regions_per_chrom;
	delete restructured_region_lists->chr_ids;

	delete restructured_region_lists;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xc220
movq %rax, %rcx
movl 0x48(%rsp), %eax
cmpl %ecx, %eax
jge 0x29aa4
movq 0x50(%rsp), %rax
movq 0x18(%rax), %rdi
movslq 0x4c(%rsp), %rsi
callq 0xc240
movq (%rax), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, %rax
je 0x299f1
movq 0x40(%rsp), %rdi
callq 0x2220
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x4c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, %rax
je 0x29a27
movq 0x38(%rsp), %rdi
callq 0xc970
movq 0x38(%rsp), %rdi
movl $0x18, %esi
callq 0x21a0
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x4c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, %rax
je 0x29a5d
movq 0x30(%rsp), %rdi
callq 0xc970
movq 0x30(%rsp), %rdi
movl $0x18, %esi
callq 0x21a0
movq 0x50(%rsp), %rax
movq (%rax), %rax
movslq 0x4c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x29a92
movq 0x28(%rsp), %rdi
callq 0xc970
movq 0x28(%rsp), %rdi
movl $0x18, %esi
callq 0x21a0
jmp 0x29a94
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x299a1
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x29ac2
movq 0x20(%rsp), %rdi
callq 0x2220
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x29ae0
movq 0x18(%rsp), %rdi
callq 0x2220
movq 0x50(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x29afd
movq 0x10(%rsp), %rdi
callq 0x2220
movq 0x50(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x29b2a
movq 0x8(%rsp), %rdi
callq 0xc570
movq 0x8(%rsp), %rdi
movl $0x18, %esi
callq 0x21a0
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x29b47
movq (%rsp), %rdi
movl $0x20, %esi
callq 0x21a0
addq $0x58, %rsp
retq
nopl (%rax)
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: sort_regions(t_annot_region*, t_annot_region*)
bool sort_regions(t_annot_region* region1, t_annot_region* region2)
{
	if(region1->start < region2->start)
	{
		return(true);
	}
	else if(region1->start == region2->start)
	{
		if(region1->end < region2->end)
		{
			return(true);
		}
		else
		{
			return(false);
		}
	}
	else
	{
		return(false);
	}
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movl 0xc(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x2a3c3
movb $0x1, -0x1(%rsp)
jmp 0x2a3fa
movq -0x10(%rsp), %rax
movl 0xc(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x2a3f5
movq -0x10(%rsp), %rax
movl 0x20(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x2a3ee
movb $0x1, -0x1(%rsp)
jmp 0x2a3fa
movb $0x0, -0x1(%rsp)
jmp 0x2a3fa
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: duplicate_region(t_annot_region*)
t_annot_region* duplicate_region(t_annot_region* region_2_dup)
{
	t_annot_region* dup_region = new t_annot_region();

	if(region_2_dup->chrom != NULL)
	{
		dup_region->chrom = new char[strlen(region_2_dup->chrom) + 2];
		strcpy(dup_region->chrom, region_2_dup->chrom);
	}
	else
	{
		dup_region->chrom = NULL;
	}

	if(region_2_dup->name != NULL)
	{
		dup_region->name = new char[strlen(region_2_dup->name) + 2];
		strcpy(dup_region->name, region_2_dup->name);
	}
	else
	{
		dup_region->name = NULL;
	}

	dup_region->start = region_2_dup->start;
	dup_region->end = region_2_dup->end;
	dup_region->strand = region_2_dup->strand;
	dup_region->n_exons = dup_region->n_exons;
	dup_region->score = dup_region->score;
	dup_region->thick_start = dup_region->thick_start;
	dup_region->thick_end = dup_region->thick_end;

	dup_region->intervals = NULL;

	return(dup_region);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x50, %edi
callq 0x2190
movq %rax, %rdi
movq %rdi, (%rsp)
xorl %esi, %esi
movl $0x50, %edx
callq 0x2110
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x2a485
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x20e0
movq %rax, %rdi
addq $0x2, %rdi
callq 0x2040
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
callq 0x2160
jmp 0x2a491
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x2a4dc
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x20e0
movq %rax, %rdi
addq $0x2, %rdi
callq 0x2040
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x2160
jmp 0x2a4e9
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x10(%rsp), %rax
movl 0xc(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x10(%rsp), %rax
movl 0x20(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x10(%rsp), %rax
movb 0x8(%rax), %cl
movq 0x8(%rsp), %rax
movb %cl, 0x8(%rax)
movq 0x8(%rsp), %rax
movl 0x24(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x24(%rax)
movq 0x8(%rsp), %rax
movl 0x10(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x8(%rsp), %rax
movl 0x28(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x28(%rax)
movq 0x8(%rsp), %rax
movl 0x2c(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x2c(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: get_chr_ids(std::vector<t_annot_region*, std::allocator<t_annot_region*>>*)
vector<char*>* get_chr_ids(vector<t_annot_region*>* annot_regions)
{
	//printf("/*Determining*/ the chromosome list from region list.\n");
	vector<char*>* chr_ids = new vector<char*>();

	for(int i_reg = 0; i_reg < (int)annot_regions->size(); i_reg++)
	{
		bool is_new_id = true;

		// Check if the the current chromosome id is included in the list of chromosome ids already collected, otherwise add it.
		for(int i_chr = 0; 
			is_new_id && i_chr < (int)chr_ids->size(); 
			i_chr++)
		{
			if(strcmp(chr_ids->at(i_chr), annot_regions->at(i_reg)->chrom) == 0)
			{
				is_new_id = false;
			}
		} // i_chr loop

		if(is_new_id)
		{
			char* new_id = new char[strlen(annot_regions->at(i_reg)->chrom) + 2];
			strcpy(new_id, annot_regions->at(i_reg)->chrom);
			chr_ids->push_back(new_id); // Add the new id.
		}
	} // i_reg loop.

	//printf("Determined %d chromosomes from region list.\n", chr_ids->size());
	return(chr_ids);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl $0x18, %edi
callq 0x2190
movq %rax, %rdi
movq %rdi, 0x28(%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x2110
movq 0x28(%rsp), %rdi
callq 0xc630
movq 0x28(%rsp), %rax
movq %rax, 0x48(%rsp)
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x50(%rsp), %rdi
callq 0xc680
movq %rax, %rcx
movl 0x24(%rsp), %eax
cmpl %ecx, %eax
jge 0x2aa88
movb $0x1, 0x43(%rsp)
movl $0x0, 0x3c(%rsp)
xorl %eax, %eax
testb $0x1, 0x43(%rsp)
movb %al, 0x23(%rsp)
je 0x2a9b0
movl 0x3c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x48(%rsp), %rdi
callq 0xc220
movq %rax, %rcx
movl 0x1c(%rsp), %eax
cmpl %ecx, %eax
setl %al
movb %al, 0x23(%rsp)
movb 0x23(%rsp), %al
testb $0x1, %al
jne 0x2a9ba
jmp 0x2aa0c
movq 0x48(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0xc240
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
movslq 0x44(%rsp), %rsi
callq 0xc800
movq 0x10(%rsp), %rdi
movq (%rax), %rax
movq (%rax), %rsi
callq 0x2240
cmpl $0x0, %eax
jne 0x2a9fa
movb $0x0, 0x43(%rsp)
jmp 0x2a9fc
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x2a981
testb $0x1, 0x43(%rsp)
je 0x2aa76
movq 0x50(%rsp), %rdi
movslq 0x44(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movq (%rax), %rdi
callq 0x20e0
movq %rax, %rdi
addq $0x2, %rdi
callq 0x2040
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
movslq 0x44(%rsp), %rsi
callq 0xc800
movq 0x8(%rsp), %rdi
movq (%rax), %rax
movq (%rax), %rsi
callq 0x2160
movq 0x48(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x1fbe0
jmp 0x2aa78
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x2a953
movq 0x48(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: check_line_skip(char*)
bool check_line_skip(char* cur_line)
{
	// Skip empty lines.
	if(strlen(cur_line) == 0)
	{
		return(true);
	}

	// Check comment.
	if(cur_line[0] == '#')
	{
		return(true);
	}
	
	// Check track info line.
	char* first_word = new char[strlen(cur_line) + 2];
	strcpy(first_word, cur_line);
	sscanf(cur_line, "%s", first_word);

	if(strcmp(first_word, "track") == 0)
	{
		delete [] first_word;
		return(true);
	}

	delete [] first_word;

	return(false);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x20e0
cmpq $0x0, %rax
jne 0x2b483
movb $0x1, 0x27(%rsp)
jmp 0x2b530
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x2b49a
movb $0x1, 0x27(%rsp)
jmp 0x2b530
movq 0x18(%rsp), %rdi
callq 0x20e0
movq %rax, %rdi
addq $0x2, %rdi
callq 0x2040
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2160
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x2a429(%rip), %rsi     # 0x558fe
movb $0x0, %al
callq 0x2170
movq 0x10(%rsp), %rdi
leaq 0x2acb8(%rip), %rsi     # 0x561a0
callq 0x2240
cmpl $0x0, %eax
jne 0x2b513
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x2b50c
movq 0x8(%rsp), %rdi
callq 0x2220
movb $0x1, 0x27(%rsp)
jmp 0x2b530
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x2b52b
movq (%rsp), %rdi
callq 0x2220
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: validate_region_coords(std::vector<t_annot_region*, std::allocator<t_annot_region*>>*)
bool validate_region_coords(vector<t_annot_region*>* regions)
{
	for(int i_reg = 0; i_reg < (int)regions->size(); i_reg++)
	{
		if(regions->at(i_reg)->start > regions->at(i_reg)->end)
		{
			fprintf(stderr, "%s:%d-%d is not valid.\n", regions->at(i_reg)->chrom, regions->at(i_reg)->start, regions->at(i_reg)->end);
			return(false);
		}
	} // i_reg loop.

	return(true);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0xc680
movq %rax, %rcx
movl 0x20(%rsp), %eax
cmpl %ecx, %eax
jge 0x2bb36
movq 0x28(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movl 0xc(%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0xc800
movq %rax, %rcx
movl 0x1c(%rsp), %eax
movq (%rcx), %rcx
cmpl 0x20(%rcx), %eax
jle 0x2bb24
movq 0x39530(%rip), %rax     # 0x64fe0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movl 0xc(%rax), %eax
movl %eax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0xc800
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movl 0x18(%rsp), %ecx
movq (%rax), %rax
movl 0x20(%rax), %r8d
leaq 0x2a7ba(%rip), %rsi     # 0x562d0
movb $0x0, %al
callq 0x2250
movb $0x0, 0x37(%rsp)
jmp 0x2bb3b
jmp 0x2bb26
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x2ba51
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: dump_BED_w_p_values(std::vector<t_annot_region*, std::allocator<t_annot_region*>>*, char*)
void dump_BED_w_p_values(vector<t_annot_region*>* regions, char* op_fp)
{
	FILE* f_op = open_f(op_fp, "w");

	for(int i_reg = 0; i_reg < (int)regions->size(); i_reg++)
	{
		t_significance_info* sig_info = (t_significance_info*)(regions->at(i_reg)->significance_info);
		fprintf(f_op, "%s\t%d\t%d\t.\t%lf\t%c\n", regions->at(i_reg)->chrom, regions->at(i_reg)->start, regions->at(i_reg)->end, sig_info->log_p_val / log(10.0), regions->at(i_reg)->strand);
	} // i_reg loop.

	fclose(f_op);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x26e9a(%rip), %rsi     # 0x52aa4
callq 0x455f0
movq %rax, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x2c(%rsp)
movq 0x50(%rsp), %rdi
callq 0xc680
movq %rax, %rcx
movl 0x2c(%rsp), %eax
cmpl %ecx, %eax
jge 0x2bd29
movq 0x50(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movq 0x40(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movl 0xc(%rax), %eax
movl %eax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movl 0x20(%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movsd 0x290bc(%rip), %xmm0    # 0x54d80
callq 0x2140
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x50(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0xc800
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movl 0x18(%rsp), %ecx
movl 0x1c(%rsp), %r8d
movsd 0x20(%rsp), %xmm0
movq (%rax), %rax
movsbl 0x8(%rax), %r9d
leaq 0x2a1da(%rip), %rsi     # 0x55eec
movb $0x1, %al
callq 0x2250
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x2bc1c
movq 0x40(%rsp), %rdi
callq 0x2180
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: dump_BED_w_q_values(std::vector<t_annot_region*, std::allocator<t_annot_region*>>*, char*)
void dump_BED_w_q_values(vector<t_annot_region*>* regions, char* op_fp)
{
	FILE* f_op = open_f(op_fp, "w");

	for(int i_reg = 0; i_reg < (int)regions->size(); i_reg++)
	{
		t_significance_info* sig_info = (t_significance_info*)(regions->at(i_reg)->significance_info);
		fprintf(f_op, "%s\t%d\t%d\t.\t%lf\t%c\n", regions->at(i_reg)->chrom, regions->at(i_reg)->start, regions->at(i_reg)->end, sig_info->log_q_val, regions->at(i_reg)->strand);
	} // i_reg loop.

	fclose(f_op);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x26d4a(%rip), %rsi     # 0x52aa4
callq 0x455f0
movq %rax, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x2c(%rsp)
movq 0x50(%rsp), %rdi
callq 0xc680
movq %rax, %rcx
movl 0x2c(%rsp), %eax
cmpl %ecx, %eax
jge 0x2be5c
movq 0x50(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movq 0x40(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movl 0xc(%rax), %eax
movl %eax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movl 0x20(%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x50(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0xc800
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movl 0x18(%rsp), %ecx
movl 0x1c(%rsp), %r8d
movsd 0x20(%rsp), %xmm0
movq (%rax), %rax
movsbl 0x8(%rax), %r9d
leaq 0x2a0a7(%rip), %rsi     # 0x55eec
movb $0x1, %al
callq 0x2250
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x2bd6c
movq 0x40(%rsp), %rdi
callq 0x2180
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: load_BED_w_p_values(char*)
vector<t_annot_region*>* load_BED_w_p_values(char* regions_bed_fp)
{
	// Load the BED file with scores.
	vector<t_annot_region*>* regions = new vector<t_annot_region*>();
	FILE* f_reg = open_f(regions_bed_fp, "r");
	while(1)
	{
		char* cur_line = getline(f_reg);
		if(cur_line == NULL)
		{
			break;
		}

		char chrom[1000];
		int start;
		int end;
		double log_p_val = 0;

		if(sscanf(cur_line, "%s %d %d %*s %lf", chrom, &start, &end, &log_p_val) != 4)
		{
			fprintf(stderr, "Could not parse %s", cur_line);
			exit(0);
		}

		t_significance_info* cur_reg_sig_info = new t_significance_info();
		cur_reg_sig_info->log_p_val = log_p_val;
		cur_reg_sig_info->log_q_val = 0.0;

		t_annot_region* cur_reg = get_empty_region();
		cur_reg->chrom = t_string::copy_me_str(chrom);
		cur_reg->start = start;
		cur_reg->end = end;
		cur_reg->strand = '+';
		cur_reg->significance_info = cur_reg_sig_info;

		regions->push_back(cur_reg);
	} // reg file reading loop.
	fclose(f_reg);

	return(regions);
}

// Assembly:
subq $0x438, %rsp            # imm = 0x438
movq %rdi, 0x430(%rsp)
movl $0x18, %edi
callq 0x2190
movq %rax, %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x2110
movq 0x8(%rsp), %rdi
callq 0xc670
movq 0x8(%rsp), %rax
movq %rax, 0x428(%rsp)
movq 0x430(%rsp), %rdi
leaq 0x2920b(%rip), %rsi     # 0x550ce
callq 0x455f0
movq %rax, 0x420(%rsp)
movq 0x420(%rsp), %rdi
callq 0x45400
movq %rax, 0x418(%rsp)
cmpq $0x0, 0x418(%rsp)
jne 0x2bef5
jmp 0x2bffb
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x418(%rsp), %rdi
leaq 0x30(%rsp), %rdx
leaq 0x29fed(%rip), %rsi     # 0x55eff
leaq 0x2c(%rsp), %rcx
leaq 0x28(%rsp), %r8
leaq 0x20(%rsp), %r9
movb $0x0, %al
callq 0x2170
cmpl $0x4, %eax
je 0x2bf54
movq 0x390ac(%rip), %rax     # 0x64fe0
movq (%rax), %rdi
movq 0x418(%rsp), %rdx
leaq 0x29fca(%rip), %rsi     # 0x55f10
movb $0x0, %al
callq 0x2250
xorl %edi, %edi
callq 0x21f0
movl $0x10, %edi
callq 0x2190
movq %rax, %rdi
movq %rdi, (%rsp)
xorl %esi, %esi
movl $0x10, %edx
callq 0x2110
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x18(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
callq 0x27b00
movq %rax, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x47b60
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movl 0x2c(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0xc(%rax)
movl 0x28(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x10(%rsp), %rax
movb $0x2b, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x428(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xc8c0
jmp 0x2bed0
movq 0x420(%rsp), %rdi
callq 0x2180
movq 0x428(%rsp), %rax
addq $0x438, %rsp            # imm = 0x438
retq
nopl (%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: get_benjamini_hochberg_corrected_p_values(std::vector<t_annot_region*, std::allocator<t_annot_region*>>*)
void get_benjamini_hochberg_corrected_p_values(vector<t_annot_region*>* regions)
{
	sort(regions->begin(), regions->end(), sort_regions_per_increasing_p_value);

	// Do BH corrections.
	for(int i_reg = 0; i_reg < (int)regions->size(); i_reg++)
	{
		double cur_region_rank = (double)i_reg + 1;

		t_significance_info* cur_reg_sig_info = regions->at(i_reg)->significance_info;
		cur_reg_sig_info->log_q_val = (cur_reg_sig_info->log_p_val + log((double)regions->size() / (double)cur_region_rank));
	} // i_reg loop.

	// Sort with respect to q-values.
	sort(regions->begin(), regions->end(), sort_regions_per_increasing_q_value);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0xc7d0
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0xc760
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
leaq -0x508(%rip), %rdx      # 0x2bb50
callq 0x31d00
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x50(%rsp), %rdi
callq 0xc680
movq %rax, %rcx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jge 0x2c12b
cvtsi2sdl 0x3c(%rsp), %xmm0
movsd 0x25f84(%rip), %xmm1    # 0x52018
addsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x50(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movq 0x40(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x50(%rsp), %rdi
callq 0xc680
movq %rax, %xmm0
movaps 0x29bb2(%rip), %xmm1    # 0x55c90
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x29bb6(%rip), %xmm1    # 0x55ca0
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
divsd 0x30(%rsp), %xmm0
callq 0x2140
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm0
movq 0x28(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x2c065
movq 0x50(%rsp), %rdi
callq 0xc7d0
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rdi
callq 0xc760
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq -0x5ba(%rip), %rdx      # 0x2bba0
callq 0x31d00
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: get_all_intervals_per_composite_intervals(std::vector<t_annot_region*, std::allocator<t_annot_region*>>*)
vector<t_annot_region*>* get_all_intervals_per_composite_intervals(vector<t_annot_region*>* composite_intervals)
{
	vector<t_annot_region*>* all_intervals = new vector<t_annot_region*>();
	for(int i_reg = 0; i_reg < (int)composite_intervals->size(); i_reg++)
	{
		vector<t_annot_region*>* cur_intervals = composite_intervals->at(i_reg)->intervals;

		for(int i_int = 0; i_int < (int)cur_intervals->size(); i_int++)
		{
			all_intervals->push_back(cur_intervals->at(i_int));
		} // i_int loop.
	} // i_reg loop.

	return(all_intervals);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl $0x18, %edi
callq 0x2190
movq %rax, %rdi
movq %rdi, 0x18(%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x2110
movq 0x18(%rsp), %rdi
callq 0xc670
movq 0x18(%rsp), %rax
movq %rax, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x40(%rsp), %rdi
callq 0xc680
movq %rax, %rcx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jge 0x2c839
movq 0x40(%rsp), %rdi
movslq 0x34(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movq 0x30(%rax), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0xc680
movq %rax, %rcx
movl 0x10(%rsp), %eax
cmpl %ecx, %eax
jge 0x2c827
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movslq 0x24(%rsp), %rsi
callq 0xc800
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xc8c0
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x2c7d7
jmp 0x2c829
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x2c793
movq 0x38(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: coverage(std::vector<t_annot_region*, std::allocator<t_annot_region*>>*)
double coverage(vector<t_annot_region*>* annot_regions)
{
	double covrg = 0.0;

	for(int i_reg = 0; i_reg < (int)annot_regions->size(); i_reg++)
	{
		if(annot_regions->at(i_reg) != NULL)
		{
			if(annot_regions->at(i_reg)->end < annot_regions->at(i_reg)->start)
			{
				//printf("Region %d has its start index larger than its end index: %d, %d\n", i_reg, 
				//	annot_regions->at(i_reg)->start,
				//	annot_regions->at(i_reg)->end);
			}
			else
			{
				covrg += annot_regions->at(i_reg)->end - annot_regions->at(i_reg)->start + 1;
			}
		}
	} // i_reg loop.

	return(covrg);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0xc680
movq %rax, %rcx
movl 0x10(%rsp), %eax
cmpl %ecx, %eax
jge 0x2cfb9
movq 0x20(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0xc800
cmpq $0x0, (%rax)
je 0x2cfa7
movq 0x20(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movl 0x20(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0xc800
movq %rax, %rcx
movl 0xc(%rsp), %eax
movq (%rcx), %rcx
cmpl 0xc(%rcx), %eax
jge 0x2cf5d
jmp 0x2cfa5
movq 0x20(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movl 0x20(%rax), %eax
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0xc800
movq %rax, %rcx
movl 0x8(%rsp), %eax
movq (%rcx), %rcx
subl 0xc(%rcx), %eax
addl $0x1, %eax
cvtsi2sd %eax, %xmm0
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
jmp 0x2cfa7
jmp 0x2cfa9
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2ceea
movsd 0x18(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: nuc_overlap(std::vector<t_annot_region*, std::allocator<t_annot_region*>>*, std::vector<t_annot_region*, std::allocator<t_annot_region*>>*)
double nuc_overlap(vector<t_annot_region*>* annot_regions1, 
					vector<t_annot_region*>* annot_regions2)
{
	// Compute the coverage of overlap divided by the coverage of all regions.
	vector<t_annot_region*>* overlapping_regions = intersect_annot_regions(annot_regions1, annot_regions2, false);

	int overlap_cvg = (int)(coverage(overlapping_regions));
	int total_cvg = (int)(coverage(annot_regions1) + coverage(annot_regions2));

	if(total_cvg == 0)
	{
		return 0.0;
	}

	return((double)(2 * overlap_cvg) / total_cvg);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
xorl %edx, %edx
callq 0x2d070
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x2ced0
cvttsd2si %xmm0, %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2ced0
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2ced0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jne 0x2d047
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x2d061
movl 0x14(%rsp), %eax
shll %eax
cvtsi2sd %eax, %xmm0
cvtsi2sdl 0x10(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax)
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: nuc_overlap_src_over_src_overlap(std::vector<t_annot_region*, std::allocator<t_annot_region*>>*, std::vector<t_annot_region*, std::allocator<t_annot_region*>>*)
double nuc_overlap_src_over_src_overlap(vector<t_annot_region*>* annot_regions1, 
										vector<t_annot_region*>* annot_regions2)
{
	// Get the overlapping regions in each list: Fix the indices: Batch intersection returns only the overlapping regions.
	vector<t_annot_region*>* overlapping_regions1 = intersect_annot_regions(annot_regions1, annot_regions2, false);
	int n_overlaps = 0;
	for(int i_reg = 0; i_reg < (int)overlapping_regions1->size(); i_reg++)
	{
		if(overlapping_regions1->at(i_reg) != NULL)
		{
			//overlapping_regions1->at(i_reg)->start = annot_regions1->at(i_reg)->start;
			//overlapping_regions1->at(i_reg)->end = annot_regions1->at(i_reg)->end;
			n_overlaps++;
		}
	} // i_reg loop.

	//vector<t_annot_region*>* overlapping_regions2 = intersect_annot_regions(annot_regions2, annot_regions1, false);

	//for(int i_reg = 0; i_reg < overlapping_regions2->size(); i_reg++)
	//{
	//	if(overlapping_regions2->at(i_reg) != NULL)
	//	{
	//		if(strcmp(overlapping_regions2->at(i_reg)->chrom, annot_regions2->at(i_reg)->chrom) != 0 ||
	//			overlapping_regions2->at(i_reg)->end > annot_regions2->at(i_reg)->end ||
	//			overlapping_regions2->at(i_reg)->start < annot_regions2->at(i_reg)->start)
	//		{
	//			printf("overlapping did not work!\n");
	//			exit(0);
	//		}

	//		overlapping_regions2->at(i_reg)->start = annot_regions2->at(i_reg)->start;
	//		overlapping_regions2->at(i_reg)->end = annot_regions2->at(i_reg)->end;
	//	}
	//} // i_reg loop.

	//int overlap_cvg = coverage(overlapping_regions);
	//int src_cvg = coverage(overlapping_regions1);

	int overlap_cvg = n_overlaps;
	int src_cvg = (int)annot_regions1->size();

	//if(src_cvg == 0)
	//{
	//	return 0.0;
	//}
	printf("%d/%d\n", overlap_cvg, src_cvg);
	return((double)(overlap_cvg) / src_cvg);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
xorl %edx, %edx
callq 0x2d070
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
callq 0xc680
movq %rax, %rcx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x2d8b0
movq 0x20(%rsp), %rdi
movslq 0x18(%rsp), %rsi
callq 0xc800
cmpq $0x0, (%rax)
je 0x2d8a1
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2d8a3
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x2d864
movl 0x1c(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rdi
callq 0xc680
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
leaq 0x28849(%rip), %rdi     # 0x5611e
movb $0x0, %al
callq 0x2050
cvtsi2sdl 0x14(%rsp), %xmm0
cvtsi2sdl 0x10(%rsp), %xmm1
divsd %xmm1, %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: get_reg2reg_distance(t_annot_region*, t_annot_region*)
int get_reg2reg_distance(t_annot_region* reg1, t_annot_region* reg2)
{
	if(reg1->start > reg2->end)
	{
		// Region 1 is to the right of region 2.
		return(reg1->start - reg2->end);
	}
	else if(reg2->start > reg1->end)
	{
		// Region 2 is to the right of region 1.
		return(reg2->start - reg1->end);
	}
	else
	{
		// The regions are overlapping.
		return(0);
	}
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movl 0xc(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jle 0x2df92
movq -0x10(%rsp), %rax
movl 0xc(%rax), %eax
movq -0x18(%rsp), %rcx
subl 0x20(%rcx), %eax
movl %eax, -0x4(%rsp)
jmp 0x2dfc2
movq -0x18(%rsp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jle 0x2dfba
movq -0x18(%rsp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rsp), %rcx
subl 0x20(%rcx), %eax
movl %eax, -0x4(%rsp)
jmp 0x2dfc2
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: get_regions_per_chromosome(std::vector<t_annot_region*, std::allocator<t_annot_region*>>*, char*)
vector<t_annot_region*>* get_regions_per_chromosome(vector<t_annot_region*>* annot_regions,
													char* chr_id)
{
	vector<t_annot_region*>* chr_regions = new vector<t_annot_region*>();

	for(int i_reg = 0; i_reg < (int)annot_regions->size(); i_reg++)
	{
		//bool new_id = false;

		// Check if the the current chromosome id is included in the list of chromosome ids already collected, otherwise add it.
		if(strcmp(annot_regions->at(i_reg)->chrom, chr_id) == 0)
		{
			// Add the current region to the chromosome regions.
			chr_regions->push_back(annot_regions->at(i_reg));
		}
	} // i_reg loop.

	return(chr_regions);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0x18, %edi
callq 0x2190
movq %rax, %rdi
movq %rdi, 0x10(%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x2110
movq 0x10(%rsp), %rdi
callq 0xc670
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
callq 0xc680
movq %rax, %rcx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x2e29c
movq 0x30(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movq (%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0x2240
cmpl $0x0, %eax
jne 0x2e28d
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0xc800
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xc8c0
jmp 0x2e28f
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2e228
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: get_regions_per_strand(std::vector<t_annot_region*, std::allocator<t_annot_region*>>*, char)
vector<t_annot_region*>* get_regions_per_strand(vector<t_annot_region*>* annot_regions,
													char strand)
{
	vector<t_annot_region*>* chr_regions = new vector<t_annot_region*>();

	for(int i_reg = 0; i_reg < (int)annot_regions->size(); i_reg++)
	{
		//bool new_id = false;

		// Check if the the current chromosome id is included in the list of chromosome ids already collected, otherwise add it.
		if(annot_regions->at(i_reg)->strand == strand)
		{
			// Add the current region to the chromosome regions.
			chr_regions->push_back(annot_regions->at(i_reg));
		}
	} // i_reg loop.

	return(chr_regions);
}

// Assembly:
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x30(%rsp)
movb %al, 0x2f(%rsp)
movl $0x18, %edi
callq 0x2190
movq %rax, %rdi
movq %rdi, 0x10(%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x2110
movq 0x10(%rsp), %rdi
callq 0xc670
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
callq 0xc680
movq %rax, %rcx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x2edc9
movq 0x30(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movsbl 0x8(%rax), %eax
movsbl 0x2f(%rsp), %ecx
cmpl %ecx, %eax
jne 0x2edba
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0xc800
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xc8c0
jmp 0x2edbc
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2ed5a
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: delete_annot_regions(std::vector<t_annot_region*, std::allocator<t_annot_region*>>*)
void delete_annot_regions(vector<t_annot_region*>* region_list)
{
	for(int i_reg = 0; i_reg < (int)region_list->size(); i_reg++)
	{
		if(region_list->at(i_reg) != NULL)
		{
			delete [] region_list->at(i_reg)->chrom;

			if(region_list->at(i_reg)->name != NULL)
			{
				delete [] region_list->at(i_reg)->name;
			}

			delete(region_list->at(i_reg));
		}
	} // i_reg loop.

	region_list->clear();
	delete(region_list);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0xc680
movq %rax, %rcx
movl 0x28(%rsp), %eax
cmpl %ecx, %eax
jge 0x2f65b
movq 0x30(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xc800
cmpq $0x0, (%rax)
je 0x2f649
movq 0x30(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x2f5d5
movq 0x20(%rsp), %rdi
callq 0x2220
movq 0x30(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x2f61b
movq 0x30(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x2f619
movq 0x18(%rsp), %rdi
callq 0x2220
jmp 0x2f61b
movq 0x30(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x2f647
movq 0x10(%rsp), %rdi
movl $0x50, %esi
callq 0x21a0
jmp 0x2f649
jmp 0x2f64b
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x2f571
movq 0x30(%rsp), %rdi
callq 0x31d90
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x2f68e
movq 0x8(%rsp), %rdi
callq 0xc970
movq 0x8(%rsp), %rdi
movl $0x18, %esi
callq 0x21a0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: delete_intersect_info(std::vector<t_annot_region*, std::allocator<t_annot_region*>>*)
void delete_intersect_info(vector<t_annot_region*>* regions)
{
	for(int i_reg = 0; i_reg < (int)regions->size(); i_reg++)
	{
		if(regions->at(i_reg)->data != NULL)
		{
			t_intersect_info* intersect_info = (t_intersect_info*)(regions->at(i_reg)->data);
			delete intersect_info;
		}
	} // i_reg loop.
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
callq 0xc680
movq %rax, %rcx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x2fa50
movq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
cmpq $0x0, 0x48(%rax)
je 0x2fa41
movq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movq 0x48(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x2fa3f
movq (%rsp), %rdi
movl $0x18, %esi
callq 0x21a0
jmp 0x2fa41
jmp 0x2fa43
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2f9d1
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: get_regions_per_end_max(std::vector<t_annot_region*, std::allocator<t_annot_region*>>*, int)
vector<t_annot_region*>* get_regions_per_end_max(vector<t_annot_region*>* annot_regions, int end_max)
{
	vector<t_annot_region*>* end_max_regs = new vector<t_annot_region*>();
	for(int i_reg = 0; i_reg < (int)annot_regions->size(); i_reg++)
	{
		if(annot_regions->at(i_reg)->end < end_max)
		{
			end_max_regs->push_back(annot_regions->at(i_reg));
		}
	} // i_reg loop.

	return(end_max_regs);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl $0x18, %edi
callq 0x2190
movq %rax, %rdi
movq %rdi, 0x10(%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x2110
movq 0x10(%rsp), %rdi
callq 0xc670
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
callq 0xc680
movq %rax, %rcx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x2fb12
movq 0x30(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movl 0x20(%rax), %eax
cmpl 0x2c(%rsp), %eax
jge 0x2fb03
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0xc800
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xc8c0
jmp 0x2fb05
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2faa7
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: get_regions_per_min_run(std::vector<t_annot_region*, std::allocator<t_annot_region*>>*, int)
vector<t_annot_region*>* get_regions_per_min_run(vector<t_annot_region*>* annot_regions, int l_min_run)
{
	vector<t_annot_region*>* min_run_regs = new vector<t_annot_region*>();
	for(int i_reg = 0; i_reg < (int)annot_regions->size(); i_reg++)
	{
		if(annot_regions->at(i_reg)->end - annot_regions->at(i_reg)->start > l_min_run)
		{
			min_run_regs->push_back(annot_regions->at(i_reg));
		}
	} // i_reg loop.

	return(min_run_regs);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl $0x18, %edi
callq 0x2190
movq %rax, %rdi
movq %rdi, 0x10(%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x2110
movq 0x10(%rsp), %rdi
callq 0xc670
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
callq 0xc680
movq %rax, %rcx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x2fbf5
movq 0x30(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movl 0x20(%rax), %eax
movl %eax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0xc800
movq %rax, %rcx
movl 0x8(%rsp), %eax
movq (%rcx), %rcx
subl 0xc(%rcx), %eax
cmpl 0x2c(%rsp), %eax
jle 0x2fbe3
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0xc800
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xc8c0
jmp 0x2fbe5
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2fb67
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: get_regions_per_max_run(std::vector<t_annot_region*, std::allocator<t_annot_region*>>*, int)
vector<t_annot_region*>* get_regions_per_max_run(vector<t_annot_region*>* annot_regions, int l_max_run)
{
	vector<t_annot_region*>* min_run_regs = new vector<t_annot_region*>();
	for(int i_reg = 0; i_reg < (int)annot_regions->size(); i_reg++)
	{
		if(annot_regions->at(i_reg)->end - annot_regions->at(i_reg)->start < l_max_run)
		{
			min_run_regs->push_back(annot_regions->at(i_reg));
		}
	} // i_reg loop.

	return(min_run_regs);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl $0x18, %edi
callq 0x2190
movq %rax, %rdi
movq %rdi, 0x10(%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x2110
movq 0x10(%rsp), %rdi
callq 0xc670
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x30(%rsp), %rdi
callq 0xc680
movq %rax, %rcx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x2fcd5
movq 0x30(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movl 0x20(%rax), %eax
movl %eax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0xc800
movq %rax, %rcx
movl 0x8(%rsp), %eax
movq (%rcx), %rcx
subl 0xc(%rcx), %eax
cmpl 0x2c(%rsp), %eax
jge 0x2fcc3
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
movslq 0x1c(%rsp), %rsi
callq 0xc800
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xc8c0
jmp 0x2fcc5
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2fc47
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nop