LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::typeString[abi:cxx11](int)
string codeGenerator::typeString( int type ){
	switch( type ){
		case TYPE_CHAR: 
			return "char";
		case TYPE_INTEGER:
			return "int";
		case TYPE_FLOAT:
			return"float";
		case TYPE_BOOL:
			return "int";
		case TYPE_STRING: 
			return "char*";
		default: 
			return "ERROR:";
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
addl $0xfffffef6, %edx       # imm = 0xFFFFFEF6
cmpl $0x4, %edx
ja 0x11a9c
leaq 0x8f3d(%rip), %rax      # 0x1a990
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x92f9(%rip), %rsi      # 0x1ad5c
leaq 0x92f5(%rip), %rdx      # 0x1ad5f
jmp 0x11aaa
leaq 0x92e4(%rip), %rsi      # 0x1ad57
leaq 0x92e1(%rip), %rdx      # 0x1ad5b
jmp 0x11aaa
leaq 0x92dd(%rip), %rsi      # 0x1ad60
leaq 0x92db(%rip), %rdx      # 0x1ad65
jmp 0x11aaa
leaq 0x92d3(%rip), %rsi      # 0x1ad66
leaq 0x92d1(%rip), %rdx      # 0x1ad6b
jmp 0x11aaa
leaq 0x92c9(%rip), %rsi      # 0x1ad6c
leaq 0x92c8(%rip), %rdx      # 0x1ad72
movq %rbx, %rdi
callq 0x3c34
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::pushStack(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char, int)
void codeGenerator::pushStack( string value, char stackID, int type ){
	if( !ShouldGenerate() ) return;
	switch( stackID ){
		case 'L':
			leftStack.push( value );
			break;
		case 'E':
			exprStack.push( value );
			if( type == TYPE_FLOAT ) freg_in_use++;
			else ireg_in_use++;
			break;
		case 'R':
			rightStack.push( value );
			break;
		default:
			cout << "Not a valid expression stack!\n";
			break;
	}
	return;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpb $0x1, 0x330(%rdi)
jne 0x11b39
movq %rdi, %rbx
movsbl %dl, %eax
cmpl $0x45, %eax
je 0x11af7
cmpl $0x52, %eax
je 0x11ae2
cmpl $0x4c, %eax
jne 0x11b15
addq $0x1d0, %rbx            # imm = 0x1D0
jmp 0x11ae9
addq $0x180, %rbx            # imm = 0x180
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x176d0
movl %ecx, %ebp
leaq 0x130(%rbx), %rdi
callq 0x176d0
cmpl $0x10b, %ebp            # imm = 0x10B
jne 0x11b33
incl 0x124(%rbx)
jmp 0x11b39
movq 0x104bc(%rip), %rdi     # 0x21fd8
leaq 0x9250(%rip), %rsi      # 0x1ad73
movl $0x1e, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2230
incl 0x120(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::AddStringHeap(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int codeGenerator::AddStringHeap( string str ){
	if( !ShouldGenerate() ) return -1;
	HeapSize += ( str.size() + 1);
	stringEntry.MMlocation = HeapSize;
	stringEntry.contents = str;
	string_heap.push(stringEntry);
	return HeapSize;
}

// Assembly:
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x1, 0x330(%rdi)
jne 0x13799
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rsi), %eax
movl 0x220(%rdi), %ecx
leal 0x1(%rax,%rcx), %eax
movl %eax, 0x220(%rdi)
leaq 0x228(%rdi), %r14
movl %eax, 0x228(%rdi)
addq $0x230, %rdi            # imm = 0x230
callq 0x2120
leaq 0x250(%rbx), %rdi
movq %r14, %rsi
callq 0x178aa
movl 0x220(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::NegateTopRegisters(int, int)
void codeGenerator::NegateTopRegisters( int type, int size ){
	if( !ShouldGenerate() ) return;
	string reg;
	int i;
	// Ensure size is at least 1 for loops
	if( size == 0 ) size++;
	
	for( i = 0; i < size; i++ ){
		reg = popStack('E', type);
		pushStack( reg, 'L', type );
	}
	for( i = 0; i < size; i++ ){
		reg = popStack('L', type);
		pushStack( reg, 'E', type );
		fprintf( oFile, "   %s = -%s;\n", reg.c_str(), reg.c_str() );
	}
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
cmpb $0x1, 0x330(%rdi)
jne 0x13989
movl %edx, %r13d
movl %esi, %ebp
movq %rdi, %r14
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
cmpl $0x1, %edx
adcl $0x0, %r13d
testl %r13d, %r13d
jle 0x1388a
leaq 0x38(%rsp), %r15
leaq 0x1d0(%r14), %rax
movq %rax, (%rsp)
leaq 0x48(%rsp), %r12
movl %r13d, %ebx
movq %r12, %rdi
movq %r14, %rsi
movl $0x45, %edx
movl %ebp, %ecx
callq 0x11b40
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x2270
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x13837
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2200
movq %r15, 0x28(%rsp)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x3ba4
cmpb $0x1, 0x330(%r14)
jne 0x1386b
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x176d0
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x13882
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
decl %ebx
jne 0x137fc
testl %r13d, %r13d
jle 0x1396d
leaq 0x78(%rsp), %r15
leaq 0x130(%r14), %rax
movq %rax, (%rsp)
leaq 0x48(%rsp), %r12
leaq 0x68(%rsp), %rbx
movq %r12, %rdi
movq %r14, %rsi
movl $0x4c, %edx
movl %ebp, %ecx
callq 0x11b40
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x2270
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x138e8
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2200
movq %r15, 0x68(%rsp)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3ba4
cmpb $0x1, 0x330(%r14)
jne 0x13930
movq (%rsp), %rdi
movq %rbx, %rsi
callq 0x176d0
cmpl $0x10b, %ebp            # imm = 0x10B
jne 0x13929
incl 0x124(%r14)
jmp 0x13930
incl 0x120(%r14)
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0x13947
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x308(%r14), %rdi
movq 0x8(%rsp), %rcx
leaq 0x7592(%rip), %rsi      # 0x1aeec
movq %rcx, %rdx
xorl %eax, %eax
callq 0x22a0
decl %r13d
jne 0x138ad
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x13989
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r15, %rdi
je 0x139d4
movq 0x78(%rsp), %rsi
jmp 0x139c1
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x139d4
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0x139d4
jmp 0x139d1
jmp 0x139d1
jmp 0x139d1
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x139f0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::setProcedurePointers(int)
void codeGenerator::setProcedurePointers( int frameSize ){
	if( !ShouldGenerate() ) return;
	comment( "Set FP and SP using the caller's FP/SP values and the new frame size" );
	fprintf( oFile, "   FP_reg = SP_reg;\n" );
	fprintf( oFile, "   SP_reg = FP_reg + %d;\n", frameSize);
	return;
}

// Assembly:
cmpb $0x1, 0x330(%rdi)
jne 0x16174
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x4ee9(%rip), %rsi      # 0x1afdd
leaq 0x4f26(%rip), %rdx      # 0x1b021
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3c34
movq 0x308(%r14), %rdi
movq (%r15), %rdx
leaq 0x4906(%rip), %rsi      # 0x1aa1f
xorl %eax, %eax
callq 0x22a0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x16135
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x308(%r14), %rcx
leaq 0x4edf(%rip), %rdi      # 0x1b022
movl $0x14, %esi
movl $0x1, %edx
callq 0x2390
movq 0x308(%r14), %rdi
leaq 0x4ed7(%rip), %rsi      # 0x1b037
movl %ebx, %edx
xorl %eax, %eax
callq 0x22a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::callProcedure(scopeValue, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void codeGenerator::callProcedure( scopeValue procValue, string id ){
	if( !ShouldGenerate() ) return;
	
	comment( "Call procedure" );
	fprintf( oFile, "   MM[SP_reg] = FP_reg;\n" );
	fprintf( oFile, "   MM[SP_reg + 1] = %d;\n", call_count );
	fprintf( oFile, "   goto %s;\n", procValue.CallLabel.c_str() );
	
	string retLabel = newReturnLabel(id);
	placeLabel( retLabel );
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
cmpb $0x1, 0x330(%rdi)
jne 0x162f9
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x70(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x4ea5(%rip), %rsi      # 0x1b051
leaq 0x4eac(%rip), %rdx      # 0x1b05f
leaq 0x60(%rsp), %r12
movq %r12, %rdi
callq 0x3c34
movq 0x308(%rbx), %rdi
movq (%r12), %rdx
leaq 0x484d(%rip), %rsi      # 0x1aa1f
xorl %eax, %eax
callq 0x22a0
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x161ef
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x308(%rbx), %rcx
leaq 0x4e63(%rip), %rdi      # 0x1b060
movl $0x18, %esi
movl $0x1, %edx
callq 0x2390
movq 0x308(%rbx), %rdi
movl 0xe8(%rbx), %edx
leaq 0x4e59(%rip), %rsi      # 0x1b079
xorl %eax, %eax
callq 0x22a0
movq 0x308(%rbx), %rdi
movq 0x20(%r15), %rdx
leaq 0x4e59(%rip), %rsi      # 0x1b092
xorl %eax, %eax
callq 0x22a0
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x3ba4
movq %rsp, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x16338
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x16285
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x2200
leaq 0x30(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x3ba4
cmpb $0x1, 0x330(%rbx)
jne 0x162c7
movq 0x308(%rbx), %rdi
movq 0x20(%rsp), %rdx
leaq 0x4d17(%rip), %rsi      # 0x1afd7
xorl %eax, %eax
callq 0x22a0
movq 0x20(%rsp), %rdi
cmpq %r14, %rdi
je 0x162de
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2200
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x162f9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2200
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq -0x10(%r15), %rdi
jmp 0x16320
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x16330
movq (%r15), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::ProcedureReturn()
void codeGenerator::ProcedureReturn(){
	if( !ShouldGenerate() ) return;
	comment( "Procedure return" );
	fprintf( oFile, "   TP_reg = MM[FP_reg + 1];\n" );
	fprintf( oFile, "   FP_reg = MM[FP_reg];\n" );
	fprintf( oFile, "   goto BRANCH_TABLE;\n" );
	return;
}

// Assembly:
cmpb $0x1, 0x330(%rdi)
jne 0x166b2
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x4a8c(%rip), %rsi      # 0x1b09f
leaq 0x4a95(%rip), %rdx      # 0x1b0af
movq %rsp, %r14
movq %r14, %rdi
callq 0x3c34
movq 0x308(%rbx), %rdi
movq (%r14), %rdx
leaq 0x43e9(%rip), %rsi      # 0x1aa1f
xorl %eax, %eax
callq 0x22a0
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x16652
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x308(%rbx), %rcx
leaq 0x4a50(%rip), %rdi      # 0x1b0b0
movl $0x1c, %esi
movl $0x1, %edx
callq 0x2390
movq 0x308(%rbx), %rcx
leaq 0x4a50(%rip), %rdi      # 0x1b0cd
movl $0x18, %esi
movl $0x1, %edx
callq 0x2390
movq 0x308(%rbx), %rcx
leaq 0x4a4c(%rip), %rdi      # 0x1b0e6
movl $0x16, %esi
movl $0x1, %edx
callq 0x2390
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::condBranch(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void codeGenerator::condBranch( string labelTrue, string labelFalse ){
	if( !ShouldGenerate() ) return;
	string cond = popStack('E', TYPE_BOOL);
	comment("Conditional branch");
	// goto true condition
	fprintf( oFile, "   if( %s ) goto %s;\n", cond.c_str(), labelTrue.c_str() );
	// goto else condition if one exists
	if( labelFalse.compare("") != 0 ) fprintf( oFile, "   goto %s;\n", labelFalse.c_str() );
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpb $0x1, 0x330(%rdi)
jne 0x167c4
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movl $0x45, %edx
movl $0x10c, %ecx            # imm = 0x10C
callq 0x11b40
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x49de(%rip), %rsi      # 0x1b0fd
leaq 0x49e9(%rip), %rdx      # 0x1b10f
leaq 0x28(%rsp), %rdi
callq 0x3c34
movq 0x308(%r14), %rdi
movq 0x28(%rsp), %rdx
leaq 0x42dc(%rip), %rsi      # 0x1aa1f
xorl %eax, %eax
callq 0x22a0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x16761
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x308(%r14), %rdi
movq 0x8(%rsp), %rdx
movq (%r15), %rcx
leaq 0x4999(%rip), %rsi      # 0x1b110
xorl %eax, %eax
callq 0x22a0
leaq 0x41d8(%rip), %rsi      # 0x1a95d
movq %rbx, %rdi
callq 0x20a0
testl %eax, %eax
je 0x167a9
movq 0x308(%r14), %rdi
movq (%rbx), %rdx
leaq 0x48f0(%rip), %rsi      # 0x1b092
xorl %eax, %eax
callq 0x22a0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x167c4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x167ee
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::branch(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void codeGenerator::branch( string label ){
	if( !ShouldGenerate() ) return;
	comment("Unconditional branch");
	fprintf( oFile, "   goto %s;\n", label.c_str() );
	return;
}

// Assembly:
cmpb $0x1, 0x330(%rdi)
jne 0x16889
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x4901(%rip), %rsi      # 0x1b126
leaq 0x490e(%rip), %rdx      # 0x1b13a
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3c34
movq 0x308(%r14), %rdi
movq (%r15), %rdx
leaq 0x41d5(%rip), %rsi      # 0x1aa1f
xorl %eax, %eax
callq 0x22a0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x16866
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x308(%r14), %rdi
movq (%rbx), %rdx
leaq 0x481b(%rip), %rsi      # 0x1b092
xorl %eax, %eax
callq 0x22a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::setArgument(scopeValue, bool, int, bool)
void codeGenerator::setArgument( scopeValue value, bool isGlobal, int index, bool indirect ){
	if( !ShouldGenerate() ) return;
	savedArgument.paramType = value.paramType;
	savedArgument.type = value.type;
	savedArgument.size = value.size;
	savedArgument.index = index;
	savedArgument.indirect = indirect;
	savedArgument.offset = value.FPoffset;
	savedArgument.isGlobal = isGlobal;
	savedArgument.set = true;
	return;
}

// Assembly:
cmpb $0x1, 0x330(%rdi)
jne 0x168f4
movl 0x40(%rsi), %eax
movl %eax, 0x2a0(%rdi)
movl (%rsi), %eax
movl %eax, 0x2a4(%rdi)
movl 0x4(%rsi), %eax
movl %eax, 0x2a8(%rdi)
movl %ecx, 0x2ac(%rdi)
movb %r8b, 0x2b4(%rdi)
movl 0x44(%rsi), %eax
movl %eax, 0x2b0(%rdi)
movb %dl, 0x2b5(%rdi)
movb $0x1, 0x2b6(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::createEntry(int, int)
void codeGenerator::createEntry( int lPos, int uPos ){
	if( lPos == uPos ){
		fprintf( oFile, "   goto %s;\n", ( branchTable[lPos] ).c_str() );
	}
	else{
		int mPos = ( lPos + uPos )/2;
		int key = mPos;
		string branchTrue = branchTableLabelTrue(mPos, true);
		string branchFalse = branchTableLabelTrue(mPos, false);

		fprintf( oFile, "   iReg[0] = %d;\n", key );
		fprintf( oFile, "   iReg[0] = TP_reg > iReg[0];\n" );
		
		fprintf( oFile, "   if( iReg[0] ) goto %s;\n", branchTrue.c_str() );
		fprintf( oFile, "   goto %s;\n", branchFalse.c_str() );
		
		fprintf( oFile, "\n%s:\n", branchTrue.c_str() );
		createEntry( mPos + 1, uPos );
		
		fprintf( oFile, "\n%s:\n", branchFalse.c_str() );
		createEntry( lPos, mPos );
		return;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
cmpl %edx, %esi
jne 0x16d55
movq 0x308(%rbx), %r14
addq $0xf0, %rbx
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x170bc
movq (%rax), %rdx
leaq 0x434c(%rip), %rsi      # 0x1b092
movq %r14, %rdi
xorl %eax, %eax
callq 0x22a0
jmp 0x16e77
movl %edx, %ebp
addl %edx, %esi
movl %esi, %r14d
shrl $0x1f, %r14d
addl %esi, %r14d
sarl %r14d
leaq 0x30(%rsp), %rdi
movl %r14d, %edx
movl $0x1, %ecx
callq 0x16ec6
leaq 0x10(%rsp), %rdi
movl %r14d, %edx
xorl %ecx, %ecx
callq 0x16ec6
movq 0x308(%rbx), %rdi
leaq 0x469a(%rip), %rsi      # 0x1b42f
movl %r14d, %edx
xorl %eax, %eax
callq 0x22a0
movq 0x308(%rbx), %rcx
leaq 0x4694(%rip), %rdi      # 0x1b441
movl $0x1f, %esi
movl $0x1, %edx
callq 0x2390
movq 0x308(%rbx), %rdi
movq 0x30(%rsp), %rdx
leaq 0x4692(%rip), %rsi      # 0x1b461
xorl %eax, %eax
callq 0x22a0
movq 0x308(%rbx), %rdi
movq 0x10(%rsp), %rdx
leaq 0x42a9(%rip), %rsi      # 0x1b092
xorl %eax, %eax
callq 0x22a0
movq 0x308(%rbx), %rdi
movq 0x30(%rsp), %rdx
leaq 0x41d4(%rip), %rsi      # 0x1afd7
xorl %eax, %eax
callq 0x22a0
leal 0x1(%r14), %esi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x16d0e
movq 0x308(%rbx), %rdi
movq 0x10(%rsp), %rdx
leaq 0x41ac(%rip), %rsi      # 0x1afd7
xorl %eax, %eax
callq 0x22a0
movl 0xc(%rsp), %esi
movq %rbx, %rdi
movl %r14d, %edx
callq 0x16d0e
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x16e5c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2200
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x16e77
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2200
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
jmp 0x16ea3
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x16ea3
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2200
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x16ebe
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/CominLab[P]QCluster/em.cc
// Function: initialize_cache(int)
void initialize_cache(int N){
	iterations = 0;
	best_assignment = new int[N];
	best_distortion = 1000000000000000;//infinite	
	for (int i=0; i<N; i++) best_assignment[i] = -1;
	return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x0, 0x8344(%rip)      # 0xc208
movslq %edi, %r14
leaq (,%r14,4), %rax
testl %r14d, %r14d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, 0x830f(%rip)      # 0xc1f8
movabsq $0x430c6bf526340000, %rcx # imm = 0x430C6BF526340000
movq %rcx, 0x8306(%rip)      # 0xc200
testl %r14d, %r14d
jle 0x3f19
movl %ebx, %edx
shlq $0x2, %rdx
movq %rax, %rdi
movl $0xff, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2130
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/CominLab[P]QCluster/em.cc
// Function: exceed_max_iterations(int, int, int*, double&)
bool exceed_max_iterations(int N, int K, int *assignment, double &distortion){
	iterations++;
	if (iterations>max_iterations){
		distortion = best_distortion;
		for(int n=0; n<N; n++) assignment[n] = best_assignment[n];	
		return true;
	}
	else{
		if (distortion < best_distortion){
			iterations = 0;
			for(int n=0; n<N; n++) best_assignment[n] = assignment[n];	
			best_distortion = distortion;
		}
	}	
	return false;
}

// Assembly:
movl 0x82e1(%rip), %eax      # 0xc208
leal 0x1(%rax), %esi
movl %esi, 0x82d8(%rip)      # 0xc208
movl 0x82aa(%rip), %esi      # 0xc1e0
cmpl %esi, %eax
jl 0x3f68
movsd 0x82be(%rip), %xmm0     # 0xc200
movsd %xmm0, (%rcx)
testl %edi, %edi
jle 0x3fac
movq 0x82a7(%rip), %rcx      # 0xc1f8
movl %edi, %edi
xorl %r8d, %r8d
movl (%rcx,%r8,4), %r9d
movl %r9d, (%rdx,%r8,4)
incq %r8
cmpq %r8, %rdi
jne 0x3f56
jmp 0x3fac
movsd (%rcx), %xmm0
movsd 0x828c(%rip), %xmm1     # 0xc200
ucomisd %xmm0, %xmm1
jbe 0x3fac
movl $0x0, 0x8284(%rip)      # 0xc208
testl %edi, %edi
jle 0x3fa4
movq 0x8269(%rip), %rcx      # 0xc1f8
movl %edi, %edi
xorl %r8d, %r8d
movl (%rdx,%r8,4), %r9d
movl %r9d, (%rcx,%r8,4)
incq %r8
cmpq %r8, %rdi
jne 0x3f94
movsd %xmm0, 0x8254(%rip)     # 0xc200
cmpl %esi, %eax
setge %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/CominLab[P]QCluster/dists.cc
// Function: euclidean_distance(double*, double*, int, double*, double*, double*, double*)
double euclidean_distance(double *centroid, double *y, int L, double* xt, 
						  double *quality, double *expected_qual, double *expected_freq)
{
	double S = 0;
	double z;
	for(int i=0; i<L; i++){
		z = centroid[i] - quality[i];
		S += z*z;
	}
	return S;
}

// Assembly:
testl %edx, %edx
jle 0x4eb4
movl %edx, %eax
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
movsd (%rdi,%rcx,8), %xmm1
subsd (%r8,%rcx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x4e98
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/CominLab[P]QCluster/dists.cc
// Function: kl_distance(double*, double*, int, double*, double*, double*, double*)
double kl_distance(double *centroid, double *p, int L, double* centroid_tilde, 
				   double *quality, double *expected_qual, double *expected_freq)
{
	double total_count = 0;
	for(int i=0; i<L; ++i){
		total_count += quality[i];
	}
	double S = 0;
	for(int i=0; i<L; i++){
		S += quality[i] * log(quality[i]/(total_count * centroid[i]));
	}
	return S;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movl %edx, %r15d
xorpd %xmm2, %xmm2
testl %edx, %edx
jle 0x4ee6
xorl %eax, %eax
addsd (%rbx,%rax,8), %xmm2
incq %rax
cmpq %rax, %r15
jne 0x4ed9
testl %edx, %edx
jle 0x4f41
xorps %xmm0, %xmm0
xorl %r12d, %r12d
movsd %xmm2, 0x8(%rsp)
movsd %xmm0, (%rsp)
movsd (%rbx,%r12,8), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd (%r14,%r12,8), %xmm1
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0x2180
movsd 0x8(%rsp), %xmm2
mulsd 0x10(%rsp), %xmm0
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
incq %r12
cmpq %r12, %r15
jne 0x4ef6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/CominLab[P]QCluster/dists.cc
// Function: symkl_distance(double*, double*, int, double*, double*, double*, double*)
double symkl_distance(double *centroid, double *p, int L, double* centroid_tilde, 
					  double *quality, double *expected_qual, double *expected_freq)
{
	double total_count = 0;
	for(int i=0; i<L; ++i){
		total_count += quality[i];
	}
	double S = 0;
	for(int i=0; i<L; i++){
		S += (quality[i]-total_count*centroid[i]) * log(quality[i]/(total_count*centroid[i]));
	}
	return S;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %rbx
movq %rdi, %r14
xorpd %xmm0, %xmm0
movl %edx, %r15d
xorpd %xmm2, %xmm2
testl %edx, %edx
jle 0x4f7c
xorl %eax, %eax
addsd (%rbx,%rax,8), %xmm2
incq %rax
cmpq %rax, %r15
jne 0x4f6f
testl %edx, %edx
jle 0x4ff8
movapd 0x3b98(%rip), %xmm0     # 0x8b20
xorpd %xmm2, %xmm0
movapd %xmm0, 0x10(%rsp)
xorpd %xmm0, %xmm0
xorl %r12d, %r12d
movapd %xmm2, 0x20(%rsp)
movsd %xmm0, (%rsp)
movsd (%rbx,%r12,8), %xmm0
movsd (%r14,%r12,8), %xmm1
movapd 0x10(%rsp), %xmm3
mulsd %xmm1, %xmm3
addsd %xmm0, %xmm3
movsd %xmm3, 0x8(%rsp)
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
callq 0x2180
movapd 0x20(%rsp), %xmm2
mulsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
incq %r12
cmpq %r12, %r15
jne 0x4f9f
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/CominLab[P]QCluster/dists.cc
// Function: d2_distance(double*, double*, int, double*, double*, double*, double*)
double d2_distance(double *centroid, double *p, int L, double* centroid_tilde, 
				   double *quality, double *expected_qual, double *expected_freq)
{
	double norm = 0;
	double S = 0;
	for(int i=0; i<L; i++){
		norm += quality[i] * quality[i];
	}
	norm = sqrt(norm);
	for(int i=0; i<L; i++){
		S += centroid[i] * quality[i] / norm;
	}
	return 1 - S;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %edx, %ebp
movq %rdi, %r14
xorpd %xmm1, %xmm1
movl %edx, %r15d
xorpd %xmm0, %xmm0
testl %edx, %edx
jle 0x5039
xorl %eax, %eax
movsd (%rbx,%rax,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rax
cmpq %rax, %r15
jne 0x5024
ucomisd %xmm1, %xmm0
jb 0x5045
sqrtsd %xmm0, %xmm0
jmp 0x504a
callq 0x2170
xorpd %xmm1, %xmm1
testl %ebp, %ebp
jle 0x506f
xorl %eax, %eax
movsd (%r14,%rax,8), %xmm2
mulsd (%rbx,%rax,8), %xmm2
divsd %xmm0, %xmm2
addsd %xmm2, %xmm1
incq %rax
cmpq %rax, %r15
jne 0x5054
movsd 0x2f91(%rip), %xmm0     # 0x8008
subsd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/CominLab[P]QCluster/dists.cc
// Function: chi2_distance(double*, double*, int, double*, double*, double*, double*)
double chi2_distance(double *centroid, double *p, int L, double* centroid_tilde, 
					 double *quality, double *expected_qual, double *expected_freq)
{
	double chi2 = 0;
	double total_count = 0;
	for(int i=0; i<L; i++){
		total_count += quality[i];
	}
	for(int i=0; i<L; i++){
		double exp_count = centroid[i] * total_count;
		chi2 += (quality[i] - exp_count) * (quality[i] - exp_count) / exp_count;
	}
	//return (chi2 - (L-3) * log(chi2))/2;
	return chi2;
}

// Assembly:
xorpd %xmm0, %xmm0
movl %edx, %eax
xorpd %xmm1, %xmm1
testl %edx, %edx
jle 0x50a4
xorl %ecx, %ecx
addsd (%r8,%rcx,8), %xmm1
incq %rcx
cmpq %rcx, %rax
jne 0x5096
testl %edx, %edx
jle 0x50d5
xorpd %xmm0, %xmm0
xorl %ecx, %ecx
movsd (%rdi,%rcx,8), %xmm2
mulsd %xmm1, %xmm2
movsd (%r8,%rcx,8), %xmm3
subsd %xmm2, %xmm3
mulsd %xmm3, %xmm3
divsd %xmm2, %xmm3
addsd %xmm3, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x50ae
retq
// File: /workspace/github_cpp_makefile_star2_O1/CominLab[P]QCluster/dists.cc
// Function: d2ast_distance(double*, double*, int, double*, double*, double*, double*)
double d2ast_distance(double *centroid, double *p, int L, double* centroid_tilde,
					  double *quality, double *expected_qual, double *expected_freq)
{
	//Determines what data to use: global(expected_freq) or local(centroid)
	double * exp_freq;
	if (expected_freq==NULL) exp_freq = centroid;
	else exp_freq = expected_freq;
	
	double x[L];
	memcpy(x, quality, L*sizeof(*quality));
	double total_count = 0;
	for(int i=0; i<L; i++){
		total_count += p[i];
	}
	double S = 0;
	for(int l=0; l<L; ++l){
		x[l] -= total_count * exp_freq[l] * expected_qual[l];
		x[l] /= sqrt(exp_freq[l] * expected_qual[l]);
		S += x[l] * x[l];
	}
	S = sqrt(S);
	for(int l=0; l<L; ++l){
		x[l] /= S;
	}	
	S = 0;
	for(int l=0; l<L; ++l){
		S += x[l] * centroid_tilde[l];
	}
	return (1-S)/2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r12
movq %rcx, -0x40(%rbp)
movq %rsi, %r15
movq %rdi, %r13
movq 0x10(%rbp), %rax
testq %rax, %rax
cmovneq %rax, %r13
movl %edx, %ebx
movq %rsp, %r14
leaq 0xf(,%rbx,8), %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
movl %edx, -0x2c(%rbp)
movslq %edx, %rax
movq %rax, -0x38(%rbp)
leaq (,%rax,8), %rdx
movq %r14, %rdi
movq %r8, %rsi
callq 0x2190
xorpd %xmm2, %xmm2
xorpd %xmm3, %xmm3
cmpl $0x0, -0x38(%rbp)
jle 0x5151
xorl %eax, %eax
addsd (%r15,%rax,8), %xmm3
incq %rax
cmpq %rax, %rbx
jne 0x5143
cmpl $0x0, -0x2c(%rbp)
jle 0x51de
xorpd 0x39bd(%rip), %xmm3     # 0x8b20
xorpd %xmm4, %xmm4
xorl %r15d, %r15d
xorpd %xmm2, %xmm2
movapd %xmm3, -0x60(%rbp)
movsd (%r13,%r15,8), %xmm0
movsd (%r12,%r15,8), %xmm1
movapd %xmm0, %xmm5
mulsd %xmm3, %xmm5
mulsd %xmm1, %xmm5
addsd (%r14,%r15,8), %xmm5
mulsd %xmm1, %xmm0
ucomisd %xmm4, %xmm0
jb 0x51a2
sqrtsd %xmm0, %xmm0
jmp 0x51c4
movsd %xmm2, -0x38(%rbp)
movsd %xmm5, -0x48(%rbp)
callq 0x2170
movsd -0x48(%rbp), %xmm5
xorpd %xmm4, %xmm4
movapd -0x60(%rbp), %xmm3
movsd -0x38(%rbp), %xmm2
divsd %xmm0, %xmm5
movsd %xmm5, (%r14,%r15,8)
mulsd %xmm5, %xmm5
addsd %xmm5, %xmm2
incq %r15
cmpq %r15, %rbx
jne 0x5173
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
jb 0x51f1
xorps %xmm0, %xmm0
sqrtsd %xmm2, %xmm0
jmp 0x51fa
movapd %xmm2, %xmm0
callq 0x2170
movq -0x40(%rbp), %rcx
movl -0x2c(%rbp), %edx
testl %edx, %edx
jle 0x521f
xorl %eax, %eax
movsd (%r14,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%r14,%rax,8)
incq %rax
cmpq %rax, %rbx
jne 0x5207
xorpd %xmm1, %xmm1
testl %edx, %edx
jle 0x5240
xorl %eax, %eax
movsd (%r14,%rax,8), %xmm0
mulsd (%rcx,%rax,8), %xmm0
addsd %xmm0, %xmm1
incq %rax
cmpq %rax, %rbx
jne 0x5229
movsd 0x2dc0(%rip), %xmm0     # 0x8008
subsd %xmm1, %xmm0
mulsd 0x39e4(%rip), %xmm0     # 0x8c38
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/CominLab[P]QCluster/centroid.cc
// Function: mean_centroid(int, int, double**, int, double**, double*, double*, double**, double*, double**, double*)
void mean_centroid(int N, int row_length, double** freq, int num_nt,
double** freq_1, double* centroid, double* centroid_tilde, 
double **quality, double *expected_qual, double **quality_1,
double *expected_freq)
{
	memset(centroid, 0, row_length * sizeof(*centroid));
	for(int n=0; n<N; n++){
		for(int l=0; l<row_length; l++){
			centroid[l] += quality[n][l];
		}
	}

	for(int l=0; l<row_length; l++){
		centroid[l] /= N;
	}
	return;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %r9, %rbx
movl %esi, %r14d
movl %edi, %ebp
movslq %esi, %rdx
shlq $0x3, %rdx
movq %r9, %rdi
xorl %esi, %esi
callq 0x2130
movl %r14d, %eax
testl %ebp, %ebp
jle 0x52bf
movq 0x28(%rsp), %rcx
movl %ebp, %edx
xorl %esi, %esi
testl %r14d, %r14d
jle 0x52b7
movq (%rcx,%rsi,8), %rdi
xorl %r8d, %r8d
movsd (%rdi,%r8,8), %xmm0
addsd (%rbx,%r8,8), %xmm0
movsd %xmm0, (%rbx,%r8,8)
incq %r8
cmpq %r8, %rax
jne 0x529d
incq %rsi
cmpq %rdx, %rsi
jne 0x5291
testl %r14d, %r14d
jle 0x52e3
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
xorl %ecx, %ecx
movsd (%rbx,%rcx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x52cd
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/CominLab[P]QCluster/centroid.cc
// Function: d2_centroid(int, int, double**, int, double**, double*, double*, double**, double*, double**, double*)
void d2_centroid(int N, int row_length, double** freq, int num_nt,
double** freq_1, double* centroid, double* centroid_tilde, 
double **quality, double *expected_qual, double **quality_1,
double *expected_freq)
{
	// add the total counts
	memset(centroid, 0, row_length * sizeof(*centroid));
	for(int n=0; n<N; ++n){
		for(int l=0; l<row_length; ++l){
			centroid[l] += quality[n][l];
		}
	}
	// now normalize the entries
	double total_sq_count = 0;
	for(int l=0; l<row_length; ++l){
		total_sq_count += centroid[l] * centroid[l];
	}
	double norm = sqrt(total_sq_count);
	for(int l=0; l<row_length; ++l){
		centroid[l] /= norm;
	}
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %esi, %ebp
movl %edi, %r14d
movslq %esi, %rdx
shlq $0x3, %rdx
movq %r9, %rdi
xorl %esi, %esi
callq 0x2130
movl %ebp, %r15d
testl %r14d, %r14d
jle 0x5343
movq 0x38(%rsp), %rax
movl %r14d, %ecx
xorl %edx, %edx
testl %ebp, %ebp
jle 0x533b
movq (%rax,%rdx,8), %rsi
xorl %edi, %edi
movsd (%rsi,%rdi,8), %xmm0
addsd (%rbx,%rdi,8), %xmm0
movsd %xmm0, (%rbx,%rdi,8)
incq %rdi
cmpq %rdi, %r15
jne 0x5324
incq %rdx
cmpq %rcx, %rdx
jne 0x531a
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
testl %ebp, %ebp
jle 0x5366
xorl %eax, %eax
movsd (%rbx,%rax,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rax
cmpq %rax, %r15
jne 0x5351
ucomisd %xmm1, %xmm0
jb 0x5372
sqrtsd %xmm0, %xmm0
jmp 0x5377
callq 0x2170
testl %ebp, %ebp
jle 0x5393
xorl %eax, %eax
movsd (%rbx,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%rax,8)
incq %rax
cmpq %rax, %r15
jne 0x537d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/CominLab[P]QCluster/centroid.cc
// Function: kl_centroid(int, int, double**, int, double**, double*, double*, double**, double*, double**, double*)
void kl_centroid(int N, int row_length, double** freq, int num_nt,
double** freq_1, double* centroid, double* centroid_tilde, 
double **quality, double *expected_qual, double **quality_1,
double *expected_freq)
{
	// add the total counts
	memset(centroid, 0, row_length * sizeof(*centroid));
	for(int n=0; n<N; ++n){
		for(int l=0; l<row_length; ++l){
			centroid[l] += quality[n][l];
		}
	}
	// now normalize the entries
	double total_count = 0;
	for(int l=0; l<row_length; ++l){
		total_count += centroid[l];
	}
	for(int l=0; l<row_length; ++l){
		centroid[l] /= total_count;
	}
	return;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %r9, %rbx
movl %esi, %ebp
movl %edi, %r14d
movslq %esi, %rdx
shlq $0x3, %rdx
movq %r9, %rdi
xorl %esi, %esi
callq 0x2130
movl %ebp, %eax
testl %r14d, %r14d
jle 0x53f9
movq 0x28(%rsp), %rcx
movl %r14d, %edx
xorl %esi, %esi
testl %ebp, %ebp
jle 0x53f1
movq (%rcx,%rsi,8), %rdi
xorl %r8d, %r8d
movsd (%rdi,%r8,8), %xmm0
addsd (%rbx,%r8,8), %xmm0
movsd %xmm0, (%rbx,%r8,8)
incq %r8
cmpq %r8, %rax
jne 0x53d7
incq %rsi
cmpq %rdx, %rsi
jne 0x53cc
xorpd %xmm0, %xmm0
testl %ebp, %ebp
jle 0x5410
xorl %ecx, %ecx
addsd (%rbx,%rcx,8), %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x5403
testl %ebp, %ebp
jle 0x542c
xorl %ecx, %ecx
movsd (%rbx,%rcx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x5416
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/CominLab[P]QCluster/centroid.cc
// Function: d2ast_centroid(int, int, double**, int, double**, double*, double*, double**, double*, double**, double*)
void d2ast_centroid(int N, int row_length, double** freq, int num_nt,
double** freq_1, double* centroid, double* centroid_tilde, 
double **quality, double *expected_qual, double **quality_1,
double *expected_freq)
{
	// compute frequencies from MM
	mm_centroid(N, row_length, freq, num_nt, freq_1, centroid, NULL, 
				quality, expected_qual, quality_1, expected_freq);
	// compute X_tilde
	memset(centroid_tilde, 0, row_length * sizeof(*centroid_tilde));
	
	double total_count = 0;
	for(int n=0; n<N; ++n){
		for(int l=0; l<row_length; ++l){
			centroid_tilde[l] += quality[n][l];
			total_count += freq[n][l];
		}
	}
	
	//Determines what data to use: global(expected_freq) or local(centroid)
	double * exp_freq;
	if (expected_freq==NULL) exp_freq = centroid;
	else exp_freq = expected_freq;
	
	double S = 0;
	for(int l=0; l<row_length; ++l){
		centroid_tilde[l] -= total_count * exp_freq[l] * expected_qual[l];
		centroid_tilde[l] /= sqrt(exp_freq[l] * expected_qual[l]);
		S += centroid_tilde[l] * centroid_tilde[l];
	}
	S = sqrt(S);
	for(int l=0; l<row_length; ++l){
		centroid_tilde[l] /= S;
	}
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r14
movq %rdx, %r15
movl %esi, %ebp
movl %edi, %r12d
movq 0xa0(%rsp), %rax
movq 0x80(%rsp), %rbx
movq %rax, 0x20(%rsp)
callq 0x5431
movslq %ebp, %rdx
shlq $0x3, %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2130
xorpd %xmm2, %xmm2
movl %ebp, %r13d
xorpd %xmm3, %xmm3
testl %r12d, %r12d
jle 0x55fc
movq 0x88(%rsp), %rax
movl %r12d, %ecx
xorl %edx, %edx
testl %ebp, %ebp
jle 0x55f4
movq (%rax,%rdx,8), %rsi
movq (%r15,%rdx,8), %rdi
xorl %r8d, %r8d
movsd (%rsi,%r8,8), %xmm0
addsd (%rbx,%r8,8), %xmm0
movsd %xmm0, (%rbx,%r8,8)
addsd (%rdi,%r8,8), %xmm3
incq %r8
cmpq %r8, %r13
jne 0x55d4
incq %rdx
cmpq %rcx, %rdx
jne 0x55c5
movq 0xa0(%rsp), %rax
testq %rax, %rax
cmovneq %rax, %r14
testl %ebp, %ebp
jle 0x56a3
xorpd 0x3505(%rip), %xmm3     # 0x8b20
movq 0x90(%rsp), %r15
xorpd %xmm4, %xmm4
xorl %r12d, %r12d
xorpd %xmm2, %xmm2
movapd %xmm3, 0x30(%rsp)
movsd (%r14,%r12,8), %xmm0
mulsd %xmm3, %xmm0
mulsd (%r15,%r12,8), %xmm0
addsd (%rbx,%r12,8), %xmm0
movsd %xmm0, (%rbx,%r12,8)
movsd (%r14,%r12,8), %xmm0
mulsd (%r15,%r12,8), %xmm0
ucomisd %xmm4, %xmm0
jb 0x5668
sqrtsd %xmm0, %xmm0
jmp 0x5683
movsd %xmm2, 0x28(%rsp)
callq 0x2170
xorpd %xmm4, %xmm4
movapd 0x30(%rsp), %xmm3
movsd 0x28(%rsp), %xmm2
movsd (%rbx,%r12,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%r12,8)
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm2
incq %r12
cmpq %r12, %r13
jne 0x5634
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm2
jb 0x56b6
xorps %xmm0, %xmm0
sqrtsd %xmm2, %xmm0
jmp 0x56bf
movapd %xmm2, %xmm0
callq 0x2170
testl %ebp, %ebp
jle 0x56db
xorl %eax, %eax
movsd (%rbx,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%rax,8)
incq %rax
cmpq %rax, %r13
jne 0x56c5
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/CominLab[P]QCluster/freqs.cc
// Function: normalize_row(double*, int)
void normalize_row(double* fv, int L)
{
	double total = 0;
	for (int l=0; l<L; l++){
		total += fv[l];	// ||fv||1
	}
	for (int l=0; l<L; l++){
		fv[l] /= total;
	}
	return;
}

// Assembly:
movl %esi, %eax
xorpd %xmm0, %xmm0
testl %esi, %esi
jle 0x5705
xorl %ecx, %ecx
addsd (%rdi,%rcx,8), %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x56f8
testl %esi, %esi
jle 0x5721
xorl %ecx, %ecx
movsd (%rdi,%rcx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rdi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x570b
retq
// File: /workspace/github_cpp_makefile_star2_O1/CominLab[P]QCluster/freqs.cc
// Function: normalize_row_against(double*, double*, int)
void normalize_row_against(double* freq, double* qual, int L)
{
	double total = 0;
	for (int l=0; l<L; l++){
		total += freq[l]; // ||freq||1
	}
	for (int l=0; l<L; l++){
		qual[l] /= total;
	}
	return;
}

// Assembly:
movl %edx, %eax
xorpd %xmm0, %xmm0
testl %edx, %edx
jle 0x573b
xorl %ecx, %ecx
addsd (%rdi,%rcx,8), %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x572e
testl %edx, %edx
jle 0x5757
xorl %ecx, %ecx
movsd (%rsi,%rcx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x5741
retq
// File: /workspace/github_cpp_makefile_star2_O1/CominLab[P]QCluster/freqs.cc
// Function: normalize_row_projection(double*, double*, int)
void normalize_row_projection(double* freq, double* qual, int L)
{
	double total = 0, total_qual = 0;
	for (int l=0; l<L; l++){
		total += freq[l];
		total_qual += qual[l];
	}
	double parziale = (total - total_qual) / L;
	for (int l=0; l<L; l++){
		qual[l] += parziale;
	}
	return;
}

// Assembly:
movl %edx, %eax
xorpd %xmm0, %xmm0
testl %edx, %edx
jle 0x577e
xorl %ecx, %ecx
xorpd %xmm1, %xmm1
addsd (%rdi,%rcx,8), %xmm0
addsd (%rsi,%rcx,8), %xmm1
incq %rcx
cmpq %rcx, %rax
jne 0x5768
subsd %xmm1, %xmm0
testl %edx, %edx
jle 0x57a5
xorps %xmm1, %xmm1
cvtsi2sd %edx, %xmm1
divsd %xmm1, %xmm0
xorl %ecx, %ecx
movsd (%rsi,%rcx,8), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x578f
retq
// File: /workspace/github_cpp_makefile_star2_O1/CominLab[P]QCluster/freqs.cc
// Function: expected_frequency_p2global(int, int, int, double*, double**)
void expected_frequency_p2global(int N, int K, int L, double *expected_freq,
								double **freq_1)
{
	double nt_freq[NUM_NT];
	memset(nt_freq, 0, NUM_NT * sizeof(nt_freq[0]));
	double S=0;
	// compute frequencies of individual nucleotides
	for (int n=0; n<N; n++){
		for (int l=0; l<NUM_NT; l++){
			nt_freq[l] += freq_1[n][l]; //= count of letter l on the dataset
		}
	}
	for (int l=0; l<NUM_NT; l++)
		S += nt_freq[l];	//S = total number of letters in the dataset

	for (int l=0; l<NUM_NT; l++){
		nt_freq[l] /= S;	//Average frequency of each letter in the dataset
	}
	// compute frequencies of words using Markov model
	for(int l=0; l<L; l++){
		double p = 1;
		for(int M=1; M<L; M*=NUM_NT){
			int digit = l/M % NUM_NT;
			p *= nt_freq[digit];
		}
		expected_freq[l] = p;
	}
	return;
}

// Assembly:
movl %edx, %esi
xorpd %xmm0, %xmm0
movapd %xmm0, -0x18(%rsp)
movapd %xmm0, -0x28(%rsp)
testl %edi, %edi
jle 0x6152
movl %edi, %eax
xorl %edx, %edx
movq (%r8,%rdx,8), %rdi
xorl %r9d, %r9d
movsd (%rdi,%r9,8), %xmm0
addsd -0x28(%rsp,%r9,8), %xmm0
movsd %xmm0, -0x28(%rsp,%r9,8)
incq %r9
cmpq $0x4, %r9
jne 0x612d
incq %rdx
cmpq %rax, %rdx
jne 0x6126
xorpd %xmm0, %xmm0
xorl %eax, %eax
addsd -0x28(%rsp,%rax,8), %xmm0
incq %rax
cmpq $0x4, %rax
jne 0x6158
xorl %eax, %eax
movsd -0x28(%rsp,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rsp,%rax,8)
incq %rax
cmpq $0x4, %rax
jne 0x6169
testl %esi, %esi
jle 0x61cc
movl %esi, %r8d
xorl %edi, %edi
movsd 0x1e75(%rip), %xmm0     # 0x8008
movapd %xmm0, %xmm1
cmpl $0x1, %esi
je 0x61bf
movl $0x1, %r9d
movapd %xmm0, %xmm1
movl %edi, %eax
xorl %edx, %edx
divl %r9d
andl $0x3, %eax
mulsd -0x28(%rsp,%rax,8), %xmm1
shll $0x2, %r9d
cmpl %esi, %r9d
jl 0x61a6
movsd %xmm1, (%rcx,%rdi,8)
incq %rdi
cmpq %r8, %rdi
jne 0x6193
retq
// File: /workspace/github_cpp_makefile_star2_O1/CominLab[P]QCluster/freqs.cc
// Function: expected_frequency_p1global(int, int, int, double*, double**)
void expected_frequency_p1global(int N, int K, int L, double *expected_freq,
								double **freq)
{
	int tot_parole = 0;
	for (int l=0; l<L; l++) {
		expected_freq[l] = 0;
		for (int n=0; n<N; n++)
			expected_freq[l] += freq[n][l];
		tot_parole += expected_freq[l];
	}	
	for (int l=0; l<L; l++) {
		expected_freq[l] /= tot_parole;
	}
	return;
}

// Assembly:
movl %edx, %eax
testl %edx, %edx
jle 0x622f
pushq %rbx
movl %edi, %esi
xorl %r9d, %r9d
xorl %r10d, %r10d
movq $0x0, (%rcx,%r9,8)
testl %edi, %edi
jle 0x6209
movsd (%rcx,%r9,8), %xmm0
xorl %r11d, %r11d
movq (%r8,%r11,8), %rbx
addsd (%rbx,%r9,8), %xmm0
movsd %xmm0, (%rcx,%r9,8)
incq %r11
cmpq %r11, %rsi
jne 0x61f1
xorps %xmm0, %xmm0
cvtsi2sd %r10d, %xmm0
addsd (%rcx,%r9,8), %xmm0
cvttsd2si %xmm0, %r10d
incq %r9
cmpq %rax, %r9
jne 0x61dc
xorps %xmm0, %xmm0
cvtsi2sd %r10d, %xmm0
popq %rbx
jmp 0x6233
xorpd %xmm0, %xmm0
testl %edx, %edx
jle 0x624f
xorl %edx, %edx
movsd (%rcx,%rdx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rcx,%rdx,8)
incq %rdx
cmpq %rdx, %rax
jne 0x6239
retq
// File: /workspace/github_cpp_makefile_star2_O1/CominLab[P]QCluster/freqs.cc
// Function: normalize_freq_matrix(double**, double**, int, int)
void normalize_freq_matrix(double** freq, double** qual, int N, int row_length)
{
	double tmp, sum_freq, sum_freq_square, V_freq;
	double sum_qual, sum_qual_square, V_qual;
	for(int l=0; l<row_length; ++l){
		sum_freq_square=0;
		sum_freq=0;
		sum_qual_square = 0;
		sum_qual = 0;
		for(int n=0; n<N; ++n){
			tmp = *(*(freq+n)+l);
			sum_freq_square += tmp*tmp;
			sum_freq += tmp;
			tmp = *(*(qual+n)+l);
			sum_qual_square += tmp*tmp;
			sum_qual += tmp;
		}
		//Variance:
		V_freq = sqrt( sum_freq_square/N - (sum_freq*sum_freq)/(N*N) );  
		V_qual = sqrt( sum_qual_square/N - (sum_qual*sum_qual)/(N*N) ); 
		if (V_freq>0 && V_qual>0){
			for(int n=0; n<N; ++n){
				*(*(freq+n)+l) /= V_freq;
				*(*(qual+n)+l) /= V_qual;				
			}
		}
	}
	return;
}

// Assembly:
testl %ecx, %ecx
jle 0x63e1
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
cvtsi2sd %edx, %xmm3
movl %edx, %eax
imull %ebx, %eax
cvtsi2sd %eax, %xmm4
movl %ecx, %r12d
movl %edx, %r13d
xorl %ebp, %ebp
xorpd %xmm5, %xmm5
movsd %xmm3, 0x8(%rsp)
movsd %xmm4, (%rsp)
xorpd %xmm0, %xmm0
xorpd %xmm7, %xmm7
xorpd %xmm6, %xmm6
xorpd %xmm1, %xmm1
testl %ebx, %ebx
jle 0x62da
xorl %eax, %eax
movq (%r15,%rax,8), %rcx
movsd (%rcx,%rbp,8), %xmm2
addsd %xmm2, %xmm1
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
movq (%r14,%rax,8), %rcx
movsd (%rcx,%rbp,8), %xmm2
addsd %xmm2, %xmm7
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm6
incq %rax
cmpq %rax, %r13
jne 0x62a8
divsd %xmm3, %xmm0
mulsd %xmm1, %xmm1
divsd %xmm4, %xmm1
subsd %xmm1, %xmm0
ucomisd %xmm5, %xmm0
jb 0x62fb
xorps %xmm8, %xmm8
sqrtsd %xmm0, %xmm8
jmp 0x632c
movapd %xmm6, 0x10(%rsp)
movapd %xmm7, 0x20(%rsp)
callq 0x2170
movapd 0x20(%rsp), %xmm7
movapd 0x10(%rsp), %xmm6
xorpd %xmm5, %xmm5
movsd (%rsp), %xmm4
movsd 0x8(%rsp), %xmm3
movapd %xmm0, %xmm8
divsd %xmm3, %xmm6
mulsd %xmm7, %xmm7
divsd %xmm4, %xmm7
subsd %xmm7, %xmm6
ucomisd %xmm5, %xmm6
jb 0x634b
xorps %xmm0, %xmm0
sqrtsd %xmm6, %xmm0
jmp 0x6371
movapd %xmm6, %xmm0
movapd %xmm8, 0x10(%rsp)
callq 0x2170
movapd 0x10(%rsp), %xmm8
xorpd %xmm5, %xmm5
movsd (%rsp), %xmm4
movsd 0x8(%rsp), %xmm3
testl %ebx, %ebx
setle %al
xorpd %xmm1, %xmm1
cmpnltpd %xmm0, %xmm1
xorpd %xmm2, %xmm2
cmpnltpd %xmm8, %xmm2
orpd %xmm1, %xmm2
movd %xmm2, %ecx
orb %al, %cl
testb $0x1, %cl
jne 0x63c7
xorl %eax, %eax
movq (%r15,%rax,8), %rcx
movsd (%rcx,%rbp,8), %xmm1
divsd %xmm8, %xmm1
movsd %xmm1, (%rcx,%rbp,8)
movq (%r14,%rax,8), %rcx
movsd (%rcx,%rbp,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rcx,%rbp,8)
incq %rax
cmpq %rax, %r13
jne 0x639a
incq %rbp
cmpq %r12, %rbp
jne 0x6292
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/CominLab[P]QCluster/seqio.cc
// Function: SeqRecord::toupper() const
SeqRecord SeqRecord::toupper() const
{
	string upper_seq; 
	unsigned int L = sequence.length();
	upper_seq.resize(L);
	for (unsigned int i=0; i<L; i++) {
		upper_seq[i] = std::toupper(sequence[i]); // need to specify std
		// namespace explicitly to avoid conflict with our member function
	}
	return SeqRecord(header, description, upper_seq, quality);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movl 0x48(%rsi), %r15d
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x20c0
testq %r15, %r15
je 0x669d
xorl %r13d, %r13d
movq 0x40(%r14), %rax
movsbl (%rax,%r13), %edi
callq 0x2380
movq 0x8(%rsp), %rcx
movb %al, (%rcx,%r13)
incq %r13
cmpq %r13, %r15
jne 0x667e
leaq 0x98(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x88(%rsp), %rdi
callq 0x3d94
leaq 0x78(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
leaq 0x68(%rsp), %rdi
callq 0x3d94
leaq 0x58(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x3d94
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x60(%r14), %rsi
movq 0x68(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x3d94
leaq 0x88(%rsp), %rsi
leaq 0x68(%rsp), %rdx
leaq 0x48(%rsp), %rcx
leaq 0x28(%rsp), %r8
movq %rbx, %rdi
callq 0x64ce
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x6753
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0x676a
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x68(%rsp), %rdi
cmpq %r13, %rdi
je 0x6781
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x88(%rsp), %rdi
cmpq %r12, %rdi
je 0x679e
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x67ba
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x67ee
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0x67ee
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0x680a
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0x680a
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r13, %rdi
je 0x6826
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0x6826
movq %rax, %rbx
movq 0x88(%rsp), %rdi
cmpq %r12, %rdi
je 0x6848
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0x6848
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x6864
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/CominLab[P]QCluster/seqio.cc
// Function: removeWhiteSpace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
static void removeWhiteSpace(string& line)
{
	size_t pos = 0;
	while (pos < line.length()) {
		if (isspace(line[pos])) {
			line.erase(pos, 1);
		} else {
			pos++;
		}
	}
	return;
}

// Assembly:
cmpq $0x0, 0x8(%rdi)
je 0x7148
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq (%rbx), %rax
movsbl (%rax,%r14), %edi
callq 0x2050
testl %eax, %eax
je 0x7138
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2080
jmp 0x713b
incq %r14
cmpq 0x8(%rbx), %r14
jb 0x7115
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop