LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/A-deLuna[P]encora-cpp-test/bitwise_add.cpp
// Function: add(int, int)
int add(int a, int b) {
  uint8_t bitCount = sizeof(int) * 8;
  int result = 0;

  uint8_t carry = 0;

  for (uint8_t i = 0; i < bitCount; i++) {
    uint8_t addition = carry + ((a >> i) & 1) + ((b >> i) & 1);
    carry = (addition & 0b10) >> 1;
    result |= ((addition & 1) << i);
  }

  // Overflow is not possible when first bit differs in arguments.
  if ((a >> (bitCount - 1)) != (b >> (bitCount - 1))) {
    return result;
  }

  // Overflow occurs when first bit is different in result and arguments.
  if ((a >> (bitCount - 1)) != (result >> (bitCount - 1))) {
    throw std::overflow_error{"Addition overflow"};
  }

  return result;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %ecx, %ecx
xorl %edx, %edx
xorl %eax, %eax
cmpl $0x20, %ecx
je 0x1321
xorl %r8d, %r8d
btl %ecx, %edi
setb %r8b
btl %ecx, %esi
adcl %edx, %r8d
movl %r8d, %edx
andl $0x1, %r8d
shll %cl, %r8d
shrl %edx
andl $0x1, %edx
orl %r8d, %eax
incl %ecx
jmp 0x12f6
sarl $0x1f, %edi
sarl $0x1f, %esi
cmpl %esi, %edi
jne 0x1334
movl %eax, %ecx
sarl $0x1f, %ecx
cmpl %ecx, %edi
jne 0x133c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x1070
movq %rax, %rbx
leaq 0x1cb6(%rip), %rsi      # 0x3004
movq %rax, %rdi
callq 0x1030
movq 0x4c6b(%rip), %rsi      # 0x5fc8
movq 0x4c5c(%rip), %rdx      # 0x5fc0
movq %rbx, %rdi
callq 0x1140
movq %rax, %r14
movq %rbx, %rdi
callq 0x10a0
movq %r14, %rdi
callq 0x1160
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x248e
movq (%rcx,%rdx,8), %rax
movl (%rax), %edi
callq 0x246c
movl %eax, 0x68(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/yuanboli233[P]interdyck_graph_reduce/graphtest.cpp
// Function: findMatch(unsigned int, SummaryGraph&, unsigned int, std::unordered_set<unsigned int, std::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<unsigned int>>&, unsigned int, unsigned int)
void findMatch(unsigned nodeID, SummaryGraph& sGraph, unsigned eid, unordered_set<unsigned>& usedNodes, unsigned origFrom, unsigned origTo){
    SummaryNode* node = sGraph.nodes[nodeID];
    if(usedNodes.find(nodeID) != usedNodes.end()){
        return;
    }
    usedNodes.insert(nodeID);
    for(vector<NodewithEID>::iterator it = node->inBlueEdgeNodes.begin(); it != node->inBlueEdgeNodes.end(); it++){
        unsigned cureid = it->edgeID;
        unsigned nextnid = it->nodeID;
        if(eid == cureid && nodeID != origTo && nextnid != origFrom){
            cout << "    match " << nodeID << " <-" << cureid << "- " << nextnid;
        }
    }
    for(vector<NodewithEID>::iterator it = node->inRedEdgeNodes.begin(); it != node->inRedEdgeNodes.end(); it++){
        unsigned nextnid = it->nodeID;
        findMatch(nextnid, sGraph, eid, usedNodes, origFrom, origTo);
    }
    for(vector<NodewithEID>::iterator it = node->outRedEdgeNodes.begin(); it != node->outRedEdgeNodes.end(); it++){
        unsigned nextnid = it->nodeID;
        findMatch(nextnid, sGraph, eid, usedNodes, origFrom, origTo);
    }

    usedNodes.erase(nodeID);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %ebp
movl %r8d, %r14d
movq %rcx, %r13
movl %edx, %r15d
movq %rsi, %r12
leaq 0xc(%rsp), %rsi
movl %edi, (%rsi)
movl %edi, %eax
movq 0x70(%r12), %rcx
movq (%rcx,%rax,8), %rbx
movq %r13, %rdi
callq 0x5868
testq %rax, %rax
jne 0x25e6
movq %r12, 0x10(%rsp)
leaq 0xc(%rsp), %rsi
movq %r13, %rdi
callq 0x58e4
movq 0x38(%rbx), %r12
movl %r15d, %eax
movq %rax, 0x18(%rsp)
movq %r13, 0x20(%rsp)
cmpq 0x40(%rbx), %r12
je 0x2585
movl (%r12), %eax
cmpl %r15d, 0x4(%r12)
setne %cl
cmpl %ebp, 0xc(%rsp)
sete %dl
cmpl %r14d, %eax
sete %sil
orb %dl, %sil
orb %cl, %sil
jne 0x257c
movl %eax, %r13d
movq 0x8aaf(%rip), %rdi      # 0xafd8
leaq 0x4af6(%rip), %rsi      # 0x7026
callq 0x21b0
movl 0xc(%rsp), %esi
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
leaq 0x4ae6(%rip), %rsi      # 0x7031
callq 0x21b0
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x2110
movq %rax, %rdi
leaq 0x4ace(%rip), %rsi      # 0x7035
callq 0x21b0
movq %rax, %rdi
movq %r13, %rsi
movq 0x20(%rsp), %r13
callq 0x2110
addq $0x8, %r12
jmp 0x24f3
movq 0x8(%rbx), %r12
cmpq 0x10(%rbx), %r12
je 0x25af
movl (%r12), %edi
movq 0x10(%rsp), %rsi
movl %r15d, %edx
movq %r13, %rcx
movl %r14d, %r8d
movl %ebp, %r9d
callq 0x2490
addq $0x8, %r12
jmp 0x2589
movq 0x20(%rbx), %r12
cmpq 0x28(%rbx), %r12
je 0x25d9
movl (%r12), %edi
movq 0x10(%rsp), %rsi
movl %r15d, %edx
movq %r13, %rcx
movl %r14d, %r8d
movl %ebp, %r9d
callq 0x2490
addq $0x8, %r12
jmp 0x25b3
leaq 0xc(%rsp), %rsi
movq %r13, %rdi
callq 0x5bca
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
movl %edi, 0x4(%rsp)
movl %edi, %r14d
movq %rsi, 0x8(%rsp)
movq 0x70(%rsi), %rax
movq (%rax,%r14,8), %rbx
leaq 0x40(%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(%rbx), %rbp
movq 0x8993(%rip), %r15      # 0xafd8
cmpq 0x58(%rbx), %rbp
je 0x26d3
movl (%rbp), %r12d
movl 0x4(%rbp), %r13d
movq %r15, %rdi
leaq 0x49d7(%rip), %rsi      # 0x7038
callq 0x21b0
movq %rax, %rdi
movq %r14, %rsi
callq 0x2110
movq %rax, %rdi
leaq 0x49c9(%rip), %rsi      # 0x7044
callq 0x21b0
movq %rax, %rdi
movq %r13, %rsi
callq 0x2110
movq %rax, %rdi
leaq 0x49b2(%rip), %rsi      # 0x7047
callq 0x21b0
movq %rax, %rdi
movq %r12, %rsi
callq 0x2110
movl %r12d, %edi
movq 0x8(%rsp), %rsi
movl %r13d, %edx
leaq 0x10(%rsp), %rcx
movl 0x4(%rsp), %r8d
movl %r12d, %r9d
callq 0x2490
movq %r15, %rdi
callq 0x20c0
addq $0x8, %rbp
jmp 0x2645
leaq 0x10(%rsp), %rdi
callq 0x32e4
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x32e4
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/yuanboli233[P]interdyck_graph_reduce/graphtest.cpp
// Function: mergeNodes(unsigned int, unsigned int, SummaryGraph&)
void mergeNodes(unsigned anodeID, unsigned bnodeID, SummaryGraph& sGraph){
    if(root(anodeID, sGraph) != anodeID || root(bnodeID, sGraph) != bnodeID)
        return mergeNodes(root(anodeID, sGraph), root(bnodeID, sGraph), sGraph);

    if(anodeID == bnodeID)
        return;

    SummaryNode* anode = sGraph.nodes[anodeID];
    SummaryNode* bnode = sGraph.nodes[bnodeID];

    bnode->belongto = anode->id;

    for(vector<NodewithEID>::iterator it = bnode->outRedEdgeNodes.begin(); it != bnode->outRedEdgeNodes.end(); it++){
        unsigned eid = it->edgeID;
        unsigned tonodeID = root(it->nodeID, sGraph);
        NodewithEID newEidNode(tonodeID, eid);
        // do not care duplicate
        anode->outRedEdgeNodes.push_back(newEidNode);
        //cout << "add new red edge " << anode->id << "->" << tonodeID << " with eid " << eid << endl;
    }
    bnode->outRedEdgeNodes.clear();

    for(vector<NodewithEID>::iterator it = bnode->outBlueEdgeNodes.begin(); it != bnode->outBlueEdgeNodes.end(); it++){
        unsigned eid = it->edgeID;
        unsigned tonodeID = root(it->nodeID, sGraph);
        NodewithEID newEidNode(tonodeID, eid);
        // do not care duplicate
        anode->outBlueEdgeNodes.push_back(newEidNode);
        //cout << "add new blue edge " << anode->id << "->" << tonodeID << " with eid " << eid << endl;
    }
    bnode->outBlueEdgeNodes.clear();

    //cout << "Merge " << anodeID << " with " << bnodeID << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movl %edi, %r14d
movl %r14d, %edi
movq %rbx, %rsi
callq 0x246c
cmpl %r14d, %eax
jne 0x2732
movl %ebp, %edi
movq %rbx, %rsi
callq 0x246c
cmpl %ebp, %eax
je 0x274e
movl %r14d, %edi
movq %rbx, %rsi
callq 0x246c
movl %eax, %r14d
movl %ebp, %edi
movq %rbx, %rsi
callq 0x246c
movl %eax, %ebp
jmp 0x2714
cmpl %ebp, %r14d
je 0x27f9
movl %r14d, %eax
movq 0x70(%rbx), %rcx
movq (%rcx,%rax,8), %r14
movl %ebp, %eax
movq (%rcx,%rax,8), %r13
movl (%r14), %eax
movl %eax, 0x68(%r13)
movq 0x20(%r13), %rbp
leaq 0x20(%r14), %r15
cmpq 0x28(%r13), %rbp
je 0x27a5
movl (%rbp), %edi
movl 0x4(%rbp), %r12d
movq %rbx, %rsi
callq 0x246c
movl %eax, (%rsp)
movl %r12d, 0x4(%rsp)
movq %r15, %rdi
movq %rsp, %rsi
callq 0x30ce
addq $0x8, %rbp
jmp 0x2777
movq 0x20(%r13), %rax
cmpq %rax, %rbp
je 0x27b2
movq %rax, 0x28(%r13)
movq 0x50(%r13), %r12
addq $0x50, %r14
movq %rsp, %r15
cmpq 0x58(%r13), %r12
je 0x27ec
movl (%r12), %edi
movl 0x4(%r12), %ebp
movq %rbx, %rsi
callq 0x246c
movl %eax, (%rsp)
movl %ebp, 0x4(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x30ce
addq $0x8, %r12
jmp 0x27bd
movq 0x50(%r13), %rax
cmpq %rax, %r12
je 0x27f9
movq %rax, 0x58(%r13)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/yuanboli233[P]interdyck_graph_reduce/graphtest.cpp
// Function: printGraphBlue(SummaryGraph&)
void printGraphBlue(SummaryGraph& sGraph){
    unordered_map<unsigned, unsigned> node2orig = sGraph.node2orignodeid;
    unordered_map<unsigned, string> eid2orig = sGraph.eid2origeidstring;
    for(unsigned i = 0; i < sGraph.nodes.size(); i++){
        SummaryNode* node = sGraph.nodes[i];
        if(node->belongto != node->id)
            continue;
        for(vector<NodewithEID>::iterator it = node->outBlueEdgeNodes.begin(); it != node->outBlueEdgeNodes.end(); it++){
            unsigned tonodeID = root(it->nodeID, sGraph);
            unsigned eid = it->edgeID;
            cout << node2orig[i] << "->" << node2orig[tonodeID] << "[label=\"o" << eid2orig[eid] << "\"]" << endl; 
        }

    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq 0x50(%rsp), %rdi
movq %rbx, %rsi
callq 0x3398
leaq 0x38(%rbx), %rsi
leaq 0x18(%rsp), %rdi
callq 0x361c
xorl %eax, %eax
leaq 0x50(%rsp), %r14
leaq 0x4813(%rip), %rbp      # 0x7058
movl %eax, 0xc(%rsp)
movl %eax, %ecx
movq 0x70(%rbx), %rdx
movq 0x78(%rbx), %rsi
subq %rdx, %rsi
sarq $0x3, %rsi
cmpq %rcx, %rsi
jbe 0x2935
movq (%rdx,%rcx,8), %r12
movl 0x68(%r12), %ecx
cmpl (%r12), %ecx
jne 0x292e
movq 0x50(%r12), %r13
cmpq 0x58(%r12), %r13
je 0x292a
movl (%r13), %edi
movq %rbx, %rsi
callq 0x246c
movl %eax, 0x14(%rsp)
movl 0x4(%r13), %eax
movl %eax, 0x10(%rsp)
movq %r14, %rdi
leaq 0xc(%rsp), %rsi
callq 0x544e
movl (%rax), %esi
movq 0x8724(%rip), %rdi      # 0xafd8
callq 0x2110
movq %rax, %rdi
leaq 0x4788(%rip), %rsi      # 0x704b
callq 0x21b0
movq %rax, %r15
movq %r14, %rdi
leaq 0x14(%rsp), %rsi
callq 0x544e
movl (%rax), %esi
movq %r15, %rdi
callq 0x2110
movq %rax, %rdi
leaq 0x4762(%rip), %rsi      # 0x704e
callq 0x21b0
movq %rax, %r15
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x5178
movq %r15, %rdi
movq %rax, %rsi
callq 0x2180
movq %rax, %rdi
movq %rbp, %rsi
callq 0x21b0
movq %rax, %rdi
callq 0x20c0
addq $0x8, %r13
jmp 0x287b
movl 0xc(%rsp), %eax
incl %eax
jmp 0x2845
leaq 0x18(%rsp), %rdi
callq 0x38e8
leaq 0x50(%rsp), %rdi
callq 0x3904
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x296d
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x38e8
leaq 0x50(%rsp), %rdi
callq 0x3904
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/yuanboli233[P]interdyck_graph_reduce/graphtest.cpp
// Function: exportMergeNodes(SummaryGraph&)
void exportMergeNodes(SummaryGraph& sGraph){
    unordered_map<unsigned, list<unsigned>*> mergemap;
    for(unsigned i = 0; i < sGraph.nodes.size(); i++){
        SummaryNode* node = sGraph.nodes[i];
        unsigned root = node->belongto;
        if(mergemap.find(root) == mergemap.end()){
            mergemap[root] = new list<unsigned>();
        }
        mergemap[root]->push_back(i);
    }

    ofstream out(merge_orig_to_colormerge);
    for(unordered_map<unsigned, list<unsigned>*>::iterator it = mergemap.begin(); it != mergemap.end(); it++){
        list<unsigned>* lst = it->second;
        unsigned root = it->first;
        out << root << ": ";
        for(list<unsigned>::iterator lit = lst->begin(); lit != lst->end(); lit++){
            out << *lit << " ";
        }
        out << endl;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rdi, %rbx
leaq 0x40(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
leaq 0x20(%rsp), %r12
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movl $0x3f800000, 0x10(%r12) # imm = 0x3F800000
movups %xmm0, 0x18(%r12)
xorl %eax, %eax
leaq 0x10(%rsp), %r14
leaq 0xc(%rsp), %r15
leaq 0x48(%rsp), %r13
movl %eax, 0x48(%rsp)
movl %eax, %eax
movq 0x70(%rbx), %rcx
movq 0x78(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x2cca
movq (%rcx,%rax,8), %rax
movl 0x68(%rax), %eax
movl %eax, 0xc(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x5ccc
testq %rax, %rax
jne 0x2cac
pushq $0x18
popq %rdi
callq 0x21c0
movq %rax, %rbp
movq %rax, 0x8(%rax)
movq %rax, (%rax)
andq $0x0, 0x10(%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x5d48
movq %rbp, (%rax)
movq %r14, %rdi
movq %r15, %rsi
callq 0x5d48
movq (%rax), %rdi
movq %r13, %rsi
callq 0x30ec
movl 0x48(%rsp), %eax
incl %eax
jmp 0x2c52
leaq 0x84d7(%rip), %rsi      # 0xb1a8
leaq 0x48(%rsp), %rdi
pushq $0x10
popq %rdx
callq 0x22e0
leaq 0x48(%rsp), %rbx
leaq 0x4357(%rip), %r14      # 0x7041
leaq 0x4345(%rip), %r15      # 0x7036
movq (%r12), %r12
testq %r12, %r12
je 0x2d45
movq 0x10(%r12), %r13
movl 0x8(%r12), %esi
movq %rbx, %rdi
callq 0x2110
movq %rax, %rdi
movq %r14, %rsi
callq 0x21b0
movq %r13, %rbp
movq (%rbp), %rbp
cmpq %r13, %rbp
je 0x2d3b
movl 0x10(%rbp), %esi
movq %rbx, %rdi
callq 0x2110
movq %rax, %rdi
movq %r15, %rsi
callq 0x21b0
jmp 0x2d1a
movq %rbx, %rdi
callq 0x20c0
jmp 0x2cf1
leaq 0x48(%rsp), %rdi
callq 0x2250
leaq 0x10(%rsp), %rdi
callq 0x3920
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2d6f
jmp 0x2d6f
movq %rax, %rbx
jmp 0x2d83
jmp 0x2d76
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x2250
leaq 0x10(%rsp), %rdi
callq 0x3920
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3aea
movq 0x18(%r14), %r13
leaq 0x70(%rbx), %r14
movslq %r13d, %rsi
movq %r14, %rdi
callq 0x3dda
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x3e70
leaq 0x70(%rsp), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq 0x3fe2
leaq 0x38(%rbx), %rdi
leaq 0x70(%rsp), %r15
movq %r15, %rsi
callq 0x4b80
movq %r15, %rdi
callq 0x38e8
movl 0x18(%rsp), %eax
incl %eax
movl %eax, 0x230(%rbx)
xorl %ebp, %ebp
testl %r13d, %r13d
cmovlel %ebp, %r13d
pushq $0x70
popq %r12
cmpl %ebp, %r13d
je 0x3a8d
movq %r12, %rdi
callq 0x21c0
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, 0x70(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x4c16
incl %ebp
jmp 0x3a4c
leaq 0x38(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x4052
movq %rsp, %rdi
callq 0x4e5a
leaq 0x38(%rsp), %rdi
callq 0x4e5a
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3acc
jmp 0x3acc
jmp 0x3ac7
movq %rax, %rbx
jmp 0x3ad7
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4e5a
leaq 0x38(%rsp), %rdi
callq 0x4e5a
movq %rbx, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, (%rdi)
movq $0x1, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movl $0x3f800000, 0x20(%rdi) # imm = 0x3F800000
movups %xmm0, 0x28(%rdi)
movb $0x0, (%rax)
movq 0x88(%rsi), %rsi
leaq 0x70(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x22d0
movl $0x0, 0xc(%rsp)
leaq 0x70(%rsp), %r15
leaq 0x10(%rsp), %r12
leaq 0x30(%rsp), %r13
movq %r15, %rdi
movq %r12, %rsi
callq 0x2040
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x3f77
movq %r14, %rdi
movq %r12, %rsi
callq 0x4396
testb %al, %al
je 0x3ee4
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4b24
leaq 0x50(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
pushq $0x1
popq %rdx
pushq $-0x1
popq %rcx
callq 0x21e0
movq %r13, %rdi
movq %rbp, %rsi
callq 0x2210
movq %rbp, %rdi
callq 0x2308
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4612
testq %rax, %rax
jne 0x3f6a
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4734
movl 0xc(%rsp), %ecx
movl %ecx, (%rax)
incl %ecx
movl %ecx, 0xc(%rsp)
movq %r13, %rdi
callq 0x2308
jmp 0x3ee4
leaq 0x70(%rsp), %rdi
callq 0x2060
leaq 0x10(%rsp), %rdi
callq 0x2308
movq %rbx, %rax
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3fa4
jmp 0x3fa4
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x2308
jmp 0x3fbd
jmp 0x3fba
movq %rax, %r14
jmp 0x3fc7
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0x2060
leaq 0x10(%rsp), %rdi
callq 0x2308
movq %rbx, %rdi
callq 0x4e5a
movq %r14, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4033
leaq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x5178
leaq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x20f0
jmp 0x4011
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x38e8
movq %r14, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x2c7e(%rip), %rsi      # 0x704b
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x3092
leaq 0x2cd8(%rip), %rsi      # 0x70bb
movq %r14, %rdi
xorl %edx, %edx
callq 0x20d0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x21e0
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
leaq 0x48(%rsp), %rsi
movq %r15, %rdi
xorl %edx, %edx
callq 0x2190
leaq 0x38(%rsp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movq %rax, %r14
movb %r12b, (%rcx)
leaq 0x98(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %r12b, (%rax)
leaq 0x68(%rsp), %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %r14, %rcx
callq 0x21e0
leaq 0x28(%rsp), %rdi
leaq 0x68(%rsp), %r15
movq %r15, %rsi
callq 0x2210
movq %r15, %rdi
callq 0x2308
addq 0x50(%rsp), %r14
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rsi
pushq $-0x1
popq %rcx
movq %r14, %rdx
callq 0x21e0
leaq 0x88(%rsp), %r14
leaq 0x68(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x2210
movq %r15, %rdi
callq 0x2308
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x45dc
leaq 0x88(%rsp), %rdi
callq 0x2308
leaq 0x28(%rsp), %rdi
callq 0x2308
leaq 0x8(%rsp), %rdi
callq 0x2308
leaq 0x48(%rsp), %rdi
callq 0x2308
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x44f5
jmp 0x44f5
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x2308
leaq 0x28(%rsp), %rdi
callq 0x2308
leaq 0x8(%rsp), %rdi
callq 0x2308
jmp 0x451e
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x2308
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O2/yuanboli233[P]interdyck_graph_reduce/./SummaryEdge.h
// Function: SummaryGraph::getEdgeLabel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string getEdgeLabel(const string& l){
        size_t b, e; 
        b = l.find_first_of("\"");
        e = l.find_last_of("\"");
        
        return l.substr(b+1, (e-b-1));
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x2594(%rip), %r15      # 0x70cd
movq %rdx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x20d0
movq %rax, %r12
pushq $-0x1
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x21a0
leaq 0x1(%r12), %rdx
notq %r12
addq %rax, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rcx
callq 0x21e0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rdi, %r14
leaq 0x8(%rsp), %rax
movl %edx, (%rax)
movl %ecx, 0x4(%rax)
movq %rsp, %r15
movl %esi, (%r15)
movl %ecx, 0x4(%r15)
movl %esi, %ecx
movq 0x70(%rdi), %rdx
movq (%rdx,%rcx,8), %rdi
addq $0x20, %rdi
movq %rax, %rsi
callq 0x30ce
movl %ebx, %eax
movq 0x70(%r14), %rcx
movq (%rcx,%rax,8), %rdi
addq $0x8, %rdi
movq %r15, %rsi
callq 0x30ce
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebx
movq %rdi, %r14
leaq 0x8(%rsp), %rax
movl %edx, (%rax)
movl %ecx, 0x4(%rax)
movq %rsp, %r15
movl %esi, (%r15)
movl %ecx, 0x4(%r15)
movl %esi, %ecx
movq 0x70(%rdi), %rdx
movq (%rdx,%rcx,8), %rdi
addq $0x50, %rdi
movq %rax, %rsi
callq 0x30ce
movl %ebx, %eax
movq 0x70(%r14), %rcx
movq (%rcx,%rax,8), %rdi
addq $0x38, %rdi
movq %r15, %rsi
callq 0x30ce
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/cesarblum[P]propertypp/test.cpp
// Function: Test::Test()
Test::Test()
{
    PROPERTYPP_INIT(b);
    PROPERTYPP_INIT(n);
    PROPERTYPP_INIT(m);
    PROPERTYPP_INIT(d);
    PROPERTYPP_INIT(o);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x68(%rdi)
movq %rdi, %rsi
callq 0x39b0
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x39ee
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x3a2c
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x3a6a
movq %rbx, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x3aaa
// File: /workspace/github_cpp_makefile_star2_O2/cesarblum[P]propertypp/test.cpp
// Function: Test::Test(Test const&)
Test::Test(const Test& rhs)
{
    PROPERTYPP_COPY(b, rhs);
    PROPERTYPP_COPY(n, rhs);
    PROPERTYPP_COPY(m, rhs);
    PROPERTYPP_COPY(d, rhs);
    PROPERTYPP_COPY(o, rhs);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x68(%rdi)
movq %rdi, %rsi
movq %rbx, %rdx
callq 0x3aea
movq %r14, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3b06
movq %r14, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3b24
movq %r14, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3b46
movq %r14, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3b68
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/alignment.cpp
// Function: Alignment_sp::SeqChange::getMutationStr[abi:cxx11]() const
string SeqChange::getMutationStr () const
{ 
  const string allele_ (allele. empty () 
                          ? "DEL" 
                          : allele == "*"
                              ? "STOP"
                              : allele
                       );
  return reference + to_string ((int) start_ref + 1 /* - al->ref_offset*/) + allele_; 
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x50(%rsi)
je 0x3f380
leaq 0x48(%r14), %r15
leaq 0x1f519(%rip), %rsi     # 0x5e884
movq %r15, %rdi
callq 0x2a6be
testb %al, %al
je 0x3f396
leaq 0x22d3d(%rip), %rsi     # 0x620bb
jmp 0x3f387
leaq 0x22371(%rip), %rsi     # 0x616f8
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xdbbe
jmp 0x3f3a3
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0xc7e0
movl 0x68(%r14), %esi
incl %esi
leaq 0x40(%rsp), %rdi
callq 0xe2d5
addq $0x28, %r14
movq %rsp, %rdi
leaq 0x40(%rsp), %rdx
movq %r14, %rsi
callq 0x2bbdd
movq %rsp, %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0xe7fa
movq %rsp, %rdi
callq 0xcbe8
leaq 0x40(%rsp), %rdi
callq 0xcbe8
leaq 0x20(%rsp), %rdi
callq 0xcbe8
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xcbe8
jmp 0x3f410
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xcbe8
jmp 0x3f41f
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xcbe8
movq %rbx, %rdi
callq 0xcaa0
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/alignment.cpp
// Function: Alignment_sp::SeqChange::better(Alignment_sp::SeqChange const&) const
bool SeqChange::better (const SeqChange &other) const
{ 
  LESS_PART (other, *this, hasMutation ());
  LESS_PART (*this, other, neighborhoodMismatch);  
  LESS_PART (other, *this, al->pIdentity ());  
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0x45c5a
movl %eax, %ebp
movq %r14, %rdi
callq 0x45c5a
movb $0x1, %bl
testb %al, %al
je 0x3f468
testb %bpl, %bpl
je 0x3f49f
movq %r14, %rdi
callq 0x45c5a
movl %eax, %ebp
movq %r15, %rdi
callq 0x45c5a
testb %al, %al
je 0x3f487
testb %bpl, %bpl
jne 0x3f487
xorl %ebx, %ebx
jmp 0x3f49f
movsd 0x80(%r14), %xmm0
movsd 0x80(%r15), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x3f4ac
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
ucomisd %xmm1, %xmm0
ja 0x3f483
movq 0x8(%r15), %rax
movq 0x8(%r14), %rcx
movq 0x200(%rcx), %xmm1
movq 0x200(%rax), %xmm0
punpcklqdq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0]
movdqa 0x22aaa(%rip), %xmm1    # 0x61f80
movdqa %xmm0, %xmm2
pand %xmm1, %xmm2
movdqa 0x22aaa(%rip), %xmm3    # 0x61f90
por %xmm3, %xmm2
psrlq $0x20, %xmm0
movdqa 0x22aa9(%rip), %xmm4    # 0x61fa0
por %xmm4, %xmm0
movapd 0x22aad(%rip), %xmm5    # 0x61fb0
subpd %xmm5, %xmm0
addpd %xmm2, %xmm0
movq 0x38(%rcx), %xmm2
movq 0x38(%rax), %xmm6
punpcklqdq %xmm2, %xmm6    # xmm6 = xmm6[0],xmm2[0]
pand %xmm6, %xmm1
por %xmm3, %xmm1
psrlq $0x20, %xmm6
por %xmm4, %xmm6
subpd %xmm5, %xmm6
addpd %xmm1, %xmm6
divpd %xmm6, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
ucomisd %xmm0, %xmm1
jbe 0x3f483
jmp 0x3f49f
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/alignment.cpp
// Function: Alignment_sp::SeqChange::finishPos(unsigned long)
bool SeqChange::finishPos (size_t flankingLen)
{
  setStartStopRef ();
  setStartTarget ();
  setNeighborhoodMismatch (flankingLen);
  ASSERT (! reference. empty ());
  if (verbose ())
    saveText (cout);
	return neighborhoodMismatch <= 0.04;   // PAR  // PD-3191
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %r14
movq %rdi, %rbx
callq 0x40298
movq %rbx, %rdi
callq 0x4057c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4085e
callq 0xc070
andl $0x0, (%rax)
cmpq $0x0, 0x30(%rbx)
je 0x40131
xorl %edi, %edi
callq 0x15d77
testb %al, %al
je 0x40113
movq 0x48e85(%rip), %rsi     # 0x88f90
movq %rbx, %rdi
callq 0x45c80
movsd 0x21ec5(%rip), %xmm0    # 0x61fe0
ucomisd 0x80(%rbx), %xmm0
setae %al
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
callq 0xc6d0
testl %eax, %eax
jne 0x40205
leaq 0x21ea3(%rip), %rsi     # 0x61fe8
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xdbbe
leaq 0x48(%rsp), %rdi
movl $0x129, %esi            # imm = 0x129
callq 0xe2d5
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0xe26e
leaq 0x1e050(%rip), %rdx     # 0x5e1d1
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0xe24f
leaq 0x222f8(%rip), %rsi     # 0x62495
leaq 0x8(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0xdbbe
leaq 0x1e719(%rip), %rdx     # 0x5e8cc
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xe24f
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0xe26e
leaq 0x220c7(%rip), %rdx     # 0x622aa
leaq 0xe8(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
callq 0xe24f
leaq 0xe8(%rsp), %rdi
callq 0x101d0
pushq $0x1
popq %rdi
callq 0xc6f0
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0xcbe8
jmp 0x40222
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0xcbe8
jmp 0x40234
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xcbe8
jmp 0x40243
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xcbe8
jmp 0x40252
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0xcbe8
jmp 0x40264
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0xcbe8
jmp 0x40276
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xcbe8
jmp 0x40285
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0xcbe8
movq %rbx, %rdi
callq 0xcaa0
nop
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/alignment.cpp
// Function: Alignment_sp::Alignment::set_nident()
void Alignment::set_nident ()
{
  ASSERT (targetSeq. size () == refSeq. size ());
  nident = 0;
  FFOR (size_t, i, targetSeq. size ())
    if (targetSeq [i] == refSeq [i])
      nident++;
}

// Assembly:
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdi, %rbx
callq 0xc070
andl $0x0, (%rax)
movq 0x38(%rbx), %rax
cmpq 0xa0(%rbx), %rax
jne 0x4262a
andq $0x0, 0x200(%rbx)
movq 0x30(%rbx), %rcx
movq 0x98(%rbx), %rdx
xorl %esi, %esi
xorl %edi, %edi
cmpq %rdi, %rax
je 0x42621
movb (%rcx,%rdi), %r8b
cmpb (%rdx,%rdi), %r8b
jne 0x4261c
incq %rsi
movq %rsi, 0x200(%rbx)
incq %rdi
jmp 0x42603
addq $0x110, %rsp            # imm = 0x110
popq %rbx
retq
callq 0xc6d0
testl %eax, %eax
jne 0x426fe
leaq 0x1f9aa(%rip), %rsi     # 0x61fe8
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xdbbe
leaq 0x50(%rsp), %rdi
movl $0x2a5, %esi            # imm = 0x2A5
callq 0xe2d5
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0xe26e
leaq 0x1bb57(%rip), %rdx     # 0x5e1d1
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0xe24f
leaq 0x2018f(%rip), %rsi     # 0x62825
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0xdbbe
leaq 0x1c220(%rip), %rdx     # 0x5e8cc
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xe24f
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0xe26e
leaq 0x200d8(%rip), %rdx     # 0x627b4
leaq 0xf0(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0xe24f
leaq 0xf0(%rsp), %rdi
callq 0x101d0
pushq $0x1
popq %rdi
callq 0xc6f0
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0xcbe8
jmp 0x4271b
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0xcbe8
jmp 0x4272d
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xcbe8
jmp 0x4273c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xcbe8
jmp 0x4274b
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xcbe8
jmp 0x4275d
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xcbe8
jmp 0x4276f
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xcbe8
jmp 0x4277e
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xcbe8
movq %rbx, %rdi
callq 0xcaa0
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/alignment.cpp
// Function: Alignment_sp::Alignment::getGlobalTargetStart() const
long Alignment::getGlobalTargetStart () const
{ 
  ASSERT (! targetProt);
  ASSERT (refProt);
  return targetStrand
           ? (long) targetStart - 3 * (long) refStart
           : (long) targetEnd   + 3 * (long) refStart; 
}

// Assembly:
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rdi, %rbx
callq 0xc070
andl $0x0, (%rax)
cmpb $0x1, 0x8(%rbx)
je 0x458ee
cmpb $0x0, 0x70(%rbx)
je 0x459c2
movzbl 0x68(%rbx), %eax
movl %eax, %ecx
xorl $0x1, %ecx
testl %eax, %eax
pushq $-0x3
popq %rdx
pushq $0x3
popq %rax
cmovneq %rdx, %rax
imulq 0xb8(%rbx), %rax
addq 0x50(%rbx,%rcx,8), %rax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
retq
callq 0xc6d0
testl %eax, %eax
jne 0x45a96
leaq 0x1c6e6(%rip), %rsi     # 0x61fe8
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xdbbe
leaq 0x50(%rsp), %rdi
movl $0x3ed, %esi            # imm = 0x3ED
callq 0xe2d5
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0xe26e
leaq 0x18893(%rip), %rdx     # 0x5e1d1
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0xe24f
leaq 0x1d359(%rip), %rsi     # 0x62cb3
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0xdbbe
leaq 0x18f5c(%rip), %rdx     # 0x5e8cc
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xe24f
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0xe26e
leaq 0x1d34e(%rip), %rdx     # 0x62cee
leaq 0xf0(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0xe24f
leaq 0xf0(%rsp), %rdi
callq 0x101d0
callq 0xc6d0
testl %eax, %eax
jne 0x45a96
leaq 0x1c612(%rip), %rsi     # 0x61fe8
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xdbbe
leaq 0x50(%rsp), %rdi
movl $0x3ee, %esi            # imm = 0x3EE
callq 0xe2d5
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0xe26e
leaq 0x187bf(%rip), %rdx     # 0x5e1d1
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0xe24f
leaq 0x1d285(%rip), %rsi     # 0x62cb3
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0xdbbe
leaq 0x18e88(%rip), %rdx     # 0x5e8cc
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xe24f
leaq 0xd0(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0xe26e
leaq 0x1d1c2(%rip), %rdx     # 0x62c36
leaq 0xf0(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0xe24f
leaq 0xf0(%rsp), %rdi
callq 0x101d0
pushq $0x1
popq %rdi
callq 0xc6f0
jmp 0x45aa2
jmp 0x45ab4
movq %rax, %rbx
leaq 0xf0(%rsp), %rdi
callq 0xcbe8
jmp 0x45ab7
movq %rax, %rbx
leaq 0xd0(%rsp), %rdi
callq 0xcbe8
jmp 0x45acb
jmp 0x45ac8
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xcbe8
jmp 0x45adc
jmp 0x45ad9
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xcbe8
jmp 0x45aed
jmp 0x45aea
movq %rax, %rbx
leaq 0xb0(%rsp), %rdi
callq 0xcbe8
jmp 0x45b01
jmp 0x45afe
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0xcbe8
jmp 0x45b15
jmp 0x45b12
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0xcbe8
jmp 0x45b26
jmp 0x45b23
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xcbe8
jmp 0x45b37
jmp 0x45b34
movq %rax, %rbx
movq %rbx, %rdi
callq 0xcaa0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2a336
addb $-0x61, %al
cmpb $0x19, %al
jae 0x45b98
movzbl %al, %eax
movl $0x16e34cf, %ecx        # imm = 0x16E34CF
btl %eax, %ecx
jae 0x45b98
leaq 0x1d27d(%rip), %rcx     # 0x62de9
movb (%rax,%rcx), %bpl
movsbl %bl, %edi
callq 0xc490
testl %eax, %eax
je 0x45b8d
movsbl %bpl, %edi
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x2a32e
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0xc310
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rsi
callq 0x2ce45
leaq 0x1d19d(%rip), %rsi     # 0x62d56
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0xe819
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0xc990
xorl %ebp, %ebp
movq 0x4340f(%rip), %rsi     # 0x88ff0
movq 0x43380(%rip), %rdx     # 0x88f68
movq %rbx, %rdi
callq 0xca40
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0xcbe8
jmp 0x45c05
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0xcbe8
testb %bpl, %bpl
jne 0x45c19
jmp 0x45c21
movq %rax, %r14
movq %rbx, %rdi
callq 0xc470
movq %r14, %rdi
callq 0xcaa0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rsi
incq %rsi
movq %rbx, %rdi
callq 0xc410
pushq $0x20
popq %rbp
movq %rax, %rdi
movl %ebp, %esi
callq 0xc690
movq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0xc410
movq %rax, %rdi
movl %ebp, %esi
callq 0xc690
movq %rax, %r15
leaq 0x28(%r14), %rsi
leaq 0x20(%rsp), %r12
pushq $0x22
popq %rdx
movq %r12, %rdi
callq 0x12085
movq %r15, %rdi
movq %r12, %rsi
callq 0xc540
leaq 0x1d013(%rip), %rsi     # 0x62d00
movq %rax, %rdi
callq 0xc5a0
movq %rax, %r15
leaq 0x48(%r14), %rsi
movq %rsp, %rdi
pushq $0x22
popq %rdx
callq 0x12085
movq %rsp, %rsi
movq %r15, %rdi
callq 0xc540
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0xc690
movq 0x68(%r14), %rsi
incq %rsi
movq %rax, %rdi
callq 0xc410
leaq 0x1b19c(%rip), %rsi     # 0x60ecf
movq %rax, %rdi
callq 0xc5a0
movq 0x70(%r14), %rsi
movq %rax, %rdi
callq 0xc410
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0xc690
movq 0x78(%r14), %rsi
incq %rsi
movq %rax, %rdi
callq 0xc410
pushq $0x20
popq %rsi
movq %rax, %rdi
callq 0xc690
movsd 0x80(%r14), %xmm0
movq %rax, %rdi
callq 0xc970
movq %rsp, %rdi
callq 0xcbe8
leaq 0x20(%rsp), %rdi
callq 0xcbe8
movq 0x88(%r14), %r15
movq 0x90(%r14), %r12
pushq $0x20
popq %rbp
cmpq %r12, %r15
je 0x45dc3
movq (%r15), %r14
movq %rbx, %rdi
movl %ebp, %esi
callq 0xc690
movq %r14, %rdi
movq %rbx, %rsi
callq 0x461b2
addq $0x8, %r15
jmp 0x45da0
movq %rbx, %rdi
callq 0xc300
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x45dda
movq %rax, %rbx
jmp 0x45dea
movq %rax, %rbx
movq %rsp, %rdi
callq 0xcbe8
leaq 0x20(%rsp), %rdi
callq 0xcbe8
movq %rbx, %rdi
callq 0xcaa0
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/./common.hpp
// Function: Common_sp::Vector<Alignment_sp::AmrMutation>::indexOf(Alignment_sp::AmrMutation const&) const
size_t indexOf (const T &value) const
      { size_t n = 0;
        for (const T& t : *this)
          if (value == t)
            return n;
          else
            n++;
        return no_index;
      }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %r15
movq 0x8(%rdi), %r12
addq $0x10, %rbx
xorl %r13d, %r13d
pushq $-0x1
popq %r14
cmpq %r12, %r15
je 0x45f41
addq $0x10, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2a27e
testb %al, %al
jne 0x45f3e
incq %r13
addq $0x118, %r15            # imm = 0x118
jmp 0x45f1a
movq %r13, %r14
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x46227
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
incq %rsi
movq %rax, %rdi
callq 0xc410
pushq $0x20
popq %rbp
movq %rax, %rdi
movl %ebp, %esi
callq 0xc690
leaq 0xa8(%rbx), %rsi
movq %rax, %rdi
callq 0xc540
movq %rax, %rdi
movl %ebp, %esi
callq 0xc690
movl 0xa0(%rbx), %esi
movq %rax, %rdi
callq 0xca50
movq %rax, %rdi
movl %ebp, %esi
callq 0xc690
addq $0x108, %rbx            # imm = 0x108
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc540
leaq 0x1cb3d(%rip), %rsi     # 0x62d6b
movq %rax, %rdi
jmp 0xc5a0
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/./alignment.hpp
// Function: Alignment_sp::Alignment::saveText(std::ostream&) const
void saveText (ostream &os) const override
    { os         << targetProt
         << '\t' << targetName 
         << '\t' << targetStart
         << '\t' << targetEnd 
         << '\t' << targetLen
         << '\t' << targetStrand
         << '\t' << refName
         << '\t' << refStart
         << '\t' << refEnd
         << '\t' << refLen
         << '\t' << nident
         << '\t' << targetSeq
         << '\t' << refSeq
         << endl;
      if (! refMutation. empty ())
        os << refMutation << endl;
	    os << "# Mutations: " << seqChanges. size () << endl;
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movzbl 0x8(%rdi), %esi
movq %r14, %rdi
callq 0xc9d0
pushq $0x9
popq %rbp
movq %rax, %rdi
movl %ebp, %esi
callq 0xc690
leaq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0xc540
movq %rax, %rdi
movl %ebp, %esi
callq 0xc690
movq 0x50(%rbx), %rsi
movq %rax, %rdi
callq 0xc410
movq %rax, %rdi
movl %ebp, %esi
callq 0xc690
movq 0x58(%rbx), %rsi
movq %rax, %rdi
callq 0xc410
movq %rax, %rdi
movl %ebp, %esi
callq 0xc690
movq 0x60(%rbx), %rsi
movq %rax, %rdi
callq 0xc410
movq %rax, %rdi
movl %ebp, %esi
callq 0xc690
movzbl 0x68(%rbx), %esi
movq %rax, %rdi
callq 0xc9d0
movq %rax, %rdi
movl %ebp, %esi
callq 0xc690
leaq 0x78(%rbx), %rsi
movq %rax, %rdi
callq 0xc540
movq %rax, %rdi
movl %ebp, %esi
callq 0xc690
movq 0xb8(%rbx), %rsi
movq %rax, %rdi
callq 0xc410
movq %rax, %rdi
movl %ebp, %esi
callq 0xc690
movq 0xc0(%rbx), %rsi
movq %rax, %rdi
callq 0xc410
movq %rax, %rdi
movl %ebp, %esi
callq 0xc690
movq 0xc8(%rbx), %rsi
movq %rax, %rdi
callq 0xc410
movq %rax, %rdi
movl %ebp, %esi
callq 0xc690
movq 0x200(%rbx), %rsi
movq %rax, %rdi
callq 0xc410
movq %rax, %rdi
movl %ebp, %esi
callq 0xc690
leaq 0x30(%rbx), %rsi
movq %rax, %rdi
callq 0xc540
movq %rax, %rdi
movl %ebp, %esi
callq 0xc690
leaq 0x98(%rbx), %rsi
movq %rax, %rdi
callq 0xc540
movq %rax, %rdi
callq 0xc300
cmpq $0x0, 0xe8(%rbx)
je 0x464f6
leaq 0xd0(%rbx), %rdi
movq 0xd0(%rbx), %rax
movq %r14, %rsi
callq *0x20(%rax)
movq %r14, %rdi
callq 0xc300
leaq 0x1c88a(%rip), %rsi     # 0x62d87
movq %r14, %rdi
callq 0xc5a0
movq %rax, %rdi
movq 0x220(%rbx), %rax
subq 0x218(%rbx), %rax
movl $0xb0, %ecx
cqto
idivq %rcx
movq %rax, %rsi
callq 0xc410
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc300
// File: /workspace/github_cpp_makefile_star2_O2/ncbi[P]amr/./common.hpp
// Function: Alignment_sp::AmrMutation const* Common_sp::checkPtr<Alignment_sp::AmrMutation const>(Alignment_sp::AmrMutation const*)
inline T* checkPtr (T* t)
    { if (t)
        return t;
      throwf ("Dereferencing nullptr");
      return nullptr;
    }

// Assembly:
pushq %rbx
subq $0x30, %rsp
testq %rdi, %rdi
je 0x46722
movq %rdi, %rax
addq $0x30, %rsp
popq %rbx
retq
leaq 0x1c648(%rip), %rsi     # 0x62d71
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0xdbbe
movq %rbx, %rdi
callq 0x101d0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xcbe8
movq %rbx, %rdi
callq 0xcaa0