LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_utils.cpp
// Function: x_fgets(char*, int, _IO_FILE*)
char* x_fgets(char* buff, int size, FILE* file)
{
	if(fgets(buff, size, file) == NULL)
	{
		return(NULL);
	}

	if(buff[t_string::string_length(buff) - 1] == '\n')
	{
		int i_new_line_char = (int)t_string::string_length(buff) - 1;
		buff[i_new_line_char] = 0;
	}

	return(buff);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2290
testq %rax, %rax
je 0x205d5
movq %rbx, %rdi
callq 0x20d90
cltq
cmpb $0xa, -0x1(%rbx,%rax)
jne 0x205d7
movq %rbx, %rdi
callq 0x20d90
cltq
movb $0x0, -0x1(%rbx,%rax)
jmp 0x205d7
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_cli.cpp
// Function: t_ansi_cli::~t_ansi_cli()
t_ansi_cli::~t_ansi_cli()
{
	for(int i_opt = 0; i_opt < (int)this->options->size(); i_opt++)
	{
		free(this->options->at(i_opt));
	}
	delete(this->options);

	for(int i_val = 0; i_val < (int)this->values->size(); i_val++)
	{
		free(this->values->at(i_val));
	}
	delete(this->values);

	for(int i_ip = 0; i_ip < (int)this->inputs->size(); i_ip++)
	{
		free(this->inputs->at(i_ip));
	}
	delete(this->inputs);

	if(this->option_prefix != NULL)
	{
		free(this->option_prefix);
	}

	if(this->exe_cmd != NULL)
	{
		free(this->exe_cmd);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x10(%rbx), %r15
movq 0x8(%r15), %rax
subq (%r15), %rax
shrq $0x3, %rax
cltq
cmpq %rax, %r14
jge 0x20aad
movq %r15, %rdi
movq %r14, %rsi
callq 0x7342
movq (%rax), %rdi
callq 0x21c0
incq %r14
jmp 0x20a7f
movq %r15, %rdi
callq 0x7cb8
pushq $0x18
popq %rsi
movq %r15, %rdi
callq 0x2180
xorl %r14d, %r14d
movq 0x18(%rbx), %r15
movq 0x8(%r15), %rax
subq (%r15), %rax
shrq $0x3, %rax
cltq
cmpq %rax, %r14
jge 0x20af1
movq %r15, %rdi
movq %r14, %rsi
callq 0x7342
movq (%rax), %rdi
callq 0x21c0
incq %r14
jmp 0x20ac3
movq %r15, %rdi
callq 0x7cb8
pushq $0x18
popq %rsi
movq %r15, %rdi
callq 0x2180
xorl %r14d, %r14d
movq 0x20(%rbx), %r15
movq 0x8(%r15), %rax
subq (%r15), %rax
shrq $0x3, %rax
cltq
cmpq %rax, %r14
jge 0x20b35
movq %r15, %rdi
movq %r14, %rsi
callq 0x7342
movq (%rax), %rdi
callq 0x21c0
incq %r14
jmp 0x20b07
movq %r15, %rdi
callq 0x7cb8
pushq $0x18
popq %rsi
movq %r15, %rdi
callq 0x2180
movq (%rbx), %rdi
callq 0x21c0
movq 0x8(%rbx), %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x21c0
jmp 0x20b62
jmp 0x20b62
movq %rax, %rdi
callq 0x760f
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_cli.cpp
// Function: t_ansi_cli::get_value_by_option(char const*, bool&)
char* t_ansi_cli::get_value_by_option(const char* option2search, bool& success)
{
	success = false;
	for(int i_opt = 0; i_opt < (int)this->options->size(); i_opt++)
	{
		if(t_string::compare_strings(this->options->at(i_opt), option2search))
		{
			success = true;
			return(this->values->at(i_opt)); // Can be NULL!
		}
	}

	success = false;
	return(NULL);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movb $0x0, (%rdx)
pushq $-0x1
popq %r14
movq 0x10(%r15), %rdi
movq 0x8(%rdi), %rax
subq (%rdi), %rax
incq %r14
shrq $0x3, %rax
cltq
cmpq %rax, %r14
jge 0x20bc6
movq %r14, %rsi
callq 0x7342
movq (%rax), %rdi
movq %r12, %rsi
callq 0x2100e
testb %al, %al
je 0x20b82
movb $0x1, (%rbx)
movq 0x18(%r15), %rdi
movq %r14, %rsi
callq 0x7342
movq (%rax), %rax
jmp 0x20bcb
movb $0x0, (%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::t_string(char const*)
t_string::t_string(const char* string)
{
	// Allocate the memory.
	//this->obj_string = (char*)malloc(string_length(string) + 3);
	//this->obj_str_mem_size = string_length(string) + 1;

	this->string_buffer = new t_string_buffer();
	this->string_buffer->i_buff = 0;
	this->string_buffer->l_buffer_mem = IBS;
	this->string_buffer->string_buff = new char[IBS+3];

	this->copy(string);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0x2170
movq %rax, %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq %rax, (%r14)
movl $0x1f4, 0x8(%rax)       # imm = 0x1F4
movl $0x1f7, %edi            # imm = 0x1F7
callq 0x2040
movq %rax, (%r15)
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x20c48
nop
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::t_string()
t_string::t_string()
{
	//this->obj_string = (char*)malloc(IBS + 3);
	//this->obj_str_mem_size = IBS;
	this->string_buffer = new t_string_buffer();
	this->string_buffer->i_buff = 0;
	this->string_buffer->l_buffer_mem = IBS;
	this->string_buffer->string_buff = new char[IBS+3];

	// Initialize the string.
	this->empty();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x2170
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq %rax, (%rbx)
movl $0x1f4, 0x8(%rax)       # imm = 0x1F4
movl $0x1f7, %edi            # imm = 0x1F7
callq 0x2040
movq %rax, (%r14)
andl $0x0, 0xc(%r14)
movb $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::sort_strings(char*, char*)
bool t_string::sort_strings(char* str1, char* str2)
{
	int l1 = t_string::string_length(str1);
	int l2 = t_string::string_length(str2);
	if(l1 < l2)
	{
		return(true);
	}
	else if(l1 > l2)
	{
		return(false);
	}
	else
	{
		for(int i = 0; i < l1; i++)
		{
			if(str1[i] < str2[i])
			{
				return(true);
			}
			else if(str1[i] > str2[i])
			{
				return(false);
			}
		} // i loop.

		// Strings are exactly the same, return false to obey strict weak ordering.
		return(false);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x20d90
movl %eax, %r15d
movq %rbx, %rdi
callq 0x20d90
movl %eax, %ecx
movb $0x1, %al
cmpl %ecx, %r15d
jl 0x20d89
xorl %eax, %eax
cmpl %ecx, %r15d
jg 0x20d89
movslq %r15d, %rcx
testl %r15d, %r15d
cmovlel %eax, %r15d
movq %rax, %rdx
cmpq %rax, %r15
je 0x20d80
movb (%r14,%rdx), %sil
movb (%rbx,%rdx), %dil
cmpb %dil, %sil
jl 0x20d7d
leaq 0x1(%rdx), %rax
cmpb %dil, %sil
jle 0x20d5b
xorl %esi, %esi
jmp 0x20d80
movb $0x1, %sil
cmpq %rcx, %rdx
setl %al
andb %sil, %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::get_string_sorting_idx(std::vector<char*, std::allocator<char*>>*)
vector<int>* t_string::get_string_sorting_idx(vector<char*>* string_list)
{
	vector<t_str_node*>* str_nodes = new vector<t_str_node*>();
	for(int i_s = 0; i_s < (int)string_list->size(); i_s++)
	{
		t_str_node* new_node = new t_str_node();
		new_node->i = i_s;
		new_node->str = string_list->at(i_s);
		str_nodes->push_back(new_node);
	} // i_s loop.

	// Sort the nodes.
	sort(str_nodes->begin(), str_nodes->end(), t_string::sort_str_nodes);	

	// Fill the sorting idx.
	vector<int>* string_sort_idx = new vector<int>();
	for(int i_s = 0; i_s < (int)str_nodes->size(); i_s++)
	{
		string_sort_idx->push_back(str_nodes->at(i_s)->i);
		delete(str_nodes->at(i_s));
	} // i_s loop.

	delete(str_nodes);

	return(string_sort_idx);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
pushq $0x18
popq %rdi
callq 0x2170
movq %rax, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rax)
movups %xmm0, (%rax)
xorl %r15d, %r15d
pushq $0x10
popq %r12
leaq 0x8(%rsp), %r13
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x3, %rax
cltq
cmpq %rax, %r15
jge 0x20e1d
movq %r12, %rdi
callq 0x2170
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq %rax, 0x8(%rsp)
movl %r15d, 0x8(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x7342
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x22bc2
incq %r15
jmp 0x20dce
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
leaq 0x8b(%rip), %rdx        # 0x20eb6
callq 0x22e33
pushq $0x18
popq %rdi
callq 0x2170
movq %rax, %r14
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %r15d, %r15d
pushq $0x10
popq %r12
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
cltq
movq %rbx, %rdi
cmpq %rax, %r15
jge 0x20e94
movq %r15, %rsi
callq 0x22be0
movq (%rax), %rsi
addq $0x8, %rsi
movq %r14, %rdi
callq 0x73a8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22be0
movq (%rax), %rdi
movq %r12, %rsi
callq 0x2180
incq %r15
jmp 0x20e4d
callq 0x233fe
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x2180
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::fast_search_string(char*, std::vector<char*, std::allocator<char*>>*, int, int)
int t_string::fast_search_string(char* query, vector<char*>* string_list, int i, int j)
{
	// Sort the string list.
	int i_mid = (i + j) / 2;

	if(i_mid == i ||
		i_mid == j)
	{
		return(i);
	}
	
	if(t_string::compare_strings(string_list->at(i_mid), query))
	{
		while(i_mid < (int)string_list->size() &&
			t_string::sort_strings(string_list->at(i_mid), query))
		{
			i_mid++;
		}

		// If the above loop hit the end, move back once.
		if(i_mid == (int)string_list->size())
		{
			i_mid--;
		}

		// If the above loop moved beyond the query move back once, which is the exact element just before query.
		if(i_mid > 0 &&
			!sort_strings(string_list->at(i_mid), query))
		{
			i_mid--;
		}

		return(i_mid);
	}
	else if(sort_strings(query, string_list->at(i_mid)))
	{
		return(t_string::fast_search_string(query, string_list, i, i_mid));
	}
	else if(!sort_strings(query, string_list->at(i_mid)))
	{
		return(t_string::fast_search_string(query, string_list, i_mid, j));
	}
	else
	{
		fprintf(stderr, "Fast searching failed @ %s(%d)\n", __FILE__, __LINE__);
		exit(0);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r13d
movl %edx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
movl %r13d, %r15d
movl %r15d, %r13d
leal (%r12,%r13), %eax
cltd
pushq $0x2
popq %rcx
idivl %ecx
cmpl %r12d, %eax
je 0x20ffb
movl %eax, %ebp
cmpl %r13d, %eax
je 0x20ffb
movslq %ebp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x7342
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x2100e
testb %al, %al
jne 0x20f7c
movq %r14, %rdi
movq %r15, %rsi
callq 0x7342
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x20d26
testb %al, %al
jne 0x20edc
movq %r14, %rdi
movq %r15, %rsi
callq 0x7342
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x20d26
movl %r15d, %r12d
testb %al, %al
je 0x20ed9
movq 0x14088(%rip), %rax     # 0x34fe0
movq (%rax), %rdi
leaq 0x7a3a(%rip), %rsi      # 0x2899c
leaq 0x7a53(%rip), %rdx      # 0x289bc
movl $0xc6, %ecx
xorl %eax, %eax
callq 0x2240
xorl %edi, %edi
callq 0x21d0
negl %ebp
movq 0x8(%r14), %rax
subq (%r14), %rax
movq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r15
jge 0x20fbc
movq %r14, %rdi
movq %r15, %rsi
callq 0x7342
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x20d26
testb %al, %al
je 0x20fb5
incq %r15
decl %ebp
jmp 0x20f7e
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x3, %rax
xorl %r15d, %r15d
addl %ebp, %eax
sete %r15b
negl %r15d
movl %r15d, %r12d
subl %ebp, %r12d
testl %r12d, %r12d
jle 0x20ffb
movl %r12d, %esi
movq %r14, %rdi
callq 0x7342
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x20d26
xorb $0x1, %al
movzbl %al, %eax
subl %eax, %r15d
subl %ebp, %r15d
movl %r15d, %r12d
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::compare_strings(char const*, char const*)
bool t_string::compare_strings(const char* str1, const char* str2)
{
	int str_len1 = string_length(str1);
	int str_len2 = string_length(str2);
	if(str_len1 != str_len2)
	{
		return(false);
	}

	for(int i = 0; i < str_len1; i++)
	{
		if(str1[i] != str2[i])
		{
			return(false);
		}
	}

	return(true);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x20d90
movl %eax, %r15d
movq %rbx, %rdi
callq 0x20d90
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %r15d
jne 0x2105b
movslq %r15d, %rcx
testl %r15d, %r15d
cmovlel %eax, %r15d
cmpq %rax, %r15
je 0x21055
movb (%r14,%rax), %dl
leaq 0x1(%rax), %rsi
cmpb (%rbx,%rax), %dl
movq %rsi, %rax
je 0x2103c
xorl %eax, %eax
jmp 0x2105b
cmpq %rcx, %rax
setge %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::copy(char*, char const*)
void t_string::copy(char* dest_string, const char* src_string)
{
	unsigned int l_src_string = string_length(src_string);
	
	// Do the actual the copying, this loop copies the null character!
	for(unsigned int i = 0; i <= l_src_string; i++)
	{
		dest_string[i] = src_string[i];
	}
	dest_string[l_src_string] = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x20d90
leal 0x1(%rax), %ecx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x210c5
movb (%r14,%rdx), %sil
movb %sil, (%rbx,%rdx)
incq %rdx
jmp 0x210b3
movl %eax, %eax
movb $0x0, (%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::get_add_i_str(std::vector<char*, std::allocator<char*>>*, char*)
int t_string::get_add_i_str(vector<char*>* strs, char* str)
{
	int i_chr = t_string::get_i_str(strs, str);

	// Add to the list.
	if(i_chr == (int)strs->size())
	{
		char* new_chr_id = t_string::copy_me_str(str);
		strs->push_back(new_chr_id);

		i_chr = t_string::get_i_str(strs, str);

		if(i_chr == (int)strs->size())
		{
			fprintf(stderr, "Failed to insert %s to the list.\n", str);
			return((int)strs->size());
		}
	}

	return(i_chr);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x21152
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
shrq $0x3, %rcx
cmpl %ecx, %eax
jne 0x21122
movq %r14, %rdi
callq 0x21062
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0xecb8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21152
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
shrq $0x3, %rcx
cmpl %ecx, %eax
je 0x2112a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x13eaf(%rip), %rax     # 0x34fe0
movq (%rax), %rdi
leaq 0x7898(%rip), %rsi      # 0x289d3
movq %r14, %rdx
xorl %eax, %eax
callq 0x2240
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
jmp 0x21122
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::get_i_str(std::vector<char*, std::allocator<char*>>*, char*)
int t_string::get_i_str(vector<char*>* strs, char* str)
{
	for(int i_chr = 0; i_chr < (int)strs->size(); i_chr++)
	{
		if(t_string::compare_strings(strs->at(i_chr), str))
		{
			return(i_chr);
		}
	} // i_chr loop.

	//printf("Could not find chromosome id %s @ %s(%d), adding it to the list.\n", chrom_id, __FILE__, __LINE__);
	return((int)strs->size());
	////exit(0);
	//getc(stdin);

	//char* new_id = new char[strlen(chrom_id) + 2];
	//strcpy(new_id, chrom_id);
	//chr_ids->push_back(new_id);

	//return(t_string::get_i_str(chr_ids, chrom_id));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
xorl %r14d, %r14d
movq 0x8(%r15), %rax
subq (%r15), %rax
shrq $0x3, %rax
movslq %eax, %rcx
cmpq %rcx, %r14
jge 0x21195
movq %r15, %rdi
movq %r14, %rsi
callq 0x7342
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x2100e
testb %al, %al
jne 0x21192
incq %r14
jmp 0x21160
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::get_i_str(std::vector<t_string*, std::allocator<t_string*>>*, char*)
int t_string::get_i_str(vector<t_string*>* strs, char* str)
{
	for(int i_chr = 0; i_chr < (int)strs->size(); i_chr++)
	{
		if(t_string::compare_strings(strs->at(i_chr)->str(), str))
		{
			return(i_chr);
		}
	} // i_chr loop.

	//printf("Could not find chromosome id %s @ %s(%d), adding it to the list.\n", chrom_id, __FILE__, __LINE__);
	return((int)strs->size());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
xorl %r14d, %r14d
movq 0x8(%r15), %rax
subq (%r15), %rax
shrq $0x3, %rax
movslq %eax, %rcx
cmpq %rcx, %r14
jge 0x211e5
movq %r15, %rdi
movq %r14, %rsi
callq 0x205dc
movq (%rax), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x2100e
testb %al, %al
jne 0x211e2
incq %r14
jmp 0x211aa
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::get_i_str_ci(std::vector<char*, std::allocator<char*>>*, char*)
int t_string::get_i_str_ci(vector<char*>* strs, char* str)
{
	for(int i_chr = 0; i_chr < (int)strs->size(); i_chr++)
	{
		if(t_string::compare_strings_ci(strs->at(i_chr), str))
		{
			return(i_chr);
		}
	} // i_chr loop.

	//printf("Could not find chromosome id %s @ %s(%d), adding it to the list.\n", chrom_id, __FILE__, __LINE__);
	return((int)strs->size());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
xorl %r14d, %r14d
movq 0x8(%r15), %rax
subq (%r15), %rax
shrq $0x3, %rax
movslq %eax, %rcx
cmpq %rcx, %r14
jge 0x21237
movq %r15, %rdi
movq %r14, %rsi
callq 0x7342
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x2123e
testb %al, %al
jne 0x21234
incq %r14
jmp 0x21202
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::compare_strings_ci(char const*, char const*)
bool t_string::compare_strings_ci(const char* str1, const char* str2)
{
        int str_len1 = string_length(str1);
        int str_len2 = string_length(str2);

        if(str_len1 != str_len2)
        {
                return(false);
        }

        for(int i = 0; i < str_len1; i++)
        {
                if(toupper(str1[i]) != toupper(str2[i]))
                {
                        return(false);
                }
        }

        return(true);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x20d90
movl %eax, %r12d
movq %rbx, %rdi
callq 0x20d90
xorl %r15d, %r15d
cmpl %eax, %r12d
jne 0x2129f
movslq %r12d, %r13
testl %r12d, %r12d
cmovlel %r15d, %r12d
cmpq %r15, %r12
je 0x21298
movsbl (%r14,%r15), %edi
callq 0x2320
movl %eax, %ebp
movsbl (%rbx,%r15), %edi
callq 0x2320
incq %r15
cmpl %eax, %ebp
je 0x21271
xorl %r15d, %r15d
jmp 0x2129f
cmpq %r13, %r15
setge %r15b
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::get_integers_in_string()
vector<int>* t_string::get_integers_in_string()
{
	vector<int>* int_vector = new vector<int>();

	// The number string.
	t_string* cur_int_str = new t_string();

	int l_str = this->length();
	for(int char_i = 0; char_i < l_str; char_i++)
	{
		if(this->x(char_i) >= '0' && this->x(char_i) <= '9')
		{
			// Add this character.
			cur_int_str->concat_char(this->x(char_i));
		}
		else
		{
			if(cur_int_str->length() > 0)
			{
				int new_num = str2num(cur_int_str, 10);

				// Add the new number
				int_vector->push_back(new_num); 

				cur_int_str->empty();
			}
		}
	} // char index.

	// Process the last string if it is a number.
	if(cur_int_str->length() > 0)
	{
		int new_num = str2num(cur_int_str, 10);

		// Add the new number
		int_vector->push_back(new_num); 

		cur_int_str->empty();
	}

	// Free integer storing string.
	delete(cur_int_str);

	return(int_vector);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
pushq $0x18
popq %rdi
callq 0x2170
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
pushq $0x8
popq %rdi
callq 0x2170
movq %rax, %r14
movq %rax, %rdi
callq 0x20cd8
movq (%r15), %rax
movl 0xc(%rax), %r13d
xorl %ebp, %ebp
testl %r13d, %r13d
cmovlel %ebp, %r13d
movq %rsp, %r12
cmpq %rbp, %r13
je 0x21377
movq (%r15), %rax
movq (%rax), %rax
movb (%rax,%rbp), %al
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x21343
movsbl %al, %esi
movq %r14, %rdi
callq 0x213f4
jmp 0x21372
movq (%r14), %rax
cmpl $0x0, 0xc(%rax)
jle 0x21372
movq %r14, %rdi
pushq $0xa
popq %rsi
callq 0x21490
movl %eax, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x73a8
movq (%r14), %rax
andl $0x0, 0xc(%rax)
movq (%rax), %rax
movb $0x0, (%rax)
incq %rbp
jmp 0x21320
movq (%r14), %rax
cmpl $0x0, 0xc(%rax)
jle 0x213a7
pushq $0xa
popq %rsi
movq %r14, %rdi
callq 0x21490
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
movq %rbx, %rdi
callq 0x73a8
movq (%r14), %rax
andl $0x0, 0xc(%rax)
movq (%rax), %rax
movb $0x0, (%rax)
movq %r14, %rdi
callq 0x212b2
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x2180
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x2180
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::concat_char(char)
void t_string::concat_char(char _char)
{
	//fprintf(stderr, "Concatting %c\n", _char);

	// A memory check.
	int str_len = this->length();
	while(this->string_buffer->l_buffer_mem <= (str_len + 10))
	{		
		char* temp_buf = this->string_buffer->string_buff;
		
		this->string_buffer->l_buffer_mem *= 2;
		this->string_buffer->i_buff = 0;
		this->string_buffer->string_buff = new char[this->string_buffer->l_buffer_mem];		

		// Following uses concat char, again, but at this point, it is for sure that the string has enough memory.
		for(int i = 0; i < str_len; i++)
		{
			this->concat_char(temp_buf[i]);
		}

		delete [] temp_buf;
	}

	int unconcat_length = str_len;
	this->string_buffer->string_buff[unconcat_length] = _char;
	this->string_buffer->i_buff = unconcat_length+1;

	// This is vert important. Finish the string!
	this->string_buffer->string_buff[unconcat_length + 1] = 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, 0x4(%rsp)
movq %rdi, %rbx
movq (%rdi), %rbp
movslq 0xc(%rbp), %r15
leal 0xa(%r15), %r12d
xorl %r13d, %r13d
testl %r15d, %r15d
cmovgl %r15d, %r13d
movslq 0x8(%rbp), %rdi
movq (%rbp), %r14
cmpl %r12d, %edi
jg 0x21466
addq %rdi, %rdi
movl %edi, 0x8(%rbp)
andl $0x0, 0xc(%rbp)
callq 0x2040
movq %rax, (%rbp)
xorl %ebp, %ebp
cmpq %rbp, %r13
je 0x21454
movsbl (%r14,%rbp), %esi
movq %rbx, %rdi
callq 0x213f4
incq %rbp
jmp 0x2143d
testq %r14, %r14
je 0x21461
movq %r14, %rdi
callq 0x2210
movq (%rbx), %rbp
jmp 0x2141b
movl 0x4(%rsp), %eax
movb %al, (%r14,%r15)
leaq 0x1(%r15), %rax
movq (%rbx), %rcx
movl %eax, 0xc(%rcx)
movq (%rcx), %rax
movb $0x0, 0x1(%rax,%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::get_alphanumeric(char*)
char* t_string::get_alphanumeric(char* string)
{
	int l_str = t_string::string_length(string);
	char* alphanum_string = new char[l_str + 2];
	//memset(alphanum_string, 0, l_str);
	t_string::set_byte_buffer(alphanum_string, l_str, 0);
	int i_an = 0;
	for(int i = 0; i < l_str; i++)
	{
		// Update if this is an alphanumeric character.
		if((string[i] >= 'a' && string[i] <= 'z') ||
			(string[i] >= 'A' && string[i] <= 'Z') ||
			(string[i] >= '0' && string[i] <= '9'))
		{
			alphanum_string[i_an] = string[i];
			i_an++;
		}
	} // i loop.

	return(alphanum_string);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x20d90
movl %eax, %r15d
leal 0x2(%r15), %eax
movslq %eax, %rdi
callq 0x2040
movq %rax, %r14
movslq %r15d, %r15
xorl %r12d, %r12d
movq %rax, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x20c70
testl %r15d, %r15d
cmovlel %r12d, %r15d
xorl %eax, %eax
cmpq %r12, %r15
je 0x21505
movb (%rbx,%r12), %cl
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
jb 0x214f8
movl %ecx, %edx
andb $-0x21, %dl
addb $-0x41, %dl
cmpb $0x19, %dl
ja 0x21500
cltq
movb %cl, (%r14,%rax)
incl %eax
incq %r12
jmp 0x214da
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::substring(char const*, int, int)
char* t_string::substring(const char* str, int i, int j)
{
	//t_string* sub_str = new t_string();
	char* sub_str = NULL;

	int l_str = t_string::string_length(str);

	// Validity checks on the arguments.
	if(i > j ||
		i > l_str)
	{
		return(NULL);
	}
	else if(j >= l_str)
	{
		j = l_str-1;
	}

	sub_str = new char[j-i+1+2];
	sub_str[0] = 0; // Make this an empty string.

	// Copy the substring.
	int ip = i;
	int i_sub_str = 0;
	while(ip <= j)
	{
		sub_str[i_sub_str] = str[ip];

		i_sub_str++;
		ip++;
	}

	// End the string.
	sub_str[i_sub_str] = 0;

	return(sub_str);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
callq 0x20d90
cmpl %r14d, %ebp
setg %cl
cmpl %ebp, %eax
setl %dl
orb %cl, %dl
je 0x21543
xorl %eax, %eax
jmp 0x21588
leal -0x1(%rax), %r15d
cmpl %r14d, %eax
cmovgl %r14d, %r15d
movl %r15d, %eax
subl %ebp, %eax
addl $0x3, %eax
movslq %eax, %rdi
callq 0x2040
movb $0x0, (%rax)
movslq %ebp, %rcx
movslq %r15d, %rdx
addq %rcx, %rbx
xorl %esi, %esi
leaq (%rcx,%rsi), %rdi
cmpq %rdx, %rdi
jg 0x21582
movb (%rbx,%rsi), %dil
movb %dil, (%rax,%rsi)
incq %rsi
jmp 0x2156c
movl %esi, %ecx
movb $0x0, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::substring(int, int)
char* t_string::substring(int i, int j)
{
	//t_string* sub_str = new t_string();
	char* sub_str;

	// Validity checks on the arguments.
	if(i > j ||
		i > this->length() || 
		j > this->length())
	{
		return(NULL);
	}
	else
	{
		sub_str = (char*)malloc(sizeof(char) * (j-i+1+2));
		sub_str[0] = 0; // Make this an empty string.
	}

	// Copy the substring.
	int ip = i;
	int i_sub_str = 0;
	while(ip <= j)
	{
		sub_str[i_sub_str] = this->x(ip);

		i_sub_str++;
		ip++;
	}

	// End the string.
	sub_str[i_sub_str] = 0;

	return(sub_str);
}

// Assembly:
movl %edx, %eax
subl %esi, %eax
jge 0x2159d
xorl %eax, %eax
retq
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq (%rdi), %r14
cmpl %edx, 0xc(%r14)
jge 0x215b0
xorl %eax, %eax
jmp 0x215ea
movl %esi, %ebp
addl $0x3, %eax
movslq %eax, %rdi
callq 0x2220
movb $0x0, (%rax)
movslq %ebp, %rdx
movslq %ebx, %rsi
xorl %ecx, %ecx
leaq (%rdx,%rcx), %rdi
cmpq %rsi, %rdi
jg 0x215e4
movq (%r14), %rdi
addq %rdx, %rdi
movb (%rcx,%rdi), %dil
movb %dil, (%rax,%rcx)
incq %rcx
jmp 0x215c8
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::is_empty(char*)
bool t_string::is_empty(char* string)
{
	int l_str = t_string::string_length(string);

	for(int i = 0; i < l_str; i++)
	{
		// 
		if(string[i] != ' ' && 
			string[i] != '\t' &&
			string[i] != '\n')
		{
			return(false);
		}
	}

	return(true);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x20d90
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
movabsq $0x100000600, %rsi      # imm = 0x100000600
cmpq %rcx, %rdx
je 0x2162d
movzbl (%rbx,%rcx), %edi
cmpq $0x20, %rdi
ja 0x2162d
btq %rdi, %rsi
jae 0x2162d
incq %rcx
jmp 0x21613
cltq
cmpq %rax, %rcx
setge %al
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::replace_avoid_list(char*, char, char, char)
void t_string::replace_avoid_list(char* str, char start_char, char end_char, char char_to_replace)
{
	t_string* avoided_char_list_str = new t_string();
	for(char cur_char = start_char; cur_char <= end_char; cur_char++)
	{
		avoided_char_list_str->concat_char(cur_char);
	} // cur_char loop.

	t_string::replace_avoid_list(str, avoided_char_list_str->str(), char_to_replace);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
pushq $0x8
popq %rdi
callq 0x2170
movq %rax, %r12
movq %rax, %rdi
callq 0x20cd8
jmp 0x216bc
movsbl %r15b, %esi
movq %r12, %rdi
callq 0x213f4
incb %r15b
cmpb %bpl, %r15b
jle 0x216ad
movq (%r12), %rax
movq (%rax), %rsi
movsbl %bl, %edx
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x216f2
movq %rax, %rbx
pushq $0x8
popq %rsi
movq %r12, %rdi
callq 0x2180
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::replace_avoid_list(char*, char*, char)
void t_string::replace_avoid_list(char* str, char* avoided_char_list, char char_to_replace)
{
	char* temp_str = new char[string_length(str) + 3];
	//memset(temp_str, 0, string_length(str) + 3);
	t_string::set_byte_buffer(temp_str, string_length(str) + 3, 0);
	int i_tmp_str = 0;
	for(int i_str = 0; i_str < string_length(str); i_str++)
	{
		// Look for avoided chars. if found, replace.
		bool found_avoided_char = false;
		for(int i_avoided = 0; i_avoided < string_length(avoided_char_list); i_avoided++)
		{
			if(str[i_str] == avoided_char_list[i_avoided])
			{
				found_avoided_char = true;
			}
		} // i_avoided loop

		if(found_avoided_char)
		{
			if(char_to_replace == 0)
			{
				// Do not put anything in the temporary string.
			}
			else
			{
				temp_str[i_tmp_str] = char_to_replace;
				i_tmp_str++;
			}
		}
		else
		{
			temp_str[i_tmp_str] = str[i_str];
			i_tmp_str++;
		}
	} // i_str loop

	copy(str, temp_str);
	delete [] temp_str;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x20d90
movl %eax, %r15d
leal 0x3(%r15), %eax
movslq %eax, %r12
movq %r12, %rdi
callq 0x2040
xorl %r13d, %r13d
movq %rax, (%rsp)
movq %rax, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x20c70
testl %r15d, %r15d
cmovlel %r13d, %r15d
xorl %r12d, %r12d
cmpq %r15, %r13
je 0x2178e
movq %r14, %rdi
callq 0x20d90
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorl %edx, %edx
cmpq %rcx, %rax
je 0x21769
movb (%rbx,%r13), %sil
cmpb (%r14,%rcx), %sil
sete %sil
orb %sil, %dl
incq %rcx
jmp 0x21750
testb $0x1, %dl
je 0x21777
movl %ebp, %eax
testb %bpl, %bpl
jne 0x2177b
jmp 0x21789
movb (%rbx,%r13), %al
movslq %r12d, %r12
movq (%rsp), %rcx
movb %al, (%rcx,%r12)
incl %r12d
incq %r13
jmp 0x2173a
movq %rbx, %rdi
movq (%rsp), %rbx
movq %rbx, %rsi
callq 0x2109c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2210
nop
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::pool_obj_list(std::vector<std::vector<void*, std::allocator<void*>>*, std::allocator<std::vector<void*, std::allocator<void*>>*>>*)
vector<void*>* t_string::pool_obj_list(vector<vector<void*>*>* obj_lists_list)
{
	vector<void*>* pooled_list = new vector<void*>();

	for(int i_l = 0; i_l < (int)obj_lists_list->size(); i_l++)
	{
		pooled_list->insert(pooled_list->end(), obj_lists_list->at(i_l)->begin(), obj_lists_list->at(i_l)->end());
	} // i_l loop.

	return(pooled_list);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
pushq $0x18
popq %rdi
callq 0x2170
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
cltq
cmpq %rax, %r15
jge 0x21825
movq 0x8(%r14), %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22c22
movq (%rax), %rax
movq (%rax), %r13
movq %rbx, %rdi
movq %r15, %rsi
callq 0x22c22
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x22c02
incq %r15
jmp 0x217d9
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::interleave_obj_list(std::vector<std::vector<void*, std::allocator<void*>>*, std::allocator<std::vector<void*, std::allocator<void*>>*>>*)
vector<void*>* t_string::interleave_obj_list(vector<vector<void*>*>* obj_lists_list)
{
	vector<void*>* interleaved_list = new vector<void*>();

	int* indices_per_list = new int[(int)obj_lists_list->size()];

	// At the begining all the indices are 0.
	for(int i_i = 0; i_i < (int)obj_lists_list->size(); i_i++)
	{

		indices_per_list[i_i] = 0;
	} // i_i loop.

	while(1)
	{
		bool added = false;

		for(int i_l = 0; i_l < (int)obj_lists_list->size(); i_l++)
		{
			// If the index for this list did not pass the end of the list, add the object to the list.
			if(indices_per_list[i_l] < (int)obj_lists_list->at(i_l)->size())
			{
				interleaved_list->push_back(obj_lists_list->at(i_l)->at(indices_per_list[i_l]));
				indices_per_list[i_l]++;
				added = true;
			}
		} // i_l loop.

		if(!added)
		{
			return(interleaved_list);
		}
	} // infinite loop exits when there are no more obj's to add.
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x18
popq %rdi
callq 0x2170
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, (%rsp)
andq $0x0, 0x10(%rax)
movq (%rbx), %r14
movq 0x8(%rbx), %r13
movq %r13, %rax
subq %r14, %rax
movq %rax, %r12
shrq $0x3, %r12
shlq $0x1d, %rax
movq %rax, %rcx
sarq $0x1e, %rcx
testq %rax, %rax
pushq $-0x1
popq %rdi
cmovnsq %rcx, %rdi
callq 0x2040
movq %rax, %r15
xorl %eax, %eax
testl %r12d, %r12d
cmovlel %eax, %r12d
cmpq %rax, %r12
je 0x218a0
andl $0x0, (%r15,%rax,4)
incq %rax
jmp 0x21891
xorl %r12d, %r12d
xorl %ebp, %ebp
subq %r14, %r13
shrq $0x3, %r13
movslq %r13d, %rax
cmpq %rax, %r12
jl 0x218c4
xorl %r12d, %r12d
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x218af
jmp 0x2191f
movslq (%r15,%r12,4), %r13
movq %rbx, %rdi
movq %r12, %rsi
callq 0x22c22
movq (%rax), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shrq $0x3, %rcx
cmpl %ecx, %r13d
jge 0x21913
movq %rbx, %rdi
movq %r12, %rsi
callq 0x22c22
movq (%rax), %rdi
movq %r13, %rsi
callq 0x17bae
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x22c44
leal 0x1(%r13), %eax
movl %eax, (%r15,%r12,4)
movb $0x1, %bpl
incq %r12
movq (%rbx), %r14
movq 0x8(%rbx), %r13
jmp 0x218a5
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::split_object_list(std::vector<void*, std::allocator<void*>>*, int)
vector<vector<void*>*>* t_string::split_object_list(vector<void*>* obj_list, int n_batches)
{
	vector<vector<void*>*>* batches = new vector<vector<void*>*>();

	int n_objs_per_batch = (int)obj_list->size() / n_batches;
	vector<void*>* current_batch = new vector<void*>();
	batches->push_back(current_batch);
	for(int i_str = 0; i_str < (int)obj_list->size(); i_str++)
	{
		if((int)current_batch->size() == n_objs_per_batch)
		{
			current_batch = new vector<void*>();
			batches->push_back(current_batch);
		}

		current_batch->push_back(obj_list->at(i_str));
	} // i_str loop.

	return(batches);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
pushq $0x18
popq %r14
movq %r14, %rdi
callq 0x2170
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
cltd
idivl %ebp
movl %eax, %ebp
movq %r14, %rdi
callq 0x2170
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rsp, %r12
movq %rax, (%r12)
movq %r15, %rdi
movq %r12, %rsi
callq 0x22c62
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
cltq
cmpq %rax, %r13
jge 0x219fa
movq (%rsp), %r14
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x3, %rax
cmpl %eax, %ebp
jne 0x219df
pushq $0x18
popq %rdi
callq 0x2170
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x22c62
movq (%rsp), %r14
movq %rbx, %rdi
movq %r13, %rsi
callq 0x17bae
movq %r14, %rdi
movq %rax, %rsi
callq 0x22c44
incq %r13
jmp 0x21994
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::split_string_list(std::vector<char*, std::allocator<char*>>*, int)
vector<vector<char*>*>* t_string::split_string_list(vector<char*>* string_list, int n_batches)
{
	vector<vector<char*>*>* batches = new vector<vector<char*>*>();

	int n_string_per_batch = (int)string_list->size() / n_batches;
	vector<char*>* current_batch = new vector<char*>();
	batches->push_back(current_batch);
	for(int i_str = 0; i_str < (int)string_list->size(); i_str++)
	{
		if((int)current_batch->size() == n_string_per_batch)
		{
			current_batch = new vector<char*>();
			batches->push_back(current_batch);
		}

		current_batch->push_back(string_list->at(i_str));
	} // i_str loop.

	return(batches);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
pushq $0x18
popq %r14
movq %r14, %rdi
callq 0x2170
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
cltd
idivl %ebp
movl %eax, %ebp
movq %r14, %rdi
callq 0x2170
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rsp, %r12
movq %rax, (%r12)
movq %r15, %rdi
movq %r12, %rsi
callq 0x22c80
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
cltq
cmpq %rax, %r13
jge 0x21ad4
movq (%rsp), %r14
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x3, %rax
cmpl %eax, %ebp
jne 0x21ab9
pushq $0x18
popq %rdi
callq 0x2170
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x22c80
movq (%rsp), %r14
movq %rbx, %rdi
movq %r13, %rsi
callq 0x7342
movq %r14, %rdi
movq %rax, %rsi
callq 0xecb8
incq %r13
jmp 0x21a6e
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::split_int_list(std::vector<int, std::allocator<int>>*, int)
vector<vector<int>*>* t_string::split_int_list(vector<int>* int_list, int n_batches)
{
	vector<vector<int>*>* batches = new vector<vector<int>*>();

	int n_ints_per_batch = (int)int_list->size() / n_batches;
	vector<int>* current_batch = new vector<int>();
	batches->push_back(current_batch);
	for(int i_str = 0; i_str < (int)int_list->size(); i_str++)
	{
		if((int)current_batch->size() == n_ints_per_batch)
		{
			current_batch = new vector<int>();
			batches->push_back(current_batch);
		}

		current_batch->push_back(int_list->at(i_str));
	} // i_str loop.

	return(batches);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
pushq $0x18
popq %r14
movq %r14, %rdi
callq 0x2170
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x2, %rax
cltd
idivl %ebp
movl %eax, %ebp
movq %r14, %rdi
callq 0x2170
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rsp, %r12
movq %rax, (%r12)
movq %r15, %rdi
movq %r12, %rsi
callq 0x22c9e
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x2, %rax
cltq
cmpq %rax, %r13
jge 0x21bae
movq (%rsp), %r14
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x2, %rax
cmpl %eax, %ebp
jne 0x21b93
pushq $0x18
popq %rdi
callq 0x2170
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, (%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x22c9e
movq (%rsp), %r14
movq %rbx, %rdi
movq %r13, %rsi
callq 0x7364
movq %r14, %rdi
movq %rax, %rsi
callq 0x73a8
incq %r13
jmp 0x21b48
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::get_unique_entries(std::vector<char*, std::allocator<char*>>*)
vector<char*>* t_string::get_unique_entries(vector<char*>* str_list)
{
	if(str_list == NULL)
	{
		return(NULL);
	}

	vector<char*>* unique_entries = new vector<char*>();
	for(int i_str = 0; i_str < (int)str_list->size(); i_str++)
	{
		int i_ent = t_string::get_i_str(unique_entries, str_list->at(i_str));
		if(i_ent == (int)unique_entries->size())
		{
			unique_entries->push_back(t_string::copy_me_str(str_list->at(i_str)));
		}
	} // i_str loop.

	return(unique_entries);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x21c4a
movq %rdi, %rbx
pushq $0x18
popq %rdi
callq 0x2170
movq %rax, %r14
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %r15d, %r15d
movq %rsp, %r12
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
cltq
cmpq %rax, %r15
jge 0x21c4d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7342
movq (%rax), %rsi
movq %r14, %rdi
callq 0x21152
movq 0x8(%r14), %rcx
subq (%r14), %rcx
shrq $0x3, %rcx
cmpl %ecx, %eax
jne 0x21c45
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7342
movq (%rax), %rdi
callq 0x21062
movq %rax, (%rsp)
movq %r14, %rdi
movq %r12, %rsi
callq 0x7d0a
incq %r15
jmp 0x21bec
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::clean_string_list(std::vector<char*, std::allocator<char*>>*)
void t_string::clean_string_list(vector<char*>* string_list)
{
	for(int i = 0; i < (int)string_list->size(); i++)
	{
		delete [] string_list->at(i);
	}

	string_list->clear();

	delete string_list;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
movslq %edx, %rdx
cmpq %rdx, %r14
jge 0x22232
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7342
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2222d
callq 0x2210
incq %r14
jmp 0x221fc
cmpq %rax, %rcx
je 0x2223b
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x7cb8
pushq $0x18
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2180
nop
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::clean_tokens(std::vector<t_string*, std::allocator<t_string*>>*)
void t_string::clean_tokens(t_string_tokens* tokens)
{
	for(int i = 0; i < (int)tokens->size(); i++)
	{
		delete(tokens->at(i));
	}

	tokens->clear();
	delete(tokens);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
pushq $0x8
popq %r15
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
shrq $0x3, %rdx
movslq %edx, %rdx
cmpq %rdx, %r14
jge 0x222ac
movq %rbx, %rdi
movq %r14, %rsi
callq 0x205dc
movq (%rax), %r12
testq %r12, %r12
je 0x2229c
movq %r12, %rdi
callq 0x212b2
movq %r12, %rdi
movq %r15, %rsi
callq 0x2180
incq %r14
jmp 0x22268
cmpq %rax, %rcx
je 0x222b5
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x23cae
pushq $0x18
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2180
nop
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::remove_beginning_spaces(char*)
char* t_string::remove_beginning_spaces(char* string)
{
	int i_last_space = 0;

	int l_str = t_string::string_length(string);

	for(int i = 0; i < l_str; i++)
	{
		if(string[i] != ' ')
		{
			i_last_space = i;
			break;
		}
	}

	char* reloc_copy = new char[l_str + 2];

	// Relocate.
	copy(reloc_copy, &string[i_last_space]);
	
	return(reloc_copy);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x20d90
xorl %ecx, %ecx
testl %eax, %eax
cmovgl %eax, %ecx
negq %rcx
pushq $-0x1
popq %rdx
leaq (%rcx,%rdx), %rsi
cmpq $-0x1, %rsi
je 0x22308
leaq 0x1(%rdx), %r15
cmpb $0x20, 0x1(%rbx,%rdx)
movq %r15, %rdx
je 0x222ee
jmp 0x2230b
xorl %r15d, %r15d
addl $0x2, %eax
movslq %eax, %rdi
callq 0x2040
movq %rax, %r14
addq %r15, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2109c
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::remove_beginning_spaces()
void t_string::remove_beginning_spaces()
{
	int i_last_space = 0;

	for(int i = 0; i < this->length(); i++)
	{
		if(this->x(i) != ' ')
		{
			i_last_space = i;
			break;
		}
	}

	char* reloc_copy = (char*)malloc(sizeof(char*) * (this->length() + 2));

	copy(reloc_copy, this->str());

	// Relocate.
	copy(this->str(), &reloc_copy[i_last_space]);
	free(reloc_copy);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rdx
movslq 0xc(%rdx), %rax
xorl %ebx, %ebx
testl %eax, %eax
movl $0x0, %ecx
cmovgl %eax, %ecx
movq (%rdx), %r14
cmpq %rbx, %rcx
je 0x2235c
cmpb $0x20, (%r14,%rbx)
jne 0x2235e
incq %rbx
jmp 0x2234b
xorl %ebx, %ebx
leaq 0x10(,%rax,8), %rdi
callq 0x2220
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x2109c
addq %r15, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2109c
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x21c0