diff --git a/augur/align.py b/augur/align.py
index 30cd8ea2f..2106b1f0a 100644
--- a/augur/align.py
+++ b/augur/align.py
@@ -1,14 +1,19 @@
 """
 Align multiple sequences from FASTA.
 """
-
+import hashlib
+from itertools import chain
 import os
+from pathlib import Path
 from shutil import copyfile
 import numpy as np
 from Bio import AlignIO, SeqIO, Seq, Align
 from .utils import run_shell_command, nthreads_value, shquote
 from collections import defaultdict
 
+from .io import open_file, read_sequences as io_read_sequences, write_sequences
+
+
 class AlignmentError(Exception):
     # TODO: this exception should potentially be renamed and made augur-wide
     # thus allowing any module to raise it and have the message printed & augur
@@ -58,11 +63,12 @@ def prepare(sequences, existing_aln_fname, output, ref_name, ref_seq_fname):
     seqs = read_sequences(*sequences)
     seqs_to_align_fname = output + ".to_align.fasta"
 
+    existing_aln = None
+    existing_aln_sequence_names = set()
+
     if existing_aln_fname:
         existing_aln = read_alignment(existing_aln_fname)
         seqs = prune_seqs_matching_alignment(seqs, existing_aln)
-    else:
-        existing_aln = None
 
     if ref_seq_fname:
         ref_seq = read_reference(ref_seq_fname)
@@ -72,18 +78,22 @@ def prepare(sequences, existing_aln_fname, output, ref_name, ref_seq_fname):
                 raise AlignmentError("ERROR: Provided existing alignment ({}bp) is not the same length as the reference sequence ({}bp)".format(existing_aln.get_alignment_length(), len(ref_seq)))
             existing_aln_fname = existing_aln_fname + ".ref.fasta"
             existing_aln.append(ref_seq)
-            write_seqs(existing_aln, existing_aln_fname)
+            existing_aln_sequence_names = write_seqs(existing_aln, existing_aln_fname)
         else:
             # reference sequence needs to be the first one for auto direction
             # adjustment (auto reverse-complement)
-            seqs.insert(0, ref_seq)
-    elif ref_name:
-        ensure_reference_strain_present(ref_name, existing_aln, seqs)
+            seqs = chain((ref_seq,), seqs)
+
+    alignment_sequence_names = write_seqs(seqs, seqs_to_align_fname, ref_name)
 
-    write_seqs(seqs, seqs_to_align_fname)
+    # Check for duplicates in the intersection of existing and new alignment
+    # sequences.
+    duplicate_sequence_names = existing_aln_sequence_names & alignment_sequence_names
+    if len(duplicate_sequence_names) > 0:
+        raise AlignmentError(
+            f"Duplicate strains detected: {', '.join(duplicate_sequence_names)}"
+        )
 
-    # 90% sure this is only ever going to catch ref_seq was a dupe
-    check_duplicates(existing_aln, seqs)
     return existing_aln_fname, seqs_to_align_fname, ref_name
 
 def run(args):
@@ -178,19 +188,34 @@ def postprocess(output_file, ref_name, keep_reference, fill_gaps):
 
 def read_sequences(*fnames):
     """return list of sequences from all fnames"""
-    seqs = {}
+    sequence_hash_by_name = {}
+
     try:
-        for fname in fnames:
-            for record in SeqIO.parse(fname, 'fasta'):
-                if record.name in seqs and record.seq != seqs[record.name].seq:
+        # Stream sequences from all input files into a single output file,
+        # skipping duplicate records (same strain and sequence) and noting
+        # mismatched sequences for the same strain name.
+        for record in io_read_sequences(*fnames):
+            # Hash each sequence and check whether another sequence with the
+            # same name already exists and if the hash is different.
+            sequence_hash = hashlib.sha256(str(record.seq).encode("utf-8")).hexdigest()
+            if record.name in sequence_hash_by_name:
+                # If the hashes differ (multiple entries with the same strain
+                # name but different sequences), we keep the first sequence and
+                # add the strain to a list of duplicates to report at the end.
+                if sequence_hash_by_name.get(record.name) != sequence_hash:
                     raise AlignmentError("Detected duplicate input strains \"%s\" but the sequences are different." % record.name)
-                    # if the same sequence then we can proceed (and we only take one)
-                seqs[record.name] = record
+
+                # If the current strain has been seen before, don't use its
+                # sequence again.
+                continue
+
+            sequence_hash_by_name[record.name] = sequence_hash
+            yield record
+
     except FileNotFoundError:
         raise AlignmentError("\nCannot read sequences -- make sure the file %s exists and contains sequences in fasta format" % fname)
     except ValueError as error:
         raise AlignmentError("\nERROR: Problem reading in {}: {}".format(fname, str(error)))
-    return list(seqs.values())
 
 def check_arguments(args):
     # Simple error checking related to a reference name/sequence
@@ -201,31 +226,29 @@ def check_arguments(args):
 
 def read_alignment(fname):
     try:
-        return AlignIO.read(fname, 'fasta')
+        with open_file(fname) as handle:
+            alignment = AlignIO.read(handle, "fasta")
+
+        return alignment
     except Exception as error:
         raise AlignmentError("\nERROR: Problem reading in {}: {}".format(fname, str(error)))
 
-def ensure_reference_strain_present(ref_name, existing_alignment, seqs):
-    if existing_alignment:
-        if ref_name not in {x.name for x in existing_alignment}:
-            raise AlignmentError("ERROR: Specified reference name %s (via --reference-name) is not in the supplied alignment."%ref_name)
-    else:
-        if ref_name not in {x.name for x in seqs}:
-            raise AlignmentError("ERROR: Specified reference name %s (via --reference-name) is not in the sequence sample."%ref_name)
-
-
-    # align
-    # if args.method=='mafft':
-    #     shoutput = shquote(output)
-    #     shname = shquote(seq_fname)
-    #     cmd = "mafft --reorder --anysymbol --thread %d %s 1> %s 2> %s.log"%(args.nthreads, shname, shoutput, shoutput)
-
 def read_reference(ref_fname):
     if not os.path.isfile(ref_fname):
         raise AlignmentError("ERROR: Cannot read reference sequence."
                              "\n\tmake sure the file \"%s\" exists"%ref_fname)
+
+    genbank_suffixes = {".gb", ".genbank"}
+    ref_fname_path = Path(ref_fname)
+
+    # Check for GenBank suffixes, while allowing for compression suffixes.
+    if len(set(ref_fname_path.suffixes) & genbank_suffixes) > 0:
+        format = "genbank"
+    else:
+        format = "fasta"
+
     try:
-        ref_seq = SeqIO.read(ref_fname, 'genbank' if ref_fname.split('.')[-1] in ['gb', 'genbank'] else 'fasta')
+        ref_seq = next(io_read_sequences(ref_fname, format=format))
     except:
         raise AlignmentError("ERROR: Cannot read reference sequence."
                 "\n\tmake sure the file %s contains one sequence in genbank or fasta format"%ref_fname)
@@ -388,43 +411,33 @@ def make_gaps_ambiguous(aln):
         seq.seq = Seq.Seq(_seq)
 
 
-def check_duplicates(*values):
-    names = set()
-    def add(name):
-        if name in names:
-            raise AlignmentError("Duplicate strains of \"{}\" detected".format(name))
-        names.add(name)
-    for sample in values:
-        if not sample:
-            # allows false-like values (e.g. always provide existing_alignment, allowing
-            # the default which is `False`)
-            continue
-        elif isinstance(sample, (list, Align.MultipleSeqAlignment)):
-            for s in sample:
-                add(s.name)
-        elif isinstance(sample, str):
-            add(sample)
-        else:
-            raise TypeError()
-
-def write_seqs(seqs, fname):
+def write_seqs(seqs, fname, ref_name=None):
     """A wrapper around SeqIO.write with error handling"""
+    sequences_written = set()
+
     try:
-        SeqIO.write(seqs, fname, 'fasta')
+        with open_file(fname, "wt") as handle:
+            for sequence in seqs:
+                sequences_written.add(sequence.id)
+                write_sequences(sequence, handle)
+
     except FileNotFoundError:
         raise AlignmentError('ERROR: Couldn\'t write "{}" -- perhaps the directory doesn\'t exist?'.format(fname))
 
+    if ref_name is not None and ref_name not in sequences_written:
+        raise AlignmentError(f"ERROR: Specified reference name {ref_name} (via --reference-name) is not in the sequence sample.")
+
+    return sequences_written
+
 
 def prune_seqs_matching_alignment(seqs, aln):
     """
     Return a set of seqs excluding those already in the alignment & print a warning
     message for each sequence which is exluded.
     """
-    ret = []
     aln_names = {s.name for s in aln}
     for seq in seqs:
         if seq.name in aln_names:
             print("Excluding {} as it is already present in the alignment".format(seq.name))
         else:
-            ret.append(seq)
-    return ret
+            yield seq
diff --git a/augur/filter.py b/augur/filter.py
index 6e08f453e..95b52d5ec 100644
--- a/augur/filter.py
+++ b/augur/filter.py
@@ -14,7 +14,8 @@
 import treetime.utils
 
 from .index import index_sequences
-from .utils import read_metadata, read_strains, get_numerical_dates, run_shell_command, shquote, is_date_ambiguous
+from .io import open_file, read_sequences, write_sequences
+from .utils import read_metadata, read_sequence_index, read_strains, get_numerical_dates, run_shell_command, shquote, is_date_ambiguous
 
 comment_char = '#'
 MAX_NUMBER_OF_PROBABILISTIC_SAMPLING_ATTEMPTS = 10
@@ -93,9 +94,9 @@ def filter_by_query(sequences, metadata_file, query):
 
 def register_arguments(parser):
     input_group = parser.add_argument_group("inputs", "metadata and sequences to be filtered")
-    input_group.add_argument('--metadata', required=True, metavar="FILE", help="sequence metadata, as CSV or TSV")
-    input_group.add_argument('--sequences', '-s', help="sequences in FASTA or VCF format")
-    input_group.add_argument('--sequence-index', help="sequence composition report generated by augur index. If not provided, an index will be created on the fly.")
+    input_group.add_argument('--metadata', nargs="+", required=True, metavar="FILE", help="sequence metadata, as CSV or TSV")
+    input_group.add_argument('--sequences', '-s', nargs="*", help="sequences in FASTA or VCF format")
+    input_group.add_argument('--sequence-index', nargs="*", help="sequence composition report generated by augur index. If not provided, an index will be created on the fly.")
 
     metadata_filter_group = parser.add_argument_group("metadata filters", "filters to apply to metadata")
     metadata_filter_group.add_argument(
@@ -170,20 +171,13 @@ def run(args):
         return 1
 
     # Load inputs, starting with metadata.
-    try:
-        # Metadata are the source of truth for which sequences we want to keep
-        # in filtered output.
-        meta_dict, meta_columns = read_metadata(args.metadata)
-        metadata_strains = set(meta_dict.keys())
-    except ValueError as error:
-        print("ERROR: Problem reading in {}:".format(args.metadata))
-        print(error)
-        return 1
+    meta_dict, meta_columns = read_metadata(*args.metadata)
+    metadata_strains = set(meta_dict.keys())
 
     #Set flags if VCF
     is_vcf = False
     is_compressed = False
-    if args.sequences and any([args.sequences.lower().endswith(x) for x in ['.vcf', '.vcf.gz']]):
+    if args.sequences and len(args.sequences) == 1 and any([args.sequences[0].lower().endswith(x) for x in ['.vcf', '.vcf.gz']]):
         is_vcf = True
         if args.sequences.lower().endswith('.gz'):
             is_compressed = True
@@ -225,10 +219,7 @@ def run(args):
             )
             index_sequences(args.sequences, sequence_index_path)
 
-        sequence_index = pd.read_csv(
-            sequence_index_path,
-            sep="\t"
-        )
+        sequence_index = read_sequence_index(*sequence_index_path)
 
         # Remove temporary index file, if it exists.
         if index_is_autogenerated:
@@ -545,19 +536,19 @@ def run(args):
         dropped_samps = list(available_strains - seq_keep)
         write_vcf(args.sequences, args.output, dropped_samps)
     elif args.sequences and args.output:
-        sequences = SeqIO.parse(args.sequences, "fasta")
+        sequences = read_sequences(*args.sequences)
 
         # Stream to disk all sequences that passed all filters to avoid reading
         # sequences into memory first. Track the observed strain names in the
         # sequence file as part of the single pass to allow comparison with the
         # provided sequence index.
         observed_sequence_strains = set()
-        with open(args.output, "w") as output_handle:
+        with open_file(args.output, "wt") as output_handle:
             for sequence in sequences:
                 observed_sequence_strains.add(sequence.id)
 
                 if sequence.id in seq_keep:
-                    SeqIO.write(sequence, output_handle, 'fasta')
+                    write_sequences(sequence, output_handle, 'fasta')
 
         if sequence_strains != observed_sequence_strains:
             # Warn the user if the expected strains from the sequence index are
diff --git a/augur/index.py b/augur/index.py
index 3b0d883c6..34f339cab 100644
--- a/augur/index.py
+++ b/augur/index.py
@@ -8,11 +8,15 @@
 import sys
 import csv
 
+from .io import open_file, read_sequences
+
+
 def register_arguments(parser):
     parser.add_argument('--sequences', '-s', required=True, help="sequences in fasta format")
     parser.add_argument('--output', '-o', help="tab-delimited file containing the number of bases per sequence in the given file. Output columns include strain, length, and counts for A, C, G, T, N, other valid IUPAC characters, ambiguous characters ('?' and '-'), and other invalid characters.", required=True)
     parser.add_argument('--verbose', '-v', action="store_true", help="print index statistics to stdout")
 
+
 def index_sequence(sequence, values):
     """Count the number of nucleotides for a given sequence record.
 
@@ -127,13 +131,7 @@ def index_sequences(sequences_path, sequence_index_path):
         total length of sequences indexed
 
     """
-    #read in files
-    try:
-        seqs = SeqIO.parse(sequences_path, 'fasta')
-    except ValueError as error:
-        print("ERROR: Problem reading in {}:".format(sequences_path), file=sys.stderr)
-        print(error, file=sys.stderr)
-        return 1
+    seqs = read_sequences(sequences_path)
 
     other_IUPAC = {'r', 'y', 's', 'w', 'k', 'm', 'd', 'h', 'b', 'v'}
     values = [{'a'},{'c'},{'g'},{'t'},{'n'},other_IUPAC,{'-'},{'?'}]
@@ -142,7 +140,7 @@ def index_sequences(sequences_path, sequence_index_path):
     tot_length = 0
     num_of_seqs = 0
 
-    with open(sequence_index_path, 'wt') as out_file:
+    with open_file(sequence_index_path, 'wt') as out_file:
         tsv_writer = csv.writer(out_file, delimiter = '\t')
 
         #write header i output file
@@ -166,7 +164,12 @@ def run(args):
     ("?" and "-"), and other invalid characters in a set of sequences and write
     the composition as a data frame to the given sequence index path.
     '''
-    num_of_seqs, tot_length = index_sequences(args.sequences, args.output)
+    try:
+        num_of_seqs, tot_length = index_sequences(args.sequences, args.output)
+    except ValueError as error:
+        print("ERROR: Problem reading in {}:".format(sequences_path), file=sys.stderr)
+        print(error, file=sys.stderr)
+        return 1
 
     if args.verbose:
         print("Analysed %i sequences with an average length of %i nucleotides." % (num_of_seqs, int(tot_length / num_of_seqs)))
diff --git a/augur/io.py b/augur/io.py
new file mode 100644
index 000000000..d972800ef
--- /dev/null
+++ b/augur/io.py
@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+"""Interfaces for reading and writing data also known as input/output (I/O)
+"""
+import Bio.SeqIO
+import Bio.SeqRecord
+from contextlib import contextmanager
+from pathlib import Path
+from xopen import xopen
+
+
+@contextmanager
+def open_file(path_or_buffer, mode="r", **kwargs):
+    """Opens a given file path and returns the handle.
+
+    Transparently handles compressed inputs and outputs.
+
+    Parameters
+    ----------
+    path_or_buffer : str or Path-like or IO buffer
+        Name of the file to open or an existing IO buffer
+
+    mode : str
+        Mode to open file (read or write)
+
+    Returns
+    -------
+    IO
+        File handle object
+
+    """
+    try:
+        with xopen(path_or_buffer, mode, **kwargs) as handle:
+            yield handle
+    except TypeError:
+        yield path_or_buffer
+
+
+def read_sequences(*paths, format="fasta"):
+    """Read sequences from one or more paths.
+
+    Automatically infer compression mode (e.g., gzip, etc.) and return a stream
+    of sequence records in the requested format (e.g., "fasta", "genbank", etc.).
+
+    Parameters
+    ----------
+    paths : list of str or Path-like objects
+        One or more paths to sequence files of any type supported by BioPython.
+
+    format : str
+        Format of input sequences matching any of those supported by BioPython
+        (e.g., "fasta", "genbank", etc.).
+
+    Yields
+    ------
+    Bio.SeqRecord.SeqRecord
+        Sequence record from the given path(s).
+
+    """
+    for path in paths:
+        # Open the given path as a handle, inferring the file's compression.
+        # This way we can pass a handle to BioPython's SeqIO interface
+        # regardless of the compression mode.
+        with open_file(path) as handle:
+            sequences = Bio.SeqIO.parse(handle, format)
+
+            for sequence in sequences:
+                yield sequence
+
+
+def write_sequences(sequences, path_or_buffer, format="fasta"):
+    """Write sequences to a given path in the given format.
+
+    Automatically infer compression mode (e.g., gzip, etc.) based on the path's
+    filename extension.
+
+    Parameters
+    ----------
+    sequences : iterable of Bio.SeqRecord.SeqRecord objects
+        A list-like collection of sequences to write
+
+    path_or_buffer : str or Path-like object or IO buffer
+        A path to a file to write the given sequences in the given format.
+
+    format : str
+        Format of input sequences matching any of those supported by BioPython
+        (e.g., "fasta", "genbank", etc.)
+
+    Returns
+    -------
+    int :
+        Number of sequences written out to the given path.
+
+    """
+    with open_file(path_or_buffer, "wt") as handle:
+        # Bio.SeqIO supports writing to the same handle multiple times for specific
+        # file formats. For the formats we use, this function call should work for
+        # both a newly opened file handle or one that is provided by the caller.
+        # For more details see:
+        # https://github.com/biopython/biopython/blob/25f5152f4aeefe184a323db25694fbfe0593f0e2/Bio/SeqIO/__init__.py#L233-L251
+        sequences_written = Bio.SeqIO.write(
+            sequences,
+            handle,
+            format
+        )
+
+    return sequences_written
diff --git a/augur/mask.py b/augur/mask.py
index 838529e12..f45c5ba52 100644
--- a/augur/mask.py
+++ b/augur/mask.py
@@ -10,13 +10,14 @@
 from Bio import SeqIO
 from Bio.Seq import MutableSeq
 
+from .io import read_sequences, write_sequences
 from .utils import run_shell_command, shquote, open_file, is_vcf, load_mask_sites, VALID_NUCLEOTIDES
 
 def get_chrom_name(vcf_file):
     """Read the CHROM field from the first non-header line of a vcf file.
-    
+
     Returns:
-    str or None: Either the CHROM field or None if no non-comment line could be found. 
+    str or None: Either the CHROM field or None if no non-comment line could be found.
     """
     with open_file(vcf_file, mode='r') as f:
         for line in f:
@@ -29,8 +30,8 @@ def mask_vcf(mask_sites, in_file, out_file, cleanup=True):
 
     This function relies on 'vcftools --exclude-positions' to mask the requested sites.
 
-    Parameters:
-    -----------
+    Parameters
+    ----------
     mask_sites: list[int]
         A list of site indexes to exclude from the vcf.
     in_file: str
@@ -73,13 +74,61 @@ def mask_vcf(mask_sites, in_file, out_file, cleanup=True):
             except OSError:
                 pass
 
+
+def mask_sequence(sequence, mask_sites, mask_from_beginning, mask_from_end, mask_invalid):
+    """Mask characters at the given sites in a single sequence record, modifying the
+    record in place.
+
+    Parameters
+    ----------
+    sequence : Bio.SeqIO.SeqRecord
+        A sequence to be masked
+    mask_sites: list[int]
+        A list of site indexes to exclude from the FASTA.
+    mask_from_beginning: int
+        Number of sites to mask from the beginning of each sequence (default 0)
+    mask_from_end: int
+        Number of sites to mask from the end of each sequence (default 0)
+    mask_invalid: bool
+        Mask invalid nucleotides (default False)
+
+    Returns
+    -------
+    Bio.SeqIO.SeqRecord
+        Masked sequence in its original record object
+
+    """
+    # Convert to a mutable sequence to enable masking with Ns.
+    sequence_length = len(sequence.seq)
+    beginning, end = mask_from_beginning, mask_from_end
+
+    if beginning + end > sequence_length:
+        beginning, end = sequence_length, 0
+
+    seq = str(sequence.seq)[beginning:-end or None]
+
+    if mask_invalid:
+        seq = "".join(nuc if nuc in VALID_NUCLEOTIDES else "N" for nuc in seq)
+
+    masked_sequence = MutableSeq("N" * beginning + seq + "N" * end)
+
+    # Replace all excluded sites with Ns.
+    for site in mask_sites:
+        if site < sequence_length:
+            masked_sequence[site] = "N"
+
+    sequence.seq = masked_sequence
+
+    return sequence
+
+
 def mask_fasta(mask_sites, in_file, out_file, mask_from_beginning=0, mask_from_end=0, mask_invalid=False):
     """Mask the provided site list from a FASTA file and write to a new file.
 
     Masked sites are overwritten as "N"s.
 
-    Parameters:
-    -----------
+    Parameters
+    ----------
     mask_sites: list[int]
         A list of site indexes to exclude from the FASTA.
     in_file: str
@@ -95,27 +144,27 @@ def mask_fasta(mask_sites, in_file, out_file, mask_from_beginning=0, mask_from_e
     """
     # Load alignment as FASTA generator to prevent loading the whole alignment
     # into memory.
-    alignment = SeqIO.parse(in_file, "fasta")
+    alignment = read_sequences(in_file)
 
     # Write the masked alignment to disk one record at a time.
     print("Removing masked sites from FASTA file.")
-    with open_file(out_file, "w") as oh:
-        for record in alignment:
-            # Convert to a mutable sequence to enable masking with Ns.
-            sequence_length = len(record.seq)
-            beginning, end = mask_from_beginning, mask_from_end
-            if beginning + end > sequence_length:
-                beginning, end = sequence_length, 0
-            seq = str(record.seq)[beginning:-end or None]
-            if mask_invalid:
-                seq = "".join(nuc if nuc in VALID_NUCLEOTIDES else "N" for nuc in seq)
-            sequence = MutableSeq("N" * beginning + seq + "N" * end)
-            # Replace all excluded sites with Ns.
-            for site in mask_sites:
-                if site < sequence_length:
-                    sequence[site] = "N"
-            record.seq = sequence
-            SeqIO.write(record, oh, "fasta")
+
+    masked_sequences = (
+        mask_sequence(
+            sequence,
+            mask_sites,
+            mask_from_beginning,
+            mask_from_end,
+            mask_invalid,
+        )
+        for sequence in alignment
+    )
+    sequences_written = write_sequences(
+        masked_sequences,
+        out_file,
+        "fasta"
+    )
+
 
 def register_arguments(parser):
     parser.add_argument('--sequences', '-s', required=True, help="sequences in VCF or FASTA format")
@@ -179,7 +228,7 @@ def run(args):
             sys.exit(1)
         mask_vcf(mask_sites, args.sequences, out_file, args.cleanup)
     else:
-        mask_fasta(mask_sites, args.sequences, out_file, 
+        mask_fasta(mask_sites, args.sequences, out_file,
                    mask_from_beginning=args.mask_from_beginning,
                    mask_from_end=args.mask_from_end,
                    mask_invalid=args.mask_invalid)
diff --git a/augur/parse.py b/augur/parse.py
index 02e1b82f5..ef61c7b0a 100644
--- a/augur/parse.py
+++ b/augur/parse.py
@@ -1,10 +1,10 @@
 """
 Parse delimited fields from FASTA sequence names into a TSV and FASTA file.
 """
-
-from Bio import SeqIO
 import pandas as pd
 
+from .io import open_file, read_sequences, write_sequences
+
 forbidden_chactacters = str.maketrans(
     {' ': None,
      '(': '_',
@@ -68,6 +68,63 @@ def prettify(x, trim=0, camelCase=False, etal=None, removeComma=False):
     return res
 
 
+def parse_sequence(sequence, fields, strain_key="strain", separator="|", prettify_fields=None, fix_dates=None):
+    """Parse a single sequence record into a sequence record and associated metadata.
+
+    Parameters
+    ----------
+    sequence : Bio.SeqRecord.SeqRecord
+        a BioPython sequence record to parse with metadata stored in its description field.
+
+    fields : list or tuple
+        a list of names for fields expected in the given record's description.
+
+    strain_key : str
+        name of the field to use as the given sequence's unique id
+
+    separator : str
+        delimiter to split record description by.
+
+    prettify_fields : list or tuple
+        a list of field names for which the values in those fields should be prettified.
+
+    fix_dates : str
+        parse "date" field into the requested canonical format ("dayfirst" or "monthfirst").
+
+    Returns
+    -------
+    Bio.SeqRecord.SeqRecord :
+        a BioPython sequence record with the given sequence's name as the record
+        id and all other metadata stripped.
+
+    dict :
+        metadata associated with the given record indexed by the given field names.
+    """
+    sequence_fields = map(str.strip, sequence.description.split(separator))
+    metadata = dict(zip(fields, sequence_fields))
+
+    tmp_name = metadata[strain_key].translate(forbidden_chactacters)
+    sequence.name = sequence.id = tmp_name
+    sequence.description = ''
+
+    if prettify_fields:
+        for field in metadata.keys() & prettify_fields:
+            if isinstance(metadata[field], str):
+                metadata[field] = prettify(metadata[field], camelCase=(not field.startswith('author')),
+                                            etal='lower' if field.startswith('author') else None)
+
+    # parse dates and convert to a canonical format
+    if fix_dates and 'date' in metadata:
+        metadata['date'] = fix_dates(
+            metadata['date'],
+            dayfirst=fix_dates=='dayfirst'
+        )
+
+    metadata["strain"] = sequence.id
+
+    return sequence, metadata
+
+
 def register_arguments(parser):
     parser.add_argument('--sequences', '-s', required=True, help="sequences in fasta or VCF format")
     parser.add_argument('--output-sequences', help="output sequences file")
@@ -84,7 +141,7 @@ def run(args):
     parse a fasta file and turn information in the header into
     a tsv or csv file.
     '''
-    seqs = SeqIO.parse(args.sequences, 'fasta')
+    sequences = read_sequences(args.sequences)
 
     # if strain or name are found in specified fields, use this
     # field to index the dictionary and the data frame
@@ -98,32 +155,26 @@ def run(args):
         strain_key = args.fields[0]
 
     # loop over sequences, parse fasta header of each sequence
-    with open(args.output_sequences, 'w', encoding='utf-8') as output:
-        for seq in seqs:
-            fields = map(str.strip, seq.description.split(args.separator))
-            tmp_meta = dict(zip(args.fields, fields))
-
-            tmp_name = tmp_meta[strain_key].translate(forbidden_chactacters)
-            seq.name = seq.id = tmp_name
-            seq.description = ''
-
-            if args.prettify_fields:
-                for field in tmp_meta.keys() & args.prettify_fields:
-                    if isinstance(tmp_meta[field], str):
-                        tmp_meta[field] = prettify(tmp_meta[field], camelCase=(not field.startswith('author')),
-                                                    etal='lower' if field.startswith('author') else None)
-
-            # parse dates and convert to a canonical format
-            if args.fix_dates and 'date' in tmp_meta:
-                tmp_meta['date'] = fix_dates(tmp_meta['date'],
-                                            dayfirst=args.fix_dates=='dayfirst')
-
-            if 'strain' in tmp_meta:
-                del tmp_meta['strain']
-            meta_data[seq.id] = tmp_meta
-
-            SeqIO.write(seq, output, 'fasta')
-
-    df = pd.DataFrame.from_dict(meta_data, orient='index')
-    df.to_csv(args.output_metadata, index_label='strain',
-              sep='\t' if args.output_metadata.endswith('tsv') else ',')
+    with open_file(args.output_sequences, "wt") as handle:
+        for sequence in sequences:
+            sequence_record, sequence_metadata = parse_sequence(
+                sequence,
+                args.fields,
+                strain_key,
+                args.separator,
+                args.prettify_fields,
+                args.fix_dates
+            )
+            meta_data[sequence_record.id] = sequence_metadata
+
+            sequences_written = write_sequences(
+                sequence_record,
+                handle
+            )
+
+    df = pd.DataFrame(meta_data.values())
+    df.to_csv(
+        args.output_metadata,
+        index=False,
+        sep='\t' if args.output_metadata.endswith('tsv') else ','
+    )
diff --git a/augur/util_support/metadata_file.py b/augur/util_support/metadata_file.py
index 7c7508148..9e3d40c84 100644
--- a/augur/util_support/metadata_file.py
+++ b/augur/util_support/metadata_file.py
@@ -1,5 +1,5 @@
 import functools
-import pandas
+import pandas as pd
 import sys
 
 
@@ -11,15 +11,19 @@ class MetadataFile:
     which is used to match metadata with samples.
     """
 
-    def __init__(self, fname, query=None):
-        self.fname = fname
+    def __init__(self, *fnames, query=None, as_data_frame=False):
+        self.fname = fnames
         self.query = query
+        self.as_data_frame = as_data_frame
 
         self.key_type = self.find_key_type()
 
     def read(self):
         self.check_metadata_duplicates()
 
+        if self.as_data_frame:
+            return self.metadata
+
         # augur assumes the metadata dict will contain either "strain" or "name" (the
         # indexed column), but DataFrame.to_dict("index") does not place the indexed
         # column in the dict. So let's make a copy of the indexed column so that the
@@ -88,10 +92,19 @@ def find_key_type(self):
 
     @functools.lru_cache()
     def parse_file(self):
-        return pandas.read_csv(
-            self.fname,
-            sep=None,  # csv.Sniffer will automatically detect sep
-            engine="python",
-            skipinitialspace=True,
-            dtype={"strain":"string", "name":"string"}
-        ).fillna("")
+        return pd.concat(
+            [
+                pd.read_csv(
+                    fname,
+                    sep=None,  # csv.Sniffer will automatically detect sep
+                    engine="python",
+                    skipinitialspace=True,
+                    dtype={"strain":"string", "name":"string"}
+                ).fillna("")
+                for fname in self.fname
+            ],
+            ignore_index=True
+        ).drop_duplicates(
+            subset=("strain",),
+            ignore_index=True
+        )
diff --git a/augur/utils.py b/augur/utils.py
index b68c484e3..adc2dc5cd 100644
--- a/augur/utils.py
+++ b/augur/utils.py
@@ -70,8 +70,23 @@ def get_json_name(args, default=None):
 def ambiguous_date_to_date_range(uncertain_date, fmt, min_max_year=None):
     return DateDisambiguator(uncertain_date, fmt=fmt, min_max_year=min_max_year).range()
 
-def read_metadata(fname, query=None):
-    return MetadataFile(fname, query).read()
+def read_metadata(*fnames, query=None, as_data_frame=False):
+    return MetadataFile(*fnames, query=query, as_data_frame=as_data_frame).read()
+
+def read_sequence_index(*sequence_index_paths):
+    return pd.concat(
+            [
+                pd.read_csv(
+                    sequence_index_path,
+                    sep="\t"
+                )
+                for sequence_index_path in sequence_index_paths
+            ],
+            ignore_index=True
+        ).drop_duplicates(
+            subset=("strain",),
+            ignore_index=True
+        )
 
 def is_date_ambiguous(date, ambiguous_by="any"):
     """
diff --git a/pytest.python3.ini b/pytest.python3.ini
index d62edcdea..5845e427e 100644
--- a/pytest.python3.ini
+++ b/pytest.python3.ini
@@ -1,4 +1,9 @@
 [pytest]
+# ignore biopython's deprecation warnings about alphabet that are outside of our control
+filterwarnings =
+    ignore::PendingDeprecationWarning:Bio.Alphabet
+    ignore:Coverage disabled
+
 addopts =
     # do not capture any output---necessary for interactive breakpoints
     -s
diff --git a/setup.py b/setup.py
index ee1f0a6fa..3f57b1555 100644
--- a/setup.py
+++ b/setup.py
@@ -52,7 +52,8 @@
         "jsonschema >=3.0.0, ==3.*",
         "packaging >=19.2",
         "pandas >=1.0.0, ==1.*",
-        "phylo-treetime ==0.8.*"
+        "phylo-treetime ==0.8.*",
+        "xopen >=1.0.1, ==1.*"
     ],
     extras_require = {
         'full': [
diff --git a/tests/builds/zika/config/zika_outgroup.gb.gz b/tests/builds/zika/config/zika_outgroup.gb.gz
new file mode 100644
index 000000000..c98f39b02
Binary files /dev/null and b/tests/builds/zika/config/zika_outgroup.gb.gz differ
diff --git a/tests/builds/zika/data/zika.fasta.gz b/tests/builds/zika/data/zika.fasta.gz
new file mode 100644
index 000000000..8068f895f
Binary files /dev/null and b/tests/builds/zika/data/zika.fasta.gz differ
diff --git a/tests/builds/zika/results/filtered.fasta.gz b/tests/builds/zika/results/filtered.fasta.gz
new file mode 100644
index 000000000..8a1030f31
Binary files /dev/null and b/tests/builds/zika/results/filtered.fasta.gz differ
diff --git a/tests/builds/zika/results/metadata.tsv.gz b/tests/builds/zika/results/metadata.tsv.gz
new file mode 100644
index 000000000..be4443bcb
Binary files /dev/null and b/tests/builds/zika/results/metadata.tsv.gz differ
diff --git a/tests/builds/zika/results/sequence_index.tsv.gz b/tests/builds/zika/results/sequence_index.tsv.gz
new file mode 100644
index 000000000..857e39167
Binary files /dev/null and b/tests/builds/zika/results/sequence_index.tsv.gz differ
diff --git a/tests/builds/zika/results/sequences.fasta.gz b/tests/builds/zika/results/sequences.fasta.gz
new file mode 100644
index 000000000..07cde2d36
Binary files /dev/null and b/tests/builds/zika/results/sequences.fasta.gz differ
diff --git a/tests/builds/zika_compressed.t b/tests/builds/zika_compressed.t
new file mode 100644
index 000000000..5abd118cf
--- /dev/null
+++ b/tests/builds/zika_compressed.t
@@ -0,0 +1,193 @@
+Run an example Zika build with Augur using compressed inputs and outputs where possible.
+
+Setup test data directory, output directory, and temporarily change directories to the test data directory.
+Some augur commands store the exact path of their inputs in their outputs.
+Running from the test data directory allows us to use relative paths that won't differ between execution environments.
+
+  $ TEST_DATA_DIR="$TESTDIR/zika"
+  $ mkdir -p "$TMP/out"
+  $ pushd "$TEST_DATA_DIR" > /dev/null
+  $ export AUGUR="../../../bin/augur"
+
+Parse a FASTA whose defline contains metadata into separate sequence and metadata files.
+
+  $ ${AUGUR} parse \
+  >   --sequences "data/zika.fasta.gz" \
+  >   --output-sequences "$TMP/out/sequences.fasta.gz" \
+  >   --output-metadata "$TMP/out/metadata.tsv.gz" \
+  >   --fields strain virus accession date region country division city db segment authors url title journal paper_url \
+  >   --prettify-fields region country division city
+
+  $ diff -u <(gzip -c -d "results/sequences.fasta.gz") <(gzip -c -d "$TMP/out/sequences.fasta.gz")
+
+Index sequence composition to speed up filters.
+
+  $ ${AUGUR} index \
+  >   --sequences "results/sequences.fasta.gz" \
+  >   --output "$TMP/out/sequence_index.tsv.gz" \
+  >   --verbose
+  Analysed 12 sequences with an average length of 10598 nucleotides.
+
+  $ diff -u <(gzip -c -d "results/sequence_index.tsv.gz") <(gzip -c -d "$TMP/out/sequence_index.tsv.gz")
+
+Filter sequences by a minimum date and an exclusion list and only keep one sequence per country, year, and month.
+
+  $ ${AUGUR} filter \
+  >   --sequences "results/sequences.fasta.gz" \
+  >   --sequence-index "results/sequence_index.tsv.gz" \
+  >   --metadata "results/metadata.tsv.gz" \
+  >   --exclude "config/dropped_strains.txt" \
+  >   --output "$TMP/out/filtered.fasta.gz" \
+  >   --group-by country year month \
+  >   --sequences-per-group 1 \
+  >   --subsample-seed 314159 \
+  >   --no-probabilistic-sampling \
+  >   --min-date 2012 > /dev/null
+  $ gzip -c -d "$TMP/out/filtered.fasta.gz" | grep "^>" | wc -l
+  \s*10 (re)
+
+Align filtered sequences to a specific reference sequence and fill any gaps.
+
+  $ ${AUGUR} align \
+  >  --sequences "results/filtered.fasta.gz" \
+  >  --reference-sequence "config/zika_outgroup.gb.gz" \
+  >  --output "$TMP/out/aligned.fasta" \
+  >  --fill-gaps > /dev/null
+
+  $ diff -u "results/aligned.fasta" "$TMP/out/aligned.fasta"
+
+Build a tree from the multiple sequence alignment.
+
+  $ ${AUGUR} tree \
+  >  --alignment "results/aligned.fasta" \
+  >  --output "$TMP/out/tree_raw.nwk" \
+  >  --method iqtree \
+  >  --tree-builder-args "-seed 314159" > /dev/null
+
+  $ python3 "$TESTDIR/../../scripts/diff_trees.py" "results/tree_raw.nwk" "$TMP/out/tree_raw.nwk" --significant-digits 5
+  {}
+
+Confirm that tree log file exists.
+
+  $ test -e "results/aligned-delim.iqtree.log"
+  $ echo $?
+  0
+
+Build a time tree from the existing tree topology, the multiple sequence alignment, and the strain metadata.
+
+  $ ${AUGUR} refine \
+  >  --tree "results/tree_raw.nwk" \
+  >  --alignment "results/aligned.fasta" \
+  >  --metadata "results/metadata.tsv.gz" \
+  >  --output-tree "$TMP/out/tree.nwk" \
+  >  --output-node-data "$TMP/out/branch_lengths.json" \
+  >  --timetree \
+  >  --coalescent opt \
+  >  --date-confidence \
+  >  --date-inference marginal \
+  >  --clock-filter-iqd 4 \
+  >  --seed 314159 > /dev/null
+
+Confirm that TreeTime trees match expected topology and branch lengths.
+
+  $ python3 "$TESTDIR/../../scripts/diff_trees.py" "results/tree.nwk" "$TMP/out/tree.nwk" --significant-digits 2
+  {}
+
+Branch lengths and other annotations like dates are too stochastic across runs to consistently compare with reasonable precision.
+
+#$ python3 "$TESTDIR/../../scripts/diff_jsons.py" "results/branch_lengths.json" "$TMP/out/branch_lengths.json" --significant-digits 0
+#{}
+
+Calculate tip frequencies from the tree.
+
+  $ ${AUGUR} frequencies \
+  >  --method kde \
+  >  --tree "results/tree.nwk" \
+  >  --metadata "results/metadata.tsv.gz" \
+  >  --pivot-interval 3 \
+  >  --output "$TMP/out/zika_tip-frequencies.json" > /dev/null
+
+  $ diff -u --ignore-matching-lines version "auspice/zika_tip-frequencies.json" "$TMP/out/zika_tip-frequencies.json"
+
+Infer ancestral sequences from the tree.
+
+  $ ${AUGUR} ancestral \
+  >  --tree "results/tree.nwk" \
+  >  --alignment "results/aligned.fasta" \
+  >  --infer-ambiguous \
+  >  --output-node-data "$TMP/out/nt_muts.json" \
+  >  --inference joint > /dev/null
+
+  $ diff -u --ignore-matching-lines version "results/nt_muts.json" "$TMP/out/nt_muts.json"
+
+Infer ancestral traits from the tree.
+
+  $ ${AUGUR} traits \
+  >  --tree "results/tree.nwk" \
+  >  --weights "config/trait_weights.csv" \
+  >  --metadata "results/metadata.tsv.gz" \
+  >  --output-node-data "$TMP/out/traits.json" \
+  >  --columns country region \
+  >  --sampling-bias-correction 3 \
+  >  --confidence > /dev/null
+
+  $ python3 "$TESTDIR/../../scripts/diff_jsons.py" "results/traits.json" "$TMP/out/traits.json" --significant-digits 5
+  {}
+
+Implicit mugration model outputs are not written to the same directory as the traits output, so we cannot test for matching mugration models here.
+See augur issue 541 (https://github.com/nextstrain/augur/issues/541) for more details.
+
+#$ diff -u "results/treecountry.mugration_model.txt" "$TMP/out/treecountry.mugration_model.txt"
+#$ diff -u "results/treeregion.mugration_model.txt" "$TMP/out/treeregion.mugration_model.txt"
+
+Translate inferred ancestral and observed nucleotide sequences to amino acid mutations.
+
+  $ ${AUGUR} translate \
+  >  --tree "results/tree.nwk" \
+  >  --ancestral-sequences "$TMP/out/nt_muts.json" \
+  >  --reference-sequence "config/zika_outgroup.gb" \
+  >  --output-node-data "$TMP/out/aa_muts.json" > /dev/null
+
+  $ diff -u --ignore-matching-lines version "results/aa_muts.json" "$TMP/out/aa_muts.json"
+
+Export JSON files as v1 auspice outputs.
+
+  $ ${AUGUR} export v1 \
+  >  --tree "results/tree.nwk" \
+  >  --metadata "results/metadata.tsv.gz" \
+  >  --node-data "$TMP/out/branch_lengths.json" \
+  >              "$TMP/out/traits.json" \
+  >              "$TMP/out/nt_muts.json" \
+  >              "$TMP/out/aa_muts.json" \
+  >  --colors "config/colors.tsv" \
+  >  --auspice-config "config/auspice_config_v1.json" \
+  >  --output-tree "$TMP/out/v1_zika_tree.json" \
+  >  --output-meta "$TMP/out/v1_zika_meta.json" \
+  >  --output-sequence "$TMP/out/v1_zika_seq.json" > /dev/null
+
+  $ ${AUGUR} validate export-v1 "$TMP/out/v1_zika_meta.json" "$TMP/out/v1_zika_tree.json" > /dev/null
+
+Compare auspice metadata files, but ignore the "updated" field since this changes with the date the export command is run.
+
+  $ diff -u --ignore-matching-lines updated "auspice/v1_zika_meta.json" "$TMP/out/v1_zika_meta.json"
+
+Export JSON files as v2 auspice outputs.
+
+  $ ${AUGUR} export v2 \
+  >  --tree "results/tree.nwk" \
+  >  --metadata "results/metadata.tsv.gz" \
+  >  --node-data "$TMP/out/branch_lengths.json" \
+  >              "$TMP/out/traits.json" \
+  >              "$TMP/out/nt_muts.json" \
+  >              "$TMP/out/aa_muts.json" \
+  >  --colors "config/colors.tsv" \
+  >  --auspice-config "config/auspice_config_v2.json" \
+  >  --output "$TMP/out/v2_zika.json" \
+  >  --title 'Real-time tracking of Zika virus evolution -- v2 JSON' \
+  >  --panels tree map entropy frequencies > /dev/null
+
+  $ ${AUGUR} validate export-v2 "$TMP/out/v2_zika.json" > /dev/null
+
+Switch back to the original directory where testing started.
+
+  $ popd > /dev/null
diff --git a/tests/functional/parse.t b/tests/functional/parse.t
new file mode 100644
index 000000000..e9e65ca44
--- /dev/null
+++ b/tests/functional/parse.t
@@ -0,0 +1,32 @@
+Integration tests for augur parse.
+
+  $ pushd "$TESTDIR" > /dev/null
+  $ export AUGUR="../../bin/augur"
+
+Parse Zika sequences into sequences and metadata.
+
+  $ ${AUGUR} parse \
+  >   --sequences parse/zika.fasta \
+  >   --output-sequences "$TMP/sequences.fasta" \
+  >   --output-metadata "$TMP/metadata.tsv" \
+  >   --fields strain virus accession date region country division city db segment authors url title journal paper_url \
+  >   --prettify-fields region country division city
+
+  $ diff -u "parse/sequences.fasta" "$TMP/sequences.fasta"
+  $ diff -u "parse/metadata.tsv" "$TMP/metadata.tsv"
+  $ rm -f "$TMP/sequences.fasta" "$TMP/metadata.tsv"
+
+Parse compressed Zika sequences into sequences and metadata.
+
+  $ ${AUGUR} parse \
+  >   --sequences parse/zika.fasta.gz \
+  >   --output-sequences "$TMP/sequences.fasta" \
+  >   --output-metadata "$TMP/metadata.tsv" \
+  >   --fields strain virus accession date region country division city db segment authors url title journal paper_url \
+  >   --prettify-fields region country division city
+
+  $ diff -u "parse/sequences.fasta" "$TMP/sequences.fasta"
+  $ diff -u "parse/metadata.tsv" "$TMP/metadata.tsv"
+  $ rm -f "$TMP/sequences.fasta" "$TMP/metadata.tsv"
+
+  $ popd > /dev/null
diff --git a/tests/functional/parse/metadata.tsv b/tests/functional/parse/metadata.tsv
new file mode 100644
index 000000000..319d519b6
--- /dev/null
+++ b/tests/functional/parse/metadata.tsv
@@ -0,0 +1,13 @@
+strain	virus	accession	date	region	country	division	city	db	segment	authors	url	title	journal	paper_url
+PAN/CDC_259359_V1_V3/2015	zika	KX156774	2015-12-18	North America	Panama	Panama	Panama	genbank	genome	Shabman et al	https://www.ncbi.nlm.nih.gov/nuccore/KX156774	Direct Submission	Submitted (29-APR-2016) J. Craig Venter Institute, 9704 Medical Center Drive, Rockville, MD 20850, USA	https://www.ncbi.nlm.nih.gov/pubmed/
+COL/FLR_00024/2015	zika	MF574569	2015-12-XX	South America	Colombia	Colombia	Colombia	genbank	genome	Pickett et al	https://www.ncbi.nlm.nih.gov/nuccore/MF574569	Direct Submission	Submitted (28-JUL-2017) J. Craig Venter Institute, 9704 Medical Center Drive, Rockville, MD 20850, USA	https://www.ncbi.nlm.nih.gov/pubmed/
+PRVABC59	zika	KU501215	2015-12-XX	North America	Puerto Rico	Puerto Rico	Puerto Rico	genbank	genome	Lanciotti et al	https://www.ncbi.nlm.nih.gov/nuccore/KU501215	Phylogeny of Zika Virus in Western Hemisphere, 2015	Emerging Infect. Dis. 22 (5), 933-935 (2016)	https://www.ncbi.nlm.nih.gov/pubmed/27088323
+COL/FLR_00008/2015	zika	MF574562	2015-12-XX	South America	Colombia	Colombia	Colombia	genbank	genome	Pickett et al	https://www.ncbi.nlm.nih.gov/nuccore/MF574562	Direct Submission	Submitted (28-JUL-2017) J. Craig Venter Institute, 9704 Medical Center Drive, Rockville, MD 20850, USA	https://www.ncbi.nlm.nih.gov/pubmed/
+Colombia/2016/ZC204Se	zika	KY317939	2016-01-06	South America	Colombia	Colombia	Colombia	genbank	genome	Quick et al	https://www.ncbi.nlm.nih.gov/nuccore/KY317939	Multiplex PCR method for MinION and Illumina sequencing of Zika and other virus genomes directly from clinical samples	Nat Protoc 12 (6), 1261-1276 (2017)	https://www.ncbi.nlm.nih.gov/pubmed/28538739
+ZKC2/2016	zika	KX253996	2016-02-16	Oceania	American Samoa	American Samoa	American Samoa	genbank	genome	Wu et al	https://www.ncbi.nlm.nih.gov/nuccore/KX253996	Direct Submission	Submitted (18-MAY-2016) Center for Diseases Control and Prevention of Guangdong Province; National Institute of Viral Disease Control and Prevention, China	https://www.ncbi.nlm.nih.gov/pubmed/
+VEN/UF_1/2016	zika	KX702400	2016-03-25	South America	Venezuela	Venezuela	Venezuela	genbank	genome	Blohm et al	https://www.ncbi.nlm.nih.gov/nuccore/KX702400	Complete Genome Sequences of Identical Zika virus Isolates in a Nursing Mother and Her Infant	Genome Announc 5 (17), e00231-17 (2017)	https://www.ncbi.nlm.nih.gov/pubmed/28450510
+DOM/2016/BB_0059	zika	KY785425	2016-04-04	North America	Dominican Republic	Dominican Republic	Dominican Republic	genbank	genome	Metsky et al	https://www.ncbi.nlm.nih.gov/nuccore/KY785425	Zika virus evolution and spread in the Americas	Nature 546 (7658), 411-415 (2017)	https://www.ncbi.nlm.nih.gov/pubmed/28538734
+BRA/2016/FC_6706	zika	KY785433	2016-04-08	South America	Brazil	Brazil	Brazil	genbank	genome	Metsky et al	https://www.ncbi.nlm.nih.gov/nuccore/KY785433	Zika virus evolution and spread in the Americas	Nature 546 (7658), 411-415 (2017)	https://www.ncbi.nlm.nih.gov/pubmed/28538734
+DOM/2016/BB_0183	zika	KY785420	2016-04-18	North America	Dominican Republic	Dominican Republic	Dominican Republic	genbank	genome	Metsky et al	https://www.ncbi.nlm.nih.gov/nuccore/KY785420	Zika virus evolution and spread in the Americas	Nature 546 (7658), 411-415 (2017)	https://www.ncbi.nlm.nih.gov/pubmed/28538734
+EcEs062_16	zika	KX879603	2016-04-XX	South America	Ecuador	Ecuador	Ecuador	genbank	genome	Marquez et al	https://www.ncbi.nlm.nih.gov/nuccore/KX879603	First Complete Genome Sequences of Zika Virus Isolated from Febrile Patient Sera in Ecuador	Genome Announc 5 (8), e01673-16 (2017)	https://www.ncbi.nlm.nih.gov/pubmed/28232448
+HND/2016/HU_ME59	zika	KY785418	2016-05-13	North America	Honduras	Honduras	Honduras	genbank	genome	Metsky et al	https://www.ncbi.nlm.nih.gov/nuccore/KY785418	Zika virus evolution and spread in the Americas	Nature 546 (7658), 411-415 (2017)	https://www.ncbi.nlm.nih.gov/pubmed/28538734
diff --git a/tests/functional/parse/sequences.fasta b/tests/functional/parse/sequences.fasta
new file mode 100644
index 000000000..3e37aa57f
--- /dev/null
+++ b/tests/functional/parse/sequences.fasta
@@ -0,0 +1,2138 @@
+>PAN/CDC_259359_V1_V3/2015
+gaatttgaagcgaatgctaacaacagtatcaacaggttttattttggatttggaaacgag
+agtttctggtcatgaaaaacccaaaaaagaaatccggaggattccggattgtcaatatgc
+taaaacgcggagtagcccgtgtgagcccctttgggggcttgaagaggctgccagccggac
+ttctgctgggtcatgggcccatcaggatggtcttggcgattctagcctttttgagattca
+cggcaatcaagccatcactgggtctcatcaatagatggggttcagtggggaaaaaagagg
+ctatggaaataataaagaagttcaagaaagatctggctgccatgctgagaataatcaatg
+ctaggaaggagaagaagagacgaggcgcagaaactagtgtcggaattgttggcctcctgc
+tgaccacagctatggcagcggaggtcactagacgtgggagtgcatactatatgtacttgg
+acagaaacgatgctggggaggccatatcttttccaaccacattggggatgaataagtgtt
+atatacagatcatggatcttggacacatgtgtgatgccaccatgagctatgaatgcccta
+tgctggatgagggggtggaaccagatgacgtcgattgttggtgcaacacgacgtcaactt
+gggttgtgtacggaacctgccatcacaaaaaaggtgaagcacggagatctagaagagccg
+tgacgctcccctcccattccactaggaagctgcaaacgcggtcgcaaacctggttggaat
+caagagaatacacaaagcacttgattagagtcgaaaattggatattcaggaaccctggtt
+tcgctttagcagcagctgccatcgcttggcttttgggaagctcaacgagccaaaaagtca
+tatacttggtcatgatactgctgattgccccggcatacagcatcaggtgcataggagtca
+gcaatagggactttgtggaaggtatgtcaggtgggacttgggttgatgtcgtcttggaac
+atggaggttgtgtcaccgtaatggcacaggacaaaccgactgtcgacatagagctggtta
+caacaacagtcagcaacatggcggaggtaagatcctactgctatgaggcatcaatatcag
+acatggcttcggacagccgctgcccaacacaaggtgaagcctaccttgacaagcaatcag
+acactcaatatgtctgcaaaagaacgttagtggacagaggctggggaaatggatgtggac
+tttttggcaaagggagcctggtgacatgcgctaagtttgcatgctccaagaaaatgaccg
+ggaagagcatccagccagagaatctggagtaccggataatgttgtcagttcatggctccc
+agcacagtgggatgatcgttaatgacacaggacatgaaactgatgagaatagagcgaagg
+ttgagataacgcccaattcaccaagagccgaagccaccctggggggttttggaagcctag
+gacttgattgtgaaccgaggacaggccttgacttttcagatttgtattacttgactatga
+ataacaagcactggttggttcacaaggagtggttccacgacattccattaccttggcacg
+ctggggcagacaccggaactccacactggaacaacaaagaagcactggtagagttcaagg
+acgcacatgccaaaaggcaaactgtcgtggttctagggagtcaagaaggagcagttcaca
+cggcccttgctggagctctggaggctgagatggatggtgcaaagggaaggctgtcctctg
+gccacttgaaatgtcgcctgaaaatggataaacttagattgaagggcgtgtcatactcct
+tgtgtaccgcagcgttcacattcaccaagatcccggctgaaacactgcacgggacagtca
+cagtggaggtacagtacgcagggacagatggaccttgcaaggttccagctcagatggcgg
+tggacatgcaaactctgaccccagttgggaggttgataaccgctaaccccgtaatcactg
+aaagcactgagaactctaagatgatgctggaacttgatccaccatttggggactcttaca
+ttgtcataggagtcggggagaagaagatcacccaccactggcacaggagtggcagcacca
+ttggaaaagcatttgaagccactgtgagaggtgccaagagaatggcagtcttgggagaca
+cagcctgggactttggatcagttggaggcgctctcaactcattgggcaagggcatccatc
+aaatttttggagcagctttcaaatcattgtttggaggaatgtcctggttctcacaaattc
+tcattggaacgttgctgatgtggttgggtctgaacacaaagaatggatctatttccctta
+tgtgcttggccttagggggagtgttgatcttcttatccacagccgtctctgctgatgtgg
+ggtgctcggtggacttctcaaagaaggagacgagatgtggtacaggggtgttcgtctaca
+acgacgttgaagcctggagggacaggtacaagtaccatcctgactccccccgtagattgg
+cagcagcagtcaagcaagcctgggaagatggtatctgcgggatctcctctgtttcaagaa
+tggaaaacatcatgtggagatcagtagaaggggagctcaacgcaatcctggaagagaatg
+gagttcaactgacggtcgttgtgggatctgtaaaaaaccccatgtggagaggtccacaga
+gattgcccgtgcctgtgaacgagctgccccacggctggaaggcttgggggaaatcgtact
+tcgtcagagcagcaaagacaaataacagctttgtcgtggatggtgacacactgaaggaat
+gcccactcaaacatagagcatggaacagctttcttgtggaggatcatgggttcggggtat
+ttcacactagtgtctggctcaaggttagagaagattattcattagagtgtgatccagccg
+ttattggaacagctgttaagggaaaggaggctgtacacagtgatctaggctactggattg
+agagtgagaagaatgacacatggaggctgaagagggcccatctgatcgagatgaaaacat
+gtgaatggccaaagtcccacacattgtggacagatggaatagaagagagtgatctgatca
+tacccaagtctttagctgggccactcagccatcacaataccagagagggctacaggaccc
+aaatgaaagggccatggcacagtgaagagcttgaaattcggtttgaggaatgcccaggca
+ctaaggtccacgtggaggaaacatgtggaacaagaggaccatctctgagatcaaccactg
+caagcggaagggtgatcgaggaatggtgctgcagggagtgcacaatgcccccactgtcgt
+tctgggctaaagatggctgttggtatggaatggagataaggcccaggaaagaaccagaaa
+gcaacttagtaaggtcaatggtgactgcaggatcaactgatcacatggatcacttctccc
+ttggagtgcttgtgattctgctcatggtgcaggaagggctgaagaagagaatgaccacaa
+agatcatcataagcacatcaatggcagtgctggtagctatgatcctgggaggattttcaa
+tgagtgacctggctaagcttgcaatcttgatgggtgccaccttcgcggaaatgaacactg
+gaggagatgtggctcatctggcgctgatagcagcattcaaagtcagaccagcgttgctgg
+tatctttcatcttcagagctaattggacaccccgtgaaagcatgctgctggccttggcct
+cgtgtcttttgcaaactgcgatctccgccttggagggcgacctgatggttctcatcaatg
+gttttgctttggcctggttggcaatacgagcgatggttgttccacgcactgacaacatca
+ccttggcaatcctggctgctctgacaccactggcccggggcacactgcttgtggcgtgga
+gagcaggccttgctacttgcggggggtttatgctcctctctctgaagggaaaaggcagtg
+tgaagaagaacttaccatttgtcatggccctgggactaaccgctgtgaggctggtcgacc
+ccatcaacgtggtgggactgctgttgctcacaaggagtgggaagcggagctggcccccta
+gcgaagtactcacagctgttggcctgatatgcgcattggctggagggttcgccaaggcag
+atatagagatggctgggcccatagccgcggtcggtctgctaattgtcagttacgtggtct
+caggaaagagtgtggacatgtacattgaaagagcaggtgacatcacatgggaaaaagatg
+cggaagtcactggaaacagtccccggctcgatgtggcgctagatgagagtggtgatttct
+ccctggtggaggatgacggtccccccatgagagagatcatactcaaggtggtcctgatga
+ccatctgtggcatgaacccaatagccataccctttgcagctggagcgtggtacgtatacg
+tgaagactggaaaaaggagtggtgctctatgggatgtgcctgctcccaaggaagtaaaaa
+agggggagaccacagatggagtgtacagagtaatgactcgtagactgctaggttcaacac
+aagttggagtgggagttatgcaagagggggtctttcacactatgtggcacgtcacaaaag
+gatccgcgctgagaagcggtgaagggagacttgatccatactggggagatgtcaagcagg
+atctggtgtcatactgtggtccatggaagctagatgccgcctgggacgggcacagcgagg
+tgcagctcttggccgtgccccccggagagagagcgaggaacatccagactctgcccggaa
+tatttaagacaaaggatggggacattggagcggttgcgctggattacccagcaggaactt
+caggatctccaatcctagacaagtgtgggagagtgataggactttatggcaatggggtcg
+tgatcaaaaatgggagttatgttagtgccatcacccaagggaggagggaggaagagactc
+ctgttgagtgcttcgagccttcgatgctgaagaagaagcagctaactgtcttagacttgc
+atcctggagctgggaaaaccaggagagttcttcctgaaatagtccgtgaagccataaaaa
+caagactccgtactgtgatcttagctccaaccagggttgtcgctgctgaaatggaggaag
+cccttagagggcttccagtgcgttatatgacaacagcagtcaatgtcacccactctggaa
+cagaaatcgtcgacttaatgtgccatgccaccttcacttcacgtctactacagccaatca
+gagtccccaactataatctgtatattatggatgaggcccacttcacagatccctcaagta
+tagcagcaagaggatacatttcaacaagggttgagatgggcgaggcggctgccatcttca
+tgaccgccacgccaccaggaacccgtgacgcatttccggactccaactcaccaattatgg
+acaccgaagtggaagtcccagagagagcctggagctcaggctttgattgggtgacggatc
+attctggaaaaacagtttggtttgttccaagcgtgaggaacggcaatgagatcgcagctt
+gtctgacaaaggctggaaaacgggtcatacagctcagcagaaagacttttgagacagagt
+tccagaaaacaaaacatcaagagtgggactttgtcgtgacaactgacatttcagagatgg
+gcgccaactttaaagctgaccgtgtcatagattccaggagatgcctaaagccggtcatac
+ttgatggcgagagagtcattctggctggacccatgcctgtcacacatgccagcgctgccc
+agaggagggggcgcataggcaggaatcccaataaacctggagatgagtatctgtatggag
+gtgggtgcgcagagactgacgaagaccatgcacactggcttgaagcaagaatgctccttg
+acaatatttacctccaagatggcctcatagcctcgctctatcgacctgaggccgacaaag
+tagcagccattgagggagagttcaagcttaggacggagcaaaggaagacctttgtggaac
+tcatgaaaagaggagatcttcctgtttggctggcctatcaggttgcatctgccggaataa
+cctacacagatagaagatggtgctttgatggcacgaccaacaacaccataatggaagaca
+gtgtgccggcagaggtgtggaccagacacggagagaaaagagtgctcaaaccgaggtgga
+tggacgccagagtttgttcagatcatgcggccctgaagtcattcaaggagtttgccgctg
+ggaaaagaggagcggcttttggagtgatggaagccctgggaacactgccaggacacatga
+cagagagattccaggaagccattgacaacctcgctgtgctcatgcgggcagagactggaa
+gcaggccttacaaagccgcggcggcccaattgccggagaccctagagaccattatgcttt
+tggggttgctgggaacagtctcgctgggaatctttttcgtcttgatgaggaacaagggca
+tagggaagatgggctttggaatggtgactcttggggccagcgcatggctcatgtggctct
+cggaaattgagccagccagaattgcatgtgtcctcattgttgtgttcctattgctggtgg
+tgctcatacctgagccagaaaagcaaagatctccccaggacaaccaaatggcaatcatca
+tcatggtagcagtaggtcttctgggcttgattaccgccaatgaactcggatggttggaga
+gaacaaagagtgacctaagccatctaatgggaaggagagaggagggggcaaccataggat
+tctcaatggacattgacctgcggccagcctcagcttgggccatctatgctgccttgacaa
+ctttcattaccccagctgtccaacatgcagtgaccacttcatacaacaactactccttaa
+tggcgatggccacgcaagctggagtgttgtttggtatgggcaaagggatgccattctacg
+catgggactttggagtcccgctgctaatgataggttgctactcacaattaacacccctga
+ccctaatagtggccatcattttgctcgtggcgcactacatgtacttgatcccagggctgc
+aggcagcagctgcgcgtgctgcccagaagagaacggcagctggcatcatgaagaaccctg
+ttgtggatggaatagtggtgactgacattgacacaatgacaattgacccccaagtggaga
+aaaagatgggacaggtgctactcatagcagtagccgtctccagcgccatactgtcgcgga
+ccgcctgggggtggggggaggctggggccctgatcacagccgcaacttccactttgtggg
+aaggctctccgaacaagtactggaactcctctacagccacttcactgtgtaacattttta
+ggggaagttacttggctggagcttctctaatctacacagtaacaagaaacgctggcttgg
+tcaagagacgtgggggtggaacaggagagaccctgggagagaaatggaaggcccgcttga
+accagatgtcggccctggagttctactcctacaaaaagtcaggcatcaccgaggtgtgca
+gagaagaggcccgccgcgccctcaaggacggtgtggcaacgggaggccatgctgtgtccc
+gaggaagtgcaaagctgagatggttggtggagcggggatacctgcagccctatggaaagg
+tcattgatcttggatgtggcagagggggctggagttactacgccgccaccatccgcaaag
+ttcaagaagtgaaaggatacacaaaaggaggccctggtcatgaagaacccgtgttggtgc
+aaagctatgggtggaacatagtccgtcttaagagtggggtggacgtctttcatatggcgg
+ctgagccgtgtgacacgttgctgtgtgacataggtgagtcatcatctagtcctgaagtgg
+aagaagcacggacgctcagagtcctctccatggtgggggattggcttgaaaaaagaccag
+gagccttttgtataaaagtgttgtgcccatacaccagcactatgatggaaaccctggagc
+gactgcagcgtaggtatgggggaggactggtcagagtgccactctcccgcaactctacac
+atgagatgtactgggtctctggagcgaaaagcaacaccataaaaagtgtgtccaccacga
+gccagctcctcttggggcgcatggacgggcctaggaggccagtgaaatatgaggaggatg
+tgaatctcggctctggcacgcgggctgtggtaagctgcgctgaagctcccaacatgaaga
+tcattggtaaccgcattgaaaggatccgcagtgagcacgcggaaacgtggttctttgacg
+agaaccacccatataggacatgggcttaccatggaagctatgaggcccccacacaagggt
+cagcgtcctctctaataaacggggttgtcaggctcctgtcaaaaccctgggatgtggtga
+ctggagtcacaggaatagccatgaccgacaccacaccgtatggtcagcaaagagttttca
+aggaaaaagtggacactagggtgccagacccccaagaaggcactcgtcaggttatgagca
+tggtctcttcctggttgtggaaagagctaggcaaacacaaacggccacgagtctgtacca
+aagaagagttcatcaacaaggttcgtagcaatgcagcattaggggcaatatttgaagagg
+aaaaagagtggaagactgcagtggaagctgtgaacgatccaaggttctgggctctagtgg
+acaaggaaagagagcaccacctgagaggagagtgccagagttgtgtgtacaacatgatgg
+gaaaaagagaaaagaaacaaggggaatttggaaaggccaagggcagccgcgccatctggt
+atatgtggctaggggctagatttctagagttcgaagcccttggattcttgaacgaggatc
+actggatggggagagagaactcaggaggtggtgttgaagggctgggattacaaagactcg
+gatatgtcctagaagagatgagtcgcataccaggaggaaggatgtatgcagatgacactg
+ctggctgggacacccgcattagcaggtttgatctggagaatgaagctctaatcaccaacc
+aaatggagaaagggcacagggccttggcattggccataatcaagtacacataccaaaaca
+aagtggtaaaggtccttagaccagctgaaaaagggaaaacagttatggacattatttcga
+gacaagaccaaagggggagcggacaagttgtcacttacgctcttaacacatttaccaacc
+tagtggtgcaactcattcggaatatggaggctgaggaagttctagagatgcaagacttgt
+ggctgctgcggaggtcagagaaagtgaccaactggttgcagagcaacggatgggataggc
+tcaaacgaatggcagtcagtggagatgattgcgttgtgaagccaattgatgataggtttg
+cacatgccctcaggttcttgaatgatatgggaaaagttaggaaggacacacaagagtgga
+aaccctcaactggatgggacaactgggaagaagttccgttttgctcccaccacttcaaca
+agctccatctcaaggacgggaggtccattgtggttccctgccgccaccaagatgaactga
+ttggccgggcccgcgtctctccaggggcgggatggagcatccgggagactgcttgcctag
+caaaatcatatgcgcaaatgtggcagctcctttatttccacagaagggacctccgactga
+tggccaatgccatttgttcatctgtgccagttgactgggttccaactgggagaactacct
+ggtcaatccatggaaagggagaatggatgaccactgaagacatgcttgtggtgtggaaca
+gagtgtggattgaggagaacgaccacatggaagacaagaccccagttgcgaaatggacag
+acattccctatttgggaaaaagggaagacttgtggtgtggatctctcatagggcacagac
+cgcgcaccacctgggctgagaacattaaaaacacagtcaacatggtgcgcaggatcatag
+gtgatgaagaaaagtacatggactacctatccacccaagttcgctacttgggtgaagaag
+ggtccacacctggagtgctgtaagcaccaatcttaatgttgtcaggcctgctagtcagcc
+acagcttggggaaagctgtgcagcctgtgacccccccaggagaagctgggaaaccaagcc
+tatagtcaggccgagaacgccatggcacggaagaagccatgctgcctgtgagcccctcag
+aggacactgagtcaaaaaaccccacgcgcttggaggcgcaggatgggaaaagaaggtggc
+gaccttccccacccttcaatctggggcctgaactggagatcagctgtggatctccagaag
+agggactagtggttagaggagaccccccggaaaacgcaaaacagcatattgacgctggga
+aagaccagagactccatgagtttccaccacgctggccgccaggcacagatcgccgaatag
+cggcggccggtgtggggaaatccatgggtct
+>COL/FLR_00024/2015
+tcagactgcgacagttcgagtttgaagcgaaagctagcaacagtatcaacaggttttatt
+ttggatttggaaacgagagtttctggtcatgaaaaacccaaaaaagaaatccggaggatt
+ccggattgtcaatatgctaaaacgcggagtagcccgtgtgagcccctttgggggcttgaa
+gaggctgccagccggacttctgctgggtcatgggcccatcaggatggtcttggcgattct
+agcctttttgagattcacggcaatcaagccatcactgggtctcatcaatagatggggttc
+agtggggaaaaaagaggctatggaaacaataaagaagttcaagaaagatctggctgccat
+gctgagaataatcaatgctaggaaggagaagaagagacgaggcgcagaaactagtgtcgg
+aattgttggcctcctgctgaccacagctatggcagcggaggtcactagacgtgggagtgc
+atactatatgtacttggacagaaacgatgctggggaggccatatcttttccaaccacatt
+ggggatgaataagtgttatatacagatcatggatcttggacacatgtgtgatgccaccat
+gagctatgaatgccctatgctggatgagggggtggaaccagatgacgtcgattgttggtg
+caacacgacgtcaacttgggttgtgtacggaacctgccatcacaaaaaaggtgaagcacg
+gagatctagaagagccgtgacgctcccctcccattccactaggaagctgcaaacgcggtc
+gcaaacctggttggaatcaagagaatacacaaagcacttgattagagtcgaaaattggat
+attcaggaaccctggtttcgctttagcagcagctgccatcgcttggcttttgggaagctc
+aacgagccaaaaagtcatatacttggtcatgatactgctgattgccccggcatacagcat
+caggtgcataggagtcagcaatagggactttgtggaaggtatgtcaggtgggacttgggt
+tgatgtcgtcttggaacatggaggttgtgtcaccgtaatggcacaggacaaaccgactgt
+cgacatagagctggttacaacaacagtcagcaacatggcggaggtaagatcctactgcta
+tgaggcatcaatatcagacatggcttcggacagccgctgcccaacacaaggtgaagccta
+ccttgagaagcaatcagacactcaatatgtctgcaaaagaacgttagtggacagaggctg
+gggaaatggatgtggactttttggcaaagggagcctggtgacatgcgctaagtttgcatg
+ctccaagaaaatgaccgggaagagcatccagccagagaatctggagtaccggataatgtt
+gtcagttcatggctcccagcacagtgggatgatcgttaatgacacaggacatgaaactga
+tgagaatagagcgaaggttgagataacgcccaattcaccaagagccgaagccaccctggg
+gggctttggaagcctaggacttgattgtgaaccgaggacaggccttgacttttcagattt
+gtattacttgactatgaataacaagcactggttggttcacaaggagtggttccacgacat
+tccattaccttggcacgctggggcagacaccggaactccacactggaacaacaaagaagc
+actggtagagttcaaggacgcacatgccaaaaggcaaactgtcgtggttctagggagtca
+agaaggagcagttcacacggcccttgctggagctctggaggctgagatggatggtgcaaa
+gggaaggctgtcctctggccacttgaaatgtcgcctgaaaatggataaacttagattgaa
+gggcgtgtcatactccttgtgtaccgcagcgttcacattcaccaagatcccggctgaaac
+actgcacgggacagtcacagtggaggtacagtacgcagggacagatggaccttgcaaggt
+tccagctcagatggcggtggacatgcaaactctgaccccagttgggaggttgataaccgc
+taaccccgtaatcactgaaagcactgagaactctaagatgatgctggaacttgatccacc
+atttggggactcttacattgtcataggagtcggggagaagaagatcacccaccactggca
+caggagtggcagcaccattggaaaagcatttgaagccactgtgagaggtgccaagagaat
+ggcagtcttgggagacacagcctgggactttggatcagttggaggcgctctcaactcatt
+gggcaagggcatccatcaaatttttggagcagctttcaaatcattgtttggaggaatgtc
+ctggttctcacaaattctcattggaacgttgctgatgtggttgggtctgaacacaaagaa
+tggatctatttcccttatgtgcttggccttagggggagtgttgatcttcttatccacagc
+cgtctctgctgatgtggggtgctcggtggacttctcaaagaaggagacgagatgtggtac
+aggggtgttcgtctataacgacgttgaagcctggagggacaggtacaagtaccatcctga
+ctccccccgtagattggcagcagcagtcaagcaagcctgggaagatggtatctgcgggat
+ctcctctgtttcaagaatggaaaacatcatgtggagatcagtagaaggggagctcaacgc
+aatcctggaagagaatggagttcaactgacggtcgttgtgggatctgtaaaaaaccccat
+gtggagaggtccacagagattgcccgtgcctgtgaacgagctgccccacggctggaaggc
+ttgggggaaatcgtacttcgtcagagcagcaaagacaaataacagctttgtcgtggatgg
+tgacacactgaaagaatgcccactcaaacatagagcatggaacagctttcttgtggagga
+tcatgggttcggggtatttcacactagtgtctggctcaaggttagagaagattattcatt
+agagtgtgatccagccgttattggaacagctgttaagggaaaggaggctgtacacagtga
+tctaggctactggattgagagtgagaagaatgacacatggaggctgaagagggcccatct
+gatcgagatgaaaacatgtgaatggccaaagtcccacacattgtggacagatggaataga
+agagagtgatctgatcatacccaagtctttagctgggccactcagccatcacaataccag
+agagggctacaggacccaaatgaaagggccatggcacagtgaagagcttgaaattcggtt
+tgaggaatgcccaggcactaaggtccacgtggaggaaacatgtggaacaagaggaccatc
+tctgagatcaaccactgcaagcggaagggtgatcgaggaatggtgctgcagggagtgcac
+aatgcccccactgtcgttctgggctaaagatggctgttggtatggaatggagataaggcc
+caggaaagaaccagaaagcaacttagtaaggtcaatggtgactgcaggatcaactgatca
+catggatcacttctcccttggagtgcttgtgattctgctcatggtgcaggaagggctgaa
+gaagagaatgaccacaaagatcatcataagcacatcaatggcagtgctggtagctatgat
+cctgggaggattttcaatgagtgacctggctaagcttgcaatcttgatgggtgccacctt
+cgcggaaatgaacactggaggagatgtagctcatctggcgctgatagcggcattcaaagt
+cagaccagcgttgctggtatccttcatcttcagagctaattggacaccccgtgaaagcat
+gctgctggccttggcctcgtgtcttttgcaaactgcgatctccgccttggagggcgacct
+gatggttctcatcaatggttttgctttggcctggttggcaatacgagcgatggttgttcc
+acgcactgacaacatcaccttggcaatcctggctgctctgacaccactggcccggggcac
+actgcttgtggcgtggagagcaggccttgctacttgcggggggtttatgctcctctctct
+gaagggaaaaggcagtgtgaagaagaacttaccatttgtcatggccctgggactaaccgc
+tgtgaggctggtcgaccccatcaacgtggtgggactgctgttgctcacaaggagtgggaa
+gcggagctggccccctagcgaagtactcacagctgttggcctgatatgcgcattggctgg
+agggttcgccaaggcagatatagagatggctgggcccatggccgcggttggtctgctaat
+tgtcagttacgtggtctcaggaaagagtgtggacatgtacattgaaagagcaggtgacat
+cacatgggaaaaagatgcggaagtcactggaaacagtccccggctcgatgtggcgctaga
+tgagagtggtgatttctccctggtggaggatgacggtccccccatgagagagatcatact
+caaggtggtcctgatgaccatctgtggcatgaacccaatagccataccctttgcagctgg
+agcgtggtacgtatacgtgaagactggaaaaaggagtggtgcgctatgggatgtgcctgc
+tcccaaggaagtaaaaaagggggagaccacagatggagtgtacagagtaatgactcgtag
+actgctaggttcaacacaagttggagtgggagttatgcaagagggggtctttcacactat
+gtggcacgtcacaaaaggatccgcgctgagaagcggtgaagggagacttgatccatactg
+gggagatgtcaagcaggatctggtgtcatactgtggtccatggaagctagatgccgcctg
+ggacgggcacagcgaggtgcagctcttggccgtgccccccggagagagagcgaggaacat
+ccagactctgcccggaatatttaagacaaaggatggggacattggagcggttgcgctgga
+ttacccagcaggaacttcaggatctccaatcctagacaagtgtgggagagtgataggact
+ttatggcaatggggtcgtgatcaaaaatgggagttatgttagtgccatcacccaagggag
+gagggaggaagagactcctgttgagtgcttcgagccttcgatgctgaagaagaagcagct
+aactgtcttagacttgcatcctggagctgggaaaaccaggagagttcttcctgaaatagt
+ccgtgaagccataaaaacaagactccgtactgtgatcttagctccaaccagggttgtcgc
+tgctgaaatggaggaagcccttagagggcttccagtgcgttatatgacaacagcagtcaa
+tgtcacccactctggaacagaaatcgtcgacttaatgtgccatgccaccttcacttcacg
+tctactacagccaatcagagtccccaactataatctgtatattatggatgaggcccactt
+cacagatccctcaagtatagcagcaagaggatacatttcaacaagggttgagatgggcga
+ggcggctgccatcttcatgaccgccacgccaccaggaacccgtgacgcatttccggactc
+caactcaccaattatggacaccgaagtggaagtcccagagagagcctggagctcaggctt
+tgattgggtgacggatcattctggaaaaacagtttggtttgttccaagcgtgaggaacgg
+caatgagatcgcagcttgtctgacaaaggctggaaaacgggtcatacagctcagcagaaa
+gacttttgagacagagttccagaaaacaaaacatcaagagtgggactttgtcgtgacaac
+tgacatttcagagatgggcgccaactttaaagctgaccgtgtcatagattccaggagatg
+cctaaagccggtcatacttgatggcgagagagtcattctggctggacccatgcctgtcac
+acatgccagcgctgcccagaggagggggcgcataggcaggaatcccaataaacctggaga
+tgagtatctgtatggaggtgggtgcgcagagactgacgaagaccatgcacactggcttga
+agcaagaatgctccttgacaatatttacctccaagatggcctcatagcctcgctctatcg
+acctgaggccgacaaagtagcagccattgagggagagttcaagcttaggacggagcaaag
+gaagacctttgtggaactcatgaaaagaggagatcttcctgtttggctggcctatcaggt
+tgcatctgccggaataacctacacagatagaagatggtgctttgatggcacgaccaacaa
+caccataatggaagacagtgtgccggcagaggtgtggaccagacacggagagaaaagagt
+gctcaaaccgaggtggatggacgccagagtttgttcagatcatgcggccctgaagtcatt
+caaggagtttgccgctgggaaaagaggagcggcttttggagtgatggaagccctgggaac
+actgccaggacacatgacagagagattccaggaagccattgacaacctcgctgtgctcat
+gcgggcagagactggaagcaggccttacaaagccgcggcggcccaattgccggagaccct
+agagaccattatgcttttggggttgctgggaacagtctcgttgggaatctttttcgtctt
+gatgaggaacaagggcatagggaagatgggctttggaatggtgactcttggggccagcgc
+atggctcatgtggctctcggaaattgagccagccagaattgcatgtgtcctcattgttgt
+gttcctattgctggtggtgctcatacctgagccagaaaagcaaagatctccccaggacaa
+ccaaatggcaatcatcatcatggtagcagtaggtcttctgggcttgattaccgccaatga
+actcggatggttggagagaacaaagagtgacctaagccatctaatgggaaggagagagga
+gggggcaaccataggattctcaatggacattgacctgcggccagcctcagcttgggccat
+ctatgctgccttgacaactttcattaccccagccgtccaacatgcagtgaccacttcata
+caacaactactccttaatggcgatggccacgcaagctggagtgttgtttggtatgggcaa
+agggatgccattctacgcatgggactttggagtcccgctgctaatgataggttgctactc
+acaattaacacccctgaccctaatagtggccatcattttgctcgtggcgcactacatgta
+cttgatcccagggctgcaggcagcagctgcgcgtgctgcccagaagagaacggcagctgg
+catcatgaagaaccctgttgtggatggaatagtggtgactgacattgacacaatgacaat
+tgacccccaagtggagaaaaagatgggacaggtgctactcatagcagtagccgtctccag
+cgccatactgtcgcggaccgcctgggggtggggggaggctggggccctgatcacagccgc
+aacttccactttgtgggaaggctctccgaacaagtactggaactcctctacagccacttc
+actgtgtaacatttttaggggaagttacttggctggagcttctctaatctacacagtaac
+aagaaacgctggcttggtcaagagacgtgggggtggaacaggagagaccctgggagagaa
+atggaaggcccgcttgaaccagatgtcggccctggagttctactcctacaaaaagtcagg
+catcaccgaggtgtgcagagaagaggcccgccgcgccctcaaggacggtgtggcaacggg
+aggccatgctgtgtcccgaggaagtgcaaagctgagatggttggtggagcggggatacct
+gcagccctatggaaaggtcattgatcttggatgtggcagagggggctggagttactacgc
+cgccaccatccgcaaagttcaagaagtgaaaggatacacaaaaggaggccctggtcatga
+agaacccgtgttggtgcaaagctatgggtggaacatagtccgtcttaagagtggggtgga
+cgtctttcatatggcggctgagccgtgtgacacgttgctgtgtgacataggtgagtcatc
+atctagtcctgaagtggaagaagcacggacgctcagagtcctctccatggtgggggattg
+gcttgaaaaaagaccaggagccttttgtataaaagtgttgtgcccatacaccagcactat
+gatggaaaccctggagcgactgcagcgtaggtatgggggaggactggtcagagtgccact
+ctcccgcaactctacacatgagatgtactgggtctctggagcgaaaagcaacaccataaa
+aagtgtgtccaccacgagccagctcctcttggggcgcatggacgggcctaggaggccagt
+gaaatatgaggaggatgtgaatctcggctctggcacgcgggctgtggtaagctgcgctga
+agctcccaacatgaagatcattggtaaccgcattgaaaggatccgcagtgagcacgcgga
+aacgtggttctttgacgagaaccacccatataggacatgggcttaccatggaagctatga
+ggcccccacacaagggtcagcgtcctctctaataaacggggttgtcaggctcctgtcaaa
+accctgggatgtggtgactggagtcacaggaatagccatgaccgacaccacaccgtatgg
+tcagcaaagagttttcaaggaaaaagtggacactagggtgccagacccccaagaaggcac
+tcgtcaggttatgagcatggtctcttcctggttgtggaaagagctaggcaaacacaaacg
+gccacgagtctgtaccaaagaagagttcatcaacaaggtgcgtagcaatgcagcattagg
+ggcaatatttgaagaggaaaaagagtggaagactgcagtggaagctgtgaacgatccaag
+gttctgggctctagtggacaaggaaagagagcaccacctgagaggagagtgccagagttg
+tgtgtacaacatgatgggaaaaagagaaaagaaacaaggggaatttggaaaggccaaggg
+cagccgcgccatctggtatatgtggctaggggctagatttctagagttcgaagcccttgg
+attcttgaacgaggatcactggatggggagagagaactcaggaggtggtgttgaagggct
+gggattacaaagactcggatatgtcctagaagagatgagtcgcataccaggaggaaggat
+gtatgcagatgacactgctggctgggacacccgcattagcaggtttgatctggagaatga
+agctctaatcaccaaccaaatggagaaagggcacagggccttggcattggccataatcaa
+gtacacataccaaaacaaagtggtaaaggtccttagaccagctgaaaaagggaaaacagt
+tatggacattatttcgagacaagaccaaagggggagcggacaagttgtcacttacgctct
+taacacatttaccaacctagtggtgcaactcattcggaatatggaggctgaggaagttct
+agagatgcaagacttgtggctgctgcggaggtcagagaaagtgaccaactggttgcagag
+caacggatgggataggctcaaacgaatggcagtcagtggagatgattgcgttgtgaagcc
+aattgatgataggtttgcacatgccctcaggttcttgaatgatatgggaaaagttaggaa
+ggacacacaagagtggaaaccctcaactggatgggacaactgggaagaagttccgttttg
+ctcccaccacttcaacaagctccatctcaaggacgggaggtccattgtggttccctgccg
+ccaccaagatgaactgattggccgggcccgcgtctctccaggggcgggatggagcatccg
+ggagactgcttgcctagcaaaatcatatgcgcaaatgtggcagctcctttatttccacag
+aagggacctccgactgatggccaatgccatttgttcatctgtgccagttgactgggttcc
+aactgggagaactacctggtcaatccatggaaagggagaatggatgaccactgaagacat
+gcttgtggtgtggaacagagtgtggattgaggagaacgaccacatggaagacaagacccc
+agttgcgaaatggacagacattccctatttgggaaaaagggaagacttgtggtgtggatc
+tctcatagggcacagaccgcgcaccacctgggctgagaacattaaaaacacagtcaacat
+ggtgcgcaggatcataggtgatgaagaaaagtacatggactacctatccacccaagttcg
+ctacttgggtgaagaagggtctacacctggagtgctgtaagcaccaatcttaatgttgtc
+aggcctgctagtcagccacagcttggggaaagctgtgcagcctgtgacccccccaggaga
+agctgggaaaccaagcctatagtcaggccgagaacgccatggcacggaagaagccatgct
+gcctgtgagcccctcagaggacactgagtcaaaaaaccccacgcgcttggaggcgcagga
+tgggaaaagaaggtggcgaccttccccacccttcaatctggggcctgaactggagatcag
+ctgtggatctccagaagagggactagtggttagaggaga
+>PRVABC59
+gttgttgatctgtgtgaatcagactgcgacagttcgagtttgaagcgaaagctagcaaca
+gtatcaacaggttttattttggatttggaaacgagagtttctggtcatgaaaaacccaaa
+aaagaaatccggaggattccggattgtcaatatgctaaaacgcggagtagcccgtgtgag
+cccctttgggggcttgaagaggctgccagccggacttctgctgggtcatgggcccatcag
+gatggtcttggcgattctagcctttttgagattcacggcaatcaagccatcactgggtct
+catcaatagatggggttcagtggggaaaaaagaggctatggaaacaataaagaagttcaa
+gaaagatctggctgccatgctgagaataatcaatgctaggaaggagaagaagagacgagg
+cgcagatactagtgtcggaattgttggcctcctgctgaccacagctatggcagcggaggt
+cactagacgtgggagtgcatactatatgtacttggacagaaacgatgctggggaggccat
+atcttttccaaccacattggggatgaataagtgttatatacagatcatggatcttggaca
+catgtgtgatgccaccatgagctatgaatgccctatgctggatgagggggtggaaccaga
+tgacgtcgattgttggtgcaacacgacgtcaacttgggttgtgtacggaacctgccatca
+caaaaaaggtgaagcacggagatctagaagagctgtgacgctcccctcccattccaccag
+gaagctgcaaacgcggtcgcaaacctggttggaatcaagagaatacacaaagcacttgat
+tagagtcgaaaattggatattcaggaaccctggcttcgcgttagcagcagctgccatcgc
+ttggcttttgggaagctcaacgagccaaaaagtcatatacttggtcatgatactgctgat
+tgccccggcatacagcatcaggtgcataggagtcagcaatagggactttgtggaaggtat
+gtcaggtgggacttgggttgatgttgtcttggaacatggaggttgtgtcaccgtaatggc
+acaggacaaaccgactgtcgacatagagctggttacaacaacagtcagcaacatggcgga
+ggtaagatcctactgctatgaggcatcaatatcagacatggcttctgacagccgctgccc
+aacacaaggtgaagcctaccttgacaagcaatcagacactcaatatgtctgcaaaagaac
+gttagtggacagaggctggggaaatggatgtggactttttggcaaagggagcctggtgac
+atgcgctaagtttgcatgctccaagaaaatgaccgggaagagcatccagccagagaatct
+ggagtaccggataatgctgtcagttcatggctcccagcacagtgggatgatcgttaatga
+cacaggacatgaaactgatgagaatagagcgaaagttgagataacgcccaattcaccgag
+agccgaagccaccctggggggttttggaagcctaggacttgattgtgaaccgaggacagg
+ccttgacttttcagatttgtattacttgactatgaataacaagcactggttggttcacaa
+ggagtggttccacgacattccattaccttggcacgctggggcagacaccggaactccaca
+ctggaacaacaaagaagcactggtagagttcaaggacgcacatgccaaaaggcaaactgt
+cgtggttctagggagtcaagaaggagcagttcacacggcccttgctggagctctggaggc
+tgagatggatggtgcaaagggaaggctgtcctctggccacttgaaatgtcgcctgaaaat
+ggataaacttagattgaagggcgtgtcatactccttgtgtactgcagcgttcacattcac
+caagatcccggctgaaacactgcacgggacagtcacagtggaggtacagtacgcagggac
+agatggaccttgcaaggttccagctcagatggcggtggacatgcaaactctgaccccagt
+tgggaggttgataaccgctaaccccgtaatcactgaaagcactgagaactctaagatgat
+gctggaacttgatccaccatttggggactcttacattgtcataggagtcggggagaagaa
+gatcacccaccactggcacaggagtggcagcaccattggaaaagcatttgaagccactgt
+gagaggtgccaagagaatggcagtcttgggagacacagcctgggactttggatcagttgg
+aggcgctctcaactcattgggcaagggcatccatcaaatttttggagcagctttcaaatc
+attgtttggaggaatgtcctggttctcacaaattctcattggaacgttgctgatgtggtt
+gggtctgaacacaaagaatggatctatttcccttatgtgcttggccttagggggagtgtt
+gatcttcttatccacagccgtctctgctgatgtggggtgctcggtggacttctcaaagaa
+ggagacgagatgcggtacaggggtgttcgtctataacgacgttgaagcctggagggacag
+gtacaagtaccatcctgactccccccgtagattggcagcagcagtcaagcaagcctggga
+agatggtatctgcgggatctcctctgtttcaagaatggaaaacatcatgtggagatcagt
+agaaggggagctcaacgcaatcctggaagagaatggagttcaactgacggtcgttgtggg
+atctgtaaaaaaccccatgtggagaggtccacagagattgcccgtgcctgtgaacgagct
+gccccacggctggaaggcttgggggaaatcgtatttcgtcagagcagcaaagacaaataa
+cagctttgtcgtggatggtgacacactgaaggaatgcccactcaaacatagagcatggaa
+cagctttcttgtggaggatcatgggttcggggtatttcacactagtgtctggctcaaggt
+tagagaagattattcattagagtgtgatccagccgttattggaacagctgttaagggaaa
+ggaggctgtacacagtgatctaggctactggattgagagtgagaagaatgacacatggag
+gctgaagagggcccatctgatcgagatgaaaacatgtgaatggccaaagtcccacacatt
+gtggacagatggaatagaagagagtgatctgatcatacccaagtctttagctgggccact
+cagccatcacaataccagagagggctacaggacccaaatgaaagggccatggcacagtga
+agagcttgaaattcggtttgaggaatgcccaggcactaaggtccacgtggaggaaacatg
+tggaacaagaggaccatctctgagatcaaccactgcaagcggaagggtgatcgaggaatg
+gtgctgcagggagtgcacaatgcccccactgtcgttccgggctaaagatggctgttggta
+tggaatggagataaggcccaggaaagaaccagaaagcaacttagtaaggtcaatggtgac
+tgcaggatcaactgatcacatggaccacttctcccttggagtgcttgtgatcctgctcat
+ggtgcaggaagggctgaagaagagaatgaccacaaagatcatcataagcacatcaatggc
+agtgctggtagctatgatcctgggaggattttcaatgagtgacctggctaagcttgcaat
+tttgatgggtgccaccttcgcggaaatgaacactggaggagatgtagctcatctggcgct
+gatagcggcattcaaagtcagaccagcgttgctggtatctttcatcttcagagctaattg
+gacaccccgtgaaagcatgctgctggccttggcctcgtgtcttttgcaaactgcgatctc
+cgccttggaaggcgacctgatggttctcatcaatggttttgctttggcctggttggcaat
+acgagcgatggttgttccacgcactgataacatcaccttggcaatcctggctgctctgac
+accactggcccggggcacactgcttgtggcgtggagagcaggccttgctacttgcggggg
+gtttatgctcctctctctgaagggaaaaggcagtgtgaagaagaacttaccatttgtcat
+ggccctgggactaaccgctgtgaggctggtcgaccccatcaacgtggtgggactgctgtt
+gctcacaaggagtgggaagcggagctggccccctagcgaagtactcacagctgttggcct
+gatatgcgcattggctggagggttcgccaaggcagatatagagatggctgggcccatggc
+cgcggtcggtctgctaattgtcagttacgtggtctcaggaaagagtgtggacatgtacat
+tgaaagagcaggtgacatcacatgggaaaaagatgcggaagtcactggaaacagtccccg
+gctcgatgtggcgctagatgagagtggtgatttctccctggtggaggatgacggtccccc
+catgagagagatcatactcaaggtggtcctgatgaccatctgtggcatgaacccaatagc
+cataccctttgcagctggagcgtggtacgtatacgtgaagactggaaaaaggagtggtgc
+tctatgggatgtgcctgctcccaaggaagtaaaaaagggggagaccacagatggagtgta
+cagagtaatgactcgtagactgctaggttcaacacaagttggagtgggagttatgcaaga
+gggggtctttcacactatgtggcacgtcacaaaaggatccgcgctgagaagcggtgaagg
+gagacttgatccatactggggagatgtcaagcaggatctggtgtcatactgtggtccatg
+gaagctagatgccgcctgggatgggcacagcgaggtgcagctcttggccgtgccccccgg
+agagagagcgaggaacatccagactctgcccggaatatttaagacaaaggatggggacat
+tggagcggttgcgctggattacccagcaggaacttcaggatctccaatcctagacaagtg
+tgggagagtgataggactttatggcaatggggtcgtgatcaaaaacgggagttatgttag
+tgccatcacccaagggaggagggaggaagagactcctgttgagtgcttcgagccctcgat
+gctgaagaagaagcagctaactgtcttagacttgcatcctggagctgggaaaaccaggag
+agttcttcctgaaatagtccgtgaagccataaaaacaagactccgtactgtgatcttagc
+tccaaccagggttgtcgctgctgaaatggaggaggcccttagagggcttccagtgcgtta
+tatgacaacagcagtcaatgtcacccactctggaacagaaatcgtcgacttaatgtgcca
+tgccaccttcacttcacgtctactacagccaatcagagtccccaactataatctgtatat
+tatggatgaggcccacttcacagatccctcaagtatagcagcaagaggatacatttcaac
+aagggttgagatgggcgaggcggctgccatcttcatgaccgccacgccaccaggaacccg
+tgacgcatttccggactccaactcaccaattatggacaccgaagtggaagtcccagagag
+agcctggagctcaggctttgattgggtgacggatcattctggaaaaacagtttggtttgt
+tccaagcgtgaggaacggcaatgagatcgcagcttgtctgacaaaggctggaaaacgggt
+catacagctcagcagaaagacttttgagacagagttccagaaaacaaaacatcaagagtg
+ggactttgtcgtgacaactgacatttcagagatgggcgccaactttaaagctgaccgtgt
+catagattccaggagatgcctaaagccggtcatacttgatggcgagagagtcattctggc
+tggacccatgcctgtcacacatgccagcgctgcccagaggagggggcgcataggcaggaa
+tcccaacaaacctggagatgagtatctgtatggaggtgggtgcgcagagactgacgaaga
+ccatgcacactggcttgaagcaagaatgctccttgacaatatttacctccaagatggcct
+catagcctcgctctatcgacctgaggccgacaaagtagcagccattgagggagagttcaa
+gcttaggacggagcaaaggaagacctttgtggaactcatgaaaagaggagatcttcctgt
+ttggctggcctatcaggttgcatctgccggaataacctacacagatagaagatggtgctt
+tgatggcacgaccaacaacaccataatggaagacagtgtgccggcagaggtgtggaccag
+acacggagagaaaagagtgctcaaaccgaggtggatggacgccagagtttgttcagatca
+tgcggccctgaagtcattcaaggagtttgccgctgggaaaagaggagcggcttttggagt
+gatggaagccctgggaacactgccaggacacatgacagagagattccaggaagccattga
+caacctcgctgtgctcatgcgggcagagactggaagcaggccttacaaagccgcggcggc
+ccaattgccggagaccctagagaccataatgcttttggggttgctgggaacagtctcgct
+gggaatcttcttcgtcttgatgaggaacaagggcatagggaagatgggctttggaatggt
+gactcttggggccagcgcatggctcatgtggctctcggaaattgagccagccagaattgc
+atgtgtcctcattgttgtgttcctattgctggtggtgctcatacctgagccagaaaagca
+aagatctccccaggacaaccaaatggcaatcatcatcatggtagcagtaggtcttctggg
+cttgattaccgccaatgaactcggatggttggagagaacaaagagtgacctaagccatct
+aatgggaaggagagaggagggggcaaccataggattctcaatggacattgacctgcggcc
+agcctcagcttgggccatctatgctgccttgacaactttcattaccccagccgtccaaca
+tgcagtgaccacctcatacaacaactactccttaatggcgatggccacgcaagctggagt
+gttgtttggcatgggcaaagggatgccattctacgcatgggactttggagtcccgctgct
+aatgataggttgctactcacaattaacacccctgaccctaatagtggccatcattttgct
+cgtggcgcactacatgtacttgatcccagggctgcaggcagcagctgcgcgtgctgccca
+gaagagaacggcagctggcatcatgaagaaccctgttgtggatggaatagtggtgactga
+cattgacacaatgacaattgacccccaagtggagaaaaagatgggacaggtgctactcat
+agcagtagccgtctccagcgccatactgtcgcggaccgcctgggggtggggggaggctgg
+ggctctgatcacagccgcaacttccactttgtgggaaggctctccgaacaagtactggaa
+ctcctctacagccacttcactgtgtaacatttttaggggaagttacttggctggagcttc
+tctaatctacacagtaacaagaaacgctggcttggtcaagagacgtgggggtggaacagg
+agagaccctgggagagaaatggaaggcccgcttgaaccagatgtcggccctggagttcta
+ctcctacaaaaagtcaggcatcaccgaggtgtgcagagaagaggcccgccgcgccctcaa
+ggacggtgtggcaacgggaggccatgctgtgtcccgaggaagtgcaaagctgagatggtt
+ggtggagcggggatacctgcagccctatggaaaggtcattgatcttggatgtggcagagg
+gggctggagttactacgtcgccaccatccgcaaagttcaagaagtgaaaggatacacaaa
+aggaggccctggtcatgaagaacccgtgttggtgcaaagctatgggtggaacatagtccg
+tcttaagagtggggtggacgtctttcatatggcggctgagccgtgtgacacgttgctgtg
+tgacataggtgagtcatcatctagtcctgaagtggaagaagcacggacgctcagagtcct
+ctccatggtgggggattggcttgaaaaaagaccaggagccttttgtataaaagtgttgtg
+cccatacaccagcactatgatggaaaccctggagcgactgcagcgtaggtatgggggagg
+actggtcagagtgccactctcccgcaactctacacatgagatgtactgggtctctggagc
+gaaaagcaacaccataaaaagtgtgtccaccacgagccagctcctcttggggcgcatgga
+cgggcctaggaggccagtgaaatatgaggaggatgtgaatctcggctctggcacgcgggc
+tgtggtaagctgcgctgaagctcccaacatgaagatcattggtaaccgcattgaaaggat
+ccgcagtgagcacgcggaaacgtggttctttgacgagaaccacccatataggacatgggc
+ttaccatggaagctatgaggcccccacacaagggtcagcgtcctctctaataaacggggt
+tgtcaggctcctgtcaaaaccctgggatgtggtgactggagtcacaggaatagccatgac
+cgacaccacaccgtatggtcagcaaagagttttcaaggaaaaagtggacactagggtgcc
+agacccccaagaaggcactcgtcaggttatgagcatggtctcttcctggttgtggaaaga
+gctaggcaaacacaaacggccacgagtctgcaccaaagaagagttcatcaacaaggttcg
+tagcaatgcagcattaggggcaatatttgaagaggaaaaagagtggaagactgcagtgga
+agctgtgaacgatccaaggttctgggctctagtggacaaggaaagagagcaccacctgag
+aggagagtgccagagctgtgtgtacaacatgatgggaaaaagagaaaagaaacaagggga
+atttggaaaggccaagggcagccgcgccatctggtatatgtggctaggggctagatttct
+agagttcgaagcccttggattcttgaacgaggatcactggatggggagagagaactcagg
+aggtggtgttgaagggctgggattacaaagactcggatatgtcctagaagagatgagtcg
+tataccaggaggaaggatgtatgcagatgacactgctggctgggacacccgcattagcag
+gtttgatctggagaatgaagctctaatcaccaaccaaatggagaaagggcacagggcctt
+ggcattggccataatcaagtacacataccaaaacaaagtggtaaaggtccttagaccagc
+tgaaaaagggaaaacagttatggacattatttcgagacaagaccaaagggggagcggaca
+agttgtcacttacgctcttaacacatttaccaacctagtggtgcaactcattcggaatat
+ggaggctgaggaagttctagagatgcaagacttgtggctgctgcggaggtcagagaaagt
+gaccaactggttgcagagcaacggatgggataggctcaaacgaatggcagtcagtggaga
+tgattgcgttgtgaagccaattgatgataggtttgcacatgccctcaggttcttgaatga
+tatgggaaaagttaggaaggacacacaagagtggaaaccctcaactggatgggacaactg
+ggaagaagttccgttttgctcccaccacttcaacaagctccatctcaaggacgggaggtc
+cattgtggttccctgccgccaccaagatgaactgattggccgggcccgcgtctctccagg
+ggcgggatggagcatccgggagactgcttgcctagcaaaatcatatgcgcaaatgtggca
+gctcctttatttccacagaagggacctccgactgatggccaatgccatttgttcatctgt
+gccagttgactgggttccaactgggagaactacctggtcaatccatggaaagggagaatg
+gatgaccactgaagacatgcttgtggtgtggaacagagtgtggattgaggagaacgacca
+catggaagacaagaccccagttacgaaatggacagacattccctatttgggaaaaaggga
+agacttgtggtgtggatctctcatagggcacagaccgcgcaccacctgggctgagaacat
+taaaaacacagtcaacatggtgcgcaggatcataggtgatgaagaaaagtacatggacta
+cctatccacccaagttcgctacttgggtgaagaagggtctacacctggagtgctgtaagc
+accaatcttaatgttgtcaggcctgctagtcagccacagcttggggaaagctgtgcagcc
+tgtgacccccccaggagaagctgggaaaccaagcctatagtcaggccgagaacgccatgg
+cacggaagaagccatgctgcctgtgagcccctcagaggacactgagtcaaaaaaccccac
+gcgcttggaggcgcaggatgggaaaagaaggtggcgaccttccccacccttcaatctggg
+gcctgaactggagatcagctgtggatctccagaagagggactagtggttagagga
+>COL/FLR_00008/2015
+tcagactgcgacagttcgagtttgaagcgaaagctagcaacagtatcaacaggttttatt
+ttggatttggaaacgagagtttctggtcatgaaaaacccaaaaaagaaatccggaggatt
+ccggattgtcaatatgctaaaacgcggagtagcccgtgtgagcccctttgggggcttgaa
+gaggctgccagccggacttctgctgggtcatgggcccatcaggatggtcttggcgattct
+agcctttttgagattcacggcaatcaagccatcactgggtctcatcaatagatggggttc
+agtggggaaaaaagaggctatggaaataataaagaagttcaagaaagatctggctgccat
+gctgagaataatcaatgctaggaaggagaagaagagacgaggcgcagaaactagtgtcgg
+aattgttggcctcctgctgaccacagctatggcagcggaggtcactagacgtgggagtgc
+atactatatgtacttggacagaaacgatgctggggaggccatatcttttccaaccacatt
+ggggatgaataagtgttatatacagatcatggatcttggacacatgtgtgatgccaccat
+gagctatgaatgccctatgctggatgagggggtggaaccagatgacgtcgattgttggtg
+caacacgacgtcaacttgggttgtgtacggaacctgccatcacaaaaaaggtgaagcacg
+gagatctagaagagccgtgacgctcccctcccattccactaggaagctgcaaacgcggtc
+gcaaacctggttggaatcaagagaatacacaaagcacttgattagagtcgaaaattggat
+attcaggaaccctggtttcgctttagcagcagctgccatcgcttggcttttgggaagctc
+aacgagccaaaaagtcatatacttggtcatgatactgctgattgccccggcatacagcat
+caggtgcataggagtcagcaatagggactttgtggaaggtatgtcaggtgggacttgggt
+tgatgtcgtcttggaacatggaggttgtgtcaccgtaatggcacaggacaaaccgactgt
+cgacatagagctggttacaacaacagtcagcaacatggcggaggtaagatcctactgcta
+tgaggcatcaatatcagacatggcttcggacagccgctgcccaacacaaggtgaagccta
+ccttgacaagcaatcagacactcaatatgtctgcaaaagaacgttagtggacagaggctg
+gggaaatggatgtggactttttggcaaagggagcctggtgacatgcgctaagtttgcatg
+ctccaagaaaatgaccgggaagagcatccagccagagaatctggagtaccggataatgtt
+gtcagttcatggctcccagcacagtgggatgatcgttaatgacacaggacatgaaactga
+tgagaatagagcgaaggttgagataacgcccaattcaccaagagccgaagccaccctggg
+gggctttggaagcctaggacttgattgtgaaccgaggacaggccttgacttttcagattt
+gtattacttgactatgaataacaagcactggttggttcacaaggagtggttccacgacat
+tccattaccttggcacgctggggcagacaccggaactccacactggaacaacaaagaagc
+actggtagagttcaaggacgcacatgccaaaaggcaaactgtcgtggttctagggagtca
+agaaggagcagttcacacggcccttgctggagctctggaggctgagatggatggtgcaaa
+gggaaggctgtcctctggccacttgaaatgtcgcctgaaaatggataaacttagattgaa
+gggcgtgtcatactccttgtgtaccgcagcgttcacattcaccaagatcccggctgaaac
+actgcacgggacagtcacagtggaggtacagtacgcagggacagatggaccttgcaaggt
+tccagctcagatggcggtggacatgcaaactctgaccccagttgggaggttgataaccgc
+taaccccgtaatcactgaaagcactgagaactctaagatgatgctggaacttgatccacc
+atttggggactcttacattgtcataggagtcggggagaagaagatcacccaccactggca
+caggagtggcagcaccattggaaaagcatttgaagccactgtgagaggtgccaagagaat
+ggcagtcttgggagacacagcctgggactttggatcagttggaggcgctctcaactcatt
+gggcaagggcatccatcaaatttttggagcagctttcaaatcattgtttggaggaatgtc
+ctggttctcacaaattctcattggaacgttgctgatgtggttgggtctgaacacaaagaa
+tggatctatttcccttatgtgcttggccttagggggagtgttgatcttcttatccacagc
+cgtctctgctgatgtggggtgctcggtggacttctcaaagaaggagacgagatgtggtac
+aggggtgttcgtctataacgacgttgaagcctggagggacaggtacaagtaccatcctga
+ctccccccgtagattggcagcagcagtcaagcaagcctgggaagatggtatctgcgggat
+ctcctctgtttcaagaatggaaaacatcatgtggagatcagtagaaggggagctcaacgc
+aatcctggaagagaatggagttcaactgacggtcgttgtgggatctgtaaaaaaccccat
+gtggagaggtccacagagattgcccgtgcctgtgaacgagctgccccacggctggaaggc
+ttgggggaaatcgtacttcgtcagagcagcaaagacaaataacagctttgtcgtggatgg
+tgacacactgaaagaatgcccactcaaacatagagcatggaacagctttcttgtggagga
+tcatgggttcggggtatttcacactagtgtctggatcaaggttagagaagattattcatt
+agagtgtgatccagccgttattggaacagctgttaagggaaaggaggctgtacacagtga
+tctaggctactggattgagagtgagaagaatgacacatggaggctgaagagggcccatct
+gatcgagatgaaaacatgtgaatggccaaagtcccacacattgtggacagatggaataga
+agagagtgatctgatcatacccaagtctttagctgggccactcagccatcacaataccag
+agagggctacaggacccaaatgaaagggccatggcacagtgaagagcttgaaattcggtt
+tgaggaatgcccaggcactaaggtccacgtggaggaaacatgtgaaacaagaggaccatc
+tctgagatcaaccactgcaagcggaagggtgatcgaggaatggtgctgcagggagtgcac
+aatgcccccactgtcgttctgggctaaagatggctgttggtatggaatggagataaggcc
+caggaaagaaccagaaagcaacttagtaaggtcaatggtgactgcaggatcaactgatca
+catggatcacttctcccttggagtgcttgtgattctgctcatggtgcaggaagggctgaa
+gaagagaatgaccacaaagatcatcataagcacatcaatggcagtgctggtagctatgat
+cctgggaggattttcaatgagtgacctggctaagcttgcaatcttgatgggtgccacctt
+cgcggaaatgaacactggaggagatgtagctcatctggcgctgatagcggcattcaaagt
+cagaccagcgttgctggtatccttcatcttcagagctaattggacaccccgtgaaagcat
+gctgctggccttggcctcgtgtcttttgcaaactgcgatctccgccttggagggcgacct
+gatggttctcatcaatggttttgctttggcctggttggcaatacgagcgatggttgttcc
+acgcactgacaacatcaccttggcaatcctggctgctctgacaccactggcccggggcac
+actgcttgtggcgtggagagcaggccttgctacttgcggggggtttatgctcctctctct
+gaagggaaaaggcagtgtgaagaagaacttaccatttgtcatggccctgggactaaccgc
+tgtgaggctggtcgaccccatcaacgtggtgggactgctgttgctcacaaggagtgggaa
+gcggagctggccccctagcgaagtactcacagctgttggcctgatatgcgcattggctgg
+agggttcgccaaggcagatatagagatggctgggcccatggccgcggttggtctgctaat
+tgtcagttacgtggtctcaggaaagagtgtggacatgtacattgaaagagcaggtgacat
+cacatgggaaaaagatgcggaagtcactggaaacagtccccggctcgatgtggcgctaga
+tgagagtggtgatttctccctggtggaggatgacggtccccccatgagagagatcatact
+caaggtggtcctgatgaccatctgtggcatgaacccaatagccataccctttgcagctgg
+agcgtggtacgtatacgtgaagactggaaaaaggagtggtgcgctatgggatgtgcctgc
+tcccaaggaagtaaaaaagggggagaccacagatggagtgtacagagtaatgactcgtag
+actgctaggttcaacacaagttggagtgggagttatgcaagagggggtctttcacactat
+gtggcacgtcacaaaaggatccgcgctgagaagcggtgaagggagacttgatccatactg
+gggagatgtcaagcaggatctggtgtcatactgtggtccatggaagctagatgccgcctg
+ggacgggcacagcgaggtgcagctcttggccgtgccccccggagagagagcgaggaacat
+ccagactctgcccggaatatttaagacaaaggatggggacattggagcggttgcgctgga
+ttacccagcaggaacttcaggatctccaatcctagacaagtgtgggagagtgataggact
+ttatggcaatggggtcgtgatcaaaaatgggagttatgttagtgccatcacccaagggag
+gagggaggaagagactcctgttgagtgcttcgagccttcgatgctgaagaagaagcagct
+aactgtcttagacttgcatcctggagctgggaaaaccaggagagttcttcctgaaatagt
+ccgtgaagccataaaaacaagactccgtactgtgatcttagctccaaccagggttgtcgc
+tgctgaaatggaggaagcccttagagggcttccagtgcgttatatgacaacagcagtcaa
+tgtcacccactctggaacagaaatcgtcgacttaatgtgccatgccaccttcacttcacg
+tctactacagccaatcagagtccccaactataatctgtatattatggatgaggcccactt
+cacagatccctcaagtatagcagcaagaggatacatttcaacaagggttgagatgggcga
+ggcggctgccatcttcatgaccgccacgccaccaggaacccgtgacgcatttccggactc
+caactcaccaattatggacaccgaagtggaagtcccagagagagcctggagctcaggctt
+tgattgggtgacagatcattctggaaaaacagtttggtttgttccaagcgtgaggaacgg
+caatgagatcgcagcttgtctgacaaaggctggaaaacgggtcatacagctcagcagaaa
+gacttttgagacagagttccagaaaacaaaacatcaagagtgggactttgtcgtgacaac
+tgacatttcagagatgggcgccaactttaaagctgaccgtgtcatagattccaggagatg
+cctaaagccggtcatacttgatggcgagagagtcattctggctggacccatgcctgtcac
+acatgccagcgctgcccagaggagggggcgcataggcaggaatcccaataaacctggaga
+tgagtatctgtatggaggtgggtgcgcagagactgacgaagaccatgcacactggcttga
+agcaagaatgctccttgacaatatttacctccaagatggcctcatagcctcgctctatcg
+acctgaggccgacaaagtagcagccattgagggagagttcaagcttaggacggagcaaag
+gaagacctttgtggaactcatgaaaagaggagatcttcctgtttggctggcctatcaggt
+tgcatctgccggaataacctacacagatagaagatggtgctttgatggcacgaccaacaa
+caccataatggaagacagtgtgccggcagaggtgtggaccagacacggagagaaaagagt
+gctcaaaccgaggtggatggacgccagagtttgttcagatcatgcggccctgaagtcatt
+caaggagtttgccgctgggaaaagaggagcggcttttggagtgatggaagccctgggaac
+actgccaggacacatgacagagagattccaggaagccattgacaacctcgctgtgctcat
+gcgggcagagactggaagcaggccttacaaagccgcggcggcccaattgccggagaccct
+agagaccattatgcttttggggttgctgggaacagtctcgttgggaatctttttcgtctt
+gatgaggaacaagggcatagggaagatgggctttggaatggtgactcttggggccagcgc
+atggctcatgtggctctcggaaattgagccagccagaattgcatgtgtcctcattgttgt
+gttcctattgctggtggtgctcatacctgagccagaaaagcaaagatctccccaggacaa
+ccaaatggcaatcatcatcatggtagcagtaggtcttctgggcttgattaccgccaatga
+actcggatggttggagagaacaaagagtgacctaagccatctaatgggaaggagagagga
+gggggcaaccataggattctcaatggacattgacctgcggccagcctcagcttgggccat
+ctatgctgccttgacaactttcattaccccagccgtccaacatgcagtgaccacttcata
+caacaactactccttaatggcgatggccacgcaagctggagtgttgtttggtatgggcaa
+agggatgccattctacgcatgggactttggagtcccgctgctaatgataggttgctactc
+acaattaacacccctgaccctaatagtggccatcattttgctcgtggcgcactacatgta
+cttgatcccagggctgcaggcagcagctgcgcgtgctgcccagaagagaacggcagctgg
+catcatgaagaaccctgttgtggatggaatagtggtgactgacattgacacaatgacaat
+tgacccccaagtggagaaaaagatgggacaggtgctactcatagcagtagccgtctccag
+cgccatactgtcgcggaccgcctgggggtggggggaggctggggccctgatcacagccgc
+aacttccactttgtgggaaggctctccgaacaagtactggaactcctctacagccacttc
+actgtgtaacatttttaggggaagttacttggctggagcttctctaatctacacagtaac
+aagaaacgctggcttggtcaagagacgtgggggtggaacaggagagaccctgggagagaa
+atggaaggcccgcttgaaccagatgtcggccctggagttctactcctacaaaaagtcagg
+catcaccgaggtgtgcagagaagaggcccgccgcgccctcaaggacggtgtggcaacggg
+aggccatgctgtgtcccgaggaagtgcaaagctgagatggttggtggagcggggatacct
+gcagccctatggaaaggtcattgatcttggatgtggcagagggggctggagttactacgc
+cgccaccatccgcaaagttcaagaagtgaaaggatacacaaaaggaggccctggtcatga
+agaacccgtgttggtgcaaagctatgggtggaacatagtccgtcttaagagtggggtgga
+cgtctttcatatggcggctgagccgtgtgacacgttgctgtgtgacataggtgagtcatc
+atctagtcctgaagtggaagaagcacggacgctcagagtcctctccatggtgggggattg
+gcttgaaaaaagaccaggagccttttgtataaaagtgttgtgcccatacaccagcactat
+gatggaaaccctggagcgactgcagcgtaggtatgggggaggactggtcagagtgccact
+ctcccgcaactctacacatgagatgtactgggtctctggagcgaaaagcaacaccataaa
+aagtgtgtccaccacgagccagctcctcttggggcgcatggacgggcctaggaggccagt
+gaaatatgaggaggatgtgaatctcggctctggcacgcgggccgtggtaagctgcgctga
+agctcccaacatgaagatcattggtaaccgcattgaaaggatccgcagtgagcacgcgga
+aacgtggttctttgacgagaaccacccatataggacatgggcttaccatggaagctatga
+ggcccccacacaagggtcagcgtcctctctaataaacggggttgtcaggctcctgtcaaa
+accctgggatgtggtgactggagtcacaggaatagccatgaccgacaccacaccgtatgg
+tcagcaaagagttttcaaggaaaaagtggacactagggtgccagacccccaagaaggcac
+tcgtcaggttatgagcatggtctcttcctggttgtggaaagagctaggcaaacacaaacg
+gccacgagtctgtaccaaagaagagttcatcaacaaggtgcgtagcaatgcagcattagg
+ggcaatatttgaagaggaaaaagagtggaagactgcagtggaagctgtgaacgatccaag
+gttctgggctctagtggacaaggaaagagagcaccacctgagaggagagtgccagagttg
+tgtgtacaacatgatgggaaaaagagaaaagaaacaaggggaatttggaaaggccaaggg
+cagccgcgccatctggtatatgtggctaggggctagatttctagagttcgaagcccttgg
+attcttgaacgaggatcactggatggggagagagaactcaggaggtggtgttgaagggct
+gggattacaaagactcggatatgtcctagaagagatgagtcgcataccaggaggaaggat
+gtatgcagatgacactgctggctgggacacccgcattagcaggtttgatctggagaatga
+agctctaatcaccaaccaaatggagaaagggcacagggccttggcattggccataatcaa
+gtacacataccaaaacaaagtggtaaaggtccttagaccagctgaaaaagggaaaacagt
+tatggacattatttcgagacaagaccaaagggggagcggacaagttgtcacttacgctct
+taacacatttaccaacctagtggtgcaactcattcggaatatggaggctgaggaagttct
+agagatgcaagacttgtggctgctgcggaggtcagagaaagtgaccaactggttgcagag
+caacggatgggataggctcaaacgaatggcagtcagtggagatgattgcgttgtgaagcc
+aattgatgataggtttgcacatgccctcaggttcttgaatgatatgggaaaagttaggaa
+ggacacacaagagtggaaaccctcaactggatgggacaactgggaagaagttccgttttg
+ctcccaccacttcaacaagctccatctcaaggacgggaggtccattgtggttccctgccg
+ccaccaagatgaactgattggccgggcccgcgtctctccaggggcgggatggagcatccg
+ggagactgcttgcctagcaaaatcatatgcgcaaatgtggcagctcctttatttccacag
+aagggacctccgactgatggccaatgccatttgttcatctgtgccagttgactgggttcc
+aactgggagaactacctggtcaatccatggaaagggagaatggatgaccactgaagacat
+gcttgtggtgtggaacagagtgtggattgaggagaacgaccacatggaagacaagacccc
+agttgcgaaatggacagacattccctatttgggaaaaagggaagacttgtggtgtggatc
+tctcatagggcacagaccgcgcaccacctgggctgagaacattaaaaacacagtcaacat
+ggtgcgcaggatcataggtgatgaagaaaagtacatggactacctatccacccaagttcg
+ctacttgggtgaagaagggtctacacctggagtgctgtaagcaccaatcttaatgttgtc
+aggcctgctagtcagccacagcttggggaaagctgtgcagcctgtgacccccccaggaga
+agctgggaaaccaagcctatagtcaggccgagaacgccatggcacggaagaagccatgct
+gcctgtgagcccctcagaggacactgagtcaaaaaaccccacgcgcttggaggcgcagga
+tgggaaaagaaggtggcgaccttccccacccttcaatctggggcctgaactggagatcag
+ctgtggatctccagaagagggactagtggttagaggaga
+>Colombia/2016/ZC204Se
+gacagttcgagtttgaagcgaaagctagcaacagtatcaacaggttttattttggatttg
+gaaacgagagtttctggtcatgaaaaacccaaaaaagaaatccggaggattccggattgt
+caatatgctaaaacgcggagtagcccgtgtgagcccctttgggggcttgaagaggctgcc
+agccggacttctgctgggtcatgggcccatcaggatggtcttggcgattctagccttttt
+gagattcacggcaatcaagccatcactgggtctcatcaatagatggggttcagtggggaa
+aaaagaggctatggaaataataaagaagttcaagaaagatctggctgccatgctgagaat
+aatcaatgctaggaaggagaagaagagacgaggcgcagaaactagtgtcggaattgttgg
+cctcctgctgaccacagctatggcagcggaggtcactagacgtgggagtgcatactatat
+gtacttggacagaaaagatgctggggaggccatatcttttccaaccacattggggatgaa
+taagtgttatatacagatcatggatcttggacacatgtgtgatgccaccatgagctatga
+atgccctatgctggatgagggggtggaaccagatgacgtcgattgttggtgcaacacgac
+gtcaacttgggttgtgtacggaacctgccatcacaaaaaaggtgaagcacggagatctag
+aagagccgtgacgctcccctcccattccactaggaagctgcaaacgcggtcgcaaacctg
+gttggaatcaagagaatacacaaagcacttgattagagtcgaaaattggatattcaggaa
+ccctggtttcgctttagcagcagctgccatcgcttggcttttgggaagctcaacgagcca
+aaaagtcatatacttggtcatgatactgctgattgccccggcatacagcatcaggtgcat
+aggagtcagcaatagggactttgtggaaggtatgtcaggtgggacttgggttgatgttgt
+cttggaacatggaggttgtgtcaccgtaatggcacaggacaaaccgactgtcgacataga
+gctggttacaacaacagtcagcaacatggcggaggtaagatcctactgctatgaggcatc
+aatatcagacatggcttcggacagccgctgcccaacacaaggtgaagcctaccttgacaa
+gcaatcagacactcaatatgtttgcaaaagaacgttagtggacagaggctggggaaatgg
+atgtggactttttggcaaagggagcctggtgacatgcgctaagtttgcatgctccaagaa
+aatgaccgggaagagcatccagccagagaatctggagtaccggataatgttgtcagttca
+tggctcccagcacagtgggatgatcgttaatgacacaggacatgaaactgatgagaatag
+agcgaaggttgagataacgcccaattcaccaagagccgaagccaccctggggggttttgg
+aagcctaggacttgattgtgaaccgaggacaggccttgacttttcagatttgtattactt
+gactatgaataacaagcactggttggttcacaaggagtggttccacgacattccattacc
+ttggcacgctggggcagacaccggaactccacactggaacaacaaagaagcactggtaga
+gttcaaggacgcacatgccaaaaggcaaactgtcgtggttctagggagtcaagaaggagc
+agttcacacggcccttgctggagctctggaggctgagatggatggtgcaaagggaaggct
+gtcctctggccacttgaaatgtcgcctgaaaatggataaacttagattgaagggcgtgtc
+atactccttgtgtaccgcagcgttcacattcaccaagatcccggctgaaacactgcacgg
+gacagtcacagtggaggtacagtacgcagggacagatggaccttgcaaggttccagctca
+gatggcggtggacatgcaaactctgaccccagttgggaggttgataaccgctaaccccgt
+aatcactgaaagcactgagaactctaagatgatgctggaacttgatccaccatttgggga
+ctcttacattgtcataggagtcggggagaagaagatcacccaccactggcataggagtgg
+cagcaccattggaaaagcatttgaagccactgtgagaggtgccaagagaatggcagtctt
+gggagacacagcctgggactttggatcagttggaggcgctctcaactcattgggcaaggg
+catccatcaaatttttggagcagctttcaaatcattgtttggaggaatgtcctggttctc
+acaaattctcattggaacgttgctgatgtggttgggtctgaacacaaagaatggatctat
+ttcccttatgtgcttggccttagggggagtgttgatcttcttatccacagccgtctctgc
+tgatgtggggtgctcggtggacttctcaaagaaggagacgagatgtggtacaggggtgtt
+cgtctataacgacgttgaagcctggagggacaggtacaagtaccatcctgactccccccg
+tagattggcagcagcagtcaagcaagcctgggaagatggtatctgcgggatctcctctgt
+ttcaagaatggaaaacatcatgtggagatcagtagaaggggagctcaacgcaatcctgga
+agagaatggagttcaactgacggtcgttgtgggatctgtaaaaaaccccatgtggagagg
+tccacagagattgcccgtgcctgtgaacgagctgccccacggctggaaggcttgggggaa
+atcgtacttcgtcagagcagcaaagacaaataacagctttgtcgtggatggtgacacact
+gaaggaatgcccactcaaacatagagcatggaacagctttcttgtggaggatcatgggtt
+cggggtatttcacactagtgtctggctcaaggttagagaagattattcattagagtgtga
+tccagccgttattggaacagctgttaagggaaaggaggctgtacacagtgatctaggcta
+ctggattgagagtgagaagaatgacacatggaggctgaagagggcccatctgatcgagat
+gaaaacatgtgaatggccaaagtcccacacattgtggacagatggaatagaagagagtga
+tctgatcatacccaagtctttagctgggccactcagccatcacaataccagagagggcta
+caggacccaaatgaaagggccatggcacagtgaagagcttgaaattcggtttgaggaatg
+cccaggcactaaggtccacgtggaggaaacatgtggaacaagaggaccatctctgagatc
+aaccactgcaagcggaagggtgatcgaggaatggtgctgcagggagtgcacaatgccccc
+actgtcgttctgggctaaagatggctgttggtatggaatggagataaggcccaggaaaga
+accagaaagcaacttagtaaggtcaatggtgactgcaggatcaactgatcacatggatca
+cttctcccttggagtgcttgtgattctgctcatggtgcaggaagggctgaagaagagaat
+gaccacaaagatcatcataagcacatcaatggcagtgctggtagctatgatcctgggagg
+attttcaatgagtgacctggctaagcttgcaattttgatgggtgccaccttcgcggaaat
+gaacactggaggagatgtagctcatctggcgctgatagcggcattcaaagtcagaccagc
+gttgctggtatctttcatcttcagagctaattggacaccccgtgaaagcatgctgctggc
+cttggcctcgtgtcttttgcaaactgcgatctccgccttggagggcgacctgatggttct
+catcaatggttttgctttggcctggttggcaatacgagcgatggttgttccacgcactga
+caacatcaccttggcaatcctggctgctctgacaccactggcccggggcacactgcttgt
+ggcgtggagagcaggccttgctacttgcggggggtttatgctcctctctctgaagggaaa
+aggcagtgtgaagaagaacttaccatttgtcatggccctgggactaaccgctgtgaggct
+ggtcgaccccatcaacgtggtgggactgctgttgctcacaaggagtgggaagcggagctg
+gccccctagcgaagtactcacagctgttggcctgatatgcgcattggctggagggttcgc
+caaggcagatatagagatggctgggcccatggccgcggtcggtctgctaattgtcagtta
+cgtggtctcaggaaagagtgtggacatgtacattgaaagagcaggtgacatcacatggga
+aaaagatgcggaagtcactggaaacagtccccggctcgatgtggcgctagatgagagtgg
+tgatttctccctggtggaggatgacggtccccccatgagagagatcatactcaaggtggt
+cctgatgaccatctgtggcatgaacccaatagccataccctttgcagctggagcgtggta
+cgtatacgtgaagactggaaaaaggagtggtgctctatgggatgtgcctgctcccaagga
+agtaaaaaagggggagaccacagatggagtgtacagagtaatgactcgtagactgctagg
+ttcaacacaagttggagtgggagttatgcaagagggggtctttcacactatgtggcacgt
+cacaaaaggatccgcgctgagaagcggtgaagggagacttgatccatactggggagatgt
+caagcaggatctggtgtcatactgtggtccatggaagctagatgccgcctgggacgggca
+cagcgaggtgcagctcttggccgtgccccccggagagagagcgaggaacatccagactct
+gcccggaatatttaagacaaaggatggggacattggagcggttgcgctggattacccagc
+aggaacttcaggatctccaatcctagacaagtgtgggagagtgataggactttatggcaa
+tggggtcgtgatcaaaaatgggagttatgttagtgccatcacccaagggaggagggagga
+agagactcctgttgagtgcttcgagccttcgatgctgaagaagaagcagctaactgtctt
+agacttgcatcctggagctgggaaaaccaggagagttcttcctgaaatagtccgtgaagc
+cataaaaacaagactccgtactgtgatcttagctccaaccagggttgtcgctgctgaaat
+ggaggaagcccttagagggcttccagtgcgttatatgacaacagcagtcaatgtcaccca
+ctctggaacagaaatcgtcgacttaatgtgccatgccaccttcacttcacgtctactaca
+gccaatcagagtccccaactataatctgtatattatggatgaggcccacttcacagatcc
+ctcaagtatagcagcaagaggatacatttcaacaagggttgagatgggcgaggcggctgc
+catcttcatgaccgccacgccaccaggaacccgtgacgcatttccggactccaactcacc
+aattatggacaccgaagtggaagtcccagagagagcctggagctcaggctttgattgggt
+gacggatcattctggaaaaacagtttggtttgttccaagcgtgaggaacggcaatgagat
+cgcagcttgtctgacaaaggctggaaaacgggtcatacagctcagcagaaagacttttga
+gacagagttccagaaaacaaaacatcaagagtgggactttgtcgtgacaactgacatttc
+agagatgggcgccaactttaaagctgaccgtgtcatagattccaggagatgcctaaagcc
+ggtcatacttgatggcgagagagtcattctggctggacccatgcctgtcacacatgccag
+cgctgcccagaggagggggcgcataggcaggaatcccaataaacctggagatgagtatct
+gtatggaggtgggtgcgcagagactgacgaagaccatgcacactggcttgaagcaagaat
+gctccttgacaatatttacctccaagatggcctcatagcctcgctctatcgacctgaggc
+cgacaaagtagcagccattgagggagagttcaagcttaggacggagcaaaggaagacctt
+tgtggaactcatgaaaagaggagatcttcctgtttggctggcctatcaggttgcatctgc
+cggaataacctacacagatagaagatggtgctttgatggcacgaccaacaacaccataat
+ggaagacagtgtgccggcagaggtgtggaccagacacggagagaaaagagtgctcaaacc
+gaggtggatggacgccagagtttgttcagatcatgcggccctgaagtcattcaaggagtt
+tgccgctgggaaaagaggagcggcttttggagtgatggaagccctgggaacactgccagg
+acacatgacagagagattccaggaagccattgacaacctcgctgtgctcatgcgggcaga
+gactggaagcaggccttacaaagccgcggcggcccaattgccggagaccctagagaccat
+tatgcttttggggttgctgggaacagtctcgctgggaatctttttcgtcttgatgaggaa
+caagggcatagggaagatgggctttggaatggtgactcttggggccagcgcatggctcat
+gtggctctcggaaattgagccagccagaattgcatgtgtcctcattgttgtgttcctatt
+gctggtggtgctcatacctgagccagaaaagcaaagatctccccaggacaaccaaatggc
+aatcatcatcatggtagcagtaggtcttctgggcttgattaccgccaatgaactcggatg
+gttggagagaacaaagagtgacctaagccatctaatgggaaggagagaggagggggcaac
+cataggattctcaatggacattgacctgcggccagcctcagcttgggccatctatgctgc
+cttgacaactttcattaccccagccgtccaacatgcagtgaccacttcatacaacaacta
+ctccttaatggcgatggccacgcaagctggagtgttgtttggtatgggcaaagggatgcc
+attctacgcatgggactttggagtcccgctgctaatgataggttgctactcacaattaac
+acccctgaccctaatagtggccatcattttgctcgtggcgcactacatgtacttgatccc
+agggctgcaggcagcagctgcgcgtgctgcccagaagagaacggcagctggcatcatgaa
+gaaccctgttgtggatggaatagtggtgactgacattgacacaatgacaattgaccccca
+agtggagaaaaagatgggacaggtgctactcatagcagtagccgtctccagcgccatact
+gtcgcggaccgcctgggggtggggggaggctggggccctgatcacagccgcaacttccac
+tttgtgggaaggctctccgaacaagtactggaactcctctacagccacttcactgtgtaa
+catttttaggggaagttacttggctggagcttctctaatctacacagtaacaagaaacgc
+tggcttggtcaagagacgtgggggtggaacaggagagaccctgggagagaaatggaaggc
+ccgcttgaaccagatgtcggccctggagttctactcctacaaaaagtcaggcatcaccga
+ggtgtgcagagaagaggcccgccgcgccctcaaggacggtgtggcaacgggaggccatgc
+tgtgtcccgaggaagtgcaaagctgagatggctggtggagcggggatacctgcagcccta
+tggaaaggtcattgatcttggatgtggcagagggggctggagttactacgccgccaccat
+ccgcaaagttcaagaagtgaaaggatacacaaaaggaggccctggtcatgaagaacccgt
+gttggtgcaaagctatgggtggaacatagtccgtcttaagagtggggtggacgtctttca
+tatggcggctgagccgtgtgacacgttgctgtgtgacataggtgagtcatcatctagtcc
+tgaagtggaagaagcacggacgctcagagtcctctccatggtgggggattggcttgaaaa
+aagaccaggagccttttgtataaaagtgttgtgcccatacaccagcactatgatggaaac
+cctggagcgactgcagcgtaggtatgggggaggactggtcagagtgccactctcccgcaa
+ctctacacatgagatgtactgggtctctggagcgaaaagcaacaccataaaaagtgtgtc
+caccacgagccagctcctcttggggcgcatggacgggcctaggaggccagtgaaatatga
+ggaggatgtgaatctcggctctggcacgcgggctgtggtaagctgcgctgaagctcccaa
+catgaagatcattggtaaccgcattgaaaggatccgcagtgagcacgcggaaacgtggtt
+ctttgacgagaaccacccatataggacatgggcttaccatggaagctatgaggcccccac
+acaagggtcagcgtcctctctaataaacggggttgtcaggctcctgtcaaaaccctggga
+tgtggtgactggagtcacaggaatagccatgaccgacaccacaccgtatggtcagcaaag
+agttttcaaggaaaaagtggacactagggtgccagacccccaagaaggcactcgtcaggt
+tatgagcatggtctcttcctggttgtggaaagagctaggcaaacacaaacggccacgagt
+ctgtaccaaagaagagttcatcaacaaggttcgtagcaatgcagcattaggggcaatatt
+tgaagaggaaaaagagtggaagactgcagtggaagctgtgaacgatccaaggttctgggc
+tctagtggacaaggaaagagagcaccacctgagaggagagtgccagagttgtgtgtacaa
+catgatgggaaaaagagaaaagaaacaaggggaatttggaaaggccaagggcagccgcgc
+catctggtatatgtggctaggggctagatttctagagttcgaagcccttggattcttgaa
+cgaggatcactggatggggagagagaactcaggaggtggtgttgaagggctgggattaca
+aagactcggatatgtcctagaagagatgagtcgcataccaggaggaaggatgtatgcaga
+tgacactgctggctgggacacccgcattagcaggtttgatctggagaatgaagctctaat
+caccaaccaaatggagaaagggcacagggccttggcattggccataatcaagtacacata
+ccaaaacaaagtggtaaaggtccttagaccagctgaaaaagggaaaacagttatggacat
+tatttcgagacaagaccaaagggggagcggacaagttgtcacttacgctcttaacacatt
+taccaacctagtggtgcaactcattcggaatatggaggctgaggaagttctagagatgca
+agacttgtggctgctgcggaggtcagagaaagtgaccaactggttgcagagcaacggatg
+ggataggctcaaacgaatggcagtcagtggagatgaytgcgttgtgaagccaattgatga
+taggtttgcacatgccctcaggttcttgaatgatatgggaaaagttaggaaggacacaca
+agagtggaaaccctcaactggatgggacaactgggaagaagttccgttttgctcccacca
+cttcaacaagctccatctcaaggacgggaggtccattgtggttccctgccgccaccaaga
+tgaactgattggccgggcccgcgtctctccaggggcgggatggagcatccgggagactgc
+ttgcctagcaaaatcatatgcgcaaatgtggcagctcctttatttccacagaagggacct
+ccgactgatggccaatgccatttgttcatctgtgccagttgactgggttccaactgggag
+aactacctggtcaatccatggaaagggagaatggatgaccactgaagacatgcttgtggt
+gtggaacagagtgtggattgaggagaacgaccacatggaagacaagaccccagttgcgaa
+atggacagacattccctatttgggaaaaagggaagacttgtggtgtggatctctcatagg
+gcacagaccgcgcaccacctgggctgagaacattaaaaacacagtcaacatggtgcgcag
+gatcataggtgatgaagaaaagtacatggactacctatccacccaagttcgctacttggg
+cgaagaagggtctacacctggagtgctgtaagcaccaatcttaatgttgtcaggcctgct
+agtcagccacagcttggggaaagctgtgcagcctgtgacccccccaggagaagctgggaa
+accaagcctatagtcaggccgagaacgccatggcacggaagaagccatgctgcctgtgag
+cccctcagaggacactgagtcaaaaaaccccacgcgcttggaggcgcaggatgggaaaag
+aaggtggcgaccttccccacccttcaatctggggcctgaactggagat
+>ZKC2/2016
+agttgttgatctgtgtgaatcagactgcgacagttcgagtttgaagcgaaagctagcaac
+agtatcaacaggttttattttggatttggaaacgagagtttctggtcatgaaaaacccaa
+aaaagaaatccggaggattccggattgtcaatatgctaaaacgcggagtagcccgtgtga
+gcccctttgggggcttgaagaggctgccagccggacttctgctgggtcatgggcccatca
+ggatggtcttggcgattctagccttcttgagattcacggcaatcaagccatcactgggtc
+tcatcaatagatggggttcagtggggaaaaaagaggctatggaaataataaagaagttca
+agaaagatctggctgccatgctgagaataatcaatgctaggaaggagaagaagagacgag
+gcgcagatactaatgtcggaattgttggcctcctgctgaccacagctatggcagcggagg
+tcactagacgtgggagtgcatactatatgtacttggacagaaacgatgctggggaggcca
+tatcttttccaaccacattggggatgaataagtgttatatacagatcatggatcttggac
+acatgtgtgatgccaccatgagctatgaatgccctatgctggatgagggggtggaaccag
+atgacgtcgattgttggtgcaacacgacgtcaacttgggttgtgtacggaacctgccatc
+acaaaaaaggtgaagcacggagatctagaagagctgtgacgctcccctcccattccacta
+ggaagctgcaaacgcggtcgcaaacttggttggaatcaagagaatacacaaagcacttga
+ttagagtcgaaaattggatattcaggaaccctggcttcgcgttagcagcagctgccatcg
+cttggcttttgggaagctcaacgagccaaaaagtcatatacttggtcatgatactgctga
+ttgccccggcatacagcatcaggtgcataggagtcagcaatagggactttgtggaaggta
+tgtcaggtgggacttgggttgatgttgtcttggaacatggaggttgtgtcaccgtaatgg
+cacaggacaaaccgactgtcgacatagagctggttacaacaacagtcagcaacatggcgg
+aggtaagatcctactgctatgaggcatcaatatcggacatggcttcggacagccgctgcc
+caacacaaggtgaagcctaccttgacaagcaatcagacactcaatatgtctgcaaaagaa
+cgttagtggacagaggctggggaaatggatgtggactttttggcaaagggagcctggtga
+catgcgctaagtttgcatgctccaagaaaatgaccgggaagagcatccagccagagaatc
+tggagtaccggataatgctgtcagttcatggctcccagcacagtgggatgatcgttaatg
+acacaggacatgaaactgatgagaatagagcgaaggttgagataacgcccaattcaccaa
+gagccgaagccaccctggggggttttggaagcctaggacttgattgtgaaccgaggacag
+gccttgacttttcagatttgtattacttgactatgaataacaagcactggttggttcaca
+aggagtggttccacgacattccattaccttggcacgctggggcagacaccggaactccac
+actggaacaacaaagaagcactggtagagttcaaggacgcacatgccaaaaggcaaactg
+tcgtggttctagggagtcaagaaggagcagttcacacggcccttgctggagctctggagg
+ctgagatggatggtgcaaagggaaggctgtcctctggccacttgaaatgtcgcctgaaaa
+tggataaacttagattgaagggcgtgtcatactccttgtgtaccgcagcgttcacattca
+ccaagatcccggctgaaacactgcacgggacagtcacagtggaggtacagtacgcaggga
+cagatggaccttgcaaggttccagctcagatggcggtggacatgcaaactctgaccccag
+ttgggaggctgataaccgctaaccccgtaatcactgaaagcactgagaactccaagatga
+tgctggaacttgatccaccatttggggactcttacattgtcataggagtcggggagaaga
+agatcacccaccactggcacaggagtggcagcaccattggaaaagcatttgaagccactg
+tgagaggtgccaggagaatggcagtcttgggagacacagcctgggactttggatcagttg
+gaggcgctctcaactcattgggcaagggcatccatcaaatttttggagcagctttcaaat
+cattgtttggaggaatgtcctggttctcacaaattctcattggaacgttgctgatgtggt
+tgggtctgaacacaaagaatggatctatttcccttatgtgcttggccttagggggagtgt
+tgatcttcttatccacagccgtctctgctgatgtggggtgctcggtggacttctcaaaga
+aggagacgagatgcggtacaggggtgttcgtctataacgacgttgaagcctggagggaca
+ggtacaagtaccatcctgactccccccgtagattggcagcagcagtcaagcaagcctggg
+aagatggtatctgtgggatctcctctgtttcaagaatggaaaacatcatgtggagatcag
+tagaaggggagctcaacgcaatcctggaagagaatggagttcaactgacggtcgttgtgg
+gatctgtaaaaaaccccatgtggagaggtccacagagattgcccgtgcctgtgaacgagc
+tgccccacggctggaaggcttgggggaaatcgtacttcgtcagagcagcaaagacaaata
+acagctttgtcgtggatggtgacacactgaaggaatgcccactcaaacatagagcatgga
+acagctttcttgtggaggatcatgggttcggggtatttcacactagtgtctggctcaagg
+ttagagaagattattcattagagtgtgatccagccgttattggaacagctgttaagggaa
+aggaggctgtacacagtgatctaggctactggattgagagtgagaagaatgacacatgga
+ggctgaagagggcccatctgatcgagatgaaaacatgtgaatggccaaagtcccacacat
+tgtggacagatggaatagaagagagtgatctgatcatacccaagtctttagctgggccac
+tcagccatcacaataccagagagggctacaggacccaaatgaaagggccatggcacagtg
+aagagcttgaaattcggtttgaggaatgcccaggcaccaaggtccacgtggaggaaacat
+gtggaacaagaggaccatctctgagatcaaccactgcaagcggaagggtgatcgaggaat
+ggtgctgcagggagtgcacaatgcccccactgtcgttccaggctaaagatggctgttggt
+atggaatggagataaggcccaggaaagaaccagaaagtaacttagtaaggtcaatggtga
+ctgcaggatcaactgatcacatggatcacttctcccttggagtgcttgtgattctgctca
+tggtgcaggaagggctgaagaagagaatgaccacaaagatcatcataagcacatcaatgg
+cagtgctggtagctatgatcctgggaggattttcaatgagtgacctggctaagcttgcaa
+ttttgatgggtgccaccttcgcggaaatgaacactggaggagatgtagctcatctggcgc
+tgatagcggcattcaaagtcagaccagcgttgctggtatctttcatcttcagagctaatt
+ggacaccccgtgaaagcatgctgctggccttggcctcgtgtcttttgcaaactgcgatct
+ccgccttggaaggcgacctgatggttctcatcaatggttttgctttggcctggttggcaa
+tacgagcgatggttgttccacgcactgataacatcaccttggcaatcctggctgctctga
+caccactggcccggggcacactgcttgtggcgtggagagcaggccttgctacttgcgggg
+ggtttatgctcctctctctgaagggaaaaggcagtgtgaagaagaacttaccatttgtca
+tggccctgggactaaccgctgtgaggctggtcgaccccatcaacgtggtgggactgctgt
+tgctcacaaggagtgggaagcggagctggccccctagcgaagtactcacagctgttggcc
+tgatatgcgcattggctggagggttcgccaaggcagatatagagatggctgggcccatgg
+ccgcggtcggtctgctaattgtcagttacgtggtctcaggaaagagtgtggacatgtaca
+ttgaaagagcaggtgacatcacatgggaaaaagatgcggaagtcactggaaacagtcccc
+ggcttgatgtggcgctagatgagagtggtgatttctccctggtggaggatgacggtcccc
+ccatgagagagatcatactcaaggtggtcctgatgaccatctgtggcatgaacccaatag
+ccataccctttgcagctggagcgtggtacgtatacgtgaagactggaaaaaggagtggag
+ctctatgggatgtgcctgctcccaaggaagtaaaaaagggggagaccacagatggagtgt
+acagagtgatgactcgtagactgctaggttcaacacaagttggagtgggagttatgcaag
+agggggtctttcacaccatgtggcacgtcacaaaaggatccgcgctgagaagcggtgaag
+ggagacttgatccatactggggagatgtcaagcaggatctggtgtcatactgtggtccat
+ggaagctagatgccgcctgggacgggcacagcgaggtgcagctcttggccgtgccccccg
+gagagagagcgaggaacatccagactctgcccggaatatttaagacaaaggatggggaca
+ttggagcggttgcgctggattacccagcaggaacttcaggatctccaatcctagacaagt
+gtgggagagtgataggactttatggcaatggggtcgtgatcaaaaatgggagttatgtta
+gtgccatcacccaagggaggagggaggaagagactcctgttgagtgcttcgagccttcga
+tgctgaagaagaagcagctaactgtcttagacttgcatcctggagctgggaaaaccagga
+gagttcttcctgaaatagtccgtgaagccataaaaacaagactccgtactgtgatcttag
+ctccaaccagggttgtcgctgccgaaatggaggaagcccttagagggcttccagtgcgtt
+atatgacaacagcagtcaatgtcacccactctggaacagaaatcgtcgacttaatgtgcc
+atgccaccttcacttcacgtctactacagccaatcagagtccccaactataatctgtata
+ttatggatgaggcccacttcacagatccctcaagtatagcagcaagaggatacatttcaa
+caagggttgagatgggcgaggcggctgccatcttcatgaccgccacgccaccaggaaccc
+gtgacgcatttccggactccaactcaccaattatggacaccgaagtggaagtcccagaga
+gagcctggagctcaggctttgattgggtgacggatcattctggaaaaacagtctggtttg
+ttccaagcgtgaggaacggcaatgagatcgcagcttgtctgacaaaggctggaaaacggg
+tcatacagctcagcagaaagacttttgagacagagttccagaaaacaaaacatcaagagt
+gggactttgtcgtgacaactgacatttcagagatgggcgccaactttaaagctgaccgtg
+tcatagattccaggagatgcctaaagccggtcatacttgatggcgagagagtcattctgg
+ctggacccatgcctgtcacacatgccagcgctgcccagaggagggggcgcataggcagga
+atcccaacaaacctggagatgagtatctgtatggaggtgggtgcgcagagactgacgaag
+accatgcacactggcttgaagcaagaatgctccttgacaatatttacctccaagatggcc
+tcatagcctcgctctatcgacctgaggccgacaaagtagcagccattgagggagagttca
+agcttaggacggagcaaaggaagacctttgtggaactcatgaaaagaggagatcttcctg
+tttggctggcctatcaggttgcatctgccggaataacctacacagatagaagatggtgct
+ttgatggcacgaccaacaacaccataatggaagacagtgtgccggcagaggtgtggacca
+gacacggagagaaaagagtgctcaaaccgaggtggatggacgccagagtttgttcagatc
+acgcggccctgaagtcattcaaggagtttgccgctgggaaaagaggagcggcttttggag
+tgatggaagccttgggaacactgccaggacacatgacagagagattccaggaagccattg
+acaacctcgctgtgctcatgcgggcagagactggaagcaggccttacaaagccgcggcgg
+cccaattgccggagaccctagagaccattatgcttttggggttgctgggaacagtctcgc
+tgggaatctttttcgtcttgatgaggaacaagggcatagggaagatgggctttggaatgg
+tgactcttggggccagcgcatggctcatgtggctctcggaaattgagccagccagaattg
+catgtgtcctcattgttgtgttcctattgctggtggtgctcatacctgagccagaaaagc
+aaagatctccccaggacaaccaaatggcaatcatcatcatggtagcagtaggtcttctgg
+gcttgattaccgccaatgaactcggatggttggagagaacaaagagtgacctaagccatc
+taatgggaaggagagaggagggggcaaccataggattctcaatggacattgacctgcggc
+cagcctcagcttgggccatctacgctgccttgacaactttcattaccccagccgtccaac
+atgcagtgaccacttcatacaacaactactccttaatggcgatggccacgcaagctggag
+tgttgtttggtatgggcaaagggatgccattctacgcatgggactttggagtcccgctgc
+taatgataggttgctactcacaattaacacccctgaccctaatagtagccatcattttgc
+tcgtggcgcactacatgtacttgatcccagggctgcaggcagcagctgcgcgtgctgccc
+agaagagaacggcagctggcatcatgaagaaccctgttgtggatggaatagtggtgactg
+acattgacacaatgacaattgacccccaagtggagaaaaagatgggacaggtgctactca
+tagcagtagccgtctccagcgccatactgtcgcggaccgcctgggggtggggggaggctg
+gggccctgatcacagctgcaacttccactttgtgggaaggctctccgaacaagtactgga
+actcctctacagccacttcactgtgtaacatttttaggggaagttacttggctggagctt
+ctctaatctacacagtaacaagaaacgctggcttggtcaagagacgtgggggtggaacag
+gagagaccctgggagagaaatggaaggcccgcttgaaccagatgtcggccctggagttct
+actcctacaaaaagtcaggcatcaccgaggtgtgcagagaagaggcccgccgcgccctca
+aggacggtgtggcaacgggaggccatgctgtgtcccgaggaagtgcaaagctgagatggt
+tggtggagcggggatacctgcagccctatggaaaggtcattgatcttggatgtggcagag
+ggggctggagttactacgccgccaccatccgcaaagttcaagaagtgaaaggatacacaa
+aaggaggccctggtcatgaagaacccatgttggtgcaaagctatgggtggaacatagtcc
+gtcttaagagtggggtggacgtctttcatatggcggctgagccgtgtgacacgttgctgt
+gtgacataggtgagtcatcatctagtcctgaagtggaagaagcacggacgctcagagtcc
+tttccatggtgggggattggcttgaaaaaagaccaggagccttttgtataaaagtgttgt
+gcccatacaccagcactatgatggaaaccctggagcgactgcagcgtaggtatgggggag
+gactggtcagagtgccactctcccgcaactctacacatgagatgtactgggtctctggag
+cgaaaagcaacaccataaaaagtgtgtccaccacgagccagctcctcttggggcgcatgg
+acgggcccaggaggccagtgaaatatgaggaggatgtgaatctcggctctggcacgcggg
+ctgtggtaagctgcgctgaagctcccaacatgaagatcattggtaaccgcattgaaagga
+tccgcagtgagcacgcggaaacgtggttctttgacgagaaccacccatataggacatggg
+cttaccatggaagctatgaggcccccacacaagggtcagcgtcctctctaataaacgggg
+ttgtcaggctcctgtcaaaaccctgggacgtggtgactggagtcacaggaatagccatga
+ccgacaccacaccgtatggtcagcaaagagttttcaaggaaaaagtggacactagggtgc
+cagatccccaagaaggcactcgtcaggttatgagcatggtctcttcctggttgtggaaag
+agctaggcaaacacaaacggccacgagtctgtaccaaagaagagttcatcaacaaggttc
+gtagcaatgcagcattaggggcaatatttgaagaggaaaaagagtggaagactgcagtgg
+aagctgtgaacgatccaaggttctgggctctagtggacaaggaaagagagcaccacctga
+gaggagagtgccagagttgtgtgtacaacatgatgggaaaaagagaaaagaaacaagggg
+aatttggaaaggccaagggcagccgcgccatctggtatatgtggctaggggctagatttc
+tagagttcgaagcccttggattcttgaacgaggatcactggatggggagagagaactcag
+gaggtggtgttgaagggctgggattacaaagactcggatatgtcctagaagagatgagtc
+gcataccaggaggaaggatgtatgcagatgacactgctggctgggacacccgcatcagca
+ggtttgatctggagaatgaagctctaatcaccaaccaaatggagaaagggcacagggcct
+tggcattggccataatcaagtacacataccaaaacaaagtggtaaaggtccttagaccag
+ctgaaaaagggaagacagttatggacattatttcgagacaagaccaaagggggagcggac
+aagttgtcacttacgctcttaacacatttaccaacctagtggtgcaactcattcggagta
+tggaggctgaggaagttctagagatgcaagacttgtggctgctgcggaggtcagagaaag
+tgaccaactggctgcagagcaacggatgggataggctcaaacgaatggcagtcagtggag
+atgattgcgttgtgaggccaattgatgataggtttgcacatgccctcaggttcttgaatg
+atatggggaaagttaggaaggacacacaagagtggaaaccctcaactggatgggacaact
+gggaggaagttccgttttgctcccaccacttcaacaagctccatctcaaggacgggaggt
+ccattgtggttccctgccgccaccaagatgaactgattggccgggcccgcgtctctccag
+gggcgggatggagcatccgggagactgcttgcctagcaaaatcatatgcgcaaatgtggc
+agctcctttatttccacagaagggacctccgactgatggccaatgccatttgttcatctg
+tgccagttgactgggttccaactgggagaactacctggtcaatccatggaaagggagaat
+ggatgaccactgaagacatgcttgtggtgtggaacagagtgtggattgaggagaacgacc
+acatggaagacaagaccccagttacgaaatggacagacattccctatttgggaaaaaggg
+aagacttgtggtgtggatctctcatagggcacagaccgcgcaccacctgggctgagaaca
+ttaaaaacacagtcaacatggtgcgcaggatcataggtgatgaagaaaagtacatggact
+acctatccacccaagttcgctacttgggtgaagaagggtctacacctggagtgctgtaag
+caccaatcttagtgttgtcaggcctgctagtcagccacagcttggggaaagctgtgcagc
+ctgtgacccccccaggagaagctgggaaaccaagcctatagtcaggccgagaacgccatg
+gcacggaagaagccatgctgcctgtgagcccctcagaggacactgagtcaaaaaacccca
+cgcgcttggaggcgcaggatgggaaaagaaggtggcgaccttccccaccctttaatctgg
+ggcctgaactggagatcagctgtggatctccagaagagggactagtggttagaggagacc
+ccccggaaaacgcaaaacagcatattgacgctgggaaagaccagagactccatgagtttc
+caccacgctggccgccaggcacagatcgccgaatagcggcggccggtgtggggaaatcca
+tgggtct
+>VEN/UF_1/2016
+agttgttactgttgctgactcagactgcgacagttcgagtttgaagcgaaagctagcaac
+agtatcaacaggttttattttggatttggaaacgagagtttctggtcatgaaaaacccaa
+aaaagaaatccggaggattccggattgtcaatatgctaaaacgcggagtagcccgtgtga
+gcccctttgggggcttgaagaggctgccagccggacttctgctgggtcatgggcccatca
+ggatggtcttggcgattctagcctttttgagattcacggcaatcaagccatcactgggtc
+tcatcaatagatggggttcagtggggaaaaaagatgctatggaaataataaagaagttca
+agaaagatctggctgccatgctgagaataatcaatgctaggaaggagaagaagagacgag
+gcgcagaaactagtgtcggaattgttggcctccttctgaccacagctatggcagcggagg
+tcactagacgtgggagtgcatactatatgtacttggacagaaacgatgctggggaggcca
+tatcttttccaaccacattggggatgaataagtgttatatacagatcatggatcttggac
+acatgtgtgatgccaccatgagctatgaatgccctatgctggatgagggggtggaaccag
+atgacgtcgattgttggtgcaacacgacgtcaacttgggttgtgtacggaacctgccatc
+acaaaaaaggtgaagcacggagatctagaagagccgtgacgctcccctcccattccacta
+ggaagctgcaaacgcggtcgcaaacctggttggaatcaagagaatacacaaagcacttga
+ttagagtcgaaaattggatattcaggaaccctggtttcgctttagcagcagctgccatcg
+cttggcttttgggaagctcaacgagccaaaaagtcatatacttggtcatgatactgctga
+ttgccccggcatacagcatcaggtgcataggagtcagcaatagggactttgtggaaggta
+tgtcaggtgggacttgggttgatgtcgtcttggaacatggaggttgtgtcaccgtaatgg
+cacaggacaaaccgactgtcgacatagagctggttacaacaacagtcagcaacatggcgg
+aggtaagatcctactgctatgaggcatcaatatcagacatggcttcggacagccgctgcc
+caacacaaggtgaagcctaccttgacaagcaatcagacactcaatatgtttgcaaaagaa
+cgttagtggacagaggctggggaaatggatgtggactttttggcaaagggagcctggtga
+catgcgctaagtttgcatgctccaagaaaatgaccgggaagagcatccagccagagaatc
+tggagtaccggataatgttgtcagttcatggctcccagcacagtgggatgattgttaatg
+acacaggacatgaaactgatgagaatagagcgaaggttgagataacgcccaattcaccaa
+gagccgaagccaccctggggggttttggaagcctaggacttgattgtgaaccgaggacag
+gccttgacttttcagatttgtattacttgactatgaataacaagcactggttggttcaca
+aggagtggttccacgacattccattaccttggcacgctggggcagacaccggaactccac
+actggaacaacaaagaagcactggtagagttcaaggacgcacatgccaaaaggcaaactg
+tcgtggttctagggagtcaagaaggagcagttcacacggcccttgctggagctctggagg
+ctgagatggatggtgcaaagggaaggctgtcctctggccacttgaaatgtcgcctgaaaa
+tggataaacttagattgaagggcgtgtcatactccttgtgtaccgcagcgttcacattca
+ccaagatcccggctgaaacactgcacgggacagtcacagtggaggtacagtacgcaggga
+cagatggaccttgcaaggttccagctcagatggcggtggacatgcaaactctgaccccag
+ttgggaggttgataaccgctaaccccgtaatcactgaaagcactgagaactctaagatga
+tgctggaacttgatccaccatttggggactcttacattgtcataggagtcggggagaaga
+agatcacccaccactggcacaggagtggcagcaccattggaaaagcatttgaagccactg
+tgagaggtgccaagagaatggcagtcttgggagacacagcctgggactttggatcagttg
+gaggcgctctcaactcattgggcaagggcatccatcaaatttttggagcagctttcaaat
+cattgtttggaggaatgtcctggttctcacaaattctcattggaacgttgctgatgtggt
+tgggtctgaacacaaagaatggatctatttcccttatgtgcttggccttagggggagtgt
+tgatcttcttatccacagccgtctctgctgatgtggggtgctcggtggacttctcaaaga
+aggagacgagatgtggtacaggggtgttcgtctataacgacgttgaagcctggagggaca
+ggtacaagtaccatcctgactccccccgtagattggcagcagcagtcaagcaagcctggg
+aagatggtatctgcgggatctcctctgtttcaagaatggaaaacatcatgtggagatcag
+tagaaggggagctcaacgcaatcctggaagagaatggagttcaactgacggtcgttgtgg
+gatctgtaaaaaaccccatgtggagaggtccacagagattgcccgtgcctgtgaacgagc
+tgccccacggctggaaggcttgggggaaatcgtacttcgtcagagcagcaaagacaaata
+acagctttgtcgtggatggtgacacactgaaagaatgcccactcaaacatagagcatgga
+acagctttcttgtggaggatcatgggttcggggtatttcacactagtgtctggctcaagg
+ttagagaagattattcattagagtgtgatccagccgttattggaacagctgttaagggaa
+aggaggctgtacacagtgatctaggctactggattgagagtgagaagaatgacacatgga
+ggctgaagagggcccatctgatcgagatgaaaacatgtgaatggccaaagtcccacacat
+tgtggacagatggaatagaagagagtgatctgatcatacccaagtctttagctgggccac
+tcagccatcacaataccagagagggctacaggacccaaatgaaagggccatggcacagtg
+aagagcttgaaattcggtttgaggaatgcccaggcactaaggtccacgtggaggaaacat
+gtggaacaagaggaccatctctgagatcacccactgcaagcggaagggtgatcgaggaat
+ggtgctgcagggagtgcacaatgcccccactgtcgttctgggctaaagatggctgttggt
+atggaatggagataaggcccaggaaagaaccagaaagcaacttagtaaggtcaatggtga
+ctgcaggatcaactgatcacatggatcacttctcccttggagtgcttgtgattctgctca
+tggtgcaggaagggctgaagaagagaatgaccacaaagatcatcataagcacatcaatgg
+cagtgctggtagctatgatcctgggaggattttcaatgagtgacctggctaagcttgcaa
+tcttgatgggtgccaccttcgcggaaatgaacactggaggagatgtagctcatctggcgc
+tgatagcggcattcaaagtcagaccagcgttgctggtatccttcatcttcagagctaatt
+ggacaccccgtgaaagcatgctgctggccttggcctcgtgtcttttgcaaactgcgatct
+ccgccttggagggcgacctgatggttctcatcaatggttttgctttggcctggttggcaa
+tacgagcgatggttgttccacgcactgacaacatcaccttggcaatcctggctgctctga
+caccactggcccggggcacactgcttgtggcgtggagagcaggccttgctacttgcgggg
+ggtttatgctcctctctctgaagggaaaaggcagtgtgaagaagaacttaccatttgtca
+tggccctgggactaaccgctgtgaggctggtcgaccccatcaacgtggtgggactgctgt
+tgctcacaaggagtgggaagcggagctggccccctagcgaagtactcacagctgttggcc
+tgatatgcgcattggctggagggttcgccaaggcagatatagagatggctgggcccatgg
+ccgcggttggtctgctaattgtcagttacgtggtctcaggaaagagtgtggacatgtaca
+ttgaaagagcaggtgacatcacatgggaaaaagatgcggaagtcactggaaacagtcccc
+ggctcgatgtggcgctagatgagagtggtgatttctccctggtggaggatgacggtcccc
+ccatgagagagatcatactcaaggtggtcctgatgaccatctgtggcatgaacccaatag
+ccataccctttgcagctggagcgtggtacgtatacgtgaagactggaaaaaggagtggtg
+cgctatgggatgtgcctgctcccaaggaagtaaaaaagggggagaccacagatggagtgt
+acagagtaatgactcgtagactgctaggttcaacacaagttggagtgggagttatgcaag
+agggggtctttcacactatgtggcacgtcacaaaaggatccgcgctgagaagcggtgaag
+ggagacttgatccatactggggagatgtcaagcaggatctggtgtcatactgtggtccat
+ggaagctagatgccgcctgggacgggcacagcgaggtgcagctcttggccgtgccccccg
+gagagagagcgaggaacatccagactctgcccggaatatttaagacaaaggatggggaca
+ttggagcggttgcgctggattacccagcaggaacttcaggatctccaatcctagacaagt
+gtgggagagtgataggactttatggcaatggggtcgtgatcaaaaatgggagttatgtta
+gtgccatcacccaagggaggagggaggaagagactcctgttgagtgcttcgagccttcga
+tgctgaagaagaagcagctaactgtcttagacttgcatcctggagctgggaaaaccagga
+gagttcttcctgaaatagtccgtgaagccataaaaacaagactccgtactgtgatcttag
+ctccaaccagggttgtcgctgctgaaatggaggaagcccttagagggcttccagtgcgtt
+atatgacaacagcagtcaatgtcacccactctggaacagaaatcgtcgacttaatgtgcc
+atgccaccttcacttcacgtctactacagccaatcagagtccccaactataatctgtata
+ttatggatgaggcccacttcacagatccctcaagtatagcagcaagaggatacatttcaa
+caagggttgagatgggcgaggcggctgccatcttcatgaccgccacgccaccaggaaccc
+gtgacgcatttccggactccaactcaccaattatggacaccgaagtggaagtcccagaga
+gagcctggagctcaggctttgattgggtgacggatcattctggaaaaacagtttggtttg
+ttccaagcgtgaggaacggcaatgagatcgcagcttgtctgacaaaggctggaaaacggg
+tcatacagctcagcagaaagacttttgagacagagttccagaaaacaaaacatcaagagt
+gggactttgtcgtgacaactgacatttcagagatgggcgccaactttaaagctgaccgtg
+tcatagattccaggagatgcctaaagccggtcatacttgatggcgagagagtcattctgg
+ctggacccatgcctgtcacacatgccagcgctgcccagaggagggggcgcataggcagga
+atcccaataaacctggagatgagtatctgtatggaggtgggtgcgcagagactgacgaag
+accatgcacactggcttgaagcaagaatgctccttgacaatatttacctccaagatggcc
+tcatagcctcgctctatcgacctgaggccgacaaagtagcagccattgagggagagttca
+agcttaggacggagcaaaggaagacctttgtggaactcatgaaaagaggagatcttcctg
+tttggctggcctatcaggttgcatctgccggaataacctacacagatagaagatggtgct
+ttgatggcacgaccaacaacaccataatggaagacagtgtgccggcagaggtgtggacca
+gacacggagagaaaagagtgctcaaaccgaggtggatggacgccagagtttgttcagatc
+atgcggccctgaagtcattcaaggagtttgccgctgggaaaagaggagcggcttttggag
+tgatggaagccctgggaacactgccaggacacatgacagagagattccaggaagccattg
+acaacctcgctgtgctcatgcgggcagagactggaagcaggccttacaaagccgcggcgg
+cccaattgccggagaccctagagaccattatgcttttggggttgctgggaacagtctcgt
+tgggaatctttttcgtcttgatgaggaacaagggcatagggaagatgggctttggaatgg
+tgactcttggggccagcgcatggctcatgtggctctcggaaattgagccagccagaattg
+catgtgtcctcattgttgtgttcctattgctggtggtgctcatacctgagccagaaaagc
+aaagatctccccaggacaaccaaatggcaatcatcatcatggtagcagtaggtcttctgg
+gcttgattaccgccaatgaactcggatggttggagagaacaaagagtgacctaagccatc
+taatgggaaggagagaggagggggcaaccataggattctcaatggacattgacctgcggc
+cagcctcagcttgggccatctatgctgccttgacaactttcattaccccagccgtccaac
+atgcagtgaccacttcatacaacaactactccttaatggcgatggccacgcaagctggag
+tgttgtttggtatgggcaaagggatgccattctacgcatgggactttggagtcccgctgc
+taatgataggttgctactcacaattaacacccctgaccctaatagtggccatcattttgc
+tcgtggcgcactacatgtacttgatcccagggctgcaggcagcagctgcgcgtgctgccc
+agaagagaacggcagctggcatcatgaagaaccctgttgtggatggaatagtggtgactg
+acattgacacaatgacaattgacccccaagtggagaaaaagatgggacaggtgctactca
+tagcagtagccgtctccagcgccatactgtcgcggaccgcctgggggtggggggaggctg
+gggccctgatcacagccgcaacttccactttgtgggaaggctctccgaacaagtactgga
+actcctctacagccacttcactgtgtaacatttttaggggaagttacttggctggagctt
+ctctaatctacacagtaacaagaaacgctggcttggtcaagagacgtgggggtggaacag
+gagagaccctgggagagaaatggaaggcccgcttgaaccagatgtcggccctggagttct
+actcctacaaaaagtcaggcatcaccgaggtgtgcagagaagaggcccgccgcgccctca
+aggacggtgtggcaacgggaggccatgctgtgtcccgaggaagtgcaaagctgagatggt
+tggtggagcggggatacctgcagccctatggaaaggtcattgatcttggatgtggcagag
+ggggctggagttactacgccgccaccatccgcaaagttcaagaagtgaaaggatacacaa
+aaggaggccctggtcatgaagaacccgtgttggtgcaaagctatgggtggaatatagtcc
+gtcttaagagtggggtggacgtctttcatatggcggctgagccgtgtgacacgttgctgt
+gtgacataggtgagtcatcatctagtcctgaagtggaagaagcacggacgctcagagtcc
+tctccatggtgggggattggcttgaaaaaagaccaggagccttttgtataaaagtgttgt
+gcccatacaccagcactatgatggaaaccctggagcgactgcagcgtaggtatgggggag
+gactggtcagagtgccactctcccgcaactctacacatgagatgtactgggtctctggag
+cgaaaagcaacaccataaaaagtgtgtccaccacgagccagctcctcttggggcgcatgg
+acgggcctaggaggccagtgaaatatgaggaggatgtgaatctcggctctggcacgcggg
+ctgtggtaagctgcgctgaagctcccaacatgaagatcattggtaaccgcattgaaagga
+tccgcagtgagcacgcggaaacgtggttctttgacgagaaccacccatataggacatggg
+cttaccatggaagctatgaggcccccacacaagggtcagcgtcctctctaataaacgggg
+ttgtcaggctcctgtcaaaaccctgggatgtggtgactggagtcacaggaatagccatga
+ccgacaccacaccgtatggtcagcaaagagttttcaaggaaaaagtggacactagggtgc
+cagacccccaagaaggcactcgtcaggttatgagcatggtctcttcctggttgtggaaag
+agctaggcaaacacaaacggccacgagtctgtaccaaagaagagttcatcaacaaggtgc
+gtagcaatgcagcattaggggcaatatttgaagaggaaaaagagtggaagactgcagtgg
+aagctgtgaacgatccaaggttctgggctctagtggacaaggaaagagagcaccacctga
+gaggagagtgccagagttgtgtgtacaacatgatgggaaaaagagaaaagaaacaagggg
+aatttggaaaggccaagggcagccgcgccatctggtatatgtggctaggggctagatttc
+tagagttcgaagcccttggattcttgaacgaggatcactggatggggagagagaactcag
+gaggtggtgttgaagggctgggattacaaagactcggatatgtcctagaagagatgagtc
+gcataccaggaggaaggatgtatgcagatgacactgctggctgggacacccgcattagca
+ggtttgatctggagaatgaagctctaatcaccaaccaaatggagaaagggcacagggcct
+tggcattggccataatcaagtacacataccaaaacaaagtggtaaaggtccttagaccag
+ctgaaaaagggaaaacagttatggacattatttcgagacaagaccaaagggggagcggac
+aagttgtcacttacgctcttaacacatttaccaacctagtggtgcaactcattcggaata
+tggaggctgaggaagttctagagatgcaagacttgtggctgctgcggaggtcagagaaag
+tgaccaactggttgcagagcaacggatgggataggctcaaacgaatggcagtcagtggag
+atgattgcgttgtgaagccaattgatgataggtttgcacatgccctcaggttcttgaatg
+atatgggaaaagttaggaaggacacacaagagtggaaaccctcaactggatgggacaact
+gggaagaagttccgttttgctcccaccacttcaacaagctccatctcaaggacgggaggt
+ccattgtggttccctgccgccaccaagatgaactgattggccgggcccgcgtctctccag
+gggcgggatggagcatccgggagactgcttgcctagcaaaatcatatgcgcaaatgtggc
+agctcctttatttccacagaagggacctccgactgatggccaatgccatttgttcatctg
+tgccagttgactgggttccaactgggagaactacctggtcaatccatggaaagggagaat
+ggatgaccactgaagacatgcttgtggtgtggaacagagtgtggattgaggagaacgacc
+acatggaagacaagaccccagttacgaaatggacagacattccctatttgggaaaaaggg
+aagacttgtggtgtggatctctcatagggcacagaccgcgcaccacctgggctgagaaca
+ttaaaaacacagtcaacatggtgcgcaggatcataggtgatgaagaaaagtacatggact
+acctatccacccaagttcgctacttgggtgaagaagggtctacacctggagtgctgtaag
+caccaatcttaatgttgtcaggcctgctagtcagccacagcttggggaaagctgtgcagc
+ctgtgacccccccaggagaagctgggaaaccaagcctatagtcaggccgagaacgccatg
+gcacggaagaagccatgctgcctgtgagcccctcagaggacactgagtcaaaaaacccca
+cgcgcttggaggcgcaggatgggaaaagaaggtggcgaccttccccacccttcaatctgg
+ggcctgaactggagatcagctgtggatctccagaagagggactagtggttagaggagacc
+ccccggaaaacgcaaaacagcatattgacgctgggaaagaccagagactccatgagtttc
+caccacgctggccgccaggcacagatcgccgaatagcggcggccggtgtggggaaatcca
+tgggtctt
+>DOM/2016/BB_0059
+tggctgccatgctgagaataatcaatgctaggaaggagaagaagagacgaggcgcagata
+ctagtgtcggaattgttggcctcctgctgaccacagctatggcagcggaggtcactagac
+gtgggagtgcatactacatgtacttggacagaaacgatgctggggaggccatatctttcc
+caaccacattggggatgaataagtgttatatacagatcatggatcttggacacatgtgtg
+atgccaccatgagctatgaatgccctatgctggatgagggggtggaaccagatgacgtcg
+attgttggtgcaacacgacgtcaacttgggttgtgtacggaacctgccatcacaaaaaag
+gtgaagcacggagatctagaagagctgtgacgctcccctcccattccactaggaagctgc
+aaacgcggtcgcaaacctggttggaatcaagagaatacacaaagcacttgattagagtcg
+aaaattggatattcaggaaccctggcttcgcgttagcagcagctgccatcgcttggcttt
+tgggaagctcaacgagccaaaaagtcatatacttggtcatgatactgctgattgccccgg
+catacagcatcaggtgcataggagtcagcaatagggactttgtggaaggtatgtcaggtg
+ggacttgggttgatgttgtcttggaacatggaggttgtgtcaccgtaatggcacaggaca
+aaccgactgtcgacatagagctggttacaacaacagtcagcaacatggcggaggtaagat
+cctactgctatgaggcatcaatatcagacatggcttcggacagccgctgcccaacacaag
+gtkaagcctaccttgacaagcaatcagacactcaatatgtctgcaaaagaacgttagtgg
+acagaggctggggaaatggatgtggactttttggcaaagggagcctggtgacatgcgcta
+agtttgcatgctccaagaaaatgaccgggaagagcatccagccagagaatctggagtacc
+ggataatgctgtcagttcatggctcccagcacagtgggatgatcgttaatgacacaggac
+atgaaactgatgagaatagagcgaaggttgagataacgcccaattcaccaagagccgaag
+ccaccctggggggttttggaagcctaggactggattgtgaaccgaggacaggccttgact
+tttcagatttgtattacttgactatgaataacaagcactggttggttcacaaggagtggt
+tccacgacattccattaccttggcacgctggggcagacaccggaactccacactggaaca
+acaaagaagcactggtagagttcaaggacgcacatgccaaaaggcaaactgtcgtggttc
+tagggagtcaagaaggagcagttcacacggcccttgctggagctctggaggctgagatgg
+atggtgcaaagggaaggctgtcctctggccacttgaaatgtcgcctgaaaatggataaac
+ttagattgaagggcgtgtcatactccttgtgtaccgcagcgttcacattcaccaagatcc
+cggctgaaacactgcacgggacagtcacagtggaggtacagtacgcagggacagatggac
+cttgcaaggttccagctcagatggcggtggacatgcaaactctgaccccagttgggaggt
+tgataaccgccaaccccgtaatcactgaaagcactgagaactctaagatgatgctggaac
+ttgatccaccatttggggactcttacattgtcataggagtcggggagaagaagatcaccc
+accactggcacaggagtggcagcaccattggaaaagcatttgaagccactgtgagaggtg
+ccaagagaatggcagtcttgggagatacagcctgggactttggatcagttggaggcgctc
+tcaactcattgggcaagggcatccatcaaatttttggagcagctttcaaatcattgtttg
+gaggaatgtcctggttctcacaaatcctcattggaacgttgctgatgtggttgggtctga
+acacaaagaatggatctatttccctcatgtgcttggccttagggggagtgttgatcttct
+tatccacagccgtctctgctgatgtggggtgctcggtggacttctcaaagaaggagacga
+gatgcggtacaggggtgttcgtctataacgacgttgaagcctggagggacaggtacaagt
+accatcctgactccccccgtagattggcagcagcagtcaagcaagcctgggaagatggta
+tctgcgggatctcctctgtttcaagaatggaaaacatcatgtggagatcagtagaagggg
+agctcaatgcaatcctggaagagaatggagttcaactgacggtcgttgtgggatctgtaa
+aaaaccccatgtggagaggtccacagagattgcccgtgcctgtgaacgagctgccccacg
+gctggaaggcttgggggaaatcgtacttcgttagagcagcaaagacaaataacagctttg
+tcgtgnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn
+nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn
+nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnntggaacagctgttaagggaaaggaggctg
+tacacagtgatctaggctactggattgagagtgagaagaatgacacatggaggctgaaga
+gggcccatctgatcgagatgaaaacatgtgaatggccaaagtcccacacattgtggacag
+atggaatagaagagagtgatctgatcatacccaagtctttagctgggccactcagccatc
+acaataccagagagggctacaggacccaaatgaaagggccatggcacagtgaagagcttg
+aaattcggtttgaggaatgcccaggcactaaggtccacgtggaggaaacatgtggaacaa
+gaggaccatctctgagatcaaccactgcaagcggaagggtgatcgaggaatggtgctgca
+gggagtgcacaatgcccccactgtcgttccgggctaaagatggctgttggtatggaatgg
+agataaggcccaggaaagaaccagaaagcaacttagtaaggtcagtggtgactgcaggat
+caactgatcacatggatcacttctcccttggagtgcttgtgattctgctcatggtgcagg
+aagggctgaagaagagaatgaccacaaagatcatcataagcacatcaatggcagtgctgg
+tagctatgatcctgggaggattttcaatgagtgacctggctaagcttgcaattttgatgg
+gtgccaccttcgcggaaatgaacactggaggagatgtagctcatctggcgctgatagcgg
+cattcaaagtcagaccagcgttgctggtatctttcatcttcagagctaattggacacccc
+gtgaaagcatgctgctggccttggcctcgtgtcttttgcaaactgcgatctccgccttgg
+aaggcgacctgatggttctcatcaatggttttgctttggcctggttggcaatacgagcga
+tggttgttccacgcactgataacatcaccttggcaatcctggctgctctgacaccactgg
+cccggggtacactgcttgtggcgtggagagcaggccttgctacttgcggggggtttatgc
+tcctctctctgaagggaaaaggcagtgtgaagaagaacttaccatttgtcatggccctgg
+gactaaccgctgtgaggctggtcgaccccatcaacgtggtgggactgctgttgctcacaa
+ggagtgggaagcggagctggccccctagcgaagtactcacagctgttggcctgatatgcg
+cattggctggagggttcgccaaggcagatatagagatggctgggcccatggccgcggtcg
+gtctgctaattgtcagttacgtggtctcaggaaagagtgtggacatgtacattgaaagag
+caggtgacatcacatgggaaaaagatgcggaagtcactggaaacagtccccggctcgatg
+tggcgctagatgagagtggtgatttctccctggtggaggatgacggtccccccatgagag
+agatcatactcaaggtggtcctgatgaccatctgtggcatgaacccaatagccataccct
+ttgcagctggagcgtggtacgtatacgtgaagactggaaaaaggagtggtgctctatggg
+atgtgcctgctcccaaggaagtaaaaaagggggagaccacagatggagtgtacagagtaa
+tgactcgtagactgctaggttcaacacaagttggagtgggagttatgcaagagggggtct
+ttcacactatgtggcatgtcacaaaaggatccgcgctgagaagcggtgaagggagacttg
+atccatactggggagatgtcaagcaggatctggtgtcatactgtggtccatggaagctag
+atgccgcctgggacgggcacagcgaggtgcagctcttggccgtgccccccggagagagag
+cgaggaacatccagactctgcccggaatatttaagacaaaggannnnnnnnnnnnnnnnn
+nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn
+nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn
+nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnncttcgagccttcgatgctgaaga
+agaagcagctaactgtcttagacttgcatcctggagctgggaaaaccaggagagttcttc
+ctgaaatagtccgtgaagctataaaaacaagactccgtactgtgatcttagctccaacca
+gggttgtcgctgctgaaatggaggaagcccttagagggcttccagtgcgttatatgacaa
+cagcagtcaatgtcacccattctggaacagaaatcgtcgacttaatgtgccatgccacct
+tcacttcacgtctactacagccaatcagagtccccaactataatctgtatattatggatg
+aggcccacttcacagatccctcaagtatagcagcaagaggatacatttcaacaagggttg
+agatgggcgaggcggctgccatcttcatgaccgccacgccaccaggaacccgtgacgcat
+ttccggnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn
+nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn
+nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnncgggtcatacagc
+tcagcagaaagacttttgagacagagttccagaaaacaaaacatcaagagtgggactttg
+tcgtgacaaccgacatttcagagatgggcgccaactttaaagctgaccgtgtcatagatt
+ccaggagatgcctaaagccggtcatacttgatggcgagagagtcattctggctggaccca
+tgcctgtcacacatgccagcgctgcccagaggagggggcgcataggcaggaatcccaaca
+aacctggagatgagtatctgtatggaggtgggtgcgcagagactgacgaagaccatgcac
+actggcttgarkcaagaatgctccttgacaatatttgcctccaagatggcctcatagcct
+cgctctatcgacctgaggccgacaaagtagcagccattgagggagagttcaagcttagga
+cggagcaaaggaagacctttgtggaactcatgaaaagaggagatcttcctgtttggctgg
+cctatcaggttgcatctgccggaataacttacacagatagaagatggtgctttgatggca
+cgaccaacaacaccataatggaagacagtgtgccggcagaggtgtggaccagacacggag
+agaaaagagtgctcaaaccgaggtggatggacgccagagtttgttcagatcatgcggccc
+tgaagtcattcaaggagtttgccgctgggaaaagaggagcggcttttggagtgatggaag
+ccctgggaacactgccaggacacatgacagagagattccaggaagccattgacaacctcg
+ctgtgctcatgcgggcagagactggaagcaggccttacaaagccgcggcggcccaattgc
+cggagaccctagagaccattatgcttttggggttgctgggaacagtctcgctgggaatct
+ttttcgtcttgatgaggaacaagggcatagggaagatgggctttggaatggtgactcttg
+gggccagcgcatggctcatgtggctctcggaaattgagccagccagaattgcatgtgtcc
+tcattgttgtgttcctattgctggtggtgctcatacctgagccagaaaagcaaagatctc
+cccaggacaaccaaatggcaatcatcatcatggtagcagtaggtcttctgggcttgatca
+ccgccaatgaactcggatggttggagagaacaaagagtgacctaagccatctaatgggaa
+ggagagaggagggagcaaccataggattctcaatggacattgacctgcggccagcctcag
+cttgggccatctatgctgccttgacaactttcattaccccagccgtccaacatgcagtga
+ccacttcatacaacaactactccttaatggcgatggccacgcaagctggagtgttgtttg
+gtatgggcaaagggatgccattctacgcatgggactttggagtcccgctgctaatgatag
+gttgctactcacaattaacacccctgaccctaatagtggccatcattttgctcgtggcgc
+actacatgtacttgatcccagggctgcaggcagcagctgcgcgtgctgcccagaagagaa
+crgcagctggcatcatgaagaaccctgttgtggatggaatagtggtgactgacattgaca
+caatgacaattgacccccaagtggagaaaaagatgggacaggtgctactcatagcagtag
+ccgtctccagcgccatactgtcgcggaccgcctgggggtggggggaggctggggccctga
+tcacagccgcaacttccactttgtgggaaggctctccgaacaagtactggaactcctcta
+cagccacttcactgtgtaacatttttaggggaagttacttggctggagcttctctaatct
+acacagtaacaagaaacgctggcttggtcaagagacgtgggggtggaacaggagagaccc
+tgggagagaaatggaaggcccgcttgaaccagatgtcggccctggagttctactcctaca
+aaaagtcaggcatcaccgaggtgtgcagagaagaggcccgccgcgccctcaaggacggtg
+tggcaacgggaggccatgctgtgtcccgaggaagtgcaaagctgagatggttggtggagc
+ggggatacctgcagccctatggaaaggtcattgatcttggatgtggcagagggggctgga
+gttactacgccgccaccatccgcaaagttcaagaagtgaaaggatacacaaaaggaggcc
+ctggtcatgaagaacccgtgttggtgcaaagctatgggtggaacatagtccgtctcaaga
+gtggggtggacgtctttcatatggcggctgagccgtgtgacacgttgctgtgtgacatag
+gtgagtcatcatctagtcctgaagtggaagaagcacggacgctcagagtcctctccatgg
+tgggggattggcttgaaaaaagaccaggagccttttgtataaaagtgttgtgcccataca
+ccagcactatgatggaaaccctggagcgactgcagcgtaggtatgggggaggactggtca
+gagtgccactctcccgcaactctacacatgagatgtactgggtctctggagcgaaaagca
+acaccataaaaagtgtgtccaccacgagccagctcctcttggggcgcatggacgggccta
+ggaggccagtgaaatatgaggaggatgtgaatctcggctctggcacgcgggctgtggtaa
+gctgcgctgaagctcccaacatgaagatcattggtaaccgcattgaaaggatccgcagtg
+agcacgcggaaacgtggttctttgacgagaaccacccatataggacatgggcttaccatg
+gaagctatgaggcccccacacaagggtcagcatcctctctagtaaacggggttgtcaggc
+tcctgtcaaaaccctgggatgtggtgactggagtcacaggaatagccatgaccgacacca
+caccgtatggtcagcaaagagttttcaaggaaaaagtggacactagggtgccagaccccc
+aagaaggcactcgtcaggttatgagcatggtctcttcctggttgtggaaagagctaggca
+aacacaaacggccacgagtctgtaccaaagaagagttcatcaacaaggttcgtagcaatg
+cagcattaggggcaatatttgaagaggaaaaagagtggaagactgcagtggaagctgtga
+acgatccaaggttctgggctctagtggacaasgaaagagagcaccacctgagaggagagt
+gccagagttgtgtgtacaacatgatgggaaaaagagaaaagaaacaaggggaatttggaa
+aggccaagggcagccgcgccatctggtatatgtggctaggggctagatttctagagttcg
+aagcccttggattcttgaacgaggatcactggwtggggagagagaactcaggaggtggtg
+ttgaagggctgggattannnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn
+nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn
+nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnagggcacagggccttggcattgg
+ccataatcaagtacacataccaaaacaaagtggtaaaggtccttagaccagctgaaaaag
+ggaaaacagttatggacattatttcgagacaagaccaaagggggagcggacaagttgtca
+cttacgctcttaacacatttaccaacctagtggtgcaactcattcggaatatggaggctg
+aggaagttctagagatgcaagacttgtggctgctgcggaggtcagagaaagtgaccaact
+ggttgcagagcaacggatgggataggctcaaacgaatggcagtcagtggagatgattgcg
+ttgtgaagccaattgatgataggtttgcacatgccctcaggttcttgaatgatatgggaa
+aagttaggaaggacacacaagagtggaaaccctcaactggatgggacaactgggaagaag
+ttccgttttgctcccaccacttcaacaagctccatctcaaggacgggaggtccattgtgg
+ttccctgccgccaccaagatgaactgattggccgggcccgcgtctctccaggggcgggat
+ggagcatccgggagactgcttgcctagcaaaatcatatgcgcaaatgtggcagctccttt
+atttccacagaagggacctccgactgatggccaatgccatttgttcatctgtgccagttg
+actgggttccaactgggagaactacctggtcaatccatggaaagggagaatggatgacca
+ttgaagacatgcttgtggtgtggaacagagtgtggattgaggagaacgaccacatggaag
+acaagaccccagttacgaaatggacagacattccctatttgggaaaaagggaagacttgt
+ggtgtggatctctcatagggcacagaccgcgcaccacctgggctgagaacattaaaaaca
+cagtcaacatggtgcgcaggatcataggtgaggaagaaaagtacatggactacctatcca
+cccaagttcgctacttgggtgaagaagggtctacacctggagtgctgtaagcaccaatct
+taatgttgtcaggcc
+>BRA/2016/FC_6706
+agtttgaagcgaaagctagcaacagtatcaacaggttttatttyggatttggaaacgaga
+gtttctggtcatgaaaaacccaaaaaagaaatccggaggattccggattgtcaatatgct
+aaaacgcggagtagcccgtgtgagcccctttgggggcttgaagaggctgccagccggact
+tctgctgggtcatgggcccatcaggatggtcttggcgattctagcctttttgagattcac
+ggcaatcaagccatcactgggtctcatcaatagatggggttcagtggggaaaaaagaggc
+tatggaaataataaagaagttcaagaaagatctggctgccatgctgagaataatcaatgc
+taggaaggagaagaagagacgaggcgcagatactagtgtcggaattgttggcctcctgct
+gaccacagctatggcagcggaggtcactagacgtgggagtgcatactatatgtacttgga
+cagaaacgatgctggggaggccatatcttttccaaccacattggggatgaataagtgtta
+tatacagatcatggatcttggacacatgtgtgatgccaccatgagctatgaatgccctat
+gctggatgagggggtggaaccagatgacgtcgattgttggtgcaacacgacgtcaacttg
+ggttgtgtacggaacctgccatcacaaaaaaggtgaagcacggagatctagaagagctgt
+gacgctcccctcccattccactaggaagctgcaaacgcggtcgcaaacctggttggaatc
+aagagaatacacaaagcacttgattagagtcgaaaattggatattcaggaaccctggctt
+cgcgttagcagcagccgccatcgcttggcttttgggaagctcaacgagccaaaaagtcat
+atacttggtcatgatactgctgattgccccggcatacagcatcaggtgcataggagtcag
+caatagggactttgtggaaggtatgtcaggtgggacttgggttgatgttgtcttggaaca
+tggaggttgtgtcaccgtaatggcacaggacaaaccgactgtcgacatagagctggttac
+aacaacagtcagcaacatggcggaggtaagatcctactgctatgaggcatcaatatcaga
+catggcttcggacagccgctgcccaacacaaggtgaagcctaccttgacaagcaatcaga
+cactcaatatgtctgyaaaagaacgttagtggacagaggctggggaaatggatgtggact
+ttttggcaaagggagcctggtgacatgcgctaagtttgcatgctccaagaaaatgaccgg
+gaagagcatccagccagagaatctggagtaccggataatgctgtcagttcatggctccca
+gcacagtgggatgatcgttaatgacacaggacatgaaactgatgagaatagagcgaaggt
+tgagataacgcccaattcaccaagagccgaagccaccctggggggttttggaagcctagg
+acttgattgtgaaccgaggacaggccttgacttttcagatttgtattacttgactatgaa
+taacaagcactggttggttcacaaggagtggttccacgacattccattaccttggcacgc
+tggggcagacaccggaactccacactggaacaacaaagaagcactggtagagttcaagga
+cgcacatgccaaaaggcaaactgtcgtggttctagggagtcaagaaggagcagttcacac
+ggcccttgctggagctctggaggctgagatggatggtgcaaagggaaggctgtcctctgg
+ccacttgaaatgtcgcctgaaaatggataaacttagattgaagggcgtgtcatactcctt
+gtgtaccgcagcgttcacattcaccaagatcccggctgaaacactgcacgggacagtcac
+agtggaggtacagtacgcagggacagatggaccttgcaaggttccagctcagatggcggt
+ggacatgcaaactctgaccccagttgggaggttgataaccgctaaccccgtaatcactga
+aagcactgagaactctaagatgatgctggaacttgatccaccatttggggactcttacat
+tgtcataggagtcggggagaagaagatcacccaccactggcacaggagtggcagcaccat
+tggaaaagcatttgaagccactgtgagaggtgccaagagaatggcagtcttgggagacac
+agcctgggactttggatcagttggaggcgctctcaactcattgggcaagggcatccatca
+aatttttggagcagctttcaaatcattgtttggaggaatgtcctggttctcacaaattct
+cattggaacgttgctgatgtggttgggtctgaacacaaagaatggatctatttcccttat
+gtgcttggccttagggggagtgttgatcttcttatccacagccgtctctgctgatgtggg
+gtgctcggtggacttctcaaagaaggagacgagatgtggtacaggggtgttcgtctataa
+cgacgttgaagcctggagggacaggtacaagtaccatcctgactccccccgtagattggc
+agcagcagtcaagcaagcctgggaagatggtatctgcgggatctcttctgtttcaagaat
+ggaaaacatcatgtggagatcagtagaaggggagctcaacgcaatcctggaagagaatgg
+agttcaactgacggtcgttgtgggatctgtaaaaaaccccatgtggagaggtccacagag
+attgcccgtgcctgtgaacgagctgccccacggctggaaggcttgggggaaatcgtactt
+cgtcagagcagcaaagacaaataacagctttgtcgtggatggtgacacactgaaggaatg
+cccactcaaacatagagcatggaacagctttctwgtggaggatcatgggttcggggtatt
+tcacactagtgtctggctcaaggttagagaagattattcattagagtgtgatccagccgt
+tattggaacagctgttaagggaaaggaggctgtacacagtgatctaggctactggattga
+gagtgagaagaatgacacatggaggctgaagagggcccatctgatcgagatgaaaacatg
+tgaatggccaaagtcccacacattgtggacagatggaatagaagagagtgatctgatcat
+acccaagtctttagctgggccactcagccatcacaataccagagagggctacaggaccca
+aatgaaagggccatggcacagtgaagagcttgaaattcggtttgaggaatgcccaggcac
+taaggtccacgtggaggaaacatgtggaacaagaggaccatctctgagatcaaccactgc
+aagcggaagggtgatcgaggaatggtgctgcagggagtgcacaatgcccccactgtcgtt
+ccgggctaaagatggctgttggtatggaatggagataaggcccaggaaagaaccagaaag
+caacttagtaaggtcaatggtgactgcaggatcaactgatcacatggatcacttctccct
+tggagtgcttgtgattctgctcatggtgcaggaagggctgaagaagagaatgaccacaaa
+gatcatcataagcacatcaatggcagtgctggtagctatgatcctgggaggattttcaat
+gagtgacctggctaagcttgcaattttgatgggtgccaccttcgcggaaatgaacactgg
+aggagatgtagctcatctggcgctgatagcggcattcaaagtcagaccagcgttgctggt
+atctttcatcttcagagctaattggacaccccgtgaaagcatgctgctggccttggcctc
+gtgtcttttgcaaactgcgatctccgccttggaaggcgacctgatggttctcatcaatgg
+ttttgctttggcctggttggcaatacgagcgatggttgttccacgcactgacaacatcac
+cttggcaatcctggctgctctgacaccactggcccggggcacactgcttgtggcgtggag
+agcaggccttgctacttgcggggggtttatgctcctctctctgaagggaaaaggcagtgt
+gaagaagaacttaccatttgtcatggccctgggactaaccgctgtgaggctggtcgaccc
+catcaacgtggtgggactgctgttgctcacaaggagtgggaagcggagctggccccctag
+cgaagtactcacagctgttggcctgatatgcgcattggctggagggttcgccaaggcaga
+tatagagatggctgggcccatggccgcggtcggtctgctaattgtcagttacgtggtctc
+gggaaagagtgtggacatgtacattgaaagagcaggtgacatcacatgggaaaaagatgc
+ggaagtcactggaaacagtccccggctcgatgtggcgctagatgagagtggtgatttctc
+cctggtggaggatgacggtccccccatgagagagatcatactcaaggtggtcctgatgac
+catctgtggcatgaacccaatagccataccctttgcagctggagcgtggtacgtatacgt
+gaagactggaaaaaggagtggtgctctatgggatgtgcctgctcccaaggaagtaaaaaa
+gggggagaccacagatggagtgtacagagtaatgactcgtagactgctaggttcaacaca
+agttggagtgggagttatgcaagagggggtctttcacactatgtggcacgtcacaaaagg
+atccgcgctgagaagcggtgaagggagacttgatccatactggggagatgtcaagcagga
+tctggtgtcatactgtggtccatggaagctagatgccgcctgggacgggcacagcgaggt
+gcagctcttggccgtgccccccggagagagagcgaggaacatccagactctgcccggaat
+atttaagacaaaggatggggannnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn
+nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn
+nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn
+nnnnnnnnnnnnnnagccttcgatgctgaagaagaagcagctaactgtcttagacttgca
+tcctggagctgggaaaaccaggagagttcttcctgaaatagtccgtgaagccataaaaac
+aagactccgtactgtgatcttagctccaaccagggttgtcgctgctgaaatggaggaagc
+ccttagagggcttccagtgcgttatatgacaacagcagtcaatgtcacccactctggaac
+agaaatcgtcgacttaatgtgcyatgccaccttcacttcacgtctactacagccaatcag
+agtccccaactataatctgtatattatggatgaggcccacttcacagatccctcaagtat
+agcagcaagaggatacatttcaacaagggttgagatgggcgaggcrgctgccatcttcat
+gaccgccacgccaccaggaacccgtgacgcatttccggactccaactcaccaattatgga
+caccgaagtggaagtcccagagagagcctggagctcaggctttgattgggtgacggatca
+ttctggaaaaacagtttggtttgttccaagcgtgaggaacggcaatgagatcgcagcttg
+tctgacaaaggctggaaaacgggtcatacagctcagcagaaagacttttgagacagagtt
+ccagaaaacaaaacatcaagagtgggactttgtcgtgacaactgacatttcagagatggg
+cgccaactttaaagctgaccgtgtcatagattccaggagatgcctaaagccggtcatact
+tgatggcgagagagtcattctggctggacccatgcctgtcacacatgccagcgctgccca
+gaggagggggcgcataggcaggaatcctaacaaacctggagatgagtatctgtatggagg
+tgggtgcgcagagactgacgaagaccatgcacactggcttgaagcaagaatgctccttga
+caatatttacctccaagatggcctcatagcctcgctctatcgacctgaggccgacaaagt
+agcagccattgagggagagttcaagcttaggacggagcaaaggaagacctttgtggaact
+catgaaaagaggagatcttcctgtttggctggcctatcaggttgcatctgccggaataac
+ctacacagatagaagatggtgctttgatggcacgaccaacaacaccataatggaagacag
+tgtgccggcagaggtgtggaccagacacggagagaaaagagtgctcaaaccgaggtggat
+ggacgccagagtttgttcagatcatgcggccctgaagtcattcaaggagtttgccgctgg
+gaaaagaggagcggcttttggagtgatggaagccctgggaacactgccaggacacatgac
+agagagattccaggaagccattgacaacctcgctgtgctcatgcgggcagagactggaag
+caggccttacaaagccgcggcggcccaattgccggagaccctagagaccattatgctctt
+ggggttgctgggaacagtctcgctgggaatctttttcgtcttgatgaggaacaagggcat
+agggaagatgggctttggaatggtgactcttggggccagcgcatggctcatgtggctctc
+ggaaattgagccagccagaattgcatgtgtcctcattgttgtgttcctattgctggtggt
+gctcatacctgagccagaaaagcaaagatctccccaggacaaccaaatggcaatcatcat
+catggtagcagtaggtcttctgggcttgattaccgccaatgaactcggatggttggagag
+aacaaagagtgacctaagccatctaatgggaaggagagaggagggggcaaccataggatt
+ctcaatggacattgacctgcggccagcctcagcttgggccatctatgctgccttgacaac
+tttcattaccccagccgtccaacatgcagtgaccacttcatacaacaactactccttaat
+ggcgatggccacgcaggctggagtgttgtttggtatgggcaaagggatgccattctacgc
+atgggactttggagtcccgctgctaatgataggttgctactcacaattaacacccctgac
+cctaatagtggccatcattttgctcgtggcgcactacatgtacttgatcccagggctgca
+ggcagcagctgcgcgtgctgcccagaagagaacggcagctggcatcatgaagaaccctgt
+tgtggatggaatagtggtgactgacattgacacaatgacaattgacccccaagtggagaa
+aaagatgggacaggtgctactcatagcagtagccgtctccagcgccatactgtcgcggac
+cgcctgggggtggggggaggctggggctctgatcacagccgcaacctccactttgtggga
+aggctctccgaacaagtactggaactcctctacagccacttcactgtgtaacatttttag
+gggaagttacttggctggagcttctctaatctacacagtaacaagaaacgctggcttggt
+caagagacgtgggggtggaacaggagagaccctgggagagaaatggaaggcccgcttgaa
+ccagatgtcggccctggagttctactcctacaaaaagtcaggcatcaccgaggtgtgcag
+agaagaggcccgccgcgccctcaaggacggtgtggcaacgggaggccatgctgtgtcccg
+aggaagtgcaaagctgagatggttggtggagcggggatacctgcagccctatggaaaggt
+cattgatcttggatgtggcagagggggctggagttactacgccgccaccatccgcaaagt
+tcaagaagtgaaaggatacacaaaaggaggccctggtcatgaagaacccgtgttggtgca
+aagctatgggtggaacatagtccgtcttaagagtggggtagacgtctttcatatggcggc
+tgagccgtgtgacacgttgctgtgtgacataggtgagtcatcatctagtcctgaagtgga
+agaagcacggacgctcagagtcctctccatggtgggggattggcttgaaaaaagaccagg
+agccttttgtataaaagtgttgtgcccatacaccagcactatgatggaaaccctggagcg
+actgcagcgtaggtatgggggaggactggtcagagtgccactctcccgcaactctacaca
+tgagatgtactgggtctctggagcgaaaagcaacaccataaaaagtgtgtccaccacgag
+ccagctcctcttggggcgcatggacgggcctaggaggccagtgaaatatgaggaggatgt
+gaatctcggctctggcacgcgggctgtggtaagctgcgctgaagctcccaacatgaagat
+cattggtaaccgcattgaaaggatccgcagtgagcacgcggaaacgtggttctttgacga
+gaaccacccatataggacatgggcttaccatggaagctatgaggcccccacacaagggtc
+agcgtcctctctaataaacggggttgtcaggctcctgtcaaaaccctgggatgtggtgac
+tggagtcacaggaatagccatgaccgacaccacaccgtatggtcagcaaagagttttcaa
+ggaaaaagtggacactagggtgccagacccccaagaaggcactcgtcaggttatgagcat
+ggtctcttcctggttgtggaaagagctaggcaaacacaagcggccacgagtctgtaccaa
+agaagagttcatcaacaaggttcgtagcaatgcagcattaggggcaatatttgaagagga
+aaaagrktggaagactgcagtggaagctgtgaacgatccaaggttctgggctctagtgga
+caaggaaagagagcaccacctgagaggagagtgccagagttgtgtgtacaacatgatggg
+aaaaagagaaaagaaacaaggggaatttggaaaggccaagggcagtcgcgccatctggta
+tatgtggctaggggctagatttctagagttcgaagcccttggattcttgaacgaggatca
+ctggatggggagagagaactcaggaggtggtgttgaagnnnnnnnnnnnnnnnnnnnnnn
+nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn
+nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn
+nnnnnnnnnnnnnnacagggccttggcattggccataatcaagtacacataccaaaacaa
+agtggtaaaggtccttagaccagctgaaaaagggaaaacagttatggacattatttcgag
+acaagaccaaagggggagcggacaagttgtcacttacgctcttaacacatttaccaacct
+agtggtgcaactcattcggaatatggaggctgaggaagttctagagatgcaagacttgtg
+gctgctgcggaggtcagagaaagtgaccaactggttgcagagcaacggatgggataggct
+caaacgaatggcagtcagtggagatgattgcgttgtgaagccaattgatgataggtttgc
+acatgccctcaggttcttgaatgatatgggaaaagtcaggaaggacacacaagagtggaa
+accctcaactggatgggacaactgggaagaagttccgttttgctcccaccacttcaacaa
+gctccatctcaaggacgggaggtccattgtggttccctgccgccaccaagatgaactgat
+tggccgggcccgcgtctctccaggggcgggatggagcatccgggagactgcttgcctagc
+aaaatcatatgcgcaaatgtggcagctcctttatttccacagaagggacctccgactgat
+ggccaatgccatttgttcatctgtgccagttgactgggttccaactgggagaactacctg
+gtcaatccatggaaagggagaatggatgaccactgaagacatgcttgtggtgtggaacag
+agtgtggattgaggagaacgaccacatggaagacaagaccccagttacgaaatggacaga
+cattccctatttgggaaaaagggaagacttgtggtgtggatctctcatagggcacagacc
+gcgcaccacctgggctgagaacattaaaaacacagtcaacatggtgcgcaggatcatagg
+tgatgaagaaaagtacatggactacctatccacccaagttcgctacttgggtgaagaagg
+gtctacacctggagtgctgtaagcaccaatcttaatgttgtcaggc
+>DOM/2016/BB_0183
+gtttgaagcgaaagctagcaacagtatcaacaggttttattttggatttggaaacgagag
+tttctggtcatgaaaaacccaaaaaagaaatccggaggattccggattgtcaatatgcta
+aaacgcggagtagcccgtgtgagcccctttgggggcttgaagaggctgccagccggactt
+ctgctgggtcatgggcccatcaggatggtcttggcgattctagcctttttgagattcacg
+gcaatcaagccatcactgggtctcatcaatagatggggttcagtggggaaaaaagaggct
+atggaaataataaagaagttcaagaaagatctggctgccatgctgagaataatcaatgct
+aggaaggagaagaagagacgaggcgcagatactagtgtcggaattgttggcctcctgctg
+accacagctatggcagcggaggtcactagacgtgggagtgcatactacatgtacttggac
+agaaacgatgctggggaggccatatcttttccaaccacattggggatgaataagtgttat
+atacagatcatggatcttggacacatgtgtgatgccaccatgagctatgaatgccctatg
+ctggatgagggggtggaaccagatgacgtcgattgttggtgcaacacgacgtcaacttgg
+gttgtgtacggaacctgccatcacaaaaaaggtgaagcacggagatctagaagagctgtg
+acgctcccctcccattccactaggaagctgcaaacgcggtcgcaaacctggttggaatca
+agagaatacacaaagcacttgattagagtcgaaaattggatattcaggaaccctggcttc
+gcgttagcagcagctgccatcgcttggcttttgggaagctcaacgagccaaaaagtcata
+tacttggtcatgatactgctgattgccccggcatacagcatcaggtgcataggagtcagc
+aatagggactttgtggaaggtatgtcaggtgggacttgggttgatgttgtcttggaacat
+ggaggttgtgtcaccgtaatggcacaggacaaaccgactgtcgacatagagctggttaca
+acaacagtcagcaacatggcggaggtaagatcctactgctatgaggcatcaatatcagac
+atggcttcggacagccgctgcccaacacaaggtgaagcctaccttgacaagcaatcagac
+actcaatatgtctgcaaaagaacgttagtggacagaggctggggaaatggatgtggactt
+tttggcaaagggagcctggtgacatgcgctaagtttgcatgctccaagaaaatgaccggg
+aagagcatccagccagagaatctggagtaccggataatgctgtcagttcatggctcccag
+cacagtgggatgatcgttaatgacacaggacatgaaactgatgagaatagagcgaaggtt
+gagataacgcccaattcaccaagagccgaagccaccctggggggttttggaagcctagga
+cttgattgtgaaccgaggacaggccttgacttttcagatttgtattacttgactatgaat
+aacaagcactggttggttcacaaggagtggttccacgacattccattaccttggcacgct
+ggggcagacaccggaactccacactggaacaacaaagaagcactggtagagttcaaggac
+gcacatgccaaaaggcaaactgtcgtggttctagggagtcaagaaggagcagttcacacg
+gcccttgctggagctctggaggctgagatggatggtgcaaagggaaggctgtcctctggc
+cacttgaaatgtcgcctgaaaatggataaacttagattgaagggcgtgtcatactccttg
+tgtaccgcagcgttcacattcaccaagatcccggctgaaacactgcacgggacagtcaca
+gtggaggtacagtacgcagggacagatggaccttgcaaggttccagctcagatggcggtg
+gacatgcaaactctgaccccagttgggaggttgataaccgccaaccccgtaatcactgaa
+agcactgagaactctaagatgatgctggaacttgatccaccatttggggactcttacatt
+gtcataggagtcggggagaagaagatcacccaccactggcacaggagtggcagcaccatt
+ggaaaagcatttgaagccactgtgagaggtgccaagagaatggcagtcttgggagacaca
+gcctgggactttggatcagttggaggcgctctcaactcattgggcaagggcatccatcaa
+atttttggagcagctttcaaatcattgtttggaggaatgtcctggttctcacaaatcctc
+attggaacgttgctgatgtggttgggtctgaacacaaagaatggatctatttccctcatg
+tgcttggccttagggggagtgttgatcttcttatccacagccgtctctgctgatgtgggg
+tgctcggtggacttctcaaagaaggagacgagatgcggtacaggggtgttcgtctataac
+gacgttgaagcctggagggacaggtacaagtaccatcctgactccccccgtagattggca
+gcagcagtcaagcaagcctgggaagatggtatctgcgggatctcctctgtttcaagaatg
+gaaaacatcatgtggagatcagtagaaggggagctcaatgcaatcctggaagagaatgga
+gtccaactgacggtcgttgtgggatctgtaaaaaaccccatgtggagaggtccacagaga
+ttgcccgtgcctgtgaacgagctgccccacggctggaaggcctgggggaaatcgtacttc
+gttagagcagcaaagacaaataacagctttgtcgtggatggtgacacactgaaggaatgc
+ccactcaaacatagagcatggaacagctttcttgtggaggatcatgggttcggggtattt
+cacactagtgtctggctcaaggttagagaagattattcattagagtgtgatccagccgtt
+attggaacagctgttaagggaaaggaggctgtacacagtgatctaggctactggattgag
+agtgagaagaatggcacatggaggctgaagagggcccatctgatcgagatgaaaacatgt
+gaatggccaaagtcccacacattgtggacagatggaatagaagagagtgatctgatcata
+cccaagtctttagctgggccactcagccatcacaataccagagagggctacaggacccaa
+atgaaagggccatggcacagtgaagagcttgaaattcggtttgaggaatgcccaggcact
+aaggtccacgtggaggaaacatgtggaacaagaggaccatctctgagatcaaccactgca
+agcggaagggtgatcgaggaatggtgctgcagggagtgcacaatgcccccactgtcgttc
+cgggctaaagatggctgttggtatggaatggagataaggcccaggaaagaaccagaaagc
+aacttagtaaggtcagtggtgactgcaggatcaactgatcacatggatcacttctccctt
+ggagtgcttgtgattctgctcatggtgcaggaagggctgaagaagagaatgaccacaaag
+atcatcataagcacatcaatggcagtgctggtagctatgatcctgggaggattttcaatg
+agtgacctggctaagcttgcaattttgatgggtgccaccttcgcggaaatgaacactgga
+ggagatgtagctcatctggcgctgatagcggcattcaaagtcagaccagcgttgctggta
+tctttcatcttcagagctaattggacaccccgtgaaagcatgctgctggccttggcctcg
+tgtcttttgcaaactgcgatctccgccttggaaggcgacctgatggttctcatcaatggt
+tttgctttggcctggttggcaatacgagcgatggttgttccacgcactgataacatcacc
+atggcaatcctggctgctctgacaccactggcccggggcacactgcttgtggcgtggaga
+gcaggccttgctacttgcggggggtttatgctcctctctctgaagggaaaaggcagtgtg
+aagaagaacttaccatttgtcatggccctgggactaaccgctgtgaggctggtcgacccc
+atcaacgtggtgggactgctgttgctcacaaggagtgggaagcggagctggccccctagc
+gaagtactcacagctgttggcctgatatgcgcattggctggagggttcgccaaggcagat
+atagagatggctgggcccatggccgcggtcggtctgctaattgtcagttacgtggtctca
+ggaaagagtgtggacatgtacattgaaagagcaggtgacatcacatgggaaaaagatgcg
+gaagtcactggaaacagtccccggctcgatgtggcgctagatgagagtggtgatttctcc
+ctggtggaggatgacggtccccccatgagagagatcatactcaaggtggtcctgatgacc
+atctgtggcatgaacccaatagccataccctttgcagctggagcgtggtacgtatacgtg
+aagactggaaaaaggagtggtgctctatgggatgtgcctgctcccaaggaagtaaaaaag
+ggggagaccacagatggagtgtacagagtaatgactcgtagactgctaggttcaacacaa
+gttggagtgggagttatgcaagagggggtctttcacactatgtggcacgtcacaaaagga
+tccgcgctgagaagcggtgaagggagacttgatccatactggggagatgtcaagcaggat
+ctggtgtcatactgtggtccatggaagctagatgccgcctgggacgggcacagcgaggtg
+cagctcttggccgtgccccccggagagagagcgaggaacatccagactctgcccggaata
+tttaagacaaaggatggggacattggagcggttgcgctggattacccagcaggaacttca
+ggatctccaatcctagacaagtgtgggagagtgataggactttatggcaatggggtcgtg
+atcaaaaatgggagttatgttagtgccatcacccaagggaggagggaggaagagactcct
+gttgagtgcttcgagccttcgatgctgaagaagaagcagctaactgtcttagacttgcat
+cctggagctgggaaaaccaggagagttcttcctgaaatagtccgtgaagctataaaaaca
+agactccgtactgtgatcttagctccaaccagggttgtcgctgctgaaatggaggaagcc
+cttagagggcttccagtgcgttatatgacaacagcagtcaatgtcacccattctggaaca
+gaaatcgtcgacttaatgtgccatgccaccttcacttcacgtctactacagccaatcaga
+gtccccaactataatctgtatattatggatgaggcccacttcacagatccctcaagtata
+gcagcaagaggatacatttcaacaagggttgagatgggcgaggcggctgccatcttcatg
+accgccacgccaccaggaacccgtgacgcatttccggactccaactcaccaattatggac
+accgaagtggaagtcccagagagagcctggagctcaggctttgattgggtgacggatcat
+tctggaaaaacagtttggtttgttccaagcgtgaggaacggcaatgagatcgcagcttgt
+ctgacaaaggctggaaaacgggtcatacagctcagcagaaagacttttgagacagagttc
+cagaaaacaaaacatcaagagtgggactttgtcgtgacaaccgacatttcagagatgggc
+gccaactttaaagctgaccgtgtcatagattccaggagatgcctaaagccggtcatactt
+gatggcgagagagtcattctggctggacccatgcctgtcacacatgccagcgctgcccag
+aggagggggcgcataggcaggaatcccaacaaacctggagatgagtatctgtatggaggt
+gggtgcgcagagactgacgaagaccatgcacactggcttgaagcaagaatgctccttgac
+aatatttacctccaagatggccttatagcctcgctctatcgacctgaggccgacaaagta
+gcagccattgagggagagttcaagcttaggacggagcaaaggaagacctttgtggaactc
+atgaaaagaggagatcttcctgtttggctggcctatcaggttgcatctgccggaataact
+tacacagatagaagatggtgctttgatggcacgaccaacaacaccataatggaagacagt
+gtgccggcagaggtgtggaccagacacggagagaaaagagtgctcaaaccgaggtggatg
+gacgccagagtttgttcagatcatgcggccctgaagtcattcaaggagtttgccgctggg
+aaaagaggagcggcttttggagtgatggaagccctgggaacactgccaggacacatgaca
+gagagattccaggaagccattgacaacctcgctgtgctcatgcgggcagagactggaagc
+aggccttacaaagccgcggcggcccaattgccggagaccctagagaccattatgcttttg
+gggttgctgggaacagtctcgctgggaatctttttcgtcttgatgaggaacaagggcata
+gggaagatgggctttggaatggtgactcttggggccagcgcatggctcatgtggctctcg
+gaaattgagccagccagaattgcatgtgtcctcattgttgtgttcctattgctggtggtg
+ctcatacctgagccagaaaagcaaagatctccccaggacaaccaaatggcaatcatcatc
+atggtagcagtaggtcttctgggcttgatcaccgccaatgaactcggatggttggagaga
+acaaagagtgacctaagccatctaatgggaaggagagaggagggagcaaccataggattc
+tcaatggacattgacctgcggccagcctcagcttgggccatctatgctgccttgacaact
+ttcattaccccagccgtccaacatgcagtgaccacttcatacaacaactactccttaatg
+gcgatggccacgcaagctggagtgttgtttggtatgggcaaagggatgccattctacgca
+tgggactttggagtcccgctgctaatgataggttgctactcacaattaacacccctgacc
+ctaatagtggccatcattttgctcgtggcgcactacatgtacttgatcccagggctgcag
+gcagcagctgcgcgtgctgcccagaagagaacggcagctggcatcatgaagaaccctgtt
+gtggatggaatagtggtgactgacattgacacaatgacaattgacccccaagtggagaaa
+aagatgggacaggtgctactcatagcagtagccgtctccagcgccatactgtcgcggacc
+gcctgggggtggggggaggctggggccctgatcacagccgcaacttccactttgtgggaa
+ggctctccgaacaagtactggaactcctctacagccacttcactgtgtaacatttttagg
+ggaagttacttggctggagcttctctaatctacacagtaacaagaaacgctggcttggtc
+aagagacgtgggggtggaacaggagagaccctgggagagaaatggaaggcccgcttgaac
+cagatgtcggccctggagttctactcctacaaaaagtcaggcatcaccgaggtgtgcaga
+gaagaggcccgccgcgccctcaaggacggtgtggcaacgggaggccatgctgtgtcccga
+ggaagtgcaaagctgagatggttggtggagcggggatacctgcagccctatggaaaggtc
+attgatcttggatgtggcagagggggctggagttactacgccgccaccatccgcaaagtt
+caagaagtgaaaggatacacaaaaggaggccctggtcatgaagaacccgtgttggtgcaa
+agctatgggtggaacatagtccgtctcaagagtggggtggacgtctttcatatggcggct
+gagccgtgtgacacgttgctgtgtgacataggtgagtcatcatctagtcctgaagtggaa
+gaagcacggacgctcagagtcctctccatggtgggggattggcttgaaaaaagaccagga
+gccttttgtataaaagtgttgtgcccatacaccagcactatgatggaaaccctggagcga
+ctgcagcgtaggtatgggggaggactggtcagagtgccactctcccgcaactctacacat
+gagatgtactgggtctctggagcgaaaagcaacaccataaaaagtgtgtccaccacgagc
+cagctcctcttggggcgcatggacgggcctaggaggccagtgaaatatgaggaggatgtg
+aatctcggctctggcacgcgggctgtggtaagctgcgctgaagctcccaacatgaagatc
+attggtaaccgcattgaaaggatccgcagtgagcacgcggaaacgtggttctttgacgag
+aaccacccatataggacatgggcttaccatggaagctatgaggcccccacacaagggtca
+gcatcctctctagtaaacggggttgtcaggctcctgtcaaaaccctgggatgtggtgact
+ggagtcacaggaatagccatgaccgacaccacaccgtatggtcagcaaagagttttcaag
+gaaaaagtggacactagggtgccagacccccaagaaggcactcgtcaggttatgagcatg
+gtctcttcctggttgtggaaagagctaggcaaacacaaacggccacgagtctgtaccaaa
+gaagagttcatcaacaaggttcgtagcaatgcagcattaggggcaatatttgaagaggaa
+aaagagtggaagactgcagtggaagctgtgaacgatccaaggttctgggctctagtggac
+aaggaaagagagcaccacctgagaggagagtgccagagttgtgtgtacaacatgatggga
+aaaagagaaaagaaacaaggggaatttggaaaggccaagggcagccgcgccatctggtat
+atgtggctaggggctagatttctagagttcgaagcccttggattcttgaacgaggatcac
+tggatggggagagagaactcaggaggtggtgttgaagggctgggattacaaagactcgga
+tatgtcctagaagagatgagtcgcataccaggaggaaggatgtatgcagatgacactgct
+ggctgggatacccgcatcagcaggtttgatctagagaatgaagctctaatcaccaaccaa
+atggagaaagggcacagggccttggcattggccataatcaagtacacataccaaaacaaa
+gtggtaaaggtccttagaccagctgaaaaagggaaaacagttatggacattatttcgaga
+caagaccaaagggggagcggacaagttgtcacttacgctcttaacacatttaccaaccta
+gtggtgcaactcattcggaatatggaggctgaggaagttctagagatgcaagacttgtgg
+ctgctgcggaggtcagagaaagtgaccaactggttgcggagcaacggatgggataggctc
+aaacgaatggcagtcagtggagatgattgcgttgtgaagccaattgatgataggtttgca
+catgccctcaggttcttgaatgatatgggaaaagttaggaaggacacacaagagtggaaa
+ccctcaactggatgggacaactgggaagaagttccgttttgctcccaccacttcaacaag
+ctccatctcaaggacgggaggtccattgtggttccctgccgccaccaagatgaactgatt
+ggccgggcccgcgtctctccaggggcgggatggagcatccgggagactgcttgcctagca
+aaatcatatgcgcaaatgtggcagctcctttatttccacagaagggacctccgactgatg
+gccaatgccatttgttcatctgtgccagttgactgggttccaactgggagaactacctgg
+tcaatccatggaaagggagaatggatgaccactgaagacatgcttgtggtgtggaacaga
+gtgtggattgaggagaacgaccacatggaagacaagaccccagttacgaaatggacagac
+attccctatttgggaaaaagggaagacttgtggtgtggatctctcatagggcacagaccg
+cgcaccacctgggctgagaacattaaaaacacagtcaacatggtgcgcaggatcataggt
+gaggaagaaaagtacatggactacctatccacccaagttcgctacttgggtgaagaaggg
+tctacacctggagtgctgtaagcaccaatcttaatgttgtcaggcctgctagtcagccac
+agcttggggaaagctgtgcagcctgtgacccccccaggagaagctgggaaaccaagccta
+tagtcaggccgagaacgccatggcacggaagaagccatgctgcctgtgagcccctcagag
+gacactgagtcaaaaaaccccacgcgcttggaggcgcaggatgggaaaagaaggtggcga
+ccttccccacccttcaatctggggcctgaactggagatcagctgtggatccccagaagag
+g
+>EcEs062_16
+agtagttgatctgtgtgaatcagactgcgacagttcgagtttgaagcgaaagctagcaac
+agtatcaacaggttttattttggatttggaaacgagagtttctggtcatgaaaaacccaa
+aaaagaaatccggaggattccggattgtcaatatgctaaaacgcggagtagcccgtgtga
+gcccctttgggggcttgaagaggctgccagccggacttctgctgggtcatgggcccatca
+ggatggtcttggcgattctagcctttttgagattcacggcaatcaagccatcactgggtc
+tcatcaatagatggggttcagtggggaaaaaagaggctatggaaataataaagaagttca
+agaaagatctggctgccatgctgagaataatcaatgctaggaaggagaagaagagacgag
+gcgcagatactagtgtcggaattgttggcctcctgctgaccacagctatggcagcggagg
+tcactagacgtgggagtgcatactatatgtacttggacagaaacgatgctggggaggcca
+tatcttttccaaccacattggggatgaataagtgttatatacagatcatggatcttggac
+acatgtgtgatgccaccatgagctatgaatgccctatgctggatgagggggtggaaccag
+atgacgtcgattgttggtgcaacacgacgtcaacttgggttgtgtacggaacctgccatc
+acaaaaaaggtgaagcacggagatctagaagagctgtgacgctcccctcccattccacta
+ggaagctgcaaacgcggtcgcaaacctggttggaatcaagagaatacacaaagcacttga
+ttagagtcgaaaattggatattcaggaaccctggcttcgcgttagcagcagctgccatcg
+cttggcttttgggaagctcaacgagccaaaaagtcatatacttggtcatgatactgctga
+ttgccccggcatacagcatcaggtgcataggagtcagcaatagggactttgtggaaggta
+tgtcaggtgggacttgggttgatgttgtcttggaacatggaggttgtgtcaccgtaatgg
+cacaggacaaaccgactgtcgacatagagctggttacaacaacagtcagcaacatggcgg
+aggtaagatcctactgctatgaggcatcaatatcagacatggcttcggacagccgctgcc
+caacacaaggtgaagcctaccttgacaagcaatcagacactcaatatgtctgcaaaagaa
+cgttagtggacagaggctggggaaatggatgcggactttttggcaaagggagcctggtga
+catgcgctaagtttgcatgctccaagaaaatgaccgggaagagcatccagccagagaatc
+tggagtaccggataatgctgtcagttcatggctcccagcacagtgggatgatcgttaatg
+acacaggacatgaaactgatgagaatagagcgaaggttgagataacgcccaattcaccaa
+gagccgaagccaccctggggggttttggaagcctaggacttgattgtgaaccgaggacag
+gccttgacttttcagatttgtattacttgactatgaataacaagcactggttggttcaca
+aggagtggttccacgacattccattaccttggcacgctggggcagacaccggaactccac
+actggaacaacaaagaagcactggtagagttcaaggacgcacatgccaaaaggcaaactg
+tcgtggttctagggagtcaagaaggagcagttcacacggcccttgctggagctctggagg
+ctgagatggatggtgcaaagggaaggctgtcctctggccacttgaaatgtcgcctgaaaa
+tggataaacttagactgaagggcgtgtcatactccttgtgtaccgcagcgttcacattca
+ccaagatcccggctgaaacactgcacgggacagtcacagtggaggtacagtacgcaggga
+cagatggaccttgcaaggttccagctcagatggcggtggacatgcaaactctgaccccag
+ttgggaggttgataaccgctaaccccgtaatcactgaaagcactgagaactctaagatga
+tgctggaacttgatccaccatttggggactcttacattgtcataggagtcggggagaaga
+agatcacccaccactggcacaggagtggcagcaccattggaaaagcatttgaagccactg
+tgagaggtgccaagagaatggcagtcttgggagacacagcctgggactttggatcagttg
+gaggcgctctcaactcattgggcaagggcatccatcaaatttttggagcagctttcaaat
+cattgtttggaggaatgtcctggttctcacaaattctcattggaacgttgctgatgtggt
+tgggtctgaacacaaagaatggatccatttcccttatgtgcttggccttagggggagtgt
+tgatcttcttatccacagccgtctctgctgatgtggggtgctcggtggacttctcaaaga
+aggagacgagatgcggtacaggggtgttcgtctataacgacgttgaagcctggagggaca
+ggtacaagtaccatcctgactccccccgtagattggcagcagcagtcaagcaagcctggg
+aagatggtatctgcgggatctcctctgtttcaagaatggaaaacatcatgtggagatcag
+tagaaggggagctcaacgcaatcctggaagagaatggagttcaactgacggtcgttgtgg
+gatctgtaaagaaccccatgtggagaggtccacagagattgcccgtgcctgtgaacgagc
+tgccccacggctggaaggcttgggggaaatcgtacttcgtcagagcagcaaagacaaata
+acagctttgtcgtggatggtgacacactgaaggaatgcccactcaaacatagagcatgga
+acagctttcttgtggaggatcatgggttcggggtatttcacactagtgtctggctcaagg
+ttagagaagattattcattagagtgtgatccagccgttattggaacagctgttaagggaa
+aggaggctgtacacagtgatctaggctactggattgagagtgagaagaatgacacatgga
+ggctgaagagggcccatctgatcgagatgaaaacatgtgaatggccaaagtcccacacat
+tgtggacagatggaatagaagagagtgatctgatcatacccaagtctttagctgggccac
+tcagccatcacaataccagagagggctacaggacccaaatgaaagggccatggcacagtg
+aagagcttgaaattcggtttgaggaatgcccaggcactaaggtccacgtggaggaaacat
+gtggaacaagaggaccatctctgagatcaaccactgcaagcggaagggtgatcgaggaat
+ggtgctgcagggagtgcacaatgcccccactgtcgttccgggctaaagatggctgttggt
+atggaatggagataaggcccaggaaagaaccagaaagcaacttagtaaggtcagtggtga
+ctgcaggatcaactgatcacatggatcacttctcccttggagtgcttgtgattctgctca
+tggtgcaggaagggctgaagaagagaatgaccacaaagatcatcataagcacatcaatgg
+cagtgctggtagctatgatcctgggaggattttcaatgagtgacctggctaagcttgcaa
+ttttgatgggtgccaccttcgcggaaatgaacactggaggagatgtagctcatctggcgc
+tgatagcggcattcaaggtcagaccagcgttgctggtatctttcatcttcagagctaatt
+ggacaccccgtgaaagcatgctgctggccttggcctcgtgtcttttgcaaactgcgatct
+ccgccttggaaggcgacctgatggttctcatcaatggttttgctttggcctggttggcaa
+tacgagcgatggttgttccacgcactgataacatcaccttggcaatcctggctgctctga
+caccactggcccggggcacactgcttgtggcgtggagagcaggccttgctacttgcgggg
+ggtttatgctcctctctctgaagggaaaaggcagtgtgaagaagaacttaccatttgtca
+tggccctgggactaaccgctgtgaggctggtcgaccccatcaacgtggtgggactgctgt
+tgctcacaaggagtgggaagcggagctggccccctagcgaagtactcacagctgttggcc
+tgatatgcgcattggctggagggttcgccaaggcagatatagagatggctgggcccatgg
+ccgcggtcggtctgctaattgtcagttacgtggtctcaggaaagagtgtggacatgtaca
+ttgaaagagcaggtgacatcacatgggaaaaagatgcggaagtcactggaaacagtcccc
+ggctcgatgtggcgctagatgagagtggtgatttctccctggtggaggatgacggtcccc
+ccatgagagagatcatactcaaggtggtcctgatgaccatctgtggcatgaacccaatag
+ccataccctttgcagctggagcgtggtacgtatacgtgaagactggaaaaaggagtggtg
+ctctatgggatgtgcctgctcccaaggaagtaaaaaagggggagaccacagatggagtgt
+acagagtaatgactcgtagactgctaggttcaacacaagttggagtgggagttatgcaag
+agggggtctttcacactatgtggcacgtcacaaaaggatccgcgctgagaagcggtgaag
+ggagacttgatccatactggggagatgtcaagcaggatctggtgtcatactgtggtccat
+ggaagctagatgccgcctgggacgggcacagcgaggtgcagctcttggccgtgccccccg
+gagagagagcgaggaacatccagactctgcccggaatatttaagacaaaggatggggaca
+ttggagctgttgcgctggattacccagcaggaacttcaggatctccaatcctagacaagt
+gtgggagagtgataggactttatggcaatggggtcgtgatcaaaaatgggagttatgtta
+gtgccatcacccaagggaggagggaggaagagactcctgttgagtgcttcgagccttcga
+tgctgaagaagaagcagctaactgtcttagacttgcatcctggagctgggaaaaccagga
+gagttcttcctgaaatagtccgtgaagccataaaaacaagactccgtactgtgatcttag
+ctccaaccagggttgtcgctgctgaaatggaggaagcccttagagggcttccagtgcgtt
+atatgacaacagcagtcaatgtcacccactctggaacagaaatcgtcgacttaatgtgcc
+atgccaccttcacttcacgtctactacagccaatcagagtccccaactataatctgtata
+ttatggatgaggcccacttcacagatccctcaagtatagcagcaagaggatacatttcaa
+caagggttgagatgggcgaggcggctgctatcttcatgaccgccacgccaccaggaaccc
+gtgacgcatttccggactccaactcaccaattatggacaccgaagtggaagtcccagaga
+gagcctggagctcaggctttgattgggtgacggatcattctggaaaaacagtttggtttg
+ttccaagcgtgaggaacggcaatgagatcgcagcttgtctgacaaaggctggaaaacggg
+tcatacaactcagcagaaagacttttgagacagagttccagaaaacaaaacatcaagagt
+gggactttgtcgtgacaactgacatttcagagatgggcgccaactttaaagctgaccgtg
+tcatagattccaggagatgcctaaagccggtcatacttgatggcgagagagtcattctgg
+ctggacccatgcctgtcacacatgccagcgctgcccagaggagggggcgcataggcagga
+atcccaacaaacctggagatgagtatctgtatggaggtgggtgcgcagagactgacgaag
+accatgcacactggcttgaagcaagaatgctccttgacaatatttacctccaagatggcc
+tcatagcctcgctctatcgacctgaggccgacaaagtagcagccattgagggagagttca
+agcttaggacggagcaaaggaagacctttgtggaactcatgaaaagaggagatcttcctg
+tttggctggcctatcaggttgcatctgccggaataacctacacagatagaagatggtgct
+ttgatggcacgaccaacaacaccataatggaagacagtgtgccggcagaggtgtggacca
+gacacggagagaaaagagtgctcaaaccgaggtggatggacgccagagtttgttcagatc
+atgcggccctgaagtcattcaaggagtttgccgctgggaaaagaggagccgcttttggag
+tgatggaagccctgggaacactgccaggacacatgacagagagattccaggaagccattg
+acaacctcgctgtgctcatgcgggcagagactggaagcaggccttacaaagccgcggcgg
+cccaattgccggagaccctagagaccattatgcttttggggttgctgggaacagtctcgc
+tgggaatctttttcgtcttgatgaggaacaagggcatagggaagatgggctttggaatgg
+tgactcttggggccagcgcatggctcatgtggctctcggaaattgagccagccagaattg
+catgtgtcctcattgttgtgttcctattgctggtggtgctcatacctgagccagaaaagc
+aaagatctccccaggacaaccaaatggcaatcatcatcatggtagcagtgggtcttctgg
+gcttgattaccgccaatgaactcggatggttggagagaacaaagagtgacctaagccatc
+taatgggaaggagagaggagggagcaaccataggattctcaatggacattgacctgcggc
+cagcctcagcttgggccatctatgctgccttgacaactttcattaccccagccgtccaac
+atgcagtgaccacttcatacaacaactactccttaatggcgatggccacgcaagctggag
+tgttgtttggtatgggcaaagggatgccattctacgcatgggactttggagtcccgctgc
+taatgataggttgctactcacaattaacacccctgaccctaatagtggccatcattttgc
+tcgtggcgcactacatgtacttgatcccagggctgcaggcagcagctgcgcgtgctgccc
+agaagagaacggcagctggcatcatgaagaaccctgttgtggatggaatagtggtgactg
+acattgacacaatgacaattgacccccaagtggagaaaaagatgggacaggtgctactca
+tagcagtagccgtctccagcgccatactgtcgcggaccgcctgggggtggggggaggctg
+gggccctgatcacagccgcaacttccactttgtgggaaggctctccgaacaagtactgga
+actcctctacagccacttcactgtgtaacatttttaggggaagttacttggctggagctt
+ctctaatctacacagtaacaagaaacgctggcttggtcaagagacgtgggggtggaacag
+gagagaccctgggagagaaatggaaggcccgcttgaaccagatgtcggccctggagttct
+actcctacaaaaagtcaggcatcaccgaggtgtgcagagaagaggcccgccgcgccctca
+aggacggtgtggcaacgggaggccatgctgtgtcccgaggaagtgcaaagctgagatggt
+tggtggagcggggatacctgcagccctatggaaaggtcattgatcttggatgtggcagag
+ggggctggagttactacgccgccaccatccgcaaagttcaagaagtgaaaggatacacaa
+aaggaggccctggtcatgaagaacccgtgttggtgcaaagctatgggtggaacatagtcc
+gtcttaagagtggggtggacgtctttcatatggcggctgagccgtgtgacacgttgctgt
+gtgacataggtgagtcatcatctagtcctgaagtggaagaagcacggacgctcagagtcc
+tctccatggtgggggattggcttgaaaaaagaccaggagccttttgtataaaagtgttgt
+gcccatacaccagcactatgatggaaacactggagcgactgcagcgtaggtatgggggag
+gactggtcagagtgccactctcccgcaactctacacatgagatgtactgggtctctggag
+cgaaaagcaacaccataaaaagtgtgtccaccacgagccagctcctcttggggcgcatgg
+acgggcctaggaggccagtgaaatatgaggaggatgtgaatctcggctctggcacgcggg
+ctgtggtaagctgcgctgaagctcccaacatgaagatcattggtaaccgcattgaaagga
+tccgcagtgagcacgcggaaacgtggttctttgacgagaaccacccatacaggacatggg
+cttaccatggaagctatgaggcccccacacaagggtcagcgtcctctctaataaacgggg
+ttgtcaggctcctgtcaaaaccctgggatgtggtgactggagtcacaggaatagccatga
+ccgacaccacaccgtatggtcagcaaagagttttcaaggaaaaagtggacactagggtgc
+cagacccccaagaaggcactcgtcaggttatgagcatggtctcttcctggttgtggaaag
+agctaggcaaacacaaacggccacgagtctgtaccaaagaagagtttatcaacaaggttc
+gtagcaatgcagcattaggggcaatatttgaagaggaaaaagagtggaagactgcagtgg
+aagctgtgaacgatccaaggttctgggctctagtggacaaggaaagagagcaccacctga
+gaggagagtgccagagttgtgtgtacaacatgatgggaaaaagagaaaagaaacaagggg
+aatttggaaaggccaagggcagccgcgccatctggtatatgtggctaggggctagatttc
+tagagttcgaagcccttggattcttgaacgaggatcactggatggggagagagaactcag
+gaggtggtgttgaagggctgggattacaaagactcggatatgtcctagaagagatgagtc
+gcataccaggaggaaggatgtatgcagatgacactgctggctgggacacccgcatcagca
+ggtttgatctggagaatgaagctctaatcaccaaccaaatggagaaagggcacagggcct
+tggcattggccataatcaagtacacataccaaaacaaagtggtaaaggtccttagaccag
+ctgaaaaagggaaaacggttatggacattatttcgagacaagaccaaagggggagcggac
+aagttgtcacttacgctcttaacacatttaccaacctagtggtgcaactcattcggaata
+tggaggctgaggaagttctagagatgcaagacttgtggctgctgcggaggtcagagaaag
+tgaccaactggttgcagagcaacggatgggataggctcaaacgaatggcagtcagtggag
+atgattgcgttgtgaagccaattgatgataggtttgcacatgccctcaggttcttgaatg
+atatgggaaaagttaggaaggacacacaagagtggaaaccctcaactggatgggacaact
+gggaagaagttccgttttgctcccaccacttcaacaagctccatctcaaggacgggaggt
+ccattgtggttccctgccgccaccaagatgaactgattggccgggcccgcgtctctccag
+gggcgggatggagcatccgggagactgcttgcctagcaaaatcatatgctcaaatgtggc
+agctcctttatttccacagaagggacctccgactgatggccaatgccatttgttcatctg
+tgccagttgactgggttccaactgggagaactacctggtcaatccatggaaagggagaat
+ggatgaccactgaagacatgcttgtggtgtggaatagagtgtggattgaggagaacgacc
+acatggaagacaagaccccagttacgaaatggacagacattccctatttgggaaaaaggg
+aagacttgtggtgtggatctctcatagggcacagaccgcgcaccacctgggctgagaaca
+ttaaaaacacagtcaacatggtgcgcaggatcataggtgatgaagaaaagtacatggact
+acctatccacccaagttcgctacttgggtgaagaagggtctacgcctggagtgctgtaag
+caccaatcctaatgttgtcaggcctgctagtcagccacagcttggggaaagctgtgcagc
+ctgtgacccccccaggagaagctgggaaaccaagcctatagtcaggccgagaacgccatg
+gcacggaagaagccatgctgcctgtgagcccctcagaggacactgagtcaaaaaacccca
+cgcgcttggaggcgcaggatgggaaaagaaggtggcgaccttccccacccttcaatctgg
+ggcctgaactggagatcagctgtggatctccagaagagggactagtggttagaggagacc
+ccccggaaaacgcaaaacagcatattgacgctgggaaagaccagagactccatgagtttc
+caccacgctggccgccaggcacagatcgccgaatagcggcggccggtgtggggaaatcca
+tgggagatcgga
+>HND/2016/HU_ME59
+gtttgaagcgaaagctagcaacagtatcaacaggttttattttggatttggaaacgagag
+tttctggtcatgaaaaacccaaaaaagaaatccggaggattccggattgtcaatatgcta
+aaacgcggagtagcccgtgtgagcccctttgggggcttgaagaggctgccagccggactt
+ctgctgggtcatgggcccatcaggatggtcttggcgattctagcctttttgagattcacg
+gcaatcaagccatcactgggtctcatcaatagatggggttcagtggggaaaaaagaggct
+atggaaataataaagaagttcaagaaagatctggctgccatgctgagaataatcaatgct
+aggaaggagaagaagagacgaggcgcagatactagtgtcggaattgttggcctcctgctg
+accacagctatggcagcggaggtcactagacgtgggagtgcatactatatgtacttggac
+agaaacgatgctggggaggccatatcttttccaaccacattggggatgaataagtgttat
+atacagatcatggatcttggacacatgtgtgatgccaccatgagctatgaatgccctatg
+ctggatgagggggtggaaccagatgacgtcgattgttggtgcaacacgacgtcaacttgg
+gttgtgtacggaacctgccatcacaaaaaaggtgaagcacggagatctagaagagctgtg
+acgctcccctcccattccactaggaagctgcaaacgcggtcgcaaacctggttggaatca
+agagaatacacaaagcacttgattagagtcgaaaattggatattcaggaaccctggcttc
+gcgttagcagcagctgccatcgcttggcttttgggaagctcaacgagccaaaaagtcata
+tacttggtcatgatactgctgattgccccggcatacagcatcaggtgcataggagtcagc
+aatagggactttgtggaaggtatgtcaggtgggacttgggttgatgttgtcttggaacat
+ggaggttgtgtcaccgtaatggcacaggacaaaccgactgtcgacatagagctggttaca
+acaacagtcagcaacatggcggaggtaagatcctactgctatgaggcatcaatatcagac
+atggcttcggacagccgctgcccaacacaaggtgaagcctaccttgacaagcaatcagac
+actcaataygtctgcaaaagaacgttagtggacagaggctggggaaatggatgtggactt
+tttggcaaagggagcctggtgacatgcgctaagtttgcatgctccaagaaaatgaccggg
+aagagcatccagccagagaatctggagtaccggataatgctgtcagttcatggctcccag
+cacagtgggatgatcgttaatgacacaggacatgaaactgatgagaatagagcgaaggtt
+gagataacgcccawttcaccaagagccgaagccaccctggggggttttggaagcctagga
+cttgattgtgaaccgaggacaggccttgacttttcagatttgtattacttgactatgaat
+aacaagcactggttggttcacaaggagtggttccacgacattccattaccttggcacgct
+ggggcagacaccggaactccacactggaacaacaaagaagcactggtagagttcaaggac
+gcacatgccaaaaggcaaactgtcgtggttctagggagtcaagaaggagcagttcacacg
+gcccttgctggagctctggaggctgagatggatggtgcaaagggaaggctgtcctctggc
+cacttgaaatgtcgcctgaaaatggataaacttagattgaagggcgtgtcatactccttg
+tgtaccgcagcgttcacattcaccaagatcccggctgaaacactgcacgggacagtcaca
+gtggaggtacagtacgcagggacagatggaccttgcaaggttccagctcagatggcggtg
+gacatgcaaactctgaccccagttgggaggttgataaccgctaaccccgtaatcactgaa
+agcactgagaactctaagatgatgctggaacttgatccaccatttggggactcttacatt
+gtcataggagtcggggagaagaagatcacccaccactggcacaggagtggcagcaccatt
+ggaaaagcatttgaagccactgtgagaggtgccaagagaatggcagtcttgggagacaca
+gcctgggactttggatcagttggaggcgctctcaactcattgggcaagggcatccatcaa
+atttttggagcagctttcaaatcattgtttggaggaatgtcctggttctcacaaattctc
+attggaacgttgctgatgtggttgggtctgaacacaaagaatggatctatttcccttatg
+tgcttggccttagggggagtgttgatcttcttatccacagccgtctctgctgatgtgggg
+tgctcggtggacttctcaaagaaggagacgagatgcggtacaggggtgttcgtctataac
+gacgttgaagcctggagggacaggtacaagtaccatcctgactccccccgtagattggca
+gcagcagtcaagcaagcctgggaagatggtatctgcgggatctcctctgtttcaagaatg
+gaaaacatcatgtggagatcagtagaaggggagctcaacgcaatcctggaagagaatgga
+gttcaactgacggtcgttgtgggatctgtaaaaaaccccatgtggagagctccacagaga
+ttgcccgtgcctgtgaacgagctgccccacggctggaaggcttgggggaaatcgtacttc
+gtcagagcagcaaagacaaataacagctttgtcgtggatggtgacacactgaaggaatgc
+ccactcaaacatagagcatggaacagctttcttgtggaggatcatgggttcggggtattt
+cacactagtgtctggctcaaggttagagaagattattcattagagtgtgatccagccgtt
+attggaacagctgttaagggaaaggaggctgtacacagtgatctaggctactggattgag
+agtgagaagaatgacacatggaggctgaagagggcccatctgatcgagatgaaaacatgt
+gaatggccaaagtcccacacattgtggacagatggaatagaagagagtgatctgatcata
+cccaagtctttagctgggccactcagccatcacaataccagagagggctacaggacccaa
+atgaaagggccatggcacagtgaagagcttgaaattcggtttgaggaatgcccaggcact
+aaggtccacgtggaggaaacatgtggaacaagaggaccatctctgagatcaaccactgca
+agcggaagggtgatcgaggaatggtgctgcagggagtgcacaatgcccccactgtcgttc
+cgggctaaagatggctgttggtatggaatggagataaggcccaggaaagaaccagaaagc
+aacttagtaaggtcaatggtgactgcaggatcaactgatcacatggatcacttctccctt
+ggagtgcttgtgattctgctcatggtgcaggaagggctaaagaagagaatgaccacaaag
+atcatcataagcacatcaatggcagtgctggtagctatgatcctgggaggattttcaatg
+agtgacctggctaagcttgcaattttgatgggtgccaccttcgcggaaatgaacactgga
+ggagatgtagctcatctggcgctgatagcggcattcaaagtcagaccagcgttgctggta
+tctttcatcttcagagctaattggacaccccgtgaaagcatgctactggccttggcctcg
+tgtcttttgcaaactgcgatctccgccttggaaggcgacctgatggttctcatcaatggt
+tttgctttggcctggttggcaatacgagcgatggttgttccacgcactgataacatcacc
+ttggcaatcctggctgctctgacaccactggcccggggcacactgcttgtggcgtggaga
+gcaggccttgctacttgcggggggtttatgctcctctctctgaagggaaaaggcagtgtg
+aagaagaacttaccatttgtcatggccctgggactaaccgctgtgaggctggtcgacccc
+atcaacgtggtgggactgctgttgctcacaaggagtgggaagcggagctggccccctagc
+gaagtactcacagctgttggcctgatatgcgcattggctggagggttcgccaaggcagat
+atagagatggctgggcccatggccgcggtcggtctgctaattgtcagttacgtggtctca
+ggaaagagtgtggacatgtacattgaaagagcaggtgacatcacatgggaaaaagatgcg
+gaagtcactggaaacagtccccggctcgatgtggcgctagatgagagtggtgatttctcc
+ctggtggaggatgacggtccccccatgagagagatcatactcaaggtggtcctgatgacc
+atctgtggcatgaacccaatagccataccctttgcagctggagcgtggtacgtatacgtg
+aagactggaaaaaggagtggtgctctatgggatgtgcctgctcccaaggaagtaaaaaag
+ggggagaccacagatggagtgtacagagtaatgactcgtagactgctaggttcaacacaa
+gttggagtgggagtcatgcaagagggggtctttcacactatgtggcacgtcacaaaagga
+tccgcactgagaagcggtgaagggagacttgatccatactggggagatgtcaagcaggat
+ctggtgtcatactgtggtccatggaagctagatgccgcctgggacgggcacagcgaggtg
+cagctcctggccgtgccccccggagagagagcgaggaacatccagactctgcccggaata
+tttaagacaaaggatggggacattggagcggttgcgctggattacccagcaggaacttca
+ggatctccaatcctagacaagtgtgggagagtgataggactttatggcaatggggtcgtg
+atcaaaaatgggagttatgttagtgccatcacccaagggaggagggaggaagagactcct
+gttgagtgcttcgagccttcgatgctgaagaagaagcagctaactgtcttagacttacat
+cctggagctgggaaaaccaggagagttcttcctgaaatagtccgtgaagccataaaaaca
+agactccgtactgtgatcttagctccaaccagggttgtcgctgctgaaatggaggaggcc
+cttagagggcttccagtgcgttatatgacaacagcagtcaatgtcacccactctggaaca
+gaaatcgtcgacttaatgtgccatgccaccttcacttcacgtctactacagccaatcaga
+gtccccaactataatctgtatattatggatgaggcccacttcacagatccctcaagtata
+gcagcaagaggatacatttcaacaagggttgagatgggcgaggcggctgccatcttcatg
+accgccacgccaccaggaacccgtgacgcatttccggactccaactcaccaattatggac
+accgaagtggaagtcccagagagagcctggagctcaggctttgattgggtgacggatcat
+tctggaaaaacagtttggtttgttccaagcgtgaggaacggcaatgagatcgcagcttgt
+ctgacaaaggctggaaaacgggtcatacagctcagcagaaagacttttgagacagagttc
+cagaaaacaaaacatcaagagtgggactttgtcgtgacaactgacatttcagagatgggc
+gccaactttaaagctgaccgtgtcatagattccaggagrtgcctaaagccggtcatactt
+gatggcgagagagtcattctggctggacccatgcctgtcacacatgccagcgctgcccag
+aggagggggcgcataggcaggaatcccaacaaacctggagatgagtatctgtatggaggt
+gggtgcgcagagactgacgaagaccatgcacactggcttgaagcaagaatgctccttgac
+aatatttacctccaagatggcctcatagcctcgctctatcgacctgaggccgacaaagta
+gcagccattgagggagagttcaagcttaggacggagcaaaggaagacctttgtggaactc
+atgaaaagaggagatcttcctgtttggctggcctatcaggttgcatctgccggaataacc
+tacacagatagaagatggtgctttgatggcacgaccaacaacaccatactggaagacagt
+gtgccggcagaggtgtggaccagacacggagagaaaagagtgctcaaaccgaggtggatg
+gacgccagagtttgttcagatcatgcggccctgaagtcattcaaggagtttgccgctggg
+aaaagaggagcggcttttggagtgatggaagccctgggaacactgccaggacacatgaca
+gagagattccaggaagccattgacaacctcgctgtgctcatgcgggcagagactggaagc
+aggccttacaaagccgcggcggcccaattgccggagaccctagagaccattatgcttttg
+gggttgctgggaacagtctcgctgggaatctttttcgtcttgatgaggaacaagggcata
+gggaagatgggctttggaatggtgacccttggggccagtgcatggctcatgtggctctcg
+gaaattgagccagccagaattgcatgtgtcctcattgttgtgttcctattgctggtggtg
+ctcatacctgagccagaaaagcaaagatctccccaggacaaccaaatggcaatcatcatc
+atggtagcagtaggtcttctgggcttgattaccgccaatgaactcggatggttggagaga
+acaaagagtgacctaagccatctgatgggaaggagagaggagggggcaaccataggattc
+tcaatggacattgacctgcggccagcctcagcttgggccatctatgctgccttgacaact
+ttcattaccccagccgtccaacatgcagtgaccacttcatacaacaactactccttaatg
+gcgatggccacgcaagctggagtgttgtttggtatgggcaaagggatgccattctacgca
+tgggactttggagtcccgctgctaatgataggttgctactcacaattaacacccctgacc
+ctaatagtggccatcattttgctcgtggcgcactacatgtacttgatcccagggctgcag
+gcagcagctgcgcgtgctgcccagaagagaacggcagctggcatcatgaagaaccctgtt
+gtggatggaatagtggtgactgacattgacacaatgacaattgacccccaagtggagaaa
+aagatgggacaggtgctactcatagcagtagccgtctccagcgccatactgtcgcggacc
+gcctgggggtggggggaggctggggccctgatcacagccgcaacttccactttgtgggaa
+ggctctccgaacaagtactggaactcctctacagccacttcactgtgtaacatttttagg
+ggaagttacttggctggagcttctctaatctacacagtaacaagaaacgctggcttggtc
+aagagacgtgggggtggaacaggagagaccctgggagagaaatggaaggcccgcttgaac
+cagatgtcggccctggagttctactcctacaaaaagtcaggcatcaccgaggtgtgcaga
+gaagaggcccgccgcgccctcaaggacggtgtggcaacgggaggccatgctgtgtcccga
+ggaagtgcaaagctgagatggttggtggagcggggatacctgcagccctatggaaaggtc
+attgatcttggatgtggcagagggggctggagttactacgccgccaccatccgcaaagtt
+caagaagtgaaaggatacacaaaaggaggccctggtcatgaagaacccgtgttggtgcaa
+agctatgggtggaacatagtccgtcttaagagtggggtggacgtctttcatatggcggct
+gagccgtgtgacacgttgctgtgtgacataggtgagtcatcatctagtcctgaagtggaa
+gaagcacggacgctcagagtcctctccatggtgggggattggcttgaaaaaagaccagga
+gccttttgtataaaagtgttgtgcccatacaccagcactatgatggaaaccctggagcga
+ctgcagcgtaggtatgggggaggactggtcagagtgccactctcccgcaactctacacat
+gagatgtactgggtctctggagcgaaaagcaacaccataaaaagtgtgtccaccacgagc
+cagctcctcttggggcgcatggacgggcctaggaggccagtgaaatatgaggaggatgtg
+aatctcggctctggcacgcgggctgtggtaagctgcgctgaagctcccaacatgaagatc
+attggtaaccgcattgaaaggatccgcagtgagcacgcggaaacgtggttctttgacgag
+aaccacccatataggacatgggcttaccatggaagctatgaggcccccacacaagggtca
+gcgtcctctctaataaacggggttgtcaggctcctgtcaaaaccctgggatgtggtgact
+ggagtcacaggaatagccatgaccgacaccacaccgtatggtcagcaaagagttttcaag
+gaaaaagtggacactagggtgccagacccccaagaaggcactcgtcaggttatgagcatg
+gtctcttcctggttgtggaaagagctaggcaaacacaaacggccacgagtctgtaccaaa
+gaagagttcatcaacaaggttcgtagcaatgcagcattaggggcaatatttgaagaggaa
+aaagagtggaagactgcagtggaagctgtgaacgatccaaggttctgggctctagtggac
+aaggaaagagagcaccacctgagaggagagtgccagagttgtgtgtacaacatgatggga
+aaaagagaaaagaaacaaggggaatttggaaaggccaagggcagccgcgccatctggtat
+atgtggctaggggctagatttctagagttcgaagcccttggattcttgaacgaggatcac
+tggatggggagagagaactcaggaggtggtgttgaagggctgggattacaaagactcgga
+tatgtcctagaagagatgagttgcataccaggaggaaggatgtatgcagatgacactgct
+ggctgggacacccgcatcagcaggtttgatctggagaatgaagctctaatcaccaaccaa
+atggagaaagggcacagggccttggcattggccataatcaagtacacataccaaaacaaa
+gtggtaaaggtccttagaccagctgaaaaagggaaaacagttatggacattatttcgaga
+caagaccaaagggggagcggacaagttgtcacttacgctcttaacacatttaccaaccta
+gtggtgcaactcatccggaatatggaggctgaggaagttctagagatgcaagacttgtgg
+ctgctgcggaggtcagagaaagtgaccaactggttgcagagcaacggatgggataggctc
+aaacgaatggcagtcagtggagatgattgcgttgtgaagccaattgatgataggtttgca
+catgccctcaggttcttgaatgatatgggaaaagttaggaaggacacacaagagtggaaa
+ccctcaactggatgggacaactgggaagaagttccgttttgctcccaccacttcaacaag
+ctccatctcaaggacgggaggtccattgtggttccctgccgccaccaagatgaactgatt
+ggccgggcccgcgtctctccaggggcgggatggagcatccgggagactgcttgcctagca
+aaatcatatgcgcaaatgtggcagctcctttatttccacagaagggacctccgactgatg
+gccaatgccatttgttcatctgtgccagttgactgggttccaactgggagaactacctgg
+tcaatccatggaaagggagaatggatgaccactgaagacatgcttgtggtgtggaacaga
+gtgtggattgaggagaacgaccacatggaagacaagaccccagttacgaaatggacagac
+attccctatttgggaaaaagggaagacttgtggtgtggatctctcatagggcacagaccg
+cgcaccacctgggctgagaacattaaaaacacagtcaacatggtgcgcaggatcataggt
+gatgaagaaaagtacatggactacctatccacccaagttcgctacttgggtgaagaaggg
+tctacacctggagtgctgtaagcaccaatcttaatgttgtcaggc
diff --git a/tests/functional/parse/zika.fasta b/tests/functional/parse/zika.fasta
new file mode 100644
index 000000000..2bedf720e
--- /dev/null
+++ b/tests/functional/parse/zika.fasta
@@ -0,0 +1,24 @@
+>PAN/CDC_259359_V1_V3/2015|zika|KX156774|2015-12-18|north_america|panama|panama|panama|genbank|genome|Shabman et al|https://www.ncbi.nlm.nih.gov/nuccore/KX156774|Direct Submission|Submitted (29-APR-2016) J. Craig Venter Institute, 9704 Medical Center Drive, Rockville, MD 20850, USA|https://www.ncbi.nlm.nih.gov/pubmed/
+gaatttgaagcgaatgctaacaacagtatcaacaggttttattttggatttggaaacgagagtttctggtcatgaaaaacccaaaaaagaaatccggaggattccggattgtcaatatgctaaaacgcggagtagcccgtgtgagcccctttgggggcttgaagaggctgccagccggacttctgctgggtcatgggcccatcaggatggtcttggcgattctagcctttttgagattcacggcaatcaagccatcactgggtctcatcaatagatggggttcagtggggaaaaaagaggctatggaaataataaagaagttcaagaaagatctggctgccatgctgagaataatcaatgctaggaaggagaagaagagacgaggcgcagaaactagtgtcggaattgttggcctcctgctgaccacagctatggcagcggaggtcactagacgtgggagtgcatactatatgtacttggacagaaacgatgctggggaggccatatcttttccaaccacattggggatgaataagtgttatatacagatcatggatcttggacacatgtgtgatgccaccatgagctatgaatgccctatgctggatgagggggtggaaccagatgacgtcgattgttggtgcaacacgacgtcaacttgggttgtgtacggaacctgccatcacaaaaaaggtgaagcacggagatctagaagagccgtgacgctcccctcccattccactaggaagctgcaaacgcggtcgcaaacctggttggaatcaagagaatacacaaagcacttgattagagtcgaaaattggatattcaggaaccctggtttcgctttagcagcagctgccatcgcttggcttttgggaagctcaacgagccaaaaagtcatatacttggtcatgatactgctgattgccccggcatacagcatcaggtgcataggagtcagcaatagggactttgtggaaggtatgtcaggtgggacttgggttgatgtcgtcttggaacatggaggttgtgtcaccgtaatggcacaggacaaaccgactgtcgacatagagctggttacaacaacagtcagcaacatggcggaggtaagatcctactgctatgaggcatcaatatcagacatggcttcggacagccgctgcccaacacaaggtgaagcctaccttgacaagcaatcagacactcaatatgtctgcaaaagaacgttagtggacagaggctggggaaatggatgtggactttttggcaaagggagcctggtgacatgcgctaagtttgcatgctccaagaaaatgaccgggaagagcatccagccagagaatctggagtaccggataatgttgtcagttcatggctcccagcacagtgggatgatcgttaatgacacaggacatgaaactgatgagaatagagcgaaggttgagataacgcccaattcaccaagagccgaagccaccctggggggttttggaagcctaggacttgattgtgaaccgaggacaggccttgacttttcagatttgtattacttgactatgaataacaagcactggttggttcacaaggagtggttccacgacattccattaccttggcacgctggggcagacaccggaactccacactggaacaacaaagaagcactggtagagttcaaggacgcacatgccaaaaggcaaactgtcgtggttctagggagtcaagaaggagcagttcacacggcccttgctggagctctggaggctgagatggatggtgcaaagggaaggctgtcctctggccacttgaaatgtcgcctgaaaatggataaacttagattgaagggcgtgtcatactccttgtgtaccgcagcgttcacattcaccaagatcccggctgaaacactgcacgggacagtcacagtggaggtacagtacgcagggacagatggaccttgcaaggttccagctcagatggcggtggacatgcaaactctgaccccagttgggaggttgataaccgctaaccccgtaatcactgaaagcactgagaactctaagatgatgctggaacttgatccaccatttggggactcttacattgtcataggagtcggggagaagaagatcacccaccactggcacaggagtggcagcaccattggaaaagcatttgaagccactgtgagaggtgccaagagaatggcagtcttgggagacacagcctgggactttggatcagttggaggcgctctcaactcattgggcaagggcatccatcaaatttttggagcagctttcaaatcattgtttggaggaatgtcctggttctcacaaattctcattggaacgttgctgatgtggttgggtctgaacacaaagaatggatctatttcccttatgtgcttggccttagggggagtgttgatcttcttatccacagccgtctctgctgatgtggggtgctcggtggacttctcaaagaaggagacgagatgtggtacaggggtgttcgtctacaacgacgttgaagcctggagggacaggtacaagtaccatcctgactccccccgtagattggcagcagcagtcaagcaagcctgggaagatggtatctgcgggatctcctctgtttcaagaatggaaaacatcatgtggagatcagtagaaggggagctcaacgcaatcctggaagagaatggagttcaactgacggtcgttgtgggatctgtaaaaaaccccatgtggagaggtccacagagattgcccgtgcctgtgaacgagctgccccacggctggaaggcttgggggaaatcgtacttcgtcagagcagcaaagacaaataacagctttgtcgtggatggtgacacactgaaggaatgcccactcaaacatagagcatggaacagctttcttgtggaggatcatgggttcggggtatttcacactagtgtctggctcaaggttagagaagattattcattagagtgtgatccagccgttattggaacagctgttaagggaaaggaggctgtacacagtgatctaggctactggattgagagtgagaagaatgacacatggaggctgaagagggcccatctgatcgagatgaaaacatgtgaatggccaaagtcccacacattgtggacagatggaatagaagagagtgatctgatcatacccaagtctttagctgggccactcagccatcacaataccagagagggctacaggacccaaatgaaagggccatggcacagtgaagagcttgaaattcggtttgaggaatgcccaggcactaaggtccacgtggaggaaacatgtggaacaagaggaccatctctgagatcaaccactgcaagcggaagggtgatcgaggaatggtgctgcagggagtgcacaatgcccccactgtcgttctgggctaaagatggctgttggtatggaatggagataaggcccaggaaagaaccagaaagcaacttagtaaggtcaatggtgactgcaggatcaactgatcacatggatcacttctcccttggagtgcttgtgattctgctcatggtgcaggaagggctgaagaagagaatgaccacaaagatcatcataagcacatcaatggcagtgctggtagctatgatcctgggaggattttcaatgagtgacctggctaagcttgcaatcttgatgggtgccaccttcgcggaaatgaacactggaggagatgtggctcatctggcgctgatagcagcattcaaagtcagaccagcgttgctggtatctttcatcttcagagctaattggacaccccgtgaaagcatgctgctggccttggcctcgtgtcttttgcaaactgcgatctccgccttggagggcgacctgatggttctcatcaatggttttgctttggcctggttggcaatacgagcgatggttgttccacgcactgacaacatcaccttggcaatcctggctgctctgacaccactggcccggggcacactgcttgtggcgtggagagcaggccttgctacttgcggggggtttatgctcctctctctgaagggaaaaggcagtgtgaagaagaacttaccatttgtcatggccctgggactaaccgctgtgaggctggtcgaccccatcaacgtggtgggactgctgttgctcacaaggagtgggaagcggagctggccccctagcgaagtactcacagctgttggcctgatatgcgcattggctggagggttcgccaaggcagatatagagatggctgggcccatagccgcggtcggtctgctaattgtcagttacgtggtctcaggaaagagtgtggacatgtacattgaaagagcaggtgacatcacatgggaaaaagatgcggaagtcactggaaacagtccccggctcgatgtggcgctagatgagagtggtgatttctccctggtggaggatgacggtccccccatgagagagatcatactcaaggtggtcctgatgaccatctgtggcatgaacccaatagccataccctttgcagctggagcgtggtacgtatacgtgaagactggaaaaaggagtggtgctctatgggatgtgcctgctcccaaggaagtaaaaaagggggagaccacagatggagtgtacagagtaatgactcgtagactgctaggttcaacacaagttggagtgggagttatgcaagagggggtctttcacactatgtggcacgtcacaaaaggatccgcgctgagaagcggtgaagggagacttgatccatactggggagatgtcaagcaggatctggtgtcatactgtggtccatggaagctagatgccgcctgggacgggcacagcgaggtgcagctcttggccgtgccccccggagagagagcgaggaacatccagactctgcccggaatatttaagacaaaggatggggacattggagcggttgcgctggattacccagcaggaacttcaggatctccaatcctagacaagtgtgggagagtgataggactttatggcaatggggtcgtgatcaaaaatgggagttatgttagtgccatcacccaagggaggagggaggaagagactcctgttgagtgcttcgagccttcgatgctgaagaagaagcagctaactgtcttagacttgcatcctggagctgggaaaaccaggagagttcttcctgaaatagtccgtgaagccataaaaacaagactccgtactgtgatcttagctccaaccagggttgtcgctgctgaaatggaggaagcccttagagggcttccagtgcgttatatgacaacagcagtcaatgtcacccactctggaacagaaatcgtcgacttaatgtgccatgccaccttcacttcacgtctactacagccaatcagagtccccaactataatctgtatattatggatgaggcccacttcacagatccctcaagtatagcagcaagaggatacatttcaacaagggttgagatgggcgaggcggctgccatcttcatgaccgccacgccaccaggaacccgtgacgcatttccggactccaactcaccaattatggacaccgaagtggaagtcccagagagagcctggagctcaggctttgattgggtgacggatcattctggaaaaacagtttggtttgttccaagcgtgaggaacggcaatgagatcgcagcttgtctgacaaaggctggaaaacgggtcatacagctcagcagaaagacttttgagacagagttccagaaaacaaaacatcaagagtgggactttgtcgtgacaactgacatttcagagatgggcgccaactttaaagctgaccgtgtcatagattccaggagatgcctaaagccggtcatacttgatggcgagagagtcattctggctggacccatgcctgtcacacatgccagcgctgcccagaggagggggcgcataggcaggaatcccaataaacctggagatgagtatctgtatggaggtgggtgcgcagagactgacgaagaccatgcacactggcttgaagcaagaatgctccttgacaatatttacctccaagatggcctcatagcctcgctctatcgacctgaggccgacaaagtagcagccattgagggagagttcaagcttaggacggagcaaaggaagacctttgtggaactcatgaaaagaggagatcttcctgtttggctggcctatcaggttgcatctgccggaataacctacacagatagaagatggtgctttgatggcacgaccaacaacaccataatggaagacagtgtgccggcagaggtgtggaccagacacggagagaaaagagtgctcaaaccgaggtggatggacgccagagtttgttcagatcatgcggccctgaagtcattcaaggagtttgccgctgggaaaagaggagcggcttttggagtgatggaagccctgggaacactgccaggacacatgacagagagattccaggaagccattgacaacctcgctgtgctcatgcgggcagagactggaagcaggccttacaaagccgcggcggcccaattgccggagaccctagagaccattatgcttttggggttgctgggaacagtctcgctgggaatctttttcgtcttgatgaggaacaagggcatagggaagatgggctttggaatggtgactcttggggccagcgcatggctcatgtggctctcggaaattgagccagccagaattgcatgtgtcctcattgttgtgttcctattgctggtggtgctcatacctgagccagaaaagcaaagatctccccaggacaaccaaatggcaatcatcatcatggtagcagtaggtcttctgggcttgattaccgccaatgaactcggatggttggagagaacaaagagtgacctaagccatctaatgggaaggagagaggagggggcaaccataggattctcaatggacattgacctgcggccagcctcagcttgggccatctatgctgccttgacaactttcattaccccagctgtccaacatgcagtgaccacttcatacaacaactactccttaatggcgatggccacgcaagctggagtgttgtttggtatgggcaaagggatgccattctacgcatgggactttggagtcccgctgctaatgataggttgctactcacaattaacacccctgaccctaatagtggccatcattttgctcgtggcgcactacatgtacttgatcccagggctgcaggcagcagctgcgcgtgctgcccagaagagaacggcagctggcatcatgaagaaccctgttgtggatggaatagtggtgactgacattgacacaatgacaattgacccccaagtggagaaaaagatgggacaggtgctactcatagcagtagccgtctccagcgccatactgtcgcggaccgcctgggggtggggggaggctggggccctgatcacagccgcaacttccactttgtgggaaggctctccgaacaagtactggaactcctctacagccacttcactgtgtaacatttttaggggaagttacttggctggagcttctctaatctacacagtaacaagaaacgctggcttggtcaagagacgtgggggtggaacaggagagaccctgggagagaaatggaaggcccgcttgaaccagatgtcggccctggagttctactcctacaaaaagtcaggcatcaccgaggtgtgcagagaagaggcccgccgcgccctcaaggacggtgtggcaacgggaggccatgctgtgtcccgaggaagtgcaaagctgagatggttggtggagcggggatacctgcagccctatggaaaggtcattgatcttggatgtggcagagggggctggagttactacgccgccaccatccgcaaagttcaagaagtgaaaggatacacaaaaggaggccctggtcatgaagaacccgtgttggtgcaaagctatgggtggaacatagtccgtcttaagagtggggtggacgtctttcatatggcggctgagccgtgtgacacgttgctgtgtgacataggtgagtcatcatctagtcctgaagtggaagaagcacggacgctcagagtcctctccatggtgggggattggcttgaaaaaagaccaggagccttttgtataaaagtgttgtgcccatacaccagcactatgatggaaaccctggagcgactgcagcgtaggtatgggggaggactggtcagagtgccactctcccgcaactctacacatgagatgtactgggtctctggagcgaaaagcaacaccataaaaagtgtgtccaccacgagccagctcctcttggggcgcatggacgggcctaggaggccagtgaaatatgaggaggatgtgaatctcggctctggcacgcgggctgtggtaagctgcgctgaagctcccaacatgaagatcattggtaaccgcattgaaaggatccgcagtgagcacgcggaaacgtggttctttgacgagaaccacccatataggacatgggcttaccatggaagctatgaggcccccacacaagggtcagcgtcctctctaataaacggggttgtcaggctcctgtcaaaaccctgggatgtggtgactggagtcacaggaatagccatgaccgacaccacaccgtatggtcagcaaagagttttcaaggaaaaagtggacactagggtgccagacccccaagaaggcactcgtcaggttatgagcatggtctcttcctggttgtggaaagagctaggcaaacacaaacggccacgagtctgtaccaaagaagagttcatcaacaaggttcgtagcaatgcagcattaggggcaatatttgaagaggaaaaagagtggaagactgcagtggaagctgtgaacgatccaaggttctgggctctagtggacaaggaaagagagcaccacctgagaggagagtgccagagttgtgtgtacaacatgatgggaaaaagagaaaagaaacaaggggaatttggaaaggccaagggcagccgcgccatctggtatatgtggctaggggctagatttctagagttcgaagcccttggattcttgaacgaggatcactggatggggagagagaactcaggaggtggtgttgaagggctgggattacaaagactcggatatgtcctagaagagatgagtcgcataccaggaggaaggatgtatgcagatgacactgctggctgggacacccgcattagcaggtttgatctggagaatgaagctctaatcaccaaccaaatggagaaagggcacagggccttggcattggccataatcaagtacacataccaaaacaaagtggtaaaggtccttagaccagctgaaaaagggaaaacagttatggacattatttcgagacaagaccaaagggggagcggacaagttgtcacttacgctcttaacacatttaccaacctagtggtgcaactcattcggaatatggaggctgaggaagttctagagatgcaagacttgtggctgctgcggaggtcagagaaagtgaccaactggttgcagagcaacggatgggataggctcaaacgaatggcagtcagtggagatgattgcgttgtgaagccaattgatgataggtttgcacatgccctcaggttcttgaatgatatgggaaaagttaggaaggacacacaagagtggaaaccctcaactggatgggacaactgggaagaagttccgttttgctcccaccacttcaacaagctccatctcaaggacgggaggtccattgtggttccctgccgccaccaagatgaactgattggccgggcccgcgtctctccaggggcgggatggagcatccgggagactgcttgcctagcaaaatcatatgcgcaaatgtggcagctcctttatttccacagaagggacctccgactgatggccaatgccatttgttcatctgtgccagttgactgggttccaactgggagaactacctggtcaatccatggaaagggagaatggatgaccactgaagacatgcttgtggtgtggaacagagtgtggattgaggagaacgaccacatggaagacaagaccccagttgcgaaatggacagacattccctatttgggaaaaagggaagacttgtggtgtggatctctcatagggcacagaccgcgcaccacctgggctgagaacattaaaaacacagtcaacatggtgcgcaggatcataggtgatgaagaaaagtacatggactacctatccacccaagttcgctacttgggtgaagaagggtccacacctggagtgctgtaagcaccaatcttaatgttgtcaggcctgctagtcagccacagcttggggaaagctgtgcagcctgtgacccccccaggagaagctgggaaaccaagcctatagtcaggccgagaacgccatggcacggaagaagccatgctgcctgtgagcccctcagaggacactgagtcaaaaaaccccacgcgcttggaggcgcaggatgggaaaagaaggtggcgaccttccccacccttcaatctggggcctgaactggagatcagctgtggatctccagaagagggactagtggttagaggagaccccccggaaaacgcaaaacagcatattgacgctgggaaagaccagagactccatgagtttccaccacgctggccgccaggcacagatcgccgaatagcggcggccggtgtggggaaatccatgggtct
+>COL/FLR_00024/2015|zika|MF574569|2015-12-XX|south_america|colombia|colombia|colombia|genbank|genome|Pickett et al|https://www.ncbi.nlm.nih.gov/nuccore/MF574569|Direct Submission|Submitted (28-JUL-2017) J. Craig Venter Institute, 9704 Medical Center Drive, Rockville, MD 20850, USA|https://www.ncbi.nlm.nih.gov/pubmed/
+tcagactgcgacagttcgagtttgaagcgaaagctagcaacagtatcaacaggttttattttggatttggaaacgagagtttctggtcatgaaaaacccaaaaaagaaatccggaggattccggattgtcaatatgctaaaacgcggagtagcccgtgtgagcccctttgggggcttgaagaggctgccagccggacttctgctgggtcatgggcccatcaggatggtcttggcgattctagcctttttgagattcacggcaatcaagccatcactgggtctcatcaatagatggggttcagtggggaaaaaagaggctatggaaacaataaagaagttcaagaaagatctggctgccatgctgagaataatcaatgctaggaaggagaagaagagacgaggcgcagaaactagtgtcggaattgttggcctcctgctgaccacagctatggcagcggaggtcactagacgtgggagtgcatactatatgtacttggacagaaacgatgctggggaggccatatcttttccaaccacattggggatgaataagtgttatatacagatcatggatcttggacacatgtgtgatgccaccatgagctatgaatgccctatgctggatgagggggtggaaccagatgacgtcgattgttggtgcaacacgacgtcaacttgggttgtgtacggaacctgccatcacaaaaaaggtgaagcacggagatctagaagagccgtgacgctcccctcccattccactaggaagctgcaaacgcggtcgcaaacctggttggaatcaagagaatacacaaagcacttgattagagtcgaaaattggatattcaggaaccctggtttcgctttagcagcagctgccatcgcttggcttttgggaagctcaacgagccaaaaagtcatatacttggtcatgatactgctgattgccccggcatacagcatcaggtgcataggagtcagcaatagggactttgtggaaggtatgtcaggtgggacttgggttgatgtcgtcttggaacatggaggttgtgtcaccgtaatggcacaggacaaaccgactgtcgacatagagctggttacaacaacagtcagcaacatggcggaggtaagatcctactgctatgaggcatcaatatcagacatggcttcggacagccgctgcccaacacaaggtgaagcctaccttgagaagcaatcagacactcaatatgtctgcaaaagaacgttagtggacagaggctggggaaatggatgtggactttttggcaaagggagcctggtgacatgcgctaagtttgcatgctccaagaaaatgaccgggaagagcatccagccagagaatctggagtaccggataatgttgtcagttcatggctcccagcacagtgggatgatcgttaatgacacaggacatgaaactgatgagaatagagcgaaggttgagataacgcccaattcaccaagagccgaagccaccctggggggctttggaagcctaggacttgattgtgaaccgaggacaggccttgacttttcagatttgtattacttgactatgaataacaagcactggttggttcacaaggagtggttccacgacattccattaccttggcacgctggggcagacaccggaactccacactggaacaacaaagaagcactggtagagttcaaggacgcacatgccaaaaggcaaactgtcgtggttctagggagtcaagaaggagcagttcacacggcccttgctggagctctggaggctgagatggatggtgcaaagggaaggctgtcctctggccacttgaaatgtcgcctgaaaatggataaacttagattgaagggcgtgtcatactccttgtgtaccgcagcgttcacattcaccaagatcccggctgaaacactgcacgggacagtcacagtggaggtacagtacgcagggacagatggaccttgcaaggttccagctcagatggcggtggacatgcaaactctgaccccagttgggaggttgataaccgctaaccccgtaatcactgaaagcactgagaactctaagatgatgctggaacttgatccaccatttggggactcttacattgtcataggagtcggggagaagaagatcacccaccactggcacaggagtggcagcaccattggaaaagcatttgaagccactgtgagaggtgccaagagaatggcagtcttgggagacacagcctgggactttggatcagttggaggcgctctcaactcattgggcaagggcatccatcaaatttttggagcagctttcaaatcattgtttggaggaatgtcctggttctcacaaattctcattggaacgttgctgatgtggttgggtctgaacacaaagaatggatctatttcccttatgtgcttggccttagggggagtgttgatcttcttatccacagccgtctctgctgatgtggggtgctcggtggacttctcaaagaaggagacgagatgtggtacaggggtgttcgtctataacgacgttgaagcctggagggacaggtacaagtaccatcctgactccccccgtagattggcagcagcagtcaagcaagcctgggaagatggtatctgcgggatctcctctgtttcaagaatggaaaacatcatgtggagatcagtagaaggggagctcaacgcaatcctggaagagaatggagttcaactgacggtcgttgtgggatctgtaaaaaaccccatgtggagaggtccacagagattgcccgtgcctgtgaacgagctgccccacggctggaaggcttgggggaaatcgtacttcgtcagagcagcaaagacaaataacagctttgtcgtggatggtgacacactgaaagaatgcccactcaaacatagagcatggaacagctttcttgtggaggatcatgggttcggggtatttcacactagtgtctggctcaaggttagagaagattattcattagagtgtgatccagccgttattggaacagctgttaagggaaaggaggctgtacacagtgatctaggctactggattgagagtgagaagaatgacacatggaggctgaagagggcccatctgatcgagatgaaaacatgtgaatggccaaagtcccacacattgtggacagatggaatagaagagagtgatctgatcatacccaagtctttagctgggccactcagccatcacaataccagagagggctacaggacccaaatgaaagggccatggcacagtgaagagcttgaaattcggtttgaggaatgcccaggcactaaggtccacgtggaggaaacatgtggaacaagaggaccatctctgagatcaaccactgcaagcggaagggtgatcgaggaatggtgctgcagggagtgcacaatgcccccactgtcgttctgggctaaagatggctgttggtatggaatggagataaggcccaggaaagaaccagaaagcaacttagtaaggtcaatggtgactgcaggatcaactgatcacatggatcacttctcccttggagtgcttgtgattctgctcatggtgcaggaagggctgaagaagagaatgaccacaaagatcatcataagcacatcaatggcagtgctggtagctatgatcctgggaggattttcaatgagtgacctggctaagcttgcaatcttgatgggtgccaccttcgcggaaatgaacactggaggagatgtagctcatctggcgctgatagcggcattcaaagtcagaccagcgttgctggtatccttcatcttcagagctaattggacaccccgtgaaagcatgctgctggccttggcctcgtgtcttttgcaaactgcgatctccgccttggagggcgacctgatggttctcatcaatggttttgctttggcctggttggcaatacgagcgatggttgttccacgcactgacaacatcaccttggcaatcctggctgctctgacaccactggcccggggcacactgcttgtggcgtggagagcaggccttgctacttgcggggggtttatgctcctctctctgaagggaaaaggcagtgtgaagaagaacttaccatttgtcatggccctgggactaaccgctgtgaggctggtcgaccccatcaacgtggtgggactgctgttgctcacaaggagtgggaagcggagctggccccctagcgaagtactcacagctgttggcctgatatgcgcattggctggagggttcgccaaggcagatatagagatggctgggcccatggccgcggttggtctgctaattgtcagttacgtggtctcaggaaagagtgtggacatgtacattgaaagagcaggtgacatcacatgggaaaaagatgcggaagtcactggaaacagtccccggctcgatgtggcgctagatgagagtggtgatttctccctggtggaggatgacggtccccccatgagagagatcatactcaaggtggtcctgatgaccatctgtggcatgaacccaatagccataccctttgcagctggagcgtggtacgtatacgtgaagactggaaaaaggagtggtgcgctatgggatgtgcctgctcccaaggaagtaaaaaagggggagaccacagatggagtgtacagagtaatgactcgtagactgctaggttcaacacaagttggagtgggagttatgcaagagggggtctttcacactatgtggcacgtcacaaaaggatccgcgctgagaagcggtgaagggagacttgatccatactggggagatgtcaagcaggatctggtgtcatactgtggtccatggaagctagatgccgcctgggacgggcacagcgaggtgcagctcttggccgtgccccccggagagagagcgaggaacatccagactctgcccggaatatttaagacaaaggatggggacattggagcggttgcgctggattacccagcaggaacttcaggatctccaatcctagacaagtgtgggagagtgataggactttatggcaatggggtcgtgatcaaaaatgggagttatgttagtgccatcacccaagggaggagggaggaagagactcctgttgagtgcttcgagccttcgatgctgaagaagaagcagctaactgtcttagacttgcatcctggagctgggaaaaccaggagagttcttcctgaaatagtccgtgaagccataaaaacaagactccgtactgtgatcttagctccaaccagggttgtcgctgctgaaatggaggaagcccttagagggcttccagtgcgttatatgacaacagcagtcaatgtcacccactctggaacagaaatcgtcgacttaatgtgccatgccaccttcacttcacgtctactacagccaatcagagtccccaactataatctgtatattatggatgaggcccacttcacagatccctcaagtatagcagcaagaggatacatttcaacaagggttgagatgggcgaggcggctgccatcttcatgaccgccacgccaccaggaacccgtgacgcatttccggactccaactcaccaattatggacaccgaagtggaagtcccagagagagcctggagctcaggctttgattgggtgacggatcattctggaaaaacagtttggtttgttccaagcgtgaggaacggcaatgagatcgcagcttgtctgacaaaggctggaaaacgggtcatacagctcagcagaaagacttttgagacagagttccagaaaacaaaacatcaagagtgggactttgtcgtgacaactgacatttcagagatgggcgccaactttaaagctgaccgtgtcatagattccaggagatgcctaaagccggtcatacttgatggcgagagagtcattctggctggacccatgcctgtcacacatgccagcgctgcccagaggagggggcgcataggcaggaatcccaataaacctggagatgagtatctgtatggaggtgggtgcgcagagactgacgaagaccatgcacactggcttgaagcaagaatgctccttgacaatatttacctccaagatggcctcatagcctcgctctatcgacctgaggccgacaaagtagcagccattgagggagagttcaagcttaggacggagcaaaggaagacctttgtggaactcatgaaaagaggagatcttcctgtttggctggcctatcaggttgcatctgccggaataacctacacagatagaagatggtgctttgatggcacgaccaacaacaccataatggaagacagtgtgccggcagaggtgtggaccagacacggagagaaaagagtgctcaaaccgaggtggatggacgccagagtttgttcagatcatgcggccctgaagtcattcaaggagtttgccgctgggaaaagaggagcggcttttggagtgatggaagccctgggaacactgccaggacacatgacagagagattccaggaagccattgacaacctcgctgtgctcatgcgggcagagactggaagcaggccttacaaagccgcggcggcccaattgccggagaccctagagaccattatgcttttggggttgctgggaacagtctcgttgggaatctttttcgtcttgatgaggaacaagggcatagggaagatgggctttggaatggtgactcttggggccagcgcatggctcatgtggctctcggaaattgagccagccagaattgcatgtgtcctcattgttgtgttcctattgctggtggtgctcatacctgagccagaaaagcaaagatctccccaggacaaccaaatggcaatcatcatcatggtagcagtaggtcttctgggcttgattaccgccaatgaactcggatggttggagagaacaaagagtgacctaagccatctaatgggaaggagagaggagggggcaaccataggattctcaatggacattgacctgcggccagcctcagcttgggccatctatgctgccttgacaactttcattaccccagccgtccaacatgcagtgaccacttcatacaacaactactccttaatggcgatggccacgcaagctggagtgttgtttggtatgggcaaagggatgccattctacgcatgggactttggagtcccgctgctaatgataggttgctactcacaattaacacccctgaccctaatagtggccatcattttgctcgtggcgcactacatgtacttgatcccagggctgcaggcagcagctgcgcgtgctgcccagaagagaacggcagctggcatcatgaagaaccctgttgtggatggaatagtggtgactgacattgacacaatgacaattgacccccaagtggagaaaaagatgggacaggtgctactcatagcagtagccgtctccagcgccatactgtcgcggaccgcctgggggtggggggaggctggggccctgatcacagccgcaacttccactttgtgggaaggctctccgaacaagtactggaactcctctacagccacttcactgtgtaacatttttaggggaagttacttggctggagcttctctaatctacacagtaacaagaaacgctggcttggtcaagagacgtgggggtggaacaggagagaccctgggagagaaatggaaggcccgcttgaaccagatgtcggccctggagttctactcctacaaaaagtcaggcatcaccgaggtgtgcagagaagaggcccgccgcgccctcaaggacggtgtggcaacgggaggccatgctgtgtcccgaggaagtgcaaagctgagatggttggtggagcggggatacctgcagccctatggaaaggtcattgatcttggatgtggcagagggggctggagttactacgccgccaccatccgcaaagttcaagaagtgaaaggatacacaaaaggaggccctggtcatgaagaacccgtgttggtgcaaagctatgggtggaacatagtccgtcttaagagtggggtggacgtctttcatatggcggctgagccgtgtgacacgttgctgtgtgacataggtgagtcatcatctagtcctgaagtggaagaagcacggacgctcagagtcctctccatggtgggggattggcttgaaaaaagaccaggagccttttgtataaaagtgttgtgcccatacaccagcactatgatggaaaccctggagcgactgcagcgtaggtatgggggaggactggtcagagtgccactctcccgcaactctacacatgagatgtactgggtctctggagcgaaaagcaacaccataaaaagtgtgtccaccacgagccagctcctcttggggcgcatggacgggcctaggaggccagtgaaatatgaggaggatgtgaatctcggctctggcacgcgggctgtggtaagctgcgctgaagctcccaacatgaagatcattggtaaccgcattgaaaggatccgcagtgagcacgcggaaacgtggttctttgacgagaaccacccatataggacatgggcttaccatggaagctatgaggcccccacacaagggtcagcgtcctctctaataaacggggttgtcaggctcctgtcaaaaccctgggatgtggtgactggagtcacaggaatagccatgaccgacaccacaccgtatggtcagcaaagagttttcaaggaaaaagtggacactagggtgccagacccccaagaaggcactcgtcaggttatgagcatggtctcttcctggttgtggaaagagctaggcaaacacaaacggccacgagtctgtaccaaagaagagttcatcaacaaggtgcgtagcaatgcagcattaggggcaatatttgaagaggaaaaagagtggaagactgcagtggaagctgtgaacgatccaaggttctgggctctagtggacaaggaaagagagcaccacctgagaggagagtgccagagttgtgtgtacaacatgatgggaaaaagagaaaagaaacaaggggaatttggaaaggccaagggcagccgcgccatctggtatatgtggctaggggctagatttctagagttcgaagcccttggattcttgaacgaggatcactggatggggagagagaactcaggaggtggtgttgaagggctgggattacaaagactcggatatgtcctagaagagatgagtcgcataccaggaggaaggatgtatgcagatgacactgctggctgggacacccgcattagcaggtttgatctggagaatgaagctctaatcaccaaccaaatggagaaagggcacagggccttggcattggccataatcaagtacacataccaaaacaaagtggtaaaggtccttagaccagctgaaaaagggaaaacagttatggacattatttcgagacaagaccaaagggggagcggacaagttgtcacttacgctcttaacacatttaccaacctagtggtgcaactcattcggaatatggaggctgaggaagttctagagatgcaagacttgtggctgctgcggaggtcagagaaagtgaccaactggttgcagagcaacggatgggataggctcaaacgaatggcagtcagtggagatgattgcgttgtgaagccaattgatgataggtttgcacatgccctcaggttcttgaatgatatgggaaaagttaggaaggacacacaagagtggaaaccctcaactggatgggacaactgggaagaagttccgttttgctcccaccacttcaacaagctccatctcaaggacgggaggtccattgtggttccctgccgccaccaagatgaactgattggccgggcccgcgtctctccaggggcgggatggagcatccgggagactgcttgcctagcaaaatcatatgcgcaaatgtggcagctcctttatttccacagaagggacctccgactgatggccaatgccatttgttcatctgtgccagttgactgggttccaactgggagaactacctggtcaatccatggaaagggagaatggatgaccactgaagacatgcttgtggtgtggaacagagtgtggattgaggagaacgaccacatggaagacaagaccccagttgcgaaatggacagacattccctatttgggaaaaagggaagacttgtggtgtggatctctcatagggcacagaccgcgcaccacctgggctgagaacattaaaaacacagtcaacatggtgcgcaggatcataggtgatgaagaaaagtacatggactacctatccacccaagttcgctacttgggtgaagaagggtctacacctggagtgctgtaagcaccaatcttaatgttgtcaggcctgctagtcagccacagcttggggaaagctgtgcagcctgtgacccccccaggagaagctgggaaaccaagcctatagtcaggccgagaacgccatggcacggaagaagccatgctgcctgtgagcccctcagaggacactgagtcaaaaaaccccacgcgcttggaggcgcaggatgggaaaagaaggtggcgaccttccccacccttcaatctggggcctgaactggagatcagctgtggatctccagaagagggactagtggttagaggaga
+>PRVABC59|zika|KU501215|2015-12-XX|north_america|puerto_rico|puerto_rico|puerto_rico|genbank|genome|Lanciotti et al|https://www.ncbi.nlm.nih.gov/nuccore/KU501215|Phylogeny of Zika Virus in Western Hemisphere, 2015|Emerging Infect. Dis. 22 (5), 933-935 (2016)|https://www.ncbi.nlm.nih.gov/pubmed/27088323
+gttgttgatctgtgtgaatcagactgcgacagttcgagtttgaagcgaaagctagcaacagtatcaacaggttttattttggatttggaaacgagagtttctggtcatgaaaaacccaaaaaagaaatccggaggattccggattgtcaatatgctaaaacgcggagtagcccgtgtgagcccctttgggggcttgaagaggctgccagccggacttctgctgggtcatgggcccatcaggatggtcttggcgattctagcctttttgagattcacggcaatcaagccatcactgggtctcatcaatagatggggttcagtggggaaaaaagaggctatggaaacaataaagaagttcaagaaagatctggctgccatgctgagaataatcaatgctaggaaggagaagaagagacgaggcgcagatactagtgtcggaattgttggcctcctgctgaccacagctatggcagcggaggtcactagacgtgggagtgcatactatatgtacttggacagaaacgatgctggggaggccatatcttttccaaccacattggggatgaataagtgttatatacagatcatggatcttggacacatgtgtgatgccaccatgagctatgaatgccctatgctggatgagggggtggaaccagatgacgtcgattgttggtgcaacacgacgtcaacttgggttgtgtacggaacctgccatcacaaaaaaggtgaagcacggagatctagaagagctgtgacgctcccctcccattccaccaggaagctgcaaacgcggtcgcaaacctggttggaatcaagagaatacacaaagcacttgattagagtcgaaaattggatattcaggaaccctggcttcgcgttagcagcagctgccatcgcttggcttttgggaagctcaacgagccaaaaagtcatatacttggtcatgatactgctgattgccccggcatacagcatcaggtgcataggagtcagcaatagggactttgtggaaggtatgtcaggtgggacttgggttgatgttgtcttggaacatggaggttgtgtcaccgtaatggcacaggacaaaccgactgtcgacatagagctggttacaacaacagtcagcaacatggcggaggtaagatcctactgctatgaggcatcaatatcagacatggcttctgacagccgctgcccaacacaaggtgaagcctaccttgacaagcaatcagacactcaatatgtctgcaaaagaacgttagtggacagaggctggggaaatggatgtggactttttggcaaagggagcctggtgacatgcgctaagtttgcatgctccaagaaaatgaccgggaagagcatccagccagagaatctggagtaccggataatgctgtcagttcatggctcccagcacagtgggatgatcgttaatgacacaggacatgaaactgatgagaatagagcgaaagttgagataacgcccaattcaccgagagccgaagccaccctggggggttttggaagcctaggacttgattgtgaaccgaggacaggccttgacttttcagatttgtattacttgactatgaataacaagcactggttggttcacaaggagtggttccacgacattccattaccttggcacgctggggcagacaccggaactccacactggaacaacaaagaagcactggtagagttcaaggacgcacatgccaaaaggcaaactgtcgtggttctagggagtcaagaaggagcagttcacacggcccttgctggagctctggaggctgagatggatggtgcaaagggaaggctgtcctctggccacttgaaatgtcgcctgaaaatggataaacttagattgaagggcgtgtcatactccttgtgtactgcagcgttcacattcaccaagatcccggctgaaacactgcacgggacagtcacagtggaggtacagtacgcagggacagatggaccttgcaaggttccagctcagatggcggtggacatgcaaactctgaccccagttgggaggttgataaccgctaaccccgtaatcactgaaagcactgagaactctaagatgatgctggaacttgatccaccatttggggactcttacattgtcataggagtcggggagaagaagatcacccaccactggcacaggagtggcagcaccattggaaaagcatttgaagccactgtgagaggtgccaagagaatggcagtcttgggagacacagcctgggactttggatcagttggaggcgctctcaactcattgggcaagggcatccatcaaatttttggagcagctttcaaatcattgtttggaggaatgtcctggttctcacaaattctcattggaacgttgctgatgtggttgggtctgaacacaaagaatggatctatttcccttatgtgcttggccttagggggagtgttgatcttcttatccacagccgtctctgctgatgtggggtgctcggtggacttctcaaagaaggagacgagatgcggtacaggggtgttcgtctataacgacgttgaagcctggagggacaggtacaagtaccatcctgactccccccgtagattggcagcagcagtcaagcaagcctgggaagatggtatctgcgggatctcctctgtttcaagaatggaaaacatcatgtggagatcagtagaaggggagctcaacgcaatcctggaagagaatggagttcaactgacggtcgttgtgggatctgtaaaaaaccccatgtggagaggtccacagagattgcccgtgcctgtgaacgagctgccccacggctggaaggcttgggggaaatcgtatttcgtcagagcagcaaagacaaataacagctttgtcgtggatggtgacacactgaaggaatgcccactcaaacatagagcatggaacagctttcttgtggaggatcatgggttcggggtatttcacactagtgtctggctcaaggttagagaagattattcattagagtgtgatccagccgttattggaacagctgttaagggaaaggaggctgtacacagtgatctaggctactggattgagagtgagaagaatgacacatggaggctgaagagggcccatctgatcgagatgaaaacatgtgaatggccaaagtcccacacattgtggacagatggaatagaagagagtgatctgatcatacccaagtctttagctgggccactcagccatcacaataccagagagggctacaggacccaaatgaaagggccatggcacagtgaagagcttgaaattcggtttgaggaatgcccaggcactaaggtccacgtggaggaaacatgtggaacaagaggaccatctctgagatcaaccactgcaagcggaagggtgatcgaggaatggtgctgcagggagtgcacaatgcccccactgtcgttccgggctaaagatggctgttggtatggaatggagataaggcccaggaaagaaccagaaagcaacttagtaaggtcaatggtgactgcaggatcaactgatcacatggaccacttctcccttggagtgcttgtgatcctgctcatggtgcaggaagggctgaagaagagaatgaccacaaagatcatcataagcacatcaatggcagtgctggtagctatgatcctgggaggattttcaatgagtgacctggctaagcttgcaattttgatgggtgccaccttcgcggaaatgaacactggaggagatgtagctcatctggcgctgatagcggcattcaaagtcagaccagcgttgctggtatctttcatcttcagagctaattggacaccccgtgaaagcatgctgctggccttggcctcgtgtcttttgcaaactgcgatctccgccttggaaggcgacctgatggttctcatcaatggttttgctttggcctggttggcaatacgagcgatggttgttccacgcactgataacatcaccttggcaatcctggctgctctgacaccactggcccggggcacactgcttgtggcgtggagagcaggccttgctacttgcggggggtttatgctcctctctctgaagggaaaaggcagtgtgaagaagaacttaccatttgtcatggccctgggactaaccgctgtgaggctggtcgaccccatcaacgtggtgggactgctgttgctcacaaggagtgggaagcggagctggccccctagcgaagtactcacagctgttggcctgatatgcgcattggctggagggttcgccaaggcagatatagagatggctgggcccatggccgcggtcggtctgctaattgtcagttacgtggtctcaggaaagagtgtggacatgtacattgaaagagcaggtgacatcacatgggaaaaagatgcggaagtcactggaaacagtccccggctcgatgtggcgctagatgagagtggtgatttctccctggtggaggatgacggtccccccatgagagagatcatactcaaggtggtcctgatgaccatctgtggcatgaacccaatagccataccctttgcagctggagcgtggtacgtatacgtgaagactggaaaaaggagtggtgctctatgggatgtgcctgctcccaaggaagtaaaaaagggggagaccacagatggagtgtacagagtaatgactcgtagactgctaggttcaacacaagttggagtgggagttatgcaagagggggtctttcacactatgtggcacgtcacaaaaggatccgcgctgagaagcggtgaagggagacttgatccatactggggagatgtcaagcaggatctggtgtcatactgtggtccatggaagctagatgccgcctgggatgggcacagcgaggtgcagctcttggccgtgccccccggagagagagcgaggaacatccagactctgcccggaatatttaagacaaaggatggggacattggagcggttgcgctggattacccagcaggaacttcaggatctccaatcctagacaagtgtgggagagtgataggactttatggcaatggggtcgtgatcaaaaacgggagttatgttagtgccatcacccaagggaggagggaggaagagactcctgttgagtgcttcgagccctcgatgctgaagaagaagcagctaactgtcttagacttgcatcctggagctgggaaaaccaggagagttcttcctgaaatagtccgtgaagccataaaaacaagactccgtactgtgatcttagctccaaccagggttgtcgctgctgaaatggaggaggcccttagagggcttccagtgcgttatatgacaacagcagtcaatgtcacccactctggaacagaaatcgtcgacttaatgtgccatgccaccttcacttcacgtctactacagccaatcagagtccccaactataatctgtatattatggatgaggcccacttcacagatccctcaagtatagcagcaagaggatacatttcaacaagggttgagatgggcgaggcggctgccatcttcatgaccgccacgccaccaggaacccgtgacgcatttccggactccaactcaccaattatggacaccgaagtggaagtcccagagagagcctggagctcaggctttgattgggtgacggatcattctggaaaaacagtttggtttgttccaagcgtgaggaacggcaatgagatcgcagcttgtctgacaaaggctggaaaacgggtcatacagctcagcagaaagacttttgagacagagttccagaaaacaaaacatcaagagtgggactttgtcgtgacaactgacatttcagagatgggcgccaactttaaagctgaccgtgtcatagattccaggagatgcctaaagccggtcatacttgatggcgagagagtcattctggctggacccatgcctgtcacacatgccagcgctgcccagaggagggggcgcataggcaggaatcccaacaaacctggagatgagtatctgtatggaggtgggtgcgcagagactgacgaagaccatgcacactggcttgaagcaagaatgctccttgacaatatttacctccaagatggcctcatagcctcgctctatcgacctgaggccgacaaagtagcagccattgagggagagttcaagcttaggacggagcaaaggaagacctttgtggaactcatgaaaagaggagatcttcctgtttggctggcctatcaggttgcatctgccggaataacctacacagatagaagatggtgctttgatggcacgaccaacaacaccataatggaagacagtgtgccggcagaggtgtggaccagacacggagagaaaagagtgctcaaaccgaggtggatggacgccagagtttgttcagatcatgcggccctgaagtcattcaaggagtttgccgctgggaaaagaggagcggcttttggagtgatggaagccctgggaacactgccaggacacatgacagagagattccaggaagccattgacaacctcgctgtgctcatgcgggcagagactggaagcaggccttacaaagccgcggcggcccaattgccggagaccctagagaccataatgcttttggggttgctgggaacagtctcgctgggaatcttcttcgtcttgatgaggaacaagggcatagggaagatgggctttggaatggtgactcttggggccagcgcatggctcatgtggctctcggaaattgagccagccagaattgcatgtgtcctcattgttgtgttcctattgctggtggtgctcatacctgagccagaaaagcaaagatctccccaggacaaccaaatggcaatcatcatcatggtagcagtaggtcttctgggcttgattaccgccaatgaactcggatggttggagagaacaaagagtgacctaagccatctaatgggaaggagagaggagggggcaaccataggattctcaatggacattgacctgcggccagcctcagcttgggccatctatgctgccttgacaactttcattaccccagccgtccaacatgcagtgaccacctcatacaacaactactccttaatggcgatggccacgcaagctggagtgttgtttggcatgggcaaagggatgccattctacgcatgggactttggagtcccgctgctaatgataggttgctactcacaattaacacccctgaccctaatagtggccatcattttgctcgtggcgcactacatgtacttgatcccagggctgcaggcagcagctgcgcgtgctgcccagaagagaacggcagctggcatcatgaagaaccctgttgtggatggaatagtggtgactgacattgacacaatgacaattgacccccaagtggagaaaaagatgggacaggtgctactcatagcagtagccgtctccagcgccatactgtcgcggaccgcctgggggtggggggaggctggggctctgatcacagccgcaacttccactttgtgggaaggctctccgaacaagtactggaactcctctacagccacttcactgtgtaacatttttaggggaagttacttggctggagcttctctaatctacacagtaacaagaaacgctggcttggtcaagagacgtgggggtggaacaggagagaccctgggagagaaatggaaggcccgcttgaaccagatgtcggccctggagttctactcctacaaaaagtcaggcatcaccgaggtgtgcagagaagaggcccgccgcgccctcaaggacggtgtggcaacgggaggccatgctgtgtcccgaggaagtgcaaagctgagatggttggtggagcggggatacctgcagccctatggaaaggtcattgatcttggatgtggcagagggggctggagttactacgtcgccaccatccgcaaagttcaagaagtgaaaggatacacaaaaggaggccctggtcatgaagaacccgtgttggtgcaaagctatgggtggaacatagtccgtcttaagagtggggtggacgtctttcatatggcggctgagccgtgtgacacgttgctgtgtgacataggtgagtcatcatctagtcctgaagtggaagaagcacggacgctcagagtcctctccatggtgggggattggcttgaaaaaagaccaggagccttttgtataaaagtgttgtgcccatacaccagcactatgatggaaaccctggagcgactgcagcgtaggtatgggggaggactggtcagagtgccactctcccgcaactctacacatgagatgtactgggtctctggagcgaaaagcaacaccataaaaagtgtgtccaccacgagccagctcctcttggggcgcatggacgggcctaggaggccagtgaaatatgaggaggatgtgaatctcggctctggcacgcgggctgtggtaagctgcgctgaagctcccaacatgaagatcattggtaaccgcattgaaaggatccgcagtgagcacgcggaaacgtggttctttgacgagaaccacccatataggacatgggcttaccatggaagctatgaggcccccacacaagggtcagcgtcctctctaataaacggggttgtcaggctcctgtcaaaaccctgggatgtggtgactggagtcacaggaatagccatgaccgacaccacaccgtatggtcagcaaagagttttcaaggaaaaagtggacactagggtgccagacccccaagaaggcactcgtcaggttatgagcatggtctcttcctggttgtggaaagagctaggcaaacacaaacggccacgagtctgcaccaaagaagagttcatcaacaaggttcgtagcaatgcagcattaggggcaatatttgaagaggaaaaagagtggaagactgcagtggaagctgtgaacgatccaaggttctgggctctagtggacaaggaaagagagcaccacctgagaggagagtgccagagctgtgtgtacaacatgatgggaaaaagagaaaagaaacaaggggaatttggaaaggccaagggcagccgcgccatctggtatatgtggctaggggctagatttctagagttcgaagcccttggattcttgaacgaggatcactggatggggagagagaactcaggaggtggtgttgaagggctgggattacaaagactcggatatgtcctagaagagatgagtcgtataccaggaggaaggatgtatgcagatgacactgctggctgggacacccgcattagcaggtttgatctggagaatgaagctctaatcaccaaccaaatggagaaagggcacagggccttggcattggccataatcaagtacacataccaaaacaaagtggtaaaggtccttagaccagctgaaaaagggaaaacagttatggacattatttcgagacaagaccaaagggggagcggacaagttgtcacttacgctcttaacacatttaccaacctagtggtgcaactcattcggaatatggaggctgaggaagttctagagatgcaagacttgtggctgctgcggaggtcagagaaagtgaccaactggttgcagagcaacggatgggataggctcaaacgaatggcagtcagtggagatgattgcgttgtgaagccaattgatgataggtttgcacatgccctcaggttcttgaatgatatgggaaaagttaggaaggacacacaagagtggaaaccctcaactggatgggacaactgggaagaagttccgttttgctcccaccacttcaacaagctccatctcaaggacgggaggtccattgtggttccctgccgccaccaagatgaactgattggccgggcccgcgtctctccaggggcgggatggagcatccgggagactgcttgcctagcaaaatcatatgcgcaaatgtggcagctcctttatttccacagaagggacctccgactgatggccaatgccatttgttcatctgtgccagttgactgggttccaactgggagaactacctggtcaatccatggaaagggagaatggatgaccactgaagacatgcttgtggtgtggaacagagtgtggattgaggagaacgaccacatggaagacaagaccccagttacgaaatggacagacattccctatttgggaaaaagggaagacttgtggtgtggatctctcatagggcacagaccgcgcaccacctgggctgagaacattaaaaacacagtcaacatggtgcgcaggatcataggtgatgaagaaaagtacatggactacctatccacccaagttcgctacttgggtgaagaagggtctacacctggagtgctgtaagcaccaatcttaatgttgtcaggcctgctagtcagccacagcttggggaaagctgtgcagcctgtgacccccccaggagaagctgggaaaccaagcctatagtcaggccgagaacgccatggcacggaagaagccatgctgcctgtgagcccctcagaggacactgagtcaaaaaaccccacgcgcttggaggcgcaggatgggaaaagaaggtggcgaccttccccacccttcaatctggggcctgaactggagatcagctgtggatctccagaagagggactagtggttagagga
+>COL/FLR_00008/2015|zika|MF574562|2015-12-XX|south_america|colombia|colombia|colombia|genbank|genome|Pickett et al|https://www.ncbi.nlm.nih.gov/nuccore/MF574562|Direct Submission|Submitted (28-JUL-2017) J. Craig Venter Institute, 9704 Medical Center Drive, Rockville, MD 20850, USA|https://www.ncbi.nlm.nih.gov/pubmed/
+tcagactgcgacagttcgagtttgaagcgaaagctagcaacagtatcaacaggttttattttggatttggaaacgagagtttctggtcatgaaaaacccaaaaaagaaatccggaggattccggattgtcaatatgctaaaacgcggagtagcccgtgtgagcccctttgggggcttgaagaggctgccagccggacttctgctgggtcatgggcccatcaggatggtcttggcgattctagcctttttgagattcacggcaatcaagccatcactgggtctcatcaatagatggggttcagtggggaaaaaagaggctatggaaataataaagaagttcaagaaagatctggctgccatgctgagaataatcaatgctaggaaggagaagaagagacgaggcgcagaaactagtgtcggaattgttggcctcctgctgaccacagctatggcagcggaggtcactagacgtgggagtgcatactatatgtacttggacagaaacgatgctggggaggccatatcttttccaaccacattggggatgaataagtgttatatacagatcatggatcttggacacatgtgtgatgccaccatgagctatgaatgccctatgctggatgagggggtggaaccagatgacgtcgattgttggtgcaacacgacgtcaacttgggttgtgtacggaacctgccatcacaaaaaaggtgaagcacggagatctagaagagccgtgacgctcccctcccattccactaggaagctgcaaacgcggtcgcaaacctggttggaatcaagagaatacacaaagcacttgattagagtcgaaaattggatattcaggaaccctggtttcgctttagcagcagctgccatcgcttggcttttgggaagctcaacgagccaaaaagtcatatacttggtcatgatactgctgattgccccggcatacagcatcaggtgcataggagtcagcaatagggactttgtggaaggtatgtcaggtgggacttgggttgatgtcgtcttggaacatggaggttgtgtcaccgtaatggcacaggacaaaccgactgtcgacatagagctggttacaacaacagtcagcaacatggcggaggtaagatcctactgctatgaggcatcaatatcagacatggcttcggacagccgctgcccaacacaaggtgaagcctaccttgacaagcaatcagacactcaatatgtctgcaaaagaacgttagtggacagaggctggggaaatggatgtggactttttggcaaagggagcctggtgacatgcgctaagtttgcatgctccaagaaaatgaccgggaagagcatccagccagagaatctggagtaccggataatgttgtcagttcatggctcccagcacagtgggatgatcgttaatgacacaggacatgaaactgatgagaatagagcgaaggttgagataacgcccaattcaccaagagccgaagccaccctggggggctttggaagcctaggacttgattgtgaaccgaggacaggccttgacttttcagatttgtattacttgactatgaataacaagcactggttggttcacaaggagtggttccacgacattccattaccttggcacgctggggcagacaccggaactccacactggaacaacaaagaagcactggtagagttcaaggacgcacatgccaaaaggcaaactgtcgtggttctagggagtcaagaaggagcagttcacacggcccttgctggagctctggaggctgagatggatggtgcaaagggaaggctgtcctctggccacttgaaatgtcgcctgaaaatggataaacttagattgaagggcgtgtcatactccttgtgtaccgcagcgttcacattcaccaagatcccggctgaaacactgcacgggacagtcacagtggaggtacagtacgcagggacagatggaccttgcaaggttccagctcagatggcggtggacatgcaaactctgaccccagttgggaggttgataaccgctaaccccgtaatcactgaaagcactgagaactctaagatgatgctggaacttgatccaccatttggggactcttacattgtcataggagtcggggagaagaagatcacccaccactggcacaggagtggcagcaccattggaaaagcatttgaagccactgtgagaggtgccaagagaatggcagtcttgggagacacagcctgggactttggatcagttggaggcgctctcaactcattgggcaagggcatccatcaaatttttggagcagctttcaaatcattgtttggaggaatgtcctggttctcacaaattctcattggaacgttgctgatgtggttgggtctgaacacaaagaatggatctatttcccttatgtgcttggccttagggggagtgttgatcttcttatccacagccgtctctgctgatgtggggtgctcggtggacttctcaaagaaggagacgagatgtggtacaggggtgttcgtctataacgacgttgaagcctggagggacaggtacaagtaccatcctgactccccccgtagattggcagcagcagtcaagcaagcctgggaagatggtatctgcgggatctcctctgtttcaagaatggaaaacatcatgtggagatcagtagaaggggagctcaacgcaatcctggaagagaatggagttcaactgacggtcgttgtgggatctgtaaaaaaccccatgtggagaggtccacagagattgcccgtgcctgtgaacgagctgccccacggctggaaggcttgggggaaatcgtacttcgtcagagcagcaaagacaaataacagctttgtcgtggatggtgacacactgaaagaatgcccactcaaacatagagcatggaacagctttcttgtggaggatcatgggttcggggtatttcacactagtgtctggatcaaggttagagaagattattcattagagtgtgatccagccgttattggaacagctgttaagggaaaggaggctgtacacagtgatctaggctactggattgagagtgagaagaatgacacatggaggctgaagagggcccatctgatcgagatgaaaacatgtgaatggccaaagtcccacacattgtggacagatggaatagaagagagtgatctgatcatacccaagtctttagctgggccactcagccatcacaataccagagagggctacaggacccaaatgaaagggccatggcacagtgaagagcttgaaattcggtttgaggaatgcccaggcactaaggtccacgtggaggaaacatgtgaaacaagaggaccatctctgagatcaaccactgcaagcggaagggtgatcgaggaatggtgctgcagggagtgcacaatgcccccactgtcgttctgggctaaagatggctgttggtatggaatggagataaggcccaggaaagaaccagaaagcaacttagtaaggtcaatggtgactgcaggatcaactgatcacatggatcacttctcccttggagtgcttgtgattctgctcatggtgcaggaagggctgaagaagagaatgaccacaaagatcatcataagcacatcaatggcagtgctggtagctatgatcctgggaggattttcaatgagtgacctggctaagcttgcaatcttgatgggtgccaccttcgcggaaatgaacactggaggagatgtagctcatctggcgctgatagcggcattcaaagtcagaccagcgttgctggtatccttcatcttcagagctaattggacaccccgtgaaagcatgctgctggccttggcctcgtgtcttttgcaaactgcgatctccgccttggagggcgacctgatggttctcatcaatggttttgctttggcctggttggcaatacgagcgatggttgttccacgcactgacaacatcaccttggcaatcctggctgctctgacaccactggcccggggcacactgcttgtggcgtggagagcaggccttgctacttgcggggggtttatgctcctctctctgaagggaaaaggcagtgtgaagaagaacttaccatttgtcatggccctgggactaaccgctgtgaggctggtcgaccccatcaacgtggtgggactgctgttgctcacaaggagtgggaagcggagctggccccctagcgaagtactcacagctgttggcctgatatgcgcattggctggagggttcgccaaggcagatatagagatggctgggcccatggccgcggttggtctgctaattgtcagttacgtggtctcaggaaagagtgtggacatgtacattgaaagagcaggtgacatcacatgggaaaaagatgcggaagtcactggaaacagtccccggctcgatgtggcgctagatgagagtggtgatttctccctggtggaggatgacggtccccccatgagagagatcatactcaaggtggtcctgatgaccatctgtggcatgaacccaatagccataccctttgcagctggagcgtggtacgtatacgtgaagactggaaaaaggagtggtgcgctatgggatgtgcctgctcccaaggaagtaaaaaagggggagaccacagatggagtgtacagagtaatgactcgtagactgctaggttcaacacaagttggagtgggagttatgcaagagggggtctttcacactatgtggcacgtcacaaaaggatccgcgctgagaagcggtgaagggagacttgatccatactggggagatgtcaagcaggatctggtgtcatactgtggtccatggaagctagatgccgcctgggacgggcacagcgaggtgcagctcttggccgtgccccccggagagagagcgaggaacatccagactctgcccggaatatttaagacaaaggatggggacattggagcggttgcgctggattacccagcaggaacttcaggatctccaatcctagacaagtgtgggagagtgataggactttatggcaatggggtcgtgatcaaaaatgggagttatgttagtgccatcacccaagggaggagggaggaagagactcctgttgagtgcttcgagccttcgatgctgaagaagaagcagctaactgtcttagacttgcatcctggagctgggaaaaccaggagagttcttcctgaaatagtccgtgaagccataaaaacaagactccgtactgtgatcttagctccaaccagggttgtcgctgctgaaatggaggaagcccttagagggcttccagtgcgttatatgacaacagcagtcaatgtcacccactctggaacagaaatcgtcgacttaatgtgccatgccaccttcacttcacgtctactacagccaatcagagtccccaactataatctgtatattatggatgaggcccacttcacagatccctcaagtatagcagcaagaggatacatttcaacaagggttgagatgggcgaggcggctgccatcttcatgaccgccacgccaccaggaacccgtgacgcatttccggactccaactcaccaattatggacaccgaagtggaagtcccagagagagcctggagctcaggctttgattgggtgacagatcattctggaaaaacagtttggtttgttccaagcgtgaggaacggcaatgagatcgcagcttgtctgacaaaggctggaaaacgggtcatacagctcagcagaaagacttttgagacagagttccagaaaacaaaacatcaagagtgggactttgtcgtgacaactgacatttcagagatgggcgccaactttaaagctgaccgtgtcatagattccaggagatgcctaaagccggtcatacttgatggcgagagagtcattctggctggacccatgcctgtcacacatgccagcgctgcccagaggagggggcgcataggcaggaatcccaataaacctggagatgagtatctgtatggaggtgggtgcgcagagactgacgaagaccatgcacactggcttgaagcaagaatgctccttgacaatatttacctccaagatggcctcatagcctcgctctatcgacctgaggccgacaaagtagcagccattgagggagagttcaagcttaggacggagcaaaggaagacctttgtggaactcatgaaaagaggagatcttcctgtttggctggcctatcaggttgcatctgccggaataacctacacagatagaagatggtgctttgatggcacgaccaacaacaccataatggaagacagtgtgccggcagaggtgtggaccagacacggagagaaaagagtgctcaaaccgaggtggatggacgccagagtttgttcagatcatgcggccctgaagtcattcaaggagtttgccgctgggaaaagaggagcggcttttggagtgatggaagccctgggaacactgccaggacacatgacagagagattccaggaagccattgacaacctcgctgtgctcatgcgggcagagactggaagcaggccttacaaagccgcggcggcccaattgccggagaccctagagaccattatgcttttggggttgctgggaacagtctcgttgggaatctttttcgtcttgatgaggaacaagggcatagggaagatgggctttggaatggtgactcttggggccagcgcatggctcatgtggctctcggaaattgagccagccagaattgcatgtgtcctcattgttgtgttcctattgctggtggtgctcatacctgagccagaaaagcaaagatctccccaggacaaccaaatggcaatcatcatcatggtagcagtaggtcttctgggcttgattaccgccaatgaactcggatggttggagagaacaaagagtgacctaagccatctaatgggaaggagagaggagggggcaaccataggattctcaatggacattgacctgcggccagcctcagcttgggccatctatgctgccttgacaactttcattaccccagccgtccaacatgcagtgaccacttcatacaacaactactccttaatggcgatggccacgcaagctggagtgttgtttggtatgggcaaagggatgccattctacgcatgggactttggagtcccgctgctaatgataggttgctactcacaattaacacccctgaccctaatagtggccatcattttgctcgtggcgcactacatgtacttgatcccagggctgcaggcagcagctgcgcgtgctgcccagaagagaacggcagctggcatcatgaagaaccctgttgtggatggaatagtggtgactgacattgacacaatgacaattgacccccaagtggagaaaaagatgggacaggtgctactcatagcagtagccgtctccagcgccatactgtcgcggaccgcctgggggtggggggaggctggggccctgatcacagccgcaacttccactttgtgggaaggctctccgaacaagtactggaactcctctacagccacttcactgtgtaacatttttaggggaagttacttggctggagcttctctaatctacacagtaacaagaaacgctggcttggtcaagagacgtgggggtggaacaggagagaccctgggagagaaatggaaggcccgcttgaaccagatgtcggccctggagttctactcctacaaaaagtcaggcatcaccgaggtgtgcagagaagaggcccgccgcgccctcaaggacggtgtggcaacgggaggccatgctgtgtcccgaggaagtgcaaagctgagatggttggtggagcggggatacctgcagccctatggaaaggtcattgatcttggatgtggcagagggggctggagttactacgccgccaccatccgcaaagttcaagaagtgaaaggatacacaaaaggaggccctggtcatgaagaacccgtgttggtgcaaagctatgggtggaacatagtccgtcttaagagtggggtggacgtctttcatatggcggctgagccgtgtgacacgttgctgtgtgacataggtgagtcatcatctagtcctgaagtggaagaagcacggacgctcagagtcctctccatggtgggggattggcttgaaaaaagaccaggagccttttgtataaaagtgttgtgcccatacaccagcactatgatggaaaccctggagcgactgcagcgtaggtatgggggaggactggtcagagtgccactctcccgcaactctacacatgagatgtactgggtctctggagcgaaaagcaacaccataaaaagtgtgtccaccacgagccagctcctcttggggcgcatggacgggcctaggaggccagtgaaatatgaggaggatgtgaatctcggctctggcacgcgggccgtggtaagctgcgctgaagctcccaacatgaagatcattggtaaccgcattgaaaggatccgcagtgagcacgcggaaacgtggttctttgacgagaaccacccatataggacatgggcttaccatggaagctatgaggcccccacacaagggtcagcgtcctctctaataaacggggttgtcaggctcctgtcaaaaccctgggatgtggtgactggagtcacaggaatagccatgaccgacaccacaccgtatggtcagcaaagagttttcaaggaaaaagtggacactagggtgccagacccccaagaaggcactcgtcaggttatgagcatggtctcttcctggttgtggaaagagctaggcaaacacaaacggccacgagtctgtaccaaagaagagttcatcaacaaggtgcgtagcaatgcagcattaggggcaatatttgaagaggaaaaagagtggaagactgcagtggaagctgtgaacgatccaaggttctgggctctagtggacaaggaaagagagcaccacctgagaggagagtgccagagttgtgtgtacaacatgatgggaaaaagagaaaagaaacaaggggaatttggaaaggccaagggcagccgcgccatctggtatatgtggctaggggctagatttctagagttcgaagcccttggattcttgaacgaggatcactggatggggagagagaactcaggaggtggtgttgaagggctgggattacaaagactcggatatgtcctagaagagatgagtcgcataccaggaggaaggatgtatgcagatgacactgctggctgggacacccgcattagcaggtttgatctggagaatgaagctctaatcaccaaccaaatggagaaagggcacagggccttggcattggccataatcaagtacacataccaaaacaaagtggtaaaggtccttagaccagctgaaaaagggaaaacagttatggacattatttcgagacaagaccaaagggggagcggacaagttgtcacttacgctcttaacacatttaccaacctagtggtgcaactcattcggaatatggaggctgaggaagttctagagatgcaagacttgtggctgctgcggaggtcagagaaagtgaccaactggttgcagagcaacggatgggataggctcaaacgaatggcagtcagtggagatgattgcgttgtgaagccaattgatgataggtttgcacatgccctcaggttcttgaatgatatgggaaaagttaggaaggacacacaagagtggaaaccctcaactggatgggacaactgggaagaagttccgttttgctcccaccacttcaacaagctccatctcaaggacgggaggtccattgtggttccctgccgccaccaagatgaactgattggccgggcccgcgtctctccaggggcgggatggagcatccgggagactgcttgcctagcaaaatcatatgcgcaaatgtggcagctcctttatttccacagaagggacctccgactgatggccaatgccatttgttcatctgtgccagttgactgggttccaactgggagaactacctggtcaatccatggaaagggagaatggatgaccactgaagacatgcttgtggtgtggaacagagtgtggattgaggagaacgaccacatggaagacaagaccccagttgcgaaatggacagacattccctatttgggaaaaagggaagacttgtggtgtggatctctcatagggcacagaccgcgcaccacctgggctgagaacattaaaaacacagtcaacatggtgcgcaggatcataggtgatgaagaaaagtacatggactacctatccacccaagttcgctacttgggtgaagaagggtctacacctggagtgctgtaagcaccaatcttaatgttgtcaggcctgctagtcagccacagcttggggaaagctgtgcagcctgtgacccccccaggagaagctgggaaaccaagcctatagtcaggccgagaacgccatggcacggaagaagccatgctgcctgtgagcccctcagaggacactgagtcaaaaaaccccacgcgcttggaggcgcaggatgggaaaagaaggtggcgaccttccccacccttcaatctggggcctgaactggagatcagctgtggatctccagaagagggactagtggttagaggaga
+>Colombia/2016/ZC204Se|zika|KY317939|2016-01-06|south_america|colombia|colombia|colombia|genbank|genome|Quick et al|https://www.ncbi.nlm.nih.gov/nuccore/KY317939|Multiplex PCR method for MinION and Illumina sequencing of Zika and other virus genomes directly from clinical samples|Nat Protoc 12 (6), 1261-1276 (2017)|https://www.ncbi.nlm.nih.gov/pubmed/28538739
+gacagttcgagtttgaagcgaaagctagcaacagtatcaacaggttttattttggatttggaaacgagagtttctggtcatgaaaaacccaaaaaagaaatccggaggattccggattgtcaatatgctaaaacgcggagtagcccgtgtgagcccctttgggggcttgaagaggctgccagccggacttctgctgggtcatgggcccatcaggatggtcttggcgattctagcctttttgagattcacggcaatcaagccatcactgggtctcatcaatagatggggttcagtggggaaaaaagaggctatggaaataataaagaagttcaagaaagatctggctgccatgctgagaataatcaatgctaggaaggagaagaagagacgaggcgcagaaactagtgtcggaattgttggcctcctgctgaccacagctatggcagcggaggtcactagacgtgggagtgcatactatatgtacttggacagaaaagatgctggggaggccatatcttttccaaccacattggggatgaataagtgttatatacagatcatggatcttggacacatgtgtgatgccaccatgagctatgaatgccctatgctggatgagggggtggaaccagatgacgtcgattgttggtgcaacacgacgtcaacttgggttgtgtacggaacctgccatcacaaaaaaggtgaagcacggagatctagaagagccgtgacgctcccctcccattccactaggaagctgcaaacgcggtcgcaaacctggttggaatcaagagaatacacaaagcacttgattagagtcgaaaattggatattcaggaaccctggtttcgctttagcagcagctgccatcgcttggcttttgggaagctcaacgagccaaaaagtcatatacttggtcatgatactgctgattgccccggcatacagcatcaggtgcataggagtcagcaatagggactttgtggaaggtatgtcaggtgggacttgggttgatgttgtcttggaacatggaggttgtgtcaccgtaatggcacaggacaaaccgactgtcgacatagagctggttacaacaacagtcagcaacatggcggaggtaagatcctactgctatgaggcatcaatatcagacatggcttcggacagccgctgcccaacacaaggtgaagcctaccttgacaagcaatcagacactcaatatgtttgcaaaagaacgttagtggacagaggctggggaaatggatgtggactttttggcaaagggagcctggtgacatgcgctaagtttgcatgctccaagaaaatgaccgggaagagcatccagccagagaatctggagtaccggataatgttgtcagttcatggctcccagcacagtgggatgatcgttaatgacacaggacatgaaactgatgagaatagagcgaaggttgagataacgcccaattcaccaagagccgaagccaccctggggggttttggaagcctaggacttgattgtgaaccgaggacaggccttgacttttcagatttgtattacttgactatgaataacaagcactggttggttcacaaggagtggttccacgacattccattaccttggcacgctggggcagacaccggaactccacactggaacaacaaagaagcactggtagagttcaaggacgcacatgccaaaaggcaaactgtcgtggttctagggagtcaagaaggagcagttcacacggcccttgctggagctctggaggctgagatggatggtgcaaagggaaggctgtcctctggccacttgaaatgtcgcctgaaaatggataaacttagattgaagggcgtgtcatactccttgtgtaccgcagcgttcacattcaccaagatcccggctgaaacactgcacgggacagtcacagtggaggtacagtacgcagggacagatggaccttgcaaggttccagctcagatggcggtggacatgcaaactctgaccccagttgggaggttgataaccgctaaccccgtaatcactgaaagcactgagaactctaagatgatgctggaacttgatccaccatttggggactcttacattgtcataggagtcggggagaagaagatcacccaccactggcataggagtggcagcaccattggaaaagcatttgaagccactgtgagaggtgccaagagaatggcagtcttgggagacacagcctgggactttggatcagttggaggcgctctcaactcattgggcaagggcatccatcaaatttttggagcagctttcaaatcattgtttggaggaatgtcctggttctcacaaattctcattggaacgttgctgatgtggttgggtctgaacacaaagaatggatctatttcccttatgtgcttggccttagggggagtgttgatcttcttatccacagccgtctctgctgatgtggggtgctcggtggacttctcaaagaaggagacgagatgtggtacaggggtgttcgtctataacgacgttgaagcctggagggacaggtacaagtaccatcctgactccccccgtagattggcagcagcagtcaagcaagcctgggaagatggtatctgcgggatctcctctgtttcaagaatggaaaacatcatgtggagatcagtagaaggggagctcaacgcaatcctggaagagaatggagttcaactgacggtcgttgtgggatctgtaaaaaaccccatgtggagaggtccacagagattgcccgtgcctgtgaacgagctgccccacggctggaaggcttgggggaaatcgtacttcgtcagagcagcaaagacaaataacagctttgtcgtggatggtgacacactgaaggaatgcccactcaaacatagagcatggaacagctttcttgtggaggatcatgggttcggggtatttcacactagtgtctggctcaaggttagagaagattattcattagagtgtgatccagccgttattggaacagctgttaagggaaaggaggctgtacacagtgatctaggctactggattgagagtgagaagaatgacacatggaggctgaagagggcccatctgatcgagatgaaaacatgtgaatggccaaagtcccacacattgtggacagatggaatagaagagagtgatctgatcatacccaagtctttagctgggccactcagccatcacaataccagagagggctacaggacccaaatgaaagggccatggcacagtgaagagcttgaaattcggtttgaggaatgcccaggcactaaggtccacgtggaggaaacatgtggaacaagaggaccatctctgagatcaaccactgcaagcggaagggtgatcgaggaatggtgctgcagggagtgcacaatgcccccactgtcgttctgggctaaagatggctgttggtatggaatggagataaggcccaggaaagaaccagaaagcaacttagtaaggtcaatggtgactgcaggatcaactgatcacatggatcacttctcccttggagtgcttgtgattctgctcatggtgcaggaagggctgaagaagagaatgaccacaaagatcatcataagcacatcaatggcagtgctggtagctatgatcctgggaggattttcaatgagtgacctggctaagcttgcaattttgatgggtgccaccttcgcggaaatgaacactggaggagatgtagctcatctggcgctgatagcggcattcaaagtcagaccagcgttgctggtatctttcatcttcagagctaattggacaccccgtgaaagcatgctgctggccttggcctcgtgtcttttgcaaactgcgatctccgccttggagggcgacctgatggttctcatcaatggttttgctttggcctggttggcaatacgagcgatggttgttccacgcactgacaacatcaccttggcaatcctggctgctctgacaccactggcccggggcacactgcttgtggcgtggagagcaggccttgctacttgcggggggtttatgctcctctctctgaagggaaaaggcagtgtgaagaagaacttaccatttgtcatggccctgggactaaccgctgtgaggctggtcgaccccatcaacgtggtgggactgctgttgctcacaaggagtgggaagcggagctggccccctagcgaagtactcacagctgttggcctgatatgcgcattggctggagggttcgccaaggcagatatagagatggctgggcccatggccgcggtcggtctgctaattgtcagttacgtggtctcaggaaagagtgtggacatgtacattgaaagagcaggtgacatcacatgggaaaaagatgcggaagtcactggaaacagtccccggctcgatgtggcgctagatgagagtggtgatttctccctggtggaggatgacggtccccccatgagagagatcatactcaaggtggtcctgatgaccatctgtggcatgaacccaatagccataccctttgcagctggagcgtggtacgtatacgtgaagactggaaaaaggagtggtgctctatgggatgtgcctgctcccaaggaagtaaaaaagggggagaccacagatggagtgtacagagtaatgactcgtagactgctaggttcaacacaagttggagtgggagttatgcaagagggggtctttcacactatgtggcacgtcacaaaaggatccgcgctgagaagcggtgaagggagacttgatccatactggggagatgtcaagcaggatctggtgtcatactgtggtccatggaagctagatgccgcctgggacgggcacagcgaggtgcagctcttggccgtgccccccggagagagagcgaggaacatccagactctgcccggaatatttaagacaaaggatggggacattggagcggttgcgctggattacccagcaggaacttcaggatctccaatcctagacaagtgtgggagagtgataggactttatggcaatggggtcgtgatcaaaaatgggagttatgttagtgccatcacccaagggaggagggaggaagagactcctgttgagtgcttcgagccttcgatgctgaagaagaagcagctaactgtcttagacttgcatcctggagctgggaaaaccaggagagttcttcctgaaatagtccgtgaagccataaaaacaagactccgtactgtgatcttagctccaaccagggttgtcgctgctgaaatggaggaagcccttagagggcttccagtgcgttatatgacaacagcagtcaatgtcacccactctggaacagaaatcgtcgacttaatgtgccatgccaccttcacttcacgtctactacagccaatcagagtccccaactataatctgtatattatggatgaggcccacttcacagatccctcaagtatagcagcaagaggatacatttcaacaagggttgagatgggcgaggcggctgccatcttcatgaccgccacgccaccaggaacccgtgacgcatttccggactccaactcaccaattatggacaccgaagtggaagtcccagagagagcctggagctcaggctttgattgggtgacggatcattctggaaaaacagtttggtttgttccaagcgtgaggaacggcaatgagatcgcagcttgtctgacaaaggctggaaaacgggtcatacagctcagcagaaagacttttgagacagagttccagaaaacaaaacatcaagagtgggactttgtcgtgacaactgacatttcagagatgggcgccaactttaaagctgaccgtgtcatagattccaggagatgcctaaagccggtcatacttgatggcgagagagtcattctggctggacccatgcctgtcacacatgccagcgctgcccagaggagggggcgcataggcaggaatcccaataaacctggagatgagtatctgtatggaggtgggtgcgcagagactgacgaagaccatgcacactggcttgaagcaagaatgctccttgacaatatttacctccaagatggcctcatagcctcgctctatcgacctgaggccgacaaagtagcagccattgagggagagttcaagcttaggacggagcaaaggaagacctttgtggaactcatgaaaagaggagatcttcctgtttggctggcctatcaggttgcatctgccggaataacctacacagatagaagatggtgctttgatggcacgaccaacaacaccataatggaagacagtgtgccggcagaggtgtggaccagacacggagagaaaagagtgctcaaaccgaggtggatggacgccagagtttgttcagatcatgcggccctgaagtcattcaaggagtttgccgctgggaaaagaggagcggcttttggagtgatggaagccctgggaacactgccaggacacatgacagagagattccaggaagccattgacaacctcgctgtgctcatgcgggcagagactggaagcaggccttacaaagccgcggcggcccaattgccggagaccctagagaccattatgcttttggggttgctgggaacagtctcgctgggaatctttttcgtcttgatgaggaacaagggcatagggaagatgggctttggaatggtgactcttggggccagcgcatggctcatgtggctctcggaaattgagccagccagaattgcatgtgtcctcattgttgtgttcctattgctggtggtgctcatacctgagccagaaaagcaaagatctccccaggacaaccaaatggcaatcatcatcatggtagcagtaggtcttctgggcttgattaccgccaatgaactcggatggttggagagaacaaagagtgacctaagccatctaatgggaaggagagaggagggggcaaccataggattctcaatggacattgacctgcggccagcctcagcttgggccatctatgctgccttgacaactttcattaccccagccgtccaacatgcagtgaccacttcatacaacaactactccttaatggcgatggccacgcaagctggagtgttgtttggtatgggcaaagggatgccattctacgcatgggactttggagtcccgctgctaatgataggttgctactcacaattaacacccctgaccctaatagtggccatcattttgctcgtggcgcactacatgtacttgatcccagggctgcaggcagcagctgcgcgtgctgcccagaagagaacggcagctggcatcatgaagaaccctgttgtggatggaatagtggtgactgacattgacacaatgacaattgacccccaagtggagaaaaagatgggacaggtgctactcatagcagtagccgtctccagcgccatactgtcgcggaccgcctgggggtggggggaggctggggccctgatcacagccgcaacttccactttgtgggaaggctctccgaacaagtactggaactcctctacagccacttcactgtgtaacatttttaggggaagttacttggctggagcttctctaatctacacagtaacaagaaacgctggcttggtcaagagacgtgggggtggaacaggagagaccctgggagagaaatggaaggcccgcttgaaccagatgtcggccctggagttctactcctacaaaaagtcaggcatcaccgaggtgtgcagagaagaggcccgccgcgccctcaaggacggtgtggcaacgggaggccatgctgtgtcccgaggaagtgcaaagctgagatggctggtggagcggggatacctgcagccctatggaaaggtcattgatcttggatgtggcagagggggctggagttactacgccgccaccatccgcaaagttcaagaagtgaaaggatacacaaaaggaggccctggtcatgaagaacccgtgttggtgcaaagctatgggtggaacatagtccgtcttaagagtggggtggacgtctttcatatggcggctgagccgtgtgacacgttgctgtgtgacataggtgagtcatcatctagtcctgaagtggaagaagcacggacgctcagagtcctctccatggtgggggattggcttgaaaaaagaccaggagccttttgtataaaagtgttgtgcccatacaccagcactatgatggaaaccctggagcgactgcagcgtaggtatgggggaggactggtcagagtgccactctcccgcaactctacacatgagatgtactgggtctctggagcgaaaagcaacaccataaaaagtgtgtccaccacgagccagctcctcttggggcgcatggacgggcctaggaggccagtgaaatatgaggaggatgtgaatctcggctctggcacgcgggctgtggtaagctgcgctgaagctcccaacatgaagatcattggtaaccgcattgaaaggatccgcagtgagcacgcggaaacgtggttctttgacgagaaccacccatataggacatgggcttaccatggaagctatgaggcccccacacaagggtcagcgtcctctctaataaacggggttgtcaggctcctgtcaaaaccctgggatgtggtgactggagtcacaggaatagccatgaccgacaccacaccgtatggtcagcaaagagttttcaaggaaaaagtggacactagggtgccagacccccaagaaggcactcgtcaggttatgagcatggtctcttcctggttgtggaaagagctaggcaaacacaaacggccacgagtctgtaccaaagaagagttcatcaacaaggttcgtagcaatgcagcattaggggcaatatttgaagaggaaaaagagtggaagactgcagtggaagctgtgaacgatccaaggttctgggctctagtggacaaggaaagagagcaccacctgagaggagagtgccagagttgtgtgtacaacatgatgggaaaaagagaaaagaaacaaggggaatttggaaaggccaagggcagccgcgccatctggtatatgtggctaggggctagatttctagagttcgaagcccttggattcttgaacgaggatcactggatggggagagagaactcaggaggtggtgttgaagggctgggattacaaagactcggatatgtcctagaagagatgagtcgcataccaggaggaaggatgtatgcagatgacactgctggctgggacacccgcattagcaggtttgatctggagaatgaagctctaatcaccaaccaaatggagaaagggcacagggccttggcattggccataatcaagtacacataccaaaacaaagtggtaaaggtccttagaccagctgaaaaagggaaaacagttatggacattatttcgagacaagaccaaagggggagcggacaagttgtcacttacgctcttaacacatttaccaacctagtggtgcaactcattcggaatatggaggctgaggaagttctagagatgcaagacttgtggctgctgcggaggtcagagaaagtgaccaactggttgcagagcaacggatgggataggctcaaacgaatggcagtcagtggagatgaytgcgttgtgaagccaattgatgataggtttgcacatgccctcaggttcttgaatgatatgggaaaagttaggaaggacacacaagagtggaaaccctcaactggatgggacaactgggaagaagttccgttttgctcccaccacttcaacaagctccatctcaaggacgggaggtccattgtggttccctgccgccaccaagatgaactgattggccgggcccgcgtctctccaggggcgggatggagcatccgggagactgcttgcctagcaaaatcatatgcgcaaatgtggcagctcctttatttccacagaagggacctccgactgatggccaatgccatttgttcatctgtgccagttgactgggttccaactgggagaactacctggtcaatccatggaaagggagaatggatgaccactgaagacatgcttgtggtgtggaacagagtgtggattgaggagaacgaccacatggaagacaagaccccagttgcgaaatggacagacattccctatttgggaaaaagggaagacttgtggtgtggatctctcatagggcacagaccgcgcaccacctgggctgagaacattaaaaacacagtcaacatggtgcgcaggatcataggtgatgaagaaaagtacatggactacctatccacccaagttcgctacttgggcgaagaagggtctacacctggagtgctgtaagcaccaatcttaatgttgtcaggcctgctagtcagccacagcttggggaaagctgtgcagcctgtgacccccccaggagaagctgggaaaccaagcctatagtcaggccgagaacgccatggcacggaagaagccatgctgcctgtgagcccctcagaggacactgagtcaaaaaaccccacgcgcttggaggcgcaggatgggaaaagaaggtggcgaccttccccacccttcaatctggggcctgaactggagat
+>ZKC2/2016|zika|KX253996|2016-02-16|oceania|american_samoa|american_samoa|american_samoa|genbank|genome|Wu et al|https://www.ncbi.nlm.nih.gov/nuccore/KX253996|Direct Submission|Submitted (18-MAY-2016) Center for Diseases Control and Prevention of Guangdong Province; National Institute of Viral Disease Control and Prevention, China|https://www.ncbi.nlm.nih.gov/pubmed/
+agttgttgatctgtgtgaatcagactgcgacagttcgagtttgaagcgaaagctagcaacagtatcaacaggttttattttggatttggaaacgagagtttctggtcatgaaaaacccaaaaaagaaatccggaggattccggattgtcaatatgctaaaacgcggagtagcccgtgtgagcccctttgggggcttgaagaggctgccagccggacttctgctgggtcatgggcccatcaggatggtcttggcgattctagccttcttgagattcacggcaatcaagccatcactgggtctcatcaatagatggggttcagtggggaaaaaagaggctatggaaataataaagaagttcaagaaagatctggctgccatgctgagaataatcaatgctaggaaggagaagaagagacgaggcgcagatactaatgtcggaattgttggcctcctgctgaccacagctatggcagcggaggtcactagacgtgggagtgcatactatatgtacttggacagaaacgatgctggggaggccatatcttttccaaccacattggggatgaataagtgttatatacagatcatggatcttggacacatgtgtgatgccaccatgagctatgaatgccctatgctggatgagggggtggaaccagatgacgtcgattgttggtgcaacacgacgtcaacttgggttgtgtacggaacctgccatcacaaaaaaggtgaagcacggagatctagaagagctgtgacgctcccctcccattccactaggaagctgcaaacgcggtcgcaaacttggttggaatcaagagaatacacaaagcacttgattagagtcgaaaattggatattcaggaaccctggcttcgcgttagcagcagctgccatcgcttggcttttgggaagctcaacgagccaaaaagtcatatacttggtcatgatactgctgattgccccggcatacagcatcaggtgcataggagtcagcaatagggactttgtggaaggtatgtcaggtgggacttgggttgatgttgtcttggaacatggaggttgtgtcaccgtaatggcacaggacaaaccgactgtcgacatagagctggttacaacaacagtcagcaacatggcggaggtaagatcctactgctatgaggcatcaatatcggacatggcttcggacagccgctgcccaacacaaggtgaagcctaccttgacaagcaatcagacactcaatatgtctgcaaaagaacgttagtggacagaggctggggaaatggatgtggactttttggcaaagggagcctggtgacatgcgctaagtttgcatgctccaagaaaatgaccgggaagagcatccagccagagaatctggagtaccggataatgctgtcagttcatggctcccagcacagtgggatgatcgttaatgacacaggacatgaaactgatgagaatagagcgaaggttgagataacgcccaattcaccaagagccgaagccaccctggggggttttggaagcctaggacttgattgtgaaccgaggacaggccttgacttttcagatttgtattacttgactatgaataacaagcactggttggttcacaaggagtggttccacgacattccattaccttggcacgctggggcagacaccggaactccacactggaacaacaaagaagcactggtagagttcaaggacgcacatgccaaaaggcaaactgtcgtggttctagggagtcaagaaggagcagttcacacggcccttgctggagctctggaggctgagatggatggtgcaaagggaaggctgtcctctggccacttgaaatgtcgcctgaaaatggataaacttagattgaagggcgtgtcatactccttgtgtaccgcagcgttcacattcaccaagatcccggctgaaacactgcacgggacagtcacagtggaggtacagtacgcagggacagatggaccttgcaaggttccagctcagatggcggtggacatgcaaactctgaccccagttgggaggctgataaccgctaaccccgtaatcactgaaagcactgagaactccaagatgatgctggaacttgatccaccatttggggactcttacattgtcataggagtcggggagaagaagatcacccaccactggcacaggagtggcagcaccattggaaaagcatttgaagccactgtgagaggtgccaggagaatggcagtcttgggagacacagcctgggactttggatcagttggaggcgctctcaactcattgggcaagggcatccatcaaatttttggagcagctttcaaatcattgtttggaggaatgtcctggttctcacaaattctcattggaacgttgctgatgtggttgggtctgaacacaaagaatggatctatttcccttatgtgcttggccttagggggagtgttgatcttcttatccacagccgtctctgctgatgtggggtgctcggtggacttctcaaagaaggagacgagatgcggtacaggggtgttcgtctataacgacgttgaagcctggagggacaggtacaagtaccatcctgactccccccgtagattggcagcagcagtcaagcaagcctgggaagatggtatctgtgggatctcctctgtttcaagaatggaaaacatcatgtggagatcagtagaaggggagctcaacgcaatcctggaagagaatggagttcaactgacggtcgttgtgggatctgtaaaaaaccccatgtggagaggtccacagagattgcccgtgcctgtgaacgagctgccccacggctggaaggcttgggggaaatcgtacttcgtcagagcagcaaagacaaataacagctttgtcgtggatggtgacacactgaaggaatgcccactcaaacatagagcatggaacagctttcttgtggaggatcatgggttcggggtatttcacactagtgtctggctcaaggttagagaagattattcattagagtgtgatccagccgttattggaacagctgttaagggaaaggaggctgtacacagtgatctaggctactggattgagagtgagaagaatgacacatggaggctgaagagggcccatctgatcgagatgaaaacatgtgaatggccaaagtcccacacattgtggacagatggaatagaagagagtgatctgatcatacccaagtctttagctgggccactcagccatcacaataccagagagggctacaggacccaaatgaaagggccatggcacagtgaagagcttgaaattcggtttgaggaatgcccaggcaccaaggtccacgtggaggaaacatgtggaacaagaggaccatctctgagatcaaccactgcaagcggaagggtgatcgaggaatggtgctgcagggagtgcacaatgcccccactgtcgttccaggctaaagatggctgttggtatggaatggagataaggcccaggaaagaaccagaaagtaacttagtaaggtcaatggtgactgcaggatcaactgatcacatggatcacttctcccttggagtgcttgtgattctgctcatggtgcaggaagggctgaagaagagaatgaccacaaagatcatcataagcacatcaatggcagtgctggtagctatgatcctgggaggattttcaatgagtgacctggctaagcttgcaattttgatgggtgccaccttcgcggaaatgaacactggaggagatgtagctcatctggcgctgatagcggcattcaaagtcagaccagcgttgctggtatctttcatcttcagagctaattggacaccccgtgaaagcatgctgctggccttggcctcgtgtcttttgcaaactgcgatctccgccttggaaggcgacctgatggttctcatcaatggttttgctttggcctggttggcaatacgagcgatggttgttccacgcactgataacatcaccttggcaatcctggctgctctgacaccactggcccggggcacactgcttgtggcgtggagagcaggccttgctacttgcggggggtttatgctcctctctctgaagggaaaaggcagtgtgaagaagaacttaccatttgtcatggccctgggactaaccgctgtgaggctggtcgaccccatcaacgtggtgggactgctgttgctcacaaggagtgggaagcggagctggccccctagcgaagtactcacagctgttggcctgatatgcgcattggctggagggttcgccaaggcagatatagagatggctgggcccatggccgcggtcggtctgctaattgtcagttacgtggtctcaggaaagagtgtggacatgtacattgaaagagcaggtgacatcacatgggaaaaagatgcggaagtcactggaaacagtccccggcttgatgtggcgctagatgagagtggtgatttctccctggtggaggatgacggtccccccatgagagagatcatactcaaggtggtcctgatgaccatctgtggcatgaacccaatagccataccctttgcagctggagcgtggtacgtatacgtgaagactggaaaaaggagtggagctctatgggatgtgcctgctcccaaggaagtaaaaaagggggagaccacagatggagtgtacagagtgatgactcgtagactgctaggttcaacacaagttggagtgggagttatgcaagagggggtctttcacaccatgtggcacgtcacaaaaggatccgcgctgagaagcggtgaagggagacttgatccatactggggagatgtcaagcaggatctggtgtcatactgtggtccatggaagctagatgccgcctgggacgggcacagcgaggtgcagctcttggccgtgccccccggagagagagcgaggaacatccagactctgcccggaatatttaagacaaaggatggggacattggagcggttgcgctggattacccagcaggaacttcaggatctccaatcctagacaagtgtgggagagtgataggactttatggcaatggggtcgtgatcaaaaatgggagttatgttagtgccatcacccaagggaggagggaggaagagactcctgttgagtgcttcgagccttcgatgctgaagaagaagcagctaactgtcttagacttgcatcctggagctgggaaaaccaggagagttcttcctgaaatagtccgtgaagccataaaaacaagactccgtactgtgatcttagctccaaccagggttgtcgctgccgaaatggaggaagcccttagagggcttccagtgcgttatatgacaacagcagtcaatgtcacccactctggaacagaaatcgtcgacttaatgtgccatgccaccttcacttcacgtctactacagccaatcagagtccccaactataatctgtatattatggatgaggcccacttcacagatccctcaagtatagcagcaagaggatacatttcaacaagggttgagatgggcgaggcggctgccatcttcatgaccgccacgccaccaggaacccgtgacgcatttccggactccaactcaccaattatggacaccgaagtggaagtcccagagagagcctggagctcaggctttgattgggtgacggatcattctggaaaaacagtctggtttgttccaagcgtgaggaacggcaatgagatcgcagcttgtctgacaaaggctggaaaacgggtcatacagctcagcagaaagacttttgagacagagttccagaaaacaaaacatcaagagtgggactttgtcgtgacaactgacatttcagagatgggcgccaactttaaagctgaccgtgtcatagattccaggagatgcctaaagccggtcatacttgatggcgagagagtcattctggctggacccatgcctgtcacacatgccagcgctgcccagaggagggggcgcataggcaggaatcccaacaaacctggagatgagtatctgtatggaggtgggtgcgcagagactgacgaagaccatgcacactggcttgaagcaagaatgctccttgacaatatttacctccaagatggcctcatagcctcgctctatcgacctgaggccgacaaagtagcagccattgagggagagttcaagcttaggacggagcaaaggaagacctttgtggaactcatgaaaagaggagatcttcctgtttggctggcctatcaggttgcatctgccggaataacctacacagatagaagatggtgctttgatggcacgaccaacaacaccataatggaagacagtgtgccggcagaggtgtggaccagacacggagagaaaagagtgctcaaaccgaggtggatggacgccagagtttgttcagatcacgcggccctgaagtcattcaaggagtttgccgctgggaaaagaggagcggcttttggagtgatggaagccttgggaacactgccaggacacatgacagagagattccaggaagccattgacaacctcgctgtgctcatgcgggcagagactggaagcaggccttacaaagccgcggcggcccaattgccggagaccctagagaccattatgcttttggggttgctgggaacagtctcgctgggaatctttttcgtcttgatgaggaacaagggcatagggaagatgggctttggaatggtgactcttggggccagcgcatggctcatgtggctctcggaaattgagccagccagaattgcatgtgtcctcattgttgtgttcctattgctggtggtgctcatacctgagccagaaaagcaaagatctccccaggacaaccaaatggcaatcatcatcatggtagcagtaggtcttctgggcttgattaccgccaatgaactcggatggttggagagaacaaagagtgacctaagccatctaatgggaaggagagaggagggggcaaccataggattctcaatggacattgacctgcggccagcctcagcttgggccatctacgctgccttgacaactttcattaccccagccgtccaacatgcagtgaccacttcatacaacaactactccttaatggcgatggccacgcaagctggagtgttgtttggtatgggcaaagggatgccattctacgcatgggactttggagtcccgctgctaatgataggttgctactcacaattaacacccctgaccctaatagtagccatcattttgctcgtggcgcactacatgtacttgatcccagggctgcaggcagcagctgcgcgtgctgcccagaagagaacggcagctggcatcatgaagaaccctgttgtggatggaatagtggtgactgacattgacacaatgacaattgacccccaagtggagaaaaagatgggacaggtgctactcatagcagtagccgtctccagcgccatactgtcgcggaccgcctgggggtggggggaggctggggccctgatcacagctgcaacttccactttgtgggaaggctctccgaacaagtactggaactcctctacagccacttcactgtgtaacatttttaggggaagttacttggctggagcttctctaatctacacagtaacaagaaacgctggcttggtcaagagacgtgggggtggaacaggagagaccctgggagagaaatggaaggcccgcttgaaccagatgtcggccctggagttctactcctacaaaaagtcaggcatcaccgaggtgtgcagagaagaggcccgccgcgccctcaaggacggtgtggcaacgggaggccatgctgtgtcccgaggaagtgcaaagctgagatggttggtggagcggggatacctgcagccctatggaaaggtcattgatcttggatgtggcagagggggctggagttactacgccgccaccatccgcaaagttcaagaagtgaaaggatacacaaaaggaggccctggtcatgaagaacccatgttggtgcaaagctatgggtggaacatagtccgtcttaagagtggggtggacgtctttcatatggcggctgagccgtgtgacacgttgctgtgtgacataggtgagtcatcatctagtcctgaagtggaagaagcacggacgctcagagtcctttccatggtgggggattggcttgaaaaaagaccaggagccttttgtataaaagtgttgtgcccatacaccagcactatgatggaaaccctggagcgactgcagcgtaggtatgggggaggactggtcagagtgccactctcccgcaactctacacatgagatgtactgggtctctggagcgaaaagcaacaccataaaaagtgtgtccaccacgagccagctcctcttggggcgcatggacgggcccaggaggccagtgaaatatgaggaggatgtgaatctcggctctggcacgcgggctgtggtaagctgcgctgaagctcccaacatgaagatcattggtaaccgcattgaaaggatccgcagtgagcacgcggaaacgtggttctttgacgagaaccacccatataggacatgggcttaccatggaagctatgaggcccccacacaagggtcagcgtcctctctaataaacggggttgtcaggctcctgtcaaaaccctgggacgtggtgactggagtcacaggaatagccatgaccgacaccacaccgtatggtcagcaaagagttttcaaggaaaaagtggacactagggtgccagatccccaagaaggcactcgtcaggttatgagcatggtctcttcctggttgtggaaagagctaggcaaacacaaacggccacgagtctgtaccaaagaagagttcatcaacaaggttcgtagcaatgcagcattaggggcaatatttgaagaggaaaaagagtggaagactgcagtggaagctgtgaacgatccaaggttctgggctctagtggacaaggaaagagagcaccacctgagaggagagtgccagagttgtgtgtacaacatgatgggaaaaagagaaaagaaacaaggggaatttggaaaggccaagggcagccgcgccatctggtatatgtggctaggggctagatttctagagttcgaagcccttggattcttgaacgaggatcactggatggggagagagaactcaggaggtggtgttgaagggctgggattacaaagactcggatatgtcctagaagagatgagtcgcataccaggaggaaggatgtatgcagatgacactgctggctgggacacccgcatcagcaggtttgatctggagaatgaagctctaatcaccaaccaaatggagaaagggcacagggccttggcattggccataatcaagtacacataccaaaacaaagtggtaaaggtccttagaccagctgaaaaagggaagacagttatggacattatttcgagacaagaccaaagggggagcggacaagttgtcacttacgctcttaacacatttaccaacctagtggtgcaactcattcggagtatggaggctgaggaagttctagagatgcaagacttgtggctgctgcggaggtcagagaaagtgaccaactggctgcagagcaacggatgggataggctcaaacgaatggcagtcagtggagatgattgcgttgtgaggccaattgatgataggtttgcacatgccctcaggttcttgaatgatatggggaaagttaggaaggacacacaagagtggaaaccctcaactggatgggacaactgggaggaagttccgttttgctcccaccacttcaacaagctccatctcaaggacgggaggtccattgtggttccctgccgccaccaagatgaactgattggccgggcccgcgtctctccaggggcgggatggagcatccgggagactgcttgcctagcaaaatcatatgcgcaaatgtggcagctcctttatttccacagaagggacctccgactgatggccaatgccatttgttcatctgtgccagttgactgggttccaactgggagaactacctggtcaatccatggaaagggagaatggatgaccactgaagacatgcttgtggtgtggaacagagtgtggattgaggagaacgaccacatggaagacaagaccccagttacgaaatggacagacattccctatttgggaaaaagggaagacttgtggtgtggatctctcatagggcacagaccgcgcaccacctgggctgagaacattaaaaacacagtcaacatggtgcgcaggatcataggtgatgaagaaaagtacatggactacctatccacccaagttcgctacttgggtgaagaagggtctacacctggagtgctgtaagcaccaatcttagtgttgtcaggcctgctagtcagccacagcttggggaaagctgtgcagcctgtgacccccccaggagaagctgggaaaccaagcctatagtcaggccgagaacgccatggcacggaagaagccatgctgcctgtgagcccctcagaggacactgagtcaaaaaaccccacgcgcttggaggcgcaggatgggaaaagaaggtggcgaccttccccaccctttaatctggggcctgaactggagatcagctgtggatctccagaagagggactagtggttagaggagaccccccggaaaacgcaaaacagcatattgacgctgggaaagaccagagactccatgagtttccaccacgctggccgccaggcacagatcgccgaatagcggcggccggtgtggggaaatccatgggtct
+>VEN/UF_1/2016|zika|KX702400|2016-03-25|south_america|venezuela|venezuela|venezuela|genbank|genome|Blohm et al|https://www.ncbi.nlm.nih.gov/nuccore/KX702400|Complete Genome Sequences of Identical Zika virus Isolates in a Nursing Mother and Her Infant|Genome Announc 5 (17), e00231-17 (2017)|https://www.ncbi.nlm.nih.gov/pubmed/28450510
+agttgttactgttgctgactcagactgcgacagttcgagtttgaagcgaaagctagcaacagtatcaacaggttttattttggatttggaaacgagagtttctggtcatgaaaaacccaaaaaagaaatccggaggattccggattgtcaatatgctaaaacgcggagtagcccgtgtgagcccctttgggggcttgaagaggctgccagccggacttctgctgggtcatgggcccatcaggatggtcttggcgattctagcctttttgagattcacggcaatcaagccatcactgggtctcatcaatagatggggttcagtggggaaaaaagatgctatggaaataataaagaagttcaagaaagatctggctgccatgctgagaataatcaatgctaggaaggagaagaagagacgaggcgcagaaactagtgtcggaattgttggcctccttctgaccacagctatggcagcggaggtcactagacgtgggagtgcatactatatgtacttggacagaaacgatgctggggaggccatatcttttccaaccacattggggatgaataagtgttatatacagatcatggatcttggacacatgtgtgatgccaccatgagctatgaatgccctatgctggatgagggggtggaaccagatgacgtcgattgttggtgcaacacgacgtcaacttgggttgtgtacggaacctgccatcacaaaaaaggtgaagcacggagatctagaagagccgtgacgctcccctcccattccactaggaagctgcaaacgcggtcgcaaacctggttggaatcaagagaatacacaaagcacttgattagagtcgaaaattggatattcaggaaccctggtttcgctttagcagcagctgccatcgcttggcttttgggaagctcaacgagccaaaaagtcatatacttggtcatgatactgctgattgccccggcatacagcatcaggtgcataggagtcagcaatagggactttgtggaaggtatgtcaggtgggacttgggttgatgtcgtcttggaacatggaggttgtgtcaccgtaatggcacaggacaaaccgactgtcgacatagagctggttacaacaacagtcagcaacatggcggaggtaagatcctactgctatgaggcatcaatatcagacatggcttcggacagccgctgcccaacacaaggtgaagcctaccttgacaagcaatcagacactcaatatgtttgcaaaagaacgttagtggacagaggctggggaaatggatgtggactttttggcaaagggagcctggtgacatgcgctaagtttgcatgctccaagaaaatgaccgggaagagcatccagccagagaatctggagtaccggataatgttgtcagttcatggctcccagcacagtgggatgattgttaatgacacaggacatgaaactgatgagaatagagcgaaggttgagataacgcccaattcaccaagagccgaagccaccctggggggttttggaagcctaggacttgattgtgaaccgaggacaggccttgacttttcagatttgtattacttgactatgaataacaagcactggttggttcacaaggagtggttccacgacattccattaccttggcacgctggggcagacaccggaactccacactggaacaacaaagaagcactggtagagttcaaggacgcacatgccaaaaggcaaactgtcgtggttctagggagtcaagaaggagcagttcacacggcccttgctggagctctggaggctgagatggatggtgcaaagggaaggctgtcctctggccacttgaaatgtcgcctgaaaatggataaacttagattgaagggcgtgtcatactccttgtgtaccgcagcgttcacattcaccaagatcccggctgaaacactgcacgggacagtcacagtggaggtacagtacgcagggacagatggaccttgcaaggttccagctcagatggcggtggacatgcaaactctgaccccagttgggaggttgataaccgctaaccccgtaatcactgaaagcactgagaactctaagatgatgctggaacttgatccaccatttggggactcttacattgtcataggagtcggggagaagaagatcacccaccactggcacaggagtggcagcaccattggaaaagcatttgaagccactgtgagaggtgccaagagaatggcagtcttgggagacacagcctgggactttggatcagttggaggcgctctcaactcattgggcaagggcatccatcaaatttttggagcagctttcaaatcattgtttggaggaatgtcctggttctcacaaattctcattggaacgttgctgatgtggttgggtctgaacacaaagaatggatctatttcccttatgtgcttggccttagggggagtgttgatcttcttatccacagccgtctctgctgatgtggggtgctcggtggacttctcaaagaaggagacgagatgtggtacaggggtgttcgtctataacgacgttgaagcctggagggacaggtacaagtaccatcctgactccccccgtagattggcagcagcagtcaagcaagcctgggaagatggtatctgcgggatctcctctgtttcaagaatggaaaacatcatgtggagatcagtagaaggggagctcaacgcaatcctggaagagaatggagttcaactgacggtcgttgtgggatctgtaaaaaaccccatgtggagaggtccacagagattgcccgtgcctgtgaacgagctgccccacggctggaaggcttgggggaaatcgtacttcgtcagagcagcaaagacaaataacagctttgtcgtggatggtgacacactgaaagaatgcccactcaaacatagagcatggaacagctttcttgtggaggatcatgggttcggggtatttcacactagtgtctggctcaaggttagagaagattattcattagagtgtgatccagccgttattggaacagctgttaagggaaaggaggctgtacacagtgatctaggctactggattgagagtgagaagaatgacacatggaggctgaagagggcccatctgatcgagatgaaaacatgtgaatggccaaagtcccacacattgtggacagatggaatagaagagagtgatctgatcatacccaagtctttagctgggccactcagccatcacaataccagagagggctacaggacccaaatgaaagggccatggcacagtgaagagcttgaaattcggtttgaggaatgcccaggcactaaggtccacgtggaggaaacatgtggaacaagaggaccatctctgagatcacccactgcaagcggaagggtgatcgaggaatggtgctgcagggagtgcacaatgcccccactgtcgttctgggctaaagatggctgttggtatggaatggagataaggcccaggaaagaaccagaaagcaacttagtaaggtcaatggtgactgcaggatcaactgatcacatggatcacttctcccttggagtgcttgtgattctgctcatggtgcaggaagggctgaagaagagaatgaccacaaagatcatcataagcacatcaatggcagtgctggtagctatgatcctgggaggattttcaatgagtgacctggctaagcttgcaatcttgatgggtgccaccttcgcggaaatgaacactggaggagatgtagctcatctggcgctgatagcggcattcaaagtcagaccagcgttgctggtatccttcatcttcagagctaattggacaccccgtgaaagcatgctgctggccttggcctcgtgtcttttgcaaactgcgatctccgccttggagggcgacctgatggttctcatcaatggttttgctttggcctggttggcaatacgagcgatggttgttccacgcactgacaacatcaccttggcaatcctggctgctctgacaccactggcccggggcacactgcttgtggcgtggagagcaggccttgctacttgcggggggtttatgctcctctctctgaagggaaaaggcagtgtgaagaagaacttaccatttgtcatggccctgggactaaccgctgtgaggctggtcgaccccatcaacgtggtgggactgctgttgctcacaaggagtgggaagcggagctggccccctagcgaagtactcacagctgttggcctgatatgcgcattggctggagggttcgccaaggcagatatagagatggctgggcccatggccgcggttggtctgctaattgtcagttacgtggtctcaggaaagagtgtggacatgtacattgaaagagcaggtgacatcacatgggaaaaagatgcggaagtcactggaaacagtccccggctcgatgtggcgctagatgagagtggtgatttctccctggtggaggatgacggtccccccatgagagagatcatactcaaggtggtcctgatgaccatctgtggcatgaacccaatagccataccctttgcagctggagcgtggtacgtatacgtgaagactggaaaaaggagtggtgcgctatgggatgtgcctgctcccaaggaagtaaaaaagggggagaccacagatggagtgtacagagtaatgactcgtagactgctaggttcaacacaagttggagtgggagttatgcaagagggggtctttcacactatgtggcacgtcacaaaaggatccgcgctgagaagcggtgaagggagacttgatccatactggggagatgtcaagcaggatctggtgtcatactgtggtccatggaagctagatgccgcctgggacgggcacagcgaggtgcagctcttggccgtgccccccggagagagagcgaggaacatccagactctgcccggaatatttaagacaaaggatggggacattggagcggttgcgctggattacccagcaggaacttcaggatctccaatcctagacaagtgtgggagagtgataggactttatggcaatggggtcgtgatcaaaaatgggagttatgttagtgccatcacccaagggaggagggaggaagagactcctgttgagtgcttcgagccttcgatgctgaagaagaagcagctaactgtcttagacttgcatcctggagctgggaaaaccaggagagttcttcctgaaatagtccgtgaagccataaaaacaagactccgtactgtgatcttagctccaaccagggttgtcgctgctgaaatggaggaagcccttagagggcttccagtgcgttatatgacaacagcagtcaatgtcacccactctggaacagaaatcgtcgacttaatgtgccatgccaccttcacttcacgtctactacagccaatcagagtccccaactataatctgtatattatggatgaggcccacttcacagatccctcaagtatagcagcaagaggatacatttcaacaagggttgagatgggcgaggcggctgccatcttcatgaccgccacgccaccaggaacccgtgacgcatttccggactccaactcaccaattatggacaccgaagtggaagtcccagagagagcctggagctcaggctttgattgggtgacggatcattctggaaaaacagtttggtttgttccaagcgtgaggaacggcaatgagatcgcagcttgtctgacaaaggctggaaaacgggtcatacagctcagcagaaagacttttgagacagagttccagaaaacaaaacatcaagagtgggactttgtcgtgacaactgacatttcagagatgggcgccaactttaaagctgaccgtgtcatagattccaggagatgcctaaagccggtcatacttgatggcgagagagtcattctggctggacccatgcctgtcacacatgccagcgctgcccagaggagggggcgcataggcaggaatcccaataaacctggagatgagtatctgtatggaggtgggtgcgcagagactgacgaagaccatgcacactggcttgaagcaagaatgctccttgacaatatttacctccaagatggcctcatagcctcgctctatcgacctgaggccgacaaagtagcagccattgagggagagttcaagcttaggacggagcaaaggaagacctttgtggaactcatgaaaagaggagatcttcctgtttggctggcctatcaggttgcatctgccggaataacctacacagatagaagatggtgctttgatggcacgaccaacaacaccataatggaagacagtgtgccggcagaggtgtggaccagacacggagagaaaagagtgctcaaaccgaggtggatggacgccagagtttgttcagatcatgcggccctgaagtcattcaaggagtttgccgctgggaaaagaggagcggcttttggagtgatggaagccctgggaacactgccaggacacatgacagagagattccaggaagccattgacaacctcgctgtgctcatgcgggcagagactggaagcaggccttacaaagccgcggcggcccaattgccggagaccctagagaccattatgcttttggggttgctgggaacagtctcgttgggaatctttttcgtcttgatgaggaacaagggcatagggaagatgggctttggaatggtgactcttggggccagcgcatggctcatgtggctctcggaaattgagccagccagaattgcatgtgtcctcattgttgtgttcctattgctggtggtgctcatacctgagccagaaaagcaaagatctccccaggacaaccaaatggcaatcatcatcatggtagcagtaggtcttctgggcttgattaccgccaatgaactcggatggttggagagaacaaagagtgacctaagccatctaatgggaaggagagaggagggggcaaccataggattctcaatggacattgacctgcggccagcctcagcttgggccatctatgctgccttgacaactttcattaccccagccgtccaacatgcagtgaccacttcatacaacaactactccttaatggcgatggccacgcaagctggagtgttgtttggtatgggcaaagggatgccattctacgcatgggactttggagtcccgctgctaatgataggttgctactcacaattaacacccctgaccctaatagtggccatcattttgctcgtggcgcactacatgtacttgatcccagggctgcaggcagcagctgcgcgtgctgcccagaagagaacggcagctggcatcatgaagaaccctgttgtggatggaatagtggtgactgacattgacacaatgacaattgacccccaagtggagaaaaagatgggacaggtgctactcatagcagtagccgtctccagcgccatactgtcgcggaccgcctgggggtggggggaggctggggccctgatcacagccgcaacttccactttgtgggaaggctctccgaacaagtactggaactcctctacagccacttcactgtgtaacatttttaggggaagttacttggctggagcttctctaatctacacagtaacaagaaacgctggcttggtcaagagacgtgggggtggaacaggagagaccctgggagagaaatggaaggcccgcttgaaccagatgtcggccctggagttctactcctacaaaaagtcaggcatcaccgaggtgtgcagagaagaggcccgccgcgccctcaaggacggtgtggcaacgggaggccatgctgtgtcccgaggaagtgcaaagctgagatggttggtggagcggggatacctgcagccctatggaaaggtcattgatcttggatgtggcagagggggctggagttactacgccgccaccatccgcaaagttcaagaagtgaaaggatacacaaaaggaggccctggtcatgaagaacccgtgttggtgcaaagctatgggtggaatatagtccgtcttaagagtggggtggacgtctttcatatggcggctgagccgtgtgacacgttgctgtgtgacataggtgagtcatcatctagtcctgaagtggaagaagcacggacgctcagagtcctctccatggtgggggattggcttgaaaaaagaccaggagccttttgtataaaagtgttgtgcccatacaccagcactatgatggaaaccctggagcgactgcagcgtaggtatgggggaggactggtcagagtgccactctcccgcaactctacacatgagatgtactgggtctctggagcgaaaagcaacaccataaaaagtgtgtccaccacgagccagctcctcttggggcgcatggacgggcctaggaggccagtgaaatatgaggaggatgtgaatctcggctctggcacgcgggctgtggtaagctgcgctgaagctcccaacatgaagatcattggtaaccgcattgaaaggatccgcagtgagcacgcggaaacgtggttctttgacgagaaccacccatataggacatgggcttaccatggaagctatgaggcccccacacaagggtcagcgtcctctctaataaacggggttgtcaggctcctgtcaaaaccctgggatgtggtgactggagtcacaggaatagccatgaccgacaccacaccgtatggtcagcaaagagttttcaaggaaaaagtggacactagggtgccagacccccaagaaggcactcgtcaggttatgagcatggtctcttcctggttgtggaaagagctaggcaaacacaaacggccacgagtctgtaccaaagaagagttcatcaacaaggtgcgtagcaatgcagcattaggggcaatatttgaagaggaaaaagagtggaagactgcagtggaagctgtgaacgatccaaggttctgggctctagtggacaaggaaagagagcaccacctgagaggagagtgccagagttgtgtgtacaacatgatgggaaaaagagaaaagaaacaaggggaatttggaaaggccaagggcagccgcgccatctggtatatgtggctaggggctagatttctagagttcgaagcccttggattcttgaacgaggatcactggatggggagagagaactcaggaggtggtgttgaagggctgggattacaaagactcggatatgtcctagaagagatgagtcgcataccaggaggaaggatgtatgcagatgacactgctggctgggacacccgcattagcaggtttgatctggagaatgaagctctaatcaccaaccaaatggagaaagggcacagggccttggcattggccataatcaagtacacataccaaaacaaagtggtaaaggtccttagaccagctgaaaaagggaaaacagttatggacattatttcgagacaagaccaaagggggagcggacaagttgtcacttacgctcttaacacatttaccaacctagtggtgcaactcattcggaatatggaggctgaggaagttctagagatgcaagacttgtggctgctgcggaggtcagagaaagtgaccaactggttgcagagcaacggatgggataggctcaaacgaatggcagtcagtggagatgattgcgttgtgaagccaattgatgataggtttgcacatgccctcaggttcttgaatgatatgggaaaagttaggaaggacacacaagagtggaaaccctcaactggatgggacaactgggaagaagttccgttttgctcccaccacttcaacaagctccatctcaaggacgggaggtccattgtggttccctgccgccaccaagatgaactgattggccgggcccgcgtctctccaggggcgggatggagcatccgggagactgcttgcctagcaaaatcatatgcgcaaatgtggcagctcctttatttccacagaagggacctccgactgatggccaatgccatttgttcatctgtgccagttgactgggttccaactgggagaactacctggtcaatccatggaaagggagaatggatgaccactgaagacatgcttgtggtgtggaacagagtgtggattgaggagaacgaccacatggaagacaagaccccagttacgaaatggacagacattccctatttgggaaaaagggaagacttgtggtgtggatctctcatagggcacagaccgcgcaccacctgggctgagaacattaaaaacacagtcaacatggtgcgcaggatcataggtgatgaagaaaagtacatggactacctatccacccaagttcgctacttgggtgaagaagggtctacacctggagtgctgtaagcaccaatcttaatgttgtcaggcctgctagtcagccacagcttggggaaagctgtgcagcctgtgacccccccaggagaagctgggaaaccaagcctatagtcaggccgagaacgccatggcacggaagaagccatgctgcctgtgagcccctcagaggacactgagtcaaaaaaccccacgcgcttggaggcgcaggatgggaaaagaaggtggcgaccttccccacccttcaatctggggcctgaactggagatcagctgtggatctccagaagagggactagtggttagaggagaccccccggaaaacgcaaaacagcatattgacgctgggaaagaccagagactccatgagtttccaccacgctggccgccaggcacagatcgccgaatagcggcggccggtgtggggaaatccatgggtctt
+>DOM/2016/BB_0059|zika|KY785425|2016-04-04|north_america|dominican_republic|dominican_republic|dominican_republic|genbank|genome|Metsky et al|https://www.ncbi.nlm.nih.gov/nuccore/KY785425|Zika virus evolution and spread in the Americas|Nature 546 (7658), 411-415 (2017)|https://www.ncbi.nlm.nih.gov/pubmed/28538734
+tggctgccatgctgagaataatcaatgctaggaaggagaagaagagacgaggcgcagatactagtgtcggaattgttggcctcctgctgaccacagctatggcagcggaggtcactagacgtgggagtgcatactacatgtacttggacagaaacgatgctggggaggccatatctttcccaaccacattggggatgaataagtgttatatacagatcatggatcttggacacatgtgtgatgccaccatgagctatgaatgccctatgctggatgagggggtggaaccagatgacgtcgattgttggtgcaacacgacgtcaacttgggttgtgtacggaacctgccatcacaaaaaaggtgaagcacggagatctagaagagctgtgacgctcccctcccattccactaggaagctgcaaacgcggtcgcaaacctggttggaatcaagagaatacacaaagcacttgattagagtcgaaaattggatattcaggaaccctggcttcgcgttagcagcagctgccatcgcttggcttttgggaagctcaacgagccaaaaagtcatatacttggtcatgatactgctgattgccccggcatacagcatcaggtgcataggagtcagcaatagggactttgtggaaggtatgtcaggtgggacttgggttgatgttgtcttggaacatggaggttgtgtcaccgtaatggcacaggacaaaccgactgtcgacatagagctggttacaacaacagtcagcaacatggcggaggtaagatcctactgctatgaggcatcaatatcagacatggcttcggacagccgctgcccaacacaaggtkaagcctaccttgacaagcaatcagacactcaatatgtctgcaaaagaacgttagtggacagaggctggggaaatggatgtggactttttggcaaagggagcctggtgacatgcgctaagtttgcatgctccaagaaaatgaccgggaagagcatccagccagagaatctggagtaccggataatgctgtcagttcatggctcccagcacagtgggatgatcgttaatgacacaggacatgaaactgatgagaatagagcgaaggttgagataacgcccaattcaccaagagccgaagccaccctggggggttttggaagcctaggactggattgtgaaccgaggacaggccttgacttttcagatttgtattacttgactatgaataacaagcactggttggttcacaaggagtggttccacgacattccattaccttggcacgctggggcagacaccggaactccacactggaacaacaaagaagcactggtagagttcaaggacgcacatgccaaaaggcaaactgtcgtggttctagggagtcaagaaggagcagttcacacggcccttgctggagctctggaggctgagatggatggtgcaaagggaaggctgtcctctggccacttgaaatgtcgcctgaaaatggataaacttagattgaagggcgtgtcatactccttgtgtaccgcagcgttcacattcaccaagatcccggctgaaacactgcacgggacagtcacagtggaggtacagtacgcagggacagatggaccttgcaaggttccagctcagatggcggtggacatgcaaactctgaccccagttgggaggttgataaccgccaaccccgtaatcactgaaagcactgagaactctaagatgatgctggaacttgatccaccatttggggactcttacattgtcataggagtcggggagaagaagatcacccaccactggcacaggagtggcagcaccattggaaaagcatttgaagccactgtgagaggtgccaagagaatggcagtcttgggagatacagcctgggactttggatcagttggaggcgctctcaactcattgggcaagggcatccatcaaatttttggagcagctttcaaatcattgtttggaggaatgtcctggttctcacaaatcctcattggaacgttgctgatgtggttgggtctgaacacaaagaatggatctatttccctcatgtgcttggccttagggggagtgttgatcttcttatccacagccgtctctgctgatgtggggtgctcggtggacttctcaaagaaggagacgagatgcggtacaggggtgttcgtctataacgacgttgaagcctggagggacaggtacaagtaccatcctgactccccccgtagattggcagcagcagtcaagcaagcctgggaagatggtatctgcgggatctcctctgtttcaagaatggaaaacatcatgtggagatcagtagaaggggagctcaatgcaatcctggaagagaatggagttcaactgacggtcgttgtgggatctgtaaaaaaccccatgtggagaggtccacagagattgcccgtgcctgtgaacgagctgccccacggctggaaggcttgggggaaatcgtacttcgttagagcagcaaagacaaataacagctttgtcgtgnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnntggaacagctgttaagggaaaggaggctgtacacagtgatctaggctactggattgagagtgagaagaatgacacatggaggctgaagagggcccatctgatcgagatgaaaacatgtgaatggccaaagtcccacacattgtggacagatggaatagaagagagtgatctgatcatacccaagtctttagctgggccactcagccatcacaataccagagagggctacaggacccaaatgaaagggccatggcacagtgaagagcttgaaattcggtttgaggaatgcccaggcactaaggtccacgtggaggaaacatgtggaacaagaggaccatctctgagatcaaccactgcaagcggaagggtgatcgaggaatggtgctgcagggagtgcacaatgcccccactgtcgttccgggctaaagatggctgttggtatggaatggagataaggcccaggaaagaaccagaaagcaacttagtaaggtcagtggtgactgcaggatcaactgatcacatggatcacttctcccttggagtgcttgtgattctgctcatggtgcaggaagggctgaagaagagaatgaccacaaagatcatcataagcacatcaatggcagtgctggtagctatgatcctgggaggattttcaatgagtgacctggctaagcttgcaattttgatgggtgccaccttcgcggaaatgaacactggaggagatgtagctcatctggcgctgatagcggcattcaaagtcagaccagcgttgctggtatctttcatcttcagagctaattggacaccccgtgaaagcatgctgctggccttggcctcgtgtcttttgcaaactgcgatctccgccttggaaggcgacctgatggttctcatcaatggttttgctttggcctggttggcaatacgagcgatggttgttccacgcactgataacatcaccttggcaatcctggctgctctgacaccactggcccggggtacactgcttgtggcgtggagagcaggccttgctacttgcggggggtttatgctcctctctctgaagggaaaaggcagtgtgaagaagaacttaccatttgtcatggccctgggactaaccgctgtgaggctggtcgaccccatcaacgtggtgggactgctgttgctcacaaggagtgggaagcggagctggccccctagcgaagtactcacagctgttggcctgatatgcgcattggctggagggttcgccaaggcagatatagagatggctgggcccatggccgcggtcggtctgctaattgtcagttacgtggtctcaggaaagagtgtggacatgtacattgaaagagcaggtgacatcacatgggaaaaagatgcggaagtcactggaaacagtccccggctcgatgtggcgctagatgagagtggtgatttctccctggtggaggatgacggtccccccatgagagagatcatactcaaggtggtcctgatgaccatctgtggcatgaacccaatagccataccctttgcagctggagcgtggtacgtatacgtgaagactggaaaaaggagtggtgctctatgggatgtgcctgctcccaaggaagtaaaaaagggggagaccacagatggagtgtacagagtaatgactcgtagactgctaggttcaacacaagttggagtgggagttatgcaagagggggtctttcacactatgtggcatgtcacaaaaggatccgcgctgagaagcggtgaagggagacttgatccatactggggagatgtcaagcaggatctggtgtcatactgtggtccatggaagctagatgccgcctgggacgggcacagcgaggtgcagctcttggccgtgccccccggagagagagcgaggaacatccagactctgcccggaatatttaagacaaaggannnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnncttcgagccttcgatgctgaagaagaagcagctaactgtcttagacttgcatcctggagctgggaaaaccaggagagttcttcctgaaatagtccgtgaagctataaaaacaagactccgtactgtgatcttagctccaaccagggttgtcgctgctgaaatggaggaagcccttagagggcttccagtgcgttatatgacaacagcagtcaatgtcacccattctggaacagaaatcgtcgacttaatgtgccatgccaccttcacttcacgtctactacagccaatcagagtccccaactataatctgtatattatggatgaggcccacttcacagatccctcaagtatagcagcaagaggatacatttcaacaagggttgagatgggcgaggcggctgccatcttcatgaccgccacgccaccaggaacccgtgacgcatttccggnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnncgggtcatacagctcagcagaaagacttttgagacagagttccagaaaacaaaacatcaagagtgggactttgtcgtgacaaccgacatttcagagatgggcgccaactttaaagctgaccgtgtcatagattccaggagatgcctaaagccggtcatacttgatggcgagagagtcattctggctggacccatgcctgtcacacatgccagcgctgcccagaggagggggcgcataggcaggaatcccaacaaacctggagatgagtatctgtatggaggtgggtgcgcagagactgacgaagaccatgcacactggcttgarkcaagaatgctccttgacaatatttgcctccaagatggcctcatagcctcgctctatcgacctgaggccgacaaagtagcagccattgagggagagttcaagcttaggacggagcaaaggaagacctttgtggaactcatgaaaagaggagatcttcctgtttggctggcctatcaggttgcatctgccggaataacttacacagatagaagatggtgctttgatggcacgaccaacaacaccataatggaagacagtgtgccggcagaggtgtggaccagacacggagagaaaagagtgctcaaaccgaggtggatggacgccagagtttgttcagatcatgcggccctgaagtcattcaaggagtttgccgctgggaaaagaggagcggcttttggagtgatggaagccctgggaacactgccaggacacatgacagagagattccaggaagccattgacaacctcgctgtgctcatgcgggcagagactggaagcaggccttacaaagccgcggcggcccaattgccggagaccctagagaccattatgcttttggggttgctgggaacagtctcgctgggaatctttttcgtcttgatgaggaacaagggcatagggaagatgggctttggaatggtgactcttggggccagcgcatggctcatgtggctctcggaaattgagccagccagaattgcatgtgtcctcattgttgtgttcctattgctggtggtgctcatacctgagccagaaaagcaaagatctccccaggacaaccaaatggcaatcatcatcatggtagcagtaggtcttctgggcttgatcaccgccaatgaactcggatggttggagagaacaaagagtgacctaagccatctaatgggaaggagagaggagggagcaaccataggattctcaatggacattgacctgcggccagcctcagcttgggccatctatgctgccttgacaactttcattaccccagccgtccaacatgcagtgaccacttcatacaacaactactccttaatggcgatggccacgcaagctggagtgttgtttggtatgggcaaagggatgccattctacgcatgggactttggagtcccgctgctaatgataggttgctactcacaattaacacccctgaccctaatagtggccatcattttgctcgtggcgcactacatgtacttgatcccagggctgcaggcagcagctgcgcgtgctgcccagaagagaacrgcagctggcatcatgaagaaccctgttgtggatggaatagtggtgactgacattgacacaatgacaattgacccccaagtggagaaaaagatgggacaggtgctactcatagcagtagccgtctccagcgccatactgtcgcggaccgcctgggggtggggggaggctggggccctgatcacagccgcaacttccactttgtgggaaggctctccgaacaagtactggaactcctctacagccacttcactgtgtaacatttttaggggaagttacttggctggagcttctctaatctacacagtaacaagaaacgctggcttggtcaagagacgtgggggtggaacaggagagaccctgggagagaaatggaaggcccgcttgaaccagatgtcggccctggagttctactcctacaaaaagtcaggcatcaccgaggtgtgcagagaagaggcccgccgcgccctcaaggacggtgtggcaacgggaggccatgctgtgtcccgaggaagtgcaaagctgagatggttggtggagcggggatacctgcagccctatggaaaggtcattgatcttggatgtggcagagggggctggagttactacgccgccaccatccgcaaagttcaagaagtgaaaggatacacaaaaggaggccctggtcatgaagaacccgtgttggtgcaaagctatgggtggaacatagtccgtctcaagagtggggtggacgtctttcatatggcggctgagccgtgtgacacgttgctgtgtgacataggtgagtcatcatctagtcctgaagtggaagaagcacggacgctcagagtcctctccatggtgggggattggcttgaaaaaagaccaggagccttttgtataaaagtgttgtgcccatacaccagcactatgatggaaaccctggagcgactgcagcgtaggtatgggggaggactggtcagagtgccactctcccgcaactctacacatgagatgtactgggtctctggagcgaaaagcaacaccataaaaagtgtgtccaccacgagccagctcctcttggggcgcatggacgggcctaggaggccagtgaaatatgaggaggatgtgaatctcggctctggcacgcgggctgtggtaagctgcgctgaagctcccaacatgaagatcattggtaaccgcattgaaaggatccgcagtgagcacgcggaaacgtggttctttgacgagaaccacccatataggacatgggcttaccatggaagctatgaggcccccacacaagggtcagcatcctctctagtaaacggggttgtcaggctcctgtcaaaaccctgggatgtggtgactggagtcacaggaatagccatgaccgacaccacaccgtatggtcagcaaagagttttcaaggaaaaagtggacactagggtgccagacccccaagaaggcactcgtcaggttatgagcatggtctcttcctggttgtggaaagagctaggcaaacacaaacggccacgagtctgtaccaaagaagagttcatcaacaaggttcgtagcaatgcagcattaggggcaatatttgaagaggaaaaagagtggaagactgcagtggaagctgtgaacgatccaaggttctgggctctagtggacaasgaaagagagcaccacctgagaggagagtgccagagttgtgtgtacaacatgatgggaaaaagagaaaagaaacaaggggaatttggaaaggccaagggcagccgcgccatctggtatatgtggctaggggctagatttctagagttcgaagcccttggattcttgaacgaggatcactggwtggggagagagaactcaggaggtggtgttgaagggctgggattannnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnagggcacagggccttggcattggccataatcaagtacacataccaaaacaaagtggtaaaggtccttagaccagctgaaaaagggaaaacagttatggacattatttcgagacaagaccaaagggggagcggacaagttgtcacttacgctcttaacacatttaccaacctagtggtgcaactcattcggaatatggaggctgaggaagttctagagatgcaagacttgtggctgctgcggaggtcagagaaagtgaccaactggttgcagagcaacggatgggataggctcaaacgaatggcagtcagtggagatgattgcgttgtgaagccaattgatgataggtttgcacatgccctcaggttcttgaatgatatgggaaaagttaggaaggacacacaagagtggaaaccctcaactggatgggacaactgggaagaagttccgttttgctcccaccacttcaacaagctccatctcaaggacgggaggtccattgtggttccctgccgccaccaagatgaactgattggccgggcccgcgtctctccaggggcgggatggagcatccgggagactgcttgcctagcaaaatcatatgcgcaaatgtggcagctcctttatttccacagaagggacctccgactgatggccaatgccatttgttcatctgtgccagttgactgggttccaactgggagaactacctggtcaatccatggaaagggagaatggatgaccattgaagacatgcttgtggtgtggaacagagtgtggattgaggagaacgaccacatggaagacaagaccccagttacgaaatggacagacattccctatttgggaaaaagggaagacttgtggtgtggatctctcatagggcacagaccgcgcaccacctgggctgagaacattaaaaacacagtcaacatggtgcgcaggatcataggtgaggaagaaaagtacatggactacctatccacccaagttcgctacttgggtgaagaagggtctacacctggagtgctgtaagcaccaatcttaatgttgtcaggcc
+>BRA/2016/FC_6706|zika|KY785433|2016-04-08|south_america|brazil|brazil|brazil|genbank|genome|Metsky et al|https://www.ncbi.nlm.nih.gov/nuccore/KY785433|Zika virus evolution and spread in the Americas|Nature 546 (7658), 411-415 (2017)|https://www.ncbi.nlm.nih.gov/pubmed/28538734
+agtttgaagcgaaagctagcaacagtatcaacaggttttatttyggatttggaaacgagagtttctggtcatgaaaaacccaaaaaagaaatccggaggattccggattgtcaatatgctaaaacgcggagtagcccgtgtgagcccctttgggggcttgaagaggctgccagccggacttctgctgggtcatgggcccatcaggatggtcttggcgattctagcctttttgagattcacggcaatcaagccatcactgggtctcatcaatagatggggttcagtggggaaaaaagaggctatggaaataataaagaagttcaagaaagatctggctgccatgctgagaataatcaatgctaggaaggagaagaagagacgaggcgcagatactagtgtcggaattgttggcctcctgctgaccacagctatggcagcggaggtcactagacgtgggagtgcatactatatgtacttggacagaaacgatgctggggaggccatatcttttccaaccacattggggatgaataagtgttatatacagatcatggatcttggacacatgtgtgatgccaccatgagctatgaatgccctatgctggatgagggggtggaaccagatgacgtcgattgttggtgcaacacgacgtcaacttgggttgtgtacggaacctgccatcacaaaaaaggtgaagcacggagatctagaagagctgtgacgctcccctcccattccactaggaagctgcaaacgcggtcgcaaacctggttggaatcaagagaatacacaaagcacttgattagagtcgaaaattggatattcaggaaccctggcttcgcgttagcagcagccgccatcgcttggcttttgggaagctcaacgagccaaaaagtcatatacttggtcatgatactgctgattgccccggcatacagcatcaggtgcataggagtcagcaatagggactttgtggaaggtatgtcaggtgggacttgggttgatgttgtcttggaacatggaggttgtgtcaccgtaatggcacaggacaaaccgactgtcgacatagagctggttacaacaacagtcagcaacatggcggaggtaagatcctactgctatgaggcatcaatatcagacatggcttcggacagccgctgcccaacacaaggtgaagcctaccttgacaagcaatcagacactcaatatgtctgyaaaagaacgttagtggacagaggctggggaaatggatgtggactttttggcaaagggagcctggtgacatgcgctaagtttgcatgctccaagaaaatgaccgggaagagcatccagccagagaatctggagtaccggataatgctgtcagttcatggctcccagcacagtgggatgatcgttaatgacacaggacatgaaactgatgagaatagagcgaaggttgagataacgcccaattcaccaagagccgaagccaccctggggggttttggaagcctaggacttgattgtgaaccgaggacaggccttgacttttcagatttgtattacttgactatgaataacaagcactggttggttcacaaggagtggttccacgacattccattaccttggcacgctggggcagacaccggaactccacactggaacaacaaagaagcactggtagagttcaaggacgcacatgccaaaaggcaaactgtcgtggttctagggagtcaagaaggagcagttcacacggcccttgctggagctctggaggctgagatggatggtgcaaagggaaggctgtcctctggccacttgaaatgtcgcctgaaaatggataaacttagattgaagggcgtgtcatactccttgtgtaccgcagcgttcacattcaccaagatcccggctgaaacactgcacgggacagtcacagtggaggtacagtacgcagggacagatggaccttgcaaggttccagctcagatggcggtggacatgcaaactctgaccccagttgggaggttgataaccgctaaccccgtaatcactgaaagcactgagaactctaagatgatgctggaacttgatccaccatttggggactcttacattgtcataggagtcggggagaagaagatcacccaccactggcacaggagtggcagcaccattggaaaagcatttgaagccactgtgagaggtgccaagagaatggcagtcttgggagacacagcctgggactttggatcagttggaggcgctctcaactcattgggcaagggcatccatcaaatttttggagcagctttcaaatcattgtttggaggaatgtcctggttctcacaaattctcattggaacgttgctgatgtggttgggtctgaacacaaagaatggatctatttcccttatgtgcttggccttagggggagtgttgatcttcttatccacagccgtctctgctgatgtggggtgctcggtggacttctcaaagaaggagacgagatgtggtacaggggtgttcgtctataacgacgttgaagcctggagggacaggtacaagtaccatcctgactccccccgtagattggcagcagcagtcaagcaagcctgggaagatggtatctgcgggatctcttctgtttcaagaatggaaaacatcatgtggagatcagtagaaggggagctcaacgcaatcctggaagagaatggagttcaactgacggtcgttgtgggatctgtaaaaaaccccatgtggagaggtccacagagattgcccgtgcctgtgaacgagctgccccacggctggaaggcttgggggaaatcgtacttcgtcagagcagcaaagacaaataacagctttgtcgtggatggtgacacactgaaggaatgcccactcaaacatagagcatggaacagctttctwgtggaggatcatgggttcggggtatttcacactagtgtctggctcaaggttagagaagattattcattagagtgtgatccagccgttattggaacagctgttaagggaaaggaggctgtacacagtgatctaggctactggattgagagtgagaagaatgacacatggaggctgaagagggcccatctgatcgagatgaaaacatgtgaatggccaaagtcccacacattgtggacagatggaatagaagagagtgatctgatcatacccaagtctttagctgggccactcagccatcacaataccagagagggctacaggacccaaatgaaagggccatggcacagtgaagagcttgaaattcggtttgaggaatgcccaggcactaaggtccacgtggaggaaacatgtggaacaagaggaccatctctgagatcaaccactgcaagcggaagggtgatcgaggaatggtgctgcagggagtgcacaatgcccccactgtcgttccgggctaaagatggctgttggtatggaatggagataaggcccaggaaagaaccagaaagcaacttagtaaggtcaatggtgactgcaggatcaactgatcacatggatcacttctcccttggagtgcttgtgattctgctcatggtgcaggaagggctgaagaagagaatgaccacaaagatcatcataagcacatcaatggcagtgctggtagctatgatcctgggaggattttcaatgagtgacctggctaagcttgcaattttgatgggtgccaccttcgcggaaatgaacactggaggagatgtagctcatctggcgctgatagcggcattcaaagtcagaccagcgttgctggtatctttcatcttcagagctaattggacaccccgtgaaagcatgctgctggccttggcctcgtgtcttttgcaaactgcgatctccgccttggaaggcgacctgatggttctcatcaatggttttgctttggcctggttggcaatacgagcgatggttgttccacgcactgacaacatcaccttggcaatcctggctgctctgacaccactggcccggggcacactgcttgtggcgtggagagcaggccttgctacttgcggggggtttatgctcctctctctgaagggaaaaggcagtgtgaagaagaacttaccatttgtcatggccctgggactaaccgctgtgaggctggtcgaccccatcaacgtggtgggactgctgttgctcacaaggagtgggaagcggagctggccccctagcgaagtactcacagctgttggcctgatatgcgcattggctggagggttcgccaaggcagatatagagatggctgggcccatggccgcggtcggtctgctaattgtcagttacgtggtctcgggaaagagtgtggacatgtacattgaaagagcaggtgacatcacatgggaaaaagatgcggaagtcactggaaacagtccccggctcgatgtggcgctagatgagagtggtgatttctccctggtggaggatgacggtccccccatgagagagatcatactcaaggtggtcctgatgaccatctgtggcatgaacccaatagccataccctttgcagctggagcgtggtacgtatacgtgaagactggaaaaaggagtggtgctctatgggatgtgcctgctcccaaggaagtaaaaaagggggagaccacagatggagtgtacagagtaatgactcgtagactgctaggttcaacacaagttggagtgggagttatgcaagagggggtctttcacactatgtggcacgtcacaaaaggatccgcgctgagaagcggtgaagggagacttgatccatactggggagatgtcaagcaggatctggtgtcatactgtggtccatggaagctagatgccgcctgggacgggcacagcgaggtgcagctcttggccgtgccccccggagagagagcgaggaacatccagactctgcccggaatatttaagacaaaggatggggannnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnagccttcgatgctgaagaagaagcagctaactgtcttagacttgcatcctggagctgggaaaaccaggagagttcttcctgaaatagtccgtgaagccataaaaacaagactccgtactgtgatcttagctccaaccagggttgtcgctgctgaaatggaggaagcccttagagggcttccagtgcgttatatgacaacagcagtcaatgtcacccactctggaacagaaatcgtcgacttaatgtgcyatgccaccttcacttcacgtctactacagccaatcagagtccccaactataatctgtatattatggatgaggcccacttcacagatccctcaagtatagcagcaagaggatacatttcaacaagggttgagatgggcgaggcrgctgccatcttcatgaccgccacgccaccaggaacccgtgacgcatttccggactccaactcaccaattatggacaccgaagtggaagtcccagagagagcctggagctcaggctttgattgggtgacggatcattctggaaaaacagtttggtttgttccaagcgtgaggaacggcaatgagatcgcagcttgtctgacaaaggctggaaaacgggtcatacagctcagcagaaagacttttgagacagagttccagaaaacaaaacatcaagagtgggactttgtcgtgacaactgacatttcagagatgggcgccaactttaaagctgaccgtgtcatagattccaggagatgcctaaagccggtcatacttgatggcgagagagtcattctggctggacccatgcctgtcacacatgccagcgctgcccagaggagggggcgcataggcaggaatcctaacaaacctggagatgagtatctgtatggaggtgggtgcgcagagactgacgaagaccatgcacactggcttgaagcaagaatgctccttgacaatatttacctccaagatggcctcatagcctcgctctatcgacctgaggccgacaaagtagcagccattgagggagagttcaagcttaggacggagcaaaggaagacctttgtggaactcatgaaaagaggagatcttcctgtttggctggcctatcaggttgcatctgccggaataacctacacagatagaagatggtgctttgatggcacgaccaacaacaccataatggaagacagtgtgccggcagaggtgtggaccagacacggagagaaaagagtgctcaaaccgaggtggatggacgccagagtttgttcagatcatgcggccctgaagtcattcaaggagtttgccgctgggaaaagaggagcggcttttggagtgatggaagccctgggaacactgccaggacacatgacagagagattccaggaagccattgacaacctcgctgtgctcatgcgggcagagactggaagcaggccttacaaagccgcggcggcccaattgccggagaccctagagaccattatgctcttggggttgctgggaacagtctcgctgggaatctttttcgtcttgatgaggaacaagggcatagggaagatgggctttggaatggtgactcttggggccagcgcatggctcatgtggctctcggaaattgagccagccagaattgcatgtgtcctcattgttgtgttcctattgctggtggtgctcatacctgagccagaaaagcaaagatctccccaggacaaccaaatggcaatcatcatcatggtagcagtaggtcttctgggcttgattaccgccaatgaactcggatggttggagagaacaaagagtgacctaagccatctaatgggaaggagagaggagggggcaaccataggattctcaatggacattgacctgcggccagcctcagcttgggccatctatgctgccttgacaactttcattaccccagccgtccaacatgcagtgaccacttcatacaacaactactccttaatggcgatggccacgcaggctggagtgttgtttggtatgggcaaagggatgccattctacgcatgggactttggagtcccgctgctaatgataggttgctactcacaattaacacccctgaccctaatagtggccatcattttgctcgtggcgcactacatgtacttgatcccagggctgcaggcagcagctgcgcgtgctgcccagaagagaacggcagctggcatcatgaagaaccctgttgtggatggaatagtggtgactgacattgacacaatgacaattgacccccaagtggagaaaaagatgggacaggtgctactcatagcagtagccgtctccagcgccatactgtcgcggaccgcctgggggtggggggaggctggggctctgatcacagccgcaacctccactttgtgggaaggctctccgaacaagtactggaactcctctacagccacttcactgtgtaacatttttaggggaagttacttggctggagcttctctaatctacacagtaacaagaaacgctggcttggtcaagagacgtgggggtggaacaggagagaccctgggagagaaatggaaggcccgcttgaaccagatgtcggccctggagttctactcctacaaaaagtcaggcatcaccgaggtgtgcagagaagaggcccgccgcgccctcaaggacggtgtggcaacgggaggccatgctgtgtcccgaggaagtgcaaagctgagatggttggtggagcggggatacctgcagccctatggaaaggtcattgatcttggatgtggcagagggggctggagttactacgccgccaccatccgcaaagttcaagaagtgaaaggatacacaaaaggaggccctggtcatgaagaacccgtgttggtgcaaagctatgggtggaacatagtccgtcttaagagtggggtagacgtctttcatatggcggctgagccgtgtgacacgttgctgtgtgacataggtgagtcatcatctagtcctgaagtggaagaagcacggacgctcagagtcctctccatggtgggggattggcttgaaaaaagaccaggagccttttgtataaaagtgttgtgcccatacaccagcactatgatggaaaccctggagcgactgcagcgtaggtatgggggaggactggtcagagtgccactctcccgcaactctacacatgagatgtactgggtctctggagcgaaaagcaacaccataaaaagtgtgtccaccacgagccagctcctcttggggcgcatggacgggcctaggaggccagtgaaatatgaggaggatgtgaatctcggctctggcacgcgggctgtggtaagctgcgctgaagctcccaacatgaagatcattggtaaccgcattgaaaggatccgcagtgagcacgcggaaacgtggttctttgacgagaaccacccatataggacatgggcttaccatggaagctatgaggcccccacacaagggtcagcgtcctctctaataaacggggttgtcaggctcctgtcaaaaccctgggatgtggtgactggagtcacaggaatagccatgaccgacaccacaccgtatggtcagcaaagagttttcaaggaaaaagtggacactagggtgccagacccccaagaaggcactcgtcaggttatgagcatggtctcttcctggttgtggaaagagctaggcaaacacaagcggccacgagtctgtaccaaagaagagttcatcaacaaggttcgtagcaatgcagcattaggggcaatatttgaagaggaaaaagrktggaagactgcagtggaagctgtgaacgatccaaggttctgggctctagtggacaaggaaagagagcaccacctgagaggagagtgccagagttgtgtgtacaacatgatgggaaaaagagaaaagaaacaaggggaatttggaaaggccaagggcagtcgcgccatctggtatatgtggctaggggctagatttctagagttcgaagcccttggattcttgaacgaggatcactggatggggagagagaactcaggaggtggtgttgaagnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnacagggccttggcattggccataatcaagtacacataccaaaacaaagtggtaaaggtccttagaccagctgaaaaagggaaaacagttatggacattatttcgagacaagaccaaagggggagcggacaagttgtcacttacgctcttaacacatttaccaacctagtggtgcaactcattcggaatatggaggctgaggaagttctagagatgcaagacttgtggctgctgcggaggtcagagaaagtgaccaactggttgcagagcaacggatgggataggctcaaacgaatggcagtcagtggagatgattgcgttgtgaagccaattgatgataggtttgcacatgccctcaggttcttgaatgatatgggaaaagtcaggaaggacacacaagagtggaaaccctcaactggatgggacaactgggaagaagttccgttttgctcccaccacttcaacaagctccatctcaaggacgggaggtccattgtggttccctgccgccaccaagatgaactgattggccgggcccgcgtctctccaggggcgggatggagcatccgggagactgcttgcctagcaaaatcatatgcgcaaatgtggcagctcctttatttccacagaagggacctccgactgatggccaatgccatttgttcatctgtgccagttgactgggttccaactgggagaactacctggtcaatccatggaaagggagaatggatgaccactgaagacatgcttgtggtgtggaacagagtgtggattgaggagaacgaccacatggaagacaagaccccagttacgaaatggacagacattccctatttgggaaaaagggaagacttgtggtgtggatctctcatagggcacagaccgcgcaccacctgggctgagaacattaaaaacacagtcaacatggtgcgcaggatcataggtgatgaagaaaagtacatggactacctatccacccaagttcgctacttgggtgaagaagggtctacacctggagtgctgtaagcaccaatcttaatgttgtcaggc
+>DOM/2016/BB_0183|zika|KY785420|2016-04-18|north_america|dominican_republic|dominican_republic|dominican_republic|genbank|genome|Metsky et al|https://www.ncbi.nlm.nih.gov/nuccore/KY785420|Zika virus evolution and spread in the Americas|Nature 546 (7658), 411-415 (2017)|https://www.ncbi.nlm.nih.gov/pubmed/28538734
+gtttgaagcgaaagctagcaacagtatcaacaggttttattttggatttggaaacgagagtttctggtcatgaaaaacccaaaaaagaaatccggaggattccggattgtcaatatgctaaaacgcggagtagcccgtgtgagcccctttgggggcttgaagaggctgccagccggacttctgctgggtcatgggcccatcaggatggtcttggcgattctagcctttttgagattcacggcaatcaagccatcactgggtctcatcaatagatggggttcagtggggaaaaaagaggctatggaaataataaagaagttcaagaaagatctggctgccatgctgagaataatcaatgctaggaaggagaagaagagacgaggcgcagatactagtgtcggaattgttggcctcctgctgaccacagctatggcagcggaggtcactagacgtgggagtgcatactacatgtacttggacagaaacgatgctggggaggccatatcttttccaaccacattggggatgaataagtgttatatacagatcatggatcttggacacatgtgtgatgccaccatgagctatgaatgccctatgctggatgagggggtggaaccagatgacgtcgattgttggtgcaacacgacgtcaacttgggttgtgtacggaacctgccatcacaaaaaaggtgaagcacggagatctagaagagctgtgacgctcccctcccattccactaggaagctgcaaacgcggtcgcaaacctggttggaatcaagagaatacacaaagcacttgattagagtcgaaaattggatattcaggaaccctggcttcgcgttagcagcagctgccatcgcttggcttttgggaagctcaacgagccaaaaagtcatatacttggtcatgatactgctgattgccccggcatacagcatcaggtgcataggagtcagcaatagggactttgtggaaggtatgtcaggtgggacttgggttgatgttgtcttggaacatggaggttgtgtcaccgtaatggcacaggacaaaccgactgtcgacatagagctggttacaacaacagtcagcaacatggcggaggtaagatcctactgctatgaggcatcaatatcagacatggcttcggacagccgctgcccaacacaaggtgaagcctaccttgacaagcaatcagacactcaatatgtctgcaaaagaacgttagtggacagaggctggggaaatggatgtggactttttggcaaagggagcctggtgacatgcgctaagtttgcatgctccaagaaaatgaccgggaagagcatccagccagagaatctggagtaccggataatgctgtcagttcatggctcccagcacagtgggatgatcgttaatgacacaggacatgaaactgatgagaatagagcgaaggttgagataacgcccaattcaccaagagccgaagccaccctggggggttttggaagcctaggacttgattgtgaaccgaggacaggccttgacttttcagatttgtattacttgactatgaataacaagcactggttggttcacaaggagtggttccacgacattccattaccttggcacgctggggcagacaccggaactccacactggaacaacaaagaagcactggtagagttcaaggacgcacatgccaaaaggcaaactgtcgtggttctagggagtcaagaaggagcagttcacacggcccttgctggagctctggaggctgagatggatggtgcaaagggaaggctgtcctctggccacttgaaatgtcgcctgaaaatggataaacttagattgaagggcgtgtcatactccttgtgtaccgcagcgttcacattcaccaagatcccggctgaaacactgcacgggacagtcacagtggaggtacagtacgcagggacagatggaccttgcaaggttccagctcagatggcggtggacatgcaaactctgaccccagttgggaggttgataaccgccaaccccgtaatcactgaaagcactgagaactctaagatgatgctggaacttgatccaccatttggggactcttacattgtcataggagtcggggagaagaagatcacccaccactggcacaggagtggcagcaccattggaaaagcatttgaagccactgtgagaggtgccaagagaatggcagtcttgggagacacagcctgggactttggatcagttggaggcgctctcaactcattgggcaagggcatccatcaaatttttggagcagctttcaaatcattgtttggaggaatgtcctggttctcacaaatcctcattggaacgttgctgatgtggttgggtctgaacacaaagaatggatctatttccctcatgtgcttggccttagggggagtgttgatcttcttatccacagccgtctctgctgatgtggggtgctcggtggacttctcaaagaaggagacgagatgcggtacaggggtgttcgtctataacgacgttgaagcctggagggacaggtacaagtaccatcctgactccccccgtagattggcagcagcagtcaagcaagcctgggaagatggtatctgcgggatctcctctgtttcaagaatggaaaacatcatgtggagatcagtagaaggggagctcaatgcaatcctggaagagaatggagtccaactgacggtcgttgtgggatctgtaaaaaaccccatgtggagaggtccacagagattgcccgtgcctgtgaacgagctgccccacggctggaaggcctgggggaaatcgtacttcgttagagcagcaaagacaaataacagctttgtcgtggatggtgacacactgaaggaatgcccactcaaacatagagcatggaacagctttcttgtggaggatcatgggttcggggtatttcacactagtgtctggctcaaggttagagaagattattcattagagtgtgatccagccgttattggaacagctgttaagggaaaggaggctgtacacagtgatctaggctactggattgagagtgagaagaatggcacatggaggctgaagagggcccatctgatcgagatgaaaacatgtgaatggccaaagtcccacacattgtggacagatggaatagaagagagtgatctgatcatacccaagtctttagctgggccactcagccatcacaataccagagagggctacaggacccaaatgaaagggccatggcacagtgaagagcttgaaattcggtttgaggaatgcccaggcactaaggtccacgtggaggaaacatgtggaacaagaggaccatctctgagatcaaccactgcaagcggaagggtgatcgaggaatggtgctgcagggagtgcacaatgcccccactgtcgttccgggctaaagatggctgttggtatggaatggagataaggcccaggaaagaaccagaaagcaacttagtaaggtcagtggtgactgcaggatcaactgatcacatggatcacttctcccttggagtgcttgtgattctgctcatggtgcaggaagggctgaagaagagaatgaccacaaagatcatcataagcacatcaatggcagtgctggtagctatgatcctgggaggattttcaatgagtgacctggctaagcttgcaattttgatgggtgccaccttcgcggaaatgaacactggaggagatgtagctcatctggcgctgatagcggcattcaaagtcagaccagcgttgctggtatctttcatcttcagagctaattggacaccccgtgaaagcatgctgctggccttggcctcgtgtcttttgcaaactgcgatctccgccttggaaggcgacctgatggttctcatcaatggttttgctttggcctggttggcaatacgagcgatggttgttccacgcactgataacatcaccatggcaatcctggctgctctgacaccactggcccggggcacactgcttgtggcgtggagagcaggccttgctacttgcggggggtttatgctcctctctctgaagggaaaaggcagtgtgaagaagaacttaccatttgtcatggccctgggactaaccgctgtgaggctggtcgaccccatcaacgtggtgggactgctgttgctcacaaggagtgggaagcggagctggccccctagcgaagtactcacagctgttggcctgatatgcgcattggctggagggttcgccaaggcagatatagagatggctgggcccatggccgcggtcggtctgctaattgtcagttacgtggtctcaggaaagagtgtggacatgtacattgaaagagcaggtgacatcacatgggaaaaagatgcggaagtcactggaaacagtccccggctcgatgtggcgctagatgagagtggtgatttctccctggtggaggatgacggtccccccatgagagagatcatactcaaggtggtcctgatgaccatctgtggcatgaacccaatagccataccctttgcagctggagcgtggtacgtatacgtgaagactggaaaaaggagtggtgctctatgggatgtgcctgctcccaaggaagtaaaaaagggggagaccacagatggagtgtacagagtaatgactcgtagactgctaggttcaacacaagttggagtgggagttatgcaagagggggtctttcacactatgtggcacgtcacaaaaggatccgcgctgagaagcggtgaagggagacttgatccatactggggagatgtcaagcaggatctggtgtcatactgtggtccatggaagctagatgccgcctgggacgggcacagcgaggtgcagctcttggccgtgccccccggagagagagcgaggaacatccagactctgcccggaatatttaagacaaaggatggggacattggagcggttgcgctggattacccagcaggaacttcaggatctccaatcctagacaagtgtgggagagtgataggactttatggcaatggggtcgtgatcaaaaatgggagttatgttagtgccatcacccaagggaggagggaggaagagactcctgttgagtgcttcgagccttcgatgctgaagaagaagcagctaactgtcttagacttgcatcctggagctgggaaaaccaggagagttcttcctgaaatagtccgtgaagctataaaaacaagactccgtactgtgatcttagctccaaccagggttgtcgctgctgaaatggaggaagcccttagagggcttccagtgcgttatatgacaacagcagtcaatgtcacccattctggaacagaaatcgtcgacttaatgtgccatgccaccttcacttcacgtctactacagccaatcagagtccccaactataatctgtatattatggatgaggcccacttcacagatccctcaagtatagcagcaagaggatacatttcaacaagggttgagatgggcgaggcggctgccatcttcatgaccgccacgccaccaggaacccgtgacgcatttccggactccaactcaccaattatggacaccgaagtggaagtcccagagagagcctggagctcaggctttgattgggtgacggatcattctggaaaaacagtttggtttgttccaagcgtgaggaacggcaatgagatcgcagcttgtctgacaaaggctggaaaacgggtcatacagctcagcagaaagacttttgagacagagttccagaaaacaaaacatcaagagtgggactttgtcgtgacaaccgacatttcagagatgggcgccaactttaaagctgaccgtgtcatagattccaggagatgcctaaagccggtcatacttgatggcgagagagtcattctggctggacccatgcctgtcacacatgccagcgctgcccagaggagggggcgcataggcaggaatcccaacaaacctggagatgagtatctgtatggaggtgggtgcgcagagactgacgaagaccatgcacactggcttgaagcaagaatgctccttgacaatatttacctccaagatggccttatagcctcgctctatcgacctgaggccgacaaagtagcagccattgagggagagttcaagcttaggacggagcaaaggaagacctttgtggaactcatgaaaagaggagatcttcctgtttggctggcctatcaggttgcatctgccggaataacttacacagatagaagatggtgctttgatggcacgaccaacaacaccataatggaagacagtgtgccggcagaggtgtggaccagacacggagagaaaagagtgctcaaaccgaggtggatggacgccagagtttgttcagatcatgcggccctgaagtcattcaaggagtttgccgctgggaaaagaggagcggcttttggagtgatggaagccctgggaacactgccaggacacatgacagagagattccaggaagccattgacaacctcgctgtgctcatgcgggcagagactggaagcaggccttacaaagccgcggcggcccaattgccggagaccctagagaccattatgcttttggggttgctgggaacagtctcgctgggaatctttttcgtcttgatgaggaacaagggcatagggaagatgggctttggaatggtgactcttggggccagcgcatggctcatgtggctctcggaaattgagccagccagaattgcatgtgtcctcattgttgtgttcctattgctggtggtgctcatacctgagccagaaaagcaaagatctccccaggacaaccaaatggcaatcatcatcatggtagcagtaggtcttctgggcttgatcaccgccaatgaactcggatggttggagagaacaaagagtgacctaagccatctaatgggaaggagagaggagggagcaaccataggattctcaatggacattgacctgcggccagcctcagcttgggccatctatgctgccttgacaactttcattaccccagccgtccaacatgcagtgaccacttcatacaacaactactccttaatggcgatggccacgcaagctggagtgttgtttggtatgggcaaagggatgccattctacgcatgggactttggagtcccgctgctaatgataggttgctactcacaattaacacccctgaccctaatagtggccatcattttgctcgtggcgcactacatgtacttgatcccagggctgcaggcagcagctgcgcgtgctgcccagaagagaacggcagctggcatcatgaagaaccctgttgtggatggaatagtggtgactgacattgacacaatgacaattgacccccaagtggagaaaaagatgggacaggtgctactcatagcagtagccgtctccagcgccatactgtcgcggaccgcctgggggtggggggaggctggggccctgatcacagccgcaacttccactttgtgggaaggctctccgaacaagtactggaactcctctacagccacttcactgtgtaacatttttaggggaagttacttggctggagcttctctaatctacacagtaacaagaaacgctggcttggtcaagagacgtgggggtggaacaggagagaccctgggagagaaatggaaggcccgcttgaaccagatgtcggccctggagttctactcctacaaaaagtcaggcatcaccgaggtgtgcagagaagaggcccgccgcgccctcaaggacggtgtggcaacgggaggccatgctgtgtcccgaggaagtgcaaagctgagatggttggtggagcggggatacctgcagccctatggaaaggtcattgatcttggatgtggcagagggggctggagttactacgccgccaccatccgcaaagttcaagaagtgaaaggatacacaaaaggaggccctggtcatgaagaacccgtgttggtgcaaagctatgggtggaacatagtccgtctcaagagtggggtggacgtctttcatatggcggctgagccgtgtgacacgttgctgtgtgacataggtgagtcatcatctagtcctgaagtggaagaagcacggacgctcagagtcctctccatggtgggggattggcttgaaaaaagaccaggagccttttgtataaaagtgttgtgcccatacaccagcactatgatggaaaccctggagcgactgcagcgtaggtatgggggaggactggtcagagtgccactctcccgcaactctacacatgagatgtactgggtctctggagcgaaaagcaacaccataaaaagtgtgtccaccacgagccagctcctcttggggcgcatggacgggcctaggaggccagtgaaatatgaggaggatgtgaatctcggctctggcacgcgggctgtggtaagctgcgctgaagctcccaacatgaagatcattggtaaccgcattgaaaggatccgcagtgagcacgcggaaacgtggttctttgacgagaaccacccatataggacatgggcttaccatggaagctatgaggcccccacacaagggtcagcatcctctctagtaaacggggttgtcaggctcctgtcaaaaccctgggatgtggtgactggagtcacaggaatagccatgaccgacaccacaccgtatggtcagcaaagagttttcaaggaaaaagtggacactagggtgccagacccccaagaaggcactcgtcaggttatgagcatggtctcttcctggttgtggaaagagctaggcaaacacaaacggccacgagtctgtaccaaagaagagttcatcaacaaggttcgtagcaatgcagcattaggggcaatatttgaagaggaaaaagagtggaagactgcagtggaagctgtgaacgatccaaggttctgggctctagtggacaaggaaagagagcaccacctgagaggagagtgccagagttgtgtgtacaacatgatgggaaaaagagaaaagaaacaaggggaatttggaaaggccaagggcagccgcgccatctggtatatgtggctaggggctagatttctagagttcgaagcccttggattcttgaacgaggatcactggatggggagagagaactcaggaggtggtgttgaagggctgggattacaaagactcggatatgtcctagaagagatgagtcgcataccaggaggaaggatgtatgcagatgacactgctggctgggatacccgcatcagcaggtttgatctagagaatgaagctctaatcaccaaccaaatggagaaagggcacagggccttggcattggccataatcaagtacacataccaaaacaaagtggtaaaggtccttagaccagctgaaaaagggaaaacagttatggacattatttcgagacaagaccaaagggggagcggacaagttgtcacttacgctcttaacacatttaccaacctagtggtgcaactcattcggaatatggaggctgaggaagttctagagatgcaagacttgtggctgctgcggaggtcagagaaagtgaccaactggttgcggagcaacggatgggataggctcaaacgaatggcagtcagtggagatgattgcgttgtgaagccaattgatgataggtttgcacatgccctcaggttcttgaatgatatgggaaaagttaggaaggacacacaagagtggaaaccctcaactggatgggacaactgggaagaagttccgttttgctcccaccacttcaacaagctccatctcaaggacgggaggtccattgtggttccctgccgccaccaagatgaactgattggccgggcccgcgtctctccaggggcgggatggagcatccgggagactgcttgcctagcaaaatcatatgcgcaaatgtggcagctcctttatttccacagaagggacctccgactgatggccaatgccatttgttcatctgtgccagttgactgggttccaactgggagaactacctggtcaatccatggaaagggagaatggatgaccactgaagacatgcttgtggtgtggaacagagtgtggattgaggagaacgaccacatggaagacaagaccccagttacgaaatggacagacattccctatttgggaaaaagggaagacttgtggtgtggatctctcatagggcacagaccgcgcaccacctgggctgagaacattaaaaacacagtcaacatggtgcgcaggatcataggtgaggaagaaaagtacatggactacctatccacccaagttcgctacttgggtgaagaagggtctacacctggagtgctgtaagcaccaatcttaatgttgtcaggcctgctagtcagccacagcttggggaaagctgtgcagcctgtgacccccccaggagaagctgggaaaccaagcctatagtcaggccgagaacgccatggcacggaagaagccatgctgcctgtgagcccctcagaggacactgagtcaaaaaaccccacgcgcttggaggcgcaggatgggaaaagaaggtggcgaccttccccacccttcaatctggggcctgaactggagatcagctgtggatccccagaagagg
+>EcEs062_16|zika|KX879603|2016-04-XX|south_america|ecuador|ecuador|ecuador|genbank|genome|Marquez et al|https://www.ncbi.nlm.nih.gov/nuccore/KX879603|First Complete Genome Sequences of Zika Virus Isolated from Febrile Patient Sera in Ecuador|Genome Announc 5 (8), e01673-16 (2017)|https://www.ncbi.nlm.nih.gov/pubmed/28232448
+agtagttgatctgtgtgaatcagactgcgacagttcgagtttgaagcgaaagctagcaacagtatcaacaggttttattttggatttggaaacgagagtttctggtcatgaaaaacccaaaaaagaaatccggaggattccggattgtcaatatgctaaaacgcggagtagcccgtgtgagcccctttgggggcttgaagaggctgccagccggacttctgctgggtcatgggcccatcaggatggtcttggcgattctagcctttttgagattcacggcaatcaagccatcactgggtctcatcaatagatggggttcagtggggaaaaaagaggctatggaaataataaagaagttcaagaaagatctggctgccatgctgagaataatcaatgctaggaaggagaagaagagacgaggcgcagatactagtgtcggaattgttggcctcctgctgaccacagctatggcagcggaggtcactagacgtgggagtgcatactatatgtacttggacagaaacgatgctggggaggccatatcttttccaaccacattggggatgaataagtgttatatacagatcatggatcttggacacatgtgtgatgccaccatgagctatgaatgccctatgctggatgagggggtggaaccagatgacgtcgattgttggtgcaacacgacgtcaacttgggttgtgtacggaacctgccatcacaaaaaaggtgaagcacggagatctagaagagctgtgacgctcccctcccattccactaggaagctgcaaacgcggtcgcaaacctggttggaatcaagagaatacacaaagcacttgattagagtcgaaaattggatattcaggaaccctggcttcgcgttagcagcagctgccatcgcttggcttttgggaagctcaacgagccaaaaagtcatatacttggtcatgatactgctgattgccccggcatacagcatcaggtgcataggagtcagcaatagggactttgtggaaggtatgtcaggtgggacttgggttgatgttgtcttggaacatggaggttgtgtcaccgtaatggcacaggacaaaccgactgtcgacatagagctggttacaacaacagtcagcaacatggcggaggtaagatcctactgctatgaggcatcaatatcagacatggcttcggacagccgctgcccaacacaaggtgaagcctaccttgacaagcaatcagacactcaatatgtctgcaaaagaacgttagtggacagaggctggggaaatggatgcggactttttggcaaagggagcctggtgacatgcgctaagtttgcatgctccaagaaaatgaccgggaagagcatccagccagagaatctggagtaccggataatgctgtcagttcatggctcccagcacagtgggatgatcgttaatgacacaggacatgaaactgatgagaatagagcgaaggttgagataacgcccaattcaccaagagccgaagccaccctggggggttttggaagcctaggacttgattgtgaaccgaggacaggccttgacttttcagatttgtattacttgactatgaataacaagcactggttggttcacaaggagtggttccacgacattccattaccttggcacgctggggcagacaccggaactccacactggaacaacaaagaagcactggtagagttcaaggacgcacatgccaaaaggcaaactgtcgtggttctagggagtcaagaaggagcagttcacacggcccttgctggagctctggaggctgagatggatggtgcaaagggaaggctgtcctctggccacttgaaatgtcgcctgaaaatggataaacttagactgaagggcgtgtcatactccttgtgtaccgcagcgttcacattcaccaagatcccggctgaaacactgcacgggacagtcacagtggaggtacagtacgcagggacagatggaccttgcaaggttccagctcagatggcggtggacatgcaaactctgaccccagttgggaggttgataaccgctaaccccgtaatcactgaaagcactgagaactctaagatgatgctggaacttgatccaccatttggggactcttacattgtcataggagtcggggagaagaagatcacccaccactggcacaggagtggcagcaccattggaaaagcatttgaagccactgtgagaggtgccaagagaatggcagtcttgggagacacagcctgggactttggatcagttggaggcgctctcaactcattgggcaagggcatccatcaaatttttggagcagctttcaaatcattgtttggaggaatgtcctggttctcacaaattctcattggaacgttgctgatgtggttgggtctgaacacaaagaatggatccatttcccttatgtgcttggccttagggggagtgttgatcttcttatccacagccgtctctgctgatgtggggtgctcggtggacttctcaaagaaggagacgagatgcggtacaggggtgttcgtctataacgacgttgaagcctggagggacaggtacaagtaccatcctgactccccccgtagattggcagcagcagtcaagcaagcctgggaagatggtatctgcgggatctcctctgtttcaagaatggaaaacatcatgtggagatcagtagaaggggagctcaacgcaatcctggaagagaatggagttcaactgacggtcgttgtgggatctgtaaagaaccccatgtggagaggtccacagagattgcccgtgcctgtgaacgagctgccccacggctggaaggcttgggggaaatcgtacttcgtcagagcagcaaagacaaataacagctttgtcgtggatggtgacacactgaaggaatgcccactcaaacatagagcatggaacagctttcttgtggaggatcatgggttcggggtatttcacactagtgtctggctcaaggttagagaagattattcattagagtgtgatccagccgttattggaacagctgttaagggaaaggaggctgtacacagtgatctaggctactggattgagagtgagaagaatgacacatggaggctgaagagggcccatctgatcgagatgaaaacatgtgaatggccaaagtcccacacattgtggacagatggaatagaagagagtgatctgatcatacccaagtctttagctgggccactcagccatcacaataccagagagggctacaggacccaaatgaaagggccatggcacagtgaagagcttgaaattcggtttgaggaatgcccaggcactaaggtccacgtggaggaaacatgtggaacaagaggaccatctctgagatcaaccactgcaagcggaagggtgatcgaggaatggtgctgcagggagtgcacaatgcccccactgtcgttccgggctaaagatggctgttggtatggaatggagataaggcccaggaaagaaccagaaagcaacttagtaaggtcagtggtgactgcaggatcaactgatcacatggatcacttctcccttggagtgcttgtgattctgctcatggtgcaggaagggctgaagaagagaatgaccacaaagatcatcataagcacatcaatggcagtgctggtagctatgatcctgggaggattttcaatgagtgacctggctaagcttgcaattttgatgggtgccaccttcgcggaaatgaacactggaggagatgtagctcatctggcgctgatagcggcattcaaggtcagaccagcgttgctggtatctttcatcttcagagctaattggacaccccgtgaaagcatgctgctggccttggcctcgtgtcttttgcaaactgcgatctccgccttggaaggcgacctgatggttctcatcaatggttttgctttggcctggttggcaatacgagcgatggttgttccacgcactgataacatcaccttggcaatcctggctgctctgacaccactggcccggggcacactgcttgtggcgtggagagcaggccttgctacttgcggggggtttatgctcctctctctgaagggaaaaggcagtgtgaagaagaacttaccatttgtcatggccctgggactaaccgctgtgaggctggtcgaccccatcaacgtggtgggactgctgttgctcacaaggagtgggaagcggagctggccccctagcgaagtactcacagctgttggcctgatatgcgcattggctggagggttcgccaaggcagatatagagatggctgggcccatggccgcggtcggtctgctaattgtcagttacgtggtctcaggaaagagtgtggacatgtacattgaaagagcaggtgacatcacatgggaaaaagatgcggaagtcactggaaacagtccccggctcgatgtggcgctagatgagagtggtgatttctccctggtggaggatgacggtccccccatgagagagatcatactcaaggtggtcctgatgaccatctgtggcatgaacccaatagccataccctttgcagctggagcgtggtacgtatacgtgaagactggaaaaaggagtggtgctctatgggatgtgcctgctcccaaggaagtaaaaaagggggagaccacagatggagtgtacagagtaatgactcgtagactgctaggttcaacacaagttggagtgggagttatgcaagagggggtctttcacactatgtggcacgtcacaaaaggatccgcgctgagaagcggtgaagggagacttgatccatactggggagatgtcaagcaggatctggtgtcatactgtggtccatggaagctagatgccgcctgggacgggcacagcgaggtgcagctcttggccgtgccccccggagagagagcgaggaacatccagactctgcccggaatatttaagacaaaggatggggacattggagctgttgcgctggattacccagcaggaacttcaggatctccaatcctagacaagtgtgggagagtgataggactttatggcaatggggtcgtgatcaaaaatgggagttatgttagtgccatcacccaagggaggagggaggaagagactcctgttgagtgcttcgagccttcgatgctgaagaagaagcagctaactgtcttagacttgcatcctggagctgggaaaaccaggagagttcttcctgaaatagtccgtgaagccataaaaacaagactccgtactgtgatcttagctccaaccagggttgtcgctgctgaaatggaggaagcccttagagggcttccagtgcgttatatgacaacagcagtcaatgtcacccactctggaacagaaatcgtcgacttaatgtgccatgccaccttcacttcacgtctactacagccaatcagagtccccaactataatctgtatattatggatgaggcccacttcacagatccctcaagtatagcagcaagaggatacatttcaacaagggttgagatgggcgaggcggctgctatcttcatgaccgccacgccaccaggaacccgtgacgcatttccggactccaactcaccaattatggacaccgaagtggaagtcccagagagagcctggagctcaggctttgattgggtgacggatcattctggaaaaacagtttggtttgttccaagcgtgaggaacggcaatgagatcgcagcttgtctgacaaaggctggaaaacgggtcatacaactcagcagaaagacttttgagacagagttccagaaaacaaaacatcaagagtgggactttgtcgtgacaactgacatttcagagatgggcgccaactttaaagctgaccgtgtcatagattccaggagatgcctaaagccggtcatacttgatggcgagagagtcattctggctggacccatgcctgtcacacatgccagcgctgcccagaggagggggcgcataggcaggaatcccaacaaacctggagatgagtatctgtatggaggtgggtgcgcagagactgacgaagaccatgcacactggcttgaagcaagaatgctccttgacaatatttacctccaagatggcctcatagcctcgctctatcgacctgaggccgacaaagtagcagccattgagggagagttcaagcttaggacggagcaaaggaagacctttgtggaactcatgaaaagaggagatcttcctgtttggctggcctatcaggttgcatctgccggaataacctacacagatagaagatggtgctttgatggcacgaccaacaacaccataatggaagacagtgtgccggcagaggtgtggaccagacacggagagaaaagagtgctcaaaccgaggtggatggacgccagagtttgttcagatcatgcggccctgaagtcattcaaggagtttgccgctgggaaaagaggagccgcttttggagtgatggaagccctgggaacactgccaggacacatgacagagagattccaggaagccattgacaacctcgctgtgctcatgcgggcagagactggaagcaggccttacaaagccgcggcggcccaattgccggagaccctagagaccattatgcttttggggttgctgggaacagtctcgctgggaatctttttcgtcttgatgaggaacaagggcatagggaagatgggctttggaatggtgactcttggggccagcgcatggctcatgtggctctcggaaattgagccagccagaattgcatgtgtcctcattgttgtgttcctattgctggtggtgctcatacctgagccagaaaagcaaagatctccccaggacaaccaaatggcaatcatcatcatggtagcagtgggtcttctgggcttgattaccgccaatgaactcggatggttggagagaacaaagagtgacctaagccatctaatgggaaggagagaggagggagcaaccataggattctcaatggacattgacctgcggccagcctcagcttgggccatctatgctgccttgacaactttcattaccccagccgtccaacatgcagtgaccacttcatacaacaactactccttaatggcgatggccacgcaagctggagtgttgtttggtatgggcaaagggatgccattctacgcatgggactttggagtcccgctgctaatgataggttgctactcacaattaacacccctgaccctaatagtggccatcattttgctcgtggcgcactacatgtacttgatcccagggctgcaggcagcagctgcgcgtgctgcccagaagagaacggcagctggcatcatgaagaaccctgttgtggatggaatagtggtgactgacattgacacaatgacaattgacccccaagtggagaaaaagatgggacaggtgctactcatagcagtagccgtctccagcgccatactgtcgcggaccgcctgggggtggggggaggctggggccctgatcacagccgcaacttccactttgtgggaaggctctccgaacaagtactggaactcctctacagccacttcactgtgtaacatttttaggggaagttacttggctggagcttctctaatctacacagtaacaagaaacgctggcttggtcaagagacgtgggggtggaacaggagagaccctgggagagaaatggaaggcccgcttgaaccagatgtcggccctggagttctactcctacaaaaagtcaggcatcaccgaggtgtgcagagaagaggcccgccgcgccctcaaggacggtgtggcaacgggaggccatgctgtgtcccgaggaagtgcaaagctgagatggttggtggagcggggatacctgcagccctatggaaaggtcattgatcttggatgtggcagagggggctggagttactacgccgccaccatccgcaaagttcaagaagtgaaaggatacacaaaaggaggccctggtcatgaagaacccgtgttggtgcaaagctatgggtggaacatagtccgtcttaagagtggggtggacgtctttcatatggcggctgagccgtgtgacacgttgctgtgtgacataggtgagtcatcatctagtcctgaagtggaagaagcacggacgctcagagtcctctccatggtgggggattggcttgaaaaaagaccaggagccttttgtataaaagtgttgtgcccatacaccagcactatgatggaaacactggagcgactgcagcgtaggtatgggggaggactggtcagagtgccactctcccgcaactctacacatgagatgtactgggtctctggagcgaaaagcaacaccataaaaagtgtgtccaccacgagccagctcctcttggggcgcatggacgggcctaggaggccagtgaaatatgaggaggatgtgaatctcggctctggcacgcgggctgtggtaagctgcgctgaagctcccaacatgaagatcattggtaaccgcattgaaaggatccgcagtgagcacgcggaaacgtggttctttgacgagaaccacccatacaggacatgggcttaccatggaagctatgaggcccccacacaagggtcagcgtcctctctaataaacggggttgtcaggctcctgtcaaaaccctgggatgtggtgactggagtcacaggaatagccatgaccgacaccacaccgtatggtcagcaaagagttttcaaggaaaaagtggacactagggtgccagacccccaagaaggcactcgtcaggttatgagcatggtctcttcctggttgtggaaagagctaggcaaacacaaacggccacgagtctgtaccaaagaagagtttatcaacaaggttcgtagcaatgcagcattaggggcaatatttgaagaggaaaaagagtggaagactgcagtggaagctgtgaacgatccaaggttctgggctctagtggacaaggaaagagagcaccacctgagaggagagtgccagagttgtgtgtacaacatgatgggaaaaagagaaaagaaacaaggggaatttggaaaggccaagggcagccgcgccatctggtatatgtggctaggggctagatttctagagttcgaagcccttggattcttgaacgaggatcactggatggggagagagaactcaggaggtggtgttgaagggctgggattacaaagactcggatatgtcctagaagagatgagtcgcataccaggaggaaggatgtatgcagatgacactgctggctgggacacccgcatcagcaggtttgatctggagaatgaagctctaatcaccaaccaaatggagaaagggcacagggccttggcattggccataatcaagtacacataccaaaacaaagtggtaaaggtccttagaccagctgaaaaagggaaaacggttatggacattatttcgagacaagaccaaagggggagcggacaagttgtcacttacgctcttaacacatttaccaacctagtggtgcaactcattcggaatatggaggctgaggaagttctagagatgcaagacttgtggctgctgcggaggtcagagaaagtgaccaactggttgcagagcaacggatgggataggctcaaacgaatggcagtcagtggagatgattgcgttgtgaagccaattgatgataggtttgcacatgccctcaggttcttgaatgatatgggaaaagttaggaaggacacacaagagtggaaaccctcaactggatgggacaactgggaagaagttccgttttgctcccaccacttcaacaagctccatctcaaggacgggaggtccattgtggttccctgccgccaccaagatgaactgattggccgggcccgcgtctctccaggggcgggatggagcatccgggagactgcttgcctagcaaaatcatatgctcaaatgtggcagctcctttatttccacagaagggacctccgactgatggccaatgccatttgttcatctgtgccagttgactgggttccaactgggagaactacctggtcaatccatggaaagggagaatggatgaccactgaagacatgcttgtggtgtggaatagagtgtggattgaggagaacgaccacatggaagacaagaccccagttacgaaatggacagacattccctatttgggaaaaagggaagacttgtggtgtggatctctcatagggcacagaccgcgcaccacctgggctgagaacattaaaaacacagtcaacatggtgcgcaggatcataggtgatgaagaaaagtacatggactacctatccacccaagttcgctacttgggtgaagaagggtctacgcctggagtgctgtaagcaccaatcctaatgttgtcaggcctgctagtcagccacagcttggggaaagctgtgcagcctgtgacccccccaggagaagctgggaaaccaagcctatagtcaggccgagaacgccatggcacggaagaagccatgctgcctgtgagcccctcagaggacactgagtcaaaaaaccccacgcgcttggaggcgcaggatgggaaaagaaggtggcgaccttccccacccttcaatctggggcctgaactggagatcagctgtggatctccagaagagggactagtggttagaggagaccccccggaaaacgcaaaacagcatattgacgctgggaaagaccagagactccatgagtttccaccacgctggccgccaggcacagatcgccgaatagcggcggccggtgtggggaaatccatgggagatcgga
+>HND/2016/HU_ME59|zika|KY785418|2016-05-13|north_america|honduras|honduras|honduras|genbank|genome|Metsky et al|https://www.ncbi.nlm.nih.gov/nuccore/KY785418|Zika virus evolution and spread in the Americas|Nature 546 (7658), 411-415 (2017)|https://www.ncbi.nlm.nih.gov/pubmed/28538734
+gtttgaagcgaaagctagcaacagtatcaacaggttttattttggatttggaaacgagagtttctggtcatgaaaaacccaaaaaagaaatccggaggattccggattgtcaatatgctaaaacgcggagtagcccgtgtgagcccctttgggggcttgaagaggctgccagccggacttctgctgggtcatgggcccatcaggatggtcttggcgattctagcctttttgagattcacggcaatcaagccatcactgggtctcatcaatagatggggttcagtggggaaaaaagaggctatggaaataataaagaagttcaagaaagatctggctgccatgctgagaataatcaatgctaggaaggagaagaagagacgaggcgcagatactagtgtcggaattgttggcctcctgctgaccacagctatggcagcggaggtcactagacgtgggagtgcatactatatgtacttggacagaaacgatgctggggaggccatatcttttccaaccacattggggatgaataagtgttatatacagatcatggatcttggacacatgtgtgatgccaccatgagctatgaatgccctatgctggatgagggggtggaaccagatgacgtcgattgttggtgcaacacgacgtcaacttgggttgtgtacggaacctgccatcacaaaaaaggtgaagcacggagatctagaagagctgtgacgctcccctcccattccactaggaagctgcaaacgcggtcgcaaacctggttggaatcaagagaatacacaaagcacttgattagagtcgaaaattggatattcaggaaccctggcttcgcgttagcagcagctgccatcgcttggcttttgggaagctcaacgagccaaaaagtcatatacttggtcatgatactgctgattgccccggcatacagcatcaggtgcataggagtcagcaatagggactttgtggaaggtatgtcaggtgggacttgggttgatgttgtcttggaacatggaggttgtgtcaccgtaatggcacaggacaaaccgactgtcgacatagagctggttacaacaacagtcagcaacatggcggaggtaagatcctactgctatgaggcatcaatatcagacatggcttcggacagccgctgcccaacacaaggtgaagcctaccttgacaagcaatcagacactcaataygtctgcaaaagaacgttagtggacagaggctggggaaatggatgtggactttttggcaaagggagcctggtgacatgcgctaagtttgcatgctccaagaaaatgaccgggaagagcatccagccagagaatctggagtaccggataatgctgtcagttcatggctcccagcacagtgggatgatcgttaatgacacaggacatgaaactgatgagaatagagcgaaggttgagataacgcccawttcaccaagagccgaagccaccctggggggttttggaagcctaggacttgattgtgaaccgaggacaggccttgacttttcagatttgtattacttgactatgaataacaagcactggttggttcacaaggagtggttccacgacattccattaccttggcacgctggggcagacaccggaactccacactggaacaacaaagaagcactggtagagttcaaggacgcacatgccaaaaggcaaactgtcgtggttctagggagtcaagaaggagcagttcacacggcccttgctggagctctggaggctgagatggatggtgcaaagggaaggctgtcctctggccacttgaaatgtcgcctgaaaatggataaacttagattgaagggcgtgtcatactccttgtgtaccgcagcgttcacattcaccaagatcccggctgaaacactgcacgggacagtcacagtggaggtacagtacgcagggacagatggaccttgcaaggttccagctcagatggcggtggacatgcaaactctgaccccagttgggaggttgataaccgctaaccccgtaatcactgaaagcactgagaactctaagatgatgctggaacttgatccaccatttggggactcttacattgtcataggagtcggggagaagaagatcacccaccactggcacaggagtggcagcaccattggaaaagcatttgaagccactgtgagaggtgccaagagaatggcagtcttgggagacacagcctgggactttggatcagttggaggcgctctcaactcattgggcaagggcatccatcaaatttttggagcagctttcaaatcattgtttggaggaatgtcctggttctcacaaattctcattggaacgttgctgatgtggttgggtctgaacacaaagaatggatctatttcccttatgtgcttggccttagggggagtgttgatcttcttatccacagccgtctctgctgatgtggggtgctcggtggacttctcaaagaaggagacgagatgcggtacaggggtgttcgtctataacgacgttgaagcctggagggacaggtacaagtaccatcctgactccccccgtagattggcagcagcagtcaagcaagcctgggaagatggtatctgcgggatctcctctgtttcaagaatggaaaacatcatgtggagatcagtagaaggggagctcaacgcaatcctggaagagaatggagttcaactgacggtcgttgtgggatctgtaaaaaaccccatgtggagagctccacagagattgcccgtgcctgtgaacgagctgccccacggctggaaggcttgggggaaatcgtacttcgtcagagcagcaaagacaaataacagctttgtcgtggatggtgacacactgaaggaatgcccactcaaacatagagcatggaacagctttcttgtggaggatcatgggttcggggtatttcacactagtgtctggctcaaggttagagaagattattcattagagtgtgatccagccgttattggaacagctgttaagggaaaggaggctgtacacagtgatctaggctactggattgagagtgagaagaatgacacatggaggctgaagagggcccatctgatcgagatgaaaacatgtgaatggccaaagtcccacacattgtggacagatggaatagaagagagtgatctgatcatacccaagtctttagctgggccactcagccatcacaataccagagagggctacaggacccaaatgaaagggccatggcacagtgaagagcttgaaattcggtttgaggaatgcccaggcactaaggtccacgtggaggaaacatgtggaacaagaggaccatctctgagatcaaccactgcaagcggaagggtgatcgaggaatggtgctgcagggagtgcacaatgcccccactgtcgttccgggctaaagatggctgttggtatggaatggagataaggcccaggaaagaaccagaaagcaacttagtaaggtcaatggtgactgcaggatcaactgatcacatggatcacttctcccttggagtgcttgtgattctgctcatggtgcaggaagggctaaagaagagaatgaccacaaagatcatcataagcacatcaatggcagtgctggtagctatgatcctgggaggattttcaatgagtgacctggctaagcttgcaattttgatgggtgccaccttcgcggaaatgaacactggaggagatgtagctcatctggcgctgatagcggcattcaaagtcagaccagcgttgctggtatctttcatcttcagagctaattggacaccccgtgaaagcatgctactggccttggcctcgtgtcttttgcaaactgcgatctccgccttggaaggcgacctgatggttctcatcaatggttttgctttggcctggttggcaatacgagcgatggttgttccacgcactgataacatcaccttggcaatcctggctgctctgacaccactggcccggggcacactgcttgtggcgtggagagcaggccttgctacttgcggggggtttatgctcctctctctgaagggaaaaggcagtgtgaagaagaacttaccatttgtcatggccctgggactaaccgctgtgaggctggtcgaccccatcaacgtggtgggactgctgttgctcacaaggagtgggaagcggagctggccccctagcgaagtactcacagctgttggcctgatatgcgcattggctggagggttcgccaaggcagatatagagatggctgggcccatggccgcggtcggtctgctaattgtcagttacgtggtctcaggaaagagtgtggacatgtacattgaaagagcaggtgacatcacatgggaaaaagatgcggaagtcactggaaacagtccccggctcgatgtggcgctagatgagagtggtgatttctccctggtggaggatgacggtccccccatgagagagatcatactcaaggtggtcctgatgaccatctgtggcatgaacccaatagccataccctttgcagctggagcgtggtacgtatacgtgaagactggaaaaaggagtggtgctctatgggatgtgcctgctcccaaggaagtaaaaaagggggagaccacagatggagtgtacagagtaatgactcgtagactgctaggttcaacacaagttggagtgggagtcatgcaagagggggtctttcacactatgtggcacgtcacaaaaggatccgcactgagaagcggtgaagggagacttgatccatactggggagatgtcaagcaggatctggtgtcatactgtggtccatggaagctagatgccgcctgggacgggcacagcgaggtgcagctcctggccgtgccccccggagagagagcgaggaacatccagactctgcccggaatatttaagacaaaggatggggacattggagcggttgcgctggattacccagcaggaacttcaggatctccaatcctagacaagtgtgggagagtgataggactttatggcaatggggtcgtgatcaaaaatgggagttatgttagtgccatcacccaagggaggagggaggaagagactcctgttgagtgcttcgagccttcgatgctgaagaagaagcagctaactgtcttagacttacatcctggagctgggaaaaccaggagagttcttcctgaaatagtccgtgaagccataaaaacaagactccgtactgtgatcttagctccaaccagggttgtcgctgctgaaatggaggaggcccttagagggcttccagtgcgttatatgacaacagcagtcaatgtcacccactctggaacagaaatcgtcgacttaatgtgccatgccaccttcacttcacgtctactacagccaatcagagtccccaactataatctgtatattatggatgaggcccacttcacagatccctcaagtatagcagcaagaggatacatttcaacaagggttgagatgggcgaggcggctgccatcttcatgaccgccacgccaccaggaacccgtgacgcatttccggactccaactcaccaattatggacaccgaagtggaagtcccagagagagcctggagctcaggctttgattgggtgacggatcattctggaaaaacagtttggtttgttccaagcgtgaggaacggcaatgagatcgcagcttgtctgacaaaggctggaaaacgggtcatacagctcagcagaaagacttttgagacagagttccagaaaacaaaacatcaagagtgggactttgtcgtgacaactgacatttcagagatgggcgccaactttaaagctgaccgtgtcatagattccaggagrtgcctaaagccggtcatacttgatggcgagagagtcattctggctggacccatgcctgtcacacatgccagcgctgcccagaggagggggcgcataggcaggaatcccaacaaacctggagatgagtatctgtatggaggtgggtgcgcagagactgacgaagaccatgcacactggcttgaagcaagaatgctccttgacaatatttacctccaagatggcctcatagcctcgctctatcgacctgaggccgacaaagtagcagccattgagggagagttcaagcttaggacggagcaaaggaagacctttgtggaactcatgaaaagaggagatcttcctgtttggctggcctatcaggttgcatctgccggaataacctacacagatagaagatggtgctttgatggcacgaccaacaacaccatactggaagacagtgtgccggcagaggtgtggaccagacacggagagaaaagagtgctcaaaccgaggtggatggacgccagagtttgttcagatcatgcggccctgaagtcattcaaggagtttgccgctgggaaaagaggagcggcttttggagtgatggaagccctgggaacactgccaggacacatgacagagagattccaggaagccattgacaacctcgctgtgctcatgcgggcagagactggaagcaggccttacaaagccgcggcggcccaattgccggagaccctagagaccattatgcttttggggttgctgggaacagtctcgctgggaatctttttcgtcttgatgaggaacaagggcatagggaagatgggctttggaatggtgacccttggggccagtgcatggctcatgtggctctcggaaattgagccagccagaattgcatgtgtcctcattgttgtgttcctattgctggtggtgctcatacctgagccagaaaagcaaagatctccccaggacaaccaaatggcaatcatcatcatggtagcagtaggtcttctgggcttgattaccgccaatgaactcggatggttggagagaacaaagagtgacctaagccatctgatgggaaggagagaggagggggcaaccataggattctcaatggacattgacctgcggccagcctcagcttgggccatctatgctgccttgacaactttcattaccccagccgtccaacatgcagtgaccacttcatacaacaactactccttaatggcgatggccacgcaagctggagtgttgtttggtatgggcaaagggatgccattctacgcatgggactttggagtcccgctgctaatgataggttgctactcacaattaacacccctgaccctaatagtggccatcattttgctcgtggcgcactacatgtacttgatcccagggctgcaggcagcagctgcgcgtgctgcccagaagagaacggcagctggcatcatgaagaaccctgttgtggatggaatagtggtgactgacattgacacaatgacaattgacccccaagtggagaaaaagatgggacaggtgctactcatagcagtagccgtctccagcgccatactgtcgcggaccgcctgggggtggggggaggctggggccctgatcacagccgcaacttccactttgtgggaaggctctccgaacaagtactggaactcctctacagccacttcactgtgtaacatttttaggggaagttacttggctggagcttctctaatctacacagtaacaagaaacgctggcttggtcaagagacgtgggggtggaacaggagagaccctgggagagaaatggaaggcccgcttgaaccagatgtcggccctggagttctactcctacaaaaagtcaggcatcaccgaggtgtgcagagaagaggcccgccgcgccctcaaggacggtgtggcaacgggaggccatgctgtgtcccgaggaagtgcaaagctgagatggttggtggagcggggatacctgcagccctatggaaaggtcattgatcttggatgtggcagagggggctggagttactacgccgccaccatccgcaaagttcaagaagtgaaaggatacacaaaaggaggccctggtcatgaagaacccgtgttggtgcaaagctatgggtggaacatagtccgtcttaagagtggggtggacgtctttcatatggcggctgagccgtgtgacacgttgctgtgtgacataggtgagtcatcatctagtcctgaagtggaagaagcacggacgctcagagtcctctccatggtgggggattggcttgaaaaaagaccaggagccttttgtataaaagtgttgtgcccatacaccagcactatgatggaaaccctggagcgactgcagcgtaggtatgggggaggactggtcagagtgccactctcccgcaactctacacatgagatgtactgggtctctggagcgaaaagcaacaccataaaaagtgtgtccaccacgagccagctcctcttggggcgcatggacgggcctaggaggccagtgaaatatgaggaggatgtgaatctcggctctggcacgcgggctgtggtaagctgcgctgaagctcccaacatgaagatcattggtaaccgcattgaaaggatccgcagtgagcacgcggaaacgtggttctttgacgagaaccacccatataggacatgggcttaccatggaagctatgaggcccccacacaagggtcagcgtcctctctaataaacggggttgtcaggctcctgtcaaaaccctgggatgtggtgactggagtcacaggaatagccatgaccgacaccacaccgtatggtcagcaaagagttttcaaggaaaaagtggacactagggtgccagacccccaagaaggcactcgtcaggttatgagcatggtctcttcctggttgtggaaagagctaggcaaacacaaacggccacgagtctgtaccaaagaagagttcatcaacaaggttcgtagcaatgcagcattaggggcaatatttgaagaggaaaaagagtggaagactgcagtggaagctgtgaacgatccaaggttctgggctctagtggacaaggaaagagagcaccacctgagaggagagtgccagagttgtgtgtacaacatgatgggaaaaagagaaaagaaacaaggggaatttggaaaggccaagggcagccgcgccatctggtatatgtggctaggggctagatttctagagttcgaagcccttggattcttgaacgaggatcactggatggggagagagaactcaggaggtggtgttgaagggctgggattacaaagactcggatatgtcctagaagagatgagttgcataccaggaggaaggatgtatgcagatgacactgctggctgggacacccgcatcagcaggtttgatctggagaatgaagctctaatcaccaaccaaatggagaaagggcacagggccttggcattggccataatcaagtacacataccaaaacaaagtggtaaaggtccttagaccagctgaaaaagggaaaacagttatggacattatttcgagacaagaccaaagggggagcggacaagttgtcacttacgctcttaacacatttaccaacctagtggtgcaactcatccggaatatggaggctgaggaagttctagagatgcaagacttgtggctgctgcggaggtcagagaaagtgaccaactggttgcagagcaacggatgggataggctcaaacgaatggcagtcagtggagatgattgcgttgtgaagccaattgatgataggtttgcacatgccctcaggttcttgaatgatatgggaaaagttaggaaggacacacaagagtggaaaccctcaactggatgggacaactgggaagaagttccgttttgctcccaccacttcaacaagctccatctcaaggacgggaggtccattgtggttccctgccgccaccaagatgaactgattggccgggcccgcgtctctccaggggcgggatggagcatccgggagactgcttgcctagcaaaatcatatgcgcaaatgtggcagctcctttatttccacagaagggacctccgactgatggccaatgccatttgttcatctgtgccagttgactgggttccaactgggagaactacctggtcaatccatggaaagggagaatggatgaccactgaagacatgcttgtggtgtggaacagagtgtggattgaggagaacgaccacatggaagacaagaccccagttacgaaatggacagacattccctatttgggaaaaagggaagacttgtggtgtggatctctcatagggcacagaccgcgcaccacctgggctgagaacattaaaaacacagtcaacatggtgcgcaggatcataggtgatgaagaaaagtacatggactacctatccacccaagttcgctacttgggtgaagaagggtctacacctggagtgctgtaagcaccaatcttaatgttgtcaggc
diff --git a/tests/functional/parse/zika.fasta.gz b/tests/functional/parse/zika.fasta.gz
new file mode 100644
index 000000000..4478e81df
Binary files /dev/null and b/tests/functional/parse/zika.fasta.gz differ
diff --git a/tests/test_io.py b/tests/test_io.py
new file mode 100644
index 000000000..d65fa5f1e
--- /dev/null
+++ b/tests/test_io.py
@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+from Bio import SeqIO
+from Bio.Seq import Seq
+from Bio.SeqRecord import SeqRecord
+import bz2
+import gzip
+import lzma
+from pathlib import Path
+import pytest
+import random
+import sys
+
+from augur.io import open_file, read_sequences, write_sequences
+
+
+def random_seq(k):
+    """Generate a single random sequence of nucleotides of length k.
+    """
+    return "".join(random.choices(("A","T","G","C"), k=k))
+
+def generate_sequences(n, k=10):
+    """Generate n random sequences of length k.
+    """
+    return (
+        SeqRecord(Seq(random_seq(k)), id=f"SEQ_{i}")
+        for i in range(1, n + 1)
+    )
+
+@pytest.fixture
+def sequences():
+    return list(generate_sequences(3))
+
+@pytest.fixture
+def sequences_generator():
+    return generate_sequences(3)
+
+@pytest.fixture
+def fasta_filename(tmpdir, sequences):
+    filename = str(tmpdir / "sequences.fasta")
+    SeqIO.write(sequences, filename, "fasta")
+    return filename
+
+@pytest.fixture
+def additional_fasta_filename(tmpdir, sequences):
+    filename = str(tmpdir / "additional_sequences.fasta")
+    SeqIO.write(sequences, filename, "fasta")
+    return filename
+
+@pytest.fixture
+def gzip_fasta_filename(tmpdir, sequences):
+    filename = str(tmpdir / "sequences.fasta.gz")
+
+    with gzip.open(filename, "wt") as oh:
+        SeqIO.write(sequences, oh, "fasta")
+
+    return filename
+
+@pytest.fixture
+def bzip2_fasta_filename(tmpdir, sequences):
+    filename = str(tmpdir / "sequences.fasta.bz2")
+
+    with bz2.open(filename, "wt") as oh:
+        SeqIO.write(sequences, oh, "fasta")
+
+    return filename
+
+@pytest.fixture
+def lzma_fasta_filename(tmpdir, sequences):
+    filename = str(tmpdir / "sequences.fasta.xz")
+
+    with lzma.open(filename, "wt") as oh:
+        SeqIO.write(sequences, oh, "fasta")
+
+    return filename
+
+@pytest.fixture
+def genbank_reference():
+    return "tests/builds/zika/config/zika_outgroup.gb"
+
+
+class TestReadSequences:
+    def test_read_sequences_from_single_file(self, fasta_filename):
+        sequences = read_sequences(fasta_filename, format="fasta")
+        assert len(list(sequences)) == 3
+
+    def test_read_sequences_from_multiple_files(self, fasta_filename, additional_fasta_filename):
+        sequences = read_sequences(fasta_filename, additional_fasta_filename, format="fasta")
+        assert len(list(sequences)) == 6
+
+    def test_read_sequences_from_multiple_files_or_buffers(self, fasta_filename, additional_fasta_filename):
+        with open(fasta_filename) as fasta_handle:
+            sequences = read_sequences(fasta_handle, additional_fasta_filename, format="fasta")
+            assert len(list(sequences)) == 6
+
+    def test_read_single_fasta_record(self, fasta_filename):
+        record = next(read_sequences(fasta_filename, format="fasta"))
+        assert record.id == "SEQ_1"
+
+    def test_read_single_genbank_record(self, genbank_reference):
+        reference = next(read_sequences(genbank_reference, format="genbank"))
+        assert reference.id == "KX369547.1"
+
+    def test_read_single_genbank_record_from_a_path(self, genbank_reference):
+        reference = next(read_sequences(Path(genbank_reference), format="genbank"))
+        assert reference.id == "KX369547.1"
+
+    def test_read_sequences_from_single_gzip_file(self, gzip_fasta_filename):
+        sequences = read_sequences(gzip_fasta_filename, format="fasta")
+        assert len(list(sequences)) == 3
+
+    def test_read_sequences_from_single_lzma_file(self, lzma_fasta_filename):
+        sequences = read_sequences(lzma_fasta_filename, format="fasta")
+        assert len(list(sequences)) == 3
+
+    def test_read_sequences_from_single_bzip2_file(self, bzip2_fasta_filename):
+        sequences = read_sequences(bzip2_fasta_filename, format="fasta")
+        assert len(list(sequences)) == 3
+
+    def test_read_sequences_from_multiple_files_with_different_compression(self, fasta_filename, gzip_fasta_filename, lzma_fasta_filename):
+        sequences = read_sequences(fasta_filename, gzip_fasta_filename, lzma_fasta_filename, format="fasta")
+        assert len(list(sequences)) == 9
+
+
+class TestWriteSequences:
+    def test_write_sequences(self, tmpdir, sequences):
+        output_filename = Path(tmpdir) / Path("new_sequences.fasta")
+        sequences_written = write_sequences(sequences, output_filename, "fasta")
+        assert sequences_written == len(sequences)
+
+    def test_write_genbank_sequence(self, tmpdir, genbank_reference):
+        output_filename = Path(tmpdir) / Path("new_sequences.fasta")
+
+        reference = SeqIO.read(genbank_reference, "genbank")
+        sequences_written = write_sequences([reference], output_filename, "genbank")
+        assert sequences_written == 1
+
+    def test_write_sequences_from_generator(self, tmpdir, sequences_generator):
+        output_filename = Path(tmpdir) / Path("new_sequences.fasta")
+        sequences_written = write_sequences(sequences_generator, output_filename, "fasta")
+        assert sequences_written == 3
+
+    def test_write_single_set_of_sequences_to_gzip_file(self, tmpdir, sequences):
+        output_filename = Path(tmpdir) / Path("new_sequences.fasta.gz")
+        sequences_written = write_sequences(sequences, output_filename, "fasta")
+        assert sequences_written == len(sequences)
+
+        with gzip.open(output_filename, "rt") as handle:
+            assert sequences_written == len([line for line in handle if line.startswith(">")])
+
+    def test_write_single_set_of_sequences_to_bzip2_file(self, tmpdir, sequences):
+        output_filename = Path(tmpdir) / Path("new_sequences.fasta.bz2")
+        sequences_written = write_sequences(sequences, output_filename, "fasta")
+        assert sequences_written == len(sequences)
+
+        with bz2.open(output_filename, "rt") as handle:
+            assert sequences_written == len([line for line in handle if line.startswith(">")])
+
+    def test_write_single_set_of_sequences_to_lzma_file(self, tmpdir, sequences):
+        output_filename = Path(tmpdir) / Path("new_sequences.fasta.xz")
+        sequences_written = write_sequences(sequences, output_filename, "fasta")
+        assert sequences_written == len(sequences)
+
+        with lzma.open(output_filename, "rt") as handle:
+            assert sequences_written == len([line for line in handle if line.startswith(">")])
+
+    def test_write_sequences_by_external_handle(self, tmpdir, sequences):
+        output_filename = Path(tmpdir) / Path("new_sequences.fasta")
+
+        with open_file(output_filename, "w") as handle:
+            total_sequences_written = 0
+            for sequence in sequences:
+                sequences_written = write_sequences(
+                    sequence,
+                    handle
+                )
+                total_sequences_written += sequences_written
+
+        with open(output_filename, "r") as handle:
+            assert total_sequences_written == len([line for line in handle if line.startswith(">")])
diff --git a/tests/test_parse.py b/tests/test_parse.py
index 570dfbed4..80c1451e9 100644
--- a/tests/test_parse.py
+++ b/tests/test_parse.py
@@ -1,3 +1,5 @@
+import Bio.SeqIO
+import Bio.Seq
 import pytest
 from pathlib import Path
 import unittest
@@ -8,7 +10,7 @@
 from augur import parse
 
 
-class TestParse: 
+class TestParse:
     def test_fix_dates(self):
         full_date = "4-5-2020"
         assert parse.fix_dates(full_date) == "2020-05-04"
@@ -49,5 +51,24 @@ def test_prettify(self):
         # test etal
         etal_lower_string = "testing string Et Al Et al"
         etal_strip_string = "nextstrain et al. et al Et Al."
-        assert parse.prettify(etal_lower_string, etal='lower') == etal_lower_string.lower() 
+        assert parse.prettify(etal_lower_string, etal='lower') == etal_lower_string.lower()
         assert parse.prettify(etal_strip_string, etal='strip') == "nextstrain   "
+
+    def test_parse_sequence(self):
+        sequence_record = Bio.SeqRecord.SeqRecord(
+            seq=Bio.Seq.Seq("ATCG"),
+            id="sequence_A",
+            description="sequence_A|USA|2020-10-03|north_america"
+        )
+        fields = ["strain", "country", "date", "region"]
+        sequence, metadata = parse.parse_sequence(
+            sequence_record,
+            fields=fields,
+            strain_key="strain",
+            prettify_fields=["region"]
+        )
+
+        assert sequence.id == metadata["strain"]
+        assert sequence.id == "sequence_A"
+        assert set(fields) == set(metadata.keys())
+        assert metadata["region"] == "North America"