LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2644a
xorl %r14d, %r14d
cmpq %r14, %rdx
jbe 0x26562
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 0x26415
testq %rdi, %rdi
je 0x2645b
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 0x264b6
xorl %r14d, %r14d
cmpq %r14, %rdx
jbe 0x26562
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 0x26481
testq %rdi, %rdi
je 0x264c7
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 0x2651e
xorl %r14d, %r14d
cmpq %r14, %rdx
jbe 0x26562
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 0x264ed
testq %rdi, %rdi
je 0x2652f
movq 0x10(%r15), %rsi
subq %rdi, %rsi
callq 0x2190
movl $0x18, %esi
movq %r15, %rdi
callq 0x2190
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x26549
callq 0x21d0
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2655c
popq %rbx
popq %r14
popq %r15
jmp 0x21d0
popq %rbx
popq %r14
popq %r15
retq
leaq 0x6367(%rip), %rdi      # 0x2c8d0
movq %r14, %rsi
xorl %eax, %eax
callq 0x2270
movq %rax, %rdi
callq 0x2664f
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movb $0x0, (%rdx)
movq 0x10(%rdi), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
testl %edx, %edx
jle 0x265e1
movq %rsi, %r12
movq %rdi, %r15
xorl %ebx, %ebx
cmpq %rbx, %rdx
jbe 0x26614
movq (%rax,%rbx,8), %rdi
movq %r12, %rsi
callq 0x26d70
testb %al, %al
jne 0x265e9
incq %rbx
movq 0x10(%r15), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rcx
subq %rax, %rcx
movq %rcx, %rdx
sarq $0x3, %rdx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %rbx
jl 0x265a8
movb $0x0, (%r14)
xorl %eax, %eax
jmp 0x26608
movb $0x1, (%r14)
movq 0x18(%r15), %rcx
movq (%rcx), %rax
movq 0x8(%rcx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rbx, %rdx
jbe 0x26614
movq (%rax,%rbx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x62b5(%rip), %rdi      # 0x2c8d0
movq %rbx, %rsi
xorl %eax, %eax
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O3/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)
movl $0x1f4, 0x8(%rax)       # imm = 0x1F4
movl $0x1f7, %edi            # imm = 0x1F7
callq 0x2040
movq %rax, (%r15)
movb (%rbx), %al
testb %al, %al
je 0x266ae
incq %rbx
movsbl %al, %esi
movq %r14, %rdi
callq 0x2724c
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x2669a
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %ecx       # imm = 0xFFFFFFFF
incl %ecx
cmpb $0x0, (%rdi,%rcx)
jne 0x267e7
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
incl %edx
cmpb $0x0, (%rsi,%rdx)
jne 0x267f4
movb $0x1, %al
cmpl %edx, %ecx
jl 0x26852
setg %dl
testl %ecx, %ecx
setle %r8b
orb %dl, %r8b
jne 0x26848
movb (%rdi), %dl
movb (%rsi), %r8b
cmpb %r8b, %dl
jl 0x26852
movl %ecx, %ecx
movb $0x1, %al
movl $0x1, %r9d
cmpb %r8b, %dl
jg 0x2684c
cmpq %rcx, %r9
setb %al
cmpq %r9, %rcx
je 0x26850
movb (%rdi,%r9), %dl
movb (%rsi,%r9), %r8b
incq %r9
cmpb %r8b, %dl
jge 0x26824
movb $0x1, %cl
jmp 0x26850
xorl %eax, %eax
jmp 0x26852
xorl %ecx, %ecx
jmp 0x26850
andb %cl, %al
andb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x26d72
leal -0x1(%rax), %ecx
xorl %edx, %edx
movl %edx, %r8d
incl %edx
cmpb $0x0, (%rsi,%r8)
jne 0x26d81
cmpl %edx, %eax
jne 0x26dad
testl %ecx, %ecx
jle 0x26db0
movl %ecx, %eax
xorl %ecx, %ecx
movb (%rdi,%rcx), %dl
cmpb (%rsi,%rcx), %dl
jne 0x26dad
incq %rcx
cmpq %rcx, %rax
jne 0x26d99
setbe %al
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x26e02
movq %rdi, %rbx
movl $0x1, %eax
leal -0x1(%rax), %ecx
incl %eax
cmpb $0x0, (%rbx,%rcx)
jne 0x26dc6
movslq %eax, %rdi
callq 0x2040
movq %rax, %r14
xorl %edx, %edx
movl %edx, %r15d
incl %edx
cmpb $0x0, (%rbx,%r15)
jne 0x26dde
cmpl $0x1, %edx
adcl $0x0, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2130
movb $0x0, (%r14,%r15)
jmp 0x26e05
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x26e10
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 0x26e26
movb $0x0, (%rdi,%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x26ed0
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
shrq $0x3, %rcx
cmpl %ecx, %eax
jne 0x26e9f
movq %r14, %rdi
callq 0x26db4
movq %rax, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x26e7a
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x26e85
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x12a12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x26ed0
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
shrq $0x3, %rcx
cmpl %ecx, %eax
je 0x26ea7
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x12132(%rip), %rax     # 0x38fe0
movq (%rax), %rdi
leaq 0x7ae4(%rip), %rsi      # 0x2e99c
movq %r14, %rdx
xorl %eax, %eax
callq 0x2250
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
jmp 0x26e9f
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %r15
movq 0x8(%rdi), %rbx
subq %r15, %rbx
sarq $0x3, %rbx
testl %ebx, %ebx
jle 0x26f1d
movq %rsi, %r14
movl %ebx, %r12d
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x26f29
movq (%r15,%r13,8), %rdi
movq %r14, %rsi
callq 0x26d70
testb %al, %al
jne 0x26f1a
incq %r13
cmpq %r13, %r12
jne 0x26efb
jmp 0x26f1d
movl %r13d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x59a0(%rip), %rdi      # 0x2c8d0
movq %rbx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %r15
movq 0x8(%rdi), %rbx
subq %r15, %rbx
sarq $0x3, %rbx
testl %ebx, %ebx
jle 0x26f91
movq %rsi, %r14
movl %ebx, %r12d
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x26f9d
movq (%r15,%r13,8), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq %r14, %rsi
callq 0x26d70
testb %al, %al
jne 0x26f8e
incq %r13
cmpq %r13, %r12
jne 0x26f69
jmp 0x26f91
movl %r13d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x592c(%rip), %rdi      # 0x2c8d0
movq %rbx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %r15
movq 0x8(%rdi), %rbx
subq %r15, %rbx
sarq $0x3, %rbx
testl %ebx, %ebx
jle 0x27007
movq %rsi, %r14
movl %ebx, %r12d
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x27013
movq (%r15,%r13,8), %rdi
movq %r14, %rsi
callq 0x27028
testb %al, %al
jne 0x27004
incq %r13
cmpq %r13, %r12
jne 0x26fe5
jmp 0x27007
movl %r13d, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x58b6(%rip), %rdi      # 0x2c8d0
movq %rbx, %rsi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x27038
leal -0x1(%rax), %ecx
xorl %edx, %edx
movl %edx, %esi
incl %edx
cmpb $0x0, (%rbx,%rsi)
jne 0x27048
cmpl %edx, %eax
jne 0x27087
testl %ecx, %ecx
jle 0x2708b
movl %ecx, %r15d
xorl %r12d, %r12d
movsbl (%r14,%r12), %edi
callq 0x2330
movl %eax, %ebp
movsbl (%rbx,%r12), %edi
callq 0x2330
cmpl %eax, %ebp
jne 0x27087
incq %r12
cmpq %r12, %r15
jne 0x27060
setbe %al
jmp 0x2708d
xorl %eax, %eax
jmp 0x2708d
movb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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)
movl $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 0x271fb
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 0x2715e
movsbl %al, %esi
movq %r14, %rdi
callq 0x2724c
jmp 0x271a9
movq (%r14), %rax
cmpl $0x0, 0xc(%rax)
jle 0x271a9
movq (%rax), %rdi
movl $0xa, %esi
callq 0x29118
movl %eax, 0x4(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2718e
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x27199
movq %rbx, %rdi
movq %r12, %rdx
callq 0xabfa
movq (%r14), %rax
movl $0x0, 0xc(%rax)
movq (%rax), %rax
movb $0x0, (%rax)
incq %rbp
cmpq %rbp, %r13
jne 0x27140
movq (%r14), %rax
cmpl $0x0, 0xc(%rax)
jle 0x271fb
movq (%rax), %rdi
movl $0xa, %esi
callq 0x29118
movl %eax, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x271e0
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x271eb
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xabfa
movq (%r14), %rax
movl $0x0, 0xc(%rax)
movq (%rax), %rax
movb $0x0, (%rax)
movq %r14, %rdi
callq 0x27096
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
// File: /workspace/github_cpp_makefile_star2_O3/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 0x272c3
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 0x272ae
xorl %ebp, %ebp
movsbl (%r14,%rbp), %esi
movq %rbx, %rdi
callq 0x2724c
incq %rbp
cmpq %rbp, %r12
jne 0x27297
jmp 0x272b3
testq %r14, %r14
je 0x272bb
movq %r14, %rdi
callq 0x2220
movq (%rbx), %rbp
movl 0x8(%rbp), %eax
jmp 0x2726f
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_O3/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, %r15d      # imm = 0xFFFFFFFF
incl %r15d
cmpb $0x0, (%rbx,%r15)
jne 0x2730f
leal 0x2(%r15), %eax
movslq %eax, %rdi
callq 0x2040
movq %rax, %r14
testl %r15d, %r15d
jle 0x27370
xorl %r12d, %r12d
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x20f0
movl %r15d, %eax
xorl %ecx, %ecx
movb (%rbx,%r12), %dl
leal -0x30(%rdx), %esi
cmpb $0xa, %sil
jb 0x2735f
movl %edx, %esi
andb $-0x21, %sil
addb $-0x41, %sil
cmpb $0x19, %sil
ja 0x27368
movslq %ecx, %rcx
movb %dl, (%r14,%rcx)
incl %ecx
incq %r12
cmpq %r12, %rax
jne 0x27342
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x27399
cmpl %edx, %ebp
setg %cl
cmpl %ebp, %eax
setl %sil
orb %cl, %sil
je 0x273b6
xorl %r14d, %r14d
jmp 0x27401
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 0x273df
xorl %eax, %eax
jmp 0x273fc
movslq %ebp, %rax
addq %rax, %rbx
movl %r15d, %r15d
incq %r15
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2130
movl %r15d, %eax
movb $0x0, (%r14,%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
movl %edx, %ebx
subl %esi, %ebx
jl 0x27427
movq (%rdi), %r15
cmpl %edx, 0xc(%r15)
jge 0x2742c
xorl %r14d, %r14d
jmp 0x2745c
movl %esi, %ebp
leal 0x3(%rbx), %eax
movslq %eax, %rdi
callq 0x2230
movq %rax, %r14
xorl %r12d, %r12d
movb %r12b, (%rax)
movslq %ebp, %rsi
addq (%r15), %rsi
incq %rbx
movq %rax, %rdi
movq %rbx, %rdx
callq 0x2130
movl %ebx, %eax
movb %r12b, (%r14,%rax)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, %eax       # imm = 0xFFFFFFFF
incl %eax
cmpb $0x0, (%rdi,%rax)
jne 0x27471
testl %eax, %eax
jle 0x274c0
movl %eax, %ecx
movq %rcx, %rdx
negq %rdx
movl $0x1, %esi
xorl %eax, %eax
movabsq $0x100000600, %r8       # imm = 0x100000600
movzbl -0x1(%rdi,%rsi), %r9d
cmpq $0x20, %r9
ja 0x274c2
btq %r9, %r8
jae 0x274c2
cmpq %rcx, %rsi
setae %al
leaq (%rdx,%rsi), %r9
incq %r9
incq %rsi
cmpq $0x1, %r9
jne 0x27496
jmp 0x274c2
movb $0x1, %al
andb $0x1, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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)
movl $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 0x275a6
movsbl %r12b, %r12d
movq %r15, %rdi
movl %r12d, %esi
callq 0x2724c
incb %r12b
cmpb %bpl, %r12b
jle 0x2758b
movq (%r13), %rax
movsbl %bl, %edx
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x275da
movq %rax, %rbx
movl $0x8, %esi
movq %r15, %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x275ee
movslq %eax, %rdi
callq 0x2040
movq %rax, %r14
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
incl %edx
cmpb $0x0, (%rbx,%rdx)
jne 0x27609
cmpl $-0x2, %edx
jl 0x27623
addl $0x3, %edx
movq %r14, %rdi
xorl %esi, %esi
callq 0x20f0
xorl %eax, %eax
xorl %ecx, %ecx
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
incl %edx
cmpb $0x0, (%rbx,%rdx)
jne 0x2762c
movslq %edx, %rdx
cmpq %rdx, %rax
jge 0x2768a
xorl %edx, %edx
xorl %esi, %esi
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
incl %edi
cmpb $0x0, (%r15,%rdi)
jne 0x27645
movslq %edi, %rdi
cmpq %rdi, %rdx
jge 0x2766a
movb (%rbx,%rax), %dil
cmpb (%r15,%rdx), %dil
sete %dil
orb %dil, %sil
incq %rdx
jmp 0x27640
testb $0x1, %sil
je 0x27679
movl %ebp, %edx
testb %bpl, %bpl
jne 0x2767c
jmp 0x27685
movb (%rbx,%rax), %dl
movslq %ecx, %rcx
movb %dl, (%r14,%rcx)
incl %ecx
incq %rax
jmp 0x27627
xorl %edx, %edx
movl %edx, %r15d
incl %edx
cmpb $0x0, (%r14,%r15)
jne 0x2768c
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
// File: /workspace/github_cpp_makefile_star2_O3/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 0x27734
xorl %r15d, %r15d
cmpq %r15, %rdx
jbe 0x2773d
movq 0x8(%r14), %rsi
movq (%rax,%r15,8), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rcx
movq %r14, %rdi
callq 0x296b8
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 0x276f8
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x518c(%rip), %rdi      # 0x2c8d0
movq %r15, %rsi
xorl %eax, %eax
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/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 (%rbx), %rbp
movq %rbx, (%rsp)
movq 0x8(%rbx), %rbx
movq %rbx, %r12
subq %rbp, %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 0x277d2
shrq %r12
movabsq $0x1fffffffc, %rdx      # imm = 0x1FFFFFFFC
andq %r12, %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x20f0
movq (%rsp), %rdi
movq %rbx, %rdx
subq %rbp, %rdx
sarq $0x3, %rdx
testl %edx, %edx
jle 0x27872
xorl %r12d, %r12d
xorl %eax, %eax
cmpq %r12, %rdx
jbe 0x27884
movslq (%r15,%r12,4), %r13
movq (%rbp,%r12,8), %rdx
movq (%rdx), %rcx
movq 0x8(%rdx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpl %edx, %r13d
jge 0x2784e
cmpq %r13, %rdx
jbe 0x27890
leaq (%rcx,%r13,8), %rdx
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x27832
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x2783e
movq %r14, %rdi
callq 0x298d4
movq (%rsp), %rdi
incl %r13d
movl %r13d, (%r15,%r12,4)
movq (%rdi), %rbp
movq 0x8(%rdi), %rbx
movb $0x1, %al
incq %r12
movq %rbx, %rcx
subq %rbp, %rcx
movq %rcx, %rdx
sarq $0x3, %rdx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r12
jl 0x277ed
testb $0x1, %al
jne 0x277d6
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5045(%rip), %rdi      # 0x2c8d0
movq %r12, %rsi
jmp 0x2789a
leaq 0x5039(%rip), %rdi      # 0x2c8d0
movq %r13, %rsi
xorl %eax, %eax
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rsp, %rdx
movq %rax, (%rdx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x299b0
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
testl %eax, %eax
jle 0x279bd
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 0x2796a
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 0x2795f
movq %rax, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x2796a
movq %r14, %rdi
movq %r12, %rdx
callq 0x299b0
movq (%rbx), %rdx
movq 0x8(%rbx), %rax
subq %rdx, %rax
sarq $0x3, %rax
cmpq %r15, %rax
jbe 0x279cf
movq (%rsp), %rdi
addq %r13, %rdx
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x2799b
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x279a0
callq 0x298d4
incq %r15
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
cltq
addq $0x8, %r13
cmpq %rax, %r15
jl 0x2791c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4efa(%rip), %rdi      # 0x2c8d0
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rsp, %rdx
movq %rax, (%rdx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x29aec
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
testl %eax, %eax
jle 0x27aff
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 0x27aac
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 0x27aa1
movq %rax, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x27aac
movq %r14, %rdi
movq %r12, %rdx
callq 0x29aec
movq (%rbx), %rdx
movq 0x8(%rbx), %rax
subq %rdx, %rax
sarq $0x3, %rax
cmpq %r15, %rax
jbe 0x27b11
movq (%rsp), %rdi
addq %r13, %rdx
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x27add
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x27ae2
callq 0x12a12
incq %r15
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
cltq
addq $0x8, %r13
cmpq %rax, %r15
jl 0x27a5e
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4db8(%rip), %rdi      # 0x2c8d0
movq %r15, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
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 $0x2, %rax
cltd
idivl %ebp
movl %eax, %ebp
movl $0x18, %edi
callq 0x2180
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r15, 0x10(%rax)
movq %rsp, %rdx
movq %rax, (%rdx)
movq %r14, %rdi
xorl %esi, %esi
callq 0x29c28
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x2, %rax
testl %eax, %eax
jle 0x27c47
xorl %r13d, %r13d
movq %rsp, %r12
xorl %r15d, %r15d
movq (%rsp), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
shrq $0x2, %rcx
cmpl %ecx, %ebp
jne 0x27bee
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 0x27be3
movq %rax, (%rsi)
addq $0x8, 0x8(%r14)
jmp 0x27bee
movq %r14, %rdi
movq %r12, %rdx
callq 0x29c28
movq (%rbx), %rax
movq 0x8(%rbx), %rdx
subq %rax, %rdx
sarq $0x2, %rdx
cmpq %r15, %rdx
jbe 0x27c59
movq (%rsp), %rdi
leaq (%rax,%r13), %rdx
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x27c21
movl (%rdx), %ecx
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x27c29
callq 0xabfa
movq (%rbx), %rax
incq %r15
movq 0x8(%rbx), %rcx
subq %rax, %rcx
shrq $0x2, %rcx
movslq %ecx, %rax
addq $0x4, %r13
cmpq %rax, %r15
jl 0x27ba0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4c70(%rip), %rdi      # 0x2c8d0
movq %r15, %rsi
xorl %eax, %eax
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/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 0x27d1e
movq %rdi, %r14
movl $0x18, %edi
callq 0x2180
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
testl %edx, %edx
jle 0x27d20
xorl %r15d, %r15d
movq %rsp, %r12
cmpq %r15, %rdx
jbe 0x27d2f
movq (%rax,%r15,8), %rsi
movq %rbx, %rdi
callq 0x26ed0
movq 0x8(%rbx), %rcx
subq (%rbx), %rcx
shrq $0x3, %rcx
cmpl %ecx, %eax
jne 0x27cfc
movq (%r14), %rax
movq 0x8(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r15, %rdx
jbe 0x27d2f
movq (%rax,%r15,8), %rdi
callq 0x26db4
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb27c
incq %r15
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
movq %rcx, %rdx
sarq $0x3, %rdx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r15
jl 0x27cb1
jmp 0x27d20
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4b9a(%rip), %rdi      # 0x2c8d0
movq %r15, %rsi
xorl %eax, %eax
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/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
movq (%rdi), %rdi
movq 0x8(%rbx), %rcx
movq %rcx, %rdx
subq %rdi, %rdx
sarq $0x3, %rdx
testl %edx, %edx
jle 0x285f1
xorl %r14d, %r14d
cmpq %r14, %rdx
jbe 0x2861f
movq (%rdi,%r14,8), %rax
testq %rax, %rax
je 0x285d6
movq %rax, %rdi
callq 0x2220
movq (%rbx), %rdi
movq 0x8(%rbx), %rcx
incq %r14
movq %rcx, %rax
subq %rdi, %rax
movq %rax, %rdx
sarq $0x3, %rdx
shrq $0x3, %rax
cltq
cmpq %rax, %r14
jl 0x285b9
cmpq %rdi, %rcx
je 0x285fa
movq %rdi, 0x8(%rbx)
testq %rdi, %rdi
je 0x2860b
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2190
movl $0x18, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2190
leaq 0x42aa(%rip), %rdi      # 0x2c8d0
movq %r14, %rsi
xorl %eax, %eax
callq 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rax
movq %rax, %rdx
subq %rdi, %rdx
sarq $0x3, %rdx
testl %edx, %edx
jle 0x28696
xorl %r14d, %r14d
cmpq %r14, %rdx
jbe 0x286c2
movq (%rdi,%r14,8), %r15
testq %r15, %r15
je 0x28666
movq %r15, %rdi
callq 0x27096
movl $0x8, %esi
movq %r15, %rdi
callq 0x2190
incq %r14
movq (%rbx), %rdi
movq 0x8(%rbx), %rax
movq %rax, %rcx
subq %rdi, %rcx
movq %rcx, %rdx
sarq $0x3, %rdx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r14
jl 0x28650
cmpq %rdi, %rax
je 0x2869f
movq %rdi, 0x8(%rbx)
testq %rdi, %rdi
je 0x286b0
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x2190
movl $0x18, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2190
leaq 0x4207(%rip), %rdi      # 0x2c8d0
movq %r14, %rsi
xorl %eax, %eax
callq 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
incl %eax
cmpb $0x0, (%rbx,%rax)
jne 0x286e4
xorl %r14d, %r14d
testl %eax, %eax
jle 0x28707
movl %eax, %ecx
xorl %r12d, %r12d
cmpb $0x20, (%rbx,%r12)
jne 0x2870a
incq %r12
cmpq %r12, %rcx
jne 0x286f8
xorl %r12d, %r12d
addl $0x2, %eax
movslq %eax, %rdi
callq 0x2040
movq %rax, %r15
addq %r12, %rbx
movl %r14d, %r12d
incl %r14d
cmpb $0x0, (%rbx,%r12)
jne 0x2871b
cmpl $0x1, %r14d
adcl $0x0, %r14d
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2130
movb $0x0, (%r15,%r12)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
movq (%rdi), %rcx
movslq 0xc(%rcx), %rax
xorl %r14d, %r14d
movq (%rcx), %rbx
testq %rax, %rax
jle 0x2877f
xorl %r12d, %r12d
cmpb $0x20, (%rbx,%r12)
jne 0x28782
incq %r12
cmpq %r12, %rax
jne 0x28770
xorl %r12d, %r12d
leaq 0x10(,%rax,8), %rdi
callq 0x2230
movq %rax, %r15
movl %r14d, %r13d
incl %r14d
cmpb $0x0, (%rbx,%r13)
jne 0x28792
cmpl $0x1, %r14d
adcl $0x0, %r14d
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2130
movb $0x0, (%r15,%r13)
movq %r15, %rsi
addq %r12, %rsi
xorl %edx, %edx
movl %edx, %r14d
incl %edx
cmpb $0x0, (%rsi,%r14)
jne 0x287c2
cmpl $0x1, %edx
adcl $0x0, %edx
movq %rbx, %rdi
callq 0x2130
movb $0x0, (%rbx,%r14)
movq %r15, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x21d0
// File: /workspace/github_cpp_makefile_star2_O3/gersteinlab[P]MUSIC/src/ms_ansi_string.cpp
// Function: t_string::concat_string(char*)
void t_string::concat_string(char* string)
{
	//// Add all the chars in the string.
	//int str_len = string_length(string);
	
	//fprintf(stderr, "Concatting: %s\n", string);
	int i = 0;
	while(string[i] != 0)
	{
		this->concat_char(string[i]);
		i++;
	}
}

// Assembly:
movb (%rsi), %al
testb %al, %al
je 0x28c34
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
incq %rbx
movsbl %al, %esi
movq %r14, %rdi
callq 0x2724c
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x28c19
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop