LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tedsharpe[P]ORFCall/ORFCall.cc
// Function: (anonymous namespace)::ORFCaller::writeCodonCounts(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ORFCaller::writeCodonCounts( std::string const& filename )
{
    std::ofstream ofs(filename);
    ofs <<
"AAA\tAAC\tAAG\tAAT\tACA\tACC\tACG\tACT\tAGA\tAGC\tAGG\tAGT\tATA\tATC\tATG\tATT\t"
"CAA\tCAC\tCAG\tCAT\tCCA\tCCC\tCCG\tCCT\tCGA\tCGC\tCGG\tCGT\tCTA\tCTC\tCTG\tCTT\t"
"GAA\tGAC\tGAG\tGAT\tGCA\tGCC\tGCG\tGCT\tGGA\tGGC\tGGG\tGGT\tGTA\tGTC\tGTG\tGTT\t"
"TAA\tTAC\tTAG\tTAT\tTCA\tTCC\tTCG\tTCT\tTGA\tTGC\tTGG\tTGT\tTTA\tTTC\tTTG\tTTT";

    for ( CodonCounts const& cCounts : mCCV )
    {
        char prefix = '\n';
        for ( size_t count : cCounts.mCounts )
        {
            ofs << prefix << count;
            prefix = '\t';
        }
    }
    ofs << '\n';
    ofs.close();
    if ( !ofs )
        FatalErr("Couldn't write codon counts to " << filename);
}

// Assembly:
subq $0x298, %rsp            # imm = 0x298
movq %rdi, 0x290(%rsp)
movq %rsi, 0x288(%rsp)
movq 0x290(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x288(%rsp), %rsi
leaq 0x88(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movl $0x10, %edx
callq 0x45a0
movq 0x28(%rsp), %rdi
leaq 0x1b369(%rip), %rsi     # 0x21c68
callq 0x4290
jmp 0x6906
movq 0x20(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0x145b0
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rdi
callq 0x16950
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x14620
testb $0x1, %al
jne 0x694a
jmp 0x6a0e
leaq 0x68(%rsp), %rdi
callq 0x16980
movq %rax, 0x58(%rsp)
movb $0xa, 0x57(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rax
addq $0x200, %rax            # imm = 0x200
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x38(%rsp), %rax
je 0x69fd
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movsbl 0x57(%rsp), %esi
leaq 0x88(%rsp), %rdi
callq 0x42e0
movq %rax, 0x18(%rsp)
jmp 0x69b4
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x4070
jmp 0x69c5
movb $0x9, 0x57(%rsp)
movq 0x40(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x40(%rsp)
jmp 0x6982
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x4420
jmp 0x6abd
jmp 0x69ff
leaq 0x68(%rsp), %rdi
callq 0x14670
jmp 0x6932
leaq 0x88(%rsp), %rdi
movl $0xa, %esi
callq 0x42e0
jmp 0x6a22
leaq 0x88(%rsp), %rdi
callq 0x43b0
jmp 0x6a31
movq 0x88(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x88(%rsp,%rax), %rdi
callq 0x4150
movb %al, 0x17(%rsp)
jmp 0x6a50
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x6a5a
jmp 0x6aa8
movq 0x2658f(%rip), %rdi     # 0x2cff0
leaq 0x1b300(%rip), %rsi     # 0x21d68
callq 0x4290
movq %rax, 0x8(%rsp)
jmp 0x6a74
movq 0x8(%rsp), %rdi
movq 0x288(%rsp), %rsi
callq 0x4260
movq %rax, (%rsp)
jmp 0x6a8c
movq (%rsp), %rdi
movq 0x26511(%rip), %rsi     # 0x2cfa8
callq 0x42b0
jmp 0x6a9e
movl $0x1, %edi
callq 0x42f0
leaq 0x88(%rsp), %rdi
callq 0x4420
addq $0x298, %rsp            # imm = 0x298
retq
movq 0x80(%rsp), %rdi
callq 0x4510
nopw (%rax,%rax)
// File: tedsharpe[P]ORFCall/ORFCall.cc
// Function: (anonymous namespace)::ORFCaller::writeIndelCounts(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void ORFCaller::writeIndelCounts( std::string const& filename )
{
    std::ofstream ofs(filename);
    ofs << "NFS\tFS\tTotCvg\n";

    for ( CodonCounts const& cCounts : mCCV )
    {
        ofs << cCounts.mIndelCounts[0] << '\t'
            << cCounts.mIndelCounts[1] << '\t'
            << cCounts.mCoverage << '\n';
    }
    ofs.close();
    if ( !ofs )
        FatalErr("Couldn't write indel counts to " << filename);
}

// Assembly:
subq $0x298, %rsp            # imm = 0x298
movq %rdi, 0x290(%rsp)
movq %rsi, 0x288(%rsp)
movq 0x290(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x288(%rsp), %rsi
leaq 0x88(%rsp), %rdi
movq %rdi, 0x50(%rsp)
movl $0x10, %edx
callq 0x45a0
movq 0x50(%rsp), %rdi
leaq 0x1af30(%rip), %rsi     # 0x21daf
callq 0x4290
jmp 0x6e86
movq 0x48(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0x145b0
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rdi
callq 0x16950
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x14620
testb $0x1, %al
jne 0x6eca
jmp 0x6fa4
leaq 0x68(%rsp), %rdi
callq 0x16980
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq 0x200(%rax), %rsi
leaq 0x88(%rsp), %rdi
callq 0x4070
movq %rax, 0x40(%rsp)
jmp 0x6ef9
movq 0x40(%rsp), %rdi
movl $0x9, %esi
callq 0x42e0
movq %rax, 0x38(%rsp)
jmp 0x6f0f
movq 0x38(%rsp), %rdi
movq 0x58(%rsp), %rax
movq 0x208(%rax), %rsi
callq 0x4070
movq %rax, 0x30(%rsp)
jmp 0x6f2c
movq 0x30(%rsp), %rdi
movl $0x9, %esi
callq 0x42e0
movq %rax, 0x28(%rsp)
jmp 0x6f42
movq 0x28(%rsp), %rdi
movq 0x58(%rsp), %rax
movq 0x210(%rax), %rsi
callq 0x4070
movq %rax, 0x20(%rsp)
jmp 0x6f5f
movq 0x20(%rsp), %rdi
movl $0xa, %esi
callq 0x42e0
jmp 0x6f70
jmp 0x6f72
leaq 0x68(%rsp), %rdi
callq 0x14670
jmp 0x6eb2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x4420
jmp 0x7041
leaq 0x88(%rsp), %rdi
callq 0x43b0
jmp 0x6fb3
movq 0x88(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x88(%rsp,%rax), %rdi
callq 0x4150
movb %al, 0x1f(%rsp)
jmp 0x6fd2
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x6fdc
jmp 0x702c
movq 0x2600d(%rip), %rdi     # 0x2cff0
leaq 0x1add4(%rip), %rsi     # 0x21dbe
callq 0x4290
movq %rax, 0x10(%rsp)
jmp 0x6ff6
movq 0x10(%rsp), %rdi
movq 0x288(%rsp), %rsi
callq 0x4260
movq %rax, 0x8(%rsp)
jmp 0x700f
movq 0x8(%rsp), %rdi
movq 0x25f8d(%rip), %rsi     # 0x2cfa8
callq 0x42b0
jmp 0x7022
movl $0x1, %edi
callq 0x42f0
leaq 0x88(%rsp), %rdi
callq 0x4420
addq $0x298, %rsp            # imm = 0x298
retq
movq 0x80(%rsp), %rdi
callq 0x4510
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movb $0x0, 0x2b(%rsp)
callq 0x43a0
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x4440
jmp 0xa8c5
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl $0x204, %ecx            # imm = 0x204
bextrl %ecx, %eax, %eax
leaq 0x170c3(%rip), %rcx     # 0x219a2
movsbl (%rax,%rcx), %esi
callq 0x4220
jmp 0xa8ea
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl $0x202, %ecx            # imm = 0x202
bextrl %ecx, %eax, %eax
leaq 0x1709e(%rip), %rcx     # 0x219a2
movsbl (%rax,%rcx), %esi
callq 0x4220
jmp 0xa90f
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %eax
andl $0x3, %eax
leaq 0x17080(%rip), %rcx     # 0x219a2
movsbl (%rax,%rcx), %esi
callq 0x4220
jmp 0xa92d
movb $0x1, 0x2b(%rsp)
testb $0x1, 0x2b(%rsp)
jne 0xa95f
jmp 0xa955
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x41b0
jmp 0xa969
movq 0x10(%rsp), %rdi
callq 0x41b0
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x4510
nopw %cs:(%rax,%rax)
// File: tedsharpe[P]ORFCall/ORFCall.cc
// Function: (anonymous namespace)::KmerHasher::operator()(__gnu_cxx::__normal_iterator<unsigned char const*, std::vector<unsigned char, std::allocator<unsigned char>>>) const
size_t operator()( Kmer itr ) const
    {
        size_t result = 14695981039346656037ul;
        for ( Kmer end(itr + mK); itr != end; ++itr )
            result = 1099511628211ul * (result ^ *itr); // FNV-1a algorithm
        return result;
    }

// Assembly:
subq $0x28, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movabsq $-0x340d631b7bdddcdb, %rcx # imm = 0xCBF29CE484222325
movq %rcx, 0x10(%rsp)
movl (%rax), %eax
movl %eax, %esi
leaq 0x20(%rsp), %rdi
callq 0x1a140
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x19f20
testb $0x1, %al
jne 0xb2fa
jmp 0xb339
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x1a180
movq %rax, %rcx
movq (%rsp), %rax
movzbl (%rcx), %ecx
xorq %rcx, %rax
movabsq $0x100000001b3, %rcx    # imm = 0x100000001B3
imulq %rcx, %rax
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x19f60
jmp 0xb2e5
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tedsharpe[P]ORFCall/ORFCall.cc
// Function: (anonymous namespace)::ORFCaller::processRead(std::vector<unsigned char, std::allocator<unsigned char>> const&, std::vector<unsigned char, std::allocator<unsigned char>> const&, char const*, unsigned long)
void processRead( Sequence const& seq, Quals const& quals,
                        char const* fileName, size_t readId )
    {
        mNReads += 1;
        Alignment aln = mRef.findAlignment(seq);
        if ( aln.empty() )
            dumpNonAligner(fileName,readId,seq,quals);
        else
            processAlignment(seq,quals,aln);
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
movq (%rax), %rsi
movq 0x48(%rsp), %rdx
leaq 0x10(%rsp), %rdi
callq 0xd680
leaq 0x10(%rsp), %rdi
callq 0xd900
testb $0x1, %al
jne 0xd4d5
jmp 0xd4f5
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq 0x40(%rsp), %r8
callq 0xd920
jmp 0xd50e
movq 0x8(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq 0xdac0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: tedsharpe[P]ORFCall/ORFCall.cc
// Function: (anonymous namespace)::FastqReader::openStream(char const*)
std::istream* openStream( char const* fastqFile )
    {
        auto len = strlen(fastqFile);
        auto flags = std::ios_base::in | std::ios_base::binary;
        if ( len >= 3 && !memcmp(fastqFile + len - 3, ".gz", 3) )
            return new igzstream(fastqFile, flags);
        return new std::ifstream(fastqFile, flags);
    }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x4130
movq %rax, 0x38(%rsp)
movl $0x8, %edi
movl $0x4, %esi
callq 0x17350
movl %eax, 0x34(%rsp)
cmpq $0x3, 0x38(%rsp)
jb 0xd61d
movq 0x40(%rsp), %rdi
addq 0x38(%rsp), %rdi
addq $-0x3, %rdi
leaq 0x1450a(%rip), %rsi     # 0x21aab
movl $0x3, %edx
callq 0x4140
cmpl $0x0, %eax
jne 0xd61d
movl $0x970, %edi            # imm = 0x970
callq 0x42a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rsi
movl 0x34(%rsp), %edx
callq 0x1c2f0
jmp 0xd5d5
movq 0x18(%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, 0x10(%rsp)
je 0xd5f7
movq 0x18(%rsp), %rax
addq $0x858, %rax            # imm = 0x858
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0xd668
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x4270
jmp 0xd672
movl $0x208, %edi            # imm = 0x208
callq 0x42a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rsi
movl 0x34(%rsp), %edx
callq 0x4540
jmp 0xd642
movq 0x8(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0xd668
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x4270
jmp 0xd672
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x4510
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq %r8, 0x60(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x50(%rax)
jne 0xd95c
jmp 0xdab5
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
movl $0x40, %esi
callq 0x42e0
movq %rax, %rdi
movq 0x78(%rsp), %rsi
callq 0x4290
movq %rax, %rdi
movl $0x3a, %esi
callq 0x42e0
movq %rax, %rdi
movq 0x70(%rsp), %rsi
callq 0x4070
movq %rax, %rdi
movl $0xa, %esi
callq 0x42e0
movq 0x68(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x1dc60
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x1dc90
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x19f20
testb $0x1, %al
jne 0xd9ea
jmp 0xda27
leaq 0x48(%rsp), %rdi
callq 0x1a180
movb (%rax), %al
movb %al, 0x3f(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movzbl 0x3f(%rsp), %edi
callq 0xddd0
movq 0x8(%rsp), %rdi
movsbl %al, %esi
callq 0x42e0
leaq 0x48(%rsp), %rdi
callq 0x19f60
jmp 0xd9d5
movq 0x58(%rsp), %rdi
leaq 0x14142(%rip), %rsi     # 0x21b75
callq 0x4290
movq 0x60(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1dc60
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1dc90
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x19f20
testb $0x1, %al
jne 0xda75
jmp 0xdaa6
leaq 0x28(%rsp), %rdi
callq 0x1a180
movb (%rax), %al
movb %al, 0x1f(%rsp)
movq 0x58(%rsp), %rdi
movzbl 0x1f(%rsp), %eax
addl $0x21, %eax
movsbl %al, %esi
callq 0x42e0
leaq 0x28(%rsp), %rdi
callq 0x19f60
jmp 0xda60
movq 0x58(%rsp), %rdi
movl $0xa, %esi
callq 0x42e0
addq $0x88, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movq 0x90(%rsp), %rsi
movq %rsi, (%rsp)
movq 0x38(%rsi), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsi)
movq 0x88(%rsp), %rdx
movq 0x80(%rsp), %rcx
movq 0x78(%rsp), %r8
leaq 0x48(%rsp), %rdi
callq 0xddf0
movq (%rsp), %rcx
movq 0x58(%rsp), %rax
movl 0xc(%rcx), %ecx
cmpq %rcx, %rax
ja 0xdb40
leaq 0x48(%rsp), %rdi
addq $0x18, %rdi
callq 0xe230
cmpq $0x1, %rax
jbe 0xdb9a
movq (%rsp), %rsi
movq 0x78(%rsp), %rdx
movq 0x88(%rsp), %rcx
movq 0x80(%rsp), %r8
leaq 0x18(%rsp), %rdi
callq 0xe250
jmp 0xdb65
leaq 0x48(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xed20
leaq 0x18(%rsp), %rdi
callq 0xed70
jmp 0xdb9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xed70
jmp 0xdbcf
movq (%rsp), %rcx
movq 0x58(%rsp), %rax
movl 0xc(%rcx), %ecx
cmpq %rcx, %rax
ja 0xdbbd
movq (%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xed90
jmp 0xdbbb
jmp 0xdbbd
leaq 0x48(%rsp), %rdi
callq 0xed70
addq $0x98, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x4510
nopl (%rax)
// File: tedsharpe[P]ORFCall/ORFCall.cc
// Function: (anonymous namespace)::AlignmentScorer::getReport() const
ReadReport getReport() const
    {
        return ReadReport{mFirstCodonCovered,
                          Offset(mWTItr-mWTBeg),
                          mNMismatches,
                          mVariations};
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rsi
movq %rsi, 0x8(%rsp)
movq 0x50(%rsi), %rax
movq %rax, (%rdi)
movq %rsi, %rdi
addq $0x28, %rdi
addq $0x20, %rsi
callq 0x1e540
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, 0x8(%rdi)
movq 0x58(%rsi), %rax
movq %rax, 0x10(%rdi)
addq $0x18, %rdi
addq $0x60, %rsi
callq 0x10070
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: tedsharpe[P]ORFCall/ORFCall.cc
// Function: (anonymous namespace)::SmithWatermanizer::max3(int, int, int, (anonymous namespace)::SmithWatermanizer::Trace*)
static int max3( int dScore, int hScore, int vScore, Trace* pTrace )
    { int result;
      if ( dScore >= hScore )
      { if ( dScore >= vScore )
        { *pTrace = Trace::DIAG; result = dScore; }
        else if ( hScore >= vScore )
        { *pTrace = Trace::LEFT; result = hScore; }
        else
        { *pTrace = Trace::UP; result = vScore; } }
      else if ( hScore >= vScore )
      { *pTrace = Trace::LEFT; result = hScore; }
      else
      { *pTrace = Trace::UP; result = vScore; }
      return result; }

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movl %edx, -0xc(%rsp)
movq %rcx, -0x18(%rsp)
movl -0x4(%rsp), %eax
cmpl -0x8(%rsp), %eax
jl 0x11797
movl -0x4(%rsp), %eax
cmpl -0xc(%rsp), %eax
jl 0x11767
movq -0x18(%rsp), %rax
movb $0x3, (%rax)
movl -0x4(%rsp), %eax
movl %eax, -0x1c(%rsp)
jmp 0x11795
movl -0x8(%rsp), %eax
cmpl -0xc(%rsp), %eax
jl 0x11783
movq -0x18(%rsp), %rax
movb $0x2, (%rax)
movl -0x8(%rsp), %eax
movl %eax, -0x1c(%rsp)
jmp 0x11793
movq -0x18(%rsp), %rax
movb $0x1, (%rax)
movl -0xc(%rsp), %eax
movl %eax, -0x1c(%rsp)
jmp 0x11795
jmp 0x117c5
movl -0x8(%rsp), %eax
cmpl -0xc(%rsp), %eax
jl 0x117b3
movq -0x18(%rsp), %rax
movb $0x2, (%rax)
movl -0x8(%rsp), %eax
movl %eax, -0x1c(%rsp)
jmp 0x117c3
movq -0x18(%rsp), %rax
movb $0x1, (%rax)
movl -0xc(%rsp), %eax
movl %eax, -0x1c(%rsp)
jmp 0x117c5
movl -0x1c(%rsp), %eax
retq
nopw (%rax,%rax)
// File: tedsharpe[P]ORFCall/ORFCall.cc
// Function: (anonymous namespace)::operator<((anonymous namespace)::Variation const&, (anonymous namespace)::Variation const&)
bool operator<( Variation const& var1, Variation const& var2 )
    { if ( var1.mType != var2.mType ) return var1.mType < var2.mType;
      if ( var1.mCodonIdx != var2.mCodonIdx )
          return var1.mCodonIdx < var2.mCodonIdx;
      return var1.mValue < var2.mValue; }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movl (%rax), %eax
movq -0x18(%rsp), %rcx
cmpl (%rcx), %eax
je 0x15b73
movq -0x10(%rsp), %rax
movl (%rax), %eax
movq -0x18(%rsp), %rcx
cmpl (%rcx), %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x15bbd
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
je 0x15ba4
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq -0x18(%rsp), %rcx
cmpq 0x8(%rcx), %rax
setb %al
andb $0x1, %al
movb %al, -0x1(%rsp)
jmp 0x15bbd
movq -0x10(%rsp), %rax
movl 0x10(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x10(%rcx), %eax
setb %al
andb $0x1, %al
movb %al, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x20050
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x41c0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x20070
movq 0x10(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
addq $0x200, %rax            # imm = 0x200
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0x16ac4
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, 0x48(%rsp)
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x20110
movq (%rsp), %rcx
addq (%rax), %rcx
movq %rcx, (%rax)
movq 0x28(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x28(%rsp)
jmp 0x16a6a
addq $0x58, %rsp
retq
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x30, %edi
callq 0x21b0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %esi
callq 0x40a0
jmp 0x2f95
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, (%rax)
je 0x3058
movq -0x38(%rbp), %rcx
movq (%rcx), %rax
movq 0x10(%rax), %rax
cmpq (%rcx), %rax
jne 0x3004
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rdx
movq (%rax), %rcx
movq %rdx, 0x10(%rcx)
movq (%rax), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, 0x18(%rcx)
movq (%rax), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, 0x10(%rcx)
movq -0x18(%rbp), %rcx
movq (%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0x303c
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x2190
jmp 0x306d
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rdx
movq (%rax), %rcx
movq 0x18(%rcx), %rcx
movq %rdx, 0x10(%rcx)
movq (%rax), %rcx
movq 0x18(%rcx), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, 0x18(%rcx)
movq (%rax), %rdx
movq -0x18(%rbp), %rcx
movq %rdx, 0x10(%rcx)
movq -0x18(%rbp), %rcx
movq (%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x38(%rbp), %rax
movq (%rax), %rax
movl 0x4(%rax), %eax
cmpl -0xc(%rbp), %eax
jge 0x3056
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x3063
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x22c0
nopw %cs:(%rax,%rax)
// File: comptotherescue[P]Fibonacci-Heap/keywordcounter.cpp
// Function: Fib::Fib(int)
Fib(int a_idata)
	{
		m_iDegree = 0;
		m_iData = a_idata;
		m_pChild = NULL;
		m_pLeftsib = this;
		m_pRightsib = this;
		m_pParent = NULL;
		m_bChildcut = false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x4(%rax)
movq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq $0x0, 0x20(%rax)
movb $0x0, 0x28(%rax)
popq %rbp
retq
nopl (%rax)
// File: comptotherescue[P]Fibonacci-Heap/keywordcounter.cpp
// Function: Fibops::Consolidate(Fib*, Fib*)
Fib* Consolidate(Fib* m, Fib* n)
	{
		if (m->m_pRightsib == n)
		{
			m->m_pLeftsib = n;
			n->m_pLeftsib = m;
			m->m_pRightsib = n;
			m->m_pRightsib = m;
		}
		else
		{
			m->m_pRightsib->m_pLeftsib = n;
			n->m_pRightsib = m->m_pRightsib;
			m->m_pRightsib = n;
			n->m_pLeftsib = m;
		}
		if (n->m_iData > m->m_iData)
		{
			return n;
		}
		return m;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x4430
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0x4468
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jle 0x4482
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x448a
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: 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
subq $0xf0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x14e0
leaq -0x68(%rbp), %rdi
callq 0x14e0
movq -0xc8(%rbp), %rsi
movq 0x2caf(%rip), %rdi      # 0x3fd8
callq 0x16c0
movq %rax, -0xc0(%rbp)
jmp 0x1337
movq -0xc0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x10f0
movb %al, -0xc9(%rbp)
jmp 0x1355
movb -0xc9(%rbp), %al
testb $0x1, %al
jne 0x1364
jmp 0x146d
movq 0x2c6d(%rip), %rdi      # 0x3fd8
leaq -0x68(%rbp), %rsi
callq 0x16c0
movq %rax, -0xd8(%rbp)
jmp 0x137d
movq -0xd8(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x10f0
movb %al, -0xd9(%rbp)
jmp 0x139b
movb -0xd9(%rbp), %al
testb $0x1, %al
jne 0x13aa
jmp 0x146d
leaq -0x98(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x15b0
jmp 0x13bc
leaq -0xb8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x15b0
jmp 0x13ce
leaq -0x98(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x1520
movb %al, -0xda(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x1080
leaq -0x98(%rbp), %rdi
callq 0x1080
movb -0xda(%rbp), %al
testb $0x1, %al
jne 0x140b
jmp 0x146b
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1780
jmp 0x141a
movq 0x2ba7(%rip), %rdi      # 0x3fc8
leaq -0x38(%rbp), %rsi
callq 0x1820
jmp 0x142c
movq 0x2b95(%rip), %rdi      # 0x3fc8
movq 0x2b7e(%rip), %rsi      # 0x3fb8
callq 0x10e0
jmp 0x1441
jmp 0x146b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x14c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x1080
jmp 0x14c5
jmp 0x14a0
movq 0x2b7c(%rip), %rdi      # 0x3ff0
leaq 0xb89(%rip), %rsi       # 0x2004
callq 0x10d0
movq %rax, -0xe8(%rbp)
jmp 0x1489
movq -0xe8(%rbp), %rdi
movq 0x2b21(%rip), %rsi      # 0x3fb8
callq 0x10e0
jmp 0x149e
jmp 0x14a0
movl $0x0, -0x4(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x15e0
leaq -0x38(%rbp), %rdi
callq 0x15e0
movl -0x4(%rbp), %eax
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x68(%rbp), %rdi
callq 0x15e0
leaq -0x38(%rbp), %rdi
callq 0x15e0
movq -0x70(%rbp), %rdi
callq 0x1150
// File: 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 %rax
movq 0x4352e8(%rip), %rdi    # 0x43aff0
leaq 0x752f5(%rip), %rsi     # 0x7b004
callq 0x53f0
movq %rax, %rdi
movq 0x43528a(%rip), %rsi    # 0x43afa8
callq 0x5460
movq 0x4352c6(%rip), %rdi    # 0x43aff0
leaq 0x752f3(%rip), %rsi     # 0x7b024
callq 0x53f0
movq %rax, %rdi
movq 0x435268(%rip), %rsi    # 0x43afa8
callq 0x5460
movq 0x4352a4(%rip), %rdi    # 0x43aff0
leaq 0x752f3(%rip), %rsi     # 0x7b046
callq 0x53f0
movq %rax, %rdi
movq 0x435246(%rip), %rsi    # 0x43afa8
callq 0x5460
movq 0x435282(%rip), %rdi    # 0x43aff0
leaq 0x752f1(%rip), %rsi     # 0x7b066
callq 0x53f0
movq %rax, %rdi
movq 0x435224(%rip), %rsi    # 0x43afa8
callq 0x5460
movq 0x435260(%rip), %rdi    # 0x43aff0
leaq 0x752eb(%rip), %rsi     # 0x7b082
callq 0x53f0
movq %rax, %rdi
movq 0x435202(%rip), %rsi    # 0x43afa8
callq 0x5460
movq 0x43523e(%rip), %rdi    # 0x43aff0
leaq 0x752e7(%rip), %rsi     # 0x7b0a0
callq 0x53f0
movq %rax, %rdi
movq 0x4351e0(%rip), %rsi    # 0x43afa8
callq 0x5460
movq 0x43521c(%rip), %rdi    # 0x43aff0
leaq 0x752d8(%rip), %rsi     # 0x7b0b3
callq 0x53f0
movq %rax, %rdi
movq 0x4351be(%rip), %rsi    # 0x43afa8
callq 0x5460
movq 0x4351fa(%rip), %rdi    # 0x43aff0
leaq 0x752ca(%rip), %rsi     # 0x7b0c7
callq 0x53f0
movq %rax, %rdi
movq 0x43519c(%rip), %rsi    # 0x43afa8
callq 0x5460
movq 0x4351d8(%rip), %rdi    # 0x43aff0
leaq 0x752bf(%rip), %rsi     # 0x7b0de
callq 0x53f0
movq %rax, %rdi
movq 0x43517a(%rip), %rsi    # 0x43afa8
callq 0x5460
movq 0x4351b6(%rip), %rdi    # 0x43aff0
leaq 0x752b6(%rip), %rsi     # 0x7b0f7
callq 0x53f0
movq %rax, %rdi
movq 0x435158(%rip), %rsi    # 0x43afa8
callq 0x5460
movq 0x435194(%rip), %rdi    # 0x43aff0
leaq 0x752c9(%rip), %rsi     # 0x7b12c
callq 0x53f0
movq %rax, %rdi
movq 0x435136(%rip), %rsi    # 0x43afa8
callq 0x5460
movq 0x435172(%rip), %rdi    # 0x43aff0
movq 0x435123(%rip), %rsi    # 0x43afa8
callq 0x5460
xorl %edi, %edi
callq 0x5500
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x43191e(%rip), %rax    # 0x43a978
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x77e0
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0x16930
movq 0x8(%rsp), %rdi
addq $0x38, %rdi
callq 0x16940
movq 0x8(%rsp), %rdi
addq $0x50, %rdi
callq 0x16950
movq 0x8(%rsp), %rdi
addq $0x70, %rdi
callq 0x5600
movq 0x8(%rsp), %rdi
addq $0x90, %rdi
callq 0x5600
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x7800
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0x16960
movq 0x8(%rsp), %rdi
addq $0x38, %rdi
callq 0x16980
movq 0x8(%rsp), %rdi
addq $0x50, %rdi
callq 0x169a0
movq 0x8(%rsp), %rdi
movl $0x0, 0x68(%rdi)
movb $0x0, 0x6c(%rdi)
addq $0x70, %rdi
callq 0x5580
movq 0x8(%rsp), %rdi
addq $0x90, %rdi
callq 0x5580
movq 0x8(%rsp), %rax
movb $0x0, 0xb0(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: atfrank[P]PCASA/lib/Analyze.cpp
// Function: AnalyzeCasa::AnalyzeCasa(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
AnalyzeCasa::AnalyzeCasa (std::string delim){
  unsigned int ntree;
  /* t1 */
  std::vector<std::string> tokens;
  t1.clear();
  ntree=CASAP::getNTree();
  t1.resize(ntree);
  
  for (unsigned int i=0; i< ntree; i++){
    t1.at(i)=new DTree;
    Misc::splitStr(CASAP::getTree(i), " \t", tokens, false);
    t1.at(i)->genDTree(tokens, delim);
  }
}

// Assembly:
subq $0xf8, %rsp
movq %rsi, 0x30(%rsp)
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq 0xf0(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x9040
movq 0x38(%rsp), %rdi
leaq 0x43141e(%rip), %rax    # 0x43aa78
movq %rax, (%rdi)
addq $0xb8, %rdi
movq %rdi, 0x40(%rsp)
callq 0x16a80
leaq 0xc8(%rsp), %rdi
callq 0x77e0
movq 0x40(%rsp), %rdi
callq 0x16a90
callq 0x79320
movl %eax, 0x4c(%rsp)
jmp 0x9690
movq 0x38(%rsp), %rdi
movl 0x4c(%rsp), %eax
movl %eax, 0xe4(%rsp)
addq $0xb8, %rdi
movl 0xe4(%rsp), %eax
movl %eax, %esi
callq 0x16ab0
jmp 0x96b7
movl $0x0, 0xb8(%rsp)
movl 0xb8(%rsp), %eax
cmpl 0xe4(%rsp), %eax
jae 0x98c3
movl $0x38, %edi
callq 0x5410
movq %rax, 0x28(%rsp)
jmp 0x96e7
movq 0x28(%rsp), %rdi
callq 0x3b100
jmp 0x96f3
movq 0x38(%rsp), %rdi
addq $0xb8, %rdi
movl 0xb8(%rsp), %eax
movl %eax, %esi
callq 0x16b50
movq %rax, 0x20(%rsp)
jmp 0x9714
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movl 0xb8(%rsp), %esi
leaq 0x98(%rsp), %rdi
callq 0x768d0
jmp 0x9737
leaq 0x77(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x5730
movq 0x18(%rsp), %rdx
leaq 0x71c5e(%rip), %rsi     # 0x7b3b0
leaq 0x78(%rsp), %rdi
callq 0x7900
jmp 0x975e
leaq 0x98(%rsp), %rdi
leaq 0x78(%rsp), %rsi
leaq 0xc8(%rsp), %rdx
xorl %ecx, %ecx
callq 0x3d840
jmp 0x977c
leaq 0x78(%rsp), %rdi
callq 0x5250
leaq 0x77(%rsp), %rdi
callq 0x5480
leaq 0x98(%rsp), %rdi
callq 0x5250
movq 0x38(%rsp), %rdi
addq $0xb8, %rdi
movl 0xb8(%rsp), %eax
movl %eax, %esi
callq 0x16b50
movq %rax, 0x10(%rsp)
jmp 0x97be
movq 0x30(%rsp), %rsi
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x51b0
jmp 0x97dc
movq 0x8(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x3bfb0
jmp 0x97f5
leaq 0x50(%rsp), %rdi
callq 0x5250
movl 0xb8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xb8(%rsp)
jmp 0x96c2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0x98d8
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
movl $0x38, %esi
callq 0x5420
jmp 0x98d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
jmp 0x988a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x5250
leaq 0x77(%rsp), %rdi
callq 0x5480
leaq 0x98(%rsp), %rdi
callq 0x5250
jmp 0x98d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xc0(%rsp)
movl %eax, 0xbc(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x5250
jmp 0x98d8
leaq 0xc8(%rsp), %rdi
callq 0x7ab0
addq $0xf8, %rsp
retq
leaq 0xc8(%rsp), %rdi
callq 0x7ab0
movq 0x40(%rsp), %rdi
callq 0x16b90
movq 0x38(%rsp), %rdi
callq 0x9130
movq 0xc0(%rsp), %rdi
callq 0x5720
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdx, (%rsp)
movq %rdi, %rax
movq (%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq %rax, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
callq 0x5630
cmpq $0x0, %rax
jbe 0x9ad0
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdi
movl $0x1, %edx
callq 0x43e50
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x441b0
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x44470
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rsi
movq %rsi, (%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x2c(%rsp)
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0x2c(%rsp), %rdx
callq 0x9940
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0x44b10
jmp 0x9b35
leaq 0x30(%rsp), %rdi
callq 0x5250
movq 0x58(%rsp), %rdi
movl $0x1, %esi
callq 0x42b70
movq (%rsp), %rdi
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rsi
callq 0x99b0
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5250
movq 0x20(%rsp), %rdi
callq 0x5720
nopl (%rax,%rax)
// File: atfrank[P]PCASA/lib/Analyze.cpp
// Function: AnalyzeDistance::setupMolSel(Molecule*)
void AnalyzeDistance::setupMolSel(Molecule* molin){
  unsigned int i;
  Molecule* tmpmol;

  for (i=0; i< this->getNSel(); i++){
    molin->select(this->getSel(i));
    tmpmol=molin->copy();
    this->addMol(tmpmol);
  }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x64(%rsp)
movq 0x18(%rsp), %rdi
movl 0x64(%rsp), %eax
movl %eax, 0x14(%rsp)
callq 0x9990
movl %eax, %ecx
movl 0x14(%rsp), %eax
cmpl %ecx, %eax
jae 0x9c68
movq 0x18(%rsp), %rsi
movq 0x68(%rsp), %rax
movq %rax, (%rsp)
movl 0x64(%rsp), %eax
movl %eax, 0x34(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x34(%rsp), %rdx
callq 0x9940
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0x44b10
jmp 0x9c11
leaq 0x38(%rsp), %rdi
callq 0x5250
movq 0x68(%rsp), %rdi
movl $0x1, %esi
callq 0x42b70
movq 0x18(%rsp), %rdi
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rsi
callq 0x99b0
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x9bb0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x5250
jmp 0x9c6d
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x5720
nopw (%rax,%rax)
// File: 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:
subq $0xb8, %rsp
movq %rdx, 0x18(%rsp)
movq %rsi, %rax
movq 0x18(%rsp), %rsi
movq %rsi, 0x20(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rax, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x80(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x51b0
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
jmp 0xeef7
leaq 0x80(%rsp), %rdi
callq 0x5250
movq 0x28(%rsp), %rdi
movq 0xa8(%rsp), %rsi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq 0xa8(%rsp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x422f0
movq 0x20(%rsp), %rsi
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x51b0
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
jmp 0xef6b
leaq 0x48(%rsp), %rdi
callq 0x5250
movq 0x28(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x28(%rsp), %rdi
movl $0x1, 0x44(%rsp)
leaq 0x44(%rsp), %rsi
callq 0xece0
movq %rax, %rdi
callq 0x44fc0
addq $0xb8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x5250
jmp 0xefe1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x5250
movq 0x78(%rsp), %rdi
callq 0x5720
nopl (%rax,%rax)
// File: atfrank[P]PCASA/lib/Analyze.cpp
// Function: AnalyzeCOG::runAnalysis()
void AnalyzeCOG::runAnalysis(){
  Coor xyz=Analyze::centerOfGeometry(this->getMol(0));
  std::cout << std::fixed;
  std::cout << std::setw(9) << std::right << std::setprecision(3) << xyz.x();
  std::cout << std::setw(9) << std::right << std::setprecision(3) << xyz.y();
  std::cout << std::setw(9) << std::right << std::setprecision(3) << xyz.z();
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rdi
movl $0x0, 0x54(%rsp)
leaq 0x54(%rsp), %rsi
callq 0xece0
movq %rax, %rsi
leaq 0x58(%rsp), %rdi
movl $0x1, %edx
callq 0xf1e0
movq 0x42bf2f(%rip), %rdi    # 0x43afb8
leaq 0x7e10(%rip), %rsi      # 0x16ea0
callq 0x5160
movl $0x9, %edi
callq 0x16ec0
movl %eax, 0x50(%rsp)
movl 0x50(%rsp), %esi
movq 0x42bf0a(%rip), %rdi    # 0x43afb8
callq 0x54e0
movq %rax, %rdi
leaq 0x7e23(%rip), %rsi      # 0x16ee0
callq 0x5160
movq %rax, 0x8(%rsp)
movl $0x3, %edi
callq 0x16f00
movq 0x8(%rsp), %rdi
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %esi
callq 0x5660
movq %rax, 0x10(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x16f20
movq 0x10(%rsp), %rdi
movsd (%rax), %xmm0
callq 0x5780
movl $0x9, %edi
callq 0x16ec0
movl %eax, 0x48(%rsp)
movl 0x48(%rsp), %esi
movq 0x42be9f(%rip), %rdi    # 0x43afb8
callq 0x54e0
movq %rax, %rdi
leaq 0x7db8(%rip), %rsi      # 0x16ee0
callq 0x5160
movq %rax, 0x18(%rsp)
movl $0x3, %edi
callq 0x16f00
movq 0x18(%rsp), %rdi
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %esi
callq 0x5660
movq %rax, 0x20(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x16f30
movq 0x20(%rsp), %rdi
movsd (%rax), %xmm0
callq 0x5780
movl $0x9, %edi
callq 0x16ec0
movl %eax, 0x40(%rsp)
movl 0x40(%rsp), %esi
movq 0x42be34(%rip), %rdi    # 0x43afb8
callq 0x54e0
movq %rax, %rdi
leaq 0x7d4d(%rip), %rsi      # 0x16ee0
callq 0x5160
movq %rax, 0x28(%rsp)
movl $0x3, %edi
callq 0x16f00
movq 0x28(%rsp), %rdi
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %esi
callq 0x5660
movq %rax, 0x30(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x16f40
movq 0x30(%rsp), %rdi
movsd (%rax), %xmm0
callq 0x5780
addq $0x78, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x10(%rsp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, 0x18(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
xorps %xmm2, %xmm2
movaps %xmm2, %xmm0
movaps %xmm2, %xmm1
callq 0x76090
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
callq 0x436b0
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jae 0xf299
movb 0x27(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xf268
movq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x43580
movq %rax, %rdi
callq 0x1f780
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xf268
jmp 0xf28c
movq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x43580
movq %rax, %rdi
callq 0x1f6e0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x761f0
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0xf219
movb 0x27(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xf2c4
movq 0x28(%rsp), %rdi
callq 0x44ba0
movq 0x10(%rsp), %rdi
movl %eax, %eax
cvtsi2sd %rax, %xmm0
callq 0x76680
jmp 0xf2df
movq 0x28(%rsp), %rdi
callq 0x44a80
movq 0x10(%rsp), %rdi
movl %eax, %eax
cvtsi2sd %rax, %xmm0
callq 0x76680
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x76060
leaq 0x48(%rsp), %rdi
callq 0x76060
movq 0x90(%rsp), %rsi
movq 0x88(%rsp), %rdx
leaq 0x18(%rsp), %rdi
callq 0x762d0
leaq 0x60(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x76110
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
movq %rsp, %rdi
callq 0x762d0
leaq 0x48(%rsp), %rdi
movq %rsp, %rsi
callq 0x76110
leaq 0x60(%rsp), %rdi
callq 0x76890
movsd %xmm0, 0x38(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x76890
movsd %xmm0, 0x30(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x76750
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
movsd 0x38(%rsp), %xmm1
mulsd 0x30(%rsp), %xmm1
divsd %xmm1, %xmm0
callq 0x53c0
movsd %xmm0, 0x78(%rsp)
movsd 0x78(%rsp), %xmm0
divsd 0x42b9c3(%rip), %xmm0   # 0x43b418
movsd 0x6b92b(%rip), %xmm1    # 0x7b388
mulsd %xmm1, %xmm0
addq $0x98, %rsp
retq
nopl (%rax)
// File: atfrank[P]PCASA/lib/Analyze.cpp
// Function: AnalyzeDihedral::runAnalysis()
void AnalyzeDihedral::runAnalysis(){
  unsigned int i;

  std::cout << std::fixed;

  for (i=0; i< this->getNMol()-3; i=i+4){
    std::cout << std::setw(9) << std::right << std::setprecision(3) << Analyze::dihedral(Analyze::centerOfGeometry(this->getMol(i)), Analyze::centerOfGeometry(this->getMol(i+1)), Analyze::centerOfGeometry(this->getMol(i+2)), Analyze::centerOfGeometry(this->getMol(i+3)));
  }
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x42b525(%rip), %rdi    # 0x43afb8
leaq 0x7406(%rip), %rsi      # 0x16ea0
callq 0x5160
movl $0x0, 0xac(%rsp)
movq 0x18(%rsp), %rdi
movl 0xac(%rsp), %eax
movl %eax, 0x14(%rsp)
callq 0xed10
movl %eax, %ecx
movl 0x14(%rsp), %eax
subl $0x3, %ecx
cmpl %ecx, %eax
jae 0xfc2b
movl $0x9, %edi
callq 0x16ec0
movl %eax, 0xa8(%rsp)
movl 0xa8(%rsp), %esi
movq 0x42b4c9(%rip), %rdi    # 0x43afb8
callq 0x54e0
movq %rax, %rdi
leaq 0x73e2(%rip), %rsi      # 0x16ee0
callq 0x5160
movq %rax, (%rsp)
movl $0x3, %edi
callq 0x16f00
movq (%rsp), %rdi
movl %eax, 0xa4(%rsp)
movl 0xa4(%rsp), %esi
callq 0x5660
movq 0x18(%rsp), %rdi
movq %rax, 0x8(%rsp)
movl 0xac(%rsp), %eax
movl %eax, 0x84(%rsp)
leaq 0x84(%rsp), %rsi
callq 0xece0
movq %rax, %rsi
leaq 0x88(%rsp), %rdi
movl $0x1, %edx
callq 0xf1e0
movq 0x18(%rsp), %rdi
movl 0xac(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
leaq 0x64(%rsp), %rsi
callq 0xece0
movq %rax, %rsi
leaq 0x68(%rsp), %rdi
movl $0x1, %edx
callq 0xf1e0
movq 0x18(%rsp), %rdi
movl 0xac(%rsp), %eax
addl $0x2, %eax
movl %eax, 0x44(%rsp)
leaq 0x44(%rsp), %rsi
callq 0xece0
movq %rax, %rsi
leaq 0x48(%rsp), %rdi
movl $0x1, %edx
callq 0xf1e0
movq 0x18(%rsp), %rdi
movl 0xac(%rsp), %eax
addl $0x3, %eax
movl %eax, 0x24(%rsp)
leaq 0x24(%rsp), %rsi
callq 0xece0
movq %rax, %rsi
leaq 0x28(%rsp), %rdi
movl $0x1, %edx
callq 0xf1e0
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x48(%rsp), %rdx
leaq 0x28(%rsp), %rcx
callq 0xfc40
movq 0x8(%rsp), %rdi
callq 0x5780
movl 0xac(%rsp), %eax
addl $0x4, %eax
movl %eax, 0xac(%rsp)
jmp 0xfaaa
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: atfrank[P]PCASA/lib/Analyze.cpp
// Function: AnalyzeAverage::postAnalysis()
void AnalyzeAverage::postAnalysis(){
  unsigned int i;
  Atom *atm;

  std::cout << std::fixed;
  for(i=0; i< this->getMol(1)->getNAtomSelected(); i++){
    atm=this->getMol(1)->getAtom(i);
    if (atm->getSel() == false){
      continue;
    }
    atm->setCoor(atm->getCoor()/getNData());
  }
  this->getMol(1)->writePDB();
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x425bc5(%rip), %rdi    # 0x43afb8
leaq 0x1aa6(%rip), %rsi      # 0x16ea0
callq 0x5160
movl $0x0, 0x7c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x7c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl $0x1, 0x6c(%rsp)
leaq 0x6c(%rsp), %rsi
callq 0xece0
movq %rax, %rdi
callq 0x44ba0
movl %eax, %ecx
movl 0x1c(%rsp), %eax
cmpl %ecx, %eax
jae 0x154d2
movq 0x20(%rsp), %rdi
movl $0x1, 0x68(%rsp)
leaq 0x68(%rsp), %rsi
callq 0xece0
movq %rax, %rdi
leaq 0x7c(%rsp), %rsi
callq 0x43580
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0x1f780
movb (%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x1547d
jmp 0x154c2
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x70(%rsp), %rdi
callq 0x1f6e0
movq 0x20(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0xed50
movq 0x8(%rsp), %rsi
cvtsi2sdl (%rax), %xmm0
leaq 0x50(%rsp), %rdi
callq 0x76630
movq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x1ffe0
movl 0x7c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x7c(%rsp)
jmp 0x15407
movq 0x20(%rsp), %rdi
movl $0x1, 0x2c(%rsp)
leaq 0x2c(%rsp), %rsi
callq 0xece0
movq %rax, %rsi
leaq 0x30(%rsp), %rdi
callq 0x42280
leaq 0x30(%rsp), %rdi
callq 0x5250
addq $0x88, %rsp
retq
nopl (%rax,%rax)