LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2966(%rip), %r13      # 0x7067
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 0x47f3
movl $0x2, %ecx
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x2290
cmpq $-0x1, %rax
je 0x4706
movq %rbp, %rdi
movq 0x8(%rsp), %rsi
movq %r12, %rdx
callq 0x56a2
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 0x47a7
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x5204
testq %rax, %rax
jne 0x47ce
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x531c
movq (%rsp), %rcx
movl %ecx, (%rax)
incl %ecx
movq %rcx, (%rsp)
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x4706
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x4706
leaq 0x70(%rsp), %rdi
callq 0x2060
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x4819
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 0x4832
jmp 0x4832
movq %rax, %r14
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x485d
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x485d
jmp 0x485a
movq %rax, %r14
jmp 0x4867
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0x2060
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x4883
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x5964
movq %r14, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x48e5
leaq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x5bfa
leaq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x20c0
jmp 0x48c3
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3f8c
movq %r14, %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x21a4(%rip), %rsi      # 0x7067
leaq 0x219f(%rip), %rdx      # 0x7069
leaq 0x8(%rsp), %rdi
callq 0x5110
leaq 0x21fc(%rip), %rsi      # 0x70d7
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 0x4f81
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 0x4fc9
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
movq %rbx, %rdi
callq 0x51a0
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4ff2
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x68(%rsp), %rdi
cmpq %r13, %rdi
je 0x5009
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x502a
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x5046
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 0x505f
jmp 0x505f
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5079
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x68(%rsp), %rdi
cmpq %r13, %rdi
je 0x5090
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x98(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x50b6
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x50b6
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x50d2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1a32(%rip), %r15      # 0x70e9
movl $0x1, %ecx
movq %rdx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x2240
movq %rax, %r12
movl $0x1, %ecx
movq %r14, %rdi
movq %r15, %rsi
movq $-0x1, %rdx
callq 0x2300
leaq 0x1(%r12), %rdx
notq %r12
addq %rax, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rcx
callq 0x21c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x589a
movq 0x10(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x28(%rdi)
jmp 0x58a8
addq $0x20, %rdi
leaq 0x10(%rsp), %rdx
callq 0x61c0
movl %ebp, %eax
movq 0x70(%rbx), %rcx
movq (%rcx,%rax,8), %rdi
movq 0x10(%rdi), %rsi
cmpq 0x18(%rdi), %rsi
je 0x58cb
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x10(%rdi)
jmp 0x58d9
addq $0x8, %rdi
leaq 0x8(%rsp), %rdx
callq 0x61c0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x591e
movq 0x10(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x58(%rdi)
jmp 0x592c
addq $0x50, %rdi
leaq 0x10(%rsp), %rdx
callq 0x61c0
movl %ebp, %eax
movq 0x70(%rbx), %rcx
movq (%rcx,%rax,8), %rdi
movq 0x40(%rdi), %rsi
cmpq 0x48(%rdi), %rsi
je 0x594f
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x40(%rdi)
jmp 0x595d
addq $0x38, %rdi
leaq 0x8(%rsp), %rdx
callq 0x61c0
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3c6e
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x3ce8
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x3d66
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x3de4
movq %rbx, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x3e5e
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
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 0x3c6e
movb (%r14), %al
movb %al, (%rbx)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x3ce8
movl 0x18(%r14), %eax
movl %eax, 0x18(%rbx)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x3d66
movss 0x30(%r14), %xmm0
movss %xmm0, 0x30(%rbx)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x3de4
movsd 0x48(%r14), %xmm0
movsd %xmm0, 0x48(%rbx)
movq %rbx, %rdi
movq %rbx, %rsi
callq 0x3e5e
movq 0x60(%r14), %rax
movq %rax, 0x60(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x67f4b
movzbl %al, %eax
movl $0x16e34cf, %ecx        # imm = 0x16E34CF
btl %eax, %ecx
jae 0x67f4b
leaq 0x2ff03(%rip), %rcx     # 0x97e29
movb (%rax,%rcx), %bpl
movl %ebx, %edi
callq 0xb460
testl %eax, %eax
je 0x67f40
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 0x44ba7
leaq 0x2fe28(%rip), %rsi     # 0x97d96
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0xeaf5
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0xb960
xorl %ebp, %ebp
movq 0x5105a(%rip), %rsi     # 0xb8ff0
movq 0x50fd3(%rip), %rdx     # 0xb8f70
movq %rbx, %rdi
callq 0xba00
movq %rax, %r14
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x67fcb
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xb5a0
jmp 0x67fcb
movq %rax, %r14
movb $0x1, %bpl
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x67fee
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb5a0
jmp 0x67fee
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x67ffb
movq %rbx, %rdi
callq 0xb440
movq %r14, %rdi
callq 0xba60
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1500b
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0xb640
movq %rax, %r15
leaq 0x2fc95(%rip), %rsi     # 0x97d40
movl $0x4, %edx
movq %rax, %rdi
callq 0xb640
leaq 0x48(%r14), %rsi
leaq 0x28(%rsp), %rdi
movl $0x22, %edx
callq 0x1500b
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 0x2ddbf(%rip), %rsi     # 0x95eca
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 0x68189
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb5a0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x681a4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb5a0
movq 0x88(%r14), %r12
movq 0x90(%r14), %r13
cmpq %r13, %r12
je 0x681e9
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 0x685b2
addq $0x8, %r12
cmpq %r13, %r12
jne 0x681bc
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 0x68221
movq %rax, %rbx
jmp 0x68244
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x68244
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb5a0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6825f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb5a0
movq %rbx, %rdi
callq 0xba60
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x68658
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 0x2f74c(%rip), %rsi     # 0x97dab
movl $0x5, %edx
movq %rax, %rdi
jmp 0xb640
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6d228
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 0x8eb54
incq (%rax)
incq %r13
cmpq %r13, %r15
jne 0x6d20a
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x8fe1a
movq %r14, %rdi
callq 0xba60
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6d276
movq %rdi, %r14
cmpq $0x0, 0x278(%rdi)
je 0x6d27f
movq 0x270(%r14), %rax
cmpb $0x3e, (%rax)
jne 0x6d27f
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 0x8ebb8
leaq 0x2afcf(%rip), %rsi     # 0x98276
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xeaf5
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0xb960
xorl %ebp, %ebp
movq 0x4bd23(%rip), %rsi     # 0xb8ff0
movq 0x4bc9c(%rip), %rdx     # 0xb8f70
movq %rbx, %rdi
callq 0xba00
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6d302
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb5a0
jmp 0x6d302
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6d325
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb5a0
jmp 0x6d325
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x6d332
movq %rbx, %rdi
callq 0xb440
movq %r14, %rdi
callq 0xba60
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6d36d
cmpl $0x61, %ecx
je 0x6d412
cmpl $0x63, %ecx
jne 0x6d385
movl $0x1, %eax
jmp 0x6d41b
cmpl $0x67, %ecx
je 0x6d416
cmpl $0x74, %ecx
jne 0x6d385
movl $0x3, %eax
jmp 0x6d41b
movq 0x4c84c(%rip), %rdi     # 0xb9bd8
movsbl %al, %esi
callq 0xb230
movq %rax, %rcx
movl $0x4, %eax
testq %rcx, %rcx
jne 0x6d41b
movl $0x10, %edi
callq 0xb2d0
movq %rax, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movsbl %bpl, %edx
leaq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0xb670
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x22, %edx
callq 0x1500b
leaq 0x2aea7(%rip), %rsi     # 0x9828c
leaq 0x40(%rsp), %rdi
callq 0xbb10
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x6d428
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x6d434
xorl %eax, %eax
jmp 0x6d41b
movl $0x2, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %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 0x4bb8e(%rip), %rsi     # 0xb8ff0
movq 0x4bb07(%rip), %rdx     # 0xb8f70
movq %rbx, %rdi
callq 0xba00
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x6d492
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb5a0
jmp 0x6d492
movq %rax, %r14
movb $0x1, %bpl
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6d4b5
movq 0x50(%rsp), %rsi
incq %rsi
callq 0xb5a0
jmp 0x6d4b5
movq %rax, %r14
movb $0x1, %bpl
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x6d4d4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb5a0
jmp 0x6d4d4
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x6d4e1
movq %rbx, %rdi
callq 0xb440
movq %r14, %rdi
callq 0xba60
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6e67a
movq %r15, %r14
shrq %r14
cmpq $0x1, %r15
je 0x6e65a
cmpq $0x1, %r14
movq %r14, %r12
adcq $0x0, %r12
leaq -0x1(%r15), %r13
xorl %ebp, %ebp
movq (%rbx), %rax
movb (%rax,%rbp), %al
cmpb $0x2d, %al
je 0x6e624
movsbl %al, %edi
callq 0x6db4f
movq (%rbx), %rcx
movb %al, (%rcx,%rbp)
movq (%rbx), %rax
movb (%rax,%r13), %al
cmpb $0x2d, %al
je 0x6e63e
movsbl %al, %edi
callq 0x6db4f
movq (%rbx), %rcx
movb %al, (%rcx,%r13)
movq (%rbx), %rax
movb (%rax,%rbp), %cl
movb (%rax,%r13), %dl
movb %dl, (%rax,%rbp)
movb %cl, (%rax,%r13)
incq %rbp
decq %r13
cmpq %rbp, %r12
jne 0x6e60c
testb $0x1, %r15b
je 0x6e67a
movq (%rbx), %rax
movb (%rax,%r14), %al
cmpb $0x2d, %al
je 0x6e67a
movsbl %al, %edi
callq 0x6db4f
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_O1/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 0x70012
movq 0x10(%r14), %rax
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0xb5d0
leaq 0x28486(%rip), %rsi     # 0x984b1
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 0x7005b
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x70062
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 0x8fe6a
leaq 0x48854(%rip), %rax     # 0xb88e8
movq %rax, (%rbx)
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x700ad
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb5a0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x700c8
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb5a0
movq 0x30(%r14), %r15
testq %r15, %r15
je 0x70100
movq $-0x1, %r12
xorl %r13d, %r13d
movq 0x28(%r14), %rax
addq 0x30(%r14), %rax
movsbl (%r12,%rax), %edi
callq 0x6db4f
movq 0x28(%rbx), %rcx
movb %al, (%rcx,%r13)
incq %r13
decq %r12
cmpq %r13, %r15
jne 0x700db
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 0x7012f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb5a0
jmp 0x7012f
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7014f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb5a0
jmp 0x7014f
movq %rax, %r14
movl $0x50, %esi
movq %rbx, %rdi
callq 0xb5a0
movq %r14, %rdi
callq 0xba60
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq 0x8(%rdi), %r13
xorl %ebp, %ebp
leaq 0xc(%rsp), %r14
leaq 0xd(%rsp), %r12
movsd (%r13), %xmm0
ucomisd %xmm0, %xmm0
jp 0x76150
movb $0x20, 0xc(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb640
movb %bpl, 0xd(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0xb640
incq %rbp
addq $0x408, %r13            # imm = 0x408
cmpq $0x80, %rbp
jne 0x7611a
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 $0x8, %r15
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 0x76243
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 0x76204
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 0x761d5
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 0x7619e
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x763f4
leaq (%rax,%r15,8), %r13
movq 0x8(%rsp), %r14
xorl %r12d, %r12d
movq %r13, 0x10(%rsp)
movsd (%r14), %xmm0
ucomisd %xmm0, %xmm0
jp 0x763dd
movsd (%rcx,%r12,8), %xmm0
ucomisd (%r13), %xmm0
jbe 0x763dd
movl $0x4, %edx
movq 0x42cbc(%rip), %rbx     # 0xb8fa0
movq %rbx, %rdi
leaq 0x22653(%rip), %rsi     # 0x98941
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 0x225f0(%rip), %rsi     # 0x9893d
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 0x20d50(%rip), %rsi     # 0x970f9
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 0x762b7
incq %r15
addq $0x400, %rcx            # imm = 0x400
cmpq $0x80, %r15
jne 0x7628a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x799b5
movsbl %dil, %eax
cmpl $0x6e, %eax
jle 0x798fb
cmpl $0x77, %eax
jg 0x79923
cmpl $0x6f, %eax
je 0x798ef
cmpl $0x75, %eax
jne 0x79963
cmpb $0x2a, %bl
sete %bpl
jmp 0x799b5
cmpl $0x2a, %eax
je 0x7994a
cmpl $0x62, %eax
je 0x79967
cmpl $0x6a, %eax
jne 0x79963
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1ff20(%rip), %rsi     # 0x9983a
leaq 0x1ff1b(%rip), %rdx     # 0x9983c
jmp 0x7997e
cmpl $0x78, %eax
je 0x799b5
cmpl $0x7a, %eax
jne 0x79963
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1f235(%rip), %rsi     # 0x98b76
leaq 0x1f230(%rip), %rdx     # 0x98b78
jmp 0x7997e
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1f21f(%rip), %rsi     # 0x98b79
leaq 0x1f21a(%rip), %rdx     # 0x98b7b
jmp 0x7997e
xorl %ebp, %ebp
jmp 0x799b5
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1f1fc(%rip), %rsi     # 0x98b73
leaq 0x1f1f7(%rip), %rdx     # 0x98b75
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 0x799b5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb5a0
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ncbi[P]amr/seq.cpp
// Function: Seq_sp::Mutation::operator<(Seq_sp::Mutation const&) const
bool Mutation::operator< (const Mutation& other) const
{ 
  LESS_PART (*this, other, prot);
  LESS_PART (*this, other, geneName);
  LESS_PART (*this, other, pos);
  LESS_PART (*this, other, ref);
  LESS_PART (*this, other, allele);
  LESS_PART (*this, other, frameshift);
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movb 0x8(%rdi), %al
movb 0x8(%rsi), %cl
movb $0x1, %bl
cmpb %cl, %al
jb 0x863bc
jbe 0x86383
xorl %ebx, %ebx
jmp 0x863bc
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rdi), %r12
leaq 0x10(%rsi), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0xb050
testl %eax, %eax
js 0x863bc
movq %r13, %rdi
movq %r12, %rsi
callq 0xb050
testl %eax, %eax
js 0x8637f
movq 0x30(%r15), %rax
movq 0x30(%r14), %rcx
cmpq %rcx, %rax
jae 0x863c8
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
ja 0x8637f
leaq 0x38(%r15), %r12
leaq 0x38(%r14), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x8ef90
testb %al, %al
jne 0x863bc
movq %r13, %rdi
movq %r12, %rsi
callq 0x8ef90
testb %al, %al
jne 0x8637f
leaq 0x58(%r15), %r12
leaq 0x58(%r14), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x8ef90
testb %al, %al
jne 0x863bc
movq %r13, %rdi
movq %r12, %rsi
callq 0x8ef90
testb %al, %al
jne 0x8637f
movb 0x78(%r15), %al
cmpb 0x78(%r14), %al
setb %bl
jmp 0x863bc
jmp 0x86429
movq %rax, %rdi
callq 0xdd06
nop
// File: /workspace/github_cpp_makefile_star2_O1/ncbi[P]amr/seq.cpp
// Function: Seq_sp::KmerIndex::IdRecord::save() const
void KmerIndex::IdRecord::save () const
{         
  f. seekp ((streamoff) addr);
  writeBin (f, prev);
  FOR (size_t, i, textSize)
    f. put (text [i]);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
addq $0x10, %rdi
xorl %edx, %edx
callq 0xb6c0
movq (%rbx), %rdi
addq $0x10, %rdi
leaq 0x10(%rbx), %rsi
movl $0x8, %edx
callq 0xb770
movl $0x18, %r14d
movq (%rbx), %rdi
addq $0x10, %rdi
movsbl (%rbx,%r14), %esi
callq 0xb040
incq %r14
cmpq $0x30, %r14
jne 0x876c2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ncbi[P]amr/seq.cpp
// Function: Seq_sp::KmerIndex::IdRecord::get[abi:cxx11]() const
string KmerIndex::IdRecord::get () const
{
  string s; s. reserve (textSize);
  FOR_REV (size_t, i, start)
    s += text [i];
  return s;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl $0x18, %esi
callq 0xb900
movq 0x30(%r14), %rax
movq %rax, %r12
subq $0x1, %r12
jb 0x88583
movsbl 0x17(%r14,%rax), %esi
movq %rbx, %rdi
callq 0xb4f0
movq %r12, %rax
jmp 0x8856a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x88594
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x885aa
movq (%r15), %rsi
incq %rsi
callq 0xb5a0
movq %r14, %rdi
callq 0xba60
// File: /workspace/github_cpp_makefile_star2_O1/ncbi[P]amr/seq.cpp
// Function: Seq_sp::KmerIndex::getKmers()
size_t KmerIndex::getKmers ()
{
  size_t kmers = 0;
  f. seekg ((streamoff) code2addr (0));
  Progress prog (code_max, progressSize);  
  Addr addr = nil;
  FOR (size_t, i, code_max)
  {
    prog ();
    readBin (f, addr);
    if (addr != nil)
      kmers++;
  }
  return kmers;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0x28(%rdi), %r15
xorl %ebx, %ebx
movl $0x10, %esi
movq %r15, %rdi
xorl %edx, %edx
callq 0xb730
movq 0x248(%r14), %rsi
leaq 0x8(%rsp), %rdi
movl $0xf4240, %edx          # imm = 0xF4240
callq 0x1fc62
movq $-0x1, (%rsp)
cmpq $0x0, 0x248(%r14)
je 0x8a73b
xorl %ebx, %ebx
leaq 0x8(%rsp), %r13
movq %rsp, %rbp
xorl %r12d, %r12d
movq %r13, %rdi
leaq 0x2f3a3(%rip), %rsi     # 0xb9ab0
callq 0x1d1c8
movl $0x8, %edx
movq %r15, %rdi
movq %rbp, %rsi
callq 0xb710
xorl %eax, %eax
cmpq $-0x1, (%rsp)
setne %al
addq %rax, %rbx
incq %r12
cmpq 0x248(%r14), %r12
jb 0x8a703
leaq 0x8(%rsp), %rdi
callq 0x1fe7a
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1fe7a
movq %rbx, %rdi
callq 0xba60
// File: /workspace/github_cpp_makefile_star2_O1/ncbi[P]amr/./seq.hpp
// Function: Seq_sp::Cds::getOverlap(Seq_sp::Cds const&) const
size_t getOverlap (const Cds &other) const
    // Symmetric
    { if (other. left () >= right ())
    		return 0;
    	if (left () >= other. right ())
    		return 0;
    	if (left () <= other. left ())
    		return getOverlap_ (other);
    	return other. getOverlap_ (*this);
    }

// Assembly:
movq %rdi, %rax
movq 0x8(%rsi), %rdx
movq 0x10(%rsi), %r8
cmpq %rdx, %r8
movq %rdx, %rcx
cmovbq %r8, %rcx
movq 0x8(%rdi), %rdi
movq 0x10(%rax), %r9
cmpq %r9, %rdi
movq %r9, %r10
cmovaq %rdi, %r10
cmpq %r10, %rcx
jae 0x8ef85
cmpq %rdi, %r9
cmovbq %r9, %rdi
cmpq %r8, %rdx
cmovaq %rdx, %r8
cmpq %r8, %rdi
jae 0x8ef85
cmpq %rcx, %rdi
jbe 0x8ef88
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x7d252
xorl %eax, %eax
retq
movq %rax, %rdi
jmp 0x7d252
// File: /workspace/github_cpp_makefile_star2_O1/ncbi[P]amr/./seq.hpp
// Function: Seq_sp::PeptideOrf::saveText(std::ostream&) const
void saveText (ostream &os) const override
	  { os         << translationStart 
	  	   << '\t' << (int) strand 
	  	   << '\t' << start 
	  	   << '\t' << stop 
	  	   << '\t' << startM
	  	   << '\t' << stopTerminator;
	  }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq %rax, %rdi
callq 0xb3e0
movb $0x9, %bpl
leaq 0x3(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0xb640
movsbl 0x10(%rbx), %esi
movq %rax, %rdi
callq 0xba10
leaq 0x4(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0xb640
movq 0x18(%rbx), %rsi
movq %rax, %rdi
callq 0xb3e0
leaq 0x5(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0xb640
movq 0x28(%rbx), %rsi
movq %rax, %rdi
callq 0xb3e0
leaq 0x6(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0xb640
movzbl 0x20(%rbx), %esi
movq %rax, %rdi
callq 0xb9a0
leaq 0x7(%rsp), %rsi
movb %bpl, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0xb640
movzbl 0x30(%rbx), %esi
movq %rax, %rdi
callq 0xb9a0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ctSkennerton[P]fxtract/util/sock_x.c
// Function: main
int main(void)
{
    int     s, port;

    s = sock_bind(NULL, 0);             // (any i/f, any port)
    sock_addr(s, NULL, &port, NULL, 0);
    if (!fork()) push(sock_connect("127.0.0.1", port, 0));
    double  tt = pull(sock_accept(s));
    close(s);

    s = sock_create(SockPath);
    if (!fork()) push(sock_open(SockPath));
    double  tu = pull(sock_accept(s));
    close(s);

    // Compare to a std unix pipe (i.e. unix socket without the socket layer).
    int     p[2];
    pipe(p);
    if (!fork()) push(p[1]);
    close(p[1]);
    double  tp = pull(p[0]);

    fprintf(stderr, "%dMB tt=%.3f tu=%.3f tp=%.3f\n", BYTES/1024*COUNT/1024, tt, tu, tp);

    unlink(SockPath);
    return 0;
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
xorl %edi, %edi
xorl %esi, %esi
callq 0x4a68
movl %eax, %ebx
leaq 0x4(%rsp), %rdx
movl %eax, %edi
xorl %esi, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x5721
callq 0x3090
testl %eax, %eax
je 0x3774
movl %ebx, %edi
callq 0x4c30
movl %eax, %edi
callq 0x37e7
movsd %xmm0, 0x10(%rsp)
movl %ebx, %edi
callq 0x34f0
leaq 0x6bb2(%rip), %rdi      # 0xa290
callq 0x4c8e
movl %eax, %ebx
callq 0x3090
testl %eax, %eax
je 0x378d
movl %ebx, %edi
callq 0x4c30
movl %eax, %edi
callq 0x37e7
movsd %xmm0, 0x8(%rsp)
movl %ebx, %edi
callq 0x34f0
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x33e0
callq 0x3090
movl 0x4(%rbx), %edi
testl %eax, %eax
je 0x379b
callq 0x34f0
movl 0x18(%rsp), %edi
callq 0x37e7
movaps %xmm0, %xmm2
movq 0x68a2(%rip), %rax      # 0x9fe0
movq (%rax), %rdi
leaq 0x38c6(%rip), %rsi      # 0x700e
movl $0x400, %edx            # imm = 0x400
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
movb $0x3, %al
callq 0x3410
leaq 0x6b29(%rip), %rdi      # 0xa290
callq 0x3140
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
movl 0x4(%rsp), %esi
leaq 0x3885(%rip), %rdi      # 0x7004
xorl %edx, %edx
callq 0x4e97
movl %eax, %edi
callq 0x37a0
leaq 0x6afc(%rip), %rdi      # 0xa290
callq 0x4dbe
movl %eax, %edi
callq 0x37a0
// File: /workspace/github_cpp_makefile_star2_O1/ctSkennerton[P]fxtract/util/sock_x.c
// Function: pull
static double pull(int fd) 
{ 
    double  t = tick();
    while (0 < read(fd, buf, BYTES));
    close(fd);
    return tick() - t;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
callq 0x487a
movsd %xmm0, (%rsp)
leaq 0x7052(%rip), %r14      # 0xa850
movl $0x8000, %edx           # imm = 0x8000
movl %ebx, %edi
movq %r14, %rsi
callq 0x3420
testq %rax, %rax
jg 0x37fe
movl %ebx, %edi
callq 0x34f0
callq 0x487a
subsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH17_SpecializedLibraryFacilities/examples/rand4.cc
// Function: main
int main()
{
	default_random_engine e;  // generates unsigned random integers
	// uniformly distributed from 0 to 1 inclusive
	uniform_real_distribution<double> u(0,1);
	for (size_t i = 0; i < 10; ++i)
    	cout << u(e) << " ";
	cout << endl;

	// empty <> signify we want to use the default result type
	uniform_real_distribution<> u2(0,1); // generates double by default
	default_random_engine e2;
	for (size_t i = 0; i < 10; ++i)
    	cout << u2(e2) << " ";  // should generate the same sequence 
	cout << endl;

	default_random_engine e3;
	// uniformly distributed from 0 to 9 inclusive
	uniform_int_distribution<unsigned> u3(0,9);
	for (size_t i = 0; i < 100; ++i)
    	cout << u3(e3) << ((i != 99)? " ": "");
	cout << endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq -0x40(%rbp), %r14
movq $0x1, (%r14)
movl $0xa, %r12d
movq 0x2da3(%rip), %rbx      # 0x3fd8
leaq 0xe14(%rip), %r15       # 0x2050
movq %r14, %rdi
callq 0x1394
addsd 0xdbc(%rip), %xmm0      # 0x2008
movq %rbx, %rdi
callq 0x10c0
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x10a0
decq %r12
jne 0x123c
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1060
leaq -0x38(%rbp), %r15
movq $0x1, (%r15)
movl $0xa, %r12d
leaq 0xda8(%rip), %r14       # 0x2050
movq %r15, %rdi
callq 0x1394
addsd 0xd50(%rip), %xmm0      # 0x2008
movq %rbx, %rdi
callq 0x10c0
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x10a0
decq %r12
jne 0x12a8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1060
leaq -0x30(%rbp), %rax
movq $0x1, (%rax)
movabsq $0x900000000, %rax      # imm = 0x900000000
leaq -0x48(%rbp), %r12
movq %rax, (%r12)
movl $0x64, %r13d
leaq 0xd2b(%rip), %r15       # 0x2051
movq %r12, %rdi
leaq -0x30(%rbp), %rsi
movq %r12, %rdx
callq 0x14d6
movl %eax, %esi
movq %rbx, %rdi
callq 0x1050
xorl %edx, %edx
cmpq $0x1, %r13
setne %dl
movq %r15, %rsi
cmovneq %r14, %rsi
movq %rax, %rdi
callq 0x10a0
decq %r13
jne 0x1326
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1090
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1060
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH02_VariablesAndBasicTypes/examples/escape.cc
// Function: main
int main() {
	std::cout << '\n';       // prints a newline
	std::cout << "\tHi!\n";  // prints a tab followd by "Hi!" and a newline
	std::cout << "Hi \x4dO\115!\n"; // prints Hi MOM! followed by a newline
	std::cout << '\115' << '\n';    // prints M followed by a newline

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movb $0xa, %r14b
leaq -0x11(%rbp), %rsi
movb %r14b, (%rsi)
movq 0x2e20(%rip), %rbx      # 0x3fd8
movl $0x1, %edx
movq %rbx, %rdi
callq 0x1040
leaq 0xe38(%rip), %rsi       # 0x2004
movl $0x5, %edx
movq %rbx, %rdi
callq 0x1040
leaq 0xe2a(%rip), %rsi       # 0x200a
movl $0x8, %edx
movq %rbx, %rdi
callq 0x1040
leaq -0x12(%rbp), %rsi
movb $0x4d, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x1040
leaq -0x13(%rbp), %rsi
movb %r14b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x1040
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/eggnot[P]pixel_camera/matrix/lib/gpio.cc
// Function: rgb_matrix::GPIO::InitOutputs(unsigned int)
uint32_t GPIO::InitOutputs(uint32_t outputs) {
  if (gpio_port_ == NULL) {
    fprintf(stderr, "Attempt to init outputs but not yet Init()-ialized.\n");
    return 0;
  }

#ifdef ADAFRUIT_RGBMATRIX_HAT_PWM
  // Hack: the user soldered together GPIO 18 (new OE) with GPIO 4 (old OE).
  // We want to make extra sure that, whatever the outside system set as pinmux,
  // the old OE is not also set as output so that these GPIO outputs don't fight
  // each other.
  // So explicitly set this particular pin as input.
  INP_GPIO(4);
#endif

  outputs &= kValidBits;   // Sanitize input.
  output_bits_ = outputs;
  for (uint32_t b = 0; b <= 27; ++b) {
    if (outputs & (1 << b)) {
      INP_GPIO(b);   // for writing, we first need to set as input.
      OUT_GPIO(b);
    }
  }
  return output_bits_;
}

// Assembly:
pushq %rax
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x26cc
andl $0xfffffff, %esi        # imm = 0xFFFFFFF
movl %esi, (%rdi)
xorl %edx, %edx
movl $0xcccccccd, %r8d       # imm = 0xCCCCCCCD
xorl %r9d, %r9d
btl %r9d, %esi
jae 0x26bc
movl %r9d, %r10d
movq %r10, %rcx
imulq %r8, %rcx
shrq $0x23, %rcx
movl %ecx, %r11d
shll $0x5, %r11d
addl %ecx, %ecx
subl %r11d, %ecx
addl %edx, %ecx
movl $0x7, %r11d
shll %cl, %r11d
notl %r11d
imulq %r8, %r10
shrq $0x21, %r10
andl $-0x4, %r10d
andl %r11d, (%rax,%r10)
movl $0x1, %r11d
shll %cl, %r11d
orl %r11d, (%rax,%r10)
incl %r9d
addl $0x3, %edx
cmpl $0x1c, %r9d
jne 0x2671
movl (%rdi), %eax
popq %rcx
retq
callq 0x2310
xorl %eax, %eax
jmp 0x26ca
nop
// File: /workspace/github_cpp_makefile_star2_O1/eggnot[P]pixel_camera/matrix/lib/gpio.cc
// Function: rgb_matrix::GPIO::Init()
bool GPIO::Init() {
  gpio_port_ = mmap_bcm_register(IsRaspberryPi2(), GPIO_REGISTER_OFFSET);
  if (gpio_port_ == NULL) {
    return false;
  }
  gpio_set_bits_ = gpio_port_ + (0x1C / sizeof(uint32_t));
  gpio_clr_bits_ = gpio_port_ + (0x28 / sizeof(uint32_t));
  return true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2790
movzbl %al, %edi
movl $0x200000, %esi         # imm = 0x200000
callq 0x270d
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x2705
leaq 0x1c(%rax), %rcx
movq %rcx, 0x10(%rbx)
leaq 0x28(%rax), %rcx
movq %rcx, 0x18(%rbx)
testq %rax, %rax
setne %al
popq %rbx
retq