sehe/Makefile

## alioth.cpp
/* The Computer Language Benchmarks Game
http://benchmarksgame.alioth.debian.org/
Contributed by Andrew Moon

*/

#include <cstdlib>
#include <cstdio>
#include <iostream>
#include <fstream>
#include <vector>
#include <string.h>

struct CPUs {
   CPUs() {
      cpu_set_t cs;
      CPU_ZERO( &cs );
      sched_getaffinity( 0, sizeof(cs), &cs );
      count = 0;
      for ( size_t i = 0; i < CPU_SETSIZE; i++ )
         count += CPU_ISSET( i, &cs ) ? 1 : 0;
      count = std::max( count, size_t(1) );
   }

   size_t count;
} cpus;

struct ReverseLookup {
   ReverseLookup( const char *from, const char *to ) {
      for ( int i = 0; i < 256; i++ )
         byteLookup[i] = i;
      for ( ; *from && *to; from++, to++ ) {
         byteLookup[toupper(*from)] = *to;
         byteLookup[tolower(*from)] = *to;
      }

      for ( int i = 0; i < 256; i++ )
         for ( int j = 0; j < 256; j++ )
            wordLookup[(i << 8) | j] = ( byteLookup[j] << 8 ) | byteLookup[i];
   }

   char operator[]( const char &c ) { return (char )byteLookup[(unsigned char )c]; }
   short operator[]( const short &s ) { return (short )wordLookup[(unsigned short )s]; }

protected:
   unsigned char byteLookup[256];
   unsigned short wordLookup[256*256];
} lookup( "acbdghkmnsrutwvy", "TGVHCDMKNSYAAWBR" );

template< class type >
struct vector2 : public std::vector<type> {
   type &last() { return this->operator[]( std::vector<type>::size() -1 ); }
};

struct Chunker {
   enum { lineLength = 60, chunkSize = 65536, };

   Chunker( int seq ) : id(seq) {}

   struct Chunk {
      Chunk() {}
      Chunk( char *in, size_t amt ) : data(in), size(amt) {}
      char *data;
      size_t size;
   };

   void NewChunk() {
      size_t cur = mark - chunkBase;
      chunks.push_back( Chunk( chunkBase, cur ) );
      chunkBase += ( cur + ( cur & 1 ) ); // keep it word aligned

      mark = chunkBase;
   }

   template< int N >
   struct LinePrinter {
      LinePrinter() : lineFill(0) {}
      void endofblock() { if ( lineFill ) newline(); }
      void emit( const char *str, size_t amt ) {
         fwrite_unlocked( str, 1, amt, stdout );
      }
      void emit( char c ) { fputc_unlocked( c, stdout ); }
      void emitnewline() { emit( '\n' ); }
      void emitlines( char *data, size_t size ) {
         if ( lineFill ) {
            size_t toprint = std::min( size, lineLength - lineFill );
            emit( data, toprint );
            size -= toprint;
            data += toprint;
            lineFill += toprint;
            if ( lineFill == lineLength )
               newline();
         }

         while ( size >= lineLength ) {
            emit( data, lineLength );
            emitnewline();
            size -= lineLength;
            data += lineLength;
         }

         if ( size ) {
            lineFill = size;
            emit( data, size );
         }
      }
      void newline() { lineFill = 0; emitnewline(); }
      void reset() { lineFill = 0; }
   protected:
      size_t lineFill;
   };

   void Print() {
      int prevId = -( id - 1 );
      while ( __sync_val_compare_and_swap( &printQueue, prevId, id ) != prevId )
         sched_yield();

      fwrite_unlocked( name, 1, strlen( name ), stdout );
      static LinePrinter<65536*2> line;
      line.reset();
      for ( int i = int(chunks.size()) - 1; i >= 0; i-- )
         line.emitlines( chunks[i].data, chunks[i].size );
      line.endofblock();

      __sync_val_compare_and_swap( &printQueue, id, -id );
   }

   // fseek on stdin seems flaky so this hack. not called often

   void Backup() {
      while ( true ) {
         if ( fgetc_unlocked( stdin ) == '>' ) {
            fseek( stdin, -1, SEEK_CUR );
            return;
         }
         fseek( stdin, -2, SEEK_CUR );
      }
   }

   // input buffer can hold all of stdin, so no size checking

   size_t Read( char *data ) {
      if ( feof( stdin ) )
         return 0;

      name = data;
      fgets_unlocked( name, 128, stdin );
      mark = chunkBase = name + strlen( name ) + 1;
      mark[lineLength] = -1;

      while ( fgets_unlocked( mark, 128, stdin ) ) {
         if ( *mark == '>' ) {
            Backup();
            break;
         }

         // mark trick should keep us from calling strlen

         mark += ( mark[lineLength] != 0xa ) ? strlen( mark ) - 1 : lineLength;
         if ( mark - chunkBase > chunkSize )
            NewChunk();

         mark[lineLength] = -1;
      }

      if ( mark - chunkBase )
         NewChunk();
      return ( chunkBase - data );
   }

   struct WorkerState {
      Chunker *chunker;
      size_t offset, count;
      pthread_t handle;
   };

   static void *ReverseWorker( void *arg ) {
      WorkerState *state = (WorkerState *)arg;
      Chunker &chunker = *state->chunker;
      for ( size_t i = 0; i < state->count; i++ ) {
         Chunk &chunk = chunker[state->offset + i];
         short *w = (short *)chunk.data, *bot = w, *top = w + ( chunk.size / 2 ) - 1;
         for ( ; bot < top; bot++, top-- ) {
            short tmp = lookup[*bot];
            *bot = lookup[*top];
            *top = tmp;
         }
         // if size is odd, final byte would reverse to the start (skip it)

         if ( chunk.size & 1 )
            chunk.data++;
      }
      return 0;
   }

   void Reverse() {
      if ( !chunks.size() )
         return;

      // this takes so little time it's almost not worth parallelizing

      vector2<WorkerState> threads;
      threads.reserve( cpus.count );
      size_t divs = chunks.size() / cpus.count;
      for ( size_t i = 0, offset = 0; i < cpus.count; i++, offset += divs ) {
         threads.push_back( WorkerState() );
         WorkerState &ws = threads.last();
         ws.chunker = this;
         ws.count = ( i < cpus.count - 1 ) ? divs : chunks.size() - offset;
         ws.offset = offset;
         pthread_create( &ws.handle, 0, ReverseWorker, &ws );
      }

      for ( size_t i = 0; i < cpus.count; i++ )
         pthread_join( threads[i].handle, 0 );
   }

   Chunk &operator[] ( size_t i ) { return chunks[i]; }

protected:
   vector2<Chunk> chunks;
   char *name, *chunkBase, *mark;
   int id;
   static volatile int printQueue;
};

// used to order chunk printing

volatile int Chunker::printQueue = 0;

struct ReverseComplement {
   ReverseComplement() {
      // get stdin file size

      long start = ftell( stdin );
      fseek( stdin, 0, SEEK_END );
      size = ftell( stdin ) - start;
      fseek( stdin, start, SEEK_SET );

      data = new char[size + 3];
   }

   ~ReverseComplement() {
      delete[] data;
   }

   static void *ChunkerThread( void *arg ) {
      Chunker *chunker = (Chunker *)arg;
      chunker->Reverse();
      chunker->Print();
      return 0;
   }

   void Run() {
      vector2<Chunker *> chunkers;
      vector2<pthread_t> threads;

      size_t cur = 0;
      for ( int id = 1; true; id++ ) {
         chunkers.push_back( new Chunker( id ) );

         size_t read = chunkers.last()->Read( data + cur );
         cur += read;
         if ( !read )
            break;

         // spawn off a thread to finish this guy up while we read another chunk in

         threads.push_back( 0 );
         pthread_create( &threads.last(), 0, ChunkerThread, chunkers.last() );
      }

      for ( size_t i = 0; i < threads.size(); i++ )
         pthread_join( threads[i], 0 );

      for ( size_t i = 0; i < chunkers.size(); i++ )
         delete chunkers[i];
   }


protected:
   size_t size;
   char *data;
};


int main( int argc, const char *argv[] ) {
   ReverseComplement revcom;
   revcom.Run();
   return 0;
}

## c-version.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define BLOCKLEN (1*1024*1024)

#define TRUE 1
#define FALSE 0

/* Initialised by calls to set_complement. Holds the complement codes. */

static char complement[256];

void set_complement(int c1, int c2) {
    complement [c1] = c2;
    complement [c2] = c1;
    complement [c1 | 0x20] = c2;
    complement [c2 | 0x20] = c1;
}

/*
 *  this walks two pointers towards each other, every time one of the pointers
 *  hits a linefeed the linefeed is skipped and the loop restarted. Whenever neither
 *  pointer is on a linefeed (the most common case) the characters are complemented
 *  and swapped.
 */

void reverse_complement(unsigned char * ptr1, unsigned char * ptr2) {
    unsigned char c;

    while (ptr1 <= ptr2) {

        if (*ptr1 == 10) {
            ptr1++;
            continue;
        }

        if (*ptr2 == 10) {
            ptr2--;
            continue;
        }

        c = complement[*ptr1];
        *ptr1++ = complement [*ptr2];
        *ptr2-- = c;
    }
}

/*
 * Fasta files do not have any parser friendly features such as length fields. This means
 * that if you want to know if a sequence is complete you have to scan for the next '>'
 * character of the title following the current sequence. This is quite time consuming,
 * and even if you find it you still have a problem because you'll have read *too much*
 * data from the input stream. That excess is then saved in a separate buffer to be re-used
 * at the beginning of the next round of reading.
 *
 * This loop is pretty slow, it takes up about 40% of the total runtime of the program.
 * There is a clear way to improve it, which is to scan only the part that was just read
 * in after the first pass through the loop in read_sequence. I'll leave that as an exercise
 * for those that want to beat this version of the code, there is an easy #1 spot in the
 * language shootout waiting for you if you add that feature ;) (and multithreading if
 * you want to keep that #1 spot!)
 */

int sequence_complete(unsigned char * p, int n, unsigned char ** saved, int * savedsize)

{
    // skip the leading '>' for the title of the current block, we want the *next* block

    p++;
    n--;

    // now search the rest of the data for a sequence start

    while (n) {
        if (*p == '>') {
            // we've found a title for the next sequence, figure how how much excess we have
            // and save the remainder

            *saved = (unsigned char*) malloc(n);

            memcpy(*saved, p, n);
            *savedsize = n;

            return TRUE;
        }

        p++;
        n--;
    }

    return FALSE;
}

// read in a sequence, if we read in more than one whole one save the excess

unsigned char * read_sequence(int * s, unsigned char ** saved, int * nsaved) {
    int size;
    unsigned char * p;
    int read;
    int n;

    if (*saved == NULL) {
        // first round or a really lucky break
        size = BLOCKLEN;
        p = (unsigned char*) malloc(BLOCKLEN);
        read = 0;
    }
    else {
        // round which starts from excess data read during a previous round
        size = *nsaved;
        p = *saved;
        *saved = NULL;
        read = *nsaved;
        size <<= 1; // fix for bug spotted by Robert G. Jakabosky
    }

    while (!feof(stdin) || read) {
        p = (unsigned char*) realloc(p, size);

        n = fread(p + read, 1, size - read, stdin);

        read += n;

        // if the sequence is now complete save the excess for the next
        // iteration and process this sequence. Like that we don't need
        // to read all the way to end-of-file before we can start processing
        // if we have read more than one whole sequence this still works, it
        // just means that we will re-visit this on the next round through
        // the reader to fetch another whole sequence.

        if (sequence_complete(p, read, saved, nsaved)) {

            read -= *nsaved;    // compensate for saved portion
            break;
        }

        // if we did not read any data we can return now

        if (n == 0) {
            break;
        }

        // every time we reach the end of the block we scale up

        if (read == size) {
            size <<= 1;
        }
    }

    *s = read;

    return p;
}

void process_sequence(unsigned char * p, int size) {

    unsigned char * start;

    // skip the block title
    start = (unsigned char*)strchr((char*)p, '\n') + 1;

    // figure out start and end of this sequence and do the complement

    reverse_complement(start, start + size - (start - p) - 1);
}

void setup() {

        set_complement ('A', 'T');
        set_complement ('C', 'G');
        set_complement ('M', 'K');
        set_complement ('R', 'Y');
        set_complement ('W', 'W');
        set_complement ('S', 'S');
        set_complement ('V', 'B');
        set_complement ('H', 'D');
        set_complement ('N', 'N');
}

/*
 * process sequences one-by-one until we're out of sequences and end-of-file
 * has been reached on the input and the readahead buffer is empty
 */

void process() {

    unsigned char * readahead = NULL;
    int nreadahead;
    unsigned char * p;
    int s;

    while (readahead != NULL || !feof(stdin)) {
        p = read_sequence(&s, &readahead, &nreadahead);

        process_sequence(p, s);

        fwrite(p, 1, s, stdout);

        free(p);
    }
}

int main() {

    setup();

    process();

    return 0;
}

## cpp-version.cpp
/* The Computer Language Benchmarks Game
   http://benchmarksgame.alioth.debian.org/

   contributed by Seth Heeren
*/
#include <iostream>
#include <string>

using std::string;
using std::cin;
using std::cout;
using std::getline;
using std::endl;

template <typename Ch> inline Ch complement(Ch c)
{
    switch (std::toupper((unsigned)c)) // std::toupper has tricky semantics - no
                                       // sign extension please
    {
        // IDEA: Reorder branches after profiling?
        // IDEA: (gcc probably compiles the switch into a jump table)
        case 'A': return 'T';
        case 'B': return 'V';
        case 'C': return 'G';
        case 'D': return 'H';
        case 'G': return 'C';
        case 'H': return 'D';
        case 'K': return 'M';
        case 'M': return 'K';
        case 'N': return 'N';
        case 'R': return 'Y';
        case 'S': return 'S';
        case 'T': case 'U': return 'A';
        case 'V': return 'B';
        case 'W': return 'W';
        case 'Y': return 'R';
    }
    throw "parse error"; // TODO proper exception
}

inline static void print_reverse(std::string const& sequence)
{
    size_t count = 0;
    for (auto i = sequence.rbegin(); i != sequence.rend(); ++i)
    {
        cout << *i; // TODO: buffer writes and append line by line?
        if (0 == ++count % 60)
            cout << '\n';
    }
    if (count % 60)
        cout << '\n';
}

int main()
{
    string sequence, line;
    sequence.reserve(12000); // arbitrary heuristic preallocation
    // cin.unsetf(std::ios::skipws);

    while (getline(cin, line))
    {
        const bool is_header = (line[0] == '>');

        if (is_header)
        {
            if (!sequence.empty())
            {
                for (auto& c : sequence)
                    c = complement(c);
                print_reverse(sequence);
            }
            // clear, (retain allocated capacity)
            sequence.resize(0);

            // print header line
            cout << line << endl;
        }
        else
        {
            sequence.append(line);
        }
    }

    if (!sequence.empty())
    {
        for (auto& c : sequence)
            c = complement(c);
        print_reverse(sequence);
    }
}

## Makefile
all: cpp-version c-version alioth

CPPFLAGS+=-g -O3
CPPFLAGS+=-march=native
# LDFLAGS+=-ltcmalloc

CXXFLAGS+=$(CPPFLAGS) -std=c++0x
LDFLAGS+=-lpthread

# CXX=clang++
# CC=~clang

%:%.cpp
	$(CXX) $(CXXFLAGS) $^ -o $@ $(LDFLAGS)

%:%.c
	$(CC) $(CPPFLAGS) $^ -o $@ $(LDFLAGS)

## revcomp-input.txt
>ONE Homo sapiens alu
GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
GGCGACAGAGCGAGACTCCG
>TWO IUB ambiguity codes
cttBtatcatatgctaKggNcataaaSatgtaaaDcDRtBggDtctttataattcBgtcg
tactDtDagcctatttSVHtHttKtgtHMaSattgWaHKHttttagacatWatgtRgaaa
NtactMcSMtYtcMgRtacttctWBacgaaatatagScDtttgaagacacatagtVgYgt
cattHWtMMWcStgttaggKtSgaYaaccWStcgBttgcgaMttBYatcWtgacaYcaga
gtaBDtRacttttcWatMttDBcatWtatcttactaBgaYtcttgttttttttYaaScYa
HgtgttNtSatcMtcVaaaStccRcctDaataataStcYtRDSaMtDttgttSagtRRca
tttHatSttMtWgtcgtatSSagactYaaattcaMtWatttaSgYttaRgKaRtccactt
tattRggaMcDaWaWagttttgacatgttctacaaaRaatataataaMttcgDacgaSSt
acaStYRctVaNMtMgtaggcKatcttttattaaaaagVWaHKYagtttttatttaacct
tacgtVtcVaattVMBcttaMtttaStgacttagattWWacVtgWYagWVRctDattBYt
gtttaagaagattattgacVatMaacattVctgtBSgaVtgWWggaKHaatKWcBScSWa
accRVacacaaactaccScattRatatKVtactatatttHttaagtttSKtRtacaaagt
RDttcaaaaWgcacatWaDgtDKacgaacaattacaRNWaatHtttStgttattaaMtgt
tgDcgtMgcatBtgcttcgcgaDWgagctgcgaggggVtaaScNatttacttaatgacag
cccccacatYScaMgtaggtYaNgttctgaMaacNaMRaacaaacaKctacatagYWctg
ttWaaataaaataRattagHacacaagcgKatacBttRttaagtatttccgatctHSaat
actcNttMaagtattMtgRtgaMgcataatHcMtaBSaRattagttgatHtMttaaKagg
YtaaBataSaVatactWtataVWgKgttaaaacagtgcgRatatacatVtHRtVYataSa
KtWaStVcNKHKttactatccctcatgWHatWaRcttactaggatctataDtDHBttata
aaaHgtacVtagaYttYaKcctattcttcttaataNDaaggaaaDYgcggctaaWSctBa
aNtgctggMBaKctaMVKagBaactaWaDaMaccYVtNtaHtVWtKgRtcaaNtYaNacg
gtttNattgVtttctgtBaWgtaattcaagtcaVWtactNggattctttaYtaaagccgc
tcttagHVggaYtgtNcDaVagctctctKgacgtatagYcctRYHDtgBattDaaDgccK
tcHaaStttMcctagtattgcRgWBaVatHaaaataYtgtttagMDMRtaataaggatMt
ttctWgtNtgtgaaaaMaatatRtttMtDgHHtgtcattttcWattRSHcVagaagtacg
ggtaKVattKYagactNaatgtttgKMMgYNtcccgSKttctaStatatNVataYHgtNa
BKRgNacaactgatttcctttaNcgatttctctataScaHtataRagtcRVttacDSDtt
aRtSatacHgtSKacYagttMHtWataggatgactNtatSaNctataVtttRNKtgRacc
tttYtatgttactttttcctttaaacatacaHactMacacggtWataMtBVacRaSaatc
cgtaBVttccagccBcttaRKtgtgcctttttRtgtcagcRttKtaaacKtaaatctcac
aattgcaNtSBaaccgggttattaaBcKatDagttactcttcattVtttHaaggctKKga
tacatcBggScagtVcacattttgaHaDSgHatRMaHWggtatatRgccDttcgtatcga
aacaHtaagttaRatgaVacttagattVKtaaYttaaatcaNatccRttRRaMScNaaaD
gttVHWgtcHaaHgacVaWtgttScactaagSgttatcttagggDtaccagWattWtRtg
ttHWHacgattBtgVcaYatcggttgagKcWtKKcaVtgaYgWctgYggVctgtHgaNcV
taBtWaaYatcDRaaRtSctgaHaYRttagatMatgcatttNattaDttaattgttctaa
ccctcccctagaWBtttHtBccttagaVaatMcBHagaVcWcagBVttcBtaYMccagat
gaaaaHctctaacgttagNWRtcggattNatcRaNHttcagtKttttgWatWttcSaNgg
gaWtactKKMaacatKatacNattgctWtatctaVgagctatgtRaHtYcWcttagccaa
tYttWttaWSSttaHcaaaaagVacVgtaVaRMgattaVcDactttcHHggHRtgNcctt
tYatcatKgctcctctatVcaaaaKaaaagtatatctgMtWtaaaacaStttMtcgactt
taSatcgDataaactaaacaagtaaVctaggaSccaatMVtaaSKNVattttgHccatca
cBVctgcaVatVttRtactgtVcaattHgtaaattaaattttYtatattaaRSgYtgBag
aHSBDgtagcacRHtYcBgtcacttacactaYcgctWtattgSHtSatcataaatataHt
cgtYaaMNgBaatttaRgaMaatatttBtttaaaHHKaatctgatWatYaacttMctctt
ttVctagctDaaagtaVaKaKRtaacBgtatccaaccactHHaagaagaaggaNaaatBW
attccgStaMSaMatBttgcatgRSacgttVVtaaDMtcSgVatWcaSatcttttVatag
ttactttacgatcaccNtaDVgSRcgVcgtgaacgaNtaNatatagtHtMgtHcMtagaa
attBgtataRaaaacaYKgtRccYtatgaagtaataKgtaaMttgaaRVatgcagaKStc
tHNaaatctBBtcttaYaBWHgtVtgacagcaRcataWctcaBcYacYgatDgtDHccta
>THREE Homo sapiens frequency
aacacttcaccaggtatcgtgaaggctcaagattacccagagaacctttgcaatataaga
atatgtatgcagcattaccctaagtaattatattctttttctgactcaaagtgacaagcc
ctagtgtatattaaatcggtatatttgggaaattcctcaaactatcctaatcaggtagcc
atgaaagtgatcaaaaaagttcgtacttataccatacatgaattctggccaagtaaaaaa
tagattgcgcaaaattcgtaccttaagtctctcgccaagatattaggatcctattactca
tatcgtgtttttctttattgccgccatccccggagtatctcacccatccttctcttaaag
gcctaatattacctatgcaaataaacatatattgttgaaaattgagaacctgatcgtgat
tcttatgtgtaccatatgtatagtaatcacgcgactatatagtgctttagtatcgcccgt
gggtgagtgaatattctgggctagcgtgagatagtttcttgtcctaatatttttcagatc
gaatagcttctatttttgtgtttattgacatatgtcgaaactccttactcagtgaaagtc
atgaccagatccacgaacaatcttcggaatcagtctcgttttacggcggaatcttgagtc
taacttatatcccgtcgcttactttctaacaccccttatgtatttttaaaattacgttta
ttcgaacgtacttggcggaagcgttattttttgaagtaagttacattgggcagactcttg
acattttcgatacgactttctttcatccatcacaggactcgttcgtattgatatcagaag
ctcgtgatgattagttgtcttctttaccaatactttgaggcctattctgcgaaatttttg
ttgccctgcgaacttcacataccaaggaacacctcgcaacatgccttcatatccatcgtt
cattgtaattcttacacaatgaatcctaagtaattacatccctgcgtaaaagatggtagg
ggcactgaggatatattaccaagcatttagttatgagtaatcagcaatgtttcttgtatt
aagttctctaaaatagttacatcgtaatgttatctcgggttccgcgaataaacgagatag
attcattatatatggccctaagcaaaaacctcctcgtattctgttggtaattagaatcac
acaatacgggttgagatattaattatttgtagtacgaagagatataaaaagatgaacaat
tactcaagtcaagatgtatacgggatttataataaaaatcgggtagagatctgctttgca
attcagacgtgccactaaatcgtaatatgtcgcgttacatcagaaagggtaactattatt
aattaataaagggcttaatcactacatattagatcttatccgatagtcttatctattcgt
tgtatttttaagcggttctaattcagtcattatatcagtgctccgagttctttattattg
ttttaaggatgacaaaatgcctcttgttataacgctgggagaagcagactaagagtcgga
gcagttggtagaatgaggctgcaaaagacggtctcgacgaatggacagactttactaaac
caatgaaagacagaagtagagcaaagtctgaagtggtatcagcttaattatgacaaccct
taatacttccctttcgccgaatactggcgtggaaaggttttaaaagtcgaagtagttaga
ggcatctctcgctcataaataggtagactactcgcaatccaatgtgactatgtaatactg
ggaacatcagtccgcgatgcagcgtgtttatcaaccgtccccactcgcctggggagacat
gagaccacccccgtggggattattagtccgcagtaatcgactcttgacaatccttttcga
ttatgtcatagcaatttacgacagttcagcgaagtgactactcggcgaaatggtattact
aaagcattcgaacccacatgaatgtgattcttggcaatttctaatccactaaagcttttc
cgttgaatctggttgtagatatttatataagttcactaattaagatcacggtagtatatt
gatagtgatgtctttgcaagaggttggccgaggaatttacggattctctattgatacaat
ttgtctggcttataactcttaaggctgaaccaggcgtttttagacgacttgatcagctgt
tagaatggtttggactccctctttcatgtcagtaacatttcagccgttattgttacgata
tgcttgaacaatattgatctaccacacacccatagtatattttataggtcatgctgttac
ctacgagcatggtattccacttcccattcaatgagtattcaacatcactagcctcagaga
tgatgacccacctctaataacgtcacgttgcggccatgtgaaacctgaacttgagtagac
gatatcaagcgctttaaattgcatataacatttgagggtaaagctaagcggatgctttat
ataatcaatactcaataataagatttgattgcattttagagttatgacacgacatagttc
actaacgagttactattcccagatctagactgaagtactgatcgagacgatccttacgtc
gatgatcgttagttatcgacttaggtcgggtctctagcggtattggtacttaaccggaca
ctatactaataacccatgatcaaagcataacagaatacagacgataatttcgccaacata
tatgtacagaccccaagcatgagaagctcattgaaagctatcattgaagtcccgctcaca
atgtgtcttttccagacggtttaactggttcccgggagtcctggagtttcgacttacata
aatggaaacaatgtattttgctaatttatctatagcgtcatttggaccaatacagaatat
tatgttgcctagtaatccactataacccgcaagtgctgatagaaaatttttagacgattt
ataaatgccccaagtatccctcccgtgaatcctccgttatactaattagtattcgttcat
acgtataccgcgcatatatgaacatttggcgataaggcgcgtgaattgttacgtgacaga
gatagcagtttcttgtgatatggttaacagacgtacatgaagggaaactttatatctata
gtgatgcttccgtagaaataccgccactggtctgccaatgatgaagtatgtagctttagg
tttgtactatgaggctttcgtttgtttgcagagtataacagttgcgagtgaaaaaccgac
gaatttatactaatacgctttcactattggctacaaaatagggaagagtttcaatcatga
gagggagtatatggatgctttgtagctaaaggtagaacgtatgtatatgctgccgttcat
tcttgaaagatacataagcgataagttacgacaattataagcaacatccctaccttcgta
acgatttcactgttactgcgcttgaaatacactatggggctattggcggagagaagcaga
tcgcgccgagcatatacgagacctataatgttgatgatagagaaggcgtctgaattgata
catcgaagtacactttctttcgtagtatctctcgtcctctttctatctccggacacaaga
attaagttatatatatagagtcttaccaatcatgttgaatcctgattctcagagttcttt
ggcgggccttgtgatgactgagaaacaatgcaatattgctccaaatttcctaagcaaatt
ctcggttatgttatgttatcagcaaagcgttacgttatgttatttaaatctggaatgacg
gagcgaagttcttatgtcggtgtgggaataattcttttgaagacagcactccttaaataa
tatcgctccgtgtttgtatttatcgaatgggtctgtaaccttgcacaagcaaatcggtgg
tgtatatatcggataacaattaatacgatgttcatagtgacagtatactgatcgagtcct
ctaaagtcaattacctcacttaacaatctcattgatgttgtgtcattcccggtatcgccc
gtagtatgtgctctgattgaccgagtgtgaaccaaggaacatctactaatgcctttgtta
ggtaagatctctctgaattccttcgtgccaacttaaaacattatcaaaatttcttctact
tggattaactacttttacgagcatggcaaattcccctgtggaagacggttcattattatc
ggaaaccttatagaaattgcgtgttgactgaaattagatttttattgtaagagttgcatc
tttgcgattcctctggtctagcttccaatgaacagtcctcccttctattcgacatcgggt
ccttcgtacatgtctttgcgatgtaataattaggttcggagtgtggccttaatgggtgca
actaggaatacaacgcaaatttgctgacatgatagcaaatcggtatgccggcaccaaaac
gtgctccttgcttagcttgtgaatgagactcagtagttaaataaatccatatctgcaatc
gattccacaggtattgtccactatctttgaactactctaagagatacaagcttagctgag
accgaggtgtatatgactacgctgatatctgtaaggtaccaatgcaggcaaagtatgcga
gaagctaataccggctgtttccagctttataagattaaaatttggctgtcctggcggcct
cagaattgttctatcgtaatcagttggttcattaattagctaagtacgaggtacaactta
tctgtcccagaacagctccacaagtttttttacagccgaaacccctgtgtgaatcttaat
atccaagcgcgttatctgattagagtttacaactcagtattttatcagtacgttttgttt
ccaacattacccggtatgacaaaatgacgccacgtgtcgaataatggtctgaccaatgta
ggaagtgaaaagataaatat

## revcomp-output.txt
>ONE Homo sapiens alu
CGGAGTCTCGCTCTGTCGCCCAGGCTGGAGTGCAGTGGCGCGATCTCGGCTCACTGCAAC
CTCCGCCTCCCGGGTTCAAGCGATTCTCCTGCCTCAGCCTCCCGAGTAGCTGGGATTACA
GGCGCGCGCCACCACGCCCGGCTAATTTTTGTATTTTTAGTAGAGACGGGGTTTCACCAT
GTTGGCCAGGCTGGTCTCGAACTCCTGACCTCAGGTGATCCGCCCGCCTCGGCCTCCCAA
AGTGCTGGGATTACAGGCGTGAGCCACCGCGCCCGGCCTTTTTGAGACGGAGTCTCGCTC
TGTCGCCCAGGCTGGAGTGCAGTGGCGCGATCTCGGCTCACTGCAACCTCCGCCTCCCGG
GTTCAAGCGATTCTCCTGCCTCAGCCTCCCGAGTAGCTGGGATTACAGGCGCGCGCCACC
ACGCCCGGCTAATTTTTGTATTTTTAGTAGAGACGGGGTTTCACCATGTTGGCCAGGCTG
GTCTCGAACTCCTGACCTCAGGTGATCCGCCCGCCTCGGCCTCCCAAAGTGCTGGGATTA
CAGGCGTGAGCCACCGCGCCCGGCCTTTTTGAGACGGAGTCTCGCTCTGTCGCCCAGGCT
GGAGTGCAGTGGCGCGATCTCGGCTCACTGCAACCTCCGCCTCCCGGGTTCAAGCGATTC
TCCTGCCTCAGCCTCCCGAGTAGCTGGGATTACAGGCGCGCGCCACCACGCCCGGCTAAT
TTTTGTATTTTTAGTAGAGACGGGGTTTCACCATGTTGGCCAGGCTGGTCTCGAACTCCT
GACCTCAGGTGATCCGCCCGCCTCGGCCTCCCAAAGTGCTGGGATTACAGGCGTGAGCCA
CCGCGCCCGGCCTTTTTGAGACGGAGTCTCGCTCTGTCGCCCAGGCTGGAGTGCAGTGGC
GCGATCTCGGCTCACTGCAACCTCCGCCTCCCGGGTTCAAGCGATTCTCCTGCCTCAGCC
TCCCGAGTAGCTGGGATTACAGGCGCGCGCCACCACGCCCGGCTAATTTTTGTATTTTTA
GTAGAGACGGGGTTTCACCATGTTGGCCAGGCTGGTCTCGAACTCCTGACCTCAGGTGAT
CCGCCCGCCTCGGCCTCCCAAAGTGCTGGGATTACAGGCGTGAGCCACCGCGCCCGGCCT
TTTTGAGACGGAGTCTCGCTCTGTCGCCCAGGCTGGAGTGCAGTGGCGCGATCTCGGCTC
ACTGCAACCTCCGCCTCCCGGGTTCAAGCGATTCTCCTGCCTCAGCCTCCCGAGTAGCTG
GGATTACAGGCGCGCGCCACCACGCCCGGCTAATTTTTGTATTTTTAGTAGAGACGGGGT
TTCACCATGTTGGCCAGGCTGGTCTCGAACTCCTGACCTCAGGTGATCCGCCCGCCTCGG
CCTCCCAAAGTGCTGGGATTACAGGCGTGAGCCACCGCGCCCGGCCTTTTTGAGACGGAG
TCTCGCTCTGTCGCCCAGGCTGGAGTGCAGTGGCGCGATCTCGGCTCACTGCAACCTCCG
CCTCCCGGGTTCAAGCGATTCTCCTGCCTCAGCCTCCCGAGTAGCTGGGATTACAGGCGC
GCGCCACCACGCCCGGCTAATTTTTGTATTTTTAGTAGAGACGGGGTTTCACCATGTTGG
CCAGGCTGGTCTCGAACTCCTGACCTCAGGTGATCCGCCCGCCTCGGCCTCCCAAAGTGC
TGGGATTACAGGCGTGAGCCACCGCGCCCGGCCTTTTTGAGACGGAGTCTCGCTCTGTCG
CCCAGGCTGGAGTGCAGTGGCGCGATCTCGGCTCACTGCAACCTCCGCCTCCCGGGTTCA
AGCGATTCTCCTGCCTCAGCCTCCCGAGTAGCTGGGATTACAGGCGCGCGCCACCACGCC
CGGCTAATTTTTGTATTTTTAGTAGAGACGGGGTTTCACCATGTTGGCCAGGCTGGTCTC
GAACTCCTGACCTCAGGTGATCCGCCCGCCTCGGCCTCCCAAAGTGCTGGGATTACAGGC
GTGAGCCACCGCGCCCGGCC
>TWO IUB ambiguity codes
TAGGDHACHATCRGTRGVTGAGWTATGYTGCTGTCABACDWVTRTAAGAVVAGATTTNDA
GASMTCTGCATBYTTCAAKTTACMTATTACTTCATARGGYACMRTGTTTTYTATACVAAT
TTCTAKGDACKADACTATATNTANTCGTTCACGBCGYSCBHTANGGTGATCGTAAAGTAA
CTATBAAAAGATSTGWATBCSGAKHTTABBAACGTSYCATGCAAVATKTSKTASCGGAAT
WVATTTNTCCTTCTTCTTDDAGTGGTTGGATACVGTTAYMTMTBTACTTTHAGCTAGBAA
AAGAGKAAGTTRATWATCAGATTMDDTTTAAAVAAATATTKTCYTAAATTVCNKTTRACG
ADTATATTTATGATSADSCAATAWAGCGRTAGTGTAAGTGACVGRADYGTGCTACHVSDT
CTVCARCSYTTAATATARAAAATTTAATTTACDAATTGBACAGTAYAABATBTGCAGBVG
TGATGGDCAAAATBNMSTTABKATTGGSTCCTAGBTTACTTGTTTAGTTTATHCGATSTA
AAGTCGAKAAASTGTTTTAWAKCAGATATACTTTTMTTTTGBATAGAGGAGCMATGATRA
AAGGNCAYDCCDDGAAAGTHGBTAATCKYTBTACBGTBCTTTTTGDTAASSWTAAWAARA
TTGGCTAAGWGRADTYACATAGCTCBTAGATAWAGCAATNGTATMATGTTKMMAGTAWTC
CCNTSGAAWATWCAAAAMACTGAADNTYGATNAATCCGAYWNCTAACGTTAGAGDTTTTC
ATCTGGKRTAVGAABVCTGWGBTCTDVGKATTBTCTAAGGVADAAAVWTCTAGGGGAGGG
TTAGAACAATTAAHTAATNAAATGCATKATCTAAYRTDTCAGSAYTTYHGATRTTWAVTA
BGNTCDACAGBCCRCAGWCRTCABTGMMAWGMCTCAACCGATRTGBCAVAATCGTDWDAA
CAYAWAATWCTGGTAHCCCTAAGATAACSCTTAGTGSAACAWTBGTCDTTDGACWDBAAC
HTTTNGSKTYYAAYGGATNTGATTTAARTTAMBAATCTAAGTBTCATYTAACTTADTGTT
TCGATACGAAHGGCYATATACCWDTKYATDCSHTDTCAAAATGTGBACTGSCCVGATGTA
TCMMAGCCTTDAAABAATGAAGAGTAACTHATMGVTTAATAACCCGGTTVSANTGCAATT
GTGAGATTTAMGTTTAMAAYGCTGACAYAAAAAGGCACAMYTAAGVGGCTGGAABVTACG
GATTSTYGTBVAKTATWACCGTGTKAGTDTGTATGTTTAAAGGAAAAAGTAACATARAAA
GGTYCAMNYAAABTATAGNTSATANAGTCATCCTATWADKAACTRGTMSACDGTATSAYT
AAHSHGTAABYGACTYTATADTGSTATAGAGAAATCGNTAAAGGAAATCAGTTGTNCYMV
TNACDRTATBNATATASTAGAAMSCGGGANRCKKMCAAACATTNAGTCTRMAATBMTACC
CGTACTTCTBGDSYAATWGAAAATGACADDCHAKAAAYATATTKTTTTCACANACWAGAA
AKATCCTTATTAYKHKCTAAACARTATTTTDATBTVWCYGCAATACTAGGKAAASTTDGA
MGGCHTTHAATVCAHDRYAGGRCTATACGTCMAGAGAGCTBTHGNACARTCCBDCTAAGA
GCGGCTTTARTAAAGAATCCNAGTAWBTGACTTGAATTACWTVACAGAAABCAATNAAAC
CGTNTRANTTGAYCMAWBADTANABRGGTKTHTWTAGTTVCTMBKTAGMTVKCCAGCANT
TVAGSWTTAGCCGCRHTTTCCTTHNTATTAAGAAGAATAGGMTRAARTCTABGTACDTTT
TATAAVDHAHTATAGATCCTAGTAAGYTWATDWCATGAGGGATAGTAAMDMNGBASTWAM
TSTATRBAYDABATGTATATYCGCACTGTTTTAACMCWBTATAWAGTATBTSTATVTTAR
CCTMTTAAKADATCAACTAATYTSVTAKGDATTATGCKTCAYCAKAATACTTKAANGAGT
ATTSDAGATCGGAAATACTTAAYAAVGTATMCGCTTGTGTDCTAATYTATTTTATTTWAA
CAGWRCTATGTAGMTGTTTGTTYKTNGTTKTCAGAACNTRACCTACKTGSRATGTGGGGG
CTGTCATTAAGTAAATNGSTTABCCCCTCGCAGCTCWHTCGCGAAGCAVATGCKACGHCA
ACAKTTAATAACASAAADATTWNYTGTAATTGTTCGTMHACHTWATGTGCWTTTTGAAHY
ACTTTGTAYAMSAAACTTAADAAATATAGTABMATATYAATGSGGTAGTTTGTGTBYGGT
TWSGSVGWMATTDMTCCWWCABTCSVACAGBAATGTTKATBGTCAATAATCTTCTTAAAC
ARVAATHAGYBWCTRWCABGTWWAATCTAAGTCASTAAAKTAAGVKBAATTBGABACGTA
AGGTTAAATAAAAACTRMDTWBCTTTTTAATAAAAGATMGCCTACKAKNTBAGYRASTGT
ASSTCGTHCGAAKTTATTATATTYTTTGTAGAACATGTCAAAACTWTWTHGKTCCYAATA
AAGTGGAYTMCYTAARCSTAAATWAKTGAATTTRAGTCTSSATACGACWAKAASATDAAA
TGYYACTSAACAAHAKTSHYARGASTATTATTHAGGYGGASTTTBGAKGATSANAACACD
TRGSTTRAAAAAAAACAAGARTCVTAGTAAGATAWATGVHAAKATWGAAAAGTYAHVTAC
TCTGRTGTCAWGATRVAAKTCGCAAVCGASWGGTTRTCSAMCCTAACASGWKKAWDAATG
ACRCBACTATGTGTCTTCAAAHGSCTATATTTCGTVWAGAAGTAYCKGARAKSGKAGTAN
TTTCYACATWATGTCTAAAADMDTWCAATSTKDACAMAADADBSAAATAGGCTHAHAGTA
CGACVGAATTATAAAGAHCCVAYHGHTTTACATSTTTATGNCCMTAGCATATGATAVAAG
>THREE Homo sapiens frequency
ATATTTATCTTTTCACTTCCTACATTGGTCAGACCATTATTCGACACGTGGCGTCATTTT
GTCATACCGGGTAATGTTGGAAACAAAACGTACTGATAAAATACTGAGTTGTAAACTCTA
ATCAGATAACGCGCTTGGATATTAAGATTCACACAGGGGTTTCGGCTGTAAAAAAACTTG
TGGAGCTGTTCTGGGACAGATAAGTTGTACCTCGTACTTAGCTAATTAATGAACCAACTG
ATTACGATAGAACAATTCTGAGGCCGCCAGGACAGCCAAATTTTAATCTTATAAAGCTGG
AAACAGCCGGTATTAGCTTCTCGCATACTTTGCCTGCATTGGTACCTTACAGATATCAGC
GTAGTCATATACACCTCGGTCTCAGCTAAGCTTGTATCTCTTAGAGTAGTTCAAAGATAG
TGGACAATACCTGTGGAATCGATTGCAGATATGGATTTATTTAACTACTGAGTCTCATTC
ACAAGCTAAGCAAGGAGCACGTTTTGGTGCCGGCATACCGATTTGCTATCATGTCAGCAA
ATTTGCGTTGTATTCCTAGTTGCACCCATTAAGGCCACACTCCGAACCTAATTATTACAT
CGCAAAGACATGTACGAAGGACCCGATGTCGAATAGAAGGGAGGACTGTTCATTGGAAGC
TAGACCAGAGGAATCGCAAAGATGCAACTCTTACAATAAAAATCTAATTTCAGTCAACAC
GCAATTTCTATAAGGTTTCCGATAATAATGAACCGTCTTCCACAGGGGAATTTGCCATGC
TCGTAAAAGTAGTTAATCCAAGTAGAAGAAATTTTGATAATGTTTTAAGTTGGCACGAAG
GAATTCAGAGAGATCTTACCTAACAAAGGCATTAGTAGATGTTCCTTGGTTCACACTCGG
TCAATCAGAGCACATACTACGGGCGATACCGGGAATGACACAACATCAATGAGATTGTTA
AGTGAGGTAATTGACTTTAGAGGACTCGATCAGTATACTGTCACTATGAACATCGTATTA
ATTGTTATCCGATATATACACCACCGATTTGCTTGTGCAAGGTTACAGACCCATTCGATA
AATACAAACACGGAGCGATATTATTTAAGGAGTGCTGTCTTCAAAAGAATTATTCCCACA
CCGACATAAGAACTTCGCTCCGTCATTCCAGATTTAAATAACATAACGTAACGCTTTGCT
GATAACATAACATAACCGAGAATTTGCTTAGGAAATTTGGAGCAATATTGCATTGTTTCT
CAGTCATCACAAGGCCCGCCAAAGAACTCTGAGAATCAGGATTCAACATGATTGGTAAGA
CTCTATATATATAACTTAATTCTTGTGTCCGGAGATAGAAAGAGGACGAGAGATACTACG
AAAGAAAGTGTACTTCGATGTATCAATTCAGACGCCTTCTCTATCATCAACATTATAGGT
CTCGTATATGCTCGGCGCGATCTGCTTCTCTCCGCCAATAGCCCCATAGTGTATTTCAAG
CGCAGTAACAGTGAAATCGTTACGAAGGTAGGGATGTTGCTTATAATTGTCGTAACTTAT
CGCTTATGTATCTTTCAAGAATGAACGGCAGCATATACATACGTTCTACCTTTAGCTACA
AAGCATCCATATACTCCCTCTCATGATTGAAACTCTTCCCTATTTTGTAGCCAATAGTGA
AAGCGTATTAGTATAAATTCGTCGGTTTTTCACTCGCAACTGTTATACTCTGCAAACAAA
CGAAAGCCTCATAGTACAAACCTAAAGCTACATACTTCATCATTGGCAGACCAGTGGCGG
TATTTCTACGGAAGCATCACTATAGATATAAAGTTTCCCTTCATGTACGTCTGTTAACCA
TATCACAAGAAACTGCTATCTCTGTCACGTAACAATTCACGCGCCTTATCGCCAAATGTT
CATATATGCGCGGTATACGTATGAACGAATACTAATTAGTATAACGGAGGATTCACGGGA
GGGATACTTGGGGCATTTATAAATCGTCTAAAAATTTTCTATCAGCACTTGCGGGTTATA
GTGGATTACTAGGCAACATAATATTCTGTATTGGTCCAAATGACGCTATAGATAAATTAG
CAAAATACATTGTTTCCATTTATGTAAGTCGAAACTCCAGGACTCCCGGGAACCAGTTAA
ACCGTCTGGAAAAGACACATTGTGAGCGGGACTTCAATGATAGCTTTCAATGAGCTTCTC
ATGCTTGGGGTCTGTACATATATGTTGGCGAAATTATCGTCTGTATTCTGTTATGCTTTG
ATCATGGGTTATTAGTATAGTGTCCGGTTAAGTACCAATACCGCTAGAGACCCGACCTAA
GTCGATAACTAACGATCATCGACGTAAGGATCGTCTCGATCAGTACTTCAGTCTAGATCT
GGGAATAGTAACTCGTTAGTGAACTATGTCGTGTCATAACTCTAAAATGCAATCAAATCT
TATTATTGAGTATTGATTATATAAAGCATCCGCTTAGCTTTACCCTCAAATGTTATATGC
AATTTAAAGCGCTTGATATCGTCTACTCAAGTTCAGGTTTCACATGGCCGCAACGTGACG
TTATTAGAGGTGGGTCATCATCTCTGAGGCTAGTGATGTTGAATACTCATTGAATGGGAA
GTGGAATACCATGCTCGTAGGTAACAGCATGACCTATAAAATATACTATGGGTGTGTGGT
AGATCAATATTGTTCAAGCATATCGTAACAATAACGGCTGAAATGTTACTGACATGAAAG
AGGGAGTCCAAACCATTCTAACAGCTGATCAAGTCGTCTAAAAACGCCTGGTTCAGCCTT
AAGAGTTATAAGCCAGACAAATTGTATCAATAGAGAATCCGTAAATTCCTCGGCCAACCT
CTTGCAAAGACATCACTATCAATATACTACCGTGATCTTAATTAGTGAACTTATATAAAT
ATCTACAACCAGATTCAACGGAAAAGCTTTAGTGGATTAGAAATTGCCAAGAATCACATT
CATGTGGGTTCGAATGCTTTAGTAATACCATTTCGCCGAGTAGTCACTTCGCTGAACTGT
CGTAAATTGCTATGACATAATCGAAAAGGATTGTCAAGAGTCGATTACTGCGGACTAATA
ATCCCCACGGGGGTGGTCTCATGTCTCCCCAGGCGAGTGGGGACGGTTGATAAACACGCT
GCATCGCGGACTGATGTTCCCAGTATTACATAGTCACATTGGATTGCGAGTAGTCTACCT
ATTTATGAGCGAGAGATGCCTCTAACTACTTCGACTTTTAAAACCTTTCCACGCCAGTAT
TCGGCGAAAGGGAAGTATTAAGGGTTGTCATAATTAAGCTGATACCACTTCAGACTTTGC
TCTACTTCTGTCTTTCATTGGTTTAGTAAAGTCTGTCCATTCGTCGAGACCGTCTTTTGC
AGCCTCATTCTACCAACTGCTCCGACTCTTAGTCTGCTTCTCCCAGCGTTATAACAAGAG
GCATTTTGTCATCCTTAAAACAATAATAAAGAACTCGGAGCACTGATATAATGACTGAAT
TAGAACCGCTTAAAAATACAACGAATAGATAAGACTATCGGATAAGATCTAATATGTAGT
GATTAAGCCCTTTATTAATTAATAATAGTTACCCTTTCTGATGTAACGCGACATATTACG
ATTTAGTGGCACGTCTGAATTGCAAAGCAGATCTCTACCCGATTTTTATTATAAATCCCG
TATACATCTTGACTTGAGTAATTGTTCATCTTTTTATATCTCTTCGTACTACAAATAATT
AATATCTCAACCCGTATTGTGTGATTCTAATTACCAACAGAATACGAGGAGGTTTTTGCT
TAGGGCCATATATAATGAATCTATCTCGTTTATTCGCGGAACCCGAGATAACATTACGAT
GTAACTATTTTAGAGAACTTAATACAAGAAACATTGCTGATTACTCATAACTAAATGCTT
GGTAATATATCCTCAGTGCCCCTACCATCTTTTACGCAGGGATGTAATTACTTAGGATTC
ATTGTGTAAGAATTACAATGAACGATGGATATGAAGGCATGTTGCGAGGTGTTCCTTGGT
ATGTGAAGTTCGCAGGGCAACAAAAATTTCGCAGAATAGGCCTCAAAGTATTGGTAAAGA
AGACAACTAATCATCACGAGCTTCTGATATCAATACGAACGAGTCCTGTGATGGATGAAA
GAAAGTCGTATCGAAAATGTCAAGAGTCTGCCCAATGTAACTTACTTCAAAAAATAACGC
TTCCGCCAAGTACGTTCGAATAAACGTAATTTTAAAAATACATAAGGGGTGTTAGAAAGT
AAGCGACGGGATATAAGTTAGACTCAAGATTCCGCCGTAAAACGAGACTGATTCCGAAGA
TTGTTCGTGGATCTGGTCATGACTTTCACTGAGTAAGGAGTTTCGACATATGTCAATAAA
CACAAAAATAGAAGCTATTCGATCTGAAAAATATTAGGACAAGAAACTATCTCACGCTAG
CCCAGAATATTCACTCACCCACGGGCGATACTAAAGCACTATATAGTCGCGTGATTACTA
TACATATGGTACACATAAGAATCACGATCAGGTTCTCAATTTTCAACAATATATGTTTAT
TTGCATAGGTAATATTAGGCCTTTAAGAGAAGGATGGGTGAGATACTCCGGGGATGGCGG
CAATAAAGAAAAACACGATATGAGTAATAGGATCCTAATATCTTGGCGAGAGACTTAAGG
TACGAATTTTGCGCAATCTATTTTTTACTTGGCCAGAATTCATGTATGGTATAAGTACGA
ACTTTTTTGATCACTTTCATGGCTACCTGATTAGGATAGTTTGAGGAATTTCCCAAATAT
ACCGATTTAATATACACTAGGGCTTGTCACTTTGAGTCAGAAAAAGAATATAATTACTTA
GGGTAATGCTGCATACATATTCTTATATTGCAAAGGTTCTCTGGGTAATCTTGAGCCTTC
ACGATACCTGGTGAAGTGTT
	/* The Computer Language Benchmarks Game
	http://benchmarksgame.alioth.debian.org/
	Contributed by Andrew Moon

	*/

	#include <cstdlib>
	#include <cstdio>
	#include <iostream>
	#include <fstream>
	#include <vector>
	#include <string.h>

	struct CPUs {
	CPUs() {
	cpu_set_t cs;
	CPU_ZERO( &cs );
	sched_getaffinity( 0, sizeof(cs), &cs );
	count = 0;
	for ( size_t i = 0; i < CPU_SETSIZE; i++ )
	count += CPU_ISSET( i, &cs ) ? 1 : 0;
	count = std::max( count, size_t(1) );
	}

	size_t count;
	} cpus;

	struct ReverseLookup {
	ReverseLookup( const char from, const char to ) {
	for ( int i = 0; i < 256; i++ )
	byteLookup[i] = i;
	for ( ; from && to; from++, to++ ) {
	byteLookup[toupper(from)] = to;
	byteLookup[tolower(from)] = to;
	}

	for ( int i = 0; i < 256; i++ )
	for ( int j = 0; j < 256; j++ )
	wordLookup[(i << 8) \| j] = ( byteLookup[j] << 8 ) \| byteLookup[i];
	}

	char operator[]( const char &c ) { return (char )byteLookup[(unsigned char )c]; }
	short operator[]( const short &s ) { return (short )wordLookup[(unsigned short )s]; }

	protected:
	unsigned char byteLookup[256];
	unsigned short wordLookup[256*256];
	} lookup( "acbdghkmnsrutwvy", "TGVHCDMKNSYAAWBR" );

	template< class type >
	struct vector2 : public std::vector<type> {
	type &last() { return this->operator[]( std::vector<type>::size() -1 ); }
	};

	struct Chunker {
	enum { lineLength = 60, chunkSize = 65536, };

	Chunker( int seq ) : id(seq) {}

	struct Chunk {
	Chunk() {}
	Chunk( char *in, size_t amt ) : data(in), size(amt) {}
	char *data;
	size_t size;
	};

	void NewChunk() {
	size_t cur = mark - chunkBase;
	chunks.push_back( Chunk( chunkBase, cur ) );
	chunkBase += ( cur + ( cur & 1 ) ); // keep it word aligned

	mark = chunkBase;
	}

	template< int N >
	struct LinePrinter {
	LinePrinter() : lineFill(0) {}
	void endofblock() { if ( lineFill ) newline(); }
	void emit( const char *str, size_t amt ) {
	fwrite_unlocked( str, 1, amt, stdout );
	}
	void emit( char c ) { fputc_unlocked( c, stdout ); }
	void emitnewline() { emit( '\n' ); }
	void emitlines( char *data, size_t size ) {
	if ( lineFill ) {
	size_t toprint = std::min( size, lineLength - lineFill );
	emit( data, toprint );
	size -= toprint;
	data += toprint;
	lineFill += toprint;
	if ( lineFill == lineLength )
	newline();
	}

	while ( size >= lineLength ) {
	emit( data, lineLength );
	emitnewline();
	size -= lineLength;
	data += lineLength;
	}

	if ( size ) {
	lineFill = size;
	emit( data, size );
	}
	}
	void newline() { lineFill = 0; emitnewline(); }
	void reset() { lineFill = 0; }
	protected:
	size_t lineFill;
	};

	void Print() {
	int prevId = -( id - 1 );
	while ( __sync_val_compare_and_swap( &printQueue, prevId, id ) != prevId )
	sched_yield();

	fwrite_unlocked( name, 1, strlen( name ), stdout );
	static LinePrinter<65536*2> line;
	line.reset();
	for ( int i = int(chunks.size()) - 1; i >= 0; i-- )
	line.emitlines( chunks[i].data, chunks[i].size );
	line.endofblock();

	__sync_val_compare_and_swap( &printQueue, id, -id );
	}

	// fseek on stdin seems flaky so this hack. not called often

	void Backup() {
	while ( true ) {
	if ( fgetc_unlocked( stdin ) == '>' ) {
	fseek( stdin, -1, SEEK_CUR );
	return;
	}
	fseek( stdin, -2, SEEK_CUR );
	}
	}

	// input buffer can hold all of stdin, so no size checking

	size_t Read( char *data ) {
	if ( feof( stdin ) )
	return 0;

	name = data;
	fgets_unlocked( name, 128, stdin );
	mark = chunkBase = name + strlen( name ) + 1;
	mark[lineLength] = -1;

	while ( fgets_unlocked( mark, 128, stdin ) ) {
	if ( *mark == '>' ) {
	Backup();
	break;
	}

	// mark trick should keep us from calling strlen

	mark += ( mark[lineLength] != 0xa ) ? strlen( mark ) - 1 : lineLength;
	if ( mark - chunkBase > chunkSize )
	NewChunk();

	mark[lineLength] = -1;
	}

	if ( mark - chunkBase )
	NewChunk();
	return ( chunkBase - data );
	}

	struct WorkerState {
	Chunker *chunker;
	size_t offset, count;
	pthread_t handle;
	};

	static void ReverseWorker( void arg ) {
	WorkerState state = (WorkerState )arg;
	Chunker &chunker = *state->chunker;
	for ( size_t i = 0; i < state->count; i++ ) {
	Chunk &chunk = chunker[state->offset + i];
	short w = (short )chunk.data, bot = w, top = w + ( chunk.size / 2 ) - 1;
	for ( ; bot < top; bot++, top-- ) {
	short tmp = lookup[*bot];
	bot = lookup[top];
	*top = tmp;
	}
	// if size is odd, final byte would reverse to the start (skip it)

	if ( chunk.size & 1 )
	chunk.data++;
	}
	return 0;
	}

	void Reverse() {
	if ( !chunks.size() )
	return;

	// this takes so little time it's almost not worth parallelizing

	vector2<WorkerState> threads;
	threads.reserve( cpus.count );
	size_t divs = chunks.size() / cpus.count;
	for ( size_t i = 0, offset = 0; i < cpus.count; i++, offset += divs ) {
	threads.push_back( WorkerState() );
	WorkerState &ws = threads.last();
	ws.chunker = this;
	ws.count = ( i < cpus.count - 1 ) ? divs : chunks.size() - offset;
	ws.offset = offset;
	pthread_create( &ws.handle, 0, ReverseWorker, &ws );
	}

	for ( size_t i = 0; i < cpus.count; i++ )
	pthread_join( threads[i].handle, 0 );
	}

	Chunk &operator[] ( size_t i ) { return chunks[i]; }

	protected:
	vector2<Chunk> chunks;
	char name, chunkBase, *mark;
	int id;
	static volatile int printQueue;
	};

	// used to order chunk printing

	volatile int Chunker::printQueue = 0;

	struct ReverseComplement {
	ReverseComplement() {
	// get stdin file size

	long start = ftell( stdin );
	fseek( stdin, 0, SEEK_END );
	size = ftell( stdin ) - start;
	fseek( stdin, start, SEEK_SET );

	data = new char[size + 3];
	}

	~ReverseComplement() {
	delete[] data;
	}

	static void ChunkerThread( void arg ) {
	Chunker chunker = (Chunker )arg;
	chunker->Reverse();
	chunker->Print();
	return 0;
	}

	void Run() {
	vector2<Chunker *> chunkers;
	vector2<pthread_t> threads;

	size_t cur = 0;
	for ( int id = 1; true; id++ ) {
	chunkers.push_back( new Chunker( id ) );

	size_t read = chunkers.last()->Read( data + cur );
	cur += read;
	if ( !read )
	break;

	// spawn off a thread to finish this guy up while we read another chunk in

	threads.push_back( 0 );
	pthread_create( &threads.last(), 0, ChunkerThread, chunkers.last() );
	}

	for ( size_t i = 0; i < threads.size(); i++ )
	pthread_join( threads[i], 0 );

	for ( size_t i = 0; i < chunkers.size(); i++ )
	delete chunkers[i];
	}


	protected:
	size_t size;
	char *data;
	};


	int main( int argc, const char *argv[] ) {
	ReverseComplement revcom;
	revcom.Run();
	return 0;
	}
	#include <stdio.h>
	#include <stdlib.h>
	#include <string.h>

	#define BLOCKLEN (110241024)

	#define TRUE 1
	#define FALSE 0

	/* Initialised by calls to set_complement. Holds the complement codes. */

	static char complement[256];

	void set_complement(int c1, int c2) {
	complement [c1] = c2;
	complement [c2] = c1;
	complement [c1 \| 0x20] = c2;
	complement [c2 \| 0x20] = c1;
	}

	/*
	* this walks two pointers towards each other, every time one of the pointers
	* hits a linefeed the linefeed is skipped and the loop restarted. Whenever neither
	* pointer is on a linefeed (the most common case) the characters are complemented
	* and swapped.
	*/

	void reverse_complement(unsigned char * ptr1, unsigned char * ptr2) {
	unsigned char c;

	while (ptr1 <= ptr2) {

	if (*ptr1 == 10) {
	ptr1++;
	continue;
	}

	if (*ptr2 == 10) {
	ptr2--;
	continue;
	}

	c = complement[*ptr1];
	ptr1++ = complement [ptr2];
	*ptr2-- = c;
	}
	}

	/*
	* Fasta files do not have any parser friendly features such as length fields. This means
	* that if you want to know if a sequence is complete you have to scan for the next '>'
	* character of the title following the current sequence. This is quite time consuming,
	* and even if you find it you still have a problem because you'll have read too much
	* data from the input stream. That excess is then saved in a separate buffer to be re-used
	* at the beginning of the next round of reading.
	*
	* This loop is pretty slow, it takes up about 40% of the total runtime of the program.
	* There is a clear way to improve it, which is to scan only the part that was just read
	* in after the first pass through the loop in read_sequence. I'll leave that as an exercise
	* for those that want to beat this version of the code, there is an easy #1 spot in the
	* language shootout waiting for you if you add that feature ;) (and multithreading if
	* you want to keep that #1 spot!)
	*/

	int sequence_complete(unsigned char * p, int n, unsigned char ** saved, int * savedsize)

	{
	// skip the leading '>' for the title of the current block, we want the next block

	p++;
	n--;

	// now search the rest of the data for a sequence start

	while (n) {
	if (*p == '>') {
	// we've found a title for the next sequence, figure how how much excess we have
	// and save the remainder

	saved = (unsigned char) malloc(n);

	memcpy(*saved, p, n);
	*savedsize = n;

	return TRUE;
	}

	p++;
	n--;
	}

	return FALSE;
	}

	// read in a sequence, if we read in more than one whole one save the excess

	unsigned char * read_sequence(int * s, unsigned char ** saved, int * nsaved) {
	int size;
	unsigned char * p;
	int read;
	int n;

	if (*saved == NULL) {
	// first round or a really lucky break
	size = BLOCKLEN;
	p = (unsigned char*) malloc(BLOCKLEN);
	read = 0;
	}
	else {
	// round which starts from excess data read during a previous round
	size = *nsaved;
	p = *saved;
	*saved = NULL;
	read = *nsaved;
	size <<= 1; // fix for bug spotted by Robert G. Jakabosky
	}

	while (!feof(stdin) \|\| read) {
	p = (unsigned char*) realloc(p, size);

	n = fread(p + read, 1, size - read, stdin);

	read += n;

	// if the sequence is now complete save the excess for the next
	// iteration and process this sequence. Like that we don't need
	// to read all the way to end-of-file before we can start processing
	// if we have read more than one whole sequence this still works, it
	// just means that we will re-visit this on the next round through
	// the reader to fetch another whole sequence.

	if (sequence_complete(p, read, saved, nsaved)) {

	read -= *nsaved; // compensate for saved portion
	break;
	}

	// if we did not read any data we can return now

	if (n == 0) {
	break;
	}

	// every time we reach the end of the block we scale up

	if (read == size) {
	size <<= 1;
	}
	}

	*s = read;

	return p;
	}

	void process_sequence(unsigned char * p, int size) {

	unsigned char * start;

	// skip the block title
	start = (unsigned char)strchr((char)p, '\n') + 1;

	// figure out start and end of this sequence and do the complement

	reverse_complement(start, start + size - (start - p) - 1);
	}

	void setup() {

	set_complement ('A', 'T');
	set_complement ('C', 'G');
	set_complement ('M', 'K');
	set_complement ('R', 'Y');
	set_complement ('W', 'W');
	set_complement ('S', 'S');
	set_complement ('V', 'B');
	set_complement ('H', 'D');
	set_complement ('N', 'N');
	}

	/*
	* process sequences one-by-one until we're out of sequences and end-of-file
	* has been reached on the input and the readahead buffer is empty
	*/

	void process() {

	unsigned char * readahead = NULL;
	int nreadahead;
	unsigned char * p;
	int s;

	while (readahead != NULL \|\| !feof(stdin)) {
	p = read_sequence(&s, &readahead, &nreadahead);

	process_sequence(p, s);

	fwrite(p, 1, s, stdout);

	free(p);
	}
	}

	int main() {

	setup();

	process();

	return 0;
	}
	/* The Computer Language Benchmarks Game
	http://benchmarksgame.alioth.debian.org/

	contributed by Seth Heeren
	*/
	#include <iostream>
	#include <string>

	using std::string;
	using std::cin;
	using std::cout;
	using std::getline;
	using std::endl;

	template <typename Ch> inline Ch complement(Ch c)
	{
	switch (std::toupper((unsigned)c)) // std::toupper has tricky semantics - no
	// sign extension please
	{
	// IDEA: Reorder branches after profiling?
	// IDEA: (gcc probably compiles the switch into a jump table)
	case 'A': return 'T';
	case 'B': return 'V';
	case 'C': return 'G';
	case 'D': return 'H';
	case 'G': return 'C';
	case 'H': return 'D';
	case 'K': return 'M';
	case 'M': return 'K';
	case 'N': return 'N';
	case 'R': return 'Y';
	case 'S': return 'S';
	case 'T': case 'U': return 'A';
	case 'V': return 'B';
	case 'W': return 'W';
	case 'Y': return 'R';
	}
	throw "parse error"; // TODO proper exception
	}

	inline static void print_reverse(std::string const& sequence)
	{
	size_t count = 0;
	for (auto i = sequence.rbegin(); i != sequence.rend(); ++i)
	{
	cout << *i; // TODO: buffer writes and append line by line?
	if (0 == ++count % 60)
	cout << '\n';
	}
	if (count % 60)
	cout << '\n';
	}

	int main()
	{
	string sequence, line;
	sequence.reserve(12000); // arbitrary heuristic preallocation
	// cin.unsetf(std::ios::skipws);

	while (getline(cin, line))
	{
	const bool is_header = (line[0] == '>');

	if (is_header)
	{
	if (!sequence.empty())
	{
	for (auto& c : sequence)
	c = complement(c);
	print_reverse(sequence);
	}
	// clear, (retain allocated capacity)
	sequence.resize(0);

	// print header line
	cout << line << endl;
	}
	else
	{
	sequence.append(line);
	}
	}

	if (!sequence.empty())
	{
	for (auto& c : sequence)
	c = complement(c);
	print_reverse(sequence);
	}
	}
	all: cpp-version c-version alioth

	CPPFLAGS+=-g -O3
	CPPFLAGS+=-march=native
	# LDFLAGS+=-ltcmalloc

	CXXFLAGS+=$(CPPFLAGS) -std=c++0x
	LDFLAGS+=-lpthread

	# CXX=clang++
	# CC=~clang

	%:%.cpp
	$(CXX) $(CXXFLAGS) $^ -o $@ $(LDFLAGS)

	%:%.c
	$(CC) $(CPPFLAGS) $^ -o $@ $(LDFLAGS)
	>ONE Homo sapiens alu
	GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGA
	TCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACT
	AAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAG
	GCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCG
	CCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGT
	GGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCA
	GGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAA
	TTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAG
	AATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCA
	GCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGT
	AATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACC
	AGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTG
	GTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACC
	CGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAG
	AGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTT
	TGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACA
	TGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCT
	GTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGG
	TTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGT
	CTCAAAAAGGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGG
	CGGGCGGATCACCTGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCG
	TCTCTACTAAAAATACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTA
	CTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCG
	AGATCGCGCCACTGCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCG
	GGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACC
	TGAGGTCAGGAGTTCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAA
	TACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGA
	GGCAGGAGAATCGCTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACT
	GCACTCCAGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAAGGCCGGGCGCGGTGGCTC
	ACGCCTGTAATCCCAGCACTTTGGGAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGT
	TCGAGACCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAATACAAAAATTAGC
	CGGGCGTGGTGGCGCGCGCCTGTAATCCCAGCTACTCGGGAGGCTGAGGCAGGAGAATCG
	CTTGAACCCGGGAGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCCAGCCTG
	GGCGACAGAGCGAGACTCCG
	>TWO IUB ambiguity codes
	cttBtatcatatgctaKggNcataaaSatgtaaaDcDRtBggDtctttataattcBgtcg
	tactDtDagcctatttSVHtHttKtgtHMaSattgWaHKHttttagacatWatgtRgaaa
	NtactMcSMtYtcMgRtacttctWBacgaaatatagScDtttgaagacacatagtVgYgt
	cattHWtMMWcStgttaggKtSgaYaaccWStcgBttgcgaMttBYatcWtgacaYcaga
	gtaBDtRacttttcWatMttDBcatWtatcttactaBgaYtcttgttttttttYaaScYa
	HgtgttNtSatcMtcVaaaStccRcctDaataataStcYtRDSaMtDttgttSagtRRca
	tttHatSttMtWgtcgtatSSagactYaaattcaMtWatttaSgYttaRgKaRtccactt
	tattRggaMcDaWaWagttttgacatgttctacaaaRaatataataaMttcgDacgaSSt
	acaStYRctVaNMtMgtaggcKatcttttattaaaaagVWaHKYagtttttatttaacct
	tacgtVtcVaattVMBcttaMtttaStgacttagattWWacVtgWYagWVRctDattBYt
	gtttaagaagattattgacVatMaacattVctgtBSgaVtgWWggaKHaatKWcBScSWa
	accRVacacaaactaccScattRatatKVtactatatttHttaagtttSKtRtacaaagt
	RDttcaaaaWgcacatWaDgtDKacgaacaattacaRNWaatHtttStgttattaaMtgt
	tgDcgtMgcatBtgcttcgcgaDWgagctgcgaggggVtaaScNatttacttaatgacag
	cccccacatYScaMgtaggtYaNgttctgaMaacNaMRaacaaacaKctacatagYWctg
	ttWaaataaaataRattagHacacaagcgKatacBttRttaagtatttccgatctHSaat
	actcNttMaagtattMtgRtgaMgcataatHcMtaBSaRattagttgatHtMttaaKagg
	YtaaBataSaVatactWtataVWgKgttaaaacagtgcgRatatacatVtHRtVYataSa
	KtWaStVcNKHKttactatccctcatgWHatWaRcttactaggatctataDtDHBttata
	aaaHgtacVtagaYttYaKcctattcttcttaataNDaaggaaaDYgcggctaaWSctBa
	aNtgctggMBaKctaMVKagBaactaWaDaMaccYVtNtaHtVWtKgRtcaaNtYaNacg
	gtttNattgVtttctgtBaWgtaattcaagtcaVWtactNggattctttaYtaaagccgc
	tcttagHVggaYtgtNcDaVagctctctKgacgtatagYcctRYHDtgBattDaaDgccK
	tcHaaStttMcctagtattgcRgWBaVatHaaaataYtgtttagMDMRtaataaggatMt
	ttctWgtNtgtgaaaaMaatatRtttMtDgHHtgtcattttcWattRSHcVagaagtacg
	ggtaKVattKYagactNaatgtttgKMMgYNtcccgSKttctaStatatNVataYHgtNa
	BKRgNacaactgatttcctttaNcgatttctctataScaHtataRagtcRVttacDSDtt
	aRtSatacHgtSKacYagttMHtWataggatgactNtatSaNctataVtttRNKtgRacc
	tttYtatgttactttttcctttaaacatacaHactMacacggtWataMtBVacRaSaatc
	cgtaBVttccagccBcttaRKtgtgcctttttRtgtcagcRttKtaaacKtaaatctcac
	aattgcaNtSBaaccgggttattaaBcKatDagttactcttcattVtttHaaggctKKga
	tacatcBggScagtVcacattttgaHaDSgHatRMaHWggtatatRgccDttcgtatcga
	aacaHtaagttaRatgaVacttagattVKtaaYttaaatcaNatccRttRRaMScNaaaD
	gttVHWgtcHaaHgacVaWtgttScactaagSgttatcttagggDtaccagWattWtRtg
	ttHWHacgattBtgVcaYatcggttgagKcWtKKcaVtgaYgWctgYggVctgtHgaNcV
	taBtWaaYatcDRaaRtSctgaHaYRttagatMatgcatttNattaDttaattgttctaa
	ccctcccctagaWBtttHtBccttagaVaatMcBHagaVcWcagBVttcBtaYMccagat
	gaaaaHctctaacgttagNWRtcggattNatcRaNHttcagtKttttgWatWttcSaNgg
	gaWtactKKMaacatKatacNattgctWtatctaVgagctatgtRaHtYcWcttagccaa
	tYttWttaWSSttaHcaaaaagVacVgtaVaRMgattaVcDactttcHHggHRtgNcctt
	tYatcatKgctcctctatVcaaaaKaaaagtatatctgMtWtaaaacaStttMtcgactt
	taSatcgDataaactaaacaagtaaVctaggaSccaatMVtaaSKNVattttgHccatca
	cBVctgcaVatVttRtactgtVcaattHgtaaattaaattttYtatattaaRSgYtgBag
	aHSBDgtagcacRHtYcBgtcacttacactaYcgctWtattgSHtSatcataaatataHt
	cgtYaaMNgBaatttaRgaMaatatttBtttaaaHHKaatctgatWatYaacttMctctt
	ttVctagctDaaagtaVaKaKRtaacBgtatccaaccactHHaagaagaaggaNaaatBW
	attccgStaMSaMatBttgcatgRSacgttVVtaaDMtcSgVatWcaSatcttttVatag
	ttactttacgatcaccNtaDVgSRcgVcgtgaacgaNtaNatatagtHtMgtHcMtagaa
	attBgtataRaaaacaYKgtRccYtatgaagtaataKgtaaMttgaaRVatgcagaKStc
	tHNaaatctBBtcttaYaBWHgtVtgacagcaRcataWctcaBcYacYgatDgtDHccta
	>THREE Homo sapiens frequency
	aacacttcaccaggtatcgtgaaggctcaagattacccagagaacctttgcaatataaga
	atatgtatgcagcattaccctaagtaattatattctttttctgactcaaagtgacaagcc
	ctagtgtatattaaatcggtatatttgggaaattcctcaaactatcctaatcaggtagcc
	atgaaagtgatcaaaaaagttcgtacttataccatacatgaattctggccaagtaaaaaa
	tagattgcgcaaaattcgtaccttaagtctctcgccaagatattaggatcctattactca
	tatcgtgtttttctttattgccgccatccccggagtatctcacccatccttctcttaaag
	gcctaatattacctatgcaaataaacatatattgttgaaaattgagaacctgatcgtgat
	tcttatgtgtaccatatgtatagtaatcacgcgactatatagtgctttagtatcgcccgt
	gggtgagtgaatattctgggctagcgtgagatagtttcttgtcctaatatttttcagatc
	gaatagcttctatttttgtgtttattgacatatgtcgaaactccttactcagtgaaagtc
	atgaccagatccacgaacaatcttcggaatcagtctcgttttacggcggaatcttgagtc
	taacttatatcccgtcgcttactttctaacaccccttatgtatttttaaaattacgttta
	ttcgaacgtacttggcggaagcgttattttttgaagtaagttacattgggcagactcttg
	acattttcgatacgactttctttcatccatcacaggactcgttcgtattgatatcagaag
	ctcgtgatgattagttgtcttctttaccaatactttgaggcctattctgcgaaatttttg
	ttgccctgcgaacttcacataccaaggaacacctcgcaacatgccttcatatccatcgtt
	cattgtaattcttacacaatgaatcctaagtaattacatccctgcgtaaaagatggtagg
	ggcactgaggatatattaccaagcatttagttatgagtaatcagcaatgtttcttgtatt
	aagttctctaaaatagttacatcgtaatgttatctcgggttccgcgaataaacgagatag
	attcattatatatggccctaagcaaaaacctcctcgtattctgttggtaattagaatcac
	acaatacgggttgagatattaattatttgtagtacgaagagatataaaaagatgaacaat
	tactcaagtcaagatgtatacgggatttataataaaaatcgggtagagatctgctttgca
	attcagacgtgccactaaatcgtaatatgtcgcgttacatcagaaagggtaactattatt
	aattaataaagggcttaatcactacatattagatcttatccgatagtcttatctattcgt
	tgtatttttaagcggttctaattcagtcattatatcagtgctccgagttctttattattg
	ttttaaggatgacaaaatgcctcttgttataacgctgggagaagcagactaagagtcgga
	gcagttggtagaatgaggctgcaaaagacggtctcgacgaatggacagactttactaaac
	caatgaaagacagaagtagagcaaagtctgaagtggtatcagcttaattatgacaaccct
	taatacttccctttcgccgaatactggcgtggaaaggttttaaaagtcgaagtagttaga
	ggcatctctcgctcataaataggtagactactcgcaatccaatgtgactatgtaatactg
	ggaacatcagtccgcgatgcagcgtgtttatcaaccgtccccactcgcctggggagacat
	gagaccacccccgtggggattattagtccgcagtaatcgactcttgacaatccttttcga
	ttatgtcatagcaatttacgacagttcagcgaagtgactactcggcgaaatggtattact
	aaagcattcgaacccacatgaatgtgattcttggcaatttctaatccactaaagcttttc
	cgttgaatctggttgtagatatttatataagttcactaattaagatcacggtagtatatt
	gatagtgatgtctttgcaagaggttggccgaggaatttacggattctctattgatacaat
	ttgtctggcttataactcttaaggctgaaccaggcgtttttagacgacttgatcagctgt
	tagaatggtttggactccctctttcatgtcagtaacatttcagccgttattgttacgata
	tgcttgaacaatattgatctaccacacacccatagtatattttataggtcatgctgttac
	ctacgagcatggtattccacttcccattcaatgagtattcaacatcactagcctcagaga
	tgatgacccacctctaataacgtcacgttgcggccatgtgaaacctgaacttgagtagac
	gatatcaagcgctttaaattgcatataacatttgagggtaaagctaagcggatgctttat
	ataatcaatactcaataataagatttgattgcattttagagttatgacacgacatagttc
	actaacgagttactattcccagatctagactgaagtactgatcgagacgatccttacgtc
	gatgatcgttagttatcgacttaggtcgggtctctagcggtattggtacttaaccggaca
	ctatactaataacccatgatcaaagcataacagaatacagacgataatttcgccaacata
	tatgtacagaccccaagcatgagaagctcattgaaagctatcattgaagtcccgctcaca
	atgtgtcttttccagacggtttaactggttcccgggagtcctggagtttcgacttacata
	aatggaaacaatgtattttgctaatttatctatagcgtcatttggaccaatacagaatat
	tatgttgcctagtaatccactataacccgcaagtgctgatagaaaatttttagacgattt
	ataaatgccccaagtatccctcccgtgaatcctccgttatactaattagtattcgttcat
	acgtataccgcgcatatatgaacatttggcgataaggcgcgtgaattgttacgtgacaga
	gatagcagtttcttgtgatatggttaacagacgtacatgaagggaaactttatatctata
	gtgatgcttccgtagaaataccgccactggtctgccaatgatgaagtatgtagctttagg
	tttgtactatgaggctttcgtttgtttgcagagtataacagttgcgagtgaaaaaccgac
	gaatttatactaatacgctttcactattggctacaaaatagggaagagtttcaatcatga
	gagggagtatatggatgctttgtagctaaaggtagaacgtatgtatatgctgccgttcat
	tcttgaaagatacataagcgataagttacgacaattataagcaacatccctaccttcgta
	acgatttcactgttactgcgcttgaaatacactatggggctattggcggagagaagcaga
	tcgcgccgagcatatacgagacctataatgttgatgatagagaaggcgtctgaattgata
	catcgaagtacactttctttcgtagtatctctcgtcctctttctatctccggacacaaga
	attaagttatatatatagagtcttaccaatcatgttgaatcctgattctcagagttcttt
	ggcgggccttgtgatgactgagaaacaatgcaatattgctccaaatttcctaagcaaatt
	ctcggttatgttatgttatcagcaaagcgttacgttatgttatttaaatctggaatgacg
	gagcgaagttcttatgtcggtgtgggaataattcttttgaagacagcactccttaaataa
	tatcgctccgtgtttgtatttatcgaatgggtctgtaaccttgcacaagcaaatcggtgg
	tgtatatatcggataacaattaatacgatgttcatagtgacagtatactgatcgagtcct
	ctaaagtcaattacctcacttaacaatctcattgatgttgtgtcattcccggtatcgccc
	gtagtatgtgctctgattgaccgagtgtgaaccaaggaacatctactaatgcctttgtta
	ggtaagatctctctgaattccttcgtgccaacttaaaacattatcaaaatttcttctact
	tggattaactacttttacgagcatggcaaattcccctgtggaagacggttcattattatc
	ggaaaccttatagaaattgcgtgttgactgaaattagatttttattgtaagagttgcatc
	tttgcgattcctctggtctagcttccaatgaacagtcctcccttctattcgacatcgggt
	ccttcgtacatgtctttgcgatgtaataattaggttcggagtgtggccttaatgggtgca
	actaggaatacaacgcaaatttgctgacatgatagcaaatcggtatgccggcaccaaaac
	gtgctccttgcttagcttgtgaatgagactcagtagttaaataaatccatatctgcaatc
	gattccacaggtattgtccactatctttgaactactctaagagatacaagcttagctgag
	accgaggtgtatatgactacgctgatatctgtaaggtaccaatgcaggcaaagtatgcga
	gaagctaataccggctgtttccagctttataagattaaaatttggctgtcctggcggcct
	cagaattgttctatcgtaatcagttggttcattaattagctaagtacgaggtacaactta
	tctgtcccagaacagctccacaagtttttttacagccgaaacccctgtgtgaatcttaat
	atccaagcgcgttatctgattagagtttacaactcagtattttatcagtacgttttgttt
	ccaacattacccggtatgacaaaatgacgccacgtgtcgaataatggtctgaccaatgta
	ggaagtgaaaagataaatat
	>ONE Homo sapiens alu
	CGGAGTCTCGCTCTGTCGCCCAGGCTGGAGTGCAGTGGCGCGATCTCGGCTCACTGCAAC
	CTCCGCCTCCCGGGTTCAAGCGATTCTCCTGCCTCAGCCTCCCGAGTAGCTGGGATTACA
	GGCGCGCGCCACCACGCCCGGCTAATTTTTGTATTTTTAGTAGAGACGGGGTTTCACCAT
	GTTGGCCAGGCTGGTCTCGAACTCCTGACCTCAGGTGATCCGCCCGCCTCGGCCTCCCAA
	AGTGCTGGGATTACAGGCGTGAGCCACCGCGCCCGGCCTTTTTGAGACGGAGTCTCGCTC
	TGTCGCCCAGGCTGGAGTGCAGTGGCGCGATCTCGGCTCACTGCAACCTCCGCCTCCCGG
	GTTCAAGCGATTCTCCTGCCTCAGCCTCCCGAGTAGCTGGGATTACAGGCGCGCGCCACC
	ACGCCCGGCTAATTTTTGTATTTTTAGTAGAGACGGGGTTTCACCATGTTGGCCAGGCTG
	GTCTCGAACTCCTGACCTCAGGTGATCCGCCCGCCTCGGCCTCCCAAAGTGCTGGGATTA
	CAGGCGTGAGCCACCGCGCCCGGCCTTTTTGAGACGGAGTCTCGCTCTGTCGCCCAGGCT
	GGAGTGCAGTGGCGCGATCTCGGCTCACTGCAACCTCCGCCTCCCGGGTTCAAGCGATTC
	TCCTGCCTCAGCCTCCCGAGTAGCTGGGATTACAGGCGCGCGCCACCACGCCCGGCTAAT
	TTTTGTATTTTTAGTAGAGACGGGGTTTCACCATGTTGGCCAGGCTGGTCTCGAACTCCT
	GACCTCAGGTGATCCGCCCGCCTCGGCCTCCCAAAGTGCTGGGATTACAGGCGTGAGCCA
	CCGCGCCCGGCCTTTTTGAGACGGAGTCTCGCTCTGTCGCCCAGGCTGGAGTGCAGTGGC
	GCGATCTCGGCTCACTGCAACCTCCGCCTCCCGGGTTCAAGCGATTCTCCTGCCTCAGCC
	TCCCGAGTAGCTGGGATTACAGGCGCGCGCCACCACGCCCGGCTAATTTTTGTATTTTTA
	GTAGAGACGGGGTTTCACCATGTTGGCCAGGCTGGTCTCGAACTCCTGACCTCAGGTGAT
	CCGCCCGCCTCGGCCTCCCAAAGTGCTGGGATTACAGGCGTGAGCCACCGCGCCCGGCCT
	TTTTGAGACGGAGTCTCGCTCTGTCGCCCAGGCTGGAGTGCAGTGGCGCGATCTCGGCTC
	ACTGCAACCTCCGCCTCCCGGGTTCAAGCGATTCTCCTGCCTCAGCCTCCCGAGTAGCTG
	GGATTACAGGCGCGCGCCACCACGCCCGGCTAATTTTTGTATTTTTAGTAGAGACGGGGT
	TTCACCATGTTGGCCAGGCTGGTCTCGAACTCCTGACCTCAGGTGATCCGCCCGCCTCGG
	CCTCCCAAAGTGCTGGGATTACAGGCGTGAGCCACCGCGCCCGGCCTTTTTGAGACGGAG
	TCTCGCTCTGTCGCCCAGGCTGGAGTGCAGTGGCGCGATCTCGGCTCACTGCAACCTCCG
	CCTCCCGGGTTCAAGCGATTCTCCTGCCTCAGCCTCCCGAGTAGCTGGGATTACAGGCGC
	GCGCCACCACGCCCGGCTAATTTTTGTATTTTTAGTAGAGACGGGGTTTCACCATGTTGG
	CCAGGCTGGTCTCGAACTCCTGACCTCAGGTGATCCGCCCGCCTCGGCCTCCCAAAGTGC
	TGGGATTACAGGCGTGAGCCACCGCGCCCGGCCTTTTTGAGACGGAGTCTCGCTCTGTCG
	CCCAGGCTGGAGTGCAGTGGCGCGATCTCGGCTCACTGCAACCTCCGCCTCCCGGGTTCA
	AGCGATTCTCCTGCCTCAGCCTCCCGAGTAGCTGGGATTACAGGCGCGCGCCACCACGCC
	CGGCTAATTTTTGTATTTTTAGTAGAGACGGGGTTTCACCATGTTGGCCAGGCTGGTCTC
	GAACTCCTGACCTCAGGTGATCCGCCCGCCTCGGCCTCCCAAAGTGCTGGGATTACAGGC
	GTGAGCCACCGCGCCCGGCC
	>TWO IUB ambiguity codes
	TAGGDHACHATCRGTRGVTGAGWTATGYTGCTGTCABACDWVTRTAAGAVVAGATTTNDA
	GASMTCTGCATBYTTCAAKTTACMTATTACTTCATARGGYACMRTGTTTTYTATACVAAT
	TTCTAKGDACKADACTATATNTANTCGTTCACGBCGYSCBHTANGGTGATCGTAAAGTAA
	CTATBAAAAGATSTGWATBCSGAKHTTABBAACGTSYCATGCAAVATKTSKTASCGGAAT
	WVATTTNTCCTTCTTCTTDDAGTGGTTGGATACVGTTAYMTMTBTACTTTHAGCTAGBAA
	AAGAGKAAGTTRATWATCAGATTMDDTTTAAAVAAATATTKTCYTAAATTVCNKTTRACG
	ADTATATTTATGATSADSCAATAWAGCGRTAGTGTAAGTGACVGRADYGTGCTACHVSDT
	CTVCARCSYTTAATATARAAAATTTAATTTACDAATTGBACAGTAYAABATBTGCAGBVG
	TGATGGDCAAAATBNMSTTABKATTGGSTCCTAGBTTACTTGTTTAGTTTATHCGATSTA
	AAGTCGAKAAASTGTTTTAWAKCAGATATACTTTTMTTTTGBATAGAGGAGCMATGATRA
	AAGGNCAYDCCDDGAAAGTHGBTAATCKYTBTACBGTBCTTTTTGDTAASSWTAAWAARA
	TTGGCTAAGWGRADTYACATAGCTCBTAGATAWAGCAATNGTATMATGTTKMMAGTAWTC
	CCNTSGAAWATWCAAAAMACTGAADNTYGATNAATCCGAYWNCTAACGTTAGAGDTTTTC
	ATCTGGKRTAVGAABVCTGWGBTCTDVGKATTBTCTAAGGVADAAAVWTCTAGGGGAGGG
	TTAGAACAATTAAHTAATNAAATGCATKATCTAAYRTDTCAGSAYTTYHGATRTTWAVTA
	BGNTCDACAGBCCRCAGWCRTCABTGMMAWGMCTCAACCGATRTGBCAVAATCGTDWDAA
	CAYAWAATWCTGGTAHCCCTAAGATAACSCTTAGTGSAACAWTBGTCDTTDGACWDBAAC
	HTTTNGSKTYYAAYGGATNTGATTTAARTTAMBAATCTAAGTBTCATYTAACTTADTGTT
	TCGATACGAAHGGCYATATACCWDTKYATDCSHTDTCAAAATGTGBACTGSCCVGATGTA
	TCMMAGCCTTDAAABAATGAAGAGTAACTHATMGVTTAATAACCCGGTTVSANTGCAATT
	GTGAGATTTAMGTTTAMAAYGCTGACAYAAAAAGGCACAMYTAAGVGGCTGGAABVTACG
	GATTSTYGTBVAKTATWACCGTGTKAGTDTGTATGTTTAAAGGAAAAAGTAACATARAAA
	GGTYCAMNYAAABTATAGNTSATANAGTCATCCTATWADKAACTRGTMSACDGTATSAYT
	AAHSHGTAABYGACTYTATADTGSTATAGAGAAATCGNTAAAGGAAATCAGTTGTNCYMV
	TNACDRTATBNATATASTAGAAMSCGGGANRCKKMCAAACATTNAGTCTRMAATBMTACC
	CGTACTTCTBGDSYAATWGAAAATGACADDCHAKAAAYATATTKTTTTCACANACWAGAA
	AKATCCTTATTAYKHKCTAAACARTATTTTDATBTVWCYGCAATACTAGGKAAASTTDGA
	MGGCHTTHAATVCAHDRYAGGRCTATACGTCMAGAGAGCTBTHGNACARTCCBDCTAAGA
	GCGGCTTTARTAAAGAATCCNAGTAWBTGACTTGAATTACWTVACAGAAABCAATNAAAC
	CGTNTRANTTGAYCMAWBADTANABRGGTKTHTWTAGTTVCTMBKTAGMTVKCCAGCANT
	TVAGSWTTAGCCGCRHTTTCCTTHNTATTAAGAAGAATAGGMTRAARTCTABGTACDTTT
	TATAAVDHAHTATAGATCCTAGTAAGYTWATDWCATGAGGGATAGTAAMDMNGBASTWAM
	TSTATRBAYDABATGTATATYCGCACTGTTTTAACMCWBTATAWAGTATBTSTATVTTAR
	CCTMTTAAKADATCAACTAATYTSVTAKGDATTATGCKTCAYCAKAATACTTKAANGAGT
	ATTSDAGATCGGAAATACTTAAYAAVGTATMCGCTTGTGTDCTAATYTATTTTATTTWAA
	CAGWRCTATGTAGMTGTTTGTTYKTNGTTKTCAGAACNTRACCTACKTGSRATGTGGGGG
	CTGTCATTAAGTAAATNGSTTABCCCCTCGCAGCTCWHTCGCGAAGCAVATGCKACGHCA
	ACAKTTAATAACASAAADATTWNYTGTAATTGTTCGTMHACHTWATGTGCWTTTTGAAHY
	ACTTTGTAYAMSAAACTTAADAAATATAGTABMATATYAATGSGGTAGTTTGTGTBYGGT
	TWSGSVGWMATTDMTCCWWCABTCSVACAGBAATGTTKATBGTCAATAATCTTCTTAAAC
	ARVAATHAGYBWCTRWCABGTWWAATCTAAGTCASTAAAKTAAGVKBAATTBGABACGTA
	AGGTTAAATAAAAACTRMDTWBCTTTTTAATAAAAGATMGCCTACKAKNTBAGYRASTGT
	ASSTCGTHCGAAKTTATTATATTYTTTGTAGAACATGTCAAAACTWTWTHGKTCCYAATA
	AAGTGGAYTMCYTAARCSTAAATWAKTGAATTTRAGTCTSSATACGACWAKAASATDAAA
	TGYYACTSAACAAHAKTSHYARGASTATTATTHAGGYGGASTTTBGAKGATSANAACACD
	TRGSTTRAAAAAAAACAAGARTCVTAGTAAGATAWATGVHAAKATWGAAAAGTYAHVTAC
	TCTGRTGTCAWGATRVAAKTCGCAAVCGASWGGTTRTCSAMCCTAACASGWKKAWDAATG
	ACRCBACTATGTGTCTTCAAAHGSCTATATTTCGTVWAGAAGTAYCKGARAKSGKAGTAN
	TTTCYACATWATGTCTAAAADMDTWCAATSTKDACAMAADADBSAAATAGGCTHAHAGTA
	CGACVGAATTATAAAGAHCCVAYHGHTTTACATSTTTATGNCCMTAGCATATGATAVAAG
	>THREE Homo sapiens frequency
	ATATTTATCTTTTCACTTCCTACATTGGTCAGACCATTATTCGACACGTGGCGTCATTTT
	GTCATACCGGGTAATGTTGGAAACAAAACGTACTGATAAAATACTGAGTTGTAAACTCTA
	ATCAGATAACGCGCTTGGATATTAAGATTCACACAGGGGTTTCGGCTGTAAAAAAACTTG
	TGGAGCTGTTCTGGGACAGATAAGTTGTACCTCGTACTTAGCTAATTAATGAACCAACTG
	ATTACGATAGAACAATTCTGAGGCCGCCAGGACAGCCAAATTTTAATCTTATAAAGCTGG
	AAACAGCCGGTATTAGCTTCTCGCATACTTTGCCTGCATTGGTACCTTACAGATATCAGC
	GTAGTCATATACACCTCGGTCTCAGCTAAGCTTGTATCTCTTAGAGTAGTTCAAAGATAG
	TGGACAATACCTGTGGAATCGATTGCAGATATGGATTTATTTAACTACTGAGTCTCATTC
	ACAAGCTAAGCAAGGAGCACGTTTTGGTGCCGGCATACCGATTTGCTATCATGTCAGCAA
	ATTTGCGTTGTATTCCTAGTTGCACCCATTAAGGCCACACTCCGAACCTAATTATTACAT
	CGCAAAGACATGTACGAAGGACCCGATGTCGAATAGAAGGGAGGACTGTTCATTGGAAGC
	TAGACCAGAGGAATCGCAAAGATGCAACTCTTACAATAAAAATCTAATTTCAGTCAACAC
	GCAATTTCTATAAGGTTTCCGATAATAATGAACCGTCTTCCACAGGGGAATTTGCCATGC
	TCGTAAAAGTAGTTAATCCAAGTAGAAGAAATTTTGATAATGTTTTAAGTTGGCACGAAG
	GAATTCAGAGAGATCTTACCTAACAAAGGCATTAGTAGATGTTCCTTGGTTCACACTCGG
	TCAATCAGAGCACATACTACGGGCGATACCGGGAATGACACAACATCAATGAGATTGTTA
	AGTGAGGTAATTGACTTTAGAGGACTCGATCAGTATACTGTCACTATGAACATCGTATTA
	ATTGTTATCCGATATATACACCACCGATTTGCTTGTGCAAGGTTACAGACCCATTCGATA
	AATACAAACACGGAGCGATATTATTTAAGGAGTGCTGTCTTCAAAAGAATTATTCCCACA
	CCGACATAAGAACTTCGCTCCGTCATTCCAGATTTAAATAACATAACGTAACGCTTTGCT
	GATAACATAACATAACCGAGAATTTGCTTAGGAAATTTGGAGCAATATTGCATTGTTTCT
	CAGTCATCACAAGGCCCGCCAAAGAACTCTGAGAATCAGGATTCAACATGATTGGTAAGA
	CTCTATATATATAACTTAATTCTTGTGTCCGGAGATAGAAAGAGGACGAGAGATACTACG
	AAAGAAAGTGTACTTCGATGTATCAATTCAGACGCCTTCTCTATCATCAACATTATAGGT
	CTCGTATATGCTCGGCGCGATCTGCTTCTCTCCGCCAATAGCCCCATAGTGTATTTCAAG
	CGCAGTAACAGTGAAATCGTTACGAAGGTAGGGATGTTGCTTATAATTGTCGTAACTTAT
	CGCTTATGTATCTTTCAAGAATGAACGGCAGCATATACATACGTTCTACCTTTAGCTACA
	AAGCATCCATATACTCCCTCTCATGATTGAAACTCTTCCCTATTTTGTAGCCAATAGTGA
	AAGCGTATTAGTATAAATTCGTCGGTTTTTCACTCGCAACTGTTATACTCTGCAAACAAA
	CGAAAGCCTCATAGTACAAACCTAAAGCTACATACTTCATCATTGGCAGACCAGTGGCGG
	TATTTCTACGGAAGCATCACTATAGATATAAAGTTTCCCTTCATGTACGTCTGTTAACCA
	TATCACAAGAAACTGCTATCTCTGTCACGTAACAATTCACGCGCCTTATCGCCAAATGTT
	CATATATGCGCGGTATACGTATGAACGAATACTAATTAGTATAACGGAGGATTCACGGGA
	GGGATACTTGGGGCATTTATAAATCGTCTAAAAATTTTCTATCAGCACTTGCGGGTTATA
	GTGGATTACTAGGCAACATAATATTCTGTATTGGTCCAAATGACGCTATAGATAAATTAG
	CAAAATACATTGTTTCCATTTATGTAAGTCGAAACTCCAGGACTCCCGGGAACCAGTTAA
	ACCGTCTGGAAAAGACACATTGTGAGCGGGACTTCAATGATAGCTTTCAATGAGCTTCTC
	ATGCTTGGGGTCTGTACATATATGTTGGCGAAATTATCGTCTGTATTCTGTTATGCTTTG
	ATCATGGGTTATTAGTATAGTGTCCGGTTAAGTACCAATACCGCTAGAGACCCGACCTAA
	GTCGATAACTAACGATCATCGACGTAAGGATCGTCTCGATCAGTACTTCAGTCTAGATCT
	GGGAATAGTAACTCGTTAGTGAACTATGTCGTGTCATAACTCTAAAATGCAATCAAATCT
	TATTATTGAGTATTGATTATATAAAGCATCCGCTTAGCTTTACCCTCAAATGTTATATGC
	AATTTAAAGCGCTTGATATCGTCTACTCAAGTTCAGGTTTCACATGGCCGCAACGTGACG
	TTATTAGAGGTGGGTCATCATCTCTGAGGCTAGTGATGTTGAATACTCATTGAATGGGAA
	GTGGAATACCATGCTCGTAGGTAACAGCATGACCTATAAAATATACTATGGGTGTGTGGT
	AGATCAATATTGTTCAAGCATATCGTAACAATAACGGCTGAAATGTTACTGACATGAAAG
	AGGGAGTCCAAACCATTCTAACAGCTGATCAAGTCGTCTAAAAACGCCTGGTTCAGCCTT
	AAGAGTTATAAGCCAGACAAATTGTATCAATAGAGAATCCGTAAATTCCTCGGCCAACCT
	CTTGCAAAGACATCACTATCAATATACTACCGTGATCTTAATTAGTGAACTTATATAAAT
	ATCTACAACCAGATTCAACGGAAAAGCTTTAGTGGATTAGAAATTGCCAAGAATCACATT
	CATGTGGGTTCGAATGCTTTAGTAATACCATTTCGCCGAGTAGTCACTTCGCTGAACTGT
	CGTAAATTGCTATGACATAATCGAAAAGGATTGTCAAGAGTCGATTACTGCGGACTAATA
	ATCCCCACGGGGGTGGTCTCATGTCTCCCCAGGCGAGTGGGGACGGTTGATAAACACGCT
	GCATCGCGGACTGATGTTCCCAGTATTACATAGTCACATTGGATTGCGAGTAGTCTACCT
	ATTTATGAGCGAGAGATGCCTCTAACTACTTCGACTTTTAAAACCTTTCCACGCCAGTAT
	TCGGCGAAAGGGAAGTATTAAGGGTTGTCATAATTAAGCTGATACCACTTCAGACTTTGC
	TCTACTTCTGTCTTTCATTGGTTTAGTAAAGTCTGTCCATTCGTCGAGACCGTCTTTTGC
	AGCCTCATTCTACCAACTGCTCCGACTCTTAGTCTGCTTCTCCCAGCGTTATAACAAGAG
	GCATTTTGTCATCCTTAAAACAATAATAAAGAACTCGGAGCACTGATATAATGACTGAAT
	TAGAACCGCTTAAAAATACAACGAATAGATAAGACTATCGGATAAGATCTAATATGTAGT
	GATTAAGCCCTTTATTAATTAATAATAGTTACCCTTTCTGATGTAACGCGACATATTACG
	ATTTAGTGGCACGTCTGAATTGCAAAGCAGATCTCTACCCGATTTTTATTATAAATCCCG
	TATACATCTTGACTTGAGTAATTGTTCATCTTTTTATATCTCTTCGTACTACAAATAATT
	AATATCTCAACCCGTATTGTGTGATTCTAATTACCAACAGAATACGAGGAGGTTTTTGCT
	TAGGGCCATATATAATGAATCTATCTCGTTTATTCGCGGAACCCGAGATAACATTACGAT
	GTAACTATTTTAGAGAACTTAATACAAGAAACATTGCTGATTACTCATAACTAAATGCTT
	GGTAATATATCCTCAGTGCCCCTACCATCTTTTACGCAGGGATGTAATTACTTAGGATTC
	ATTGTGTAAGAATTACAATGAACGATGGATATGAAGGCATGTTGCGAGGTGTTCCTTGGT
	ATGTGAAGTTCGCAGGGCAACAAAAATTTCGCAGAATAGGCCTCAAAGTATTGGTAAAGA
	AGACAACTAATCATCACGAGCTTCTGATATCAATACGAACGAGTCCTGTGATGGATGAAA
	GAAAGTCGTATCGAAAATGTCAAGAGTCTGCCCAATGTAACTTACTTCAAAAAATAACGC
	TTCCGCCAAGTACGTTCGAATAAACGTAATTTTAAAAATACATAAGGGGTGTTAGAAAGT
	AAGCGACGGGATATAAGTTAGACTCAAGATTCCGCCGTAAAACGAGACTGATTCCGAAGA
	TTGTTCGTGGATCTGGTCATGACTTTCACTGAGTAAGGAGTTTCGACATATGTCAATAAA
	CACAAAAATAGAAGCTATTCGATCTGAAAAATATTAGGACAAGAAACTATCTCACGCTAG
	CCCAGAATATTCACTCACCCACGGGCGATACTAAAGCACTATATAGTCGCGTGATTACTA
	TACATATGGTACACATAAGAATCACGATCAGGTTCTCAATTTTCAACAATATATGTTTAT
	TTGCATAGGTAATATTAGGCCTTTAAGAGAAGGATGGGTGAGATACTCCGGGGATGGCGG
	CAATAAAGAAAAACACGATATGAGTAATAGGATCCTAATATCTTGGCGAGAGACTTAAGG
	TACGAATTTTGCGCAATCTATTTTTTACTTGGCCAGAATTCATGTATGGTATAAGTACGA
	ACTTTTTTGATCACTTTCATGGCTACCTGATTAGGATAGTTTGAGGAATTTCCCAAATAT
	ACCGATTTAATATACACTAGGGCTTGTCACTTTGAGTCAGAAAAAGAATATAATTACTTA
	GGGTAATGCTGCATACATATTCTTATATTGCAAAGGTTCTCTGGGTAATCTTGAGCCTTC
	ACGATACCTGGTGAAGTGTT