LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: get_left_flanking_regions(std::vector<t_annot_region*, std::allocator<t_annot_region*>>*, int)
vector<t_annot_region*>* get_left_flanking_regions(vector<t_annot_region*>* regions, int l_flank)
{
	vector<t_annot_region*>* left_flanking_regions = new vector<t_annot_region*>();

	for(int i_reg = 0; i_reg < (int)regions->size(); i_reg++)
	{
		t_annot_region* new_region = new t_annot_region();
		new_region->chrom = new char[strlen(regions->at(i_reg)->chrom) + 2];
		strcpy(new_region->chrom, regions->at(i_reg)->chrom);
		new_region->start = (regions->at(i_reg)->start > l_flank)?(regions->at(i_reg)->start - l_flank):1;
		new_region->end = regions->at(i_reg)->start;
		new_region->strand = regions->at(i_reg)->strand;

		left_flanking_regions->push_back(new_region);
	} // i_reg loop.

	return(left_flanking_regions);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%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 0xc670
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x50(%rsp), %rdi
callq 0xc680
movq %rax, %rcx
movl 0x24(%rsp), %eax
cmpl %ecx, %eax
jge 0x2fe77
movl $0x50, %edi
callq 0x2190
movq %rax, %rdi
movq %rdi, 0x10(%rsp)
xorl %esi, %esi
movl $0x50, %edx
callq 0x2110
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movq (%rax), %rdi
callq 0x20e0
movq %rax, %rdi
addq $0x2, %rdi
callq 0x2040
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0xc800
movq 0x18(%rsp), %rdi
movq (%rax), %rax
movq (%rax), %rsi
callq 0x2160
movq 0x50(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movl 0xc(%rax), %eax
cmpl 0x4c(%rsp), %eax
jle 0x2fe07
movq 0x50(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movl 0xc(%rax), %eax
subl 0x4c(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x2fe12
movl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2fe12
movl 0xc(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x50(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movl 0xc(%rax), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x50(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movb 0x8(%rax), %cl
movq 0x30(%rsp), %rax
movb %cl, 0x8(%rax)
movq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xc8c0
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x2fd27
movq 0x40(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: load_chromosome_lengths_per_tabbed_file(char*, std::vector<char*, std::allocator<char*>>*, std::vector<int, std::allocator<int>>*)
void load_chromosome_lengths_per_tabbed_file(char* chr_lengths_fp, vector<char*>* chr_ids, vector<int>* chr_lengths)
{
	FILE* f_l_chrs = open_f(chr_lengths_fp, "r");

	while(1)
	{
		char* cur_line = getline(f_l_chrs);
		if(cur_line == NULL)
		{
			break;
		}

		char cur_chr_id[1000];
		int cur_l_chr = 0;
		if(sscanf(cur_line, "%s %d", cur_chr_id, &cur_l_chr) != 2)
		{
			fprintf(stderr, "Could not read chromosome lengths from: %s\n", cur_line);
			exit(0);
		} // check if reading is succesful.

		chr_ids->push_back(t_string::copy_me_str(cur_chr_id));
		chr_lengths->push_back(cur_l_chr);
	} // file reading loop.

	fclose(f_l_chrs);
}

// Assembly:
subq $0x438, %rsp            # imm = 0x438
movq %rdi, 0x430(%rsp)
movq %rsi, 0x428(%rsp)
movq %rdx, 0x420(%rsp)
movq 0x430(%rsp), %rdi
leaq 0x25210(%rip), %rsi     # 0x550ce
callq 0x455f0
movq %rax, 0x418(%rsp)
movq 0x418(%rsp), %rdi
callq 0x45400
movq %rax, 0x410(%rsp)
cmpq $0x0, 0x410(%rsp)
jne 0x2fef0
jmp 0x2ff86
movl $0x0, 0x1c(%rsp)
movq 0x410(%rsp), %rdi
leaq 0x20(%rsp), %rdx
leaq 0x26311(%rip), %rsi     # 0x5621d
leaq 0x1c(%rsp), %rcx
movb $0x0, %al
callq 0x2170
cmpl $0x2, %eax
je 0x2ff44
movq 0x350bc(%rip), %rax     # 0x64fe0
movq (%rax), %rdi
movq 0x410(%rsp), %rdx
leaq 0x262ed(%rip), %rsi     # 0x56223
movb $0x0, %al
callq 0x2250
xorl %edi, %edi
callq 0x21f0
movq 0x428(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x47b60
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
callq 0xc640
movq 0x420(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0xc340
jmp 0x2fecb
movq 0x418(%rsp), %rdi
callq 0x2180
addq $0x438, %rsp            # imm = 0x438
retq
nopl (%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: get_right_flanking_regions(std::vector<t_annot_region*, std::allocator<t_annot_region*>>*, int)
vector<t_annot_region*>* get_right_flanking_regions(vector<t_annot_region*>* regions, int l_flank)
{
	vector<t_annot_region*>* right_flanking_regions = new vector<t_annot_region*>();

	for(int i_reg = 0; i_reg < (int)regions->size(); i_reg++)
	{
		t_annot_region* new_region = new t_annot_region();
		new_region->chrom = new char[strlen(regions->at(i_reg)->chrom) + 2];
		strcpy(new_region->chrom, regions->at(i_reg)->chrom);
		new_region->start = regions->at(i_reg)->end;
		new_region->end = regions->at(i_reg)->end + l_flank;
		new_region->strand = regions->at(i_reg)->strand;

		right_flanking_regions->push_back(new_region);
	} // i_reg loop.

	return(right_flanking_regions);
}

// 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 0x30105
movl $0x50, %edi
callq 0x2190
movq %rax, %rdi
movq %rdi, (%rsp)
xorl %esi, %esi
movl $0x50, %edx
callq 0x2110
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movq (%rax), %rdi
callq 0x20e0
movq %rax, %rdi
addq $0x2, %rdi
callq 0x2040
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xc800
movq 0x8(%rsp), %rdi
movq (%rax), %rax
movq (%rax), %rsi
callq 0x2160
movq 0x40(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movl 0x20(%rax), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x40(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movl 0x20(%rax), %ecx
addl 0x3c(%rsp), %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 0x2ffe7
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: delete_annot_regions(t_annot_region*)
void delete_annot_regions(t_annot_region* region)
{
	if(region != NULL)
	{
		delete [] region->chrom;

		if(region->name != NULL)
		{
			delete [] region->name;
		}

		delete(region);
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x30e3b
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x30dee
movq 0x18(%rsp), %rdi
callq 0x2220
movq 0x20(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x30e1a
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x30e18
movq 0x10(%rsp), %rdi
callq 0x2220
jmp 0x30e1a
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x30e39
movq 0x8(%rsp), %rdi
movl $0x50, %esi
callq 0x21a0
jmp 0x30e3b
addq $0x28, %rsp
retq
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: merge_annot_regions(std::vector<t_annot_region*, std::allocator<t_annot_region*>>*, std::vector<t_annot_region*, std::allocator<t_annot_region*>>*, int, bool)
vector<t_annot_region*>* merge_annot_regions(vector<t_annot_region*>* annot_regions1,
											vector<t_annot_region*>* annot_regions2,
											int max_gap, 
											bool match_strands) // Maximum distance between two annotated regions that are in the merged region.
{
	fprintf(stderr, "Merging %ld versus %ld regions.\n", annot_regions1->size(), annot_regions2->size());

	vector<t_annot_region*>* total_annot_regions = new vector<t_annot_region*>();
	for(int i = 0; i < (int)annot_regions1->size(); i++)
	{
		total_annot_regions->push_back(annot_regions1->at(i));
	} // i loop.

	for(int i = 0; i < (int)annot_regions2->size(); i++)
	{
		total_annot_regions->push_back(annot_regions2->at(i));
	} // i loop.

	vector<t_annot_region*>* merged_annot_regions = merge_annot_regions(total_annot_regions,
																			max_gap, 
																			match_strands);

	delete(total_annot_regions);

	return(merged_annot_regions);
}

// Assembly:
subq $0x78, %rsp
movb %cl, %al
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
andb $0x1, %al
movb %al, 0x63(%rsp)
movq 0x3417f(%rip), %rax     # 0x64fe0
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x70(%rsp), %rdi
callq 0xc680
movq %rax, 0x38(%rsp)
movq 0x68(%rsp), %rdi
callq 0xc680
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rdx
movq %rax, %rcx
leaq 0x253b9(%rip), %rsi     # 0x5624f
movb $0x0, %al
callq 0x2250
movl $0x18, %edi
callq 0x2190
movq %rax, %rdi
movq %rdi, 0x40(%rsp)
xorl %esi, %esi
movl $0x18, %edx
callq 0x2110
movq 0x40(%rsp), %rdi
callq 0xc670
movq 0x40(%rsp), %rax
movq %rax, 0x58(%rsp)
movl $0x0, 0x54(%rsp)
movl 0x54(%rsp), %eax
movl %eax, 0x2c(%rsp)
movq 0x70(%rsp), %rdi
callq 0xc680
movq %rax, %rcx
movl 0x2c(%rsp), %eax
cmpl %ecx, %eax
jge 0x30f27
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x70(%rsp), %rdi
movslq 0x54(%rsp), %rsi
callq 0xc800
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0xc8c0
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x30ed7
movl $0x0, 0x50(%rsp)
movl 0x50(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x68(%rsp), %rdi
callq 0xc680
movq %rax, %rcx
movl 0x1c(%rsp), %eax
cmpl %ecx, %eax
jge 0x30f7f
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rdi
movslq 0x50(%rsp), %rsi
callq 0xc800
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xc8c0
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x30f2f
movq 0x58(%rsp), %rdi
movl 0x64(%rsp), %esi
movb 0x63(%rsp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x2f380
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x30fc4
movq 0x8(%rsp), %rdi
callq 0xc970
movq 0x8(%rsp), %rdi
movl $0x18, %esi
callq 0x21a0
movq 0x48(%rsp), %rax
addq $0x78, %rsp
retq
nop
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: merge_annot_regions(std::vector<std::vector<t_annot_region*, std::allocator<t_annot_region*>>*, std::allocator<std::vector<t_annot_region*, std::allocator<t_annot_region*>>*>>*, int, bool)
vector<t_annot_region*>* merge_annot_regions(vector<vector<t_annot_region*>*>* annot_regions_list,
												int max_gap, 
												bool match_strands)
{
	vector<t_annot_region*>* total_annot_regions = new vector<t_annot_region*>();
	for(int i_reg_list = 0; i_reg_list < (int)annot_regions_list->size(); i_reg_list++)
	{
		vector<t_annot_region*>* cur_annot_regions = annot_regions_list->at(i_reg_list);
		for(int i = 0; i < (int)cur_annot_regions->size(); i++)
		{
			total_annot_regions->push_back(cur_annot_regions->at(i));
		} // i loop.
	} // i_reg_list loop.

	vector<t_annot_region*>* merged_annot_regions = merge_annot_regions(total_annot_regions,
																			max_gap, 
																			match_strands);

	delete(total_annot_regions);

	return(merged_annot_regions);
}

// Assembly:
subq $0x58, %rsp
movb %dl, %al
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
andb $0x1, %al
movb %al, 0x4b(%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, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x50(%rsp), %rdi
callq 0x1ac60
movq %rax, %rcx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jge 0x310c1
movq 0x50(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0x1ac80
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0xc680
movq %rax, %rcx
movl 0x10(%rsp), %eax
cmpl %ecx, %eax
jge 0x310af
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movslq 0x2c(%rsp), %rsi
callq 0xc800
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xc8c0
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x3105f
jmp 0x310b1
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x3101f
movq 0x40(%rsp), %rdi
movl 0x4c(%rsp), %esi
movb 0x4b(%rsp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x2f380
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x31103
movq (%rsp), %rdi
callq 0xc970
movq (%rsp), %rdi
movl $0x18, %esi
callq 0x21a0
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: gersteinlab[P]MUSIC/src/ms_annot_region_tools.cpp
// Function: delete_annot_regions_with_line_information(std::vector<t_annot_region*, std::allocator<t_annot_region*>>*)
void delete_annot_regions_with_line_information(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;
			char* cur_line_info = (char*)region_list->at(i_reg)->data;
			if(cur_line_info != NULL)
			{
				delete [] cur_line_info;
			}
			delete(region_list->at(i_reg));
		}
	} // i_reg loop.

	region_list->clear();
	delete(region_list);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
movl %eax, 0x2c(%rsp)
movq 0x40(%rsp), %rdi
callq 0xc680
movq %rax, %rcx
movl 0x2c(%rsp), %eax
cmpl %ecx, %eax
jge 0x316a4
movq 0x40(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0xc800
cmpq $0x0, (%rax)
je 0x31692
movq 0x40(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x31625
movq 0x20(%rsp), %rdi
callq 0x2220
movq 0x40(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movq 0x48(%rax), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x31664
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x31662
movq 0x18(%rsp), %rdi
callq 0x2220
jmp 0x31664
movq 0x40(%rsp), %rdi
movslq 0x3c(%rsp), %rsi
callq 0xc800
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x31690
movq 0x10(%rsp), %rdi
movl $0x50, %esi
callq 0x21a0
jmp 0x31692
jmp 0x31694
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x315c1
movq 0x40(%rsp), %rdi
callq 0x31d90
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x316d7
movq 0x8(%rsp), %rdi
callq 0xc970
movq 0x8(%rsp), %rdi
movl $0x18, %esi
callq 0x21a0
addq $0x48, %rsp
retq
nopl (%rax)
// File: gersteinlab[P]MUSIC/src/ms_signal_track_tools.cpp
// Function: dump_per_nucleotide_uchar_binary_profile(unsigned char*, int, char*)
void dump_per_nucleotide_uchar_binary_profile(unsigned char* signal_profile, int l_profile, char* op_fp)
{
	// Dump the per nucleotide signal profile.
	FILE* f_op = open_f(op_fp, "wb");

	// Write data length to first couple bytes.
	fwrite(&(l_profile), sizeof(int), 1, f_op);

	// Dump the data: Dump 0 based data.
	fwrite(&(signal_profile[1]), sizeof(unsigned char), l_profile+1, f_op);

	fclose(f_op);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x205fa(%rip), %rsi     # 0x54998
callq 0x455f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
leaq 0x1c(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x2360
movq 0x20(%rsp), %rdi
addq $0x1, %rdi
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
movq 0x8(%rsp), %rcx
movl $0x1, %esi
callq 0x2360
movq 0x8(%rsp), %rdi
callq 0x2180
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_signal_track_tools.cpp
// Function: load_per_nucleotide_binary_uchar_profile(char*, int&)
unsigned char* load_per_nucleotide_binary_uchar_profile(char* binary_per_nucleotide_profile_fp, int& l_profile)
{
	FILE* f_prof = open_f(binary_per_nucleotide_profile_fp, "rb");

	// Read the profile length.
	int l_data = 0;
	fread(&l_data, sizeof(int), 1, f_prof);
	l_profile = l_data;

	// Read the data.
	unsigned char* signal_profile_buffer = new unsigned char[l_profile+2];

if(__DUMP_SIGNAL_TRACK_MSGS__)
	fprintf(stderr, "Loading %d data values.\n", l_profile);

	// Following is to use the codebase indexing: 1 based indexing.
	fread(&(signal_profile_buffer[1]), sizeof(char), l_profile+1, f_prof);
	
	fclose(f_prof);

	return(signal_profile_buffer);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x21ee6(%rip), %rsi     # 0x56300
callq 0x455f0
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rcx
leaq 0xc(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x2270
movl 0xc(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
movl (%rax), %eax
addl $0x2, %eax
movslq %eax, %rdi
callq 0x2040
movq %rax, (%rsp)
testb $0x1, 0x30d72(%rip)     # 0x651df
je 0x3448e
movq 0x30b6a(%rip), %rax     # 0x64fe0
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movl (%rax), %edx
leaq 0x21e7c(%rip), %rsi     # 0x56303
movb $0x0, %al
callq 0x2250
movq (%rsp), %rdi
addq $0x1, %rdi
movq 0x18(%rsp), %rax
movl (%rax), %eax
addl $0x1, %eax
movslq %eax, %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %esi
callq 0x2270
movq 0x10(%rsp), %rdi
callq 0x2180
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_signal_track_tools.cpp
// Function: get_profile_extrema(double*, int, double&, double&)
void get_profile_extrema(double* profile, int l_profile, double& prof_min, double& prof_max)
{
	prof_min = 1000*1000;
	prof_max = -1000*1000;
	for(int i = 1; i <= l_profile; i++)
	{
		if(profile[i] > prof_max)
		{
			prof_max = profile[i];
		}

		if(profile[i] < prof_min)
		{
			prof_min = profile[i];
		}
	} // i loop.
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq -0x18(%rsp), %rax
movsd 0x21e00(%rip), %xmm0    # 0x562f0
movsd %xmm0, (%rax)
movq -0x20(%rsp), %rax
movsd 0x21de7(%rip), %xmm0    # 0x562e8
movsd %xmm0, (%rax)
movl $0x1, -0x24(%rsp)
movl -0x24(%rsp), %eax
cmpl -0xc(%rsp), %eax
jg 0x34591
movq -0x8(%rsp), %rax
movslq -0x24(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rsp), %rax
ucomisd (%rax), %xmm0
jbe 0x34549
movq -0x8(%rsp), %rax
movslq -0x24(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x20(%rsp), %rax
movsd %xmm0, (%rax)
movq -0x8(%rsp), %rax
movslq -0x24(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x18(%rsp), %rax
movsd (%rax), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3457f
movq -0x8(%rsp), %rax
movslq -0x24(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x18(%rsp), %rax
movsd %xmm0, (%rax)
jmp 0x34581
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x3450d
retq
nopw %cs:(%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_signal_track_tools.cpp
// Function: get_zero_indexed_per_one_indexed_data(double*, int)
double* get_zero_indexed_per_one_indexed_data(double* one_indexed_data, int l_profile)
{
	double* zero_indexed_data = new double[l_profile];
	for(int i = 1; i <= l_profile; i++)
	{
		zero_indexed_data[i-1] = one_indexed_data[i];
	} // i loop.

	return(zero_indexed_data);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movslq 0x1c(%rsp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2040
movq %rax, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jg 0x3461a
movq 0x20(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x345e0
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_signal_track_tools.cpp
// Function: get_one_indexed_per_zero_indexed_data(double*, int)
double* get_one_indexed_per_zero_indexed_data(double* zero_indexed_data, int l_profile)
{
	double* one_indexed_data = new double[l_profile+2];
	for(int i = 0; i < l_profile; i++)
	{
		one_indexed_data[i+1] = zero_indexed_data[i];
	} // i loop.

	return(one_indexed_data);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl 0x1c(%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, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x346ae
movq 0x20(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x34674
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_signal_track_tools.cpp
// Function: copy_profile(double*, int)
double* copy_profile(double* signal_profile, int l_profile)
{
	double* copy_prof = new double[l_profile+2];

	for(int i_sig = 1; i_sig <= l_profile; i_sig++)
	{
		copy_prof[i_sig] = signal_profile[i_sig];
	} // i_sig loop.

	return(copy_prof);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl 0x1c(%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, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jg 0x34a99
movq 0x20(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x34a64
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_signal_track_tools.cpp
// Function: extract_one_indexed_profile_per_profile(double*, int, int, int, int&)
double* extract_one_indexed_profile_per_profile(double* signal_profile_buffer, int l_profile, int start, int end, int& l_extracted_profile)
{
	double* extracted_prof = new double[end - start + 3];	
	for(int i_sig = start; i_sig <= end; i_sig++)
	{
		extracted_prof[i_sig - start] = 0;
	} // i_sig loop.
	
	// Count the extracted profile.
	l_extracted_profile = 1;
	for(int i_sig = start; i_sig <= MIN(l_profile, end); i_sig++)
	{
		extracted_prof[l_extracted_profile] = signal_profile_buffer[i_sig];
		l_extracted_profile++;
	} // i_sig loop.

	// Profiles are one based.
	l_extracted_profile--;

	return(extracted_prof);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq %r8, 0x18(%rsp)
movl 0x24(%rsp), %eax
subl 0x28(%rsp), %eax
addl $0x3, %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, 0x10(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x24(%rsp), %eax
jg 0x34b34
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
subl 0x28(%rsp), %ecx
movslq %ecx, %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x34b05
movq 0x18(%rsp), %rax
movl $0x1, (%rax)
movl 0x28(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x24(%rsp), %eax
jle 0x34b62
movl 0x24(%rsp), %eax
movl %eax, (%rsp)
jmp 0x34b69
movl 0x2c(%rsp), %eax
movl %eax, (%rsp)
movl 0x4(%rsp), %eax
movl (%rsp), %ecx
cmpl %ecx, %eax
jg 0x34bae
movq 0x30(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movslq (%rcx), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x18(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x34b47
movq 0x18(%rsp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_signal_track_tools.cpp
// Function: dump_per_nucleotide_binary_profile(double*, int, char*)
void dump_per_nucleotide_binary_profile(double* signal_profile, int l_profile, char* op_fp)
{
	// Dump the per nucleotide signal profile.
	FILE* f_op = open_f(op_fp, "wb");

	// Write data length to first couple bytes.
	fwrite(&(l_profile), sizeof(int), 1, f_op);

	// Dump the data: Dump 0 based data.
	fwrite(&(signal_profile[1]), sizeof(double), l_profile+1, f_op);

	fclose(f_op);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x1f83a(%rip), %rsi     # 0x54998
callq 0x455f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
leaq 0x1c(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x2360
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdx
movq 0x8(%rsp), %rcx
movl $0x8, %esi
callq 0x2360
movq 0x8(%rsp), %rdi
callq 0x2180
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_signal_track_tools.cpp
// Function: load_per_nucleotide_binary_profile(char*, int&)
double* load_per_nucleotide_binary_profile(char* binary_per_nucleotide_profile_fp, int& l_profile)
{
	FILE* f_prof = open_f(binary_per_nucleotide_profile_fp, "rb");

	// Read the profile length.
	int l_data = 0;
	fread(&l_data, sizeof(int), 1, f_prof);
	l_profile = l_data;

	// Read the data.
	double* signal_profile_buffer = new double[l_profile+2];

if(__DUMP_SIGNAL_TRACK_MSGS__)
	fprintf(stderr, "Loading %d data values.\n", l_profile);

	// Following is to use the codebase indexing: 1 based indexing.
	fread(&(signal_profile_buffer[1]), sizeof(double), l_profile+1, f_prof);
	
	fclose(f_prof);

	return(signal_profile_buffer);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x21126(%rip), %rsi     # 0x56300
callq 0x455f0
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rcx
leaq 0xc(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x2270
movl 0xc(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x18(%rsp), %rax
movl (%rax), %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, (%rsp)
testb $0x1, 0x2ff97(%rip)     # 0x651df
je 0x35269
movq 0x2fd8f(%rip), %rax     # 0x64fe0
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movl (%rax), %edx
leaq 0x210a1(%rip), %rsi     # 0x56303
movb $0x0, %al
callq 0x2250
movq (%rsp), %rdi
addq $0x8, %rdi
movq 0x18(%rsp), %rax
movl (%rax), %eax
addl $0x1, %eax
movslq %eax, %rdx
movq 0x10(%rsp), %rcx
movl $0x8, %esi
callq 0x2270
movq 0x10(%rsp), %rdi
callq 0x2180
movq (%rsp), %rax
addq $0x28, %rsp
retq
// File: gersteinlab[P]MUSIC/src/ms_signal_track_tools.cpp
// Function: get_log_plus_one_profile(double*, double, int)
void get_log_plus_one_profile(double* signal_profile, double base, int l_profile)
{
	for(int i = 1; i <= l_profile; i++)
	{
		double cur_log_value = xlog(signal_profile[i]+1.0)/xlog(base);
		signal_profile[i] = cur_log_value;
	} // i loop.
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl $0x1, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jg 0x35515
movq 0x20(%rsp), %rax
movslq 0x10(%rsp), %rcx
movsd 0x1cb51(%rip), %xmm0    # 0x52018
addsd (%rax,%rcx,8), %xmm0
callq 0x441e0
movsd %xmm0, (%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x441e0
movaps %xmm0, %xmm1
movsd (%rsp), %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movq 0x20(%rsp), %rax
movslq 0x10(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x354ab
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_signal_track_tools.cpp
// Function: floorize_profile(double*, int)
void floorize_profile(double* signal_profile, int l_profile)
{
	for(int i = 1; i <= l_profile; i++)
	{
		double cur_floor_val = floor(signal_profile[i]);
		signal_profile[i] = cur_floor_val;
	} // i loop.
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x1, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jg 0x35579
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
callq 0x22e0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x35535
addq $0x18, %rsp
retq
nop
// File: gersteinlab[P]MUSIC/src/ms_signal_track_tools.cpp
// Function: get_zero_profile(int)
double* get_zero_profile(int l_profile)
{
	double* cur_profile = new double[l_profile+2];
	for(int i = 0; i <= l_profile; i++)
	{
		cur_profile[i] = 0.0;
	} // i loop.

	return(cur_profile);
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl 0x14(%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, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x14(%rsp), %eax
jg 0x355e8
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
xorps %xmm0, %xmm0
movsd %xmm0, (%rax,%rcx,8)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x355bf
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_signal_enrichment_utils.cpp
// Function: get_binomial_p_val_per_enriched_background_values(int, int, double*)
double get_binomial_p_val_per_enriched_background_values(int enriched_value, int background_value, double* _log_factorials)
{
	int grand_total_int = (int)(enriched_value + background_value);

	// Setup the log factorials.
	double* log_factorials = NULL;
	if(_log_factorials == NULL)
	{
		log_factorials = buffer_log_factorials(grand_total_int+3);
	}
	else
	{
		log_factorials = _log_factorials;
	}

	// Compute the p-values.
	double log_flip = log(.5);
	double cur_region_log_p_val = xlog(0.0);
	for(int i = 0; i <= background_value; i++)
	{
		double log_cur_half_pow = log_flip * grand_total_int;
		double log_cur_perm = 0.0; // = xlog(1.0).

		// Compute the current permutation, using shortcuts, bypassing the function calls from xlog_math library.
		log_cur_perm = xlog_div(log_factorials[grand_total_int], xlog_mul(log_factorials[i], log_factorials[grand_total_int-i]));
		cur_region_log_p_val = xlog_sum(cur_region_log_p_val, xlog_mul(log_cur_perm, log_cur_half_pow));
	} // i loop.

	// Free memory if it is allocated in the function.
	if(_log_factorials == NULL)
	{
		delete [] log_factorials;
	}
	else
	{
	}

	return(cur_region_log_p_val);
}

// Assembly:
subq $0x68, %rsp
movl %edi, 0x64(%rsp)
movl %esi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movl 0x64(%rsp), %eax
addl 0x60(%rsp), %eax
movl %eax, 0x54(%rsp)
movq $0x0, 0x48(%rsp)
cmpq $0x0, 0x58(%rsp)
jne 0x35fd1
movl 0x54(%rsp), %edi
addl $0x3, %edi
callq 0x3f420
movq %rax, 0x48(%rsp)
jmp 0x35fdb
movq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
movsd 0x1c055(%rip), %xmm0    # 0x52038
callq 0x2140
movsd %xmm0, 0x40(%rsp)
xorps %xmm0, %xmm0
callq 0x441e0
movsd %xmm0, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x60(%rsp), %eax
jg 0x360c4
movsd 0x40(%rsp), %xmm0
cvtsi2sdl 0x54(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x48(%rsp), %rax
movslq 0x54(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x48(%rsp), %rax
movslq 0x34(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x48(%rsp), %rax
movl 0x54(%rsp), %ecx
subl 0x34(%rsp), %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm1
callq 0x44510
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
callq 0x445a0
movsd %xmm0, 0x20(%rsp)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
movsd 0x28(%rsp), %xmm1
callq 0x44510
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
callq 0x44310
movsd %xmm0, 0x38(%rsp)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x36004
cmpq $0x0, 0x58(%rsp)
jne 0x360e8
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x360e6
movq 0x8(%rsp), %rdi
callq 0x2220
jmp 0x360ea
jmp 0x360ea
movsd 0x38(%rsp), %xmm0
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_genome_sequence_tools.cpp
// Function: map_nuc_to_sig(char)
int map_nuc_to_sig(char nuc)
{
	switch(nuc)
	{
		case 'A':
			return(0);
			break;
		case 'C':
			return(1);
			break;
		case 'G':
			return(2);
			break;
		case 'U':
			return(0);
			break;
		case 'T':
			return(4);
			break;
		default:
			return(0);
			break;
	}
}

// Assembly:
movb %dil, %al
movb %al, -0x5(%rsp)
movsbl -0x5(%rsp), %eax
addl $-0x41, %eax
movl %eax, %ecx
movq %rcx, -0x10(%rsp)
subl $0x14, %eax
ja 0x3c702
movq -0x10(%rsp), %rax
leaq 0x19f89(%rip), %rcx     # 0x56650
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rsp)
jmp 0x3c70a
movl $0x1, -0x4(%rsp)
jmp 0x3c70a
movl $0x2, -0x4(%rsp)
jmp 0x3c70a
movl $0x0, -0x4(%rsp)
jmp 0x3c70a
movl $0x4, -0x4(%rsp)
jmp 0x3c70a
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: gersteinlab[P]MUSIC/src/ms_genome_sequence_tools.cpp
// Function: get_genome_i_per_seq_i(char, int, int, int&, int)
bool get_genome_i_per_seq_i(char strand, 
	int genome_start, 
	int genome_end, 
	int& genome_i, int seq_i)
{
	int l_seq = genome_end - genome_start + 1;
	genome_i = seq_i + genome_start;

	// Revert the index if the mirna is on negative strand.
	if(strand == '-')
	{
		//seq_i = l_seq - seq_i - 1;
		genome_i = l_seq + genome_start - seq_i - 1;
	}

	return(true);
}

// Assembly:
movb %dil, %al
movb %al, -0x1(%rsp)
movl %esi, -0x8(%rsp)
movl %edx, -0xc(%rsp)
movq %rcx, -0x18(%rsp)
movl %r8d, -0x1c(%rsp)
movl -0xc(%rsp), %eax
subl -0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rsp)
movl -0x1c(%rsp), %ecx
addl -0x8(%rsp), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movsbl -0x1(%rsp), %eax
cmpl $0x2d, %eax
jne 0x3c767
movl -0x20(%rsp), %ecx
addl -0x8(%rsp), %ecx
subl -0x1c(%rsp), %ecx
subl $0x1, %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movb $0x1, %al
andb $0x1, %al
retq
nopl (%rax)
// File: gersteinlab[P]MUSIC/src/ms_genome_sequence_tools.cpp
// Function: get_seq_i_per_genome_i(char, int, int, int, int&)
bool get_seq_i_per_genome_i(char strand, 
	int genome_start, 
	int genome_end, 
	int genome_i, int& seq_i)
{
	// genome_i must be within the element of interest.
	if(genome_i < genome_start ||
		genome_i > genome_end)
	{
		return(false);
	}

	// genome_i must be within the element of interest: If it is not, fix it.
	if(genome_i < genome_start)
	{
		genome_i = genome_start;
	}
	
	if(genome_i > genome_end)
	{
		genome_i = genome_end;
	}

	int l_seq = genome_end - genome_start + 1;
	seq_i = genome_i - genome_start;

	// Revert the index if the mirna is on negative strand.
	if(strand == '-')
	{
		seq_i = l_seq - seq_i - 1;
	}

	return(true);
}

// Assembly:
movb %dil, %al
movb %al, -0x2(%rsp)
movl %esi, -0x8(%rsp)
movl %edx, -0xc(%rsp)
movl %ecx, -0x10(%rsp)
movq %r8, -0x18(%rsp)
movl -0x10(%rsp), %eax
cmpl -0x8(%rsp), %eax
jl 0x3c79c
movl -0x10(%rsp), %eax
cmpl -0xc(%rsp), %eax
jle 0x3c7a3
movb $0x0, -0x1(%rsp)
jmp 0x3c809
movl -0x10(%rsp), %eax
cmpl -0x8(%rsp), %eax
jge 0x3c7b5
movl -0x8(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
cmpl -0xc(%rsp), %eax
jle 0x3c7c7
movl -0xc(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0xc(%rsp), %eax
subl -0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
movl -0x10(%rsp), %ecx
subl -0x8(%rsp), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movsbl -0x2(%rsp), %eax
cmpl $0x2d, %eax
jne 0x3c804
movl -0x1c(%rsp), %ecx
movq -0x18(%rsp), %rax
subl (%rax), %ecx
subl $0x1, %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
// File: gersteinlab[P]MUSIC/src/ms_genome_sequence_tools.cpp
// Function: load_binary_sequence_file(char*, int&)
char* load_binary_sequence_file(char* bin_seq_fp, int& l_seq)
{
	FILE* f_bin_seq = open_f(bin_seq_fp, "rb");
	int l_bin_seq = 0;

	// Read the length.
	fread(&l_bin_seq, sizeof(int), 1, f_bin_seq);

	l_seq = l_bin_seq;

	// Read the sequence.
	char* bin_seq = new char[l_bin_seq+2];
	fread(bin_seq, sizeof(char), l_bin_seq, f_bin_seq);
	fclose(f_bin_seq);

	return(bin_seq);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x197a6(%rip), %rsi     # 0x56300
callq 0x455f0
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rcx
leaq 0xc(%rsp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0x2270
movl 0xc(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movl 0xc(%rsp), %eax
addl $0x2, %eax
movslq %eax, %rdi
callq 0x2040
movq %rax, (%rsp)
movq (%rsp), %rdi
movslq 0xc(%rsp), %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %esi
callq 0x2270
movq 0x10(%rsp), %rdi
callq 0x2180
movq (%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: gersteinlab[P]MUSIC/src/ms_genome_sequence_tools.cpp
// Function: load_BED_with_sequences(char*)
vector<t_annot_region*>* load_BED_with_sequences(char* bed_w_seq_fp)
{
	vector<t_annot_region*>* regs_w_seqs = new vector<t_annot_region*>();

	FILE* f_bed_w_seq = open_f(bed_w_seq_fp, "r");

	while(1)
	{
		char* cur_line = getline(f_bed_w_seq);
		if(cur_line == NULL)
		{
			break;
		}

		char chrom[100];
		int start;
		int end;
		char strand;
		char name[100];
		char* cur_seq = new char[t_string::string_length(cur_line) + 2];		

		if(sscanf(cur_line, "%s %d %d %s %*s %c %s", chrom, 
			&start, &end, name, &strand, cur_seq) != 6)
		{
			fprintf(stderr, "Could not parse the sequence bed file line:\n%s\n", cur_line);
			exit(0);
		}

		t_annot_region* cur_region = get_empty_region();
		cur_region->chrom = t_string::copy_me_str(chrom);
		cur_region->start = translate_coord(start, BED_COORDS::start_base, CODEBASE_COORDS::start_base);
		cur_region->end = translate_coord(end, BED_COORDS::end_base, CODEBASE_COORDS::end_base);
		cur_region->strand = strand;

		// The sequence is stored in the data entry.
		cur_region->data = (void*)cur_seq;

		regs_w_seqs->push_back(cur_region);
	} // file reading loop.

	fclose(f_bed_w_seq);

	return(regs_w_seqs);
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x120(%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, 0x118(%rsp)
movq 0x120(%rsp), %rdi
leaq 0x1827b(%rip), %rsi     # 0x550ce
callq 0x455f0
movq %rax, 0x110(%rsp)
movq 0x110(%rsp), %rdi
callq 0x45400
movq %rax, 0x108(%rsp)
cmpq $0x0, 0x108(%rsp)
jne 0x3ce85
jmp 0x3cfa7
movq 0x108(%rsp), %rdi
callq 0x47640
addl $0x2, %eax
movslq %eax, %rdi
callq 0x2040
movq %rax, 0x28(%rsp)
movq 0x108(%rsp), %rdi
leaq 0xa0(%rsp), %rdx
leaq 0x30(%rsp), %r9
movq 0x28(%rsp), %rax
leaq 0x1982a(%rip), %rsi     # 0x566ed
leaq 0x9c(%rsp), %rcx
leaq 0x98(%rsp), %r8
leaq 0x97(%rsp), %r10
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x2170
cmpl $0x6, %eax
je 0x3cf17
movq 0x280e9(%rip), %rax     # 0x64fe0
movq (%rax), %rdi
movq 0x108(%rsp), %rdx
leaq 0x197b4(%rip), %rsi     # 0x566bd
movb $0x0, %al
callq 0x2250
xorl %edi, %edi
callq 0x21f0
callq 0x27b00
movq %rax, 0x20(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x47b60
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movl 0x9c(%rsp), %edi
xorl %esi, %esi
movl $0x1, %edx
callq 0x1fd20
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0xc(%rax)
movl 0x98(%rsp), %edi
movl $0x1, %edx
movl %edx, %esi
callq 0x1fd20
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x20(%rax)
movb 0x97(%rsp), %cl
movq 0x20(%rsp), %rax
movb %cl, 0x8(%rax)
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x118(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xc8c0
jmp 0x3ce60
movq 0x110(%rsp), %rdi
callq 0x2180
movq 0x118(%rsp), %rax
addq $0x128, %rsp            # imm = 0x128
retq
nopw %cs:(%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_genome_sequence_tools.cpp
// Function: load_whole_chromosome_sequence_per_bin_file(char*, int&)
char* load_whole_chromosome_sequence_per_bin_file(char* chr_fp, int& n_nucs)
{
	FILE* f_chr = open_f(chr_fp, "rb");
	
	// Get the file size.
	fseek (f_chr, 0 , SEEK_END);
	n_nucs = (int)(ftell(f_chr));
	rewind(f_chr);

	char* nucs = new char[n_nucs+2]; 

	fread(nucs, sizeof(char), n_nucs, f_chr);

	fclose(f_chr);

	return(nucs);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x18516(%rip), %rsi     # 0x56300
callq 0x455f0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x21b0
movq 0x10(%rsp), %rdi
callq 0x2030
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rdi
callq 0x2060
movq 0x18(%rsp), %rax
movl (%rax), %eax
addl $0x2, %eax
movslq %eax, %rdi
callq 0x2040
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movslq (%rax), %rdx
movq 0x10(%rsp), %rcx
movl $0x1, %esi
callq 0x2270
movq 0x10(%rsp), %rdi
callq 0x2180
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_profile_normalization.cpp
// Function: slope(double*, double*, int)
double slope(double* prof1_total_sigs_per_win, double* prof2_total_sigs_per_win, int n_processed_wins)
{
	// Compute the slope from 1 DOF (slope) LLS regression.
	double num = 0.0f;
	double den = 0.0f;
	for(int i = 0; i < n_processed_wins; i++)
	{
		num += prof1_total_sigs_per_win[i] * prof2_total_sigs_per_win[i];
		den += prof1_total_sigs_per_win[i] * prof1_total_sigs_per_win[i];
		//num += control_frag_cnt->at(i) * chip_seq_frag_cnt->at(i);
		//den += control_frag_cnt->at(i) * control_frag_cnt->at(i);
	} // i loop

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

	return(num / den);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x3e9c7
movq 0x28(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x20(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd 0x10(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x28(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x28(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd 0x8(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x3e94c
movsd 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x3e9da
jp 0x3e9da
jmp 0x3e9eb
movsd 0x8(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x3ea13
jp 0x3ea13
movq 0x265ee(%rip), %rax     # 0x64fe0
movq (%rax), %rdi
leaq 0x17e52(%rip), %rsi     # 0x5684e
movb $0x0, %al
callq 0x2250
movsd 0x1360d(%rip), %xmm0    # 0x52018
movsd %xmm0, 0x30(%rsp)
jmp 0x3ea25
movsd 0x10(%rsp), %xmm0
divsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
// File: gersteinlab[P]MUSIC/src/ms_combinatorics.cpp
// Function: factorial(int)
double factorial(int n)
{
	double cur_fact = 1.0;
	for(int i = 1; i <= n; i++)
	{
		cur_fact *= i;
	} 

	return(cur_fact);
}

// Assembly:
movl %edi, -0x4(%rsp)
movsd 0x1339c(%rip), %xmm0    # 0x52018
movsd %xmm0, -0x10(%rsp)
movl $0x1, -0x14(%rsp)
movl -0x14(%rsp), %eax
cmpl -0x4(%rsp), %eax
jg 0x3ecb3
cvtsi2sdl -0x14(%rsp), %xmm0
mulsd -0x10(%rsp), %xmm0
movsd %xmm0, -0x10(%rsp)
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x3ec8a
movsd -0x10(%rsp), %xmm0
retq
nopw (%rax,%rax)
// File: gersteinlab[P]MUSIC/src/ms_combinatorics.cpp
// Function: is_gt(std::vector<int, std::allocator<int>>*, std::vector<int, std::allocator<int>>*)
bool is_gt(vector<int>* combinatorial_indices1, vector<int>* combinatorial_indices2)
{
	for(int i = 0; i < (int)combinatorial_indices1->size(); i++)
	{
		if(combinatorial_indices1->at(i) > combinatorial_indices2->at(i))
		{
			return(true);
		}
		else if(combinatorial_indices1->at(i) == combinatorial_indices2->at(i))
		{
			
		}
	} // i loop.

	return(false);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0xc2a0
movq %rax, %rcx
movl 0x8(%rsp), %eax
cmpl %ecx, %eax
jge 0x3ed6c
movq 0x18(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0xc2c0
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0xc2c0
movq %rax, %rcx
movl 0x4(%rsp), %eax
cmpl (%rcx), %eax
jle 0x3ed29
movb $0x1, 0x27(%rsp)
jmp 0x3ed71
movq 0x18(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0xc2c0
movl (%rax), %eax
movl %eax, (%rsp)
movq 0x10(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0xc2c0
movq %rax, %rcx
movl (%rsp), %eax
cmpl (%rcx), %eax
jne 0x3ed58
jmp 0x3ed58
jmp 0x3ed5a
jmp 0x3ed5c
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3ecd6
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: gersteinlab[P]MUSIC/src/ms_combinatorics.cpp
// Function: is_equal(std::vector<int, std::allocator<int>>*, std::vector<int, std::allocator<int>>*)
bool is_equal(vector<int>* combinatorial_indices1, vector<int>* combinatorial_indices2)
{
	for(int i = 0; i < (int)combinatorial_indices1->size(); i++)
	{
		if(combinatorial_indices1->at(i) != combinatorial_indices2->at(i))
		{
			return(false);
		}
	} // i loop.

	return(true);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0xc2a0
movq %rax, %rcx
movl 0x8(%rsp), %eax
cmpl %ecx, %eax
jge 0x3edf8
movq 0x18(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0xc2c0
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0xc2c0
movq %rax, %rcx
movl 0x4(%rsp), %eax
cmpl (%rcx), %eax
je 0x3ede9
movb $0x0, 0x27(%rsp)
jmp 0x3edfd
jmp 0x3edeb
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3ed96
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: is_valid_indexing(std::vector<int, std::allocator<int>>*)
bool is_valid_indexing(vector<int>* sorted_combinatorial_indices)
{
	for(int i = 0; i < (int)sorted_combinatorial_indices->size()-1; i++)
	{
		if(sorted_combinatorial_indices->at(i) == sorted_combinatorial_indices->at(i+1))
		{
			return(false);
		}
	} // i loop.

	return(true);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0xc2a0
movq %rax, %rcx
movl 0x10(%rsp), %eax
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x3ee8b
movq 0x18(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0xc2c0
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
callq 0xc2c0
movq %rax, %rcx
movl 0xc(%rsp), %eax
cmpl (%rcx), %eax
jne 0x3ee7c
movb $0x0, 0x27(%rsp)
jmp 0x3ee90
jmp 0x3ee7e
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x3ee21
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)