LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/kube[P]gradius/Player.cpp
// Function: Player::draw()
void  Player::draw() {
  int offsetX = (COLS - _world.getWidth()) / 2;
  int offsetY = (LINES - _world.getHeight()) / 2;

  attron(COLOR_PAIR(3));
  move(offsetY + _posY, offsetX + _posX);
  addch(_skin);
  attroff(COLOR_PAIR(3));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x3645(%rip), %rax      # 0x6fb8
movl (%rax), %r14d
movq 0x30(%rdi), %rdi
callq 0x350a
subl %eax, %r14d
movl %r14d, %ebp
shrl $0x1f, %ebp
addl %r14d, %ebp
sarl %ebp
movq 0x3614(%rip), %rax      # 0x6fa8
movl (%rax), %r14d
movq 0x30(%rbx), %rdi
callq 0x3506
subl %eax, %r14d
movl %r14d, %r15d
shrl $0x1f, %r15d
addl %r14d, %r15d
sarl %r15d
movq 0x3621(%rip), %r14      # 0x6fd8
movq (%r14), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %edx, %edx
callq 0x20b0
cvtsi2ss %r15d, %xmm0
addss 0xc(%rbx), %xmm0
cvttss2si %xmm0, %edi
xorps %xmm0, %xmm0
cvtsi2ss %ebp, %xmm0
addss 0x8(%rbx), %xmm0
cvttss2si %xmm0, %esi
callq 0x20d0
movq (%r14), %rdi
movl 0x2c(%rbx), %esi
callq 0x2070
movq (%r14), %rdi
movl $0x300, %esi            # imm = 0x300
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x21a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/kube[P]gradius/Player.cpp
// Function: Player::moveImpulsion(float, float)
void  Player::moveImpulsion(float x, float y) {
  _dirX += x;
  _dirY += y;

  _dirX = abs(_dirX) > _maxSpeed ? _dirX / abs(_dirX) * _maxSpeed : _dirX;
  _dirY = abs(_dirY) > _maxSpeed ? _dirY / abs(_dirY) * _maxSpeed : _dirY;
}

// Assembly:
addss 0x10(%rdi), %xmm0
addss 0x14(%rdi), %xmm1
movaps 0x4df(%rip), %xmm2      # 0x4010
movaps %xmm0, %xmm3
xorps %xmm2, %xmm3
maxss %xmm0, %xmm3
movss 0x24(%rdi), %xmm4
movaps %xmm0, %xmm5
divss %xmm3, %xmm5
mulss %xmm4, %xmm5
movaps %xmm4, %xmm6
cmpltss %xmm3, %xmm6
andps %xmm6, %xmm5
andnps %xmm0, %xmm6
orps %xmm5, %xmm6
movss %xmm6, 0x10(%rdi)
xorps %xmm1, %xmm2
maxss %xmm1, %xmm2
movaps %xmm1, %xmm0
divss %xmm2, %xmm0
mulss %xmm4, %xmm0
cmpltss %xmm2, %xmm4
andps %xmm4, %xmm0
andnps %xmm1, %xmm4
orps %xmm0, %xmm4
movss %xmm4, 0x14(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/tedsharpe[P]ORFCall/ORFCall.cc
// Function: (anonymous namespace)::seqFor[abi:cxx11](unsigned int)
std::string seqFor( Codon codon )
{
    std::string result;
    result.reserve(3);
    result.push_back("ACGT"[(codon >> 4) & 3]);
    result.push_back("ACGT"[(codon >> 2) & 3]);
    result.push_back("ACGT"[codon & 3]);
    return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl $0x3, %esi
callq 0x3300
movl $0x204, %eax            # imm = 0x204
bextrl %eax, %r14d, %eax
leaq 0x5790(%rip), %r12      # 0xcb96
movsbl (%rax,%r12), %esi
movq %rbx, %rdi
callq 0x31a0
movl $0x202, %eax            # imm = 0x202
bextrl %eax, %r14d, %eax
movsbl (%rax,%r12), %esi
movq %rbx, %rdi
callq 0x31a0
andl $0x3, %r14d
movsbl (%r14,%r12), %esi
movq %rbx, %rdi
callq 0x31a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x745a
callq 0x31c0
movq %r14, %rdi
callq 0x33a0
// File: /workspace/github_cpp_makefile_star2_O1/tedsharpe[P]ORFCall/ORFCall.cc
// Function: (anonymous namespace)::Reference::findAlignment(std::vector<unsigned char, std::allocator<unsigned char>> const&) const
ReadReport getReport() const
    {
        return ReadReport{mFirstCodonCovered,
                          Offset(mWTItr-mWTBeg),
                          mNMismatches,
                          mVariations};
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rdx), %r8
movq 0x8(%rdx), %r13
movq %r13, %rcx
subq %r8, %rcx
movl (%rsi), %eax
cmpq %rax, %rcx
jae 0x8039
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x9(%rdi)
vmovups %xmm0, (%rdi)
movq %rdi, %rax
jmp 0x815f
movq %rsi, 0x8(%rsp)
movq %rcx, 0x20(%rsp)
movq %rdi, 0x10(%rsp)
movq %r8, 0x18(%rsp)
subq %rax, %r13
leaq 0x1(%r13), %rax
movq %r8, (%rsp)
cmpq %rax, %r8
je 0x80dc
movq 0x8(%rsp), %rax
leaq 0x38(%rax), %r15
movl 0x38(%rax), %r12d
movq 0x48(%rax), %rbx
movabsq $0x100000001b3, %r14    # imm = 0x100000001B3
movq (%rsp), %rbp
movabsq $-0x340d631b7bdddcdb, %rcx # imm = 0xCBF29CE484222325
testq %r12, %r12
je 0x80ae
xorl %eax, %eax
movabsq $-0x340d631b7bdddcdb, %rdx # imm = 0xCBF29CE484222325
movzbl (%rbp,%rax), %ecx
xorq %rdx, %rcx
imulq %r14, %rcx
incq %rax
movq %rcx, %rdx
cmpq %rax, %r12
jne 0x8097
movq %rcx, %rax
xorl %edx, %edx
divq %rbx
movq %r15, %rdi
movq %rdx, %rsi
leaq 0x18(%rsp), %rdx
callq 0x76c2
testq %rax, %rax
jne 0x80f0
leaq 0x1(%rbp), %rax
movq %rax, 0x18(%rsp)
cmpq %r13, %rbp
movq %rax, %rbp
jne 0x807c
vxorps %xmm0, %xmm0, %xmm0
movq 0x10(%rsp), %rax
vmovups %xmm0, 0x9(%rax)
vmovups %xmm0, (%rax)
jmp 0x815f
movq 0x10(%rax), %rcx
subq (%rsp), %rbp
cmpq %rcx, %rbp
movq %rcx, %rdx
cmovbq %rbp, %rdx
subq %rdx, %rcx
subq %rdx, %rbp
movq 0x8(%rsp), %rsi
movq 0x10(%rsi), %rdx
subq 0x8(%rsi), %rdx
movq %rdx, %rsi
subq %rcx, %rsi
movq 0x20(%rsp), %r9
movq %r9, %rdi
subq %rbp, %rdi
cmpq %rsi, %rdi
cmovaeq %rsi, %rdi
movb 0x18(%rax), %r8b
subq %rcx, %rdx
subq %rdi, %rdx
subq %rbp, %r9
subq %rdi, %r9
testb %r8b, %r8b
cmoveq %rbp, %r9
cmoveq %rcx, %rdx
addq %rdx, %rdi
movq 0x10(%rsp), %rax
movq %rdx, (%rax)
movq %rdi, 0x8(%rax)
movq %r9, 0x10(%rax)
movb %r8b, 0x18(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/tedsharpe[P]ORFCall/ORFCall.cc
// Function: (anonymous namespace)::ORFCaller::dumpNonAligner(char const*, unsigned long, std::vector<unsigned char, std::allocator<unsigned char>> const&, std::vector<unsigned char, std::allocator<unsigned char>> const&)
void dumpNonAligner( char const* fileName, size_t readId,
                            Sequence const& seq, Quals const& quals )
    { if ( !mpJunkOS ) return;
      std::ostream& os = *mpJunkOS;
      os << '@' << fileName << ':' << readId << '\n';
      for ( Call call : seq ) os << charFor(call);
      os << "\n+\n";
      for ( Qual qual : quals ) os << (char)(qual+FASTQ_QUAL_OFFSET);
      os << '\n'; }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x50(%rdi), %rbx
testq %rbx, %rbx
je 0x82ae
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbp
leaq 0x4(%rsp), %rsi
movb $0x40, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x3210
movq %rax, %r13
testq %rbp, %rbp
je 0x81c7
movq %rbp, %rdi
callq 0x30e0
movq %r13, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x3210
jmp 0x81e2
movq (%r13), %rax
movq -0x18(%rax), %rax
movq %r13, %rdi
addq %rax, %rdi
movl 0x20(%r13,%rax), %esi
orl $0x1, %esi
callq 0x3360
leaq 0x5(%rsp), %rsi
movb $0x3a, (%rsi)
movl $0x1, %edx
movq %r13, %rdi
callq 0x3210
movq %rax, %rdi
movq %r12, %rsi
callq 0x3130
leaq 0x6(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x3210
movq (%r15), %r12
movq 0x8(%r15), %r13
cmpq %r13, %r12
je 0x8253
leaq 0x4b6d(%rip), %rbp      # 0xcd97
leaq 0x2(%rsp), %r15
movzbl (%r12), %eax
movb (%rax,%rbp), %al
movb %al, 0x2(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3210
incq %r12
cmpq %r13, %r12
jne 0x822f
leaq 0x4b39(%rip), %rsi      # 0xcd93
movl $0x3, %edx
movq %rbx, %rdi
callq 0x3210
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x8299
leaq 0x3(%rsp), %r14
movb (%r15), %al
addb $0x21, %al
movb %al, 0x3(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3210
incq %r15
cmpq %r12, %r15
jne 0x8278
leaq 0x7(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x3210
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tedsharpe[P]ORFCall/ORFCall.cc
// Function: (anonymous namespace)::ORFCaller::processAlignment(std::vector<unsigned char, std::allocator<unsigned char>> const&, std::vector<unsigned char, std::allocator<unsigned char>> const&, (anonymous namespace)::Alignment const&)
void processAlignment( Sequence const& seq, Quals const& quals,
                                Alignment const& aln )
    {
        mNAlignedReads += 1;
        ReadReport readReport = findAlternateCodons(seq,quals,aln);
        if ( readReport.mNMismatches > mMaxSeqErrs ||
                readReport.mVariations.size() > 1 )
            readReport = findIndels(aln,seq,quals);
        if ( readReport.mNMismatches <= mMaxSeqErrs )
            processReport(readReport);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
incq 0x38(%rdi)
movq %rsp, %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %r15, %r8
callq 0x83e4
movl 0xc(%rbx), %eax
cmpq %rax, 0x10(%r13)
ja 0x831d
movq 0x20(%rsp), %rax
subq 0x18(%rsp), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
cmpq $0x2, %rcx
jb 0x838f
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
movq %r14, %r8
callq 0x8546
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
vmovups 0x30(%rsp), %xmm0
vmovaps %xmm0, (%rsp)
vmovups 0x48(%rsp), %xmm0
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %rdi
vmovups %xmm0, 0x18(%rsp)
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x48(%rsp)
movq $0x0, 0x58(%rsp)
testq %rdi, %rdi
je 0x8380
callq 0x31c0
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x838f
callq 0x31c0
movl 0xc(%rbx), %eax
cmpq %rax, 0x10(%rsp)
ja 0x83a4
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x93ee
movq 0x18(%rsp), %rdi
addq $0x60, %rsp
testq %rdi, %rdi
je 0x83c0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x31c0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x83dc
callq 0x31c0
movq %rbx, %rdi
callq 0x33a0
// File: /workspace/github_cpp_makefile_star2_O1/tedsharpe[P]ORFCall/ORFCall.cc
// Function: (anonymous namespace)::ORFCaller::findAlternateCodons(std::vector<unsigned char, std::allocator<unsigned char>> const&, std::vector<unsigned char, std::allocator<unsigned char>> const&, (anonymous namespace)::Alignment const&)
ReadReport findAlternateCodons( Sequence const& seq,
                                    Quals const& quals,
                                    Alignment const& aln )
    {
        AlignmentScorer alignmentScorer(mRef,aln.getRefStart(),mMinQ);
        auto refItr(mRef.getRef().begin()+aln.getRefStart());
        auto refEnd(mRef.getRef().begin()+aln.getRefEnd());
        if ( !aln.isReadRC() )
        {
            auto readItr(seq.begin()+aln.getReadStart());
            auto qualItr(quals.begin()+aln.getReadStart());
            while ( refItr != refEnd )
            {
                alignmentScorer(*refItr,*readItr,*qualItr);
                ++refItr; ++readItr; ++qualItr;
            }
        }
        else
        {
            auto readItr(seq.rbegin()+aln.getReadStart());
            auto qualItr(quals.rbegin()+aln.getReadStart());
            while ( refItr != refEnd )
            {
                alignmentScorer(*refItr,complement(*readItr),*qualItr);
                ++refItr; ++readItr; ++qualItr;
            }
        }
        return alignmentScorer.getReport();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, 0x8(%rsp)
movq (%rsi), %rsi
movq (%r8), %rdx
movzbl 0x8(%r13), %ecx
leaq 0x10(%rsp), %rdi
callq 0x9550
movq (%r13), %rax
movq (%r12), %rbp
movq 0x8(%r12), %r15
movq 0x8(%rax), %r13
addq %rbp, %r13
cmpb $0x0, 0x18(%r12)
je 0x8492
subq %r15, %rbp
je 0x84d1
movq 0x10(%r12), %r15
notq %r15
movq 0x8(%r14), %r12
addq %r15, %r12
addq 0x8(%rbx), %r15
xorl %ebx, %ebx
leaq 0x10(%rsp), %r14
movzbl (%r13), %esi
movb (%r15,%rbx), %al
movl %eax, %ecx
xorb $0x3, %cl
cmpb $0x4, %al
movzbl %cl, %eax
movl $0x4, %ecx
cmovel %ecx, %eax
movzbl (%r12,%rbx), %ecx
movzbl %al, %edx
movq %r14, %rdi
callq 0x961e
incq %r13
decq %rbx
cmpq %rbx, %rbp
jne 0x845a
jmp 0x84d1
cmpq %r15, %rbp
je 0x84d1
movq %rbx, %rax
movq 0x10(%r12), %rbx
movq (%r14), %r12
addq %rbx, %r12
addq (%rax), %rbx
subq %rbp, %r15
xorl %ebp, %ebp
leaq 0x10(%rsp), %r14
movzbl (%r13,%rbp), %esi
movzbl (%rbx,%rbp), %edx
movzbl (%r12,%rbp), %ecx
movq %r14, %rdi
callq 0x961e
incq %rbp
cmpq %rbp, %r15
jne 0x84b2
leaq 0x70(%rsp), %rsi
movq -0x10(%rsi), %rax
movq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq -0x38(%rsi), %rax
subq -0x40(%rsi), %rax
sarq $0x2, %rax
movq %rax, 0x8(%rbx)
movq -0x8(%rsi), %rax
movq %rax, 0x10(%rbx)
leaq 0x18(%rbx), %rdi
callq 0x988e
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x8512
callq 0x31c0
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x852b
jmp 0x852b
movq %rax, %rbx
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x853d
callq 0x31c0
movq %rbx, %rdi
callq 0x33a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/tedsharpe[P]ORFCall/ORFCall.cc
// Function: (anonymous namespace)::AlignmentScorer::AlignmentScorer((anonymous namespace)::Reference const&, unsigned long, unsigned char)
AlignmentScorer( Reference const& ref, Offset refStart, Qual minQ )
    : mRefPos(refStart), mExonItr(ref.getORF().begin()), mNextExon{0,0},
      mWTBeg(ref.getORFWTCodons().begin()), mMinQ(minQ),
      mCodon(0), mPhase(0), mNCodonMismatches(0), mNHiQCalls(0),
      mFirstCodonCovered(0), mNMismatches(0)
    {
        while ( mExonItr->mEnd <= mRefPos )
        {
            mFirstCodonCovered += mExonItr->size();
            ++mExonItr;
        }
        mNextExon = *mExonItr;
        if ( mRefPos > mExonItr->mBegin )
            mFirstCodonCovered += mRefPos - mExonItr->mBegin;
        mPhase = mFirstCodonCovered % 3;
        mFirstCodonCovered = mFirstCodonCovered / 3;
        mWTItr = ref.getORFWTCodons().begin()+mFirstCodonCovered;
        mPlannedItr = ref.getPlannedMasks().begin()+mFirstCodonCovered;
        mCodon = *mWTItr >> ((3 - mPhase)*2);
    }

// Assembly:
movq %rdx, (%rdi)
movq 0x78(%rsi), %rax
movq %rax, 0x8(%rdi)
leaq 0x10(%rdi), %r8
vxorps %xmm0, %xmm0, %xmm0
vmovups %xmm0, 0x10(%rdi)
movq 0x90(%rsi), %r9
movq %r9, 0x20(%rdi)
vmovups %xmm0, 0x28(%rdi)
movb %cl, 0x38(%rdi)
vmovups %xmm0, 0x3c(%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x50(%rdi)
movq $0x0, 0x70(%rdi)
movq 0x8(%rax), %rcx
cmpq %rdx, %rcx
ja 0x95b8
xorl %r9d, %r9d
subq (%rax), %rcx
addq %rcx, %r9
movq 0x18(%rax), %rcx
addq $0x10, %rax
cmpq %rdx, %rcx
jbe 0x959d
movq %r9, 0x50(%rdi)
movq %rax, 0x8(%rdi)
vmovups (%rax), %xmm0
vmovups %xmm0, (%r8)
subq (%rax), %rdx
jbe 0x95cd
leaq 0x50(%rdi), %rax
addq %rdx, (%rax)
movq 0x50(%rdi), %rdx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
mulxq %rax, %rax, %rax
shrq %rax
leal (%rax,%rax,2), %ecx
subl %ecx, %edx
movl %edx, 0x40(%rdi)
movq %rax, 0x50(%rdi)
movq 0x90(%rsi), %rcx
leaq (%rcx,%rax,4), %rcx
movq %rcx, 0x28(%rdi)
shlq $0x3, %rax
addq 0xa8(%rsi), %rax
movq %rax, 0x30(%rdi)
addl %edx, %edx
xorb $0x6, %dl
shrxl %edx, (%rcx), %eax
movl %eax, 0x3c(%rdi)
vzeroupper
retq
// File: /workspace/github_cpp_makefile_star2_O1/tedsharpe[P]ORFCall/ORFCall.cc
// Function: (anonymous namespace)::AlignmentScorer::operator()(unsigned char, unsigned char, unsigned char)
void operator()( Call wtCall, Call call, Qual qual )
    {
        if ( mRefPos == mNextExon.mEnd )
            mNextExon = *++mExonItr;
        if ( mRefPos++ < mNextExon.mBegin )
        {
            if ( wtCall != call && qual >= mMinQ )
                mNMismatches += 1;
        }
        else
        {
            if ( qual >= mMinQ )
            {
                mNHiQCalls += 1;
                if ( wtCall != call )
                {
                    mNMismatches += 1;
                    mNCodonMismatches += 1;
                }
            }
            mCodon = (mCodon << 2) | call;
            if ( ++mPhase == 3 )
            {
                if ( mCodon != *mWTItr &&
                     ((1ul << mCodon) & *mPlannedItr) &&
                     mNHiQCalls == 3 )
                {
                    if ( mVariations.empty() )
                        mNMismatches -= mNCodonMismatches;
                    mVariations.push_back(
                        Variation{VariationType::ALTERNATE_CODON,
                                   Offset(mWTItr-mWTBeg),
                                   mCodon} );
                }
                mCodon = 0;
                mPhase = 0;
                mNCodonMismatches = 0;
                mNHiQCalls = 0;
                ++mWTItr;
                ++mPlannedItr;
            }
        }
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
cmpq 0x18(%rdi), %rax
jne 0x964b
leaq 0x10(%rbx), %rdi
movq 0x8(%rbx), %r8
leaq 0x10(%r8), %r9
movq %r9, 0x8(%rbx)
vmovdqu 0x10(%r8), %xmm0
vmovdqu %xmm0, (%rdi)
leaq 0x1(%rax), %rdi
movq %rdi, (%rbx)
cmpq 0x10(%rbx), %rax
jae 0x9673
cmpb %dl, %sil
je 0x970e
cmpb %cl, 0x38(%rbx)
ja 0x970e
incq 0x58(%rbx)
jmp 0x970e
cmpb %cl, 0x38(%rbx)
ja 0x9687
incl 0x48(%rbx)
cmpb %dl, %sil
je 0x9687
incq 0x58(%rbx)
incl 0x44(%rbx)
movl 0x3c(%rbx), %ecx
movl 0x40(%rbx), %esi
shll $0x2, %ecx
movzbl %dl, %eax
orl %ecx, %eax
movl %eax, 0x3c(%rbx)
incl %esi
movl %esi, 0x40(%rbx)
cmpl $0x3, %esi
jne 0x970e
leaq 0x3c(%rbx), %r14
movq 0x28(%rbx), %rcx
cmpl (%rcx), %eax
je 0x96f3
movq 0x30(%rbx), %rdx
movq (%rdx), %rdx
btq %rax, %rdx
jae 0x96f3
cmpl $0x3, 0x48(%rbx)
jne 0x96f3
leaq 0x60(%rbx), %rdi
movq 0x60(%rbx), %rdx
cmpq 0x68(%rbx), %rdx
jne 0x96d6
movl 0x44(%rbx), %edx
subq %rdx, 0x58(%rbx)
movq %rsp, %rsi
movl $0x0, (%rsi)
subq 0x20(%rbx), %rcx
sarq $0x2, %rcx
movq %rcx, 0x8(%rsi)
movl %eax, 0x10(%rsi)
callq 0x9716
vpxor %xmm0, %xmm0, %xmm0
vmovdqu %xmm0, (%r14)
vmovdqu 0x28(%rbx), %xmm0
vpaddq 0x2d87(%rip), %xmm0, %xmm0 # 0xc490
vmovdqu %xmm0, 0x28(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/tedsharpe[P]ORFCall/ORFCall.cc
// Function: (anonymous namespace)::AminoAcidNamer::getAACounts(unsigned long const*, std::vector<unsigned long, std::allocator<unsigned long>>*) const
void getAACounts( size_t const* codonCounts,
                            std::vector<size_t>* pAACounts ) const
    { std::vector<size_t>& aaCounts = *pAACounts;
      aaCounts.clear(); aaCounts.resize(mLabels.size());
      for ( size_t idx : mCodonToAA )
          aaCounts[idx] += *codonCounts++; }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rax
cmpq %rax, 0x8(%rdx)
je 0xa0b7
movq %rax, 0x8(%r15)
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0xb9a6
movq (%r15), %rax
xorl %ecx, %ecx
movq 0x20(%r14,%rcx), %rdx
movq (%rbx,%rcx), %rsi
addq %rsi, (%rax,%rdx,8)
addq $0x8, %rcx
cmpq $0x200, %rcx            # imm = 0x200
jne 0xa0c8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/comptotherescue[P]Fibonacci-Heap/keywordcounter.cpp
// Function: Fibops::Insert(int)
Fib* Insert(int a_ival)
	{
		Fib *node = new Fib(a_ival);
		
		if (m_pMax != NULL)
		{
			if (m_pMax->m_pLeftsib == m_pMax) {
				m_pMax->m_pLeftsib = node;
				node->m_pRightsib = m_pMax;
				node->m_pLeftsib = m_pMax;
				m_pMax->m_pRightsib = node;
			}
			else {
				m_pMax->m_pRightsib->m_pLeftsib = node;
				node->m_pRightsib = m_pMax->m_pRightsib;
				node->m_pLeftsib = m_pMax;
				m_pMax->m_pRightsib = node;
			}
			if (m_pMax->m_iData < a_ival) {
				m_pMax = node;
			}
		}
		else
		{
			m_pMax = node;
		}
		return node;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movl $0x30, %edi
callq 0x2160
movl $0x0, (%rax)
movl %r14d, 0x4(%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movb $0x0, 0x28(%rax)
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x2c5d
cmpq %rcx, 0x10(%rcx)
je 0x2c47
movq 0x18(%rcx), %rdx
movq %rax, 0x10(%rdx)
movq %rdx, 0x18(%rax)
jmp 0x2c4f
movq %rax, 0x10(%rcx)
movq %rcx, 0x18(%rax)
movq %rcx, 0x10(%rax)
movq %rax, 0x18(%rcx)
cmpl %r14d, 0x4(%rcx)
jge 0x2c60
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/comptotherescue[P]Fibonacci-Heap/keywordcounter.cpp
// Function: Fibops::IncreaseKey(Fib*, int)
void IncreaseKey(Fib *key, int a_iVal)
	{
		Fib* k;
		key->m_iData += a_iVal;
		//Check if the value is greater than it's parent
		if (NULL == key->m_pParent)
		{
			if (m_pMax->m_iData < key->m_iData)
			{
				m_pMax = key;
			}
			return;
		}
		if (key->m_pParent->m_iData < key->m_iData)
		{
			do
			{
				if (key->m_pRightsib == key)
				{ 
					key->m_pParent->m_pChild = NULL;
				}
				else
				{
					key->m_pParent->m_pChild = key->m_pRightsib;
					key->m_pLeftsib->m_pRightsib = key->m_pRightsib;
					key->m_pRightsib->m_pLeftsib = key->m_pLeftsib;
				}
				//Make childcut boolean true
				key->m_pParent->m_bChildcut = true;
				key->m_pParent->m_iDegree -= 1;
				m_pMax->m_pRightsib->m_pLeftsib = key;
				key->m_pRightsib = m_pMax->m_pRightsib;
				m_pMax->m_pRightsib = key;
				key->m_pLeftsib = m_pMax;
				if (m_pMax->m_iData < key->m_iData)
				{
					m_pMax = key;
				}
				k = key->m_pParent;
				key->m_pParent = NULL;
				key = k;
			} while (NULL != key->m_pParent && key->m_pParent->m_bChildcut == true); // check if parent's childcut is true
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
addl 0x4(%rsi), %edx
movl %edx, 0x4(%rsi)
movq 0x20(%rsi), %rax
testq %rax, %rax
je 0x2cf8
cmpl %edx, 0x4(%rax)
jge 0x2d03
movq (%rdi), %rax
movq 0x18(%rsi), %rcx
movq 0x20(%rsi), %rdx
cmpq %rsi, %rcx
je 0x2ca8
movq %rcx, 0x8(%rdx)
movq 0x10(%rsi), %rdx
movq %rcx, 0x18(%rdx)
movq 0x18(%rsi), %rcx
movq %rdx, 0x10(%rcx)
jmp 0x2cb0
movq $0x0, 0x8(%rdx)
movq 0x20(%rsi), %rcx
movb $0x1, 0x28(%rcx)
decl (%rcx)
movq 0x18(%rax), %rdx
movq %rsi, 0x10(%rdx)
movq %rdx, 0x18(%rsi)
movq %rsi, 0x18(%rax)
movq %rax, 0x10(%rsi)
movl 0x4(%rax), %edx
cmpl 0x4(%rsi), %edx
jge 0x2cdc
movq %rsi, (%rdi)
movq %rsi, %rax
movq $0x0, 0x20(%rsi)
movq 0x20(%rcx), %rdx
testq %rdx, %rdx
je 0x2d03
cmpb $0x0, 0x28(%rdx)
movq %rcx, %rsi
jne 0x2c85
jmp 0x2d03
movq (%rdi), %rax
cmpl %edx, 0x4(%rax)
jge 0x2d03
movq %rsi, (%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH07_Classes/examples/add_item.cc
// Function: main
int main()
{
	Sales_data data1, data2;
	if (read(cin, data1) && read(cin, data2)) {  // read the transactions
		if (data1.isbn() == data2.isbn()) {      // check isbns
			data1.combine(data2);                // add the transactions
			print(cout, data1);                  // print the results
			cout << endl;                        // followed by a newline 
		}
	} else
		cerr << "Input failed!" << endl;        

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
leaq -0x68(%rbp), %r14
movq %r14, -0x10(%r14)
xorl %eax, %eax
movq %rax, -0x8(%r14)
movb %al, (%r14)
movl %eax, 0x10(%r14)
movq %rax, 0x18(%r14)
leaq -0xb8(%rbp), %r15
movq %r15, -0x10(%r15)
movq %rax, -0x8(%r15)
movb %al, (%r15)
movl %eax, 0x10(%r15)
movq %rax, 0x18(%r15)
movq 0x2cde(%rip), %rdi      # 0x3fd8
leaq -0x78(%rbp), %rsi
callq 0x15f9
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x1336
movq 0x2cc0(%rip), %rdi      # 0x3fd8
leaq -0xc8(%rbp), %rsi
callq 0x15f9
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
je 0x13bc
movq 0x2cb3(%rip), %rbx      # 0x3ff0
leaq 0xcc0(%rip), %rsi       # 0x2004
movl $0xd, %edx
movq %rbx, %rdi
callq 0x10d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10a0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1060
movq -0xc8(%rbp), %rdi
cmpq %r15, %rdi
je 0x1393
movq -0xb8(%rbp), %rsi
incq %rsi
callq 0x10b0
movq -0x78(%rbp), %rdi
cmpq %r14, %rdi
je 0x13a8
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x10b0
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
addq %rsi, %rdx
leaq -0x48(%rbp), %rdi
callq 0x1500
leaq -0x88(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq -0xc8(%rbp), %rsi
movq -0xc0(%rbp), %rdx
addq %rsi, %rdx
leaq -0x98(%rbp), %rdi
callq 0x1500
movq -0x40(%rbp), %rdx
cmpq -0x90(%rbp), %rdx
jne 0x142b
testq %rdx, %rdx
je 0x1430
movq -0x98(%rbp), %rsi
movq -0x48(%rbp), %rdi
callq 0x10c0
testl %eax, %eax
sete %r13b
jmp 0x1433
xorl %r13d, %r13d
jmp 0x1433
movb $0x1, %r13b
movq -0x98(%rbp), %rdi
cmpq %rbx, %rdi
je 0x144e
movq -0x88(%rbp), %rsi
incq %rsi
callq 0x10b0
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x1463
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x10b0
testb %r13b, %r13b
je 0x1378
leaq -0x78(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x1670
movq 0x2b45(%rip), %rbx      # 0x3fc8
leaq -0x78(%rbp), %rsi
movq %rbx, %rdi
callq 0x16e7
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10a0
jmp 0x1365
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x14c7
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x10b0
jmp 0x14c7
jmp 0x14c4
movq %rax, %rbx
movq -0xc8(%rbp), %rdi
cmpq %r15, %rdi
je 0x14e2
movq -0xb8(%rbp), %rsi
incq %rsi
callq 0x10b0
movq -0x78(%rbp), %rdi
cmpq %r14, %rdi
je 0x14f7
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x10b0
movq %rbx, %rdi
callq 0x1120
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/src/casa.cpp
// Function: usage()
void usage(){
  std::cerr << "Usages: Skipping unknown option"  << std::endl;
  std::cerr << "Usage:  casa [-options] <PDBfile>" << std::endl;
  std::cerr << "Options: [-paramfile PARAMfile]" << std::endl;
  std::cerr << "         [-reffile REFfile]" << std::endl;
  std::cerr << "         [-sasafile SASAfile]" << std::endl;
  std::cerr << "         [-header]" << std::endl;
  std::cerr << "         [-predict]" << std::endl;
  std::cerr << "         [-cut Cutoff]" << std::endl;
  std::cerr << "         [-trj TRAJfile]" << std::endl;
  std::cerr << "         [-skip frames] [-start frame] [-stop frame]" << std::endl;  
  std::cerr << "         [-identification ID]" << std::endl;
  std::cerr << std::endl;
  exit(0);
}

// Assembly:
pushq %rbx
movq 0x3ec48c(%rip), %rbx    # 0x3f0ff0
leaq 0x374a5(%rip), %rsi     # 0x3c010
movq %rbx, %rdi
callq 0x42b0
movq %rax, %rdi
callq 0x4150
leaq 0x374ae(%rip), %rsi     # 0x3c030
movq %rbx, %rdi
callq 0x42b0
movq %rax, %rdi
callq 0x4150
leaq 0x374b9(%rip), %rsi     # 0x3c052
movq %rbx, %rdi
callq 0x42b0
movq %rax, %rdi
callq 0x4150
leaq 0x374c2(%rip), %rsi     # 0x3c072
movq %rbx, %rdi
callq 0x42b0
movq %rax, %rdi
callq 0x4150
leaq 0x374c7(%rip), %rsi     # 0x3c08e
movq %rbx, %rdi
callq 0x42b0
movq %rax, %rdi
callq 0x4150
leaq 0x374ce(%rip), %rsi     # 0x3c0ac
movq %rbx, %rdi
callq 0x42b0
movq %rax, %rdi
callq 0x4150
leaq 0x374ca(%rip), %rsi     # 0x3c0bf
movq %rbx, %rdi
callq 0x42b0
movq %rax, %rdi
callq 0x4150
leaq 0x374c7(%rip), %rsi     # 0x3c0d3
movq %rbx, %rdi
callq 0x42b0
movq %rax, %rdi
callq 0x4150
leaq 0x374c7(%rip), %rsi     # 0x3c0ea
movq %rbx, %rdi
callq 0x42b0
movq %rax, %rdi
callq 0x4150
leaq 0x374c9(%rip), %rsi     # 0x3c103
movq %rbx, %rdi
callq 0x42b0
movq %rax, %rdi
callq 0x4150
leaq 0x374e7(%rip), %rsi     # 0x3c138
movq %rbx, %rdi
callq 0x42b0
movq %rax, %rdi
callq 0x4150
movq %rbx, %rdi
callq 0x4150
xorl %edi, %edi
callq 0x4360
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Analyze.cpp
// Function: Analyze::Analyze()
Analyze::Analyze (){
  sel.clear();
  mol.clear();
  tdata.clear();
  fdata.clear();
  ndata=0;
  resel=false;
  ifile.clear();
  ofile.clear();
  verbose=false;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x3ea199(%rip), %rax    # 0x3f0990
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x80(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
movq %rax, 0x70(%rbx)
xorl %eax, %eax
movq %rax, 0x78(%rbx)
movb %al, 0x80(%rbx)
leaq 0xa0(%rbx), %rcx
movq %rcx, 0x90(%rbx)
movq %rax, 0x98(%rbx)
movb %al, 0xa0(%rbx)
movq 0x8(%rbx), %rsi
callq 0x12974
movq 0x20(%rbx), %rax
cmpq %rax, 0x28(%rbx)
je 0x6862
movq %rax, 0x28(%rbx)
movq 0x38(%rbx), %rax
cmpq %rax, 0x40(%rbx)
je 0x6870
movq %rax, 0x40(%rbx)
leaq 0x50(%rbx), %rdi
movq 0x50(%rbx), %rsi
callq 0x129c6
movl $0x0, 0x68(%rbx)
xorl %eax, %eax
movb %al, 0x6c(%rbx)
movq %rax, 0x78(%rbx)
movq 0x70(%rbx), %rcx
movb %al, (%rcx)
movq %rax, 0x98(%rbx)
movq 0x90(%rbx), %rcx
movb %al, (%rcx)
movb %al, 0xb0(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Analyze.cpp
// Function: Analyze::readTopology(Molecule*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Analyze::readTopology(Molecule* molin, std::string topin){
  if (topin.length() > 0){
    molin->readTopology(topin);
    molin->setMass();
    molin->setCharge();
  }
}

// Assembly:
cmpq $0x0, 0x8(%rdx)
je 0x6ff2
pushq %rbx
movq %rsi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
movl $0x1, %edx
callq 0x24d84
movq %rbx, %rdi
movl $0x1, %esi
callq 0x2505c
movq %rbx, %rdi
movl $0x1, %esi
popq %rbx
jmp 0x2529a
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Analyze.cpp
// Function: Analyze::setupMolSel(Molecule*)
void Analyze::setupMolSel(Molecule* molin){
  Molecule* tmpmol;

  molin->select(this->getSel(0));
  tmpmol=molin->copy();
  this->addMol(tmpmol);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xc(%rsp), %rdx
movl $0x0, (%rdx)
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x6eea
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
movl $0x1, %ecx
callq 0x257d4
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x704e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %r14, %rdi
movl $0x1, %esi
callq 0x24100
movq %rbx, %rdi
movq %rax, %rsi
callq 0x6f48
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x708e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Analyze.cpp
// Function: AnalyzeAverage::preAnalysis(Molecule*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void AnalyzeAverage::preAnalysis(Molecule* molin, std::string topin){
  this->readTopology(molin, topin);
  this->setupMolSel(molin);
  Molecule* refmol=molin->clone();
  this->readTopology(refmol, topin);
  this->setupMolSel(refmol);
  //Zero coordinates for future appending
  this->getMol(1)->zeroCoor();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x6486
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x10(%rax)
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0xd44e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x42e0
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x18(%rax)
movq %r15, %rdi
movl $0x1, %esi
movl $0x1, %edx
callq 0x23bb2
movq %rax, %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x6486
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0x10(%rax)
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0xd4b2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42e0
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x18(%rax)
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq $0x1, %rdx
jbe 0xd4ea
movq 0x8(%rax), %rdi
callq 0x25b6c
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2ee38(%rip), %rdi     # 0x3c329
movl $0x1, %esi
xorl %eax, %eax
callq 0x4440
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0xd50e
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0xd51f
movq (%r13), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rdi
callq 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Analyze.cpp
// Function: Analyze::centerOfGeometry(Molecule*, bool)
Coor Analyze::centerOfGeometry(Molecule *mol, bool selFlag){
  Coor cog=Coor(0.0, 0.0, 0.0);

  for (unsigned int i=0; i< mol->getAtmVecSize(); i++){
    if (selFlag == true && mol->getAtom(i)->getSel() == false){
      continue;
    }
    cog+=mol->getAtom(i)->getCoor();
  }

  if (selFlag == true){
    cog/=mol->getNAtomSelected();
  }
  else{
    cog/=mol->getNAtom();
  }

  return cog;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
callq 0x3a28c
movl $0x0, 0xc(%rsp)
movq %r14, %rdi
callq 0x24830
testl %eax, %eax
je 0xd6ec
leaq 0xc(%rsp), %r15
testb %bpl, %bpl
je 0xd6b4
movq %r14, %rdi
movq %r15, %rsi
callq 0x24776
movq %rax, %rdi
callq 0x14ae6
cmpb $0x0, (%rax)
je 0xd6d2
movq %r14, %rdi
movq %r15, %rsi
callq 0x24776
movq %rax, %rdi
callq 0x14abe
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3a2f8
movl 0xc(%rsp), %r12d
incl %r12d
movl %r12d, 0xc(%rsp)
movq %r14, %rdi
callq 0x24830
cmpl %eax, %r12d
jb 0xd697
movq %r14, %rdi
testb %bpl, %bpl
je 0xd6fb
callq 0x2585c
jmp 0xd700
callq 0x2577c
movl %eax, %eax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movq %rbx, %rdi
callq 0x3a4e6
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Analyze.cpp
// Function: Analyze::angle(Coor const&, Coor const&, Coor const&)
double Analyze::angle (const Coor& u, const Coor& v, const Coor& w){
  double angle;
  Coor dx, dy;
  double dp, nx, ny;

  dx=u-v;
  dy=w-v;

  nx=dx.norm();
  ny=dy.norm();

  dp=dx.dot(dy);

  angle=acos(dp/(nx*ny));

  return angle/PI*180.0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x3a27c
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x3a27c
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x3a360
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3a2ae
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3a360
movq %r14, %rdi
movq %r13, %rsi
callq 0x3a2ae
movq %rbx, %rdi
callq 0x3a598
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
callq 0x3a598
movsd %xmm0, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3a52c
movsd (%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
divsd %xmm1, %xmm0
callq 0x4290
divsd 0x3e3613(%rip), %xmm0   # 0x3f1308
mulsd 0x2e74b(%rip), %xmm0    # 0x3c448
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Atom.cpp
// Function: Atom::reset()
void Atom::reset(){
  tag="NoID";
  recname="ATOM";
  atmnum=0;
  atmname="    ";
  atmtype="  ";
  alt=" ";
  res=NULL;
  resname="   ";
  chn=NULL;
  chainid=" ";
  realid=" ";
  resid=0;
  coor=Coor(0.0, 0.0, 0.0);
  occu=0.0;
  bfac=0.0;
  elem=" ";
  segid="  ";
  sel=true;
  summary="";
  ss="";
  mass=1.0;
  charge=0.0;
  data.clear();
  bonds.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdx
leaq 0x27f7e(%rip), %rcx     # 0x3c64b
xorl %r12d, %r12d
movl $0x4, %r8d
xorl %esi, %esi
callq 0x4470
leaq 0x20(%rbx), %rdi
movq 0x28(%rbx), %rdx
leaq 0x27f64(%rip), %rcx     # 0x3c650
movl $0x4, %r8d
xorl %esi, %esi
callq 0x4470
movl %r12d, 0x40(%rbx)
leaq 0x48(%rbx), %rdi
movq 0x50(%rbx), %rdx
leaq 0x28f91(%rip), %rcx     # 0x3d69d
movl $0x4, %r8d
xorl %esi, %esi
callq 0x4470
leaq 0x68(%rbx), %rdi
movq 0x70(%rbx), %rdx
leaq 0x28f77(%rip), %r14     # 0x3d69f
movl $0x2, %r8d
xorl %esi, %esi
movq %r14, %rcx
callq 0x4470
leaq 0x88(%rbx), %rdi
movq 0x90(%rbx), %rdx
leaq 0x28f53(%rip), %r15     # 0x3d6a0
movl $0x1, %r8d
xorl %esi, %esi
movq %r15, %rcx
callq 0x4470
movq %r12, 0xa8(%rbx)
leaq 0xb0(%rbx), %rdi
movq 0xb8(%rbx), %rdx
leaq 0x28f25(%rip), %rcx     # 0x3d69e
movl $0x3, %r8d
xorl %esi, %esi
callq 0x4470
movq %r12, 0xd0(%rbx)
leaq 0xd8(%rbx), %rdi
movq 0xe0(%rbx), %rdx
movl $0x1, %r8d
xorl %esi, %esi
movq %r15, %rcx
callq 0x4470
leaq 0xf8(%rbx), %rdi
movq 0x100(%rbx), %rdx
movl $0x1, %r8d
xorl %esi, %esi
movq %r15, %rcx
callq 0x4470
movl %r12d, 0x118(%rbx)
movq %rsp, %r12
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r12, %rdi
callq 0x3a28c
leaq 0x140(%rbx), %rdi
movq %r12, %rsi
callq 0x3a2ae
leaq 0x1e0(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x158(%rbx)
movq 0x1e8(%rbx), %rdx
movl $0x1, %r8d
xorl %esi, %esi
movq %r15, %rcx
callq 0x4470
leaq 0x168(%rbx), %rdi
movq 0x170(%rbx), %rdx
movl $0x2, %r8d
xorl %esi, %esi
movq %r14, %rcx
callq 0x4470
movb $0x1, 0x188(%rbx)
leaq 0x190(%rbx), %rdi
movq 0x198(%rbx), %rdx
leaq 0x27c61(%rip), %r14     # 0x3c4b6
xorl %esi, %esi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x4470
leaq 0x1b0(%rbx), %rdi
movq 0x1b8(%rbx), %rdx
xorl %esi, %esi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x4470
movsd 0x27bcb(%rip), %xmm0    # 0x3c450
movups %xmm0, 0x1d0(%rbx)
movq 0x208(%rbx), %rax
cmpq %rax, 0x210(%rbx)
je 0x148a3
movq %rax, 0x210(%rbx)
movq 0x220(%rbx), %rax
cmpq %rax, 0x228(%rbx)
je 0x148ba
movq %rax, 0x228(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Atom.cpp
// Function: Atom::clone(Atom*)
void Atom::clone(Atom* atmin){
  tag=atmin->getTag();
  recname=atmin->getRecName();
  atmnum=atmin->getAtmNum();
  atmname=atmin->getAtmName();
  atmtype=atmin->getAtmType();
  alt=atmin->getAlt();
  res=atmin->getResidue();
  resname=atmin->getResName();
  chn=atmin->getChain();
  chainid=atmin->getChainId();
  realid=atmin->getRealId();
  resid=atmin->getResId();
  icode=atmin->getICode();
  coor=atmin->getCoor();
  occu=atmin->getOccu();
  bfac=atmin->getBFac();
  elem=atmin->getElem();
  segid=atmin->getSegId();
  sel=atmin->getSel();
  summary=atmin->getSummary();
  ss=atmin->getSS();
  mass=atmin->getMass();
  charge=atmin->getCharge();
  atminx=atmin->getAtmInx();
  data=atmin->getData();
  bonds=atmin->getBonds();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4180
leaq 0x20(%rbx), %rsi
leaq 0x20(%r14), %rdi
callq 0x4180
movl 0x40(%rbx), %eax
movl %eax, 0x40(%r14)
leaq 0x48(%rbx), %rsi
leaq 0x48(%r14), %rdi
callq 0x4180
leaq 0x68(%rbx), %rsi
leaq 0x68(%r14), %rdi
callq 0x4180
movl $0x88, %edi
leaq (%rbx,%rdi), %rsi
addq %r14, %rdi
callq 0x4180
movq 0xa8(%rbx), %rax
movq %rax, 0xa8(%r14)
movl $0xb0, %edi
leaq (%rbx,%rdi), %rsi
addq %r14, %rdi
callq 0x4180
movq 0xd0(%rbx), %rax
movq %rax, 0xd0(%r14)
movl $0xd8, %edi
leaq (%rbx,%rdi), %rsi
addq %r14, %rdi
callq 0x4180
movl $0xf8, %edi
leaq (%rbx,%rdi), %rsi
addq %r14, %rdi
callq 0x4180
movl 0x118(%rbx), %eax
movl %eax, 0x118(%r14)
movl $0x120, %edi            # imm = 0x120
leaq (%rbx,%rdi), %rsi
addq %r14, %rdi
callq 0x4180
movl $0x140, %edi            # imm = 0x140
leaq (%rbx,%rdi), %rsi
addq %r14, %rdi
callq 0x3a2ae
movsd 0x158(%rbx), %xmm0
movsd %xmm0, 0x158(%r14)
movsd 0x160(%rbx), %xmm0
movsd %xmm0, 0x160(%r14)
movl $0x1e0, %edi            # imm = 0x1E0
leaq (%rbx,%rdi), %rsi
addq %r14, %rdi
callq 0x4180
movl $0x168, %edi            # imm = 0x168
leaq (%rbx,%rdi), %rsi
addq %r14, %rdi
callq 0x4180
movb 0x188(%rbx), %al
movb %al, 0x188(%r14)
movl $0x190, %edi            # imm = 0x190
leaq (%rbx,%rdi), %rsi
addq %r14, %rdi
callq 0x4180
movl $0x1b0, %edi            # imm = 0x1B0
leaq (%rbx,%rdi), %rsi
addq %r14, %rdi
callq 0x4180
movsd 0x1d0(%rbx), %xmm0
movsd %xmm0, 0x1d0(%r14)
movsd 0x1d8(%rbx), %xmm0
movsd %xmm0, 0x1d8(%r14)
movl 0x200(%rbx), %eax
movl %eax, 0x200(%r14)
movl $0x208, %edi            # imm = 0x208
leaq (%rbx,%rdi), %rsi
addq %r14, %rdi
callq 0x1261c
movl $0x220, %eax            # imm = 0x220
addq %rax, %rbx
addq %rax, %r14
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x15190
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/Atom.cpp
// Function: Atom::dummy()
void Atom::dummy(){
  tag="NoID";
  recname="ATOM";
  atmnum=1;
  atmname="CA";
  atmtype="C.3";
  alt=" ";
  res=NULL;
  resname="ALA";
  chn=NULL;
  chainid="+";
  realid="+";
  resid=999;
  coor=Coor(0.0, 0.0, 0.0);
  occu=0.0;
  bfac=0.0;
  elem=" ";
  segid="DUMY";
  sel=true;
  summary="";
  ss="";
  mass=1.0;
  charge=0.0;
  atminx=std::numeric_limits<unsigned int>::max();
  data.clear();
  bonds.clear();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdx
leaq 0x27b0e(%rip), %rcx     # 0x3c64b
xorl %r15d, %r15d
movl $0x4, %r8d
xorl %esi, %esi
callq 0x4470
leaq 0x20(%rbx), %rdi
movq 0x28(%rbx), %rdx
leaq 0x27af4(%rip), %rcx     # 0x3c650
movl $0x4, %r8d
xorl %esi, %esi
callq 0x4470
movl $0x1, 0x40(%rbx)
leaq 0x48(%rbx), %rdi
movq 0x50(%rbx), %rdx
leaq 0x276fe(%rip), %rcx     # 0x3c27d
movl $0x2, %r8d
xorl %esi, %esi
callq 0x4470
leaq 0x68(%rbx), %rdi
movq 0x70(%rbx), %rdx
leaq 0x27aba(%rip), %rcx     # 0x3c655
movl $0x3, %r8d
xorl %esi, %esi
callq 0x4470
leaq 0x88(%rbx), %rdi
movq 0x90(%rbx), %rdx
leaq 0x28ae3(%rip), %r14     # 0x3d6a0
movl $0x1, %r8d
xorl %esi, %esi
movq %r14, %rcx
callq 0x4470
movq %r15, 0xa8(%rbx)
leaq 0xb0(%rbx), %rdi
movq 0xb8(%rbx), %rdx
leaq 0x27c14(%rip), %rcx     # 0x3c7fd
movl $0x3, %r8d
xorl %esi, %esi
callq 0x4470
movq %r15, 0xd0(%rbx)
leaq 0xd8(%rbx), %rdi
movq 0xe0(%rbx), %rdx
leaq 0x27a47(%rip), %r15     # 0x3c659
movl $0x1, %r8d
xorl %esi, %esi
movq %r15, %rcx
callq 0x4470
leaq 0xf8(%rbx), %rdi
movq 0x100(%rbx), %rdx
movl $0x1, %r8d
xorl %esi, %esi
movq %r15, %rcx
callq 0x4470
movl $0x3e7, 0x118(%rbx)     # imm = 0x3E7
leaq 0x8(%rsp), %r15
xorps %xmm0, %xmm0
xorps %xmm1, %xmm1
xorps %xmm2, %xmm2
movq %r15, %rdi
callq 0x3a28c
leaq 0x140(%rbx), %rdi
movq %r15, %rsi
callq 0x3a2ae
leaq 0x1e0(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x158(%rbx)
movq 0x1e8(%rbx), %rdx
movl $0x1, %r8d
xorl %esi, %esi
movq %r14, %rcx
callq 0x4470
leaq 0x168(%rbx), %rdi
movq 0x170(%rbx), %rdx
leaq 0x279af(%rip), %rcx     # 0x3c65b
movl $0x4, %r8d
xorl %esi, %esi
callq 0x4470
movb $0x1, 0x188(%rbx)
leaq 0x190(%rbx), %rdi
movq 0x198(%rbx), %rdx
leaq 0x277e1(%rip), %r14     # 0x3c4b6
xorl %esi, %esi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x4470
leaq 0x1b0(%rbx), %rdi
movq 0x1b8(%rbx), %rdx
xorl %esi, %esi
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x4470
movsd 0x2774b(%rip), %xmm0    # 0x3c450
movups %xmm0, 0x1d0(%rbx)
movl $0xffffffff, 0x200(%rbx) # imm = 0xFFFFFFFF
movq 0x208(%rbx), %rax
cmpq %rax, 0x210(%rbx)
je 0x14d2d
movq %rax, 0x210(%rbx)
movq 0x220(%rbx), %rax
cmpq %rax, 0x228(%rbx)
je 0x14d44
movq %rax, 0x228(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/CASA.cpp
// Function: CASA::setHist(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double const&)
void CASA::setHist(const std::string &key, const double &val){
    if (this->hist.find (key) != this->hist.end()){
      this->hist.at(key) = val;
    } else {
      this->hist.insert(std::pair<std::string, double>(key, val));
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x78(%rdi), %rbx
movq %rbx, %rdi
callq 0x2045c
subq $-0x80, %r12
cmpq %r12, %rax
je 0x1f475
movsd (%r14), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1fda6
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
jmp 0x1f4c3
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x6486
movsd (%r14), %xmm0
movsd %xmm0, 0x20(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2028e
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x1f4c3
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x1f4e9
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rdi
callq 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/CASA.cpp
// Function: CASA::accumHist(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double const&)
void CASA::accumHist(const std::string &key, const double &val){
    if (this->hist.find (key) != this->hist.end()){
      this->hist.at(key) += val;
    } else {
      this->hist.insert(std::pair<std::string, double>(key, val));
    }
    
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x78(%rdi), %rbx
movq %rbx, %rdi
callq 0x2045c
subq $-0x80, %r12
cmpq %r12, %rax
je 0x1f541
movsd (%r14), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1fda6
movsd 0x8(%rsp), %xmm0
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
jmp 0x1f58f
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x6486
movsd (%r14), %xmm0
movsd %xmm0, 0x20(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2028e
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x1f58f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x1f5b5
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42e0
movq %rbx, %rdi
callq 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O1/atfrank[P]PCASA/lib/CASA.cpp
// Function: CASA::getRefSASA(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
double CASA::getRefSASA(const std::string &key){
    if (this->refSASA.find (key) == this->refSASA.end()){
        return 0.0;
    } else {
        return (this->refSASA.at(key));
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x18(%rdi), %r14
movq %r14, %rdi
callq 0x2045c
addq $0x20, %r15
cmpq %r15, %rax
je 0x1f989
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1fda6
movsd (%rax), %xmm0
jmp 0x1f98c
xorps %xmm0, %xmm0
popq %rbx
popq %r14
popq %r15
retq