LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::popArguments(int)
void codeGenerator::popArguments(int SPoffset){
	if( !ShouldGenerate() ) return;
	
	while( argListStack.size() != 0 ){
		
		savedArgument = argListStack.top();
		argListStack.pop();
		
		if( savedArgument.index < 0 && savedArgument.size > 1 && !savedArgument.indirect ){
			SPoffset -= savedArgument.size;
		}
		else{
			SPoffset -= 1;
		}

		if( savedArgument.paramType == TYPE_PARAM_OUT || savedArgument.paramType == TYPE_PARAM_INOUT ){
			comment("Pop argument.");
			mm2reg(savedArgument.type, savedArgument.size, SPoffset, false, savedArgument.index, false, TYPE_INTEGER, true );
			reg2mm(savedArgument.type, savedArgument.type, savedArgument.size, savedArgument.size, savedArgument.offset, savedArgument.isGlobal);
		}
	}
	return;
}

// Assembly:
cmpb $0x1, 0x330(%rdi)
jne 0xf336
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x2b8(%rdi), %r15
leaq 0x2a0(%rdi), %r12
movq %r15, %rdi
callq 0x100b4
testq %rax, %rax
je 0xf328
movq 0x2e8(%r14), %rax
cmpq 0x2f0(%r14), %rax
jne 0xf210
movq 0x300(%r14), %rax
movq -0x8(%rax), %rax
movl $0x1f8, %ecx            # imm = 0x1F8
addq %rcx, %rax
movq -0x8(%rax), %rcx
movq %rcx, 0x10(%r12)
movups -0x18(%rax), %xmm0
movups %xmm0, (%r12)
movq %r15, %rdi
callq 0x10254
cmpl $0x0, 0x2ac(%r14)
jns 0xf24e
movl 0x2a8(%r14), %eax
cmpl $0x2, %eax
jl 0xf24e
cmpb $0x0, 0x2b4(%r14)
je 0xf321
decl %ebx
movl (%r12), %eax
andl $-0x2, %eax
cmpl $0x120, %eax            # imm = 0x120
jne 0xf1dc
leaq 0x48(%rsp), %r13
movq %r13, %rdi
leaq 0x3eb8(%rip), %rsi      # 0x13129
leaq 0x7(%rsp), %rdx
callq 0x36b8
movq %r14, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0xbf98
movq %r13, %rdi
callq 0x20f0
movl 0x2a4(%r14), %edx
movl 0x2a8(%r14), %ecx
movl 0x2ac(%r14), %eax
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movl %ebx, %r8d
xorl %r9d, %r9d
pushq $0x1
movl $0x10a, %ebp            # imm = 0x10A
pushq %rbp
pushq $0x0
pushq %rax
callq 0xdbce
addq $0x20, %rsp
movq %r13, %rdi
callq 0x20f0
movl 0x2a4(%r14), %ecx
movl 0x2a8(%r14), %r8d
movl 0x2b0(%r14), %eax
movzbl 0x2b5(%r14), %r10d
subq $0x8, %rsp
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movl %ecx, %edx
movl %r8d, %r9d
pushq $0x0
pushq %rbp
pushq $0x0
pushq %r10
pushq %rax
callq 0xe322
addq $0x30, %rsp
movq %r13, %rdi
callq 0x20f0
jmp 0xf1dc
subl %eax, %ebx
jmp 0xf250
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl %esi, 0x4(%rsp)
cmpl %edx, %esi
jne 0xf381
movq 0x308(%rbx), %r14
addq $0xf0, %rbx
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
callq 0xf58a
movq (%rax), %rdx
leaq 0x3d00(%rip), %rsi      # 0x13072
movq %r14, %rdi
xorl %eax, %eax
callq 0x2280
jmp 0xf478
movl %edx, %r15d
movl %esi, %r14d
leal (%r15,%r14), %eax
pushq $0x2
popq %rcx
cltd
idivl %ecx
movl %eax, %ebp
leaq 0x28(%rsp), %rdi
pushq $0x1
popq %rcx
movl %eax, %edx
callq 0xf4a8
leaq 0x8(%rsp), %rdi
movl %ebp, %edx
xorl %ecx, %ecx
callq 0xf4a8
movq 0x308(%rbx), %rdi
leaq 0x4051(%rip), %rsi      # 0x1340f
movl %ebp, %edx
xorl %eax, %eax
callq 0x2280
movq 0x308(%rbx), %rcx
leaq 0x404c(%rip), %rdi      # 0x13421
pushq $0x1f
popq %rsi
pushq $0x1
popq %rdx
callq 0x2380
movq 0x308(%rbx), %rdi
movq 0x28(%rsp), %rdx
leaq 0x404e(%rip), %rsi      # 0x13441
xorl %eax, %eax
callq 0x2280
movq 0x308(%rbx), %rdi
movq 0x8(%rsp), %rdx
leaq 0x3c65(%rip), %rsi      # 0x13072
xorl %eax, %eax
callq 0x2280
movq 0x308(%rbx), %rdi
movq 0x28(%rsp), %rdx
leaq 0x3b90(%rip), %rsi      # 0x12fb7
xorl %eax, %eax
callq 0x2280
movl %ebp, %esi
incl %esi
movq %rbx, %rdi
movl %r15d, %edx
callq 0xf338
movq 0x308(%rbx), %rdi
movq 0x8(%rsp), %rdx
leaq 0x3b67(%rip), %rsi      # 0x12fb7
xorl %eax, %eax
callq 0x2280
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0xf338
leaq 0x8(%rsp), %rdi
callq 0x20f0
leaq 0x28(%rsp), %rdi
callq 0x20f0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xf495
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20f0
leaq 0x28(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/jandoerntlein[P]wire/src/wire.h
// Function: void wire::DirectWire<>::connect<Light>(unsigned int, void (Light::*)(), Light*)
inline void connect( unsigned int idx, 
        void ( K::* pMemberFunc )( Args... args ), 
        K* pInstance ) 
    {
        if( m_fn.count( idx ) == 0 )
            connect_helper<K>( std::make_integer_sequence<int, sizeof...( Args )>{}, 
                idx, 
                pMemberFunc, 
                pInstance );
#ifdef WIRE_USE_EXCEPTIONS
        else
            throw std::runtime_error( "Requested index already in use." );
#endif
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
leaq 0x4(%rsp), %rax
movl %esi, (%rax)
movq %rax, %rsi
callq 0x394c
testq %rax, %rax
jne 0x2799
movl 0x4(%rsp), %esi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x38e4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jandoerntlein[P]wire/src/wire.h
// Function: wire::DirectWire<>::operator()(unsigned int) const
inline void operator()( unsigned int idx, Args... params ) const
    {
        if( m_fn.count( idx ) > 0 ) 
            m_fn.at( idx )( params... );
#ifdef WIRE_USE_EXCEPTIONS
        else
            throw std::runtime_error( "Function index is not in use." );
#endif
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rax
movl %esi, (%rax)
movq %rax, %rsi
callq 0x394c
testq %rax, %rax
je 0x2821
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x4170
movq %rax, %rdi
callq 0x385a
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/jandoerntlein[P]wire/src/wire.h
// Function: void wire::Wire<>::connect_helper<Light>(std::integer_sequence<int, ...>, void (Light::*)(), Light*)
inline void connect_helper( std::integer_sequence<int, Idcs...>, 
        void ( K::* pMemberFunc )( Args... args ), 
        K* pInstance ) 
    {
        std::function<void( Args... )> f = std::bind( pMemberFunc, 
            pInstance, 
            placeholderpack<Idcs>{}... );
        m_fn.emplace_back( f );
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x2c06
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2c4e
movq %rsp, %rdi
callq 0x2a86
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2a86
movq %rbx, %rdi
callq 0x2160
// File: /workspace/github_cpp_makefile_star2_O2/jandoerntlein[P]wire/src/wire.h
// Function: void wire::DirectWire<>::connect_helper<Light>(std::integer_sequence<int, ...>, unsigned int, void (Light::*)(), Light*)
inline void connect_helper( std::integer_sequence<int, Idcs...>,  
        unsigned int idx, 
        void ( K::* pMemberFunc )( Args... args ), 
        K* pInstance ) 
    {
        std::function<void( Args... )> f = std::bind( pMemberFunc, 
            pInstance, 
            placeholderpack<Idcs>{}... );
        m_fn.emplace( idx, f );
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x4(%rsp), %r14
movl %esi, (%r14)
leaq 0x28(%rsp), %rsi
movq %rdx, (%rsi)
movq %rcx, 0x8(%rsi)
movq %r8, 0x10(%rsi)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2c06
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x39dc
leaq 0x8(%rsp), %rdi
callq 0x2a86
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2a86
movq %rbx, %rdi
callq 0x2160
// File: /workspace/github_cpp_makefile_star2_O2/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
andl $0x0, 0x7a85(%rip)      # 0xb200
movl %edi, %ebx
movl %edi, %eax
shlq $0x2, %rax
xorl %r14d, %r14d
testl %edi, %edi
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
cmovlel %r14d, %ebx
callq 0x2030
movq %rax, 0x7a51(%rip)      # 0xb1f0
movabsq $0x430c6bf526340000, %rcx # imm = 0x430C6BF526340000
movq %rcx, 0x7a48(%rip)      # 0xb1f8
cmpq %r14, %rbx
je 0x37bf
orl $-0x1, (%rax,%r14,4)
incq %r14
jmp 0x37b0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x7a33(%rip), %eax      # 0xb200
leal 0x1(%rax), %esi
movl %esi, 0x7a2a(%rip)      # 0xb200
movl 0x79fc(%rip), %esi      # 0xb1d8
cmpl %esi, %eax
jl 0x380e
movsd 0x7a10(%rip), %xmm0     # 0xb1f8
movsd %xmm0, (%rcx)
movq 0x79fd(%rip), %rcx      # 0xb1f0
xorl %r8d, %r8d
testl %edi, %edi
cmovlel %r8d, %edi
cmpq %r8, %rdi
je 0x3851
movl (%rcx,%r8,4), %r9d
movl %r9d, (%rdx,%r8,4)
incq %r8
jmp 0x37fc
movsd (%rcx), %xmm0
movsd 0x79de(%rip), %xmm1     # 0xb1f8
ucomisd %xmm0, %xmm1
jbe 0x3851
andl $0x0, 0x79d9(%rip)      # 0xb200
movq 0x79c2(%rip), %rcx      # 0xb1f0
xorl %r8d, %r8d
testl %edi, %edi
cmovlel %r8d, %edi
cmpq %r8, %rdi
je 0x3849
movl (%rdx,%r8,4), %r9d
movl %r9d, (%rcx,%r8,4)
incq %r8
jmp 0x3837
movsd %xmm0, 0x79a7(%rip)     # 0xb1f8
cmpl %esi, %eax
setge %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
xorpd %xmm0, %xmm0
cmpq %rax, %rdx
je 0x4294
movsd (%rdi,%rax,8), %xmm1
subsd (%r8,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x4277
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %edx, %r14d
movq %rdi, %r15
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %r14d
xorpd %xmm0, %xmm0
cmpq %rax, %r14
je 0x42c4
addsd (%rbx,%rax,8), %xmm0
incq %rax
jmp 0x42b5
xorpd %xmm1, %xmm1
xorl %r12d, %r12d
movsd %xmm0, (%rsp)
cmpq %r12, %r14
je 0x4318
movsd (%rbx,%r12,8), %xmm2
movsd %xmm2, 0x8(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd (%r15,%r12,8), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm2, %xmm0
divsd %xmm1, %xmm0
callq 0x2180
movsd 0x10(%rsp), %xmm1
mulsd 0x8(%rsp), %xmm0
addsd %xmm0, %xmm1
movsd (%rsp), %xmm0
incq %r12
jmp 0x42d0
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movl %edx, %r14d
movq %rdi, %r15
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %r14d
xorpd %xmm0, %xmm0
cmpq %rax, %r14
je 0x4357
addsd (%rbx,%rax,8), %xmm0
incq %rax
jmp 0x4348
movapd 0x37c1(%rip), %xmm1     # 0x7b20
movapd %xmm0, 0x20(%rsp)
xorpd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
xorpd %xmm0, %xmm0
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x43cd
movsd %xmm0, (%rsp)
movsd (%rbx,%r12,8), %xmm0
movsd (%r15,%r12,8), %xmm1
movapd 0x10(%rsp), %xmm2
mulsd %xmm1, %xmm2
addsd %xmm0, %xmm2
movsd %xmm2, 0x8(%rsp)
mulsd 0x20(%rsp), %xmm1
divsd %xmm1, %xmm0
callq 0x2180
mulsd 0x8(%rsp), %xmm0
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movsd (%rsp), %xmm0
incq %r12
jmp 0x4376
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %r8, %rbx
movl %edx, %r14d
movq %rdi, %r15
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %r14d
xorpd %xmm0, %xmm0
cmpq %rax, %r14
je 0x440a
movsd (%rbx,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x43f3
xorpd %xmm2, %xmm2
ucomisd %xmm2, %xmm0
jb 0x441a
sqrtsd %xmm0, %xmm0
jmp 0x4423
callq 0x2170
xorpd %xmm2, %xmm2
xorl %eax, %eax
cmpq %rax, %r14
je 0x4442
movsd (%r15,%rax,8), %xmm1
mulsd (%rbx,%rax,8), %xmm1
divsd %xmm0, %xmm1
addsd %xmm1, %xmm2
incq %rax
jmp 0x4425
movsd 0x2bbe(%rip), %xmm0     # 0x7008
subsd %xmm2, %xmm0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
xorpd %xmm1, %xmm1
cmpq %rax, %rdx
je 0x446f
addsd (%r8,%rax,8), %xmm1
incq %rax
jmp 0x445f
xorpd %xmm0, %xmm0
xorl %eax, %eax
cmpq %rax, %rdx
je 0x449e
movsd (%rdi,%rax,8), %xmm2
mulsd %xmm1, %xmm2
movsd (%r8,%rax,8), %xmm3
subsd %xmm2, %xmm3
mulsd %xmm3, %xmm3
divsd %xmm2, %xmm3
addsd %xmm3, %xmm0
incq %rax
jmp 0x4475
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %r9, %r15
movq %rcx, -0x30(%rbp)
movq %rsi, %r13
movq %rdi, %r12
movl %edx, %eax
movq %rsp, %r14
leaq 0xf(,%rax,8), %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
movslq %edx, %rbx
leaq (,%rbx,8), %rdx
movq %r14, %rdi
movq %r8, %rsi
callq 0x2190
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
xorpd %xmm2, %xmm2
cmpq %rax, %rbx
je 0x4506
addsd (%r13,%rax,8), %xmm2
incq %rax
jmp 0x44f5
movq 0x10(%rbp), %rax
testq %rax, %rax
cmovneq %rax, %r12
xorpd 0x3607(%rip), %xmm2     # 0x7b20
xorpd %xmm4, %xmm4
xorl %r13d, %r13d
xorpd %xmm3, %xmm3
movapd %xmm2, -0x50(%rbp)
cmpq %r13, %rbx
je 0x4595
movsd (%r12,%r13,8), %xmm0
movsd (%r15,%r13,8), %xmm1
movapd %xmm0, %xmm5
mulsd %xmm2, %xmm5
mulsd %xmm1, %xmm5
addsd (%r14,%r13,8), %xmm5
mulsd %xmm1, %xmm0
ucomisd %xmm4, %xmm0
jb 0x455c
sqrtsd %xmm0, %xmm0
jmp 0x457e
movsd %xmm3, -0x40(%rbp)
movsd %xmm5, -0x38(%rbp)
callq 0x2170
movsd -0x38(%rbp), %xmm5
xorpd %xmm4, %xmm4
movsd -0x40(%rbp), %xmm3
movapd -0x50(%rbp), %xmm2
divsd %xmm0, %xmm5
movsd %xmm5, (%r14,%r13,8)
mulsd %xmm5, %xmm5
addsd %xmm5, %xmm3
incq %r13
jmp 0x4529
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm3
jb 0x45a5
sqrtsd %xmm3, %xmm0
jmp 0x45ae
movapd %xmm3, %xmm0
callq 0x2170
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq %rax, %rbx
je 0x45ce
movsd (%r14,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%r14,%rax,8)
incq %rax
jmp 0x45b4
xorpd %xmm1, %xmm1
xorl %eax, %eax
cmpq %rax, %rbx
je 0x45ed
movsd (%r14,%rax,8), %xmm0
mulsd (%rcx,%rax,8), %xmm0
addsd %xmm0, %xmm1
incq %rax
jmp 0x45d4
movsd 0x2a13(%rip), %xmm0     # 0x7008
subsd %xmm1, %xmm0
mulsd 0x3637(%rip), %xmm0     # 0x7c38
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %rbx
movl %edi, %ebp
movq 0x38(%rsp), %r15
movslq %esi, %r14
leaq (,%r14,8), %rdx
xorl %r12d, %r12d
movq %r9, %rdi
xorl %esi, %esi
callq 0x2130
testl %r14d, %r14d
cmovlel %r12d, %r14d
testl %ebp, %ebp
movl $0x0, %eax
cmovgl %ebp, %eax
cmpq %rax, %r12
je 0x4674
xorl %ecx, %ecx
cmpq %rcx, %r14
je 0x466f
movq (%r15,%r12,8), %rdx
movsd (%rdx,%rcx,8), %xmm0
addsd (%rbx,%rcx,8), %xmm0
movsd %xmm0, (%rbx,%rcx,8)
incq %rcx
jmp 0x4652
incq %r12
jmp 0x464b
cvtsi2sd %ebp, %xmm0
xorl %eax, %eax
cmpq %rax, %r14
je 0x4692
movsd (%rbx,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%rax,8)
incq %rax
jmp 0x467a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %rbx
movl %edi, %r14d
movq 0x38(%rsp), %r12
movslq %esi, %r15
leaq (,%r15,8), %rdx
xorl %r13d, %r13d
movq %r9, %rdi
xorl %esi, %esi
callq 0x2130
testl %r15d, %r15d
cmovlel %r13d, %r15d
testl %r14d, %r14d
cmovlel %r13d, %r14d
cmpq %r14, %r13
je 0x46fe
xorl %eax, %eax
cmpq %rax, %r15
je 0x46f9
movq (%r12,%r13,8), %rcx
movsd (%rcx,%rax,8), %xmm0
addsd (%rbx,%rax,8), %xmm0
movsd %xmm0, (%rbx,%rax,8)
incq %rax
jmp 0x46dc
incq %r13
jmp 0x46d5
xorpd %xmm0, %xmm0
xorl %eax, %eax
cmpq %rax, %r15
je 0x471b
movsd (%rbx,%rax,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rax
jmp 0x4704
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x472b
sqrtsd %xmm0, %xmm0
jmp 0x4730
callq 0x2170
xorl %eax, %eax
cmpq %rax, %r15
je 0x474a
movsd (%rbx,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%rax,8)
incq %rax
jmp 0x4732
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %rbx
movl %edi, %r14d
movq 0x38(%rsp), %r12
movslq %esi, %r15
leaq (,%r15,8), %rdx
xorl %r13d, %r13d
movq %r9, %rdi
xorl %esi, %esi
callq 0x2130
testl %r15d, %r15d
cmovlel %r13d, %r15d
testl %r14d, %r14d
cmovlel %r13d, %r14d
cmpq %r14, %r13
je 0x47b7
xorl %eax, %eax
cmpq %rax, %r15
je 0x47b2
movq (%r12,%r13,8), %rcx
movsd (%rcx,%rax,8), %xmm0
addsd (%rbx,%rax,8), %xmm0
movsd %xmm0, (%rbx,%rax,8)
incq %rax
jmp 0x4795
incq %r13
jmp 0x478e
xorpd %xmm0, %xmm0
xorl %eax, %eax
cmpq %rax, %r15
je 0x47cc
addsd (%rbx,%rax,8), %xmm0
incq %rax
jmp 0x47bd
xorl %eax, %eax
cmpq %rax, %r15
je 0x47e6
movsd (%rbx,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%rax,8)
incq %rax
jmp 0x47ce
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, %r13d
movq %rdi, 0x28(%rsp)
movq 0xa0(%rsp), %rax
movq 0x88(%rsp), %rbp
movq 0x80(%rsp), %rbx
movq %rax, 0x20(%rsp)
callq 0x47f0
movslq %r13d, %r13
leaq (,%r13,8), %rdx
xorl %r12d, %r12d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2130
movq 0x28(%rsp), %rdx
testl %r13d, %r13d
cmovlel %r12d, %r13d
testl %edx, %edx
cmovlel %r12d, %edx
xorpd %xmm2, %xmm2
cmpq %rdx, %r12
je 0x49cb
xorl %eax, %eax
cmpq %rax, %r13
je 0x49c6
movq (%rbp,%r12,8), %rcx
movsd (%rcx,%rax,8), %xmm0
addsd (%rbx,%rax,8), %xmm0
movsd %xmm0, (%rbx,%rax,8)
movq (%r15,%r12,8), %rcx
addsd (%rcx,%rax,8), %xmm2
incq %rax
jmp 0x499f
incq %r12
jmp 0x4998
movq 0xa0(%rsp), %rax
testq %rax, %rax
cmovneq %rax, %r14
xorpd 0x313e(%rip), %xmm2     # 0x7b20
xorpd %xmm4, %xmm4
xorl %r15d, %r15d
xorpd %xmm3, %xmm3
movq 0x90(%rsp), %r12
movapd %xmm2, 0x30(%rsp)
cmpq %r15, %r13
je 0x4a6c
movsd (%r14,%r15,8), %xmm0
mulsd %xmm2, %xmm0
mulsd (%r12,%r15,8), %xmm0
addsd (%rbx,%r15,8), %xmm0
movsd %xmm0, (%rbx,%r15,8)
movsd (%r14,%r15,8), %xmm0
mulsd (%r12,%r15,8), %xmm0
ucomisd %xmm4, %xmm0
jb 0x4a34
sqrtsd %xmm0, %xmm0
jmp 0x4a4f
movsd %xmm3, 0x28(%rsp)
callq 0x2170
xorpd %xmm4, %xmm4
movsd 0x28(%rsp), %xmm3
movapd 0x30(%rsp), %xmm2
movsd (%rbx,%r15,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%r15,8)
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm3
incq %r15
jmp 0x49fb
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm3
jb 0x4a7c
sqrtsd %xmm3, %xmm0
jmp 0x4a85
movapd %xmm3, %xmm0
callq 0x2170
xorl %eax, %eax
cmpq %rax, %r13
je 0x4a9f
movsd (%rbx,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rbx,%rax,8)
incq %rax
jmp 0x4a87
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
xorpd %xmm0, %xmm0
cmpq %rax, %rsi
je 0x4aca
addsd (%rdi,%rax,8), %xmm0
incq %rax
jmp 0x4abb
xorl %eax, %eax
cmpq %rax, %rsi
je 0x4ae4
movsd (%rdi,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rdi,%rax,8)
incq %rax
jmp 0x4acc
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
testl %edx, %edx
cmovlel %eax, %edx
xorpd %xmm0, %xmm0
cmpq %rax, %rdx
je 0x4aff
addsd (%rdi,%rax,8), %xmm0
incq %rax
jmp 0x4af0
xorl %eax, %eax
cmpq %rax, %rdx
je 0x4b19
movsd (%rsi,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rsi,%rax,8)
incq %rax
jmp 0x4b01
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %ecx, %ecx
testl %edx, %edx
movl $0x0, %eax
cmovgl %edx, %eax
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
cmpq %rcx, %rax
je 0x4b42
addsd (%rdi,%rcx,8), %xmm0
addsd (%rsi,%rcx,8), %xmm1
incq %rcx
jmp 0x4b2e
subsd %xmm1, %xmm0
cvtsi2sd %edx, %xmm1
divsd %xmm1, %xmm0
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x4b68
movsd (%rsi,%rcx,8), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsi,%rcx,8)
incq %rcx
jmp 0x4b50
retq
// File: /workspace/github_cpp_makefile_star2_O2/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)
xorl %eax, %eax
testl %edi, %edi
cmovlel %eax, %edi
cmpq %rdi, %rax
je 0x5322
movq (%r8,%rax,8), %rdx
xorl %r9d, %r9d
cmpq $0x4, %r9
je 0x531d
movsd (%rdx,%r9,8), %xmm0
addsd -0x28(%rsp,%r9,8), %xmm0
movsd %xmm0, -0x28(%rsp,%r9,8)
incq %r9
jmp 0x52fe
incq %rax
jmp 0x52f2
xorpd %xmm0, %xmm0
xorl %eax, %eax
cmpq $0x4, %rax
je 0x5339
addsd -0x28(%rsp,%rax,8), %xmm0
incq %rax
jmp 0x5328
xorl %eax, %eax
cmpq $0x4, %rax
je 0x5356
movsd -0x28(%rsp,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, -0x28(%rsp,%rax,8)
incq %rax
jmp 0x533b
xorl %edi, %edi
testl %esi, %esi
movl $0x0, %r8d
cmovgl %esi, %r8d
movl $0x1, %r9d
movsd 0x1c96(%rip), %xmm0     # 0x7008
cmpq %r8, %rdi
je 0x53a3
movapd %xmm0, %xmm1
movl %r9d, %r10d
cmpl %esi, %r10d
jge 0x5399
movl %edi, %eax
xorl %edx, %edx
divl %r10d
andl $0x3, %eax
mulsd -0x28(%rsp,%rax,8), %xmm1
shll $0x2, %r10d
jmp 0x537e
movsd %xmm1, (%rcx,%rdi,8)
incq %rdi
jmp 0x5372
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
xorl %eax, %eax
testl %edi, %edi
cmovlel %eax, %edi
testl %edx, %edx
cmovlel %eax, %edx
xorl %esi, %esi
cvtsi2sd %esi, %xmm0
cmpq %rdx, %rax
je 0x53ec
andq $0x0, (%rcx,%rax,8)
xorpd %xmm1, %xmm1
xorl %esi, %esi
cmpq %rsi, %rdi
je 0x53df
movq (%r8,%rsi,8), %r9
addsd (%r9,%rax,8), %xmm1
movsd %xmm1, (%rcx,%rax,8)
incq %rsi
jmp 0x53c6
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %esi
incq %rax
jmp 0x53b2
xorl %eax, %eax
cmpq %rax, %rdx
je 0x5406
movsd (%rcx,%rax,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rcx,%rax,8)
incq %rax
jmp 0x53ee
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %ecx, %ebx
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
cvtsi2sd %edx, %xmm3
movl %edx, %eax
imull %edx, %eax
cvtsi2sd %eax, %xmm0
unpcklpd %xmm0, %xmm3            # xmm3 = xmm3[0],xmm0[0]
xorl %r13d, %r13d
testl %edx, %edx
cmovlel %r13d, %r14d
testl %ecx, %ecx
cmovlel %r13d, %ebx
xorpd %xmm4, %xmm4
movapd %xmm3, 0x10(%rsp)
cmpq %rbx, %r13
je 0x556d
xorpd %xmm5, %xmm5
xorpd %xmm6, %xmm6
xorl %eax, %eax
xorpd %xmm1, %xmm1
cmpq %rax, %r14
je 0x5492
movq (%r12,%rax,8), %rcx
movsd (%rcx,%r13,8), %xmm0
addsd %xmm0, %xmm1
movq (%r15,%rax,8), %rcx
movsd (%rcx,%r13,8), %xmm2
unpcklpd %xmm2, %xmm0            # xmm0 = xmm0[0],xmm2[0]
mulpd %xmm0, %xmm0
addpd %xmm0, %xmm5
addsd %xmm2, %xmm6
incq %rax
jmp 0x5460
mulsd %xmm1, %xmm1
movapd %xmm5, %xmm0
unpcklpd %xmm1, %xmm0            # xmm0 = xmm0[0],xmm1[0]
divpd %xmm3, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
subsd %xmm1, %xmm0
ucomisd %xmm4, %xmm0
jb 0x54ba
sqrtsd %xmm0, %xmm2
jmp 0x54e3
movapd %xmm5, (%rsp)
movapd %xmm6, 0x20(%rsp)
callq 0x2170
movapd 0x20(%rsp), %xmm6
movapd (%rsp), %xmm5
xorpd %xmm4, %xmm4
movapd 0x10(%rsp), %xmm3
movapd %xmm0, %xmm2
mulsd %xmm6, %xmm6
shufpd $0x1, %xmm6, %xmm5      # xmm5 = xmm5[1],xmm6[0]
divpd %xmm3, %xmm5
movapd %xmm5, %xmm0
unpckhpd %xmm5, %xmm0            # xmm0 = xmm0[1],xmm5[1]
subsd %xmm0, %xmm5
ucomisd %xmm4, %xmm5
jb 0x5508
sqrtsd %xmm5, %xmm0
jmp 0x5525
movapd %xmm5, %xmm0
movsd %xmm2, (%rsp)
callq 0x2170
movsd (%rsp), %xmm2
xorpd %xmm4, %xmm4
movapd 0x10(%rsp), %xmm3
ucomisd %xmm4, %xmm2
jbe 0x5565
ucomisd %xmm4, %xmm0
jbe 0x5565
xorl %eax, %eax
cmpq %rax, %r14
je 0x5565
movq (%r12,%rax,8), %rcx
movsd (%rcx,%r13,8), %xmm1
divsd %xmm2, %xmm1
movsd %xmm1, (%rcx,%r13,8)
movq (%r15,%rax,8), %rcx
movsd (%rcx,%r13,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rcx,%r13,8)
incq %rax
jmp 0x5533
incq %r13
jmp 0x5449
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
pushq $0x1
popq %r15
cmpq 0x8(%rbx), %r14
jae 0x5d54
movq (%rbx), %rax
movsbl (%rax,%r14), %edi
callq 0x2040
testl %eax, %eax
je 0x5d4f
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2080
jmp 0x5d28
incq %r14
jmp 0x5d28
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/CominLab[P]QCluster/seqio.cc
// Function: FastqRead(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<SeqRecord, std::allocator<SeqRecord>>&)
void FastqRead(string fname, vector<SeqRecord>& recs)
{
	int N = CountReads(fname);
	RecordGenerator rec_gen(fname);
	for (int i=0; i<N; i++) {
		recs.push_back(rec_gen.next());
	}
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x310, %rsp            # imm = 0x310
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2270
movq %r15, %rdi
callq 0x5e6c
movl %eax, %ebp
leaq 0x20(%rsp), %rdi
callq 0x20f0
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2270
leaq 0xc0(%rsp), %rdi
movq %r15, %rsi
callq 0x5958
movq %rsp, %rdi
callq 0x20f0
xorl %r12d, %r12d
testl %ebp, %ebp
cmovgl %ebp, %r12d
leaq 0x40(%rsp), %r14
leaq 0xc0(%rsp), %r15
subl $0x1, %r12d
jb 0x5e11
movq %r14, %rdi
movq %r15, %rsi
callq 0x59fa
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5f68
movq %r14, %rdi
callq 0x5674
jmp 0x5deb
leaq 0xc0(%rsp), %rdi
callq 0x59d4
addq $0x310, %rsp            # imm = 0x310
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
jmp 0x5e3e
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x20f0
jmp 0x5e64
movq %rax, %rbx
jmp 0x5e57
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x5674
leaq 0xc0(%rsp), %rdi
callq 0x59d4
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O2/CominLab[P]QCluster/seqio.cc
// Function: CountReads(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int CountReads(string fname)
{
	int num_reads = 0;
	int indice_riga = 0;
	string line="";
	
	ifstream ifs(fname.c_str());
	
	//Skip rows until first "@" character
	while (ifs.good() && (!line.length() || line[0] != '@')) {
		getline(ifs, line);
	}
	
	while (ifs.good()) {
		indice_riga = (indice_riga+1) % 4;
		if (indice_riga % 4 == 0) num_reads++;	//Couno 1 read every 4 row
		getline(ifs, line);
	}
	
	return num_reads;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rdi, %rbx
leaq 0x1c41(%rip), %rsi      # 0x7ac6
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x35b0
movq (%rbx), %rsi
leaq 0x28(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x2350
leaq 0x28(%rsp), %rbx
leaq 0x8(%rsp), %r14
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x48(%rsp,%rax)
jne 0x5edd
cmpq $0x0, 0x10(%rsp)
je 0x5ed0
movq 0x8(%rsp), %rax
cmpb $0x40, (%rax)
je 0x5edd
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2060
jmp 0x5eae
xorl %ebx, %ebx
pushq $0x4
popq %r12
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %r15
xorl %ebp, %ebp
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x48(%rsp,%rax)
jne 0x5f1c
incl %ebp
movl %ebp, %eax
cltd
idivl %r12d
movl %edx, %ebp
cmpl $0x1, %edx
adcl $0x0, %ebx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2060
jmp 0x5eef
leaq 0x28(%rsp), %rdi
callq 0x2090
leaq 0x8(%rsp), %rdi
callq 0x20f0
movl %ebx, %eax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x5f56
jmp 0x5f49
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2090
leaq 0x8(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2320
// File: /workspace/github_cpp_makefile_star2_O2/iZhangHui[P]CppPrimer/CH11_AssociativeContainers/examples/word_count.cc
// Function: main
int main()
{
	// count the number of times each word occurs in the input
	map<string, size_t> word_count; // empty map from string to size_t
	string word;
	while (cin >> word)
		++word_count[word];

	for (const auto& w : word_count)
		cout <<  w.first << " occurs " << w.second << " times" << endl;

	// get an iterator positioned on the first element
	auto map_it = word_count.cbegin();
	// compare the current iterator to the off-the-end iterator
	while (map_it != word_count.cend()) {
		// dereference the iterator to print the element key--value pairs
		cout << map_it->first << " occurs "
			 << map_it->second << " times" << endl;
		++map_it;  // increment the iterator to denote the next element
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
leaq -0x70(%rbp), %r13
andl $0x0, (%r13)
andq $0x0, 0x8(%r13)
movq %r13, 0x10(%r13)
movq %r13, 0x18(%r13)
andq $0x0, 0x20(%r13)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x2cc1(%rip), %rbx      # 0x4fe0
leaq -0x48(%rbp), %r14
leaq -0x78(%rbp), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2140
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2350
movq %r15, %rdi
movq %r14, %rsi
callq 0x245a
incq (%rax)
jmp 0x2327
movq -0x60(%rbp), %r12
movq 0x2c75(%rip), %rbx      # 0x4fd0
leaq 0xca2(%rip), %r14       # 0x3004
leaq 0xca4(%rip), %r15       # 0x300d
cmpq %r13, %r12
je 0x23b3
leaq 0x20(%r12), %rsi
movq %rbx, %rdi
callq 0x20e0
movq %rax, %rdi
movq %r14, %rsi
callq 0x20f0
movq 0x40(%r12), %rsi
movq %rax, %rdi
callq 0x20a0
movq %rax, %rdi
movq %r15, %rsi
callq 0x20f0
movq %rax, %rdi
callq 0x2090
movq %r12, %rdi
callq 0x20b0
movq %rax, %r12
jmp 0x2369
movq -0x60(%rbp), %r12
movq 0x2c12(%rip), %rbx      # 0x4fd0
leaq 0xc3f(%rip), %r14       # 0x3004
leaq 0xc41(%rip), %r15       # 0x300d
cmpq %r13, %r12
je 0x2416
leaq 0x20(%r12), %rsi
movq %rbx, %rdi
callq 0x20e0
movq %rax, %rdi
movq %r14, %rsi
callq 0x20f0
movq 0x40(%r12), %rsi
movq %rax, %rdi
callq 0x20a0
movq %rax, %rdi
movq %r15, %rsi
callq 0x20f0
movq %rax, %rdi
callq 0x2090
movq %r12, %rdi
callq 0x2130
movq %rax, %r12
jmp 0x23cc
leaq -0x48(%rbp), %rdi
callq 0x2080
leaq -0x78(%rbp), %rdi
callq 0x24d2
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x243d
jmp 0x243d
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2080
leaq -0x78(%rbp), %rdi
callq 0x24d2
movq %rbx, %rdi
callq 0x2190
// File: /workspace/github_cpp_makefile_star2_O2/MPSLab-ASU[P]DiRAC/./src/baseAccelSim.cc
// Function: baseAccelSim::read_inputs()
void baseAccelSim::read_inputs()
{
	read_file_kernels(kernelFileName);
	set_kernel_parameters();
	readArchSpec(archSpecFileName);
	readConfig(configFileName);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
leaq 0x203c64(%rip), %rsi    # 0x608800
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x4931c0
movq %rbx, %rsi
callq 0x404c2c
leaq 0x48(%rsp), %rdi
callq 0x490a30
callq 0x404e12
leaq 0x203c19(%rip), %rsi    # 0x6087e0
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x4931c0
movq %rbx, %rsi
callq 0x4050dc
leaq 0x28(%rsp), %rdi
callq 0x490a30
leaq 0x203bd3(%rip), %rsi    # 0x6087c0
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x4931c0
movq %rbx, %rsi
callq 0x405aaa
leaq 0x8(%rsp), %rdi
callq 0x490a30
addq $0x68, %rsp
popq %rbx
popq %r14
retq
jmp 0x404c18
jmp 0x404c18
movq %rax, %r14
movq %rbx, %rdi
callq 0x490a30
movq %r14, %rdi
callq 0x4bea70
nop
// File: /workspace/github_cpp_makefile_star2_O2/MPSLab-ASU[P]DiRAC/./src/baseAccelSim.cc
// Function: baseAccelSim::read_file_kernels(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void baseAccelSim::read_file_kernels(string kernelFileName) {
	string key, value;
	uint16_t it=0;

	ifstream inFile(kernelFileName.c_str());
	if(!inFile)
	{
		cout << "Cannot open and read file: " << kernelFileName.c_str() << endl;
		exit (EXIT_FAILURE);
	}

	string line;
 	while (getline(inFile, line)) {
		// skip reading first two lines of the file
		if(it < 2) {
			it++; continue;
		}
		istringstream tokenStream(line);
		tokenStream >> key >> value;
		kernels.push_back(value);
		nameOfKernels.push_back(key);
		it++;
	}
	inFile.close();

	assert(kernels.size() > 0 && "No bytes of the kernels in the file ");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3e8, %rsp            # imm = 0x3E8
movq %rsi, %rbx
leaq 0x50(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
leaq 0x30(%rsp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
xorl %edx, %edx
movb %dl, (%rax)
movb %dl, (%rcx)
movq (%rsi), %rsi
leaq 0x60(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x45cbc0
movq 0x60(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x80(%rsp,%rax)
jne 0x404d75
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %ebp, %ebp
leaq 0x60(%rsp), %rbx
movq %rsp, %r14
leaq 0x268(%rsp), %r15
leaq 0x40(%rsp), %r12
leaq 0x20(%rsp), %r13
movq %rbx, %rdi
movq %r14, %rsi
callq 0x493470
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x404d23
cmpw $0x1, %bp
jbe 0x404d1f
movq %r15, %rdi
movq %r14, %rsi
pushq $0x8
popq %rdx
callq 0x488420
movq %r15, %rdi
movq %r12, %rsi
callq 0x415af0
movq %rax, %rdi
movq %r13, %rsi
callq 0x415af0
leaq 0x203890(%rip), %rdi    # 0x608590
movq %r13, %rsi
callq 0x40a2a0
leaq 0x203869(%rip), %rdi    # 0x608578
movq %r12, %rsi
callq 0x40a2a0
movq %r15, %rdi
callq 0x485d10
incl %ebp
jmp 0x404cb6
leaq 0x60(%rsp), %rdi
callq 0x45d170
movq 0x203864(%rip), %rax    # 0x608598
cmpq 0x203855(%rip), %rax    # 0x608590
je 0x404da3
movq %rsp, %rdi
callq 0x490a30
leaq 0x60(%rsp), %rdi
callq 0x45d520
leaq 0x20(%rsp), %rdi
callq 0x490a30
leaq 0x40(%rsp), %rdi
callq 0x490a30
addq $0x3e8, %rsp            # imm = 0x3E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq $0x609900, %rdi         # imm = 0x609900
leaq 0x18b29d(%rip), %rsi    # 0x590020
callq 0x480750
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x480750
movq %rax, %rdi
callq 0x480030
pushq $0x1
popq %rdi
callq 0x4da4e0
leaq 0x18b292(%rip), %rdi    # 0x59003c
leaq 0x18b2c8(%rip), %rsi    # 0x590079
leaq 0x18b2d7(%rip), %rcx    # 0x59008f
pushq $0x35
popq %rdx
callq 0x4d36d0
movq %rax, %rbx
jmp 0x404deb
jmp 0x404dce
movq %rax, %rbx
jmp 0x404df5
jmp 0x404dce
movq %rax, %rbx
jmp 0x404de3
movq %rax, %rbx
leaq 0x268(%rsp), %rdi
callq 0x485d10
movq %rsp, %rdi
callq 0x490a30
leaq 0x60(%rsp), %rdi
callq 0x45d520
leaq 0x20(%rsp), %rdi
callq 0x490a30
leaq 0x40(%rsp), %rdi
callq 0x490a30
movq %rbx, %rdi
callq 0x4bea70
nop
// File: /workspace/github_cpp_makefile_star2_O2/MPSLab-ASU[P]DiRAC/./src/baseAccelSim.cc
// Function: baseAccelSim::read_data_operand(unsigned char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void baseAccelSim::read_data_operand(uint8_t op, string fileName) {
	ifstream inFile(fileName.c_str());
	if(!inFile)
	{
		cout << "Cannot open and read file: " << fileName.c_str() << endl;
		exit (EXIT_FAILURE);
	}

	for(int i=0; i < size_tensors[op]; i++) {
		inFile >> tensor_operands[op][i];
	}
	inFile.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdx, %rbx
movl %esi, %ebp
movq (%rdx), %rsi
leaq 0x8(%rsp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x45cbc0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
jne 0x407068
movzbl %bpl, %r14d
xorl %r15d, %r15d
leaq 0x8(%rsp), %rbx
xorl %r12d, %r12d
movq 0x201551(%rip), %rax    # 0x608570
cmpq %r12, (%rax,%r14,8)
jbe 0x407044
movq 0x201534(%rip), %rax    # 0x608560
movq (%rax,%r14,8), %rsi
addq %r15, %rsi
movq %rbx, %rdi
callq 0x4665c0
incq %r12
addq $0x2, %r15
jmp 0x407018
leaq 0x8(%rsp), %rdi
callq 0x45d170
leaq 0x8(%rsp), %rdi
callq 0x45d520
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq $0x609900, %rdi         # imm = 0x609900
leaq 0x188faa(%rip), %rsi    # 0x590020
callq 0x480750
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x480750
movq %rax, %rdi
callq 0x480030
pushq $0x1
popq %rdi
callq 0x4da4e0
jmp 0x407098
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x45d520
movq %rbx, %rdi
callq 0x4bea70
nop
// File: /workspace/github_cpp_makefile_star2_O2/MPSLab-ASU[P]DiRAC/./src/baseAccelSim.cc
// Function: baseAccelSim::write_data_operand(unsigned char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void baseAccelSim::write_data_operand(uint8_t op, string fileName)
{
	std::ofstream outFile;
  outFile.open (fileName.c_str(), std::ofstream::out | std::ofstream::trunc);

	for(uint64_t idx = 0; idx < size_tensors[op]; idx++)
    outFile << tensor_operands[op][idx] << "\n";

	outFile.close();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdx, %r14
movl %esi, %ebx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x45b830
movq (%r14), %rsi
pushq $0x30
popq %rdx
movq %r15, %rdi
callq 0x45c150
movzbl %bl, %r15d
xorl %r12d, %r12d
leaq 0x8(%rsp), %rbx
leaq 0x192c15(%rip), %r14    # 0x599e4a
movq 0x201334(%rip), %rax    # 0x608570
cmpq (%rax,%r15,8), %r12
jae 0x40726a
movq 0x201317(%rip), %rax    # 0x608560
movq (%rax,%r15,8), %rax
movzwl (%rax,%r12,2), %esi
movq %rbx, %rdi
callq 0x480d70
movq %rax, %rdi
movq %r14, %rsi
callq 0x480750
incq %r12
jmp 0x407235
leaq 0x8(%rsp), %rdi
callq 0x45d1b0
leaq 0x8(%rsp), %rdi
callq 0x45d3e0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x40728f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x45d3e0
movq %rbx, %rdi
callq 0x4bea70