LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/mirkat1206[P]Quine-McCluskey-Petrick-Method/Petrick_Method.cpp
// Function: Petrick_Method::Print_SOP()
void Petrick_Method::Print_SOP() {
	cout<<"Sum of Product = "<< endl;
	int size = SOP.size() ;
	for( int i=0 ; i<size ; i++ ) {
		iter = SOP[i].begin() ;
		cout<<"("<< *iter <<")";
		for( iter++ ; iter!=SOP[i].end() ; iter++ )
			cout<<"("<< *iter <<")";
		cout<< endl;
	}
	cout<< endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0x69e9(%rip), %rbx      # 0xcfd0
leaq 0x2bde(%rip), %rsi      # 0x91cc
movl $0x11, %edx
movq %rbx, %rdi
callq 0x2210
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x20(%r14), %rax
subq 0x18(%r14), %rax
sarq $0x4, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
movq %rcx, -0x30(%rbp)
testl %ecx, %ecx
jle 0x6779
movq -0x30(%rbp), %rax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq %rax, -0x30(%rbp)
xorl %ecx, %ecx
leaq 0x2b80(%rip), %r15      # 0x91de
leaq 0x2b65(%rip), %r12      # 0x91ca
movq 0x18(%r14), %rax
movq %rcx, -0x38(%rbp)
shlq $0x4, %rcx
leaq (%rcx,%rcx,2), %r13
movq 0x18(%rax,%r13), %rax
movq %rax, 0x6b37(%rip)      # 0xd1b8
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2210
movq 0x6b20(%rip), %rax      # 0xd1b8
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
movq %rbx, %rdi
callq 0x2210
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2210
movq 0x6af9(%rip), %rdi      # 0xd1b8
callq 0x2220
movq %rax, 0x6aed(%rip)      # 0xd1b8
movq 0x18(%r14), %rcx
addq %r13, %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
je 0x6741
movq -0x38(%rbp), %rax
leaq (%rax,%rax,2), %r13
shlq $0x4, %r13
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2210
movq 0x6aba(%rip), %rax      # 0xd1b8
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
movq %rbx, %rdi
callq 0x2210
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2210
movq 0x6a93(%rip), %rdi      # 0xd1b8
callq 0x2220
movq %rax, 0x6a87(%rip)      # 0xd1b8
movq 0x18(%r14), %rcx
addq %r13, %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
jne 0x66e7
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq -0x38(%rbp), %rcx
incq %rcx
cmpq -0x30(%rbp), %rcx
jne 0x6665
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O3/mirkat1206[P]Quine-McCluskey-Petrick-Method/Petrick_Method.cpp
// Function: Petrick_Method::Print_FewestTerm_P()
void Petrick_Method::Print_FewestTerm_P() {
	int min_cover = SOP[0].size() ;
	for( int i=0 ; SOP[i].size()==min_cover ; i++ ) {
		cout<<"Answer "<< i+1 <<" : "<< endl;
		iter = SOP[i].begin() ;
		cout<< *iter ;
		for( iter++ ; iter!=SOP[i].end() ; iter++ )
			cout<<"\n"<< *iter ;
		cout<< endl ;
		cout<<"cost = "<< SOP_cost[i] << endl ;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x18(%rdi), %rax
movq 0x28(%rax), %rcx
movslq %ecx, %rax
movq %rcx, -0x30(%rbp)
cmpq %rcx, %rax
jne 0x6983
movq %rdi, %rbx
xorl %r12d, %r12d
movq 0x67ec(%rip), %r14      # 0xcfd0
leaq 0x284f(%rip), %r15      # 0x903a
movl $0x7, %edx
movq %r14, %rdi
leaq 0x29e6(%rip), %rsi      # 0x91e0
callq 0x2210
leaq 0x1(%r12), %rsi
movq %r14, %rdi
movq %rsi, -0x38(%rbp)
callq 0x22d0
movq %rax, %r13
movl $0x3, %edx
movq %rax, %rdi
leaq 0x29c6(%rip), %rsi      # 0x91e8
callq 0x2210
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x18(%rbx), %rax
movq %r12, %rcx
shlq $0x4, %rcx
leaq (%rcx,%rcx,2), %r13
movq 0x18(%rax,%r13), %rax
movq %rax, 0x694e(%rip)      # 0xd1b8
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
movq %r14, %rdi
callq 0x2210
movq 0x6937(%rip), %rdi      # 0xd1b8
callq 0x2220
movq %rax, 0x692b(%rip)      # 0xd1b8
movq 0x18(%rbx), %rcx
addq %r13, %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
je 0x68ef
leaq (%r12,%r12,2), %r13
shlq $0x4, %r13
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2210
movq 0x68fc(%rip), %rax      # 0xd1b8
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
movq %r14, %rdi
callq 0x2210
movq 0x68e5(%rip), %rdi      # 0xd1b8
callq 0x2220
movq %rax, 0x68d9(%rip)      # 0xd1b8
movq 0x18(%rbx), %rcx
addq %r13, %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
jne 0x68a5
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movl $0x7, %edx
movq %r14, %rdi
leaq 0x28c7(%rip), %rsi      # 0x91ec
callq 0x2210
movq 0x60(%rbx), %rax
movl (%rax,%r12,4), %esi
movq %r14, %rdi
callq 0x22d0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x18(%rbx), %rax
movq -0x38(%rbp), %r12
leaq (%r12,%r12,2), %rcx
shlq $0x4, %rcx
movq -0x30(%rbp), %rdx
cmpq %rdx, 0x28(%rax,%rcx)
je 0x67eb
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mirkat1206[P]Quine-McCluskey-Petrick-Method/Petrick_Method.cpp
// Function: Petrick_Method::HW1_Print_Minimum_Cover()
void Petrick_Method::HW1_Print_Minimum_Cover() {
	int min_cover = SOP[0].size(), min_cost = SOP_cost[0] , ans = 0 ;
	int size = SOP.size() ;
	for( int i=0 ; SOP[i].size()==min_cover ; i++ ) {
		if( SOP_cost[i]<min_cost ) {
			min_cost = SOP_cost[i] ;
			ans = i ;
		}
	}
	cout<<".mc "<< min_cover << endl;
	for( iter=SOP[ans].begin() ; iter!=SOP[ans].end() ; iter++ )
		cout<< *iter << endl;
	cout<<"cost="<< min_cost << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rcx
movq 0x60(%rdi), %rax
movq 0x28(%rcx), %r15
movl (%rax), %ebx
movslq %r15d, %rdx
xorl %r13d, %r13d
cmpq %r15, %rdx
jne 0x69e0
addq $0x58, %rcx
xorl %edx, %edx
movl (%rax,%rdx,4), %esi
cmpl %ebx, %esi
cmovll %edx, %r13d
cmovll %esi, %ebx
incq %rdx
leaq 0x30(%rcx), %rsi
cmpq %r15, (%rcx)
movq %rsi, %rcx
je 0x69c2
movslq %r13d, %r13
movq 0x65e9(%rip), %r12      # 0xcfd0
leaq 0x2806(%rip), %rsi      # 0x91f4
movl $0x4, %edx
movq %r12, %rdi
callq 0x2210
movq %r12, %rdi
movl %r15d, %esi
callq 0x22d0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x18(%r14), %rax
leaq (%r13,%r13,2), %r13
shlq $0x4, %r13
leaq (%rax,%r13), %rcx
addq $0x8, %rcx
movq 0x10(%rcx), %rax
movq %rax, 0x6768(%rip)      # 0xd1b8
cmpq %rcx, %rax
je 0x6ab9
movq 0x6574(%rip), %r15      # 0xcfd0
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
movq %r15, %rdi
callq 0x2210
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x671b(%rip), %rdi      # 0xd1b8
callq 0x2220
movq %rax, 0x670f(%rip)      # 0xd1b8
movq 0x18(%r14), %rcx
addq %r13, %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
jne 0x6a5c
movq 0x6510(%rip), %r14      # 0xcfd0
leaq 0x2732(%rip), %rsi      # 0x91f9
movl $0x5, %edx
movq %r14, %rdi
callq 0x2210
movq %r14, %rdi
movl %ebx, %esi
callq 0x22d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O3/mirkat1206[P]Quine-McCluskey-Petrick-Method/Petrick_Method.cpp
// Function: Petrick_Method::HW1_Print_Minimum_Cover(std::basic_ofstream<char, std::char_traits<char>>&)
void Petrick_Method::HW1_Print_Minimum_Cover(ofstream &fout) {
	int min_cover = SOP[0].size(), min_cost = SOP_cost[0] , ans = 0 ;
	int size = SOP.size() ;
	for( int i=0 ; SOP[i].size()==min_cover ; i++ ) {
		if( SOP_cost[i]<min_cost ) {
			min_cost = SOP_cost[i] ;
			ans = i ;
		}
	}
	fout<<".mc "<< min_cover << endl;
	for( iter=SOP[ans].begin() ; iter!=SOP[ans].end() ; iter++ )
		fout<< *iter << endl;
	fout<<"cost="<< min_cost << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0x18(%rdi), %rcx
movq 0x60(%rdi), %rax
movq 0x28(%rcx), %r12
movl (%rax), %r14d
movslq %r12d, %rdx
xorl %r13d, %r13d
cmpq %r12, %rdx
jne 0x6b6a
addq $0x58, %rcx
xorl %edx, %edx
movl (%rax,%rdx,4), %esi
cmpl %r14d, %esi
cmovll %edx, %r13d
cmovll %esi, %r14d
incq %rdx
leaq 0x30(%rcx), %rsi
cmpq %r12, (%rcx)
movq %rsi, %rcx
je 0x6b4a
movslq %r13d, %r13
leaq 0x2683(%rip), %rsi      # 0x91f4
movl $0x4, %edx
movq %rbx, %rdi
callq 0x2210
movq %rbx, %rdi
movl %r12d, %esi
callq 0x22d0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x18(%r15), %rax
leaq (%r13,%r13,2), %r13
shlq $0x4, %r13
leaq (%rax,%r13), %rcx
addq $0x8, %rcx
movq 0x10(%rcx), %rax
movq %rax, 0x65e5(%rip)      # 0xd1b8
cmpq %rcx, %rax
je 0x6c32
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
movq %rbx, %rdi
callq 0x2210
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq 0x659f(%rip), %rdi      # 0xd1b8
callq 0x2220
movq %rax, 0x6593(%rip)      # 0xd1b8
movq 0x18(%r15), %rcx
addq %r13, %rcx
addq $0x8, %rcx
jmp 0x6bd3
leaq 0x25c0(%rip), %rsi      # 0x91f9
movl $0x5, %edx
movq %rbx, %rdi
callq 0x2210
movq %rbx, %rdi
movl %r14d, %esi
callq 0x22d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/ssearch_x.c
// Function: on_match
static int
on_match(int strnum, const char *textp, MEMREF const *pattv)
{
    ++hits;
    if (verbose > 1)
	fprintf(stderr, "match patt[%d] '%.*s' at %"FSIZE"d\n",
		strnum, (int)pattv[strnum].len, pattv[strnum].ptr,
		textp - text.ptr);
    return  1;
}

// Assembly:
incl 0x6eb9(%rip)            # 0xa770
cmpl $0x2, 0x6e9a(%rip)      # 0xa758
jge 0x38c6
movl $0x1, %eax
retq
pushq %rax
movq %rsi, %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x36ca
addq $0x8, %rsp
jmp 0x38c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ctSkennerton[P]fxtract/util/ssearch.c
// Function: ssearch_destroy
void
ssearch_destroy(SSEARCH*ssp)
{
    if (!ssp)
        return;

    free(ssp->mapv);
    map_destroy(ssp->suffixh);
    free(ssp->prefixv);
    free(ssp);
}

// Assembly:
testq %rdi, %rdi
je 0x4d4b
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x3200
movq 0x18(%rbx), %rdi
callq 0x5533
movq 0x20(%rbx), %rdi
callq 0x3200
movq %rbx, %rdi
popq %rbx
jmp 0x3200
retq
// File: /workspace/github_cpp_makefile_star2_O3/yuanboli233[P]interdyck_graph_reduce/./SummaryEdge.h
// Function: root(unsigned int, SummaryGraph&)
unsigned root(unsigned id, SummaryGraph& sGraph){
    SummaryNode* node = sGraph.nodes[id];
    if(node->id != node->belongto){
        node->belongto = root(sGraph.nodes[node->belongto]->id, sGraph);
    }
    return node->belongto;
    // postcondition: root(node).belongto == node
    // node.belongto = root(node)
}

// Assembly:
pushq %rbx
movl %edi, %eax
movq 0x70(%rsi), %rcx
movq (%rcx,%rax,8), %rbx
movl (%rbx), %eax
movl 0x68(%rbx), %edx
cmpl %edx, %eax
je 0x25ee
movq (%rcx,%rdx,8), %rax
movl (%rax), %edi
callq 0x25cc
movl %eax, 0x68(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/yuanboli233[P]interdyck_graph_reduce/graphtest.cpp
// Function: findMatch(unsigned int, SummaryGraph&)
void findMatch(unsigned nodeID, SummaryGraph& sGraph){
    SummaryNode* node = sGraph.nodes[nodeID];
    unordered_set<unsigned> usedNodes;
    //usedNodes.insert(nodeID);
    for(vector<NodewithEID>::iterator it = node->outBlueEdgeNodes.begin(); it != node->outBlueEdgeNodes.end(); it++){
        unsigned eid = it->edgeID;
        unsigned nextnid = it->nodeID;
        cout << "Candidate: " << nodeID << " -" << eid << "-> " << nextnid;
        findMatch(nextnid, sGraph, eid, usedNodes, nodeID, nextnid);
        cout << endl;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edi, 0xc(%rsp)
movl %edi, %ecx
movq %rsi, 0x10(%rsp)
movq 0x70(%rsi), %rax
movq %rcx, 0x18(%rsp)
movq (%rax,%rcx,8), %rbp
leaq 0x50(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
movq 0x50(%rbp), %r14
cmpq 0x58(%rbp), %r14
je 0x28c1
movq 0x77d5(%rip), %r15      # 0x9fd8
movl (%r14), %r12d
movl 0x4(%r14), %r13d
movl $0xb, %edx
movq %r15, %rdi
leaq 0x481f(%rip), %rsi      # 0x7038
callq 0x21e0
movq %r15, %rdi
movq 0x18(%rsp), %rsi
callq 0x20e0
movq %rax, %rbx
movl $0x2, %edx
movq %rax, %rdi
leaq 0x4807(%rip), %rsi      # 0x7044
callq 0x21e0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x20e0
movq %rax, %rbx
movl $0x3, %edx
movq %rax, %rdi
leaq 0x47e8(%rip), %rsi      # 0x7047
callq 0x21e0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x20e0
movl %r12d, %edi
movq 0x10(%rsp), %rsi
movl %r13d, %edx
leaq 0x20(%rsp), %rcx
movl 0xc(%rsp), %r8d
movl %r12d, %r9d
callq 0x25f0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
addq $0x8, %r14
cmpq 0x58(%rbp), %r14
jne 0x2803
leaq 0x20(%rsp), %rdi
callq 0x39bc
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x39bc
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/yuanboli233[P]interdyck_graph_reduce/./SummaryEdge.h
// Function: SummaryGraph::constructGraph()
void constructGraph(){
        unordered_map<string, unsigned> string2nodeid = readNodes();
        int vtxNum = string2nodeid.size();
        //cout << "Node Number: " << vtxNum << endl;
        nodes.reserve(vtxNum);
        unordered_map<string, unsigned> str2eid = getEdgeIDs();
        eid2origeidstring = getEidToOrig(str2eid);
        eidNum = str2eid.size() + 1;
        for(int i = 0; i < vtxNum; i++){
            nodes.push_back(new SummaryNode(i, str2eid.size()));
        }
        readEdges(string2nodeid, str2eid);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
leaq 0x78(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4088
movq 0x18(%r14), %r12
leaq 0x70(%rbx), %r14
movslq %r12d, %rsi
movq %r14, %rdi
callq 0x44f0
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x458c
leaq 0x40(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %rbx, %rsi
callq 0x479a
leaq 0x38(%rbx), %rdi
leaq 0x40(%rsp), %rsi
callq 0x2320
leaq 0x40(%rsp), %rdi
callq 0x3e9e
movl 0x20(%rsp), %eax
incl %eax
movl %eax, 0x230(%rbx)
testl %r12d, %r12d
jle 0x401f
xorl %ebp, %ebp
leaq 0x40(%rsp), %r15
movl $0x70, %edi
callq 0x2190
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rax)
movups %xmm0, 0x48(%rax)
movups %xmm0, 0x38(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
movl %ebp, (%rax)
movl %ebp, 0x68(%rax)
movq %rax, 0x40(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x560e
incl %ebp
cmpl %ebp, %r12d
jne 0x3fde
leaq 0x78(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x480a
leaq 0x8(%rsp), %rdi
callq 0x586e
leaq 0x78(%rsp), %rdi
callq 0x586e
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4068
movq %rax, %rdi
callq 0x3a2b
jmp 0x4068
jmp 0x4063
movq %rax, %rbx
jmp 0x4075
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x586e
leaq 0x78(%rsp), %rdi
callq 0x586e
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/yuanboli233[P]interdyck_graph_reduce/./SummaryEdge.h
// Function: SummaryGraph::getEdgeIDs[abi:cxx11]()
unordered_map<string, unsigned> getEdgeIDs(){
        unordered_map<string, unsigned> result;
        unsigned eid = 0;

        string line;
        ifstream in(filename.c_str(), ifstream::in);

        while(getline(in, line)){
            if(! isEdge(line)){
                continue;
            }

            string edgeLabel = getEdgeLabel(line);
            edgeLabel = edgeLabel.substr(1);
            //cout << "edge label is " << edgeLabel << endl;
            if(result.find(edgeLabel) == result.end()){
                result[edgeLabel] = eid;
                eid++;
            }
        }
        return result;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, (%rdi)
movq $0x1, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movl $0x3f800000, 0x20(%rdi) # imm = 0x3F800000
movups %xmm0, 0x28(%rdi)
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsi, 0x8(%rsp)
movq 0x88(%rsi), %rsi
leaq 0x70(%rsp), %r15
movq %r15, %rdi
movl $0x8, %edx
callq 0x22d0
movq $0x0, (%rsp)
leaq 0x10(%rsp), %r12
leaq 0x2a44(%rip), %r13      # 0x704b
leaq 0x30(%rsp), %rbp
movq 0x70(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x22e0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x46f9
movl $0x2, %ecx
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x2290
cmpq $-0x1, %rax
je 0x460c
movq %rbp, %rdi
movq 0x8(%rsp), %rsi
movq %r12, %rdx
callq 0x55a4
movl $0x1, %edx
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movq %rbp, %rsi
movq $-0x1, %rcx
callq 0x21c0
movq %rbp, %rdi
movq %r14, %rsi
callq 0x2200
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x46ad
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x5110
testq %rax, %rax
jne 0x46d4
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x5228
movq (%rsp), %rcx
movl %ecx, (%rax)
incl %ecx
movq %rcx, (%rsp)
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x460c
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x460c
leaq 0x70(%rsp), %rdi
callq 0x2060
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x471f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rax
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4738
jmp 0x4738
movq %rax, %r14
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x4763
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x4763
jmp 0x4760
movq %rax, %r14
jmp 0x476d
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0x2060
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x4789
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x586e
movq %r14, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/yuanboli233[P]interdyck_graph_reduce/./SummaryEdge.h
// Function: SummaryGraph::getEidToOrig(std::unordered_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int, std::hash<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::equal_to<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, unsigned int>>>&)
unordered_map<unsigned, string> getEidToOrig(unordered_map<string, unsigned>& str2eid){
        unordered_map<unsigned, string> result;
        for(unordered_map<string, unsigned>::iterator it = str2eid.begin(); it != str2eid.end(); it++){
            result[it->second] = it->first;
        }
        return result;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, (%rdi)
movq $0x1, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movl $0x3f800000, 0x20(%rdi) # imm = 0x3F800000
movups %xmm0, 0x28(%rdi)
addq $0x10, %r14
movq (%r14), %r14
testq %r14, %r14
je 0x47eb
leaq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x5b12
leaq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x20c0
jmp 0x47c9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3e9e
movq %r14, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/yuanboli233[P]interdyck_graph_reduce/./SummaryEdge.h
// Function: SummaryGraph::getNodePair(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
pair<string, string> getNodePair(string line){
        string delimiter = "->";
        string str = line.substr(0, line.find_first_of("["));
        string::size_type delimiterstart = str.find_first_of(delimiter);
        string from, to;
        from = str.substr(0, delimiterstart);
        to = str.substr(delimiterstart + delimiter.size());
        return make_pair(from, to);

    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x2282(%rip), %rsi      # 0x704b
leaq 0x227d(%rip), %rdx      # 0x704d
leaq 0x8(%rsp), %rdi
callq 0x5016
leaq 0x22da(%rip), %rsi      # 0x70bb
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x2240
leaq 0x88(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x21c0
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rcx
xorl %r12d, %r12d
leaq 0x88(%rsp), %r15
movq %r15, %rdi
xorl %edx, %edx
callq 0x2240
movq %rax, %r14
leaq 0x78(%rsp), %r13
movq %r13, -0x10(%r13)
movq %r12, -0x8(%r13)
movb %r12b, (%r13)
leaq 0x58(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq %r12, -0x8(%rbp)
movb %r12b, (%rbp)
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x21c0
leaq 0x68(%rsp), %rdi
leaq 0x28(%rsp), %r15
movq %r15, %rsi
callq 0x2200
movq (%r15), %rdi
leaq 0x38(%rsp), %r15
cmpq %r15, %rdi
je 0x4e87
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21a0
addq 0x10(%rsp), %r14
leaq 0x28(%rsp), %rdi
leaq 0x88(%rsp), %rsi
movq %r14, %rdx
movq $-0x1, %rcx
callq 0x21c0
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %r14
movq %r14, %rsi
callq 0x2200
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x4ecf
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
movq %rbx, %rdi
callq 0x50ac
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4ef8
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x68(%rsp), %rdi
cmpq %r13, %rdi
je 0x4f0f
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4f30
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4f4c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4f65
jmp 0x4f65
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4f7f
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x68(%rsp), %rdi
cmpq %r13, %rdi
je 0x4f96
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4fbc
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x4fbc
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4fd8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O3/yuanboli233[P]interdyck_graph_reduce/./SummaryEdge.h
// Function: SummaryGraph::insertBracketEdge(unsigned int, unsigned int, unsigned int)
void insertBracketEdge(unsigned fid, unsigned tid, unsigned eid){
        //cout << "Edge: " << fid << " to " << tid << " color: red.\n";
        NodewithEID eidToNode(tid, eid);
        NodewithEID eidFromNode(fid, eid);
        nodes[fid]->outRedEdgeNodes.push_back(eidToNode);
        nodes[tid]->inRedEdgeNodes.push_back(eidFromNode);
    }

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movl %edx, 0x10(%rsp)
movl %ecx, 0x14(%rsp)
movl %esi, 0x8(%rsp)
movl %ecx, 0xc(%rsp)
movl %esi, %eax
movq 0x70(%rdi), %rcx
movq (%rcx,%rax,8), %rdi
movq 0x28(%rdi), %rsi
cmpq 0x30(%rdi), %rsi
je 0x57a4
movq 0x10(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x28(%rdi)
jmp 0x57b2
addq $0x20, %rdi
leaq 0x10(%rsp), %rdx
callq 0x6070
movl %ebp, %eax
movq 0x70(%rbx), %rcx
movq (%rcx,%rax,8), %rdi
movq 0x10(%rdi), %rsi
cmpq 0x18(%rdi), %rsi
je 0x57d5
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x10(%rdi)
jmp 0x57e3
addq $0x8, %rdi
leaq 0x8(%rsp), %rdx
callq 0x6070
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/yuanboli233[P]interdyck_graph_reduce/./SummaryEdge.h
// Function: SummaryGraph::insertParenthesisEdge(unsigned int, unsigned int, unsigned int)
void insertParenthesisEdge(unsigned fid, unsigned tid, unsigned eid){
        //cout << "Edge: " << fid << " to " << tid << " color: blue.\n";
        NodewithEID eidToNode(tid, eid);
        NodewithEID eidFromNode(fid, eid);
        nodes[fid]->outBlueEdgeNodes.push_back(eidToNode);
        nodes[tid]->inBlueEdgeNodes.push_back(eidFromNode);
    }

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movl %edx, 0x10(%rsp)
movl %ecx, 0x14(%rsp)
movl %esi, 0x8(%rsp)
movl %ecx, 0xc(%rsp)
movl %esi, %eax
movq 0x70(%rdi), %rcx
movq (%rcx,%rax,8), %rdi
movq 0x58(%rdi), %rsi
cmpq 0x60(%rdi), %rsi
je 0x5828
movq 0x10(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x58(%rdi)
jmp 0x5836
addq $0x50, %rdi
leaq 0x10(%rsp), %rdx
callq 0x6070
movl %ebp, %eax
movq 0x70(%rbx), %rcx
movq (%rcx,%rax,8), %rdi
movq 0x40(%rdi), %rsi
cmpq 0x48(%rdi), %rsi
je 0x5859
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x40(%rdi)
jmp 0x5867
addq $0x38, %rdi
leaq 0x8(%rsp), %rdx
callq 0x6070
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/alignment.cpp
// Function: Alignment_sp::(anonymous namespace)::complementaryNucleotide(char)
char complementaryNucleotide (char wildNucleotide)
{
  char r = ' ';
  switch (toLower (wildNucleotide))
  {
    case 'a': r = 't'; break;
    case 'c': r = 'g'; break;
    case 'g': r = 'c'; break;
    case 't': r = 'a'; break;
    case 'm': r = 'k'; break;
    case 'r': r = 'y'; break;
    case 'w': r = 'w'; break;
    case 's': r = 's'; break;
    case 'y': r = 'r'; break;
    case 'k': r = 'm'; break;
    case 'v': r = 'b'; break;
    case 'h': r = 'd'; break;
    case 'd': r = 'h'; break;
    case 'b': r = 'v'; break;
    case 'n': r = 'n'; break;
    default: 
    	throw runtime_error ("Bad wild nucleotide " + toString (wildNucleotide));
  }
  if (isupper (wildNucleotide))
    r = toUpper (r);

  return r;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %edi, %ebx
movb %bl, 0xf(%rsp)
callq 0xb840
addb $-0x61, %al
cmpb $0x19, %al
jae 0x67cc7
movzbl %al, %eax
movl $0x16e34cf, %ecx        # imm = 0x16E34CF
btl %eax, %ecx
jae 0x67cc7
leaq 0x30177(%rip), %rcx     # 0x97e19
movb (%rax,%rcx), %bpl
movl %ebx, %edi
callq 0xb460
testl %eax, %eax
je 0x67cbc
movzbl %bpl, %edi
callq 0xbab0
movl %eax, %ebp
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0xb2d0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rsi
callq 0x44a6b
leaq 0x3009c(%rip), %rsi     # 0x97d86
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0xeb12
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0xb960
xorl %ebp, %ebp
movq 0x512de(%rip), %rsi     # 0xb8ff0
movq 0x51257(%rip), %rdx     # 0xb8f70
movq %rbx, %rdi
callq 0xba00
movq %rax, %r14
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x67d3f
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xb5a0
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x67d5a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb5a0
testb %bpl, %bpl
jne 0x67d84
jmp 0x67d8c
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x67d84
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb5a0
jmp 0x67d84
movq %rax, %r14
movq %rbx, %rdi
callq 0xb440
movq %r14, %rdi
callq 0xba60
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/./alignment.hpp
// Function: Alignment_sp::SeqChange::saveText(std::ostream&) const
void saveText (ostream &os) const override
    { os        << start + 1 
         << ' ' << len 
         << ' ' << strQuote (reference) << " -> " << strQuote (allele)
         << ' ' << start_ref + 1 << ".." << stop_ref
         << ' ' << start_target + 1 
         << ' ' << neighborhoodMismatch;
      for (const AmrMutation* mutation : mutations)
      { os << ' ' ;
        mutation->saveText (os);
      }
      os << endl; 
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rsi
incq %rsi
movq %rbx, %rdi
callq 0xb3e0
movb $0x20, %bpl
leaq 0x8(%rsp), %r15
movb %bpl, (%r15)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0xb640
movq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0xb3e0
movb %bpl, (%r15)
leaq 0x8(%rsp), %rsi
movl $0x1, %edx
movq %rax, %rdi
callq 0xb640
movq %rax, %r15
leaq 0x28(%r14), %rsi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movl $0x22, %edx
callq 0x14ff2
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0xb640
movq %rax, %r15
leaq 0x2fef5(%rip), %rsi     # 0x97d30
movl $0x4, %edx
movq %rax, %rdi
callq 0xb640
leaq 0x48(%r14), %rsi
leaq 0x28(%rsp), %rdi
movl $0x22, %edx
callq 0x14ff2
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r15, %rdi
callq 0xb640
leaq 0x7(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0xb640
movq 0x68(%r14), %rsi
incq %rsi
movq %rax, %rdi
callq 0xb3e0
movq %rax, %r15
leaq 0x2e019(%rip), %rsi     # 0x95eb4
movl $0x2, %edx
movq %rax, %rdi
callq 0xb640
movq 0x70(%r14), %rsi
movq %r15, %rdi
callq 0xb3e0
leaq 0x7(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0xb640
movq 0x78(%r14), %rsi
incq %rsi
movq %rax, %rdi
callq 0xb3e0
leaq 0x7(%rsp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0xb640
movsd 0x80(%r14), %xmm0
movq %rax, %rdi
callq 0xb940
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x67f19
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb5a0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x67f34
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb5a0
movq 0x88(%r14), %r12
movq 0x90(%r14), %r13
cmpq %r13, %r12
je 0x67f79
leaq 0x8(%rsp), %r14
movq (%r12), %r15
movb $0x20, 0x8(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb640
movq %r15, %rdi
movq %rbx, %rsi
callq 0x68342
addq $0x8, %r12
cmpq %r13, %r12
jne 0x67f4c
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb570
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb040
movq %rax, %rdi
callq 0xb3f0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x67fb1
movq %rax, %rbx
jmp 0x67fd4
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x67fd4
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb5a0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x67fef
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb5a0
movq %rbx, %rdi
callq 0xba60
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/./alignment.hpp
// Function: Alignment_sp::AmrMutation::saveText(std::ostream&) const
void saveText (ostream &os) const override
    { if (empty ())
        os << "empty";
      else
        os << pos_real + 1 << ' ' << geneMutation << ' ' << frameshift_insertion << ' ' << name; 
    }

// Assembly:
movq %rsi, %rax
cmpq $0x0, 0x18(%rdi)
je 0x683e8
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
incq %rsi
movq %rax, %rdi
callq 0xb3e0
movb $0x20, %bpl
leaq 0x5(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0xb640
movq 0xa8(%rbx), %rsi
movq 0xb0(%rbx), %rdx
movq %rax, %rdi
callq 0xb640
leaq 0x6(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0xb640
movl 0xa0(%rbx), %esi
movq %rax, %rdi
callq 0xba10
leaq 0x7(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0xb640
movq 0x108(%rbx), %rsi
movq 0x110(%rbx), %rdx
movq %rax, %rdi
callq 0xb640
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x2f9ac(%rip), %rsi     # 0x97d9b
movl $0x5, %edx
movq %rax, %rdi
jmp 0xb640
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/seq.cpp
// Function: Seq_sp::Seq::getTaxonStart(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
FOR_REV (size_t, i, s. size ())
  {
    if (s [i] == ']')
      brackets++;
    else if (s [i] == '[')
    {
      if (brackets == 1)
        return i;
      else if (brackets == 0)
    	  return string::npos;  // Non-balanced brackets: too many '['
      else
        brackets--;
    }
  //cout << s. substr (0, i + 1) << ' ' << i << ' ' << brackets << endl;  
    if (brackets == 0)
    	return string::npos;  // No brackets
  }

// Assembly:
movq (%rdi), %rdx
movq 0x8(%rdi), %rcx
decq %rcx
xorl %esi, %esi
movq $-0x1, %rax
cmpq $-0x1, %rcx
je 0x6c5f4
movzbl (%rdx,%rcx), %edi
cmpl $0x5b, %edi
je 0x6c5de
cmpl $0x5d, %edi
jne 0x6c5ec
incq %rsi
jmp 0x6c5ec
testq %rsi, %rsi
je 0x6c5f4
cmpq $0x1, %rsi
je 0x6c5f5
decq %rsi
decq %rcx
testq %rsi, %rsi
jne 0x6c5c5
retq
movq %rcx, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/seq.cpp
// Function: Seq_sp::Seq::getCharCount() const
map<char,size_t> Seq::getCharCount () const
{ 
  map<char,size_t> m;
  for (const char c : seq)
    m [c] ++;
  return m;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq 0x30(%rsi), %r15
testq %r15, %r15
je 0x6d0b4
movq 0x28(%rsi), %r12
xorl %r13d, %r13d
leaq 0xf(%rsp), %r14
movb (%r12,%r13), %al
movb %al, 0xf(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8e748
incq (%rax)
incq %r13
cmpq %r13, %r15
jne 0x6d096
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x8fa76
movq %r14, %rdi
callq 0xba60
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/seq.cpp
// Function: Seq_sp::Multifasta::qcNewSeq() const
void Multifasta::qcNewSeq () const
{
	if (   ! in. eof 
	    && ! (   ! in. line. empty () 
	          && in. line [0] == '>'
	         )
	   )
	  throw runtime_error ("Error in Multifasta, " + in. lineStr ());   
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
cmpb $0x0, 0x220(%rdi)
jne 0x6d102
movq %rdi, %r14
cmpq $0x0, 0x278(%rdi)
je 0x6d10b
movq 0x270(%r14), %rax
cmpb $0x3e, (%rax)
jne 0x6d10b
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
addq $0x8, %r14
movl $0x10, %edi
callq 0xb2d0
movq %rax, %rbx
movq %rsp, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x8e7ae
leaq 0x2b133(%rip), %rsi     # 0x98266
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xeb12
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xb960
xorl %ebp, %ebp
movq 0x4be97(%rip), %rsi     # 0xb8ff0
movq 0x4be10(%rip), %rdx     # 0xb8f70
movq %rbx, %rdi
callq 0xba00
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6d186
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb5a0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6d1a1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb5a0
testb %bpl, %bpl
jne 0x6d1cb
jmp 0x6d1d3
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6d1cb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb5a0
jmp 0x6d1cb
movq %rax, %r14
movq %rbx, %rdi
callq 0xb440
movq %r14, %rdi
callq 0xba60
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/seq.cpp
// Function: Seq_sp::nuc2num(char)
size_t nuc2num (char wildNucleotide)
{
  const char c = toLower (wildNucleotide);
  switch (c)
  {
    case 'a': return 0; break;
    case 'c': return 1; break;
    case 'g': return 2; break;
    case 't': return 3; break;
  }  
  if (isAmbigNucl (c))
    return 4;
  throw runtime_error (strQuote (string (1, wildNucleotide)) + " is not a nucleotide");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movl %edi, %ebp
callq 0xb840
movzbl %al, %ecx
cmpl $0x66, %ecx
jg 0x6d20e
cmpl $0x61, %ecx
je 0x6d2af
cmpl $0x63, %ecx
jne 0x6d226
movl $0x1, %eax
jmp 0x6d2b8
cmpl $0x67, %ecx
je 0x6d2b3
cmpl $0x74, %ecx
jne 0x6d226
movl $0x3, %eax
jmp 0x6d2b8
movq 0x4c9ab(%rip), %rdi     # 0xb9bd8
movsbl %al, %esi
callq 0xb230
movq %rax, %rcx
movl $0x4, %eax
testq %rcx, %rcx
jne 0x6d2b8
movl $0x10, %edi
callq 0xb2d0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movsbl %bpl, %edx
movq %rsp, %rdi
movl $0x1, %esi
callq 0xb670
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
movl $0x22, %edx
callq 0x14ff2
leaq 0x2affa(%rip), %rsi     # 0x9827c
leaq 0x40(%rsp), %rdi
callq 0xbb10
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x6d2c5
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x6d2d2
xorl %eax, %eax
jmp 0x6d2b8
movl $0x2, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0xb960
xorl %ebp, %ebp
movq 0x4bcee(%rip), %rsi     # 0xb8ff0
movq 0x4bc67(%rip), %rdx     # 0xb8f70
movq %rbx, %rdi
callq 0xba00
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x6d333
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb5a0
jmp 0x6d333
movq %rax, %r14
movb $0x1, %bpl
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6d34e
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xb5a0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6d364
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb5a0
testb %bpl, %bpl
jne 0x6d389
jmp 0x6d391
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6d389
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb5a0
jmp 0x6d389
movq %rax, %r14
movq %rbx, %rdi
callq 0xb440
movq %r14, %rdi
callq 0xba60
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/seq.cpp
// Function: Seq_sp::reverseDna(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
string& reverseDna (string &seq)
{
  const size_t len = seq. size ();
  if (! len)
  	return seq;

  FFOR (size_t, i, len / 2)
  {
  	const size_t j = len - 1 - i;
  	if (seq [i] != '-')
  		seq [i] = complementaryNucleotide (seq [i]);
  	if (seq [j] != '-')
  		seq [j] = complementaryNucleotide (seq [j]);
    swap (seq [i], seq [j]);
  }

  if (len % 2)
  {
  	const size_t i = len / 2;
  	if (seq [i] != '-')
  		seq [i] = complementaryNucleotide (seq [i]);
  }
 
  return seq;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0x6e53d
movq %r15, %r14
shrq %r14
cmpq $0x1, %r15
je 0x6e523
cmpq $0x1, %r14
movq %r14, %r12
adcq $0x0, %r12
leaq -0x1(%r15), %r13
xorl %ebp, %ebp
movq (%rbx), %rax
movb (%rax,%rbp), %cl
cmpb $0x2d, %cl
je 0x6e4e7
movsbl %cl, %edi
callq 0x6d9ff
movq (%rbx), %rcx
movb %al, (%rcx,%rbp)
movq (%rbx), %rax
movb (%rax,%r13), %dl
movb $0x2d, %cl
cmpb $0x2d, %dl
je 0x6e508
movsbl %dl, %edi
callq 0x6d9ff
movq (%rbx), %rcx
movb %al, (%rcx,%r13)
movq (%rbx), %rax
movb (%rax,%r13), %cl
movb (%rax,%rbp), %dl
movb %cl, (%rax,%rbp)
movb %dl, (%rax,%r13)
incq %rbp
decq %r13
cmpq %rbp, %r12
jne 0x6e4cb
testb $0x1, %r15b
je 0x6e53d
movq (%rbx), %rax
movb (%rax,%r14), %al
cmpb $0x2d, %al
je 0x6e53d
movsbl %al, %edi
callq 0x6d9ff
movq (%rbx), %rcx
movb %al, (%rcx,%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/seq.cpp
// Function: Seq_sp::Dna::makeComplementary() const
Dna* Dna::makeComplementary () const
{
  Dna* dna = new Dna (getId () + ".rev", seq. size (), sparse);
  FFOR (size_t, i, seq. size ())
    dna->seq [i] = complementaryNucleotide (seq [seq. size () - 1 - i]);

#if 0
  if (Qual)
  {
    dna->CreateQual ();
    For (i, SeqLen)
      dna->Qual [i] = Qual [SeqLen - 1 - i];
  }
#endif

  return dna;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
movl $0x50, %edi
callq 0xb590
movq %rax, %rbx
leaq 0x8(%r14), %r15
movq %r15, %rdi
movl $0x20, %esi
xorl %edx, %edx
callq 0xb760
cmpq $-0x1, %rax
jne 0x6feda
movq 0x10(%r14), %rax
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0xb5d0
leaq 0x285ae(%rip), %rsi     # 0x984a1
leaq 0x20(%rsp), %rdi
callq 0xbb10
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x6ff23
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x6ff2a
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rsp, %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x30(%r14), %rdx
movzbl 0x48(%r14), %ecx
movq %rbx, %rdi
callq 0x8fac6
leaq 0x4898c(%rip), %rax     # 0xb88e8
movq %rax, (%rbx)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6ff75
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb5a0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6ff90
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb5a0
movq 0x30(%r14), %r15
testq %r15, %r15
je 0x6ffc8
movq $-0x1, %r12
xorl %r13d, %r13d
movq 0x28(%r14), %rax
addq 0x30(%r14), %rax
movsbl (%r12,%rax), %edi
callq 0x6d9ff
movq 0x28(%rbx), %rcx
movb %al, (%rcx,%r13)
incq %r13
decq %r12
cmpq %r13, %r15
jne 0x6ffa3
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6fff7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb5a0
jmp 0x6fff7
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x70017
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb5a0
jmp 0x70017
movq %rax, %r14
movl $0x50, %esi
movq %rbx, %rdi
callq 0xb5a0
movq %r14, %rdi
callq 0xba60
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/seq.cpp
// Function: Seq_sp::SubstMat::saveText(std::ostream&) const
void SubstMat::saveText (ostream& os) const 
{
  FOR (size_t, i, sim_size)
    if (goodIndex (i))
      os << ' ' << char (i);
  os << endl;
  
  FOR (size_t, i, sim_size)
    if (goodIndex (i))
    {
      os << char (i);
      FOR (size_t, j, sim_size)
        if (goodIndex (j))
          os << ' ' << sim [i] [j];
      os << endl;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r15
addq $0x8, %r15
xorl %r13d, %r13d
leaq 0xc(%rsp), %r14
leaq 0xd(%rsp), %r12
movq %r15, %rbp
movsd (%rbp), %xmm0
ucomisd %xmm0, %xmm0
jp 0x75ff1
movb $0x20, 0xc(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb640
movb %r13b, 0xd(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0xb640
incq %r13
addq $0x408, %rbp            # imm = 0x408
cmpq $0x80, %r13
jne 0x75fbc
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb570
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb040
movq %rax, %rdi
callq 0xb3f0
xorl %r13d, %r13d
leaq 0xf(%rsp), %r12
movq %r15, %rbp
movq %r15, 0x10(%rsp)
movq %r13, %rax
shlq $0xa, %rax
addq %r15, %rax
movsd (%rax,%r13,8), %xmm0
ucomisd %xmm0, %xmm0
jp 0x760e0
movb %r13b, 0xe(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
leaq 0xe(%rsp), %rsi
callq 0xb640
movq %r15, %r14
xorl %r15d, %r15d
movsd (%r14), %xmm0
ucomisd %xmm0, %xmm0
jp 0x760a1
movb $0x20, 0xf(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb640
movsd (%rbp,%r15,8), %xmm0
movq %rax, %rdi
callq 0xb940
incq %r15
addq $0x408, %r14            # imm = 0x408
cmpq $0x80, %r15
jne 0x76072
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb570
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb040
movq %rax, %rdi
callq 0xb3f0
movq 0x10(%rsp), %r15
incq %r13
addq $0x400, %rbp            # imm = 0x400
cmpq $0x80, %r13
jne 0x7603b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/seq.cpp
// Function: Seq_sp::SubstMat::printAnomalies() const
FOR (size_t, i, sim_size)
  {
    if (! goodIndex (i))
      continue;
    FOR (size_t, j, sim_size)
    {
      if (! goodIndex (j))
        continue;
      if (sim [i] [i] < sim [i] [j])
        cout << "sim(" << char (i) << ',' << char (i) << ") < sim(" << char(i) << ',' << char(j) << ")" << endl;
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
addq $0x8, %rdi
xorl %r15d, %r15d
movq %rdi, 0x8(%rsp)
movq %rdi, %rcx
movb $0x2c, %bpl
movq %r15, %rax
shlq $0xa, %rax
addq 0x8(%rsp), %rax
movsd (%rax,%r15,8), %xmm0
ucomisd %xmm0, %xmm0
jp 0x76290
leaq (%rax,%r15,8), %r13
movq 0x8(%rsp), %r14
xorl %r12d, %r12d
movq %r13, 0x10(%rsp)
movsd (%r14), %xmm0
ucomisd %xmm0, %xmm0
jp 0x76279
movsd (%rcx,%r12,8), %xmm0
ucomisd (%r13), %xmm0
jbe 0x76279
movl $0x4, %edx
movq 0x42e20(%rip), %rbx     # 0xb8fa0
movq %rbx, %rdi
leaq 0x227a7(%rip), %rsi     # 0x98931
movq %rcx, %r13
callq 0xb640
movb %r15b, 0x2(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x2(%rsp), %rsi
callq 0xb640
movb %bpl, 0x3(%rsp)
movl $0x1, %edx
movq %rax, %rdi
leaq 0x3(%rsp), %rsi
callq 0xb640
movb %r15b, 0x4(%rsp)
movl $0x1, %edx
movq %rax, %rdi
leaq 0x4(%rsp), %rsi
callq 0xb640
movq %rax, %rbx
movl $0x8, %edx
movq %rax, %rdi
leaq 0x22744(%rip), %rsi     # 0x9892d
callq 0xb640
movb %r15b, 0x5(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x5(%rsp), %rsi
callq 0xb640
movb %bpl, 0x6(%rsp)
movl $0x1, %edx
movq %rax, %rdi
leaq 0x6(%rsp), %rsi
callq 0xb640
movb %r12b, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
leaq 0x7(%rsp), %rsi
callq 0xb640
movq %rax, %rbx
movl $0x1, %edx
movq %rax, %rdi
leaq 0x20ea4(%rip), %rsi     # 0x970e9
callq 0xb640
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0xb570
movsbl %al, %esi
movq %rbx, %rdi
callq 0xb040
movq %rax, %rdi
callq 0xb3f0
movq %r13, %rcx
movq 0x10(%rsp), %r13
incq %r12
addq $0x408, %r14            # imm = 0x408
cmpq $0x80, %r12
jne 0x76153
incq %r15
addq $0x400, %rcx            # imm = 0x400
cmpq $0x80, %r15
jne 0x76126
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ncbi[P]amr/seq.cpp
// Function: Seq_sp::moreGeneralAminoacid(char, char)
bool moreGeneralAminoacid (char wildAminoacid1,
                           char wildAminoacid2)
{
  if (wildAminoacid1 == wildAminoacid2)
    return true;


  switch (wildAminoacid1)
  {
    case 'x': return true;
    case 'b': return charInSet (wildAminoacid2, "dn");
    case 'z': return charInSet (wildAminoacid2, "eq");
    case 'j': return charInSet (wildAminoacid2, "il");
    case 'u': return wildAminoacid2 == '*'; 
    case 'o': return wildAminoacid2 == '*'; 
    case '*': return charInSet (wildAminoacid2, "uo");
  }

  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movb $0x1, %bpl
cmpb %bl, %dil
je 0x79639
movsbl %dil, %eax
cmpl $0x6e, %eax
jle 0x7957f
cmpl $0x77, %eax
jg 0x795a7
cmpl $0x6f, %eax
je 0x79573
cmpl $0x75, %eax
jne 0x795e7
cmpb $0x2a, %bl
sete %bpl
jmp 0x79639
cmpl $0x2a, %eax
je 0x795ce
cmpl $0x62, %eax
je 0x795eb
cmpl $0x6a, %eax
jne 0x795e7
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2028c(%rip), %rsi     # 0x9982a
leaq 0x20287(%rip), %rdx     # 0x9982c
jmp 0x79602
cmpl $0x78, %eax
je 0x79639
cmpl $0x7a, %eax
jne 0x795e7
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1f5a1(%rip), %rsi     # 0x98b66
leaq 0x1f59c(%rip), %rdx     # 0x98b68
jmp 0x79602
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1f58b(%rip), %rsi     # 0x98b69
leaq 0x1f586(%rip), %rdx     # 0x98b6b
jmp 0x79602
xorl %ebp, %ebp
jmp 0x79639
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1f568(%rip), %rsi     # 0x98b63
leaq 0x1f563(%rip), %rdx     # 0x98b65
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xdc76
movsbl %bl, %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0xb760
cmpq $-0x1, %rax
setne %bpl
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x79639
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb5a0
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq