LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/gersteinlab[P]MUSIC/src/ms_utils.cpp
// Function: get_n_non_empty_lines(char*)
int get_n_non_empty_lines(char* fp)
{
	int n_lines = 0;
	FILE* f = open_f(fp, "r");
	while(1)
	{
		char* cur_line = getline(f);
		if(cur_line == NULL)
		{
			break;
		}

		if(!line_empty(cur_line))
		{
			n_lines++;
		}

		delete [] cur_line;
	}
	fclose(f);

	return(n_lines);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0x7908(%rip), %rsi      # 0x2dd08
callq 0x26387
movq %rax, %r14
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x26258
movq %rax, %r15
testq %rax, %rax
je 0x26431
movq %r15, %rdi
callq 0x26446
xorb $0x1, %al
movzbl %al, %eax
addl %eax, %ebx
movq %r15, %rdi
callq 0x2220
testq %r15, %r15
jne 0x2640a
movq %r14, %rdi
callq 0x2170
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/gersteinlab[P]MUSIC/src/ms_utils.cpp
// Function: line_empty(char*)
bool line_empty(char* line)
{
	int l = t_string::string_length(line);
	for(int i = 0; i < l; i++)
	{
		if(line[i] != ' ' &&
			line[i] != '\t' &&
			line[i] != '\n')
		{
			return(false);
		}
	}

	return(true);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x26e82
movl %eax, %ecx
testl %eax, %eax
setle %al
jle 0x26497
movl %ecx, %ecx
movq %rcx, %rdx
negq %rdx
movl $0x1, %esi
movabsq $0x100000600, %rdi      # imm = 0x100000600
movzbl -0x1(%rbx,%rsi), %r8d
cmpq $0x20, %r8
ja 0x26497
btq %r8, %rdi
jae 0x26497
cmpq %rcx, %rsi
setae %al
leaq (%rdx,%rsi), %r8
incq %r8
incq %rsi
cmpq $0x1, %r8
jne 0x2646f
andb $0x1, %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/gersteinlab[P]MUSIC/src/ms_utils.cpp
// Function: get_next_char_per_file_buffer(t_file_buffer*, char&)
bool get_next_char_per_file_buffer(t_file_buffer* file_buffer, char& char_val)
{
	if(file_buffer->f_ptr < file_buffer->l_file)
	{
		char_val = file_buffer->file_buffer[file_buffer->f_ptr];
		file_buffer->f_ptr++;
		return(true);
	}
	else
	{
		char_val = 0;
		return(false);
	}
}

// Assembly:
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
cmpq %rcx, %rax
jge 0x264b6
movq (%rdi), %rdx
movb (%rdx,%rax), %dl
movb %dl, (%rsi)
incq 0x8(%rdi)
jmp 0x264b9
movb $0x0, (%rsi)
cmpq %rcx, %rax
setl %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/gersteinlab[P]MUSIC/src/ms_utils.cpp
// Function: get_next_token_per_file_till_newline(_IO_FILE*, char*, int, char*, bool&, bool&)
bool get_next_token_per_file_till_newline(FILE* file, char* buffer, int l_buffer, char* delim_char, bool& new_line_check, bool& eof_check)
{
	int i_buff = 0;
	char ret = 0;
	new_line_check = false;
	eof_check = false;
	while(1)
	{
		ret = getc(file);

		if(ret == EOF)
		{
			eof_check = true;
			return(false);
		}

		// If we found a new line, break. The file pointer points to the new line's beginning.
		if(ret == '\n')
		{
			new_line_check = true;
			break;
		}

		// The current character is not a new line, is it the delimiter?
		if(ret == delim_char[0])
		{
			break;
		}
		else if(i_buff < l_buffer)
		{
			// Copy the read character to the buffer, if the buffer did not overflow, otherwise does not copy but keeps reading the file till the next token is found.
			buffer[i_buff] = ret;
			i_buff++;
		}
	} // file reading loop.

	if(i_buff < l_buffer)
	{
		buffer[i_buff] = 0;
	}
	else
	{
		buffer[l_buffer-1] = 0;
	}
	
	if(i_buff == 0)
	{
		return(false);
	}
	else
	{
		return(true);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rcx, %r12
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r13
xorl %r14d, %r14d
movb %r14b, (%r8)
movq %r9, (%rsp)
movb %r14b, (%r9)
movq %r13, %rdi
callq 0x20a0
movl %eax, %ecx
shll $0x18, %ecx
cmpl $0xa000000, %ecx        # imm = 0xA000000
je 0x2655b
cmpl $0xff000000, %ecx       # imm = 0xFF000000
je 0x26550
sarl $0x18, %ecx
movsbl (%r12), %edx
cmpl %edx, %ecx
je 0x2655f
cmpl %ebp, %r14d
jge 0x26517
movl %r14d, %ecx
movb %al, (%rbx,%rcx)
incl %r14d
jmp 0x26517
movq (%rsp), %rax
movb $0x1, (%rax)
xorl %eax, %eax
jmp 0x2657d
movb $0x1, (%r15)
movl %r14d, %eax
addq %rbx, %rax
cmpl %ebp, %r14d
movslq %ebp, %rcx
leaq -0x1(%rbx,%rcx), %rcx
cmovlq %rax, %rcx
movb $0x0, (%rcx)
testl %r14d, %r14d
setne %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/gersteinlab[P]MUSIC/src/ms_utils.cpp
// Function: 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 0x22a0
testq %rax, %rax
je 0x265dd
movq %rbx, %rdi
callq 0x26e82
cltq
cmpb $0xa, -0x1(%rbx,%rax)
jne 0x265df
movq %rbx, %rdi
callq 0x26e82
cltq
movb $0x0, -0x1(%rbx,%rax)
jmp 0x265df
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x10(%rdi), %r15
movq (%r15), %rdi
movq 0x8(%r15), %rdx
subq %rdi, %rdx
sarq $0x3, %rdx
testl %edx, %edx
jle 0x26a6a
xorl %r14d, %r14d
cmpq %r14, %rdx
jbe 0x26b82
movq (%rdi,%r14,8), %rdi
callq 0x21d0
incq %r14
movq 0x10(%rbx), %r15
movq (%r15), %rdi
movq 0x8(%r15), %rax
subq %rdi, %rax
movq %rax, %rdx
sarq $0x3, %rdx
shrq $0x3, %rax
cltq
cmpq %rax, %r14
jl 0x26a35
testq %rdi, %rdi
je 0x26a7b
movq 0x10(%r15), %rsi
subq %rdi, %rsi
callq 0x2190
movl $0x18, %esi
movq %r15, %rdi
callq 0x2190
movq 0x18(%rbx), %r15
movq (%r15), %rdi
movq 0x8(%r15), %rdx
subq %rdi, %rdx
sarq $0x3, %rdx
testl %edx, %edx
jle 0x26ad6
xorl %r14d, %r14d
cmpq %r14, %rdx
jbe 0x26b82
movq (%rdi,%r14,8), %rdi
callq 0x21d0
incq %r14
movq 0x18(%rbx), %r15
movq (%r15), %rdi
movq 0x8(%r15), %rax
subq %rdi, %rax
movq %rax, %rdx
sarq $0x3, %rdx
shrq $0x3, %rax
cltq
cmpq %rax, %r14
jl 0x26aa1
testq %rdi, %rdi
je 0x26ae7
movq 0x10(%r15), %rsi
subq %rdi, %rsi
callq 0x2190
movl $0x18, %esi
movq %r15, %rdi
callq 0x2190
movq 0x20(%rbx), %r15
movq (%r15), %rdi
movq 0x8(%r15), %rdx
subq %rdi, %rdx
sarq $0x3, %rdx
testl %edx, %edx
jle 0x26b3e
xorl %r14d, %r14d
cmpq %r14, %rdx
jbe 0x26b82
movq (%rdi,%r14,8), %rdi
callq 0x21d0
incq %r14
movq 0x20(%rbx), %r15
movq (%r15), %rdi
movq 0x8(%r15), %rax
subq %rdi, %rax
movq %rax, %rdx
sarq $0x3, %rdx
shrq $0x3, %rax
cltq
cmpq %rax, %r14
jl 0x26b0d
testq %rdi, %rdi
je 0x26b4f
movq 0x10(%r15), %rsi
subq %rdi, %rsi
callq 0x2190
movl $0x18, %esi
movq %r15, %rdi
callq 0x2190
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x26b69
callq 0x21d0
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x26b7c
popq %rbx
popq %r14
popq %r15
jmp 0x21d0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x6d4d(%rip), %rdi      # 0x2d8d6
movq %r14, %rsi
xorl %eax, %eax
callq 0x2270
movq %rax, %rdi
callq 0x26c7b
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movb $0x0, (%rdx)
movq 0x10(%rdi), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
testl %edx, %edx
setg %bpl
jle 0x26c0c
movq %rsi, %r12
movq %rdi, %r15
xorl %r14d, %r14d
cmpq %r14, %rdx
jbe 0x26c40
movq (%rcx,%r14,8), %rdi
movq %r12, %rsi
callq 0x2738a
testb %al, %al
jne 0x26c0e
incq %r14
movq 0x10(%r15), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
subq %rcx, %rax
movq %rax, %rdx
sarq $0x3, %rdx
shrq $0x3, %rax
movslq %eax, %rsi
cmpq %rsi, %r14
setl %bpl
jl 0x26bcd
jmp 0x26c2c
jmp 0x26c2c
movb $0x1, (%rbx)
movq 0x18(%r15), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r14, %rdx
jbe 0x26c40
movq (%rax,%r14,8), %rax
testb $0x1, %bpl
jne 0x26c37
movb $0x0, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6c8f(%rip), %rdi      # 0x2d8d6
movq %r14, %rsi
xorl %eax, %eax
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x10, %edi
callq 0x2180
movq %rax, %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq %rax, (%r14)
movq $0x1f4, 0x8(%rax)       # imm = 0x1F4
movl $0x1f7, %edi            # imm = 0x1F7
callq 0x2040
movq %rax, (%r15)
movb (%rbx), %al
testb %al, %al
je 0x26cdb
incq %rbx
movsbl %al, %esi
movq %r14, %rdi
callq 0x278c0
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x26cc7
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x10, %edi
callq 0x2180
movq %rax, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq %rax, (%rbx)
movq $0x1f4, 0x8(%rax)       # imm = 0x1F4
movl $0x1f7, %edi            # imm = 0x1F7
callq 0x2040
movq %rax, (%r14)
movl $0x0, 0xc(%r14)
movb $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
incl %edx
cmpb $0x0, (%rdi,%rdx)
jne 0x26e19
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
incl %ecx
cmpb $0x0, (%rsi,%rcx)
jne 0x26e26
movb $0x1, %al
cmpl %ecx, %edx
jl 0x26e7a
jle 0x26e3a
xorl %eax, %eax
jmp 0x26e7a
testl %edx, %edx
setg %al
jle 0x26e78
movb (%rdi), %r8b
movb (%rsi), %r10b
movb $0x1, %cl
cmpb %r10b, %r8b
jl 0x26e78
movl %edx, %edx
movl $0x1, %r9d
cmpb %r10b, %r8b
jg 0x26e7d
cmpq %rdx, %r9
setb %al
cmpq %r9, %rdx
je 0x26e78
movb (%rdi,%r9), %r8b
movb (%rsi,%r9), %r10b
incq %r9
cmpb %r10b, %r8b
jge 0x26e56
jmp 0x26e78
andb %cl, %al
andb $0x1, %al
retq
xorl %ecx, %ecx
jmp 0x26e78
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, 0x10(%rsp)
movq %rdi, (%rsp)
movq (%rsp), %r13
leal (%rcx,%rbx), %eax
movl %eax, %r14d
shrl $0x1f, %r14d
addl %eax, %r14d
sarl %r14d
cmpl %ebx, %r14d
je 0x27348
cmpl %ecx, %r14d
je 0x27348
movq %rcx, 0x18(%rsp)
movq %rbx, 0x20(%rsp)
movslq %r14d, %r12
movq 0x10(%rsp), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %r15
subq %rax, %r15
movq %r15, %rbp
sarq $0x3, %rbp
cmpq %r12, %rbp
jbe 0x27359
movq (%rax,%r12,8), %rbx
movq %rbx, %rdi
movq %rax, 0x8(%rsp)
movq %r13, %rsi
callq 0x2738a
testb %al, %al
jne 0x272e1
movq %r13, %rdi
movq %rbx, %rsi
callq 0x26e14
testb %al, %al
jne 0x272d4
movl %r14d, %ebx
movq 0x18(%rsp), %rcx
jmp 0x27255
movl %r14d, %ecx
movq 0x20(%rsp), %rbx
jmp 0x27255
movq %r12, %r13
cmpl %ebp, %r14d
movq 0x8(%rsp), %r12
jge 0x2731c
shrq $0x3, %r15
movslq %r15d, %rbx
movq %r13, %r14
movq (%rsp), %r15
cmpq %r14, %rbp
jbe 0x27365
movq (%r12,%r14,8), %rdi
movq %r15, %rsi
callq 0x26e14
testb %al, %al
je 0x2731c
incq %r14
cmpq %r14, %rbx
jne 0x272fc
movl %ebp, %r14d
xorl %eax, %eax
cmpl %ebp, %r14d
sete %al
movl %r14d, %ebx
subl %eax, %ebx
testl %ebx, %ebx
jle 0x27348
movl %ebx, %esi
cmpq %rsi, %rbp
jbe 0x27380
movq (%r12,%rsi,8), %rdi
movq (%rsp), %rsi
callq 0x26e14
xorb $0x1, %al
movzbl %al, %eax
subl %eax, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6576(%rip), %rdi      # 0x2d8d6
movq %r12, %rsi
jmp 0x27376
cmpq %r13, %rbp
cmovaq %rbp, %r13
leaq 0x6563(%rip), %rdi      # 0x2d8d6
movq %r13, %rsi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x2270
leaq 0x654f(%rip), %rdi      # 0x2d8d6
jmp 0x27376
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorl %eax, %eax
movl %eax, %ecx
incl %eax
cmpb $0x0, (%rdi,%rcx)
jne 0x2738c
leal -0x1(%rax), %ecx
xorl %edx, %edx
movl %edx, %r8d
incl %edx
cmpb $0x0, (%rsi,%r8)
jne 0x2739b
cmpl %edx, %eax
jne 0x273dc
testl %ecx, %ecx
setle %al
jle 0x273db
movb (%rdi), %dl
cmpb (%rsi), %dl
jne 0x273db
movl %ecx, %eax
movl $0x1, %edx
movq %rdx, %rcx
cmpq %rdx, %rax
je 0x273d5
movb (%rdi,%rcx), %r8b
leaq 0x1(%rcx), %rdx
cmpb (%rsi,%rcx), %r8b
je 0x273bf
cmpq %rax, %rcx
setae %al
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::copy_me_str(char const*)
char* t_string::copy_me_str(const char* str)
{
	if(str == NULL)
	{
		return(NULL);
	}

	char* new_str = new char[t_string::string_length(str) + 2];
	t_string::copy(new_str, str);
	return(new_str);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x2742e
movq %rdi, %rbx
movl $0x1, %eax
leal -0x1(%rax), %ecx
incl %eax
cmpb $0x0, (%rbx,%rcx)
jne 0x273f2
movslq %eax, %rdi
callq 0x2040
movq %rax, %r14
xorl %edx, %edx
movl %edx, %r15d
incl %edx
cmpb $0x0, (%rbx,%r15)
jne 0x2740a
cmpl $0x1, %edx
adcl $0x0, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2130
movb $0x0, (%r14,%r15)
jmp 0x27431
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorl %ecx, %ecx
movl %ecx, %eax
incl %ecx
cmpb $0x0, (%rsi,%rax)
jne 0x2743c
movl %ecx, %ecx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %edx, %edx
movb (%rsi,%rdx), %r8b
movb %r8b, (%rdi,%rdx)
incq %rdx
cmpq %rdx, %rcx
jne 0x27452
movb $0x0, (%rdi,%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x274fc
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
shrq $0x3, %rcx
cmpl %ecx, %eax
jne 0x274cb
movq %r14, %rdi
callq 0x273e0
movq %rax, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x274a6
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x274b1
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x12d32
movq %rbx, %rdi
movq %r14, %rsi
callq 0x274fc
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
shrq $0x3, %rcx
cmpl %ecx, %eax
je 0x274d3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x12b06(%rip), %rax     # 0x39fe0
movq (%rax), %rdi
leaq 0x84b8(%rip), %rsi      # 0x2f99c
movq %r14, %rdx
xorl %eax, %eax
callq 0x2250
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
jmp 0x274cb
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
movq (%rdi), %r12
movq 0x8(%rdi), %rbx
subq %r12, %rbx
sarq $0x3, %rbx
testl %ebx, %ebx
jle 0x27549
movq %rsi, %r14
movl %ebx, %r13d
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %r15d, %r15d
cmpq %r15, %rbx
je 0x27560
movq (%r12,%r15,8), %rdi
movq %r14, %rsi
callq 0x2738a
testb %al, %al
jne 0x2754c
incq %r15
cmpq %r15, %r13
jne 0x27527
movl %ebx, %r15d
jmp 0x2754c
xorl %r15d, %r15d
cmpl %ebx, %r15d
cmovgel %ebx, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x636f(%rip), %rdi      # 0x2d8d6
movq %rbx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
movq (%rdi), %r12
movq 0x8(%rdi), %rbx
subq %r12, %rbx
sarq $0x3, %rbx
testl %ebx, %ebx
jle 0x275c7
movq %rsi, %r14
movl %ebx, %r13d
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %r15d, %r15d
cmpq %r15, %rbx
je 0x275de
movq (%r12,%r15,8), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq %r14, %rsi
callq 0x2738a
testb %al, %al
jne 0x275ca
incq %r15
cmpq %r15, %r13
jne 0x2759f
movl %ebx, %r15d
jmp 0x275ca
xorl %r15d, %r15d
cmpl %ebx, %r15d
cmovgel %ebx, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x62f1(%rip), %rdi      # 0x2d8d6
movq %rbx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
movq (%rdi), %r12
movq 0x8(%rdi), %rbx
subq %r12, %rbx
sarq $0x3, %rbx
testl %ebx, %ebx
jle 0x27647
movq %rsi, %r14
movl %ebx, %r13d
andl $0x7fffffff, %r13d      # imm = 0x7FFFFFFF
xorl %r15d, %r15d
cmpq %r15, %rbx
je 0x2765e
movq (%r12,%r15,8), %rdi
movq %r14, %rsi
callq 0x27672
testb %al, %al
jne 0x2764a
incq %r15
cmpq %r15, %r13
jne 0x27625
movl %ebx, %r15d
jmp 0x2764a
xorl %r15d, %r15d
cmpl %ebx, %r15d
cmovgel %ebx, %r15d
movl %r15d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x6271(%rip), %rdi      # 0x2d8d6
movq %rbx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
movl %eax, %ecx
incl %eax
cmpb $0x0, (%r14,%rcx)
jne 0x27682
leal -0x1(%rax), %r12d
xorl %ecx, %ecx
movl %ecx, %edx
incl %ecx
cmpb $0x0, (%rbx,%rdx)
jne 0x27693
cmpl %ecx, %eax
jne 0x276fb
testl %r12d, %r12d
setle %bpl
jle 0x276fd
movsbl (%r14), %edi
callq 0x2330
movl %eax, %r15d
movsbl (%rbx), %edi
callq 0x2330
cmpl %eax, %r15d
jne 0x276fd
movl %r12d, %r15d
movl $0x1, %ecx
movq %rcx, %r12
cmpq %rcx, %r15
je 0x276f2
movsbl (%r14,%r12), %edi
callq 0x2330
movl %eax, %ebp
movsbl (%rbx,%r12), %edi
callq 0x2330
leaq 0x1(%r12), %rcx
cmpl %eax, %ebp
je 0x276cb
cmpq %r15, %r12
setae %bpl
jmp 0x276fd
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x18, %edi
callq 0x2180
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movl $0x8, %edi
callq 0x2180
movq %rax, %r14
movl $0x10, %edi
callq 0x2180
movq %rax, %r12
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq %rax, (%r14)
movq $0x1f4, 0x8(%rax)       # imm = 0x1F4
movl $0x1f7, %edi            # imm = 0x1F7
callq 0x2040
movq %rax, (%r12)
movl $0x0, 0xc(%r12)
movb $0x0, (%rax)
movq (%r15), %rax
movslq 0xc(%rax), %r13
testq %r13, %r13
jle 0x27824
xorl %ebp, %ebp
leaq 0x4(%rsp), %r12
movq (%r15), %rax
movq (%rax), %rax
movb (%rax,%rbp), %al
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x277d1
movsbl %al, %esi
movq %r14, %rdi
callq 0x278c0
jmp 0x2781c
movq (%r14), %rax
cmpl $0x0, 0xc(%rax)
jle 0x2781c
movq (%rax), %rdi
movl $0xa, %esi
callq 0x29834
movl %eax, 0x4(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x27801
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2780c
movq %rbx, %rdi
movq %r12, %rdx
callq 0xadd0
movq (%r14), %rax
movl $0x0, 0xc(%rax)
movq (%rax), %rax
movb $0x0, (%rax)
incq %rbp
cmpq %rbp, %r13
jne 0x277b3
movq (%r14), %rax
cmpl $0x0, 0xc(%rax)
jle 0x2786e
movq (%rax), %rdi
movl $0xa, %esi
callq 0x29834
movl %eax, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x27853
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2785e
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xadd0
movq (%r14), %rax
movl $0x0, 0xc(%rax)
movq (%rax), %rax
movb $0x0, (%rax)
movq %r14, %rdi
callq 0x27708
movl $0x8, %esi
movq %r14, %rdi
callq 0x2190
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x8, %esi
movq %r14, %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl 0x8(%rbp), %eax
movl 0xc(%rbp), %r12d
movslq %r12d, %r15
leal 0xa(%r15), %r13d
cmpl %r13d, %eax
jg 0x27935
movq (%rbp), %r14
addl %eax, %eax
movl %eax, 0x8(%rbp)
movl $0x0, 0xc(%rbp)
movslq %eax, %rdi
callq 0x2040
movq %rax, (%rbp)
testl %r12d, %r12d
jle 0x27920
xorl %ebp, %ebp
movsbl (%r14,%rbp), %esi
movq %rbx, %rdi
callq 0x278c0
incq %rbp
cmpq %rbp, %r12
jne 0x2790b
testq %r14, %r14
je 0x2792d
movq %r14, %rdi
callq 0x2220
movq (%rbx), %rbp
movl 0x8(%rbp), %eax
jmp 0x278e3
movq (%rbp), %rax
movl 0x4(%rsp), %ecx
movb %cl, (%rax,%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
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
incl %r12d
cmpb $0x0, (%rbx,%r12)
jne 0x27981
leal 0x2(%r12), %eax
movslq %eax, %rdi
callq 0x2040
movq %rax, %r14
movl %r12d, %r15d
testl %r12d, %r12d
jle 0x279b0
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x20f0
testl %r12d, %r12d
jle 0x279e6
xorl %eax, %eax
xorl %ecx, %ecx
movb (%rbx,%rax), %dl
leal -0x30(%rdx), %esi
cmpb $0xa, %sil
jb 0x279d5
movl %edx, %esi
andb $-0x21, %sil
addb $-0x41, %sil
cmpb $0x19, %sil
ja 0x279de
movslq %ecx, %rcx
movb %dl, (%r14,%rcx)
incl %ecx
incq %rax
cmpq %rax, %r15
jne 0x279b9
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %esi, %ebp
movq %rdi, %rbx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
incl %eax
cmpb $0x0, (%rbx,%rax)
jne 0x27a0f
cmpl %edx, %ebp
setg %cl
cmpl %ebp, %eax
setl %sil
orb %cl, %sil
je 0x27a2c
xorl %r14d, %r14d
jmp 0x27a73
leal -0x1(%rax), %r15d
cmpl %edx, %eax
cmovgl %edx, %r15d
movl %r15d, %eax
subl %ebp, %eax
addl $0x3, %eax
movslq %eax, %rdi
callq 0x2040
movq %rax, %r14
movb $0x0, (%rax)
subl %ebp, %r15d
jge 0x27a56
xorl %r15d, %r15d
jmp 0x27a6e
movslq %ebp, %rax
addq %rax, %rbx
leaq 0x1(%r15), %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2130
incl %r15d
movb $0x0, (%r14,%r15)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %eax
subl %esi, %eax
jl 0x27aa8
movl %edx, %ebx
movl %esi, %ebp
movq (%rdi), %r15
movl 0xc(%r15), %ecx
cmpl %esi, %ecx
setl %dl
cmpl %ebx, %ecx
setl %cl
orb %dl, %cl
je 0x27aad
xorl %r14d, %r14d
jmp 0x27adf
addl $0x3, %eax
movslq %eax, %rdi
callq 0x2230
movq %rax, %r14
movb $0x0, (%rax)
subl %ebp, %ebx
jge 0x27ac6
xorl %ebx, %ebx
jmp 0x27ada
movslq %ebp, %rsi
addq (%r15), %rsi
leaq 0x1(%rbx), %rdx
movq %r14, %rdi
callq 0x2130
incl %ebx
movb $0x0, (%r14,%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
incl %ecx
cmpb $0x0, (%rdi,%rcx)
jne 0x27af7
testl %ecx, %ecx
setle %al
jle 0x27b45
movl %ecx, %ecx
movq %rcx, %rdx
negq %rdx
movl $0x1, %esi
movabsq $0x100000600, %r8       # imm = 0x100000600
movzbl -0x1(%rdi,%rsi), %r9d
cmpq $0x20, %r9
ja 0x27b45
btq %r9, %r8
jae 0x27b45
cmpq %rcx, %rsi
setae %al
leaq (%rdx,%rsi), %r9
incq %r9
incq %rsi
cmpq $0x1, %r9
jne 0x27b1d
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r12d
movq %rdi, %r14
movl $0x8, %edi
callq 0x2180
movq %rax, %r15
movl $0x10, %edi
callq 0x2180
movq %rax, %r13
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movq %rax, (%r15)
movq $0x1f4, 0x8(%rax)       # imm = 0x1F4
movl $0x1f7, %edi            # imm = 0x1F7
callq 0x2040
movq %rax, (%r13)
movl $0x0, 0xc(%r13)
movb $0x0, (%rax)
cmpb %bpl, %r12b
jg 0x27c1e
movsbl %r12b, %r12d
movq %r15, %rdi
movl %r12d, %esi
callq 0x278c0
incb %r12b
jmp 0x27c05
movq (%r15), %rax
movq (%rax), %rsi
movsbl %bl, %edx
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x27c56
movq %rax, %rbx
movl $0x8, %esi
movq %r15, %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x2, %eax
leal -0x2(%rax), %ecx
incl %eax
cmpb $0x0, (%rbx,%rcx)
jne 0x27c6a
movslq %eax, %rdi
callq 0x2040
movq %rax, %r14
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
incl %eax
cmpb $0x0, (%rbx,%rax)
jne 0x27c85
cmpl $-0x2, %eax
jl 0x27ca2
addl $0x3, %eax
movslq %eax, %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x20f0
xorl %eax, %eax
movl $0x1, %ecx
xorl %edx, %edx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
incl %esi
cmpb $0x0, (%rbx,%rsi)
jne 0x27cb0
movslq %esi, %rsi
cmpq %rsi, %rax
jge 0x27d11
xorl %esi, %esi
xorl %edi, %edi
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
incl %r8d
cmpb $0x0, (%r15,%r8)
jne 0x27cca
movslq %r8d, %r8
cmpq %r8, %rsi
jge 0x27cf0
movb (%rbx,%rax), %r8b
cmpb (%r15,%rsi), %r8b
movzbl %dil, %edi
cmovel %ecx, %edi
incq %rsi
jmp 0x27cc4
testb $0x1, %dil
je 0x27cff
movl %ebp, %esi
testb %bpl, %bpl
jne 0x27d03
jmp 0x27d0c
movb (%rbx,%rax), %sil
movslq %edx, %rdx
movb %sil, (%r14,%rdx)
incl %edx
incq %rax
jmp 0x27cab
xorl %edx, %edx
movl %edx, %r15d
incl %edx
cmpb $0x0, (%r14,%r15)
jne 0x27d13
cmpl $0x1, %edx
adcl $0x0, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2130
movb $0x0, (%rbx,%r15)
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2220
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movl $0x18, %edi
callq 0x2180
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
testl %edx, %edx
jle 0x27dbc
xorl %r15d, %r15d
cmpq %r15, %rdx
jbe 0x27dc5
movq 0x8(%r14), %rsi
movq (%rax,%r15,8), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq %r14, %rdi
callq 0x29dec
incq %r15
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
movq %rcx, %rdx
sarq $0x3, %rdx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r15
jl 0x27d80
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x5b0a(%rip), %rdi      # 0x2d8d6
movq %r15, %rsi
xorl %eax, %eax
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x18, %edi
callq 0x2180
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq 0x8(%rbx), %r12
subq (%rbx), %r12
movq %r12, %r13
shrq $0x3, %r13
movq %r12, %rax
shlq $0x1d, %rax
movq %rax, %rcx
sarq $0x1e, %rcx
testq %rax, %rax
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x2040
movq %rax, %r15
testl %r13d, %r13d
jle 0x27e50
shrq %r12
movabsq $0x1fffffffc, %rdx      # imm = 0x1FFFFFFFC
andq %r12, %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x20f0
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
testl %edx, %edx
jle 0x27edc
xorl %r13d, %r13d
xorl %eax, %eax
cmpq %r13, %rdx
jbe 0x27efc
movslq (%r15,%r13,4), %rbp
movq (%rcx,%r13,8), %rdx
movq (%rdx), %rcx
movq 0x8(%rdx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpl %edx, %ebp
jge 0x27eba
cmpq %rbp, %rdx
jbe 0x27f08
leaq (%rcx,%rbp,8), %rdx
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x27eaa
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x27eb2
movq %r14, %rdi
callq 0x2a040
incl %ebp
movl %ebp, (%r15,%r13,4)
movb $0x1, %al
incq %r13
movq (%rbx), %rcx
movq 0x8(%rbx), %rsi
subq %rcx, %rsi
movq %rsi, %rdx
sarq $0x3, %rdx
shrq $0x3, %rsi
movslq %esi, %rsi
cmpq %rsi, %r13
jl 0x27e67
jmp 0x27ede
xorl %eax, %eax
testb $0x1, %al
cmoveq %r14, %r12
jne 0x27e50
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x59d3(%rip), %rdi      # 0x2d8d6
movq %r13, %rsi
jmp 0x27f12
leaq 0x59c7(%rip), %rdi      # 0x2d8d6
movq %rbp, %rsi
xorl %eax, %eax
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x18, %edi
callq 0x2180
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %r15d, %r15d
movq %r15, 0x10(%rax)
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
cltd
idivl %ebp
movl %eax, %ebp
movl $0x18, %edi
callq 0x2180
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r15, 0x10(%rax)
movq %rax, (%rsp)
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x27f80
movq %rax, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x27f8b
movq %rsp, %rdx
movq %r14, %rdi
callq 0x2a11c
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
testl %eax, %eax
jle 0x28048
xorl %r13d, %r13d
movq %rsp, %r12
xorl %r15d, %r15d
movq (%rsp), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shrq $0x3, %rcx
cmpl %ecx, %ebp
jne 0x27ff5
movl $0x18, %edi
callq 0x2180
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, (%rsp)
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x27fea
movq %rax, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x27ff5
movq %r14, %rdi
movq %r12, %rdx
callq 0x2a11c
movq (%rbx), %rdx
movq 0x8(%rbx), %rax
subq %rdx, %rax
sarq $0x3, %rax
cmpq %r15, %rax
jbe 0x2805a
movq (%rsp), %rdi
addq %r13, %rdx
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x28026
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x2802b
callq 0x2a040
incq %r15
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
cltq
addq $0x8, %r13
cmpq %rax, %r15
jl 0x27fa7
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5875(%rip), %rdi      # 0x2d8d6
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x18, %edi
callq 0x2180
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %r15d, %r15d
movq %r15, 0x10(%rax)
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
cltd
idivl %ebp
movl %eax, %ebp
movl $0x18, %edi
callq 0x2180
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r15, 0x10(%rax)
movq %rax, (%rsp)
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x280d4
movq %rax, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x280df
movq %rsp, %rdx
movq %r14, %rdi
callq 0x2a258
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
testl %eax, %eax
jle 0x2819c
xorl %r13d, %r13d
movq %rsp, %r12
xorl %r15d, %r15d
movq (%rsp), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shrq $0x3, %rcx
cmpl %ecx, %ebp
jne 0x28149
movl $0x18, %edi
callq 0x2180
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, (%rsp)
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x2813e
movq %rax, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x28149
movq %r14, %rdi
movq %r12, %rdx
callq 0x2a258
movq (%rbx), %rdx
movq 0x8(%rbx), %rax
subq %rdx, %rax
sarq $0x3, %rax
cmpq %r15, %rax
jbe 0x281ae
movq (%rsp), %rdi
addq %r13, %rdx
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x2817a
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x2817f
callq 0x12d32
incq %r15
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
cltq
addq $0x8, %r13
cmpq %rax, %r15
jl 0x280fb
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5721(%rip), %rdi      # 0x2d8d6
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2270