# HG changeset patch # User devteam # Date 1417715922 18000 # Node ID 2a6cfe8997aa9f515ad0eabd59138e707dae0d21 # Parent aceaf1d94d2db9f19d948b50a59b4d2d88696418 Uploaded from GH diff -r aceaf1d94d2d -r 2a6cfe8997aa bowtie2_wrapper.xml --- a/bowtie2_wrapper.xml Mon Nov 10 13:58:50 2014 -0500 +++ b/bowtie2_wrapper.xml Thu Dec 04 12:58:42 2014 -0500 @@ -1,23 +1,25 @@ - - - is a short-read aligner + + + - map reads against reference genome bowtie2 --version - bowtie2 + bowtie2 samtools - + ## prepare bowtie2 index #set index_path = '' #if str($reference_genome.source) == "history": - bowtie2-build "$reference_genome.own_file" genome; ln -s "$reference_genome.own_file" genome.fa; + bowtie2-build "$reference_genome.own_file" genome && + ln -s "$reference_genome.own_file" genome.fa && #set index_path = 'genome' #else: #set index_path = $reference_genome.index.fields.path #end if ## execute bowtie2 + bowtie2 ## number of threads @@ -26,75 +28,125 @@ ## index file path -x $index_path - ## check for single/pair-end - #if str( $library.type ) == "single" - ## prepare inputs - -U $library.input_1 - #if $output_unaligned_reads_l + ## Fastq inputs + #if str( $library.type ) == "single": + -U "${input_1}" + #if str( $library.unaligned_file ) == "true": --un $output_unaligned_reads_l #end if + #elif str( $library.type ) == "paired": + -1 "${input_1}" + -2 "${input_2}" + #if str( $library.paired_options.paired_options_selector ) == "yes": + -I "${library.paired_options.I}" + -X "${library.paired_options.X}" + ${library.paired_options.fr_rf_ff} + ${library.paired_options.no_mixed} + ${library.paired_options.no_discordant} + ${library.paired_options.dovetail} + ${library.paired_options.no_contain} + ${library.paired_options.no_overlap} + #end if + #if str( $library.unaligned_file ) == "true": + --un-conc $output_unaligned_reads_l + #end if #else - ## prepare inputs - -1 $library.input_1 - -2 $library.input_2 - -I $library.min_insert - -X $library.max_insert - - #if $output_unaligned_reads_l + ## prepare collection + -1 $library.input_1.forward + -2 $library.input_1.reverse + #if str( $library.paired_options.paired_options_selector ) == "yes": + -I "${library.paired_options.I}" + -X "${library.paired_options.X}" + ${library.paired_options.fr_rf_ff} + ${library.paired_options.no_mixed} + ${library.paired_options.no_discordant} + ${library.paired_options.dovetail} + ${library.paired_options.no_contain} + ${library.paired_options.no_overlap} + #end if + #if str( $library.unaligned_file ) == "true": --un-conc $output_unaligned_reads_l #end if #end if - ## configure settings - #if str($params.full) == "yes": - ## add alignment type - $params.align_type - - ## add performance - $params.performance - - ## add time flag - $params.time + ## Readgroups + #if str( $read_group.read_group_selector ) == "yes": + --rg-id "${read_group.rgid}" + --rg "SM:${read_group.rgsm}" + --rg "LB:${read_group.rglb}" + --rg "PL:${read_group.rgpl}" + #end if - ## add nofw/norc - $params.nofw_norc - - ## set gbar - --gbar $params.gbar - - ## check skip - #if str($params.skip) != "0": - -s $params.skip + ## Analysis type + #if ( str( $analysis_type.analysis_type_selector ) == "simple" and str( $analysis_type.presets ) != "no_presets" ): + $analysis_type.presets + #elif str( $analysis_type.analysis_type_selector ) == "full": + #if str( $analysis_type.input_options.input_options_selector ) == "yes": + --skip "${analysis_type.input_options.skip}" + --qupto "${analysis_type.input_options.qupto}" + --trim5 "${analysis_type.input_options.trim5}" + --trim3 "${analysis_type.input_options.trim3}" + ${analysis_type.input_options.qv_encoding} + ${analysis_type.input_options.solexa-quals} + ${analysis_type.input_options.int-quals} #end if - - ## check upto - #if str($params.upto) != "0": - -u $params.upto + + #if str( $analysis_type.alignment_options.alignment_options_selector ) == "yes": + -N "${$analysis_type.alignment_options.N}" + -L "${$analysis_type.alignment_options.L}" + -i "${$analysis_type.alignment_options.i}" + --n_ceil "${$analysis_type.alignment_options.n_ceil}" + --dpad "${$analysis_type.alignment_options.dpad}" + --gbar "${$analysis_type.alignment_options.gbar}" + ${analysis_type.alignment_options.ignore-quals} + ${analysis_type.alignment_options.nofw} + ${analysis_type.alignment_options.norc} + ${analysis_type.alignment_options.no_1mm_upfront} + #if str( $analysis_type.alignment_options.align_mode.align_mode_selector ) == "end-to-end": + --end-to-end + --score-min "${$analysis_type.alignment_options.align_mode.core-min}" + #elif str( $analysis_type.alignment_options.align_mode.align_mode_selector ) == "local": + --local + --score-min "${$analysis_type.alignment_options.align_mode.core-min}" + #end if + #end if + + #if str( $analysis_type.scoring_options.scoring_options_selector ) == "yes": + --ma "${analysis_type.scoring_options.ma}" + --mp "${analysis_type.scoring_options.mp}" + --np "${analysis_type.scoring_options.np}" + --rdg "${analysis_type.scoring_options.rdg_read_open},${analysis_type.scoring_options.rdg_read_extend}" + --rfg "${analysis_type.scoring_options.rfg_ref_open},${analysis_type.scoring_options.rfg_ref_extend}" + #end if + + #if str( $analysis_type.reporting_options.reporting_options_selector ) == "k": + -k "${analysis_type.reporting_options.k}" + #elif str( $analysis_type.reporting_options.reporting_options_selector ) == "a": + -a + #end if + + #if str( $analysis_type.effort_options.effort_options_selector ) == "yes": + -D "${analysis_type.effort_options.D}" + -R "${analysis_type.effort_options.R}" + #end if + + #if str( $analysis_type.sam_options.sam_options_selector ) == "yes": + ${analysis_type.sam_options.no-unal} + ${analysis_type.sam_options.omit-sec-seq} + #end if + + #if str( $analysis_type.other_options.other_options_selector ) == "yes": + ${analysis_type.other_options.reorder} + ${analysis_type.other_options.non-deterministic} + --seed "${analysis_type.other_options.seed}" #end if - ## check trim5 - #if str($params.trim5) != "0": - -5 $params.trim5 - #end if - - ## check trim3 - #if str($params.trim3) != "0": - -3 $params.trim3 - #end if - #end if + #elif str( $analysis_type.analysis_type_selector ) == "cline": + ${analysis_type.cline} + #end if - ## read group information - #if str($read_group.selection) == "yes": - #if $read_group.rgid and $read_group.rglb and $read_group.rgpl and $read_group.rgsm: - --rg-id "$read_group.rgid" - --rg "LB:$read_group.rglb" - --rg "PL:$read_group.rgpl" - --rg "SM:$read_group.rgsm" - #end if - #end if - - ## view/sort and output file + ## view/sort and output BAM file | samtools view -Su - | samtools sort -o - - > $output ## rename unaligned sequence files @@ -105,6 +157,7 @@ ; mv $left $output_unaligned_reads_l; mv $right $output_unaligned_reads_r #end if + @@ -115,32 +168,81 @@ - + + + + - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - + - - - + + + - + @@ -148,76 +250,183 @@ - + - + - + - - - - + + + + - - - - - + + + + - - - - + + + + + + + + + + + - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + - - + + - unaligned_file is True + library['unaligned_file'] is True - library['type'] == "paired" and unaligned_file is True + ( library['type'] == "paired" or library['type'] == "paired_collection" ) and library['unaligned_file'] is True - + + @@ -256,128 +466,446 @@ - + - + + - - - + + + + + **Bowtie2 Overview** -Bowtie_ is an ultrafast and memory-efficient tool for aligning sequencing reads to long reference sequences. It is particularly good at aligning reads of about 50 up to 100s or 1,000s of characters to relatively long (e.g. mammalian) genomes. Bowtie 2 supports gapped, local, and paired-end alignment modes. Bowtie 2 outputs alignments in SAM format, enabling interoperation with a large number of other tools. +Bowtie2_ is an ultrafast and memory-efficient tool for aligning sequencing reads to long reference sequences. It is particularly good at aligning reads of about 50 up to 100s or 1,000s of characters to relatively long (e.g. mammalian) genomes. Bowtie 2 supports gapped, local, and paired-end alignment modes. Galaxy wrapper for Bowtie 2 outputs alignments in `BAM format`_, enabling interoperation with a large number of other tools available at this site. +Majority of information in this page is derived from an excellent `Bowtie2 manual`_ written by Ben Langmead. + +.. _Bowtie2: http://bowtie-bio.sourceforge.net/bowtie2/ +.. _`Bowtie2 manual`: http://bowtie-bio.sourceforge.net/bowtie2/manual.shtml +.. _`BAM format`: http://samtools.github.io/hts-specs/SAMv1.pdf + +----- -*Please cite:* Langmead, B., Trapnell, C., Pop, M. and Salzberg, S.L. Ultrafast and memory-efficient alignment of short DNA sequences to the human genome. Genome Biology 10:R25 (2009) +**Selecting reference genomes for Bowtie2** + +Galaxy wrapper for Bowtie2 allows you select between precomputed and user-defined indices for reference genomes using **Will you select a reference genome from your history or use a built-in index?** flag. This flag has two options: -.. _Bowtie: http://bowtie-bio.sourceforge.net/bowtie2/ + 1. **Use a built-in genome index** - when selected (this is default), Galaxy provides the user with **Select reference genome index** dropdown. Genomes listed in this dropdown have been pre-indexed with bowtie2-build utility and are ready to be mapped against. + 2. **Use a genome from the history and build index** - when selected, Galaxy provides the user with **Select reference genome sequence** dropdown. This dropdown is populated by all FASTA formatted files listed in your current history. If your genome of interest is uploaded into history it will be shown there. Selecting a genome from this dropdown will cause Galaxy to first transparently index it using bowtie2-build command, and then run mapping with bowtie2. + +If your genome of interest is not listed here you have two choices: + + 1. Contact galaxy team using **Help->Support** link at the top of the interface and let us know that an index needs to be added + 2. Upload your genome of interest as a FASTA file to Galaxy history and selected **Use a genome from the history and build index** option. ------ +.. class:: infomark + +**Bowtie2 options** + +Galaxy wrapper for Bowtie2 implements most but not all options available through the command line. Supported options are described below. + +----- + **Inputs** Bowtie 2 accepts files in Sanger FASTQ format (single or pair-end). Use the FASTQ Groomer to prepare your files. ------ -**Outputs** +**Input options**:: + + -s/--skip <int> + Skip (i.e. do not align) the first `<int>` reads or pairs in the input. + + -u/--qupto <int> + Align the first `<int>` reads or read pairs from the input (after the + `-s`/`--skip` reads or pairs have been skipped), then stop. Default: no limit. + + -5/--trim5 <int> + Trim `<int>` bases from 5' (left) end of each read before alignment (default: 0). -The mapped sequence reads are provided as BAM file, while unmapped reads are optionally available as SAM records. When Bowtie 2 finishes running, it prints messages summarizing what happened. These messages are printed to the "standard error" ("stderr") filehandle. For datasets consisting of unpaired reads, the summary might look like this:: + -3/--trim3 <int> + Trim `<int>` bases from 3' (right) end of each read before alignment (default: 0). + + --phred33 + Input qualities are ASCII chars equal to the Phred quality plus 33. This is + also called the "Phred+33" encoding, which is used by the very latest Illumina + pipelines. + + --phred64 + Input qualities are ASCII chars equal to the [Phred quality] plus 64. This is + also called the "Phred+64" encoding. - 20000 reads; of these: - 20000 (100.00%) were unpaired; of these: - 1247 (6.24%) aligned 0 times - 18739 (93.69%) aligned exactly 1 time - 14 (0.07%) aligned >1 times - 93.77% overall alignment rate + --solexa-quals + Convert input qualities from Solexa Phred quality (which can be negative) to + Phred Phred quality (which can't). This scheme was used in older Illumina GA + Pipeline versions (prior to 1.3). Default: off. + + --int-quals + Quality values are represented in the read input file as space-separated ASCII integers, e.g., `40 40 30 40`..., rather than ASCII characters, e.g., `II?I`.... + Integers are treated as being on the [Phred quality] scale unless + `--solexa-quals` is also specified. Default: off. + +------ + +**Presets in `--end-to-end` mode**:: + + --very-fast + Same as: `-D 5 -R 1 -N 0 -L 22 -i S,0,2.50` + + --fast + Same as: `-D 10 -R 2 -N 0 -L 22 -i S,0,2.50` + + --sensitive + Same as: `-D 15 -R 2 -L 22 -i S,1,1.15` (default in `--end-to-end` mode) + + --very-sensitive + Same as: `-D 20 -R 3 -N 0 -L 20 -i S,1,0.50` ------ -**Alignment options** - -*--end-to-end/--local* - -By default, Bowtie 2 performs end-to-end read alignment. That is, it searches for alignments involving all of the read characters. This is also called an "untrimmed" or "unclipped" alignment. When the --local option is specified, Bowtie 2 performs local read alignment. In this mode, Bowtie 2 might "trim" or "clip" some read characters from one or both ends of the alignment if doing so maximizes the alignment score. - -End-to-end alignment example:: +**Presets options in `--local` mode**:: - Read GACTGGGCGATCTCGACTTCG - ||||| |||||||||||||| - Reference GACTG--CGATCTCGACATCG - -Local alignment example:: - - Read ACGGTTGCGTTAA-TCCGCCACG - ||||||||| |||||| - Reference TAACTTGCGTTAAATCCGCCTGG - -*-s/--skip (default: 0)* + --very-fast-local + Same as: `-D 5 -R 1 -N 0 -L 25 -i S,1,2.00` -Skip (i.e. do not align) the first n-reads or pairs in the input. - -*-u/--qupto (default: no limit)* - -Align the first n-reads or read pairs from the input (after the -s/--skip reads or pairs have been skipped), then stop. - -*-5/--trim5 (default: 0)* - -Trim n-bases from 5' (left) end of each read before alignment. + --fast-local + Same as: `-D 10 -R 2 -N 0 -L 22 -i S,1,1.75` -*-3/--trim3 (default: 0)* - -Trim n-bases from 3' (right) end of each read before alignment. - -*--nofw/--norc (default: both strands enabled)* + --sensitive-local + Same as: `-D 15 -R 2 -N 0 -L 20 -i S,1,0.75` (default in `--local` mode) -If --nofw is specified, Bowtie 2 will not attempt to align unpaired reads to the forward (Watson) reference strand. If --norc is specified, bowtie2 will not attempt to align unpaired reads against the reverse-complement (Crick) reference strand. In paired-end mode, --nofw and --norc pertain to the fragments; i.e. specifying --nofw causes Bowtie 2 to explore only those paired-end configurations corresponding to fragments from the reverse-complement (Crick) strand. Default: both strands enabled. - -*--gbar (default: 4)* - -Disallow gaps within n-positions of the beginning or end of the read. - + --very-sensitive-local + Same as: `-D 20 -R 3 -N 0 -L 20 -i S,1,0.50` + ------ -**Paired-end options** +**Alignment options**:: + + -N <int> + Sets the number of mismatches to allowed in a seed alignment during [multiseed + alignment]. Can be set to 0 or 1. Setting this higher makes alignment slower + (often much slower) but increases sensitivity. Default: 0. + + -L <int> + Sets the length of the seed substrings to align during [multiseed alignment]. + Smaller values make alignment slower but more senstive. Default: the + `--sensitive` preset is used by default, which sets `-L` to 20 both in + `--end-to-end` mode and in `--local` mode. + + -i <func> + Sets a function governing the interval between seed substrings to use during + [multiseed alignment]. For instance, if the read has 30 characers, and seed + length is 10, and the seed interval is 6, the seeds extracted will be: + + Read: TAGCTACGCTCTACGCTATCATGCATAAAC + Seed 1 fw: TAGCTACGCT + Seed 1 rc: AGCGTAGCTA + Seed 2 fw: CGCTCTACGC + Seed 2 rc: GCGTAGAGCG + Seed 3 fw: ACGCTATCAT + Seed 3 rc: ATGATAGCGT + Seed 4 fw: TCATGCATAA + Seed 4 rc: TTATGCATGA + + Since it's best to use longer intervals for longer reads, this parameter sets + the interval as a function of the read length, rather than a single + one-size-fits-all number. For instance, specifying `-i S,1,2.5` sets the + interval function `f` to `f(x) = 1 + 2.5 * sqrt(x)`, where x is the read length. + See also: [setting function options]. If the function returns a result less than + 1, it is rounded up to 1. Default: the `--sensitive` preset is used by + default, which sets `-i` to `S,1,1.15` in `--end-to-end` mode to `-i S,1,0.75` + in `--local` mode. + + --n-ceil <func> + Sets a function governing the maximum number of ambiguous characters (usually + `N`s and/or `.`s) allowed in a read as a function of read length. For instance, + specifying `-L,0,0.15` sets the N-ceiling function `f` to `f(x) = 0 + 0.15 * x`, + where x is the read length. See also: [setting function options]. Reads + exceeding this ceiling are [filtered out]. Default: `L,0,0.15`. + + --dpad <int> + "Pads" dynamic programming problems by `<int>` columns on either side to allow + gaps. Default: 15. + + --gbar <int> + Disallow gaps within `<int>` positions of the beginning or end of the read. + Default: 4. + + --ignore-quals + When calculating a mismatch penalty, always consider the quality value at the + mismatched position to be the highest possible, regardless of the actual value. + I.e. input is treated as though all quality values are high. This is also the + default behavior when the input doesn't specify quality values (e.g. in `-f`, + `-r`, or `-c` modes). -*-I/--minins (default: 0)* + --nofw/--norc + If `--nofw` is specified, `bowtie2` will not attempt to align unpaired reads to + the forward (Watson) reference strand. If `--norc` is specified, `bowtie2` will + not attempt to align unpaired reads against the reverse-complement (Crick) + reference strand. In paired-end mode, `--nofw` and `--norc` pertain to the + fragments; i.e. specifying `--nofw` causes `bowtie2` to explore only those + paired-end configurations corresponding to fragments from the reverse-complement + (Crick) strand. Default: both strands enabled. + + --no-1mm-upfront + By default, Bowtie 2 will attempt to find either an exact or a 1-mismatch + end-to-end alignment for the read *before* trying the [multiseed heuristic]. Such + alignments can be found very quickly, and many short read alignments have exact or + near-exact end-to-end alignments. However, this can lead to unexpected + alignments when the user also sets options governing the [multiseed heuristic], + like `-L` and `-N`. For instance, if the user specifies `-N 0` and `-L` equal + to the length of the read, the user will be surprised to find 1-mismatch alignments + reported. This option prevents Bowtie 2 from searching for 1-mismatch end-to-end + alignments before using the [multiseed heuristic], which leads to the expected + behavior when combined with options such as `-L` and `-N`. This comes at the + expense of speed. + + --end-to-end + In this mode, Bowtie 2 requires that the entire read align from one end to the + other, without any trimming (or "soft clipping") of characters from either end. + The match bonus `--ma` always equals 0 in this mode, so all alignment scores + are less than or equal to 0, and the greatest possible alignment score is 0. + This is mutually exclusive with `--local`. `--end-to-end` is the default mode. -The minimum fragment length for valid paired-end alignments. E.g. if -I 60 is specified and a paired-end alignment consists of two 20-bp alignments in the appropriate orientation with a 20-bp gap between them, that alignment is considered valid (as long as -X is also satisfied). A 19-bp gap would not be valid in that case. If trimming options -3 or -5 are also used, the -I constraint is applied with respect to the untrimmed mates. + --local + In this mode, Bowtie 2 does not require that the entire read align from one end + to the other. Rather, some characters may be omitted ("soft clipped") from the + ends in order to achieve the greatest possible alignment score. The match bonus + `--ma` is used in this mode, and the best possible alignment score is equal to + the match bonus (`--ma`) times the length of the read. Specifying `--local` + and one of the presets (e.g. `--local --very-fast`) is equivalent to specifying + the local version of the preset (`--very-fast-local`). This is mutually + exclusive with `--end-to-end`. `--end-to-end` is the default mode. + +----- + +**Scoring options**:: + + --ma <int> + Sets the match bonus. In `--local` mode `<int>` is added to the alignment + score for each position where a read character aligns to a reference character + and the characters match. Not used in `--end-to-end` mode. Default: 2. + + --mp MX,MN + Sets the maximum (`MX`) and minimum (`MN`) mismatch penalties, both integers. A + number less than or equal to `MX` and greater than or equal to `MN` is + subtracted from the alignment score for each position where a read character + aligns to a reference character, the characters do not match, and neither is an + `N`. If `--ignore-quals` is specified, the number subtracted quals `MX`. + Otherwise, the number subtracted is `MN + floor( (MX-MN)(MIN(Q, 40.0)/40.0) )` + where Q is the Phred quality value. Default: `MX` = 6, `MN` = 2. + + --np <int> + Sets penalty for positions where the read, reference, or both, contain an + ambiguous character such as `N`. Default: 1. + + --rdg <int1>,<int2> + Sets the read gap open (`<int1>`) and extend (`<int2>`) penalties. A read gap of + length N gets a penalty of `<int1>` + N * `<int2>`. Default: 5, 3. + + --rfg <int1>,<int2> + Sets the reference gap open (`<int1>`) and extend (`<int2>`) penalties. A + reference gap of length N gets a penalty of `<int1>` + N * `<int2>`. Default: + 5, 3. -The larger the difference between -I and -X, the slower Bowtie 2 will run. This is because larger differences bewteen -I and -X require that Bowtie 2 scan a larger window to determine if a concordant alignment exists. For typical fragment length ranges (200 to 400 nucleotides), Bowtie 2 is very efficient. + --score-min <func> + Sets a function governing the minimum alignment score needed for an alignment to + be considered "valid" (i.e. good enough to report). This is a function of read + length. For instance, specifying `L,0,-0.6` sets the minimum-score function `f` + to `f(x) = 0 + -0.6 * x`, where `x` is the read length. See also: [setting + function options]. The default in `--end-to-end` mode is `L,-0.6,-0.6` and + the default in `--local` mode is `G,20,8`. + +----- + +**Reporting options**:: + + -k <int> + By default, `bowtie2` searches for distinct, valid alignments for each read. + When it finds a valid alignment, it continues looking for alignments that are + nearly as good or better. The best alignment found is reported (randomly + selected from among best if tied). Information about the best alignments is + used to estimate mapping quality and to set SAM optional fields, such as + `AS:i` and `XS:i`. + + When `-k` is specified, however, `bowtie2` behaves differently. Instead, it + searches for at most `<int>` distinct, valid alignments for each read. The + search terminates when it can't find more distinct valid alignments, or when it + finds `<int>`, whichever happens first. All alignments found are reported in + descending order by alignment score. The alignment score for a paired-end + alignment equals the sum of the alignment scores of the individual mates. Each + reported read or pair alignment beyond the first has the SAM 'secondary' bit + (which equals 256) set in its FLAGS field. For reads that have more than + `<int>` distinct, valid alignments, `bowtie2` does not guarantee that the + `<int>` alignments reported are the best possible in terms of alignment score. + `-k` is mutually exclusive with `-a`. -*-X/--maxins (default: 0)* + Note: Bowtie 2 is not designed with large values for `-k` in mind, and when + aligning reads to long, repetitive genomes large `-k` can be very, very slow. + + -a + Like `-k` but with no upper limit on number of alignments to search for. `-a` + is mutually exclusive with `-k`. + + Note: Bowtie 2 is not designed with `-a` mode in mind, and when + aligning reads to long, repetitive genomes this mode can be very, very slow. + +----- + +**Effort options**:: + + -D <int> + Up to `<int>` consecutive seed extension attempts can "fail" before Bowtie 2 + moves on, using the alignments found so far. A seed extension "fails" if it + does not yield a new best or a new second-best alignment. This limit is + automatically adjusted up when -k or -a are specified. Default: 15. + + -R <int> + `<int>` is the maximum number of times Bowtie 2 will "re-seed" reads with + repetitive seeds. When "re-seeding," Bowtie 2 simply chooses a new set of reads + (same length, same number of mismatches allowed) at different offsets and + searches for more alignments. A read is considered to have repetitive seeds if + the total number of seed hits divided by the number of seeds that aligned at + least once is greater than 300. Default: 2. + +----- + +**Paired-end options**:: -The maximum fragment length for valid paired-end alignments. E.g. if -X 100 is specified and a paired-end alignment consists of two 20-bp alignments in the proper orientation with a 60-bp gap between them, that alignment is considered valid (as long as -I is also satisfied). A 61-bp gap would not be valid in that case. If trimming options -3 or -5 are also used, the -X constraint is applied with respect to the untrimmed mates, not the trimmed mates. + -I/--minins <int> + The minimum fragment length for valid paired-end alignments. E.g. if `-I 60` is + specified and a paired-end alignment consists of two 20-bp alignments in the + appropriate orientation with a 20-bp gap between them, that alignment is + considered valid (as long as `-X` is also satisfied). A 19-bp gap would not + be valid in that case. If trimming options `-3` or `-5` are also used, the + `-I` constraint is applied with respect to the untrimmed mates. + + The larger the difference between `-I` and `-X`, the slower Bowtie 2 will + run. This is because larger differences bewteen `-I` and `-X` require that + Bowtie 2 scan a larger window to determine if a concordant alignment exists. + For typical fragment length ranges (200 to 400 nucleotides), Bowtie 2 is very + efficient. + + Default: 0 (essentially imposing no minimum) + + -X/--maxins <int> + The maximum fragment length for valid paired-end alignments. E.g. if `-X 100` + is specified and a paired-end alignment consists of two 20-bp alignments in the + proper orientation with a 60-bp gap between them, that alignment is considered + valid (as long as `-I` is also satisfied). A 61-bp gap would not be valid in + that case. If trimming options `-3` or `-5` are also used, the `-X` + constraint is applied with respect to the untrimmed mates, not the trimmed + mates. + + The larger the difference between `-I` and `-X`, the slower Bowtie 2 will + run. This is because larger differences bewteen `-I` and `-X` require that + Bowtie 2 scan a larger window to determine if a concordant alignment exists. + For typical fragment length ranges (200 to 400 nucleotides), Bowtie 2 is very + efficient. + + Default: 500. -The larger the difference between -I and -X, the slower Bowtie 2 will run. This is because larger differences bewteen -I and -X require that Bowtie 2 scan a larger window to determine if a concordant alignment exists. For typical fragment length ranges (200 to 400 nucleotides), Bowtie 2 is very efficient. + --fr/--rf/--ff + The upstream/downstream mate orientations for a valid paired-end alignment + against the forward reference strand. E.g., if `--fr` is specified and there is + a candidate paired-end alignment where mate 1 appears upstream of the reverse + complement of mate 2 and the fragment length constraints (`-I` and `-X`) are + met, that alignment is valid. Also, if mate 2 appears upstream of the reverse + complement of mate 1 and all other constraints are met, that too is valid. + `--rf` likewise requires that an upstream mate1 be reverse-complemented and a + downstream mate2 be forward-oriented. ` --ff` requires both an upstream mate 1 + and a downstream mate 2 to be forward-oriented. Default: `--fr` (appropriate + for Illumina's Paired-end Sequencing Assay). + + --no-mixed + By default, when `bowtie2` cannot find a concordant or discordant alignment for + a pair, it then tries to find alignments for the individual mates. This option + disables that behavior. + --no-discordant + By default, `bowtie2` looks for discordant alignments if it cannot find any + concordant alignments. A discordant alignment is an alignment where both mates + align uniquely, but that does not satisfy the paired-end constraints + (`--fr`/`--rf`/`--ff`, `-I`, `-X`). This option disables that behavior. + + --dovetail + If the mates "dovetail", that is if one mate alignment extends past the + beginning of the other such that the wrong mate begins upstream, consider that + to be concordant. See also: [Mates can overlap, contain or dovetail each + other]. Default: mates cannot dovetail in a concordant alignment. + + --no-contain + If one mate alignment contains the other, consider that to be non-concordant. + See also: [Mates can overlap, contain or dovetail each other]. Default: a mate + can contain the other in a concordant alignment. + + --no-overlap + If one mate alignment overlaps the other at all, consider that to be + non-concordant. See also: [Mates can overlap, contain or dovetail each other]. + Default: mates can overlap in a concordant alignment. + ------ -**SAM options** +**SAM options**:: -*--rg-id [text]* + --rg-id <text> + Set the read group ID to `<text>`. This causes the SAM `@RG` header line to be + printed, with `<text>` as the value associated with the `ID:` tag. It also + causes the `RG:Z:` extra field to be attached to each SAM output record, with + value set to `<text>`. -Set the read group ID to [text]. This causes the SAM @RG header line to be printed, with [text] as the value associated with the ID: tag. It also causes the RG:Z: extra field to be attached to each SAM output record, with value set to [text]. + --rg <text> + Add `<text>` (usually of the form `TAG:VAL`, e.g. `SM:Pool1`) as a field on the + `@RG` header line. Note: in order for the `@RG` line to appear, `--rg-id` + must also be specified. This is because the `ID` tag is required by the [SAM + Spec][SAM]. Specify `--rg` multiple times to set multiple fields. See the + [SAM Spec][SAM] for details about what fields are legal. -*--rg [text]* + --omit-sec-seq + When printing secondary alignments, Bowtie 2 by default will write out the `SEQ` + and `QUAL` strings. Specifying this option causes Bowtie 2 to print an asterix + in those fields instead. + +----- -Add [text] as a field on the @RG header line. Note: in order for the @RG line to appear, --rg-id must also be specified. This is because the ID tag is required by the SAM Spec. Specify --rg multiple times to set multiple fields. See the SAM Spec for details about what fields are legal. +**Other options**:: ------- + --reorder + Guarantees that output SAM records are printed in an order corresponding to the + order of the reads in the original input file, even when `-p` is set greater + than 1. Specifying `--reorder` and setting `-p` greater than 1 causes Bowtie + 2 to run somewhat slower and use somewhat more memory then if `--reorder` were + not specified. Has no effect if `-p` is set to 1, since output order will + naturally correspond to input order in that case. -**Output options** - -*--un/--un-conc* + --seed <int> + Use `<int>` as the seed for pseudo-random number generator. Default: 0. -Write reads that fail to align concordantly to file(s). These reads correspond to the SAM records. - -*-t/--time (default: off)* - -Print the wall-clock time required to load the index files and align the reads. This is printed to the "standard error" ("stderr") filehandle. + --non-deterministic + Normally, Bowtie 2 re-initializes its pseudo-random generator for each read. It + seeds the generator with a number derived from (a) the read name, (b) the + nucleotide sequence, (c) the quality sequence, (d) the value of the `--seed` + option. This means that if two reads are identical (same name, same + nucleotides, same qualities) Bowtie 2 will find and report the same alignment(s) + for both, even if there was ambiguity. When `--non-deterministic` is specified, + Bowtie 2 re-initializes its pseudo-random generator for each read using the + current time. This means that Bowtie 2 will not necessarily report the same + alignment for two identical reads. This is counter-intuitive for some users, + but might be more appropriate in situations where the input consists of many + identical reads. + + 10.1186/gb-2009-10-3-r25 + 10.1038/nmeth.1923 + diff -r aceaf1d94d2d -r 2a6cfe8997aa bowtie2_wrapper.xml.orig --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/bowtie2_wrapper.xml.orig Thu Dec 04 12:58:42 2014 -0500 @@ -0,0 +1,930 @@ + + + - map reads against reference genome + bowtie2 --version + + bowtie2 + samtools + + + + ## prepare bowtie2 index + #set index_path = '' + #if str($reference_genome.source) == "history": + bowtie2-build "$reference_genome.own_file" genome && + ln -s "$reference_genome.own_file" genome.fa && + #set index_path = 'genome' + #else: + #set index_path = $reference_genome.index.fields.path + #end if + + ## execute bowtie2 + + bowtie2 + + ## number of threads + -p \${GALAXY_SLOTS:-4} + + ## index file path + -x $index_path + + + ## Fastq inputs + #if str( $library.type ) == "single": + -U "${input_1}" + #if str( $library.unaligned_file ) == "true": + --un $output_unaligned_reads_l + #end if + #elif str( $library.type ) == "paired": + -1 "${input_1}" + -2 "${input_2}" + #if str( $library.paired_options.paired_options_selector ) == "yes": + -I "${library.paired_options.I}" + -X "${library.paired_options.X}" + ${library.paired_options.fr_rf_ff} + ${library.paired_options.no_mixed} + ${library.paired_options.no_discordant} + ${library.paired_options.dovetail} + ${library.paired_options.no_contain} + ${library.paired_options.no_overlap} + #end if + #if str( $library.unaligned_file ) == "true": + --un-conc $output_unaligned_reads_l + #end if + #else + ## prepare collection + -1 $library.input_1.forward + -2 $library.input_1.reverse + #if str( $library.paired_options.paired_options_selector ) == "yes": + -I "${library.paired_options.I}" + -X "${library.paired_options.X}" + ${library.paired_options.fr_rf_ff} + ${library.paired_options.no_mixed} + ${library.paired_options.no_discordant} + ${library.paired_options.dovetail} + ${library.paired_options.no_contain} + ${library.paired_options.no_overlap} + #end if + #if str( $library.unaligned_file ) == "true": + --un-conc $output_unaligned_reads_l + #end if + #end if + + ## Readgroups + #if str( $read_group.read_group_selector ) == "yes": + --rg-id "${read_group.rgid}" + --rg "SM:${read_group.rgsm}" + --rg "LB:${read_group.rglb}" + --rg "PL:${read_group.rgpl}" + #end if + + ## Analysis type + #if ( str( $analysis_type.analysis_type_selector ) == "simple" and str( $analysis_type.presets ) != "no_presets" ): + $analysis_type.presets + #elif str( $analysis_type.analysis_type_selector ) == "full": + #if str( $analysis_type.input_options.input_options_selector ) == "yes": + --skip "${analysis_type.input_options.skip}" + --qupto "${analysis_type.input_options.qupto}" + --trim5 "${analysis_type.input_options.trim5}" + --trim3 "${analysis_type.input_options.trim3}" + ${analysis_type.input_options.qv_encoding} + ${analysis_type.input_options.solexa-quals} + ${analysis_type.input_options.int-quals} + #end if + + #if str( $analysis_type.alignment_options.alignment_options_selector ) == "yes": + -N "${$analysis_type.alignment_options.N}" + -L "${$analysis_type.alignment_options.L}" + -i "${$analysis_type.alignment_options.i}" + --n_ceil "${$analysis_type.alignment_options.n_ceil}" + --dpad "${$analysis_type.alignment_options.dpad}" + --gbar "${$analysis_type.alignment_options.gbar}" + ${analysis_type.alignment_options.ignore-quals} + ${analysis_type.alignment_options.nofw} + ${analysis_type.alignment_options.norc} + ${analysis_type.alignment_options.no_1mm_upfront} + #if str( $analysis_type.alignment_options.align_mode.align_mode_selector ) == "end-to-end": + --end-to-end + --score-min "${$analysis_type.alignment_options.align_mode.core-min}" + #elif str( $analysis_type.alignment_options.align_mode.align_mode_selector ) == "local": + --local + --score-min "${$analysis_type.alignment_options.align_mode.core-min}" + #end if + #end if + + #if str( $analysis_type.scoring_options.scoring_options_selector ) == "yes": + --ma "${analysis_type.scoring_options.ma}" + --mp "${analysis_type.scoring_options.mp}" + --np "${analysis_type.scoring_options.np}" + --rdg "${analysis_type.scoring_options.rdg_read_open},${analysis_type.scoring_options.rdg_read_extend}" + --rfg "${analysis_type.scoring_options.rfg_ref_open},${analysis_type.scoring_options.rfg_ref_extend}" + #end if + + #if str( $analysis_type.reporting_options.reporting_options_selector ) == "k": + -k "${analysis_type.reporting_options.k}" + #elif str( $analysis_type.reporting_options.reporting_options_selector ) == "a": + -a + #end if + + #if str( $analysis_type.effort_options.effort_options_selector ) == "yes": + -D "${analysis_type.effort_options.D}" + -R "${analysis_type.effort_options.R}" + #end if + + #if str( $analysis_type.sam_options.sam_options_selector ) == "yes": + ${analysis_type.sam_options.no-unal} + ${analysis_type.sam_options.omit-sec-seq} + #end if + + #if str( $analysis_type.other_options.other_options_selector ) == "yes": + ${analysis_type.other_options.reorder} + ${analysis_type.other_options.non-deterministic} + --seed "${analysis_type.other_options.seed}" + #end if + + #elif str( $analysis_type.analysis_type_selector ) == "cline": + ${analysis_type.cline} + #end if + + ## view/sort and output BAM file + | samtools view -Su - | samtools sort -o - - > $output + + ## rename unaligned sequence files + #if $library.type == "paired" and $output_unaligned_reads_l and $output_unaligned_reads_r: + #set left = str($output_unaligned_reads_l).replace( '.dat', '.1.dat' ) + #set right = str($output_unaligned_reads_l).replace( '.dat', '.2.dat' ) + + ; mv $left $output_unaligned_reads_l; + mv $right $output_unaligned_reads_r + #end if + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +<<<<<<< HEAD +======= + +>>>>>>> 9c937b55955856d7c8950db2a60f2f8fd2b14152 + + + + + + + + library['unaligned_file'] is True + + + + + + + ( library['type'] == "paired" or library['type'] == "paired_collection" ) and library['unaligned_file'] is True + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +<<<<<<< HEAD + + + +======= + + + + +>>>>>>> 9c937b55955856d7c8950db2a60f2f8fd2b14152 + + + + + +**Bowtie2 Overview** + +Bowtie2_ is an ultrafast and memory-efficient tool for aligning sequencing reads to long reference sequences. It is particularly good at aligning reads of about 50 up to 100s or 1,000s of characters to relatively long (e.g. mammalian) genomes. Bowtie 2 supports gapped, local, and paired-end alignment modes. Galaxy wrapper for Bowtie 2 outputs alignments in `BAM format`_, enabling interoperation with a large number of other tools available at this site. +Majority of information in this page is derived from an excellent `Bowtie2 manual`_ written by Ben Langmead. + +<<<<<<< HEAD +*Please cite:* Langmead, Ben and Salzberg, Steven L (2012). Fast gapped-read alignment with Bowtie 2. In Nature Methods, 9 (4), pp. 357–359. +======= +.. _Bowtie2: http://bowtie-bio.sourceforge.net/bowtie2/ +.. _`Bowtie2 manual`: http://bowtie-bio.sourceforge.net/bowtie2/manual.shtml +.. _`BAM format`: http://samtools.github.io/hts-specs/SAMv1.pdf +>>>>>>> 9c937b55955856d7c8950db2a60f2f8fd2b14152 + +----- + +**Selecting reference genomes for Bowtie2** + +Galaxy wrapper for Bowtie2 allows you select between precomputed and user-defined indices for reference genomes using **Will you select a reference genome from your history or use a built-in index?** flag. This flag has two options: + + 1. **Use a built-in genome index** - when selected (this is default), Galaxy provides the user with **Select reference genome index** dropdown. Genomes listed in this dropdown have been pre-indexed with bowtie2-build utility and are ready to be mapped against. + 2. **Use a genome from the history and build index** - when selected, Galaxy provides the user with **Select reference genome sequence** dropdown. This dropdown is populated by all FASTA formatted files listed in your current history. If your genome of interest is uploaded into history it will be shown there. Selecting a genome from this dropdown will cause Galaxy to first transparently index it using bowtie2-build command, and then run mapping with bowtie2. + +If your genome of interest is not listed here you have two choices: + + 1. Contact galaxy team using **Help->Support** link at the top of the interface and let us know that an index needs to be added + 2. Upload your genome of interest as a FASTA file to Galaxy history and selected **Use a genome from the history and build index** option. + +------ + +.. class:: infomark + +**Bowtie2 options** + +Galaxy wrapper for Bowtie2 implements most but not all options available through the command line. Supported options are described below. + +----- + +**Inputs** + +Bowtie 2 accepts files in Sanger FASTQ format (single or pair-end). Use the FASTQ Groomer to prepare your files. + +------ + +**Input options**:: + + -s/--skip <int> + Skip (i.e. do not align) the first `<int>` reads or pairs in the input. + + -u/--qupto <int> + Align the first `<int>` reads or read pairs from the input (after the + `-s`/`--skip` reads or pairs have been skipped), then stop. Default: no limit. + + -5/--trim5 <int> + Trim `<int>` bases from 5' (left) end of each read before alignment (default: 0). + + -3/--trim3 <int> + Trim `<int>` bases from 3' (right) end of each read before alignment (default: 0). + + --phred33 + Input qualities are ASCII chars equal to the Phred quality plus 33. This is + also called the "Phred+33" encoding, which is used by the very latest Illumina + pipelines. + + --phred64 + Input qualities are ASCII chars equal to the [Phred quality] plus 64. This is + also called the "Phred+64" encoding. + + --solexa-quals + Convert input qualities from Solexa Phred quality (which can be negative) to + Phred Phred quality (which can't). This scheme was used in older Illumina GA + Pipeline versions (prior to 1.3). Default: off. + + --int-quals + Quality values are represented in the read input file as space-separated ASCII integers, e.g., `40 40 30 40`..., rather than ASCII characters, e.g., `II?I`.... + Integers are treated as being on the [Phred quality] scale unless + `--solexa-quals` is also specified. Default: off. + +------ + +**Presets in `--end-to-end` mode**:: + + --very-fast + Same as: `-D 5 -R 1 -N 0 -L 22 -i S,0,2.50` + + --fast + Same as: `-D 10 -R 2 -N 0 -L 22 -i S,0,2.50` + + --sensitive + Same as: `-D 15 -R 2 -L 22 -i S,1,1.15` (default in `--end-to-end` mode) + + --very-sensitive + Same as: `-D 20 -R 3 -N 0 -L 20 -i S,1,0.50` + +------ + +**Presets options in `--local` mode**:: + + --very-fast-local + Same as: `-D 5 -R 1 -N 0 -L 25 -i S,1,2.00` + + --fast-local + Same as: `-D 10 -R 2 -N 0 -L 22 -i S,1,1.75` + + --sensitive-local + Same as: `-D 15 -R 2 -N 0 -L 20 -i S,1,0.75` (default in `--local` mode) + + --very-sensitive-local + Same as: `-D 20 -R 3 -N 0 -L 20 -i S,1,0.50` + +------ + +**Alignment options**:: + + -N <int> + Sets the number of mismatches to allowed in a seed alignment during [multiseed + alignment]. Can be set to 0 or 1. Setting this higher makes alignment slower + (often much slower) but increases sensitivity. Default: 0. + + -L <int> + Sets the length of the seed substrings to align during [multiseed alignment]. + Smaller values make alignment slower but more senstive. Default: the + `--sensitive` preset is used by default, which sets `-L` to 20 both in + `--end-to-end` mode and in `--local` mode. + + -i <func> + Sets a function governing the interval between seed substrings to use during + [multiseed alignment]. For instance, if the read has 30 characers, and seed + length is 10, and the seed interval is 6, the seeds extracted will be: + + Read: TAGCTACGCTCTACGCTATCATGCATAAAC + Seed 1 fw: TAGCTACGCT + Seed 1 rc: AGCGTAGCTA + Seed 2 fw: CGCTCTACGC + Seed 2 rc: GCGTAGAGCG + Seed 3 fw: ACGCTATCAT + Seed 3 rc: ATGATAGCGT + Seed 4 fw: TCATGCATAA + Seed 4 rc: TTATGCATGA + + Since it's best to use longer intervals for longer reads, this parameter sets + the interval as a function of the read length, rather than a single + one-size-fits-all number. For instance, specifying `-i S,1,2.5` sets the + interval function `f` to `f(x) = 1 + 2.5 * sqrt(x)`, where x is the read length. + See also: [setting function options]. If the function returns a result less than + 1, it is rounded up to 1. Default: the `--sensitive` preset is used by + default, which sets `-i` to `S,1,1.15` in `--end-to-end` mode to `-i S,1,0.75` + in `--local` mode. + + --n-ceil <func> + Sets a function governing the maximum number of ambiguous characters (usually + `N`s and/or `.`s) allowed in a read as a function of read length. For instance, + specifying `-L,0,0.15` sets the N-ceiling function `f` to `f(x) = 0 + 0.15 * x`, + where x is the read length. See also: [setting function options]. Reads + exceeding this ceiling are [filtered out]. Default: `L,0,0.15`. + + --dpad <int> + "Pads" dynamic programming problems by `<int>` columns on either side to allow + gaps. Default: 15. + + --gbar <int> + Disallow gaps within `<int>` positions of the beginning or end of the read. + Default: 4. + + --ignore-quals + When calculating a mismatch penalty, always consider the quality value at the + mismatched position to be the highest possible, regardless of the actual value. + I.e. input is treated as though all quality values are high. This is also the + default behavior when the input doesn't specify quality values (e.g. in `-f`, + `-r`, or `-c` modes). + + --nofw/--norc + If `--nofw` is specified, `bowtie2` will not attempt to align unpaired reads to + the forward (Watson) reference strand. If `--norc` is specified, `bowtie2` will + not attempt to align unpaired reads against the reverse-complement (Crick) + reference strand. In paired-end mode, `--nofw` and `--norc` pertain to the + fragments; i.e. specifying `--nofw` causes `bowtie2` to explore only those + paired-end configurations corresponding to fragments from the reverse-complement + (Crick) strand. Default: both strands enabled. + + --no-1mm-upfront + By default, Bowtie 2 will attempt to find either an exact or a 1-mismatch + end-to-end alignment for the read *before* trying the [multiseed heuristic]. Such + alignments can be found very quickly, and many short read alignments have exact or + near-exact end-to-end alignments. However, this can lead to unexpected + alignments when the user also sets options governing the [multiseed heuristic], + like `-L` and `-N`. For instance, if the user specifies `-N 0` and `-L` equal + to the length of the read, the user will be surprised to find 1-mismatch alignments + reported. This option prevents Bowtie 2 from searching for 1-mismatch end-to-end + alignments before using the [multiseed heuristic], which leads to the expected + behavior when combined with options such as `-L` and `-N`. This comes at the + expense of speed. + + --end-to-end + In this mode, Bowtie 2 requires that the entire read align from one end to the + other, without any trimming (or "soft clipping") of characters from either end. + The match bonus `--ma` always equals 0 in this mode, so all alignment scores + are less than or equal to 0, and the greatest possible alignment score is 0. + This is mutually exclusive with `--local`. `--end-to-end` is the default mode. + + --local + In this mode, Bowtie 2 does not require that the entire read align from one end + to the other. Rather, some characters may be omitted ("soft clipped") from the + ends in order to achieve the greatest possible alignment score. The match bonus + `--ma` is used in this mode, and the best possible alignment score is equal to + the match bonus (`--ma`) times the length of the read. Specifying `--local` + and one of the presets (e.g. `--local --very-fast`) is equivalent to specifying + the local version of the preset (`--very-fast-local`). This is mutually + exclusive with `--end-to-end`. `--end-to-end` is the default mode. + +----- + +**Scoring options**:: + + --ma <int> + Sets the match bonus. In `--local` mode `<int>` is added to the alignment + score for each position where a read character aligns to a reference character + and the characters match. Not used in `--end-to-end` mode. Default: 2. + + --mp MX,MN + Sets the maximum (`MX`) and minimum (`MN`) mismatch penalties, both integers. A + number less than or equal to `MX` and greater than or equal to `MN` is + subtracted from the alignment score for each position where a read character + aligns to a reference character, the characters do not match, and neither is an + `N`. If `--ignore-quals` is specified, the number subtracted quals `MX`. + Otherwise, the number subtracted is `MN + floor( (MX-MN)(MIN(Q, 40.0)/40.0) )` + where Q is the Phred quality value. Default: `MX` = 6, `MN` = 2. + + --np <int> + Sets penalty for positions where the read, reference, or both, contain an + ambiguous character such as `N`. Default: 1. + + --rdg <int1>,<int2> + Sets the read gap open (`<int1>`) and extend (`<int2>`) penalties. A read gap of + length N gets a penalty of `<int1>` + N * `<int2>`. Default: 5, 3. + + --rfg <int1>,<int2> + Sets the reference gap open (`<int1>`) and extend (`<int2>`) penalties. A + reference gap of length N gets a penalty of `<int1>` + N * `<int2>`. Default: + 5, 3. + + --score-min <func> + Sets a function governing the minimum alignment score needed for an alignment to + be considered "valid" (i.e. good enough to report). This is a function of read + length. For instance, specifying `L,0,-0.6` sets the minimum-score function `f` + to `f(x) = 0 + -0.6 * x`, where `x` is the read length. See also: [setting + function options]. The default in `--end-to-end` mode is `L,-0.6,-0.6` and + the default in `--local` mode is `G,20,8`. + +----- + +**Reporting options**:: + + -k <int> + By default, `bowtie2` searches for distinct, valid alignments for each read. + When it finds a valid alignment, it continues looking for alignments that are + nearly as good or better. The best alignment found is reported (randomly + selected from among best if tied). Information about the best alignments is + used to estimate mapping quality and to set SAM optional fields, such as + `AS:i` and `XS:i`. + + When `-k` is specified, however, `bowtie2` behaves differently. Instead, it + searches for at most `<int>` distinct, valid alignments for each read. The + search terminates when it can't find more distinct valid alignments, or when it + finds `<int>`, whichever happens first. All alignments found are reported in + descending order by alignment score. The alignment score for a paired-end + alignment equals the sum of the alignment scores of the individual mates. Each + reported read or pair alignment beyond the first has the SAM 'secondary' bit + (which equals 256) set in its FLAGS field. For reads that have more than + `<int>` distinct, valid alignments, `bowtie2` does not guarantee that the + `<int>` alignments reported are the best possible in terms of alignment score. + `-k` is mutually exclusive with `-a`. + + Note: Bowtie 2 is not designed with large values for `-k` in mind, and when + aligning reads to long, repetitive genomes large `-k` can be very, very slow. + + -a + Like `-k` but with no upper limit on number of alignments to search for. `-a` + is mutually exclusive with `-k`. + + Note: Bowtie 2 is not designed with `-a` mode in mind, and when + aligning reads to long, repetitive genomes this mode can be very, very slow. + +----- + +**Effort options**:: + + -D <int> + Up to `<int>` consecutive seed extension attempts can "fail" before Bowtie 2 + moves on, using the alignments found so far. A seed extension "fails" if it + does not yield a new best or a new second-best alignment. This limit is + automatically adjusted up when -k or -a are specified. Default: 15. + + -R <int> + `<int>` is the maximum number of times Bowtie 2 will "re-seed" reads with + repetitive seeds. When "re-seeding," Bowtie 2 simply chooses a new set of reads + (same length, same number of mismatches allowed) at different offsets and + searches for more alignments. A read is considered to have repetitive seeds if + the total number of seed hits divided by the number of seeds that aligned at + least once is greater than 300. Default: 2. + +----- + +**Paired-end options**:: + + -I/--minins <int> + The minimum fragment length for valid paired-end alignments. E.g. if `-I 60` is + specified and a paired-end alignment consists of two 20-bp alignments in the + appropriate orientation with a 20-bp gap between them, that alignment is + considered valid (as long as `-X` is also satisfied). A 19-bp gap would not + be valid in that case. If trimming options `-3` or `-5` are also used, the + `-I` constraint is applied with respect to the untrimmed mates. + + The larger the difference between `-I` and `-X`, the slower Bowtie 2 will + run. This is because larger differences bewteen `-I` and `-X` require that + Bowtie 2 scan a larger window to determine if a concordant alignment exists. + For typical fragment length ranges (200 to 400 nucleotides), Bowtie 2 is very + efficient. + + Default: 0 (essentially imposing no minimum) + + -X/--maxins <int> + The maximum fragment length for valid paired-end alignments. E.g. if `-X 100` + is specified and a paired-end alignment consists of two 20-bp alignments in the + proper orientation with a 60-bp gap between them, that alignment is considered + valid (as long as `-I` is also satisfied). A 61-bp gap would not be valid in + that case. If trimming options `-3` or `-5` are also used, the `-X` + constraint is applied with respect to the untrimmed mates, not the trimmed + mates. + + The larger the difference between `-I` and `-X`, the slower Bowtie 2 will + run. This is because larger differences bewteen `-I` and `-X` require that + Bowtie 2 scan a larger window to determine if a concordant alignment exists. + For typical fragment length ranges (200 to 400 nucleotides), Bowtie 2 is very + efficient. + + Default: 500. + + --fr/--rf/--ff + The upstream/downstream mate orientations for a valid paired-end alignment + against the forward reference strand. E.g., if `--fr` is specified and there is + a candidate paired-end alignment where mate 1 appears upstream of the reverse + complement of mate 2 and the fragment length constraints (`-I` and `-X`) are + met, that alignment is valid. Also, if mate 2 appears upstream of the reverse + complement of mate 1 and all other constraints are met, that too is valid. + `--rf` likewise requires that an upstream mate1 be reverse-complemented and a + downstream mate2 be forward-oriented. ` --ff` requires both an upstream mate 1 + and a downstream mate 2 to be forward-oriented. Default: `--fr` (appropriate + for Illumina's Paired-end Sequencing Assay). + + --no-mixed + By default, when `bowtie2` cannot find a concordant or discordant alignment for + a pair, it then tries to find alignments for the individual mates. This option + disables that behavior. + + --no-discordant + By default, `bowtie2` looks for discordant alignments if it cannot find any + concordant alignments. A discordant alignment is an alignment where both mates + align uniquely, but that does not satisfy the paired-end constraints + (`--fr`/`--rf`/`--ff`, `-I`, `-X`). This option disables that behavior. + + --dovetail + If the mates "dovetail", that is if one mate alignment extends past the + beginning of the other such that the wrong mate begins upstream, consider that + to be concordant. See also: [Mates can overlap, contain or dovetail each + other]. Default: mates cannot dovetail in a concordant alignment. + + --no-contain + If one mate alignment contains the other, consider that to be non-concordant. + See also: [Mates can overlap, contain or dovetail each other]. Default: a mate + can contain the other in a concordant alignment. + + --no-overlap + If one mate alignment overlaps the other at all, consider that to be + non-concordant. See also: [Mates can overlap, contain or dovetail each other]. + Default: mates can overlap in a concordant alignment. + +------ + +**SAM options**:: + + --rg-id <text> + Set the read group ID to `<text>`. This causes the SAM `@RG` header line to be + printed, with `<text>` as the value associated with the `ID:` tag. It also + causes the `RG:Z:` extra field to be attached to each SAM output record, with + value set to `<text>`. + + --rg <text> + Add `<text>` (usually of the form `TAG:VAL`, e.g. `SM:Pool1`) as a field on the + `@RG` header line. Note: in order for the `@RG` line to appear, `--rg-id` + must also be specified. This is because the `ID` tag is required by the [SAM + Spec][SAM]. Specify `--rg` multiple times to set multiple fields. See the + [SAM Spec][SAM] for details about what fields are legal. + + --omit-sec-seq + When printing secondary alignments, Bowtie 2 by default will write out the `SEQ` + and `QUAL` strings. Specifying this option causes Bowtie 2 to print an asterix + in those fields instead. + +----- + +**Other options**:: + + --reorder + Guarantees that output SAM records are printed in an order corresponding to the + order of the reads in the original input file, even when `-p` is set greater + than 1. Specifying `--reorder` and setting `-p` greater than 1 causes Bowtie + 2 to run somewhat slower and use somewhat more memory then if `--reorder` were + not specified. Has no effect if `-p` is set to 1, since output order will + naturally correspond to input order in that case. + + --seed <int> + Use `<int>` as the seed for pseudo-random number generator. Default: 0. + + --non-deterministic + Normally, Bowtie 2 re-initializes its pseudo-random generator for each read. It + seeds the generator with a number derived from (a) the read name, (b) the + nucleotide sequence, (c) the quality sequence, (d) the value of the `--seed` + option. This means that if two reads are identical (same name, same + nucleotides, same qualities) Bowtie 2 will find and report the same alignment(s) + for both, even if there was ambiguity. When `--non-deterministic` is specified, + Bowtie 2 re-initializes its pseudo-random generator for each read using the + current time. This means that Bowtie 2 will not necessarily report the same + alignment for two identical reads. This is counter-intuitive for some users, + but might be more appropriate in situations where the input consists of many + identical reads. + + + +<<<<<<< HEAD + 10.1038/nmeth.1923 + +======= + 10.1186/gb-2009-10-3-r25 + 10.1038/nmeth.1923 + +>>>>>>> 9c937b55955856d7c8950db2a60f2f8fd2b14152 + diff -r aceaf1d94d2d -r 2a6cfe8997aa shed_upload.tar.gz Binary file shed_upload.tar.gz has changed diff -r aceaf1d94d2d -r 2a6cfe8997aa test-data/bowtie2-fq1.fq --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test-data/bowtie2-fq1.fq Thu Dec 04 12:58:42 2014 -0500 @@ -0,0 +1,400 @@ +@M01368:8:000000000-A3GHV:1:1101:6911:8255/1 +ATCTGGTTCCTACTTCAGGGCCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACCTACGTTCAATATT ++ +BCCCCFFFFFFFGGGGGGGGGGGHHHHGHGHHHHHHHHHGGGGGGHHHHGHHHHHHHHHHGHHHHHHGGHGGHHHGHHHHFHHGHHHHHHHHHGHEHEFFGHHEGGCEFGGFHHHBGHHGHHHHGHFHHHGHGHGHGGCDFDDACGGGGGGGAAFFFFFFFFFBAFFFFFB;FFFFFFADDFFFFFFFFFFEFFFFFFFFFFBFFFFFFFFFFFFFFEFFFFFFFFBFEFFFFEFE;DFFFDFBFF/9BFB +@M01368:8:000000000-A3GHV:1:1101:14518:9998/1 +GTTATTATTATGTCCTACAAGCATTAATTAATTAACACACTTTAGTAAGTATGTTCGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGGGATAGACCTGTGATCCATCGTGAT ++ +AAAAAFFFFFFFGGGGGGGGGGHGGHHHHGHHHHHHHGCGHHHHHHHHHHHHHHHGGGGGHHHHHHHHHGHHGFHFE5BGEEHFGGGHHHHHHHHFBHHGGGGFHGHHFGHHHHGHHHHHHGEGGGGFHFHGEGHHGGCDGDGHGGGDGGHGGCGGGHGHHH/ACDG?.1FGCDCCGCA.CC@CDCHFHGFFGGGEBFGAB//CEFBFGG.:;D;;A0AFFFFFB..:@ABFF//;BFFFFFBF/9D:A// +@M01368:8:000000000-A3GHV:1:1101:18422:19051/1 +GTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACCTACG ++ +CCCCCFDDDDDFGGGGGGGGGGHHHHHHHHHHHHHHHHGHHHHHHFHHHHGGGGHHHHHHHHHGHHHHHHHHHHHHGGHGGHHHHHHHHHHHHHHHHHHHHHHHHHHHGHHHHHGCGGGHHHHHHHHHHHHHHHHHHHHHHGFDHGFHCFGGGGFGGFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;FFFFFFFFFFFFFFFFFFFFFFFFFFFFEFBFFFFFFFFFF:FFF. +@M01368:8:000000000-A3GHV:1:1101:25545:21098/1 +ATTAATTAACACACTTTAGTAAGTATGTTCGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATAAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATGGCTTATTTAAGGGGAACGGGTGGGG ++ +33AA?DFD5BDFGGGFEBDGEGHEGHGEGHCEGGHHCHGHHFFHHGFGAGE53FF2FAFFGDE5FFFE5GFBFGAEE1GHHHGHHHEHE3FGHF@GEGEGGHHGG3FAGFFDE?EEE3GFEGFGFGGCG?GHHHFHGGGC@DHFFHD/AA@AAAAD2ADDFFGGGGGFGGHA?EAEFBEAGHFABFGG5FDF5DB1EEGAFDFB53FF5FH@G5FFEHGHEFHFFHBE333GF43GCGGGGE@0?BFGGB0B?FHGFDGGHHHBFFDEGGHGFFFDFE@<1>@FFFGHHHHFHEFGDABFFGG/@DCE---;--..;.../9 +@M01368:8:000000000-A3GHV:1:1103:25519:6301/1 +AAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGCATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACCTACGTTCAATATTACAGCTGTCTCTTATACACATCTCCGAGCCCACGAGACTAAGGCGAATTTCGT ++ +3A3AAFFFFBFFGGG2CF?4FGHGHHCHGGHHBHGFFAGGHHFFHHCGHFEGCECEGHFFFHGHHGFGHFGDAFDGFFEEFEGGBECC/;>=EF?AEFFFF;9;=DAFFFFBBFFFBFFF//;BFB.:FBFFBB/BFFFF/BFFE?EFAFEF9 +@M01368:8:000000000-A3GHV:1:1104:11928:24197/1 +ACGTAGGTGCGATAAATAATGGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATGTCTTATTTAAGGGGAACGTGTGGGCTATTTAGGTTTTATGACCCTGAAGTAGGAACCAGATGTCGGATA ++ +CDDCCFCFFFBCGGGGGGGGGGHHHGHHHGGGGGHHHHHHHHHHHHHHHHHHGGGGGHHHHGGGHHHGGGGGGHHHGGGGHHGGGGHHHHHHGGGGGGHHHHGGGGGGGHGGGGGGHHHHHHHHHGHHHHGHHGHHHHGGHGEEGGGGFHHFHHHGHGEHHHHHHHHHHHHHHHHHGGGGGGFGGGGGGGGFFGGGFGFGAEFEFGFEAFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF@D9 +@M01368:8:000000000-A3GHV:1:1104:12288:20635/1 +CACTTGGGGGTAGCTAAAGTGAACTGTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGCCGCAGCATCTGTCTTTGATTCCTGCCT ++ +ABA?AFBAB2>AFGGGGFFGD5GGHGFFHGHEGGGGHHHHFFHH5FHGHHHFFHEFHHHHHHGGHHHHHGFHGGHGGGGFHGGGFBHHHFGEGHHHHGHGGGGECEHHFHHGHHFFHFGGGHHHEGHDGHHGHGHFHHHECGCBCHHGFHHFHD1GFHEFHEF?GDCFFEFE0A@;@>BD/9BFBBBBFDFFFF99D=?>DDBFF-AFFEBB9BBEFEFAFFF//-@---;;FBBFBFB///;99999BA9 +@M01368:8:000000000-A3GHV:1:1104:13832:4398/1 +CACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCCTGTCTCTTATACACATCTCCGAGCCCACGAGACTAAGGCGAATCTCGTATGCCGTCTTCTGCTTGACAAAAAAAAACACACAACAACCAACACCCAGTAGACTAGTGCGTC ++ +AAABABCAFFFFGGGGGGGGGGHFHHHHHHHHHGFFHHGGHGGGGGHHHHHHHHHHFHHHHGHHHHHGGHGHGGHGGGGGGGHGFFGGGGDGGHHHHGGGGFGGGGGCFGGEGCDGGGGGGGGGGGGEGF?;BFFFFFFFFFFFFFFFFFF:FFFFFFFFFFFFFFFFFFFFFFF/FFFFFFC.;BFEAFFFFF;@FFBFFFFEF?/FFFFE----:...:...9....9.9...:.9//9////;/9-.- +@M01368:8:000000000-A3GHV:1:1104:23670:4161/1 +ATTCAATTGTTATTATTATGTCCTACAAGCATTAATTAATTAACACACTTTAGTAAGTATGTTCGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCC ++ +AAAABFFFFFFFGGGGGGGCGBBGGHHHHHHHHHGHHHHHHHHHHFGGHHHHHHGGFHHHHHHHGGGGGFHHHGHHHHHGHHHHGHHGGGHGGGGHHHHHGHHHHHHEGGGFHHHGFFDGEGHGHFHGHHGEGGGHHBGHGGHGHGGGGG/@FCDFDGFHGGGDFFHFGFFGGGGGHHHHGGGGGGGEGCDG?GGBFFFEE00BFFGABBBAFGGGEGEA.9FFF/./;BFBF./AAF/BFFBBF/F/BFB +@M01368:8:000000000-A3GHV:1:1104:24927:22253/1 +AGCTAAAGTGAACTGTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTAT ++ +AAA?AFFF3DFFFGGBGFF3EAEEEHFHHFHHHGHHHHDGHHGAEFGHHHGFCHHGHHHBGHHHAEGGHGGFHFBFHHHHHHHHHHFHH1EEHEEHH1FFDEEFCGHBGHHFHEHHHHHH1FCGHHHHEEFGEEGFFCHHH11>GHHF/FG2DGGCGAGGHGGGG@@@BEFFF?@@@FFEFFFFFF?@@FB@BB@FFFE=;==---A9EFBBB/;E;A9B/B/FFFEF/B///;/;9/A/;/9BFFFBFBB +@M01368:8:000000000-A3GHV:1:1104:4705:7727/1 +CTACAAGCATTAATTAATTAACACACTTTAGTAAGTATGTTCGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATGTCTTATTTAAGGG ++ +BBBBBFFBFFFFGGGGGGGGGGHHHGHHHGHHHHH6GHHHHFFGGGHHHHHHHHHHHHHHHGGFGGGEGGGHHHHHHHHHHGHE3FGGGGHHHHHFHHHHHHHHHHHHGGGGGHHFHFCGFHHGGGGGGGHHGGGGHHGGGGGGHHHHGGGADCHHHHGDGGGGGGGGC@DGFHEHHHHHHGHHHHGFGDEGFGFFGGGGCFGBEGFGGGFG;C.BFFFFFFFBFBFFFF/F?.AFFF/BFFEFFFFFEFF +@M01368:8:000000000-A3GHV:1:1104:7756:4776/1 +GGCCCATAACACTTGGGGGTAGCTAAAGTGAACTGTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGA ++ +CCCCCCFFFFFFGGGGGGGEEFHHHHGHGHHHHHHGGHHHGGGGGGHHGHHHHHGHHGHHHGGFHHHHHHHHGHHHFHHGHHGFGGGGHHHHHHHHGHGHFFHFHHHHHHGGHGFGFHHHGHG?FGHHHHHHHHHHHHHHGHGHHGHGGCDGFFHHHHGHHHHHGHHHGFHGHFHGHGHGH/@CABFFFFFFFACAFF?BBFFBFD-@-.D>FFAF.F.:9---;AADFFFFFBEFFF:9FFFFBBFFFF/ +@M01368:8:000000000-A3GHV:1:1105:11310:21761/1 +ATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATGTCTTATTTAAGGGGAACGTGTGGGCTATTTAGGTTTTATGACCCTGAAGTAGGAACCAGATGTCGGATACAGTTCACTTT ++ +CCCCBFFFFFFFGGGGGGGGGGGHHHHHHHHHHHHGHHHHHGGGGGHHHHHGGHHHGGGGGGHHHGGGGHHGGGGHHHHHHGGGGGGHHHHGGGGGGGHGGGGGGHHHHGHHHGHHHGHGHHGHHHHGGHGGG=FFGEHHHHHGHFGGHHGHHHHHFHHHHHHHGGHHHHHHHGHEHHGHHHHHGGGGF9AGE?DEGFFGGGGGGGGGGGGGGFFFF/9FFBFFFFFFFEFFFBFFFFFFFFFFFFEFFF0 +@M01368:8:000000000-A3GHV:1:1105:11578:14676/1 +ATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATGTCTTATTTAAGGGGAACGTGTGGGCTATTTAGGTTTTATGACCCTGAAGTAGGAACCAGATGTC ++ +CDDDDFFFBFFCGGGGGGGGGGHHHHHHHHHHHHGGGGGHHHHHHHHHHHHHHHHHHGGGGGHHHHFGGHHHGGGGGGHHHGGGGHHGGGGHHHHHHGGGGGGHHHHGGGGGGGHGGGGGGHHHHHHHHHHHHHHHHHGHHHHGGGGGGHGGHGHHHHHHH;CHHHHHHHHHHHHHHHGHGGGGFGGGFGGGGGGGGGGGGFGGGEGGFFFFFFFFFFFFFFFFFFFFFFFFF/FFFFFFFFFFFFFFFF0 +@M01368:8:000000000-A3GHV:1:1105:13575:19255/1 +TTAGTAAGTATGTTCGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGTTCCCGTGAGTGGTTAATAGGGTGATAGGCCTGTGATCCATCGTGATGTCTTATTTAAGGGGAACGTGTGGGCTATTTAGGTTTTATG ++ +AA1A1DFFFFFBGG3A111FFAEGDDBGFDHF00F01BBA00BFGEHFBFFA1FABB0FAE?CFHF1BGFHFB0011F121E//>>1F10>B?EFHGCC/?/BFG/EEGFFEE//BCFDE0?E@@B/?11AAFFFFFEAGGGFGGAA6FHDGGCGFHFFHFHFHHHHHGDDDFFFHGFFHGBEGEGHHHFFFHGEEAEGHHHHHFHHHFHGHFEDGGEGBEAGEFHHFFHHHHHHGGHHHGHHGBGHHFHHFGHHHHG?CG?AFHH1FHHHGHFHHHF?DGHFFHCGAGEFHGCBBBB?BFFF?B-B.9/BFFFFFB=-AD?..@FFFF@@-@@?AFD.FFFBBEEBD9/:FFFFFBB/:FF9BF/BF.BBFF/: +@M01368:8:000000000-A3GHV:1:1105:21099:2895/1 +TAGCTAAAGTGAACTGTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTT ++ +CBCBBFFFFFFFGGGGGGGGGGGGGFHHHHFHGHHHHHHFHHHHFGFHHHHHHGHHHHHHGHHEHGGGGHHHHHHHHHHHHHHHHHHHHHHGGHGGHHHHHHHHFHHHHGHGHHHGGHHHHHGGHFFGHGCGGGHGHHGHHHFGHHFHH/FGGGHFGFEGGCFCCD;B@DFFFFFFFFFFFFFFFFFFFFFFFFF;F.BEFADFFFF.AEFFFFFFE;D.;:B00099:09BFBFFBFF.0:000BFFBF0 +@M01368:8:000000000-A3GHV:1:1105:26469:19245/1 +TTATGATTATGTCCTACAAGCATTAATTAATTAACACACTTTAGTAAGTATGTTCGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCAAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATG ++ +BAAAAFFFBFFFGGGGGGFFGGHHHHHHHHHHHHGGHHGHHHGGHHHHHHHHHHHDEGGHGHHHHHGEDHFHGFHGGHHGGHGGEHHHGHHGHHGHHHGGEGGGHGHGHHHHHHGHHHHGHGGGGGHFHGGGGHHGGGGCDGHHHGD>A@FFFFFFFGGGFEECFGGFFB5GBHH5DFH5GBEEAEFHFHHF3F3GHFHHHEF3GAEHBGFHFFEFFHHHHFFB31FGGEGFHGEHHHHHHHHHHHHHHHHHEEEEGHHHFFF3GF3FGF44BBGEHHHHGG2B/BGGHE;B=.9.;.BBFFF..;A;/B/;B//;;//BBF/ +@M01368:8:000000000-A3GHV:1:1106:22927:3863/1 +GTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGACTTCTGTCTCTTATACACATCTCCGAGCCCACGAGACTAA ++ +A>ABAFA?D@AFGGGGFGGGFGFHHHFFH4BCBGHHHHGFFF3G5BF3322EEAFHHHHHHAB5GHFHEHFHHH3BEEHFGF5@13FDF3GDGFHHFGHHHGHHHGFGGHHFCG//?/EGHHHG3F4BFFGHHHEDGFHHB/B/?FBF<@-9?BDEFFF?B--?DFFFB9FA>B;A.BFDB?AB.--@;-.FFAEFFFF9AE;DDFFFFB/9BFFFFFFFB:BF/BB/BFF//FFF-=--.99=--.9/// +@M01368:8:000000000-A3GHV:1:1106:23625:4236/1 +TAGCTAAAGTGAACTGTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTA ++ +@?AAAFFBFBFFFGGFGFGGGEFCGGHHHHFGHGHFHGHHHHGGFGGFGHHGHGHHHHGHGFFHHGGGGGHHHHHHHHHBFHHEFHHHHHHGF?FAGHGFHHHGDGFHHGGGHGHFHHHGHHHGHHFHHGFFGFHHHGHHHHFFHHHHH/FGHHHHGHGHGDFFFE?FFF/--;;9/:BFFFBA///9----;B.//////;...---9--- +@M01368:8:000000000-A3GHV:1:1106:6455:17124/1 +GTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACCTACG ++ +BBBAAFABDBBFGGGGGGGGGGHHHGHHGHHHHHHHHHGHHGHHGHHHGHGGGEGHHHHHHHHHHHHHGHHHGHHHGGHGGHHHHHHHHHHHHHHHHHHGHHHHHHHHGHHHHHGGCFEHHHGFHHHHGHHFFH?GGHHHHGHGHGHHCFGGGGGGGFFFFFFFFFFFFFFFFFFFFADFA?.FEFAFFFEFFFFFFFFFFFFDABFBBFFFFFFFFEFFBFFFFFFFFFFF/FFBFFFFFFADE>BFFF9 +@M01368:8:000000000-A3GHV:1:1107:14451:26748/1 +GTATGTTCGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATGTCTTATTTAAGGGGAACGTGTGGGCTATTTAGGTTTTATGACCCTGA ++ +BABBBFFDABBBGGGGGGGGGGHGHHHHGAGHGGGGGHHHHHHHHGHHHHHGGGGGGFFHHHHHHHHHFHHHHHGGGGCHFHH3FEHHGCGGGDGHHHGFGGHHGGGGHHHHHHG/DGGGHHHHGGGGGCCHGG?CGG1GHHGHHHHBGHHHFHHGHHHHGGADAD00ECEGHEFHHFFAEFFFFFGGFBFBFFFGFFG.;B/99;BCFGGGGEFFFFFFEDA./:ADEB?FBFFFF;FFEBFBFFB./9. +@M01368:8:000000000-A3GHV:1:1107:18714:24788/1 +GTATGTTCGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATGTCTTATTTAAGGGGAACGTGTGGGCTATTTAGGTTTTATGACCCTGA ++ +BBBCCFFFDEDEGGGGGGGGGGHHHHHHGGHHGGHGGHHHHHHHHHHHHHHGGGGGHHHHHHHHHHHHHHHHHHGGGGGHHHHCFGHHHGGGGGGHHHGGGGHHGGGGHHHHHHGGGGGGHHHHGGGGGGGHGGGGGGHHHHHGHHHHHHHHHHHGHHHHGGEGEGCCEGGHHHHHHG:CAFFGGGGGGBFEFGGGGHGAFFGGFGGGGGGGEFFFFFFFFFEF/EDDFFFFFFFFFBFFFFFBBFFBBF/ +@M01368:8:000000000-A3GHV:1:1107:21355:8333/1 +ATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATGTCTTATTTAAGGGGAACGTGTGGGCTATTTAGGTTTTATGACCCTGAAGTAGGAACCAGATG ++ +ABCBBFFFFFAFGGGGGGGGGGHHHHHHHHFHHHHHGGGGGHHHHHHFHHHGHHHHHHHGGGGGHHHHFFGHGHGGGGGGGHGGEGGGHGGGGHHHHHHGGGGGGHHHHGGGGGGGHGGGGGGHGHHHFHHHHHHHHGHFFHHHHGGHGEGHHGHGFHHFHGHCEFHEGHGHHHGHHHGGGGGGCFFFFBFGGFGGGGFBG?FDGGGEGFFFFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBFF.AA/9 +@M01368:8:000000000-A3GHV:1:1107:22864:15712/1 +AATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACCTACGTTCAATATTACCTGTCTCTTATACACATCTCCGAGCCCACGAGACTAAGGCGAATCTCGTATG ++ +BBBBBFBBFFFFGGGGCEGGGGHGHHDGFHHHHHHHHHHHHHCHHGHFGBGDFGE?GHHGHFBHHFHHHHHHHHHGHFGFGHGHHGGC@DCFGHHGGGGGGGHHHHHHGGGGGFGGGGFFGGGGFADGFEFFFFFFFFFFF9;FFFF/BFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFEAECDFFFFFFFFFBFFFFFFFFFFFFFFEFBFBFFF/FFFDF-;-9;E@>-9DFFF/FFBF;-.:;.9A// +@M01368:8:000000000-A3GHV:1:1107:24817:14233/1 +CTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACCTACGTTCAATATTACAGGCGAACAT ++ +3AABABFFBFFFGCFGGGGGGGHHHFGCFGGGFFGHHCGHHHGHGHGHBFFHHHEDGGFGFGHHFFFHGGEGHFHHGHFHGFFHHHFGHHHFHACECEHHHBGFHGFHHHFHHF4GFHFHFHEHGGE/EG:A-CFGGFGADGGGGFGGGGDAAAADFA.-AFFECFDAAFFFFEFFFFBFF;D;BFFFB/;BFFFFFFFFFFFFFFBFFBF/;//;BFFFF?FFFFFFEDAFFFFFBF//:BFBACF--9/ +@M01368:8:000000000-A3GHV:1:1107:24830:14440/1 +AACTGTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACC ++ +ABBBA@FFFFBBGGGGGGGGGGHGHHGHHGHHHGGHHHHHGHGHHGDHHHHHHAGGGGFHHGHHHHHHGHHHHHHHHHHHEGAFGFHFHHHHGEGHHHHHHHHHHHHHHHHHGGHHHGEFEGGHHGHHHHHGGHGFHH/?GHHHHGFGHGFHCGGBBDAFFFEFFFFFFFFFFFFFF=CDDADDFFFFEF=BFFFEFFFBFFFFEEBF./:FFFFFFFFFFFFFFFFFFFEFFFFFFFFFFF/BFBEFFC- +@M01368:8:000000000-A3GHV:1:1107:26478:23602/1 +GCTAAAGTGAACTGTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATCTGTCTCTTATACACCTCTC ++ +1AAAAF1B13BBBEGGGFGGGGGGHHDB1BGFHHHFGFGGG0F00BGBGFGGF1GBGB1BGCGAEE/FGFHGHFHHHHHBFF1B0FGGF//F//FGFGFFF/1@B1DFHHHGGEFEDHFDFAFF0B//1FDD1GFFHHDF?1BD>GF/GCAC0C@?@-;99BBB->@--;-B//99B--9-BF=A--A-:A----9AA9AFBFBBB?E@BBFFFFFFFBFFFFFBFFFBBFFF//B/////-;9 +@M01368:8:000000000-A3GHV:1:1108:11059:23181/1 +GTTATTATTATGTCCTACAAGCATTAATTAATTAACACACTTTAGTAAGTATGTTCGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGAT ++ +CCCCCFFFFFFFGGGGGGGGGGGHHHHHHHHHHHHHHHHGHHHHHHHHHHHHHGHHGGGGHIIIHHHHHHHGHHHHGHHHGGHGGHHHHHHHHHHHHHHGGGGGHHGHHHHHHHHHHHHHHHGGGGGHHHHHFGHHHGGGGGGHHHGGGGGHGGGGHHHHHHGGGGGGHGGHEFGGGGGHGGG-ECHHHGGGGGGGGGFGFFGGGGFGGGCF?EFGG0;BFFFFB?9AAFFFFFFBF;BBFFBFFFFE?F/ +@M01368:8:000000000-A3GHV:1:1108:12233:13498/1 +TAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATGTCTTATTTAAGGGGAACGTGTGGGCTATTTAGGTTTTATGACCCTGAAGTAGGAACCCTGTCTCTTATACAC ++ +BCCBAFFBCCCCGGGGGGGGGGHHHHGGGGGHHHHHHGHGHBGFHHHHHGGGGGHHGGBFGHHGGGGGGGHHHGGGGHHGGGFHHHHHHGGGGGGHGHHGGGGGGGGGGGGGGHHHHFHHHGHGHHHHHHGHGHHGGFGGGDFFGGHHHGHGH/FHHHFHGHGHHGHHHGHHBAAAA3BDFFFFDGBFFEEGGGGHHGHFHHCFHGHGHHHGF3BFGFHGFEFHFHGH3EGFC1EEGBFGBHFGGFFHHHGHFHGHHGHGGHCEHEBCFF3ED3@GH4FDEG12FFHFFHG/G3FGA/@EFEFCG33FFGBBGHFHH/?BFBGFGFAGC2C/@-;@-;BFFEFADF?DFFFFFF?;AFFA;AD;..FEFFA--;9;D.9BFFBE?;.;///://///99//BB/9;F./B//BBFB9////99/ +@M01368:8:000000000-A3GHV:1:1109:25237:11722/1 +CCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATGCTGTCTCTTATACACATCTCCGAGCCCACGAGACTAAGGCGAATATCGTATGCCGT ++ +AABBBFFFFFBBF5BGGFGABGHGGAEFGFHHHHFHCHFHHBFGGGEHBGGHFFFFGFAEF5FHH?EGGF5AEG3?EBFHD?C/EFHFFEGEE?CFGGGHHFHB3EEFG?EEGHCFGGGGGGGECA?FFFDFBFGCG4EGFG??GACFGGHFHCFHCHBECDEFCEGHHHHHFFGGF3AFFHHFGEGCGHHGEHGFGHHEGG?EFHHH?EGGHHGGGGHHHHHHEGGGGGHFHHGFDDGGACFCC@?/FDDGHHHGHEFFHHH0FDHHFFEDCD.CFHHGDFGGGGGEFGC?EGHHHB0CGHHGCGHHHHBEHGHH.::ACA;FECFGGGGGFFFEFGGGGGGGFFBBBFGBFFFEFFFFBFFFFFFBBFBFFB9..AF?FFFFFFF9 +@M01368:8:000000000-A3GHV:1:1110:14751:26540/1 +TAACACTTGGGGGTAGCTAAAGTGAACTGTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACTGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGTTGTGCACGCGATAGCATTGCGCGACGCTGGCGCCGGCGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTG ++ +AAA?1CFFFFADGEEGFGB1112DGDGHGFGHHCG/ECEBGGHDFGHHFHGHEB1BCGFFE2EGHHGHFFFHHBFFHEFCGGHHFHHHHH111BFFHGHEHBEHGGECEFHGFHFGGDBBGHHBHHHH0GH22FGHGFFFH1BFCG0F@FGG11@GDHFG1D/1FGFHH/FCG.>0><-<@CCFFG.CC-@C?C9FFF0C---;------;9----9-9@-AAFF9B9---9-/;B9BF/9BB//B/;/// +@M01368:8:000000000-A3GHV:1:1110:15519:10008/1 +CTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATGTCTTATTTAAGGGGAACGTGTGGGCTATTTAGGTTTTATGACCCTGAAGTAGGAACC ++ +BBBBBFFFFFFFGGGGGGCBGGE?GGGHHHHHGHHBEGGHHGGGGGHHHHHHHHHHHGGHHHHGFGGGGHGHGCFGHHHGGGCGGHGHGGGGGHFGGGHHHHHHGCEFGGHHHHGGGGGGGHGG/CEGHHHHGFHHHGFHHGFFHGHGHFGGEGFDDGGBCGHHGFHH/CHHHHGHGHF0CFGGGGGGGFFFFFBFFFFFFGFFGGF?DGEDEEFEFFFF?FFFFFFFFFFFFFFFBFFF.BFFFBFBBA; +@M01368:8:000000000-A3GHV:1:1110:16559:7507/1 +CATTCAATTGTTATTATTATGTCCTACAAGCATTAATTAATTAACACACTTTAGTAAGTATGTTCGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAACTGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATC ++ +ABBBAFFFFFFFFGGGGGGGFGGGGAGHHGCHHGHHHHHHHHHHHGHHGHHHHHHHHHHHHHHHHFGGGHHHHHHHHBDHHHHHGGHFEEGHGGHHHHHHHGHHHEHFGGGGGGHHHF33FGHHG3GDDGH//EEGHHFFBF?GHHFCC@DGFCGGB?DGHAFGGHHGFH0E??<@DGHGGCFGGF?DGGGFFGGGGGGGG.C/0BBF?FBBEGG0FFF.AA9;B9/E////99;;:.//:FFFFBBF//9 +@M01368:8:000000000-A3GHV:1:1110:16700:6843/1 +AAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATGTCTTATTTAAGGGGAACGTGTGGGCTATTTAGGTTTTATGACCCTGAAGTAGGAACCTGTCTCTTATACACATCTCCGAGCC ++ +BBBBBFFFFFFFGGGGGGGGGGHHHHGHHHHHHHHHHHHGGGGGHHHHHGGHGHGGGGGGHHHGFFGHHGGGGHHHHHHCGG@FGHFHFEGGGGGGHGGGGDGHHHHHHHHHHHHHHGHHGHGHHGGGGGCGHEHGHHHFHHHFF.DGHHHHHHGHHHHHHGFGHGCGHGHHHHHHHHGHHHCD?:A::FCDGEGFGFFBFGBFGGGF00CBFFFF/BFBFFFFAE.FBBFBFFFFB/BFFBFFF/ADCAD +@M01368:8:000000000-A3GHV:1:1110:18014:7856/1 +ATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGGGATAGACCTGTGATCCATCGTGATGCTGTCTCTTATACACATCTCCGAGCCCACGAGACTAAGGCGAATCTCGTATGCCGTCTTCTGCTTGCAAAAAAAAAATAG ++ +AABBBFFFFFFFCGGGCGGGGGGHHHHHGFHHHHHHGHHHGGGGGFHHGHFGGHHHGGFGGGHHGGGGGHHGGGGHGGHHHGGGGGGHHGHGDGGGGGGGGB/A99FE//BBFFF.9/FF?DA=@9./9 +@M01368:8:000000000-A3GHV:1:1110:23303:11846/1 +ACTTGGGGGTAGCTAAAGTGAACTGTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGTGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTC ++ +3ABB?FAB?DAAGGGFBGGBB5AFFFGFHHGGGEGHHHFHHF3EGFHHHHEFHHGGHHHGH3EFHHHHHBDGHHE?ECHGHGHHHHHHFHHHGHHHHHHHGGHGGFHHHFHHGFFHHFEGFHHHHHHEHHFDAGHHHH/BDDFGGH1FDBGHHHHHHHCGHHHFH?0CGCF>CC=@--AFBFFB?=BFDFFF//FDB;-9A-AD-.A.A=?-9-:B/AEB/BFF.A;DDFFFBBFFFF/BBFFFFBFF9B; +@M01368:8:000000000-A3GHV:1:1111:13195:14562/1 +ATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATGTCTTATTTAAGGGGAACGTGTGGGCTATTTAGGTTTTATGACCCTGAAGTAGGAACCAGATGTCGGATACCTGTCTCTTATACACATCTCCGAGCCCACGAGA ++ +ABAAAFFFFFFFGGGGGGGGGGGHHGG4FDFGFGGCGGGHGHG?EGHEGFFDHFHHHHGGFE@EHHGEEEGFCCEFFGFG/EHHHHHBFBGGHFHFHEHGHEFGGGED/EFDEFFEHHBGHHCFFFDFGGHHGFFFHHHHGFG>0<0DGGFHBGHFBDFGHGFFGGAGHHGCGBHFFHHHFFFBFGGGGF/:FFFCB9F9FF0FEFE?FF0BED-D.//BF9//BBFF/BFFFEFFFFED-DCFF?.:BFA +@M01368:8:000000000-A3GHV:1:1111:14287:20817/1 +GCCAACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTCATCGCACCTACGTTCACTATTACAGGCGAACATACTTATTAAAGTGTGTTAATTAAT ++ +>>A3>AAAACFFFGFGFGGGGGHGHHHHHHHGGGGGHGHFFCGHHGBGHFHHHHAGHHHHEHHAGFFEHEAE?GHHHHEGFFFDGHGHBFFHFHHHGHGHGHBECG@@@EHGGEGCGGGGFFGGGG?BGGGGGG.-C.FEDCFFFEFFFAF/99BEFA.:9BFB/9FFFEFFFFFFEFFF/FBBFFFFFFFFFFFB//;.@@//;DFFFF//BBFFFBF;A;DF=>B//;9B//B/;/;9//9//;B/:B9 +@M01368:8:000000000-A3GHV:1:1111:23624:14516/1 +GTCCTACAAGCATTAATTAATTAACACACTTTAGTAAGTATGTTCGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGGGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATGTCTTATTTAG ++ +3>3AAFFFFFAFGGGGGGGGBGHHHHHHGGHGGHEHGHADFHHHHEGGGHBGHFFHHEHHGHFHGG5FBEEGEGHHHGHHHEFDGHHFFGFGGHHGHHHGHBHGHFHFHHGGGGFCFBGFGE?GFBECEGDGHEHGDGCGHGC/DF@GHGFFCGGGGFFFFDD?@C@GFEC?-ADHFFHBGHFBHFG0CC//.;B0/CA.;AA.;@.AB/9BB/A/.AFFFE/BFFF///9B/FBDE9/;99/B/BFFEF/ +@M01368:8:000000000-A3GHV:1:1111:7437:24508/1 +ACACACTTTAGTAAGTATGTTCGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATGTCTGTCTCTTATACACATCTCCGAGCCCACGAG ++ +CBCCDCFFFFFFGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHGGGFFEHGGHHHHHHHHHHHGHHGGGGGHHHHHHFHHHHGHHHHGHGGGGGHHHHHGGHHHGGGGGGHHHGGGGHHGGGGHHHHHHGGGGGGHGHHGGGGGGGHGGGGGCGHHHHGHHGHHHHHHHEDHHGHGGGGGD;BEGGGFFGGGGC:CFGGGGGGGGGFGGGFFFGFFFFF;FFF;BFFFFFFFFFFFB:FFFFD=CAEEEF>- +@M01368:8:000000000-A3GHV:1:1111:8665:25542/1 +TCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTGTCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACCTACGTTCAATATTACAGGCG ++ +AA3AAFFFFFFFGGGFGFFGGGGHGH4AGGGFHHCGEE2FGHHHHHHHHHHGFHGF53FHEGGFAF5CFHHGGFGHFHHGGHHHCHHHHHHHFHHGH?EEEG1FFFEHHFHFGGHHGG?F4FBGHGHCHEF0//-9--;0CFGG?@BGDGFFFFEFBBBDA?FFBFFFF=B;-9.AA9EFFFF/;9BD.//;9/9/B:/:BFBFFBFFF/B:BFF//;/B/FFFBFF.A-BFFFBA/F//BFFFBF/;/A- +@M01368:8:000000000-A3GHV:1:1111:9655:13916/1 +GGCCCATAACACTTGGGGGTAGCTAAAGTGAACTGTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGCGGTGTCCACGCAATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGA ++ +1>>1AAFFFFFBGGFE1EEEEGGHGHHH2FGHHHFGFGHGCFGGGEFHGGEGGHHHHGHEFBFEGHHHGHHBEHHHHGHGFHHHGGGGHHEGGGGHHHGFHGHHHH1FHHG?G/AGF1GBFGEFFHF2FDD0FG--99@=---AAABA-BF/B?A@F-9BBFF//BB/9/ +@M01368:8:000000000-A3GHV:1:1112:10272:7828/1 +GTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCTGTCTCTTATACACATCTCCGAGCCCACGAGACTAAGGCGAATCTCGTATGCCGTCTT ++ +AAABABBBBBBFGGGGGGGGGGHGHHGHGHHHHHHHHHGHHHGGHDGHHHGGGGHHHHHHHHHHHHHHHFHGHHHHGGHGGHHHFHHHHHCGHFFHHHHHHHHHHHHHGHGEFGAEEEEHHGHHGHGHHHHHHHGHHHHHHGHGHFFBC/BA?BGGGFFFFFFFFFFFFFFFC-@DDFFFFFFFEFAFFFFFFBFBFFFFFFFFFFFFFFFFBFF->@FFFFFFFFFFBFBFAD--.99;A?////:.9A. +@M01368:8:000000000-A3GHV:1:1112:9832:16531/1 +CTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGGGCTGTCTTATTTAAGGGGAACGTGTGGGCTATTTAGGTTTTATGACCTTGAAGTAGGAACC ++ +AABABFFFFFFFF4GGGGEBGEFGHGGHGHGHHHGGHFBGFGGGGGHHEFHGEHFHFHEHHHHHGCGGGHFHHCFGHE@1EEEFFGB?EEEEHBGGGCHHGHHBEE@>EAHHFAEBDGGGCEFF?CEGFFHHHHHFHHHFHGHCGCAHHF<..C.D=0CD.GFHHHG.CAGHC:CHB0GGGFFB0:CFA.A-;9.;000CBBFFBFGA.9AA;A;EDDE.ABBFFFF9;BEFFF/BF//9/B//9:B//.. +@M01368:8:000000000-A3GHV:1:1112:9832:6701/1 +CGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATGTCTTATTTAAGGGGAACGTGTGGGCTATTTAGGTTTTATGACCCTGAAGTAGGA ++ +AABBBBFFFFFFGGGFGGGGGGHHHGGHGGHHHHHHHHHHHGHHGGGGGHHHHHHHHHHHHHHHHHHGGCGDHHHHFGGHHHGGGGGFGGHGGGGHHGGGGHHHHHHGGGGGGHHGGGGDGGFGHGGFCDCHHHHGHHHHGHHFAGFGGEHFGEG.C1>11F1D1DDFFFFGGG1FH3GHGHGHGHFHEC?EC0B1FBGFB1GHHH21AF2HH2FEGEHAE10AAE/>/FFHE?/E/?E1@EFFH?E@/EGGG//B11B//<@@C0F/<0AAAAFFFBFFFGGGGGGGGGGHHFHGHHHHGHHHHHHHHHHHGGGGHHHHFHHHHFHGHHHHGAFFEFHEGHHHHHHHHGHEHHGGFGGGHHHHHHFHHHHHGGHHHHGGGGGHFHHFF?HHGGFECEFFGHFFGFHGECDGHGBGFHGDF@@?CGFHCEGGGFD.CCC?EGHBHHHFHHFBCFFGEB/CEGGGGDAA.90C9CEBFGGBBF/9.9FBFFFBBFF//99FFFFEABF//99FFEFFFBFF +@M01368:8:000000000-A3GHV:1:1113:5741:16959/1 +TAGTAAGTATGTTCGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATGTCTTATTTAAGGGGAACGTGTGGGCTATTTAGGTTTTATGA ++ +ABBBBFFFFFFFGGGFGGGGGGHHHGHHGGHBGHGAGFFCAFGHGFFGHHGFHHHHHGGGGGHGHHHHHHHHE3BFFHHHGG0EDF@GHFFGGGHGGGGGGGGGGGGGHHGGEEFHGFHHDDG@DGGGHHGDGGGGGHGG?CF?HHGHHHGHGHHHFFHGGGHHHHGGCD.;0A33>FFFFFF@FFFGGGGFGGD4EGGGGGHHGFFGHFGGHHHFEFHECFHHHEHGAGBCCGCCEGGHGHEGFBFHFHHHHGGGHFHGHEGGGFEGEGG??@DBGHGGC-@FFGHFHFHB-??DA-DD@9:BEBG@B?E?A.ABBFBFA??F.FF/BFFB/B9B/9;BF9FF9FFFFFFFFFFFFFF?BB?;9EE;-;DDB9//;B-B@;ABFFEFFFF/-.9A.;//9/BF./B/..9.9:...////// +@M01368:8:000000000-A3GHV:1:1114:14540:5315/1 +CTTTAGTAAGTATGTTCGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATGTCTTATTTAAGGGGAACGTGGGGGCTATTTAGGTTTTT ++ +AABCCFFFFFFFGGGGGGGGGGHHHHHHHFHHHHGHHGHHGGGHGGHHHHHHHGHHHHHHGGGGGHHFHHHFGHHGGFHHHHHGGGGGHHHGHGGHHHGGGGGGHGHGGGGHHGGGGHHHHHEGDDFGFFFHHGGGGGCDAFCFGFDHHHHGGHGHHHHHHBCGEHHHHGGHG.ACGEHGG0CBFFF:A;BB0;09CGF00CFFFE0AA?//CFFFFFFFFFFFFFFFBEF;A.-=A--:BBFB90;;FE. +@M01368:8:000000000-A3GHV:1:1114:15066:16302/1 +TAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACCTACGTTCAATATTACAGGCGAACATACTTACTAACGGTTGTTAATTAATTATTGCTTGTAGGACA ++ +BBBBAFFBDFBFBGGGGGFGGGBGFFFHGFHHGFFFHGHHHGHHHHFFHHHGHGC?AEFFHEFBFFFGHHHHH1FDGFFHGHGHFEGCGC-<>ABFFFFFFGGCGC1BBF1GHHHBHHHHGFHGH1A100AA/GGEHGFBAA1FFD2FHHHHECG2F1BB/E0FC/A>EE/FGGFGEF1EGBBEHHCGGGHBGEHFHE0B?E--;C?CCGGG@A@GBFBBBB09?@??A-AB--ABE@=-=-9AE9A;FFFFFE=9-//;//;9FF/////;;///9B///;/B////9FFBB;--A@-;/9;9-:-/;;FFFE9BF?@;-9-99/B9F/://///99/; +@M01368:8:000000000-A3GHV:1:1114:2404:13066/1 +TCCTACAAGCATTAATTAATTAACACACTTTAGTAAGTATGTTCGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCTGTCTATTATACACATC ++ +CCCCCFFFFCFFGGGGGGGGGGHHHHHGHHHHHHHHHFFHHHHHGGGGHHHHHHHHFHHHHHHFGGHHGGHGGHHHHHHGHHFHHHHGGGGGGHHHHHHGHHHHHHHHHHGGGGGGGHH?FGHHHGGGGGGHHGGFGGHHGGGGHHHHHFGGGGFGHGHHGGGGGGGHGGGEGGHHGHHHHHHHHHGFBFFDA0FGGGFFGG0:EFGGGGGGGG;AEBF0B0BFFBFFFFFFFFFFFFFFFFFFFFFEFF0 +@M01368:8:000000000-A3GHV:1:1114:9184:6959/1 +GGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATGTCTTATTTAAGGGGAACGTGTGGGCTATTTAGGTTTTATGACCCTGAAGTAGGAACCAGATGTCGGATACAGTTCACTTTCTGTCTCTTA ++ +AABBBFFFCCCBFGGGGGGGGGHHHHHHHHGGGGGGHHHG3FFHHHFGFGGGHHHGGGEHHGGGGHHHHHHGGGGGGHGHGGGGGGGDEGGGGEGGFHHHHHHHHHHHHGGGFGEHHGGFDGGGDFFGFHHHHGFCFHHHHHEFHFHGGFFGHHGGGHHHHDGHHHFHHHFFFFGFGGG.EFGGGGFGEBFGGGFGFGGGGFFBFGGBBFFFFFB/FEFF?///;A::AABBFFFBFFFFFFFFFBFFFF/ diff -r aceaf1d94d2d -r 2a6cfe8997aa test-data/bowtie2-fq2.fq --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test-data/bowtie2-fq2.fq Thu Dec 04 12:58:42 2014 -0500 @@ -0,0 +1,400 @@ +@M01368:8:000000000-A3GHV:1:1101:6911:8255/2 +TCGCCTTACCGCTACTCACCCACGGCGGCCATCAGCCGATACTAAGTTTGGGGTATGGTGGGGGGGATAATGAATTAGGTTGTGGGGGAGGGTTTGTGGTTGAGAGAAACACAAAAAACAATCTTATATATGGGTAGTCGTTTTGTATTGGTTTTTTGTTTTGTTTGTGTTTTGAGTGTCGGTTTAGTTCGGTGTACTAGGGGGGGTGGATGGGGTCGGCTGGTGAGGGGGTCTTAGTGTATTGAGTGTGG ++ +1>11111@11111A111A100000000////011110//>>/12@1@22B/////1@>21/>>/-----9/;////9////--;-;-;-----;--------9/-/-///9-;-------9//////9/////-//-/9-;-;9--/////99-;--9-:-;----/---/-----////---9-/////--;A-//////---------9/-----;-----/-/-----;--;//////////9;///- +@M01368:8:000000000-A3GHV:1:1101:14518:9998/2 +CATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACCTACGTTCAATATTACAGGCGAACATACTTACTAAAGTGTGTTAATTAATTAATGCTTGTAGGACATAATAATAA ++ +CCCCCFCCCCCFGGGGGGGGGGHHHHHHHHHHHHHHHHGFHHHHGGGGGHGFHHHHHHHHHHHHHHHHHHHGHGGEHGGGGCGGGHHGGCGGGGGHHGHHHGGGGGGGG.BFFFGAGADFGAFDGFGGCFFF;DDFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFBFFFFFFFFFFFFFFFFFFF09FFFE00;BE@;DABBFFFFFBBFB00;F:9;FFBFFF9BFFFFFFFFFFFFF90/::BFFFBF0 +@M01368:8:000000000-A3GHV:1:1101:18422:19051/2 +CTACAAGCATTAATTAATTAACACACTTTAGTAAGTATGTTCGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGGGATAGACCTGTGATCCATCGTGATGTCTTATTTAAGGG ++ +BCCCCFFCFFFFGGGGGGGGGGHHHGHHHHHHHHHHHHHHHHGGGGHHHHHHHHEHHHHHHHGGHHGGHGGHHHHHHHGHGGHHHGGGGGHGHHHHGGGHFHFHHHHHGGGGGHBFFCGDHHHGGGGGGHGGGGGGHHGCGGGFGHHBGGGGGFFFHEGGGGGCDCCE@EFGHHHHFHEGHGFFHHGB;ECBFGGGEFEFFGF0AFGFGFFG.;;DFFFFFFFFFF090BFFFE?FEFBBFBFFFB990BF +@M01368:8:000000000-A3GHV:1:1101:25545:21098/2 +GCCCATAACACTTGGGGGTAGCTAAAGTGAACTGTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTTCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCAACCTATGTCGCAGTATCTGTCTTTGAT ++ +3AAA34BFFFFFGCGGCGGGCGHHHGHHHHCGHFGHFHGFGGCDGGBD5FGFFFHFHGGGHAEBFGHHHEHGGFHBGGFHHHGGGEEFHHHFHFFHDHGHGHHHHFFHHGGFAEGFFFFFBGHHHFFHHHHHHHFHFHHFHGFHGHGA/<@EFHEHH1GGHFFFHG1>=FGHFHGF.GE//-AADEBGGGGFFCGGHHA5DFGAE?AAEDFHG2AEE1FBE00A1BGE0?E1FFGEEEGB4F43?EE/>///F??//@BCBAC<<.<<AABBFFCFFFGGGFGGGGGGGGHHHHHHHHHHHHHHHHHHGHHHGGEGGFFHHHHHHGHGHGHHHHHEHFHGHHHHEFHHGHGGGGGHHHHGHHHHHHHHHGFGHHHHHGHGHGHHGGGCCGGGGFGGGGGGDGGGGFGDGGGFFFFFFEFFFFFFFBAF:9AF//;BEF-DD/FFFFBFFFFFFFFFEBFF?FB;/;//BFFEFFE/::..9;-:B9:FBFFFFFFBFB/9/FFF/B///99/:B/// +@M01368:8:000000000-A3GHV:1:1102:17584:10050/2 +GTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATCTGTCTCTTATACACATCTGACGCTGCCGACGAGCGATCTAGTGGAGATCTTGGGGGGTGG ++ +ABCCCFFFFFCFGGGGGGGGGGGGGGHHHHHHHHHHHHHHHHGHHHFHGGHGGHHHHHHHHHHHHHHGHHHGGHHHHHHHGGHHHHGGGGGHHHHHHHHHHHHHHGGHHHHHHGHGHGGHGGFGGGGGGGGGGFGGFGGGGGGGGGFFFFFFFFFFEFFCFAAFEFEFFFFFFFCFDFFFFFFEFFFFFFFFFFBFFFFFFF/:BFFFFFFFFFFFFFFFFAFC=@-.;A///B././//////.-9---- +@M01368:8:000000000-A3GHV:1:1102:18842:24844/2 +CTACAAGCATTAATTAATTAACACACTTTAGTAAGTATGTTCGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATGTCTTATTTAAGGG ++ +CCCCBFFBFFFFGGGGGGGGGGHHHGHHHHHHHHHHHHHHHHGGGGHHHHHHHHFHHHHHGHGHHHGGHGGHHHHGHHHHHHGHHGGGGGHFHHHFGHHHHHHHHHHHGGGGGHHHGFECGGHGGGGGGHHHGGGGHHGGGGHHHHHEFDCADGHHHHGGGGFC?AE-@DDFHFFHHHCFHGGFFGFFFGGGEFEGFGED9C?CEGF90FEF/A./BBF9FFFFFFFFBFFF.9AF////;FFBFFB/:BF +@M01368:8:000000000-A3GHV:1:1102:21788:11027/2 +AATTAACACACTTTAGTAAGTATGTTCGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATGTCTTATTTAAGGGGAACGTGTGGGCCTG ++ +CDDDDFFFFDDFGGGGGGGGGGHHHHHGGGGHHHHHHHHGHHHHHHHGGHHGEHGGHHHHHHHHHHHHHHGGGGEHHHHHHHHHHFFFFFHHHGGGGGHFHGBFEHHHGGGGGGGHHGGGGHGGGGGHHFHHHGGG@CGHHHGGGGGGGGGGGEGDGFFDHHGEHHBCFHGBGFAGGHFGGCEEF0BE///FDFACF?FHFGC//??1B0<FF>DFCFDFFFFFFFFF-BBAFFFFFFFFE@D9B;FBFFFFFFFFB9/9FFFEBF9/B/BB/BFAADDFFC-;;9-;@@9-.9/://///://///...- +@M01368:8:000000000-A3GHV:1:1103:25465:20010/2 +AACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGTGCACCCTATGTCCTGTCTCTTATACACATCTGACGCTGCCGACGAGCGATCTAGTGTAGGTCTTGGTGGTCGTCCTCGTATTTGAACACATAATCGTG ++ +AAABBFFFFFDFGGGGGGGGGGHHHHHHGHHHGFHHHHHHHGGGGGHHHHHGHHHHHHHHEHHHHHGHGGHHGGGHHHHGGGGGHHHHHEHFGEHHHEE14BGHHHGHGHFCE/EFGGGGGGHGGGGGG?FFGGGG.ADGGGFFDA.FFEC--;9BBBD?FFFFFFFFBBFFFFFFFFFFFFFFFFFADFDFFC-BBB;BF-.;9:B9B9/9/;9;//;:.99/;-...:.../;//////.9/////.;. +@M01368:8:000000000-A3GHV:1:1103:25519:6301/2 +CTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATGCTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGGGATGTCTTATTTCTGTCTCTTATACACATCTGACGCTGCCGACGAGCGATCTAGTGTAGAT ++ +>AABBFFFFFFFFFFGGGCAFGCGHGGGHGGGHHFHHHFHHGGGGGFFFHHHBHHHHG5BG5GFEEEE1FGFFGF1EGHGGG/BFHEF@EA1BE1@EED3?4DHGGGGEGHFFFDDG?DCDEG@<?@DGCAGC-;@DGFFHGCHEEFGGFGFB/;..BBB.CCE?A0FE0EBFF0FEF.;=DFFB//BFBF//;/:9BA.9FB9//;9//;9F;FF +@M01368:8:000000000-A3GHV:1:1104:13832:4398/2 +GACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGCTGTCTCTTATACACATCTGACGCTGCCGACGAGCGATCTAGTGTAGATCTCGGGGGGTGCCGGCTCATTAAAAAAAGAAGATGTCGAGATGTCAGTGCGTGAGTGGAAGTG ++ +BBCCCFFFFFFFGGGGGGGGGGGGGHGGGGGGGHHHGFGGHHFGGGHGHHGHGFGECGHHHHGGGGGGGHEGFGGGHHGHFHHHHFGHFHHHHGHHHHFGGFGG3FFGGHHHHHHH2?FFGHFHHHHHHHHHBGHDGC0FGHHGHHGHHHHHHHHHHFGHHGGGGGHG-:@?FAGA:.:09CB0000;9B0.9-;---:./----.0;B00;:0;;.../90009..-..00000000-...90:.00/00 +@M01368:8:000000000-A3GHV:1:1104:23670:4161/2 +CGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACCTACGTTCAA ++ +A3AABBFFFFFFGGGGGGGGGGHHFHHHHHHGHGHHHHHGCHHHHGGGGHHHHHHHHHHHHHHHGHHGHGHGGHGGHGHGGHHGFGHHGHHHEHHGHHHHHGHEHEHHHGGFGGHHHFHHHGHHHHHHHGHHHHG4EGGGFCBBCA?DGGGGGGCCAFFFFFFFFFFFFFFFFFDFFF.9@--=AFFFF;FBFFBEFFF9FBFFB9/FFFFFFB/FFFFFFFBFFFF/BBFBB/FFFE?.;@FFB?FBB// +@M01368:8:000000000-A3GHV:1:1104:24927:22253/2 +GTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGGGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATGTCTTATTTAAGGGGAACGTGGGGGCTATTTAGGTTTTATGACCCTGAAGTAGGAACGAG ++ +AABBBFFFFFFFGAFGG5GGGGHDGHHHHHHHHHHHHFHCFGC2F3BFGFGHBGHHFHEDHFGGGGGHHHG3F?GHHGGC/EFEHFGAEFFHGGAEHGGGG3EEGEEDHFHAAD@DGGGHG/AC1>GED-<<-.;C0:0C:C;GH:::::0B90;FFGEGFBFF0C.;9F0;0090;900;00FA9D.A...-9=BBFFFE/FE9;9E//BBBB.BBB///B/9/B..;. +@M01368:8:000000000-A3GHV:1:1104:4705:7727/2 +TCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACCTACGTTCAATATTACAGGCG ++ +ABBBAFFFFFFFGGFGGFGGGGGHHHHFHHHHHHGGGGHHHHHHHHHHHHHHHHHHHHHHEDEFGHFHHHHGHGHHHHHHHGHHHHHHHHFHGHHHHHGGGGGHHHGHHHHHHHHHHHGHHHHFHGHGHGGHGGGDCD.;FFGGGGGGGGFFFFFFFFFFFFF.>FFFFFF-BBEFFFFFBFFFFF-DDFFFFFFEFFFFFFFFFFFF?F///9FFFFF/;FFFFF?AADCFFEFAFFEFFFFFB/;B/A9 +@M01368:8:000000000-A3GHV:1:1104:7756:4776/2 +CTACAAGCATTAATTAATTAACACACTTTAGTAAGTATGTTCGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATGTCTTATTTAAGGG ++ +BBBBBFFBFFFFGGGGGGGGGFFHHGHHGHHGGHGHHGFHHGGGGGHHHHHHHHGFF3GGGHGGGHFDHEGHHFHHHHGFHBCGHGEGFFFFFHHHHHGHHHHHGHHHGGGGGHHGHHGGHHHGGGGGGHHECCFDHHADGGHHHFGFDC////FHHHDGFCGCDEECF?EGGFFHHFEHFGGHHFFF/A900;C.9..C0990.;CFBFGE/9.9B99/;B.99/FB///9AEF/99/9/BBF/B/B//A +@M01368:8:000000000-A3GHV:1:1105:11310:21761/2 +ACTTGGGGGTAGCTAAAGTGAACTGTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCTCC ++ +BCCCCFCCCCCCGGGGGGGGGGHHHHHHHHGGGGGHHHHHHHHGHHHHHHHHHGHHHHHHHHGHHHHHHHHHHGGGGGHHHHHHHHHHGHHHHHHHHHHHGGHGGHHHHGHHHDGHHHHHHHHHHHHHHHHHGHHHHHGGGGGGHHHHHGHHHHHHHHFFHHHHHCCAHFHHGGFFFFFFFFFAA;BDDFFFF00.-=D.ABDA-.::AAF;F@.AAD./0000.9-;.9:00009:F090;FF000900; +@M01368:8:000000000-A3GHV:1:1105:11578:14676/2 +GCTCCGGGCCCATAACACTTGGGGGTAGCTAAAGTGAACTGTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGT ++ +CCBCCCBBCCCCGGGGGGGGGGHGGGGGHHHHHHHGHHHHGHHHHHFFFGGHGHHHHHHHHHHHHHHHHFGHHHHHHHGHHGHFHFGHHHGGGGHHHHHHHHHHHHHHFHHHHHHHGGHGGHHHHHHHHHHHHHHHHHHHHHHHHHHHGHHHHHDGGCGHHHHHHHHHHHHHFF>ABFDCFFFFFDGFGFDGDEG1EGEFFBFHFGHA0E00A0CAAC0FFDFFAGHFEHHFDH/EAFCFFHACGHHAFFEF2DFFG/FGHHHHGHGH0C@/E@GGC0FG10>GGFGHHGHFFBGFGB2>F@;-A@FF<-;---@-;-----;-BFF/;---9//BBFFFF//B;FF///9BF///;/;B/BBFBFFBB/;-9--///;9/:-;BFFBBB9F +@M01368:8:000000000-A3GHV:1:1105:15502:11453/2 +GATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACCTACGTTCAATATTACAGGCGAACATACTTACTAAAGTGTGTTAATTAATTAATGCTTGTAGGACCTGTCTCTTATACACATCTG ++ +CCCCCFFFCFFFGGGGGGGGGGHHHHHHGHHHHHGGGGGFHFHHHHHHGHHHHHGHHHHHHGHFHGHGGGGGGGGHHHGGGGGGGGHHHGHGGGGGGGGGGGHHGGGFGGGFEGGGGFFFGGFGDGGGBFGFFFFFFFFFFFFFE0BFFFFFFFFFFFFFFFFFFF;BFFDFFFFBF0BFFBFFEEBFFAA009FFFFFBFFEBB0;.BFFBFFFFFFFFFFFF0;BFFFFE//090::B0000:009900 +@M01368:8:000000000-A3GHV:1:1105:16787:9771/2 +TCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACCTACGTTCAATATTACAGGCG ++ +CCCDCFFFFFFFGGGGGGGGGGGHHHHHHHHHHHGGGGHHHHHHHHHHHHHHFHHHHHHHGGFGGHHEHHHHHAGHHGHBHHHGHHHHHHGHGHGHHHGGGGGHHHHHHHHHHHHHHHFFHHHHHGHGHGHHGGGACAFGGGGGG-AFGGFFFFFFFFFFFFFFFFFFFFF-9@AFEDFFFFFB.9-AABBBFFFEFFFFFFFFBFFFFFFEBB0BBBFFBFFBFBEDEAFFEB.ABFBFBFFFF0::/.- +@M01368:8:000000000-A3GHV:1:1105:17564:15723/2 +ATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACCTACGTT ++ +CCCCCCCCCFFFGGGGGGGGGGHHHHGHHGHHHHHHGHHHHHHFHHHHGGGGHHGHFHHHHHHHFHHHHHHHGHGGHGGHGHHHHFHFHHGHHHHHHHHHHHHHEHGHHHHHGGGGGHHHHGEHHGHHHHHHGHFGHFHGGAHGGHGGGCCBDFGFFAFDBDDFFFFFBDA;AAD-ADC?AFEFB-@@AAEFEFFFFF..-:.B0:FFFFFFEF0BFF09FF.0;9BFFFFF0BFFFFFF?.::-909;.9 +@M01368:8:000000000-A3GHV:1:1105:18108:12091/2 +GTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTACTGTCTCTTATACAC ++ +CBBCCFCCCCCFGGGGGGGGGGHHGHHHHFHHHHHHFHGHHHHFHFHHHHGGGGHHHHHHHHHHHHHHHHHHHHHHGGHGGHGHHHHGHFHGHHGHHHHHHGHHHHHHGHHHHHGGGGGHHHHHHHHGHHHHHGFGHHHHHGHDHGHHGCA;?AAFGFEFDFFF.FFFFEBDFFFFFFFFBFFFFFFFFFEFEFFFEFFFFFFF.:BFFF0BFFFFFFFFFFFF;0FF0;BFFFFFFFFBFFFBFEFFFF0 +@M01368:8:000000000-A3GHV:1:1105:18331:16683/2 +TTATTATGTCCTACAAGCATTAATTAATTAACACACTTTAGTAAGTATGTTCGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGGGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATATCT ++ +CCCCCFFFFFFFGGGGGGGGGGHHHHHHHHHHHHHGHHHHHFHGHHGHHHHHGGFGHHIIHHIHHHHHHHFHCFGHEEHFFHGHHFGHGHGHFHHGGGGGGEEGHHEHFHHGGHFHHFGGGGDFGBCGG?DGHGGFCGGHHECEF?CHGGDGFFGGHHC?EEGGHHHH.>AEGGGHEE-AEG0C0GCCEFFFFGEFG/;CEGGGE.:CAE.;@.@EFBFFFF/..:BFF0:BB00FBFFFFBDAFFF0;0B +@M01368:8:000000000-A3GHV:1:1105:20577:18421/2 +ATGTCCTACAAGCATTAATTAATTAACACACTTTAGTAAGTATGTTCGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGCCGAAAATACCAAATGCATGGAGAGCTCCCGTGAATGGGTAATAGGGTGATAGACCTGTGATCCATCGTGATGTCTTATTT ++ +?ABBBFFFFFFF4CFFGGGFGGHHHHHHHCEGHHCHFGHCAFEFHHHGGAEGGHHDHHHBGHBGHHH?5BGE1AEEFHHHHHGHFHBGHGEGGGGHBFHHFGHBGCFFG4EGHGG?E/FG3F3F/FGCDECEA/FGG/CEDBB//?BHEHHF0ADC@D>D9@DDCFFFFFFCFDFE.AA;/BB/.;-.;BFBBBFFBFFFFFFF/9FF?/;/BBFFFFF/;FFB/ +@M01368:8:000000000-A3GHV:1:1106:17389:18671/2 +GTATGTTCGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGGGATAGACCTGTGATCCATCGTGATGTCTTATTTAAGGGGAACGTGTGGGCTCTTTAGGGTTTATGACCCTGA ++ +BBCCCFFFCBCCGGGGGGGGGGHGHGHHGFGFGFHGGHHGHHHHHHHHFHHGGGGAGFBGHHHFBBGH5GDHH5EEEGEHEGFBF1DGFDGFGGGBBCEEGEHFEFDDHFBFHFD/@BGDGDHHGDCCFCD/C<->.ADDGE1GA;9.FFFFFFD-99ADFFD-.9FADF--9..;AAFEFFEAA-;.///BB:BBF/BBB//B//99/;BBB/9////F +@M01368:8:000000000-A3GHV:1:1107:18714:24788/2 +GGCCCATAACACTTGGGGGTAGCTAAAGTGAACTGTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTAGGTCGCAGGAACTGTCCTTGT ++ +BCCCCCFFFFFFGGGGGGGEGGHHHHGGFFHHHHHHHHHHGGGGGHHHHGHHHHHHHHHHHHHFHHHHHHHHGHHHHHHGHHHHGGCGHHHHHHHHHHHHHHHGHHHHHGDGHGGHHHHHHHHGHHHHHHHHHHHGHHHHHHEHHHGHFGGGGHHHHEHFHHGHFHHF.>GGHHHGHGHGGHCFFCDFDFFFFFFAAF.FFFFFEFAFCFFA..@.AFFFC9--9;.;A///00--;A-.;.000000090 +@M01368:8:000000000-A3GHV:1:1107:21355:8333/2 +GTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCGGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACCTACG ++ +AABCCFCCCCCFGGGGGGGGGGHHHGHHHFHHHHHHGHGHHHHHHGHHHHGGGGHHHHHHHHHFFHHFHGHHHHHHGGHGGHHHGHHHHGGHFHHHHHHHFHHGHHGEFFHFHHGGGGGGHHHFHHHHGHHHHE?FGHHHHGFGHGHHGGGDGGGGGFFFCFFFFFFFFFFFFA;DBBDFFFAFFFF;DBAFEDFFFFFEA?-9...9;9;BFFFF//BFBFFFFBFBFFFFFB/BFFF9B/EDEF-BFF. +@M01368:8:000000000-A3GHV:1:1107:22864:15712/2 +GTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATGTCTTATTCTGTCTCTTATACACATCTGACGCTGCCGCCGAGGGCTCTAGTTGTGGTCTG ++ +AABCCFFFFFFFGGGGGGGGGGGGGHHHHHHHHHHGHHHGGGGFHGHHHHGHFGFFFFGGHGGGGGCHFHFAFEDHHGGFGGGHHEGEGGHHEGGCHGHHHHGGGGGGHGF0EECGGGGFECCFFGFBGHHHHHHGGHHGHFCFEHFBEFGGADDDC=CC0CCFHG:CEHHHGHBGH:GFFGFF0CAAA/BF09BBBBBBB9CFFB0C00;000;:CFFB;:...D?>:@=:9-@...//;////..;/;/ +@M01368:8:000000000-A3GHV:1:1107:24817:14233/2 +CTTTAGTAAGTATGTTCGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGGGATAGACCTGTGATCCATCGTGATGTCTTATTTAAGGGGAAAGTGTGGGCTATTTAGGTTTTT ++ +CCCCBFFFFFFFGGGGGGGGGGFHHHHHHHHHHHHHHGHHHGEHGGHHGHHHHHGHHEHHGGGGEHGHHHGEHHGHHDGHHHHGGGGGFGEFGGEGHHGCEEEGHHEFGGDHGGGGAGFHHHHGGF/?//GHFFDGGGGGHAD??DC1DHHBGHHHHGHF<FGGGGGGGGGGGFHHEFGHHHGGGGGGHHHCGGEFHFGGGFHHHHHGGGEGGHHFHEEGEG/EEEE/?/EHFHH3GGH4EGHHCB01CGHGHGD//<@CGGBFFDGHHHH0FEHHGEGFHCD11>0=GGHGCCFGHGBGGD0GGHC0C.@?ACEEC/.EDEB?BFFCFB9CFF090BBCBFBF0CCB0B00A.9E.B/9BA=-..B9FBF//;BBBBFFB:./9/9/9;B//9BF/;B/ +@M01368:8:000000000-A3GHV:1:1108:11059:23181/2 +AACTGTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACC ++ +CCCCCFFFFFCCGGGGGGGGGGHHHHHHHHHHHGHHHHHHHHGHHHHHHHHHHHGGGGHHHHHHHHHHHHHHHHHHHHHHGGHGGHHHHHHHHFHHHHHHHHHHHHHHHHGHGHEHHGFCGGGHHHHHHHHHHHHHHHFGHHHHHGHGHGHHGGGBFGFFFFEAFFFA.BFFFEFDDFFFFFFFFFFEEFF;D;EFFFFFF0BFFFADDFFFFFBFBFFFFFBB0FFFF0::0BF000BFFFBBF0EDFF@ +@M01368:8:000000000-A3GHV:1:1108:12233:13498/2 +GGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACCTACTGTCTCTTATACAC ++ +ABBBCFFFFFFFGGGGGGGGGGHHHGHHHHHHBGHHHGGGGHHHHHHHHHHHHHHHHHHHHHHGGHGGHHGHHHHHGGHHGHHHHHHGHHHHHHHGGHHHHGGGGGHHHHHHHHHHHHHGHGHHHHHHGHGHGGHGGGGAGGFGGGGGGGGFFFFFFFFFFDFFFFDFFFFFFFFF>.AEDEFFFFF?E-DAB9FFFFFFFEF:FBFB009:0FFFF9BFFBFFFFBB0.9A=-/0BFF0BBFFBFF:90: +@M01368:8:000000000-A3GHV:1:1108:14328:14751/2 +GTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATCTGTCTCTTATACA ++ +ABBBBFBBBBBFGGGGGGGGGGHHHHHHHHHHHHHHHHGHHHHHHDHHHHGGGGHHHHHHHHHHHHGHHHHHHHHHGGHGGHGGHHHHHGHHHHHHHHHHHHHHHHFHGHHHHHGGGGGHHHHHGHGHHHHHHG?FHHHFHGHGHGHHGGGGGGGGGFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFAFFE.ADEFFFFFFFADFFFFF///BBFF/FFFFFBFAFFFFBB///;9:BBFFFBF9B9//:/ +@M01368:8:000000000-A3GHV:1:1108:16350:22621/2 +CATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACCTACGTTCAATAT ++ +CCCCCFFFFFFFGGGGGCGGGGHHHHHHHHGHHHHGHGHHHHGGGGHHHHHHHHHHHIHHHGHHHHHHGGHGGHHHHGHGHGHHHHHHHHHHHGHHHHHHGGHHHHGGGGGHHHHHHHHHHHHHGHGHHHGHHGGGGGHHGGGDADDGFFGGGGFFFFFFFFFDFFFDFFFFFFFFFFFAFAEFEDFFFFFFEE-AAFFFFFBFFFFF0FFFBFF;AFFFFFFFFFFFFFFFFFFFFFAB9BFFFFFBFFF +@M01368:8:000000000-A3GHV:1:1108:21791:23272/2 +CATAACACTTGGGGGTAGCTAAAGTGAACTGTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCT ++ +BBBBBFFFFFFFGGGGGGGGGGHHHHGGHHHHHHHGGGEGGHHFGDHGHHHHHHGGHHH2GGHHHGHHGGGGFGFBFHHHGGGGHGHGHHHHHHHHHHGHGHHGHHGGHGGHHHHGGFHGGGHFHGHHHHHGGHHHGHGFCGFFDGGG/FCFHBGHHHHHHHGHCHHHHGGGHGHGHGCFF;>@DFFBFFFFFFDFFFFFFFF;;.DDAA;FFF;BB;C@..9::BBFBBA;-:.::FBB///;/////:/ +@M01368:8:000000000-A3GHV:1:1108:23314:26089/2 +CATAACACTTGGGGGTAGCTAAAGTGAACTGTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCC ++ +BBAAAFFFFFFFGGGGGGGGGGHHGDHHHHHFHHHHGGGGGFHFFGFFHEGHHHHHHHHFGHFHHHHDEHHHHHHGHFHHGGGGHHGFHHHHHHHHHHHHHHHHHHF?EEFCHFGFHHEFFFHGFHHGHFHFHHHFFHAG??GHACGGDGHGGBFHHHHHHHGHFGHGHGEGHGCFFF@CD-BDDFFFFFFFFDDFFBBFFD-B-A.DFFA.AFEFF-;-..:..BFFFFFA-../9FFF//B/BBBBFF/ +@M01368:8:000000000-A3GHV:1:1108:25084:18127/2 +CCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACCTACGTTCAATATTACAGGCGAACATACTTACTAAAGTGTGTTAATTAATTAATGCTTGTAG ++ +CCCCCFFFFFFFGGGGGGGGGGGGHHHHHHHHFHHHHHHHHHHHHHHGGHHGHHHHHGGGGFHHHHHFHHHHHHHHHGGHHHHHCGGHGHHGGGGGGGHHGGGGGGGGHHHGHHGGGGGGGGGGGGGGGG@CDE?EFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFE;DFBFFFFFFFFFFFFFFFFFFFAFFFFFFFBFFE0BBBFFFFFFFFFFBFFFF9BB0:0:B; +@M01368:8:000000000-A3GHV:1:1108:7626:10048/2 +AACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATCTGTCTCTTATACACATCTGACGCTGCCGACGAGCGATCTAGTGGAGATCTCTGGGGTCGGCGGATTT ++ +BCCDDFFFFFFFGGGGGGGGGGHHHHHHHHHHHHHHHHHHHGGGGGHHHHHHHHFGHHHHHHHHHHHHGHHHHGGFHHHFGGGGHHHGHHHHHHHHHHHFGHHHHHGHGHGHHGCGCGGFHHHGGGGGGGGGGGGGGGGGGGFFFAFFFFFFAA-AFEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBBFFDFFFFFB-<>;>@BE<:000.0.0/0<00<0:>..-<<<---.0 +@M01368:8:000000000-A3GHV:1:1109:11270:12255/2 +CTACCTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCTGTCTCTTATACACATCTGACGCTGCCGACGAGCGATCTAGTGGAGATT ++ +BCCCCFFFFFFFGGGGGGGGGGHHHHHFHHHHGGGGHHHHHHHHHHHHHHHHHHHHGHGGHGGHHGHHHHHGHHHHHHHHHFHHHHHGHHGHHHHHGGGGGHHHHHHHHGHHHHHH?FHHHHHGHGHGHHGGGGGGGGGGGGGGGGGGGGFFFFFFFFFFFFFFFFECADFFFF.DEBFFFFFF;D.B;.ED.FFFFFFF-.:00009BBF +@M01368:8:000000000-A3GHV:1:1109:24217:19077/2 +TAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATGTCTTATTTAAGGGGAACGTGTGGGCTATTTAGGTTTTATGAACCTGAAGTAGGAACCAGATGTCGGATACAGTTCACTTTCTGTC ++ +BBBBBFFFFFFFGFEGGCFGFGHHHHFHHFHHHHHHGGEEEFGHGFFAGFFEEAEGGHHBEEFAFGAEF1G3GFGGEEF@EAGGHGFF?ECGGHEEEFGGHHHHFHHFHHGFHHHC2DAGHGG00-BFFA9FFFFFFFFFFFBFAFFAFFFFFBFFFFFFF/9BFFDFFDDFF-9@CDAD;:AFF/;B//....;;///; +@M01368:8:000000000-A3GHV:1:1109:27103:7153/2 +NTACTTCAGGGTCNTAAAACCTNAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCANGGNAGCTCTCCNNGNNNNTGGTATTNTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACCTACGTTCAATATTACCTGTCTC ++ +#>>AAAFFFFFFG#AAFFGGGG#BAFFAGHHHGGGGHGHHHHFHHHHHHHGHHHHHHHEGFGGHHBGHGHHBGFFEG2GHHFHFHHHGHHGHFH#/B#??FFGHHH##?####????FHG#??CFGGGEF>CGAGAGGGFGAA@@FFFFFFFFB=@@FF?FF;FFFF@@-@-AFEF?BB/BF?E-BBFFF;:BB/BFFFB/BFFFBFBFBBFFFFFB/FFFBB/;9A@@BFFBFFFF/BBFFFFFFE/:9/ +@M01368:8:000000000-A3GHV:1:1109:8763:7859/2 +GGTTCCTACTTCAGGGTCATAAAGCCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACCTACGTTCAATATTACAG ++ +>AAABFFFFFFFGGGGGGGGGGHHHHHHHCHFAFHHDGEGFHHHHHHHHFHHHHFHHHHHHGHGGHGGHHHFHGHHHHHFFHHHHHHBGHFFHGHGHHHHHGGEGGHHHHHGHHHHHHHHHGFGHHHHGHGHGHHCCGGGGGGGGGGAAGF?FFFFBFA@=BDDFF?-;FFF;@CFFEFEFFFFFFFFFBFDFFFFFFFFFFFFFFFFFFFFFF:FFFF/BF/FFFEFF?DECAFEFFFFFE:FFFFFFFB +@M01368:8:000000000-A3GHV:1:1110:12808:18367/2 +GCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACAGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACCTACGTTCAATATTACAGGCGAACATACTTACTAAAGTGTGTTAATTCTT ++ +ABCCCCDDDFFFGGGGGGGGGGHHHHHHHHHGGGGGGHHHHFHHGHHHHHHHHHHHHHGHHHGGHHHH3GFHEFHHHHHGHHGFHHHHHFGHHHHHGHGHGGHGGGGGGGHHHGGCGGGGHHGGGGGGGGGGGGGGGGGGGF-BAEFEBEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFAFEFDFFFFFFFFFF0BFBED=@DFFFFFFFFFEFFFFFBFAFB;0:;F0 +@M01368:8:000000000-A3GHV:1:1110:14751:26540/2 +ATGTTCGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATGTCTTATTTAAGGGGAACGGTTGGGCTATTTGGGTTTTTTGACCCTGAAG ++ +BBBBBFBBBBBFGGGGGGGGGGHHHHGGFHGGHGGCHHHHHHGHHHGHHGEGGGHHHHHHHHHHEFHHHHHHGEE?FGHGEHGGHHHGGGGGGEHHGGGGHHGGGEGHHHGHGGGDFGHHGHGGGGGCGAFFCCDFHHHH1CGGHBHFHFCGFFCDFHGCCE.CC:EGFHHCGHHGCF?FGGGFGGG;B9;FFFFFFEGEBF0;;;0;CFBFFF?D.DE.:..99-...;;//9A.;DE.9-./:FB.;// +@M01368:8:000000000-A3GHV:1:1110:15519:10008/2 +GGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACCTACGTTCAATATTACAG ++ +BBCBCFFFFFFFGGGGGGGGGGHHHGHHHFHHBGHHHGGGGHHHHHHGHHHHHHHHHHHHHHHGGHGGHHGHHHGGBGHHHHHHHHHHHHHHHHHGGFHHHGGGEGHHHHHHHHHHHHHHHGHHHHHHGHGHGHHGGGGGGDGGGGGGGGGBFFFFFFFFFFFFFFFFFFFECB-=BFFFFFFFFBB?E-A::FFBFFFFFBFFFFFFFFFFFFBFFEFFF;0BFF0:FE?FFFFBFFFFFFFFFFFFFF0 +@M01368:8:000000000-A3GHV:1:1110:16559:7507/2 +GCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACCTACGTTCAATATTACAGGCGAACATACTTACTAAAGTGTGTTAATTAAT ++ +>AABBCCCCFFFGGGGGGGGGGHHHHHHHHHGGHGGHGHFHHHHFHHHHHHHHHHFHHGHHHHGHHHHHGGEEGHHHHHHHHHHHHHHHHHHHHHHGHGHGHHGGGGGGGHHGGGFGAGFGGGGGGGGGGGDDDFAGGFFFFCFAFEEFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBFFFFFFFFFFFFFFE..@BFFBD./;:0FFFFF09B/AFCA=-99BFFBFFFFFFFB:BFBFFBFB9: +@M01368:8:000000000-A3GHV:1:1110:16700:6843/2 +GTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTCTGTCTCTTATACACATTTGTCGCTC ++ +CBCCDFFFFFFFGGGGGGGGGGHHGHHHGGHFHHHGGGGGHHHHHHHHHHGHHHHHHHHHHHGGHGGHHHHHHHGBGFFHHHHHHGHHHHHHHHGHHHHHGGGGGHHHHHHHHHHHHHHHFHHHHGHCG/GGHHGGGGGGAFGEEADAGGDFFFF00D>CFDDFFFB?AF?B;-@>.FEDFFFFF0BF-BDFFFFE00B0BF0FFFF:BFA0B0:BBFBBFFFFF0B0:000<00FDFFFFFFFFFFFBFFFFFFFFFFF/FFF/BFFFFFFFBA.?@;FFBDFFFF/ +@M01368:8:000000000-A3GHV:1:1111:7437:24508/2 +ACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACCTACGTTCAATATTACAGGCGAACATACTTACTAAAGTGTGTCTGTCTCTTATACACATCTGACGCTGCCGAGA ++ +BBBBBFFBABBBGGGGGGGGFGHHHHHHHHHHHHHGHHHGFHHHHGGGGDHHHHHHHHGFHHHHHGHHHHHHGHFHGHHGGGDFGDFFGGGFFGFFGHGHHHGGC?AD-:A-AFFGGG-?9EFEFGGFFBFEFCFFFFFFFBBBFFFFFFFFFFFFFFFBBFFFFFFFFFFFFFFFFFFEFFFFFFBFFFFEFEFFFF;CF-FFFFFFFF/BFFFFFFFFFFFFEFBFFFB/FFFFFFF//9A..;F--@9 +@M01368:8:000000000-A3GHV:1:1111:8665:25542/2 +CTTTAGTAAGTATGTTCGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGACAGACCTGTGATCCATCGTGATGTCTTATTTAAGGGGAACGTGTGGGCTATTTAGGTTTTA ++ +CCCCCFFFFFFFGGGGGGGGGGHHHHHHHFHHHHCHHGDGGGGHGGHHHHHHHHGHGHHHGGGGGHFHHHHFHHHFFHHHHHFGCGGEHFHHFGGHFHGGGGGGHHFEEEAFEFFDFHGHHHHGGGGGGGHH0DGGGGCGHCC-FFFFFFFGGGGGGGGGGHHHHHGHHHHGHHGGHHGGHGGHHHGHHHHFHHGHHAFGGGHHHHHGHHHHFHFHHHHHECGGGHGHHHEFHFHGGGGGGGGFGFFGFFEFGEGHHHGHHGGDGGGHGFGGGGGGGGE@GCGGHHHGHHHHHGHHHHFHHGEGFFEGCE.ECCECEHCGGFFE/AABFFG0CFE0BFFF9CFGG.F/BBBFFGFGGGFFFFFFBFEDAEFFFFFBFFFFFFF0;FEBF: +@M01368:8:000000000-A3GHV:1:1112:10272:7828/2 +GTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATGTCTTATTTAAGGGGAACGTGTGGGCTATTTAGGTTTTATGACCCTGAAGTAGGAACCAGATGTCGGATACCTGTCTCTTATACACATCTGACGCTGCCGACGAGCGATCAAGTGTAGTGCTCGGGGGGG ++ +BBCCBFFCCCCCGGGGGGGGGGGGGGHHHHHHGGGGGGHHFHGGGGGFGHGGGGGGHHHHHHHHHHFHHHHFHGFFHHGF?ECEFFFFFFHHHHHH?FHHHHHHHHHGFHHHHHHGGGFGHHHHFHHHHHHHHHHGGGFGFGCGGGGHHHHHHHHHHHGGFFHGHHHHHFFHFCGFHCCGHGHCGGHG?DGGGGGFBBFGFBFBBBGGGB0000;CD?DFFAFF9=--;...://;////////.------ +@M01368:8:000000000-A3GHV:1:1112:9832:16531/2 +GTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACCTACG ++ +BBBBBFBBBBBFGGGGGGGGGGHFHHHHHHHHHHHHHHGHHHHGHFHHHGEEGGHHHGHHHHHHHHHHHHEHGHHGGGHGGHGHHHHHGHHHHGHHHHHHHHHHHHHHGHHHHHGEGCGHHHHHGHHHHHHHHHHHHHHGHFFGHGHHGGGDACDFFFFABFFFFFFFFFFD-BC?DA9.DFFBEA==B=?F.;ABBFBFEF-DAF/BFF9/FFFBB/9BFFFFFFF/BFBBFFFFFFF/9FEA?--B/;. +@M01368:8:000000000-A3GHV:1:1112:9832:6701/2 +GCTAAAGTGAACTGTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATT ++ +BBBBAFFFFFFFGGGGGGGGGGFGHHHHHGHHHHHHHHHHHHCGHHHHHHHGHHHHHHDGHHGGAECHHGHHHHHHHGHHHGHGFHHHHGGHGGHHFHHHHHHFHHHHHHHHH2GHHHHGHGHHFHHGGFGGGHHGHHHHHFHHHHEFHHHHEFGFFHGEHCFGDFDFFFFFCFFFFFFFFFFFFFAFBFFDFFFFFFFFADCF?9?EFBFB9EF-A.;BFFFFFFFBFFFFFFFFFFFFBFFFFFFFFFF +@M01368:8:000000000-A3GHV:1:1113:13532:8618/2 +GCCCATAACACTTGGGGGTAGCTAAAGTGAACTGTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTGGAT ++ +CDDDBFFFFFFFGGGGGGGGGGHHHHHGGHHHGHHHGHHGGGGEHHGGHHHHHHHHHHHHHHGHHGHHHHHGGHHHHHFHHHHGCDCGHHHHHHHHEHHHGHGHHHGFHGGHGGHHHHHHHHFHHHFHHHGHHHHHHHHHFGGHHHHGGGEGAFHHGHHGGHHHHGHFBGFHGHGHGHGGHGGF@DAFEFBECAB=A.0BFFFEDF=A9.@D.-AAFFFA-:-..:.9/0:;0..-..0000::BFB09:: +@M01368:8:000000000-A3GHV:1:1113:21679:18011/2 +TTAGTAAGTATGTTCGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCTGTCTCTTATACACATCTGACGCTGCCGACGACCGAGCTAGTTGAGATC ++ +BCCCBFFFFFFFGGGGGGGGGGHHHHHFHHHGHHHGFGHGGHGGHHHHHHGHHHHHHHGGGGFHHHHHHEGHHHHHHHHFGGFCGEHFHFGEGHHHFGGGGGHHHGGGEHGGGGGHHHHHHGDCCCGHHHHDGGGGCD/FCC->DFFF. +@M01368:8:000000000-A3GHV:1:1113:5741:16959/2 +GTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACCTACG ++ +BBBBCFCCCCCFGGGGGGGGGGHHHHHHHGHHHHHHHHGHHHHGHDGHHHGGGGHHHHHHHHHHHHHHHGHHHHHGGGEGGHHHHFHHHHHHHHHHHHHHHHHHHHHHGHHGHHGGGGGHHHHHHHHHHHGHHHFHHHHHHGHGHGHGGGGCGGFGGFFFFFFFFFFFFFBFFFFFFFFFFFFFFAFFFFEAEFFFFFFFFFFF9BFFBFFFFFFFFFFFFFFBFFFFFFFFFFFFFFFFFFADAB-/BF. +@M01368:8:000000000-A3GHV:1:1114:10130:11959/2 +ATCAGAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGTGATAGACCTGTGATCCATCGTGATGTCTTATTTAAGGGGAACGCTGTCTCTTATACACATCTGACGCTGCCGACGAGCGATCTAGTGGAGAGTTCTGTGGGGCCGGGGATCCTTATAAAAAAAATAGA ++ +BCCDDFFFFFFFGGGGGGGGGGGHHHHHGGHHHGGGCGGHGHGGGGHHGGGGHHHHHHGGGEGGHHHFGGGGG?E1FE?/EEHHHHHGHHGHHHHGHFHGHGHHGDGGFG2FF2?GHHHHHGCCCFHGHGHHHHGHHFEHHFGHHGHH<1=DGHHHGHHGHGAGAEEDG.CGCGHC0CGBFHGFBBF0ABDDEFF@?--:BB@.;:BF;0.0:0.0:000:BF.-.------.9/;000::0;0:--.000 +@M01368:8:000000000-A3GHV:1:1114:14540:5315/2 +CACTTGGGGGTAGCTAAAGTGAACTGTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCC ++ +CCCCCFFCCDCCGGGGGGGGGGHHHHHHHHHGGGGGHHHHHHHHHHHHHHHHHHHGHHHHHHHGHHHHFHFHHHGGGGGHHHHHHHHHHHHHGHHHHHHHHGGGGGGHHHFHHHGHHHHHHHHHHHHHHHHHHGHGHHHGGGFGHHHHHHHHFHHHHHF?1FHHGHGHGHGHHGGFFFFDBFBE;BCC.:BFFFFFFFFFFFFFF;AFFFFF-=-.AEDEFFFFF..9A;9FFFF0FFFFE00FFF0:BA. +@M01368:8:000000000-A3GHV:1:1114:15066:16302/2 +TTATTATTATGTCCTACAAGCATTAATTAATTAACACACTTTAGTAAGTATGTTCGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCACACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGGGATAGACCTGTGATCCATCGTGTGG ++ +CCCCCFFFFFFFGGGGGGGGGGHHHHHHHHHHHHHHHDGHHHHFHHGHHGHHHHHGGGGEHHHHFHHFF5FHHFEGHHHGDHGGHGHGFGGGEHFGHHGGGGGHGHHHGHHFHHB3FGHHFGGGG?GFFHCCEBGFFECCDFEGFCFGCHHGFDDHHHGHHCFGGGGGFBFDGFG?-:..AFG.-C0C009;:00;00:9/:CEFFF?AE::9;9?0:FEF0;0..--./00::B/090000000;A.... +@M01368:8:000000000-A3GHV:1:1114:16639:15258/2 +TTATTATTATGTCCTACAAGCATTAATTAATTAACACACTTTAGTAAGTATGTTCGCCTGTAATATTGAACGTAGGTGCGATAAATAATAGGATGAGGCAGGAATCAAAGACAGATACTGCGACATAGGGTGCTCCGGCTCCAGCGTCTCGCAATGCTATCGCGTGCGCACCCCCCAGACGAAAATACCAAATGCATGGAGAGCTCCCGTGAGTGGTTAATAGGGGGATAGACCTGTGATCCATCGTGATG ++ +CDCCCFFFFFFFGGGGGGGGGGHHHHHHHHHHHHHHHHGHHHHHHHHGHHHHHHGGGGGHGIHHHIH5DEGHHHF?FGHGGHGGHEGGHFHHGHGEHHGGGGGFFFGHFBG2GHEBGHHGHGGEG/GFGABEDFGHEED?GGHHFFGGGCFEGD/GFHFFGEFGCGG?CC??D-EF@EEEFGCDDBBFGGGEBBFFF09090A.BFGA.9CCA0;EBAB00BBFF.@-./;BB;BFFF0:00099AAFFF0 +@M01368:8:000000000-A3GHV:1:1114:2404:13066/2 +ATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCTATTATTTATCGCACCTACGTTCAATATTACAGGCGACCATACTTACTAAAGTGTGTTAATTAATTAATGCTTGTAGGACTGTCTCTTATACACATT ++ +CCCCCFFFFFFCGGGGGGGGGGHHHHHHHHHFFHHHHGGGGGHFFFHHFHHHHHHHHHHHHHHHGFEGGGHGEDFCDFHGHFG@@DGGHHHHHHGGGGCGGGGGEHGGCGBB?CF99EGFGGFGG?D9CFFFF/BBFFFFFEF9BFFAFFFFEFFFFFFFFFFFFFFFFFFFFF.FFBBFFFFFFFFFFFF-9;;;BFFFFFB9BFBFBFABFFEFFFFFFFFFF::BFFBFFFF.9//;FFFFF/BFFB/ +@M01368:8:000000000-A3GHV:1:1114:9184:6959/2 +AAAGTGAACTGTATCCGACATCTGGTTCCTACTTCAGGGTCATAAAACCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATGGATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGGGTGTGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTCCTGCCTCATCCCTGTCTCTTA ++ +CCCCBFFFFFFFGGGGGGGGGGHHHHHHHHHHHHHHHHHHHHHHHHHHGHHHHHHEHIHHGGGGHHHHHHHHHHHHHGHHHHHHHHGGGGGHHFHHHHHBGHHHHHHHHHHHHHHHHHGHHHHHGGGGGHHHHGHHHHHHHHHHHHHHHHHGHGHGHHGGGGCFFFFFFFFFFFFFFFFFFFFFFFFFF.CFFFFAF=D=EAEFFF0B:0AF-DAFBFFFFFFFFFBFFFFFFFFFFBFFFEFF9B900B0 diff -r aceaf1d94d2d -r 2a6cfe8997aa test-data/bowtie2-ref.fasta --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test-data/bowtie2-ref.fasta Thu Dec 04 12:58:42 2014 -0500 @@ -0,0 +1,239 @@ +>chrM +GATCACAGGTCTATCACCCTATTAACCACTCACGGGAGCTCTCCATGCATTTGGTATTTTCGTCTGGGGG +GTATGCACGCGATAGCATTGCGAGACGCTGGAGCCGGAGCACCCTATGTCGCAGTATCTGTCTTTGATTC +CTGCCTCATCCTATTATTTATCGCACCTACGTTCAATATTACAGGCGAACATACTTACTAAAGTGTGTTA +ATTAATTAATGCTTGTAGGACATAATAATAACAATTGAATGTCTGCACAGCCACTTTCCACACAGACATC +ATAACAAAAAATTTCCACCAAACCCCCCCTCCCCCGCTTCTGGCCACAGCACTTAAACACATCTCTGCCA +AACCCCAAAAACAAAGAACCCTAACACCAGCCTAACCAGATTTCAAATTTTATCTTTTGGCGGTATGCAC +TTTTAACAGTCACCCCCCAACTAACACATTATTTTCCCCTCCCACTCCCATACTACTAATCTCATCAATA +CAACCCCCGCCCATCCTACCCAGCACACACACACCGCTGCTAACCCCATACCCCGAACCAACCAAACCCC +AAAGACACCCCCCACAGTTTATGTAGCTTACCTCCTCAAAGCAATACACTGAAAATGTTTAGACGGGCTC +ACATCACCCCATAAACAAATAGGTTTGGTCCTAGCCTTTCTATTAGCTCTTAGTAAGATTACACATGCAA +GCATCCCCGTTCCAGTGAGTTCACCCTCTAAATCACCACGATCAAAAGGAACAAGCATCAAGCACGCAGC +AATGCAGCTCAAAACGCTTAGCCTAGCCACACCCCCACGGGAAACAGCAGTGATTAACCTTTAGCAATAA +ACGAAAGTTTAACTAAGCTATACTAACCCCAGGGTTGGTCAATTTCGTGCCAGCCACCGCGGTCACACGA +TTAACCCAAGTCAATAGAAGCCGGCGTAAAGAGTGTTTTAGATCACCCCCTCCCCAATAAAGCTAAAACT +CACCTGAGTTGTAAAAAACTCCAGTTGACACAAAATAGACTACGAAAGTGGCTTTAACATATCTGAACAC +ACAATAGCTAAGACCCAAACTGGGATTAGATACCCCACTATGCTTAGCCCTAAACCTCAACAGTTAAATC +AACAAAACTGCTCGCCAGAACACTACGAGCCACAGCTTAAAACTCAAAGGACCTGGCGGTGCTTCATATC +CCTCTAGAGGAGCCTGTTCTGTAATCGATAAACCCCGATCAACCTCACCACCTCTTGCTCAGCCTATATA +CCGCCATCTTCAGCAAACCCTGATGAAGGCTACAAAGTAAGCGCAAGTACCCACGTAAAGACGTTAGGTC +AAGGTGTAGCCCATGAGGTGGCAAGAAATGGGCTACATTTTCTACCCCAGAAAACTACGATAGCCCTTAT +GAAACTTAAGGGTCGAAGGTGGATTTAGCAGTAAACTAAGAGTAGAGTGCTTAGTTGAACAGGGCCCTGA +AGCGCGTACACACCGCCCGTCACCCTCCTCAAGTATACTTCAAAGGACATTTAACTAAAACCCCTACGCA +TTTATATAGAGGAGACAAGTCGTAACATGGTAAGTGTACTGGAAAGTGCACTTGGACGAACCAGAGTGTA +GCTTAACACAAAGCACCCAACTTACACTTAGGAGATTTCAACTTAACTTGACCGCTCTGAGCTAAACCTA +GCCCCAAACCCACTCCACCTTACTACCAGACAACCTTAGCCAAACCATTTACCCAAATAAAGTATAGGCG +ATAGAAATTGAAACCTGGCGCAATAGATATAGTACCGCAAGGGAAAGATGAAAAATTATAACCAAGCATA +ATATAGCAAGGACTAACCCCTATACCTTCTGCATAATGAATTAACTAGAAATAACTTTGCAAGGAGAGCC +AAAGCTAAGACCCCCGAAACCAGACGAGCTACCTAAGAACAGCTAAAAGAGCACACCCGTCTATGTAGCA +AAATAGTGGGAAGATTTATAGGTAGAGGCGACAAACCTACCGAGCCTGGTGATAGCTGGTTGTCCAAGAT +AGAATCTTAGTTCAACTTTAAATTTGCCCACAGAACCCTCTAAATCCCCTTGTAAATTTAACTGTTAGTC +CAAAGAGGAACAGCTCTTTGGACACTAGGAAAAAACCTTGTAGAGAGAGTAAAAAATTTAACACCCATAG +TAGGCCTAAAAGCAGCCACCAATTAAGAAAGCGTTCAAGCTCAACACCCACTACCTAAAAAATCCCAAAC +ATATAACTGAACTCCTCACACCCAATTGGACCAATCTATCACCCTATAGAAGAACTAATGTTAGTATAAG +TAACATGAAAACATTCTCCTCCGCATAAGCCTGCGTCAGATTAAAACACTGAACTGACAATTAACAGCCC +AATATCTACAATCAACCAACAAGTCATTATTACCCTCACTGTCAACCCAACACAGGCATGCTCATAAGGA +AAGGTTAAAAAAAGTAAAAGGAACTCGGCAAATCTTACCCCGCCTGTTTACCAAAAACATCACCTCTAGC +ATCACCAGTATTAGAGGCACCGCCTGCCCAGTGACACATGTTTAACGGCCGCGGTACCCTAACCGTGCAA +AGGTAGCATAATCACTTGTTCCTTAAATAGGGACCTGTATGAATGGCTCCACGAGGGTTCAGCTGTCTCT +TACTTTTAACCAGTGAAATTGACCTGCCCGTGAAGAGGCGGGCATAACACAGCAAGACGAGAAGACCCTA +TGGAGCTTTAATTTATTAATGCAAACAGTACCTAACAAACCCACAGGTCCTAAACTACCAAACCTGCATT +AAAAATTTCGGTTGGGGCGACCTCGGAGCAGAACCCAACCTCCGAGCAGTACATGCTAAGACTTCACCAG +TCAAAGCGAACTACTATACTCAATTGATCCAATAACTTGACCAACGGAACAAGTTACCCTAGGGATAACA +GCGCAATCCTATTCTAGAGTCCATATCAACAATAGGGTTTACGACCTCGATGTTGGATCAGGACATCCCG +ATGGTGCAGCCGCTATTAAAGGTTCGTTTGTTCAACGATTAAAGTCCTACGTGATCTGAGTTCAGACCGG +AGTAATCCAGGTCGGTTTCTATCTACNTTCAAATTCCTCCCTGTACGAAAGGACAAGAGAAATAAGGCCT +ACTTCACAAAGCGCCTTCCCCCGTAAATGATATCATCTCAACTTAGTATTATACCCACACCCACCCAAGA +ACAGGGTTTGTTAAGATGGCAGAGCCCGGTAATCGCATAAAACTTAAAACTTTACAGTCAGAGGTTCAAT +TCCTCTTCTTAACAACATACCCATGGCCAACCTCCTACTCCTCATTGTACCCATTCTAATCGCAATGGCA +TTCCTAATGCTTACCGAACGAAAAATTCTAGGCTATATACAACTACGCAAAGGCCCCAACGTTGTAGGCC +CCTACGGGCTACTACAACCCTTCGCTGACGCCATAAAACTCTTCACCAAAGAGCCCCTAAAACCCGCCAC +ATCTACCATCACCCTCTACATCACCGCCCCGACCTTAGCTCTCACCATCGCTCTTCTACTATGAACCCCC +CTCCCCATACCCAACCCCCTGGTCAACCTCAACCTAGGCCTCCTATTTATTCTAGCCACCTCTAGCCTAG +CCGTTTACTCAATCCTCTGATCAGGGTGAGCATCAAACTCAAACTACGCCCTGATCGGCGCACTGCGAGC +AGTAGCCCAAACAATCTCATATGAAGTCACCCTAGCCATCATTCTACTATCAACATTACTAATAAGTGGC +TCCTTTAACCTCTCCACCCTTATCACAACACAAGAACACCTCTGATTACTCCTGCCATCATGACCCTTGG +CCATAATATGATTTATCTCCACACTAGCAGAGACCAACCGAACCCCCTTCGACCTTGCCGAAGGGGAGTC +CGAACTAGTCTCAGGCTTCAACATCGAATACGCCGCAGGCCCCTTCGCCCTATTCTTCATAGCCGAATAC +ACAAACATTATTATAATAAACACCCTCACCACTACAATCTTCCTAGGAACAACATATGACGCACTCTCCC +CTGAACTCTACACAACATATTTTGTCACCAAGACCCTACTTCTAACCTCCCTGTTCTTATGAATTCGAAC +AGCATACCCCCGATTCCGCTACGACCAACTCATACACCTCCTATGAAAAAACTTCCTACCACTCACCCTA +GCATTACTTATATGATATGTCTCCATACCCATTACAATCTCCAGCATTCCCCCTCAAACCTAAGAAATAT +GTCTGATAAAAGAGTTACTTTGATAGAGTAAATAATAGGAGCTTAAACCCCCTTATTTCTAGGACTATGA +GAATCGAACCCATCCCTGAGAATCCAAAATTCTCCGTGCCACCTATCACACCCCATCCTAAAGTAAGGTC +AGCTAAATAAGCTATCGGGCCCATACCCCGAAAATGTTGGTTATACCCTTCCCGTACTAATTAATCCCCT +GGCCCAACCCGTCATCTACTCTACCATCTTTGCAGGCACACTCATCACAGCGCTAAGCTCGCACTGATTT +TTTACCTGAGTAGGCCTAGAAATAAACATGCTAGCTTTTATTCCAGTTCTAACCAAAAAAATAAACCCTC +GTTCCACAGAAGCTGCCATCAAGTATTTCCTCACGCAAGCAACCGCATCCATAATCCTTCTAATAGCTAT +CCTCTTCAACAATATACTCTCCGGACAATGAACCATAACCAATACTACCAATCAATACTCATCATTAATA +ATCATAATAGCTATAGCAATAAAACTAGGAATAGCCCCCTTTCACTTCTGAGTCCCAGAGGTTACCCAAG +GCACCCCTCTGACATCCGGCCTGCTTCTTCTCACATGACAAAAACTAGCCCCCATCTCAATCATATACCA +AATCTCTCCCTCACTAAACGTAAGCCTTCTCCTCACTCTCTCAATCTTATCCATCATAGCAGGCAGTTGA +GGTGGATTAAACCAAACCCAGCTACGCAAAATCTTAGCATACTCCTCAATTACCCACATAGGATGAATAA +TAGCAGTTCTACCGTACAACCCTAACATAACCATTCTTAATTTAACTATTTATATTATCCTAACTACTAC +CGCATTCCTACTACTCAACTTAAACTCCAGCACCACGACCCTACTACTATCTCGCACCTGAAACAAGCTA +ACATGACTAACACCCTTAATTCCATCCACCCTCCTCTCCCTAGGAGGCCTGCCCCCGCTAACCGGCTTTT +TGCCCAAATGGGCCATTATCGAAGAATTCACAAAAAACAATAGCCTCATCATCCCCACCATCATAGCCAC +CATCACCCTCCTTAACCTCTACTTCTACCTACGCCTAATCTACTCCACCTCAATCACACTACTCCCCATA +TCTAACAACGTAAAAATAAAATGACAGTTTGAACATACAAAACCCACCCCATTCCTCCCCACACTCATCG +CCCTTACCACGCTACTCCTACCTATCTCCCCTTTTATACTAATAATCTTATAGAAATTTAGGTTAAATAC +AGACCAAGAGCCTTCAAAGCCCTCAGTAAGTTGCAATACTTAATTTCTGTAACAGCTAAGGACTGCAAAA +CCCCACTCTGCATCAACTGAACGCAAATCAGCCACTTTAATTAAGCTAAGCCCTTACTAGACCAATGGGA +CTTAAACCCACAAACACTTAGTTAACAGCTAAGCACCCTAATCAACTGGCTTCAATCTACTTCTCCCGCC +GCCGGGAAAAAAGGCGGGAGAAGCCCCGGCAGGTTTGAAGCTGCTTCTTCGAATTTGCAATTCAATATGA +AAATCACCTCGGAGCTGGTAAAAAGAGGCCTAACCCCTGTCTTTAGATTTACAGTCCAATGCTTCACTCA +GCCATTTTACCTCACCCCCACTGATGTTCGCCGACCGTTGACTATTCTCTACAAACCACAAAGACATTGG +AACACTATACCTATTATTCGGCGCATGAGCTGGAGTCCTAGGCACAGCTCTAAGCCTCCTTATTCGAGCC +GAGCTGGGCCAGCCAGGCAACCTTCTAGGTAACGACCACATCTACAACGTTATCGTCACAGCCCATGCAT +TTGTAATAATCTTCTTCATAGTAATACCCATCATAATCGGAGGCTTTGGCAACTGACTAGTTCCCCTAAT +AATCGGTGCCCCCGATATGGCGTTTCCCCGCATAAACAACATAAGCTTCTGACTCTTACCTCCCTCTCTC +CTACTCCTGCTCGCATCTGCTATAGTGGAGGCCGGAGCAGGAACAGGTTGAACAGTCTACCCTCCCTTAG +CAGGGAACTACTCCCACCCTGGAGCCTCCGTAGACCTAACCATCTTCTCCTTACACCTAGCAGGTGTCTC +CTCTATCTTAGGGGCCATCAATTTCATCACAACAATTATCAATATAAAACCCCCTGCCATAACCCAATAC +CAAACGCCCCTCTTCGTCTGATCCGTCCTAATCACAGCAGTCCTACTTCTCCTATCTCTCCCAGTCCTAG +CTGCTGGCATCACTATACTACTAACAGACCGCAACCTCAACACCACCTTCTTCGACCCCGCCGGAGGAGG +AGACCCCATTCTATACCAACACCTATTCTGATTTTTCGGTCACCCTGAAGTTTATATTCTTATCCTACCA +GGCTTCGGAATAATCTCCCATATTGTAACTTACTACTCCGGAAAAAAAGAACCATTTGGATACATAGGTA +TGGTCTGAGCTATGATATCAATTGGCTTCCTAGGGTTTATCGTGTGAGCACACCATATATTTACAGTAGG +AATAGACGTAGACACACGAGCATATTTCACCTCCGCTACCATAATCATCGCTATCCCCACCGGCGTCAAA +GTATTTAGCTGACTCGCCACACTCCACGGAAGCAATATGAAATGATCTGCTGCAGTGCTCTGAGCCCTAG +GATTCATCTTTCTTTTCACCGTAGGTGGCCTGACTGGCATTGTATTAGCAAACTCATCACTAGACATCGT +ACTACACGACACGTACTACGTTGTAGCCCACTTCCACTATGTCCTATCAATAGGAGCTGTATTTGCCATC +ATAGGAGGCTTCATTCACTGATTTCCCCTATTCTCAGGCTACACCCTAGACCAAACCTACGCCAAAATCC +ATTTCACTATCATATTCATCGGCGTAAATCTAACTTTCTTCCCACAACACTTTCTCGGCCTATCCGGAAT +GCCCCGACGTTACTCGGACTACCCCGATGCATACACCACATGAAACATCCTATCATCTGTAGGCTCATTC +ATTTCTCTAACAGCAGTAATATTAATAATTTTCATGATTTGAGAAGCCTTCGCTTCGAAGCGAAAAGTCC +TAATAGTAGAAGAACCCTCCATAAACCTGGAGTGACTATATGGATGCCCCCCACCCTACCACACATTCGA +AGAACCCGTATACATAAAATCTAGACAAAAAAGGAAGGAATCGAACCCCCCAAAGCTGGTTTCAAGCCAA +CCCCATGGCCTCCATGACTTTTTCAAAAAGGTATTAGAAAAACCATTTCATAACTTTGTCAAAGTTAAAT +TATAGGCTAAATCCTATATATCTTAATGGCACATGCAGCGCAAGTAGGTCTACAAGACGCTACTTCCCCT +ATCATAGAAGAGCTTATCACCTTTCATGATCACGCCCTCATAATCATTTTCCTTATCTGCTTCCTAGTCC +TGTATGCCCTTTTCCTAACACTCACAACAAAACTAACTAATACTAACATCTCAGACGCTCAGGAAATAGA +AACCGTCTGAACTATCCTGCCCGCCATCATCCTAGTCCTCATCGCCCTCCCATCCCTACGCATCCTTTAC +ATAACAGACGAGGTCAACGATCCCTCCCTTACCATCAAATCAATTGGCCACCAATGGTACTGAACCTACG +AGTACACCGACTACGGCGGACTAATCTTCAACTCCTACATACTTCCCCCATTATTCCTAGAACCAGGCGA +CCTGCGACTCCTTGACGTTGACAATCGAGTAGTACTCCCGATTGAAGCCCCCATTCGTATAATAATTACA +TCACAAGACGTCTTGCACTCATGAGCTGTCCCCACATTAGGCTTAAAAACAGATGCAATTCCCGGACGTC +TAAACCAAACCACTTTCACCGCTACACGACCGGGGGTATACTACGGTCAATGCTCTGAAATCTGTGGAGC +AAACCACAGTTTCATGCCCATCGTCCTAGAATTAATTCCCCTAAAAATCTTTGAAATAGGGCCCGTATTT +ACCCTATAGCACCCCCTCTACCCCCTCTAGAGCCCACTGTAAAGCTAACTTAGCATTAACCTTTTAAGTT +AAAGATTAAGAGAACCAACACCTCTTTACAGTGAAATGCCCCAACTAAATACTACCGTATGGCCCACCAT +AATTACCCCCATACTCCTTACACTATTCCTCATCACCCAACTAAAAATATTAAACACAAACTACCACCTA +CCTCCCTCACCAAAGCCCATAAAAATAAAAAATTATAACAAACCCTGAGAACCAAAATGAACGAAAATCT +GTTCGCTTCATTCATTGCCCCCACAATCCTAGGCCTACCCGCCGCAGTACTGATCATTCTATTTCCCCCT +CTATTGATCCCCACCTCCAAATATCTCATCAACAACCGACTAATCACCACCCAACAATGACTAATCAAAC +TAACCTCAAAACAAATGATAACCATACACAACACTAAAGGACGAACCTGATCTCTTATACTAGTATCCTT +AATCATTTTTATTGCCACAACTAACCTCCTCGGACTCCTGCCTCACTCATTTACACCAACCACCCAACTA +TCTATAAACCTAGCCATGGCCATCCCCTTATGAGCGGGCACAGTGATTATAGGCTTTCGCTCTAAGATTA +AAAATGCCCTAGCCCACTTCTTACCACAAGGCACACCTACACCCCTTATCCCCATACTAGTTATTATCGA +AACCATCAGCCTACTCATTCAACCAATAGCCCTGGCCGTACGCCTAACCGCTAACATTACTGCAGGCCAC +CTACTCATGCACCTAATTGGAAGCGCCACCCTAGCAATATCAACCATTAACCTTCCCTCTACACTTATCA +TCTTCACAATTCTAATTCTACTGACTATCCTAGAAATCGCTGTCGCCTTAATCCAAGCCTACGTTTTCAC +ACTTCTAGTAAGCCTCTACCTGCACGACAACACATAATGACCCACCAATCACATGCCTATCATATAGTAA +AACCCAGCCCATGACCCCTAACAGGGGCCCTCTCAGCCCTCCTAATGACCTCCGGCCTAGCCATGTGATT +TCACTTCCACTCCATAACGCTCCTCATACTAGGCCTACTAACCAACACACTAACCATATACCAATGATGG +CGCGATGTAACACGAGAAAGCACATACCAAGGCCACCACACACCACCTGTCCAAAAAGGCCTTCGATACG +GGATAATCCTATTTATTACCTCAGAAGTTTTTTTCTTCGCAGGATTTTTCTGAGCCTTTTACCACTCCAG +CCTAGCCCCTACCCCCCAATTAGGAGGGCACTGGCCCCCAACAGGCATCACCCCGCTAAATCCCCTAGAA +GTCCCACTCCTAAACACATCCGTATTACTCGCATCAGGAGTATCAATCACCTGAGCTCACCATAGTCTAA +TAGAAAACAACCGAAACCAAATAATTCAAGCACTGCTTATTACAATTTTACTGGGTCTCTATTTTACCCT +CCTACAAGCCTCAGAGTACTTCGAGTCTCCCTTCACCATTTCCGACGGCATCTACGGCTCAACATTTTTT +GTAGCCACAGGCTTCCACGGACTTCACGTCATTATTGGCTCAACTTTCCTCACTATCTGCTTCATCCGCC +AACTAATATTTCACTTTACATCCAAACATCACTTTGGCTTCGAAGCCGCCGCCTGATACTGGCATTTTGT +AGATGTGGTTTGACTATTTCTGTATGTCTCCATCTATTGATGAGGGTCTTACTCTTTTAGTATAAATAGT +ACCGTTAACTTCCAATTAACTAGTTTTGACAACATTCAAAAAAGAGTAATAAACTTCGCCTTAATTTTAA +TAATCAACACCCTCCTAGCCTTACTACTAATAATTATTACATTTTGACTACCACAACTCAACGGCTACAT +AGAAAAATCCACCCCTTACGAGTGCGGCTTCGACCCTATATCCCCCGCCCGCGTCCCTTTCTCCATAAAA +TTCTTCTTAGTAGCTATTACCTTCTTATTATTTGATCTAGAAATTGCCCTCCTTTTACCCCTACCATGAG +CCCTACAAACAACTAACCTGCCACTAATAGTTATGTCATCCCTCTTATTAATCATCATCCTAGCCCTAAG +TCTGGCCTATGAGTGACTACAAAAAGGATTAGACTGAACCGAATTGGTATATAGTTTAAACAAAACGAAT +GATTTCGACTCATTAAATTATGATAATCATATTTACCAAATGCCCCTCATTTACATAAATATTATACTAG +CATTTACCATCTCACTTCTAGGAATACTAGTATATCGCTCACACCTCATATCCTCCCTACTATGCCTAGA +AGGAATAATACTATCGCTGTTCATTATAGCTACTCTCATAACCCTCAACACCCACTCCCTCTTAGCCAAT +ATTGTGCCTATTGCCATACTAGTCTTTGCCGCCTGCGAAGCAGCGGTGGGCCTAGCCCTACTAGTCTCAA +TCTCCAACACATATGGCCTAGACTACGTACATAACCTAAACCTACTCCAATGCTAAAACTAATCGTCCCA +ACAATTATATTACTACCACTGACATGACTTTCCAAAAAACACATAATTTGAATCAACACAACCACCCACA +GCCTAATTATTAGCATCATCCCTCTACTATTTTTTAACCAAATCAACAACAACCTATTTAGCTGTTCCCC +AACCTTTTCCTCCGACCCCCTAACAACCCCCCTCCTAATACTAACTACCTGACTCCTACCCCTCACAATC +ATGGCAAGCCAACGCCACTTATCCAGTGAACCACTATCACGAAAAAAACTCTACCTCTCTATACTAATCT +CCCTACAAATCTCCTTAATTATAACATTCACAGCCACAGAACTAATCATATTTTATATCTTCTTCGAAAC +CACACTTATCCCCACCTTGGCTATCATCACCCGATGAGGCAACCAGCCAGAACGCCTGAACGCAGGCACA +TACTTCCTATTCTACACCCTAGTAGGCTCCCTTCCCCTACTCATCGCACTAATTTACACTCACAACACCC +TAGGCTCACTAAACATTCTACTACTCACTCTCACTGCCCAAGAACTATCAAACTCCTGAGCCAACAACTT +AATATGACTAGCTTACACAATAGCTTTTATAGTAAAGATACCTCTTTACGGACTCCACTTATGACTCCCT +AAAGCCCATGTCGAAGCCCCCATCGCTGGGTCAATAGTACTTGCCGCAGTACTCTTAAAACTAGGCGGCT +ATGGTATAATACGCCTCACACTCATTCTCAACCCCCTGACAAAACACATAGCCTACCCCTTCCTTGTACT +ATCCCTATGAGGCATAATTATAACAAGCTCCATCTGCCTACGACAAACAGACCTAAAATCGCTCATTGCA +TACTCTTCAATCAGCCACATAGCCCTCGTAGTAACAGCCATTCTCATCCAAACCCCCTGAAGCTTCACCG +GCGCAGTCATTCTCATAATCGCCCACGGGCTTACATCCTCATTACTATTCTGCCTAGCAAACTCAAACTA +CGAACGCACTCACAGTCGCATCATAATCCTCTCTCAAGGACTTCAAACTCTACTCCCACTAATAGCTTTT +TGATGACTTCTAGCAAGCCTCGCTAACCTCGCCTTACCCCCCACTATTAACCTACTGGGAGAACTCTCTG +TGCTAGTAACCACGTTCTCCTGATCAAATATCACTCTCCTACTTACAGGACTCAACATACTAGTCACAGC +CCTATACTCCCTCTACATATTTACCACAACACAATGGGGCTCACTCACCCACCACATTAACAACATAAAA +CCCTCATTCACACGAGAAAACACCCTCATGTTCATACACCTATCCCCCATTCTCCTCCTATCCCTCAACC +CCGACATCATTACCGGGTTTTCCTCTTGTAAATATAGTTTAACCAAAACATCAGATTGTGAATCTGACAA +CAGAGGCTTACGACCCCTTATTTACCGAGAAAGCTCACAAGAACTGCTAACTCATGCCCCCATGTCTAAC +AACATGGCTTTCTCAACTTTTAAAGGATAACAGCTATCCATTGGTCTTAGGCCCCAAAAATTTTGGTGCA +ACTCCAAATAAAAGTAATAACCATGCACACTACTATAACCACCCTAACCCTGACTTCCCTAATTCCCCCC +ATCCTTACCACCCTCGTTAACCCTAACAAAAAAAACTCATACCCCCATTATGTAAAATCCATTGTCGCAT +CCACCTTTATTATCAGTCTCTTCCCCACAACAATATTCATGTGCCTAGACCAAGAAGTTATTATCTCGAA +CTGACACTGAGCCACAACCCAAACAACCCAGCTCTCCCTAAGCTTCAAACTAGACTACTTCTCCATAATA +TTCATCCCTGTAGCATTGTTCGTTACATGGTCCATCATAGAATTCTCACTGTGATATATAAACTCAGACC +CAAACATTAATCAGTTCTTCAAATATCTACTCATCTTCCTAATTACCATACTAATCTTAGTTACCGCTAA +CAACCTATTCCAACTGTTCATCGGCTGAGAGGGCGTAGGAATTATATCCTTCTTGCTCATCAGTTGATGA +TACGCCCGAGCAGATGCCAACACAGCAGCCATTCAAGCAATCCTATACAACCGTATCGGCGATATCGGTT +TCATCCTCGCCTTAGCATGATTTATCCTACACTCCAACTCATGAGACCCACAACAAATAGCCCTTCTAAA +CGCTAATCCAAGCCTCACCCCACTACTAGGCCTCCTCCTAGCAGCAGCAGGCAAATCAGCCCAATTAGGT +CTCCACCCCTGACTCCCCTCAGCCATAGAAGGCCCCACCCCAGTCTCAGCCCTACTCCACTCAAGCACTA +TAGTTGTAGCAGGAATCTTCTTACTCATCCGCTTCCACCCCCTAGCAGAAAATAGCCCACTAATCCAAAC +TCTAACACTATGCTTAGGCGCTATCACCACTCTGTTCGCAGCAGTCTGCGCCCTTACACAAAATGACATC +AAAAAAATCGTAGCCTTCTCCACTTCAAGTCAACTAGGACTCATAATAGTTACAATCGGCATCAACCAAC +CACACCTAGCATTCCTGCACATCTGTACCCACGCCTTCTTCAAAGCCATACTATTTATGTGCTCCGGGTC +CATCATCCACAACCTTAACAATGAACAAGATATTCGAAAAATAGGAGGACTACTCAAAACCATACCTCTC +ACTTCAACCTCCCTCACCATTGGCAGCCTAGCATTAGCAGGAATACCTTTCCTCACAGGTTTCTACTCCA +AAGACCACATCATCGAAACCGCAAACATATCATACACAAACGCCTGAGCCCTATCTATTACTCTCATCGC +TACCTCCCTGACAAGCGCCTATAGCACTCGAATAATTCTTCTCACCCTAACAGGTCAACCTCGCTTCCCC +ACCCTTACTAACATTAACGAAAATAACCCCACCCTACTAAACCCCATTAAACGCCTGGCAGCCGGAAGCC +TATTCGCAGGATTTCTCATTACTAACAACATTTCCCCCGCATCCCCCTTCCAAACAACAATCCCCCTCTA +CCTAAAACTCACAGCCCTCGCTGTCACTTTCCTAGGACTTCTAACAGCCCTAGACCTCAACTACCTAACC +AACAAACTTAAAATAAAATCCCCACTATGCACATTTTATTTCTCCAACATACTCGGATTCTACCCTAGCA +TCACACACCGCACAATCCCCTATCTAGGCCTTCTTACGAGCCAAAACCTGCCCCTACTCCTCCTAGACCT +AACCTGACTAGAAAAGCTATTACCTAAAACAATTTCACAGCACCAAATCTCCACCTCCATCATCACCTCA +ACCCAAAAAGGCATAATTAAACTTTACTTCCTCTCTTTCTTCTTCCCACTCATCCTAACCCTACTCCTAA +TCACATAACCTATTCCCCCGAGCAATCTCAATTACAATATATACACCAACAAACAATGTTCAACCAGTAA +CTACTACTAATCAACGCCCATAATCATACAAAGCCCCCGCACCAATAGGATCCTCCCGAATCAACCCTGA +CCCCTCTCCTTCATAAATTATTCAGCTTCCTACACTATTAAAGTTTACCACAACCACCACCCCATCATAC +TCTTTCACCCACAGCACCAATCCTACCTCCATCGCTAACCCCACTAAAACACTCACCAAGACCTCAACCC +CTGACCCCCATGCCTCAGGATACTCCTCAATAGCCATCGCTGTAGTATATCCAAAGACAACCATCATTCC +CCCTAAATAAATTAAAAAAACTATTAAACCCATATAACCTCCCCCAAAATTCAGAATAATAACACACCCG +ACCACACCGCTAACAATCAATACTAAACCCCCATAAATAGGAGAAGGCTTAGAAGAAAACCCCACAAACC +CCATTACTAAACCCACACTCAACAGAAACAAAGCATACATCATTATTCTCGCACGGACTACAACCACGAC +CAATGATATGAAAAACCATCGTTGTATTTCAACTACAAGAACACCAATGACCCCAATACGCAAAACTAAC +CCCCTAATAAAATTAATTAACCACTCATTCATCGACCTCCCCACCCCATCCAACATCTCCGCATGATGAA +ACTTCGGCTCACTCCTTGGCGCCTGCCTGATCCTCCAAATCACCACAGGACTATTCCTAGCCATGCACTA +CTCACCAGACGCCTCAACCGCCTTTTCATCAATCGCCCACATCACTCGAGACGTAAATTATGGCTGAATC +ATCCGCTACCTTCACGCCAATGGCGCCTCAATATTCTTTATCTGCCTCTTCCTACACATCGGGCGAGGCC +TATATTACGGATCATTTCTCTACTCAGAAACCTGAAACATCGGCATTATCCTCCTGCTTGCAACTATAGC +AACAGCCTTCATAGGCTATGTCCTCCCGTGAGGCCAAATATCATTCTGAGGGGCCACAGTAATTACAAAC +TTACTATCCGCCATCCCATACATTGGGACAGACCTAGTTCAATGAATCTGAGGAGGCTACTCAGTAGACA +GTCCCACCCTCACACGATTCTTTACCTTTCACTTCATCTTGCCCTTCATTATTGCAGCCCTAGCAACACT +CCACCTCCTATTCTTGCACGAAACGGGATCAAACAACCCCCTAGGAATCACCTCCCATTCCGATAAAATC +ACCTTCCACCCTTACTACACAATCAAAGACGCCCTCGGCTTACTTCTCTTCCTTCTCTCCTTAATGACAT +TAACACTATTCTCACCAGACCTCCTAGGCGACCCAGACAATTATACCCTAGCCAACCCCTTAAACACCCC +TCCCCACATCAAGCCCGAATGATATTTCCTATTCGCCTACACAATTCTCCGATCCGTCCCTAACAAACTA +GGAGGCGTCCTTGCCCTATTACTATCCATCCTCATCCTAGCAATAATCCCCATCCTCCATATATCCAAAC +AACAAAGCATAATATTTCGCCCACTAAGCCAATCACTTTATTGACTCCTAGCCGCAGACCTCCTCATTCT +AACCTGAATCGGAGGACAACCAGTAAGCTACCCTTTTACCATCATTGGACAAGTAGCATCCGTACTATAC +TTCACAACAATCCTAATCCTAATACCAACTATCTCCCTAATTGAAAACAAAATACTCAAATGGGCCTGTC +CTTGTAGTATAAACTAATACACCAGTCTTGTAAACCGGAGATGAAAACCTTTTTCCAAGGACAAATCAGA +GAAAAAGTCTTTAACTCCACCATTAGCACCCAAAGCTAAGATTCTAATTTAAACTATTCTCTGTTCTTTC +ATGGGGAAGCAGATTTGGGTACCACCCAAGTATTGACTCACCCATCAACAACCGCTATGTATTTCGTACA +TTACTGCCAGCCACCATGAATATTGTACGGTACCATAAATACTTGACCACCTGTAGTACATAAAAACCCA +ATCCACATCAAAACCCCCTCCCCATGCTTACAAGCAAGTACAGCAATCAACCCTCAACTATCACACATCA +ACTGCAACTCCAAAGCCACCCCTCACCCACTAGGATACCAACAAACCTACCCACCCTTAACAGTACATAG +TACATAAAGCCATTTACCGTACATAGCACATTACAGTCAAATCCCTTCTCGTCCCCATGGATGACCCCCC +TCAGATAGGGGTCCCTTGACCACCATCCTCCGTGAAATCAATATCCCGCACAAGAGTGCTACTCTCCTCG +CTCCGGGCCCATAACACTTGGGGGTAGCTAAAGTGAACTGTATCCGACATCTGGTTCCTACTTCAGGGTC +ATAAAGCCTAAATAGCCCACACGTTCCCCTTAAATAAGACATCACGATG + diff -r aceaf1d94d2d -r 2a6cfe8997aa test-data/bowtie2-test1.bam Binary file test-data/bowtie2-test1.bam has changed diff -r aceaf1d94d2d -r 2a6cfe8997aa test-data/bowtie2/phix_genome.fasta --- a/test-data/bowtie2/phix_genome.fasta Mon Nov 10 13:58:50 2014 -0500 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,78 +0,0 @@ ->gi|9626372|ref|NC_001422.1| Enterobacteria phage phiX174, complete genome -GAGTTTTATCGCTTCCATGACGCAGAAGTTAACACTTTCGGATATTTCTGATGAGTCGAAAAATTATCTT -GATAAAGCAGGAATTACTACTGCTTGTTTACGAATTAAATCGAAGTGGACTGCTGGCGGAAAATGAGAAA -ATTCGACCTATCCTTGCGCAGCTCGAGAAGCTCTTACTTTGCGACCTTTCGCCATCAACTAACGATTCTG -TCAAAAACTGACGCGTTGGATGAGGAGAAGTGGCTTAATATGCTTGGCACGTTCGTCAAGGACTGGTTTA -GATATGAGTCACATTTTGTTCATGGTAGAGATTCTCTTGTTGACATTTTAAAAGAGCGTGGATTACTATC -TGAGTCCGATGCTGTTCAACCACTAATAGGTAAGAAATCATGAGTCAAGTTACTGAACAATCCGTACGTT -TCCAGACCGCTTTGGCCTCTATTAAGCTCATTCAGGCTTCTGCCGTTTTGGATTTAACCGAAGATGATTT -CGATTTTCTGACGAGTAACAAAGTTTGGATTGCTACTGACCGCTCTCGTGCTCGTCGCTGCGTTGAGGCT -TGCGTTTATGGTACGCTGGACTTTGTGGGATACCCTCGCTTTCCTGCTCCTGTTGAGTTTATTGCTGCCG -TCATTGCTTATTATGTTCATCCCGTCAACATTCAAACGGCCTGTCTCATCATGGAAGGCGCTGAATTTAC -GGAAAACATTATTAATGGCGTCGAGCGTCCGGTTAAAGCCGCTGAATTGTTCGCGTTTACCTTGCGTGTA -CGCGCAGGAAACACTGACGTTCTTACTGACGCAGAAGAAAACGTGCGTCAAAAATTACGTGCGGAAGGAG -TGATGTAATGTCTAAAGGTAAAAAACGTTCTGGCGCTCGCCCTGGTCGTCCGCAGCCGTTGCGAGGTACT -AAAGGCAAGCGTAAAGGCGCTCGTCTTTGGTATGTAGGTGGTCAACAATTTTAATTGCAGGGGCTTCGGC -CCCTTACTTGAGGATAAATTATGTCTAATATTCAAACTGGCGCCGAGCGTATGCCGCATGACCTTTCCCA -TCTTGGCTTCCTTGCTGGTCAGATTGGTCGTCTTATTACCATTTCAACTACTCCGGTTATCGCTGGCGAC -TCCTTCGAGATGGACGCCGTTGGCGCTCTCCGTCTTTCTCCATTGCGTCGTGGCCTTGCTATTGACTCTA -CTGTAGACATTTTTACTTTTTATGTCCCTCATCGTCACGTTTATGGTGAACAGTGGATTAAGTTCATGAA -GGATGGTGTTAATGCCACTCCTCTCCCGACTGTTAACACTACTGGTTATATTGACCATGCCGCTTTTCTT -GGCACGATTAACCCTGATACCAATAAAATCCCTAAGCATTTGTTTCAGGGTTATTTGAATATCTATAACA -ACTATTTTAAAGCGCCGTGGATGCCTGACCGTACCGAGGCTAACCCTAATGAGCTTAATCAAGATGATGC -TCGTTATGGTTTCCGTTGCTGCCATCTCAAAAACATTTGGACTGCTCCGCTTCCTCCTGAGACTGAGCTT -TCTCGCCAAATGACGACTTCTACCACATCTATTGACATTATGGGTCTGCAAGCTGCTTATGCTAATTTGC -ATACTGACCAAGAACGTGATTACTTCATGCAGCGTTACCATGATGTTATTTCTTCATTTGGAGGTAAAAC -CTCTTATGACGCTGACAACCGTCCTTTACTTGTCATGCGCTCTAATCTCTGGGCATCTGGCTATGATGTT -GATGGAACTGACCAAACGTCGTTAGGCCAGTTTTCTGGTCGTGTTCAACAGACCTATAAACATTCTGTGC -CGCGTTTCTTTGTTCCTGAGCATGGCACTATGTTTACTCTTGCGCTTGTTCGTTTTCCGCCTACTGCGAC -TAAAGAGATTCAGTACCTTAACGCTAAAGGTGCTTTGACTTATACCGATATTGCTGGCGACCCTGTTTTG -TATGGCAACTTGCCGCCGCGTGAAATTTCTATGAAGGATGTTTTCCGTTCTGGTGATTCGTCTAAGAAGT -TTAAGATTGCTGAGGGTCAGTGGTATCGTTATGCGCCTTCGTATGTTTCTCCTGCTTATCACCTTCTTGA -AGGCTTCCCATTCATTCAGGAACCGCCTTCTGGTGATTTGCAAGAACGCGTACTTATTCGCCACCATGAT -TATGACCAGTGTTTCCAGTCCGTTCAGTTGTTGCAGTGGAATAGTCAGGTTAAATTTAATGTGACCGTTT -ATCGCAATCTGCCGACCACTCGCGATTCAATCATGACTTCGTGATAAAAGATTGAGTGTGAGGTTATAAC -GCCGAAGCGGTAAAAATTTTAATTTTTGCCGCTGAGGGGTTGACCAAGCGAAGCGCGGTAGGTTTTCTGC -TTAGGAGTTTAATCATGTTTCAGACTTTTATTTCTCGCCATAATTCAAACTTTTTTTCTGATAAGCTGGT -TCTCACTTCTGTTACTCCAGCTTCTTCGGCACCTGTTTTACAGACACCTAAAGCTACATCGTCAACGTTA -TATTTTGATAGTTTGACGGTTAATGCTGGTAATGGTGGTTTTCTTCATTGCATTCAGATGGATACATCTG -TCAACGCCGCTAATCAGGTTGTTTCTGTTGGTGCTGATATTGCTTTTGATGCCGACCCTAAATTTTTTGC -CTGTTTGGTTCGCTTTGAGTCTTCTTCGGTTCCGACTACCCTCCCGACTGCCTATGATGTTTATCCTTTG -AATGGTCGCCATGATGGTGGTTATTATACCGTCAAGGACTGTGTGACTATTGACGTCCTTCCCCGTACGC -CGGGCAATAACGTTTATGTTGGTTTCATGGTTTGGTCTAACTTTACCGCTACTAAATGCCGCGGATTGGT -TTCGCTGAATCAGGTTATTAAAGAGATTATTTGTCTCCAGCCACTTAAGTGAGGTGATTTATGTTTGGTG -CTATTGCTGGCGGTATTGCTTCTGCTCTTGCTGGTGGCGCCATGTCTAAATTGTTTGGAGGCGGTCAAAA -AGCCGCCTCCGGTGGCATTCAAGGTGATGTGCTTGCTACCGATAACAATACTGTAGGCATGGGTGATGCT -GGTATTAAATCTGCCATTCAAGGCTCTAATGTTCCTAACCCTGATGAGGCCGCCCCTAGTTTTGTTTCTG -GTGCTATGGCTAAAGCTGGTAAAGGACTTCTTGAAGGTACGTTGCAGGCTGGCACTTCTGCCGTTTCTGA -TAAGTTGCTTGATTTGGTTGGACTTGGTGGCAAGTCTGCCGCTGATAAAGGAAAGGATACTCGTGATTAT -CTTGCTGCTGCATTTCCTGAGCTTAATGCTTGGGAGCGTGCTGGTGCTGATGCTTCCTCTGCTGGTATGG -TTGACGCCGGATTTGAGAATCAAAAAGAGCTTACTAAAATGCAACTGGACAATCAGAAAGAGATTGCCGA -GATGCAAAATGAGACTCAAAAAGAGATTGCTGGCATTCAGTCGGCGACTTCACGCCAGAATACGAAAGAC -CAGGTATATGCACAAAATGAGATGCTTGCTTATCAACAGAAGGAGTCTACTGCTCGCGTTGCGTCTATTA -TGGAAAACACCAATCTTTCCAAGCAACAGCAGGTTTCCGAGATTATGCGCCAAATGCTTACTCAAGCTCA -AACGGCTGGTCAGTATTTTACCAATGACCAAATCAAAGAAATGACTCGCAAGGTTAGTGCTGAGGTTGAC -TTAGTTCATCAGCAAACGCAGAATCAGCGGTATGGCTCTTCTCATATTGGCGCTACTGCAAAGGATATTT -CTAATGTCGTCACTGATGCTGCTTCTGGTGTGGTTGATATTTTTCATGGTATTGATAAAGCTGTTGCCGA -TACTTGGAACAATTTCTGGAAAGACGGTAAAGCTGATGGTATTGGCTCTAATTTGTCTAGGAAATAACCG -TCAGGATTGACACCCTCCCAATTGTATGTTTTCATGCCTCCAAATCTTGGAGGCTTTTTTATGGTTCGTT -CTTATTACCCTTCTGAATGTCACGCTGATTATTTTGACTTTGAGCGTATCGAGGCTCTTAAACCTGCTAT -TGAGGCTTGTGGCATTTCTACTCTTTCTCAATCCCCAATGCTTGGCTTCCATAAGCAGATGGATAACCGC -ATCAAGCTCTTGGAAGAGATTCTGTCTTTTCGTATGCAGGGCGTTGAGTTCGATAATGGTGATATGTATG -TTGACGGCCATAAGGCTGCTTCTGACGTTCGTGATGAGTTTGTATCTGTTACTGAGAAGTTAATGGATGA -ATTGGCACAATGCTACAATGTGCTCCCCCAACTTGATATTAATAACACTATAGACCACCGCCCCGAAGGG -GACGAAAAATGGTTTTTAGAGAACGAGAAGACGGTTACGCAGTTTTGCCGCAAGCTGGCTGCTGAACGCC -CTCTTAAGGATATTCGCGATGAGTATAATTACCCCAAAAAGAAAGGTATTAAGGATGAGTGTTCAAGATT -GCTGGAGGCCTCCACTATGAAATCGCGTAGAGGCTTTGCTATTCAGCGTTTGATGAATGCAATGCGACAG -GCTCATGCTGATGGTTGGTTTATCGTTTTTGACACTCTCACGTTGGCTGACGACCGATTAGAGGCGTTTT -ATGATAATCCCAATGCTTTGCGTGACTATTTTCGTGATATTGGTCGTATGGTTCTTGCTGCCGAGGGTCG -CAAGGCTAATGATTCACACGCCGACTGCTATCAGTATTTTTGTGTGCCTGAGTATGGTACAGCTAATGGC -CGTCTTCATTTCCATGCGGTGCACTTTATGCGGACACTTCCTACAGGTAGCGTTGACCCTAATTTTGGTC -GTCGGGTACGCAATCGCCGCCAGTTAAATAGCTTGCAAAATACGTGGCCTTATGGTTACAGTATGCCCAT -CGCAGTTCGCTACACGCAGGACGCTTTTTCACGTTCTGGTTGGTTGTGGCCTGTTGATGCTAAAGGTGAG -CCGCTTAAAGCTACCAGTTATATGGCTGTTGGTTTCTATGTGGCTAAATACGTTAACAAAAAGTCAGATA -TGGACCTTGCTGCTAAAGGTCTAGGAGCTAAAGAATGGAACAACTCACTAAAAACCAAGCTGTCGCTACT -TCCCAAGAAGCTGTTCAGAATCAGAATGAGCCGCAACTTCGGGATGAAAATGCTCACAATGACAAATCTG -TCCACGGAGTGCTTAATCCAACTTACCAAGCTGGGTTACGACGCGACGCCGTTCAACCAGATATTGAAGC -AGAACGCAAAAAGAGAGATGAGATTGAGGCTGGGAAAAGTTACTGTAGCCGACGTTTTGGCGGCGCAACC -TGTGACGACAAATCTGCTCAAATTTATGCGCGCTTCGATAAAAATGATTGGCGTATCCAACCTGCA \ No newline at end of file diff -r aceaf1d94d2d -r 2a6cfe8997aa test-data/bowtie2/phix_mapped.bam Binary file test-data/bowtie2/phix_mapped.bam has changed diff -r aceaf1d94d2d -r 2a6cfe8997aa test-data/bowtie2/phix_reads.fastq --- a/test-data/bowtie2/phix_reads.fastq Mon Nov 10 13:58:50 2014 -0500 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,260 +0,0 @@ -@HWI-EAS210R_0001:4:10:890:1882#0/1 -AATCTCATCTCTCTTTTTGCGTTCTGCTTCAATATCTG -+HWI-EAS210R_0001:4:10:890:1882#0/1 -fcceeggggggggggggffghggggggggggggggggg -@HWI-EAS210R_0001:4:10:890:1010#0/1 -GTTGTTTCTGTTGGTGCTGATATTGCTTTTGATGCCGA -+HWI-EAS210R_0001:4:10:890:1010#0/1 -gggggggggggggghgggggggggfggggggggggggg -@HWI-EAS210R_0001:4:10:890:1780#0/1 -GAGGCCTCCACTATGAAATCGCGTAGAGGCTTTGCTAT -+HWI-EAS210R_0001:4:10:890:1780#0/1 -ggfhggggggggggggggggghgggggfggggggdggg -@HWI-EAS210R_0001:4:10:890:1348#0/1 -TTGAGCGTATCGAGGCTCTTAAACCTGCTATTGAGGCT -+HWI-EAS210R_0001:4:10:890:1348#0/1 -ggggggggggggggggggggggggghfggeggggggdg -@HWI-EAS210R_0001:4:10:890:1707#0/1 -AAAAGAGATTGCTGGCATTCAGTCGGCGACTTCACGCC -+HWI-EAS210R_0001:4:10:890:1707#0/1 -gfgfgfgggggggfggeggggffgcgggdfggfggdgg -@HWI-EAS210R_0001:4:10:890:1527#0/1 -CGTACTTATTCGCCACCATGATTATGACCAGTGTTTCC -+HWI-EAS210R_0001:4:10:890:1527#0/1 -gggggggggggggggggggggggggggggggggggggg -@HWI-EAS210R_0001:4:10:890:781#0/1 -CGGAAAACGAACAAGCGCAAGAGTAAACATAGTGCCAT -+HWI-EAS210R_0001:4:10:890:781#0/1 -gggggggggggggggggggggggggggggggghggggg -@HWI-EAS210R_0001:4:10:890:568#0/1 -GTTTATCGCAATCTGCCGACCACTCGCGATTCAATCAT -+HWI-EAS210R_0001:4:10:890:568#0/1 -gggggggfgggggggggggggggggggggggggggggg -@HWI-EAS210R_0001:4:10:890:1365#0/1 -CCAACATAAACATTATTGCCCGGCGTACGAGGAAGGAC -+HWI-EAS210R_0001:4:10:890:1365#0/1 -eggggdggfghggggggggghgfgfegghfggfgggge -@HWI-EAS210R_0001:4:10:890:161#0/1 -GTGATTATCTTGCTGCTGCATTTCCTGAGCTTAATGCT -+HWI-EAS210R_0001:4:10:890:161#0/1 -ggggfg_gggfegggfgeggaefefdbfddeedgcgg` -@HWI-EAS210R_0001:4:10:890:1920#0/1 -TTTATCAATACCATGAAAAATATCAACCACACCAGAAG -+HWI-EAS210R_0001:4:10:890:1920#0/1 -gggggggggggggggggggggffggggggggggggggg -@HWI-EAS210R_0001:4:10:890:61#0/1 -GTCGCGTCGTAACCCAGCTTGGTAAGTTGGATTAAGCA -+HWI-EAS210R_0001:4:10:890:61#0/1 -eede[egfggfggggggggggggegggggfgggggggg -@HWI-EAS210R_0001:4:10:890:1284#0/1 -AAGCGCAAGAGTAAACATAGTGCCATGCTCAGGAACAA -+HWI-EAS210R_0001:4:10:890:1284#0/1 -gggggggggggggggggggggggggggggggggggggg -@HWI-EAS210R_0001:4:10:890:208#0/1 -CAGACCTATAAACATTCTGTGCCGCGTTTCTTTGTTCC -+HWI-EAS210R_0001:4:10:890:208#0/1 -gggeggggggggggggggggggggggggggggddgggg -@HWI-EAS210R_0001:4:10:890:859#0/1 -CAATAGATGTGGTAGAAGTCGTCATTTGGCGAGAAAGC -+HWI-EAS210R_0001:4:10:890:859#0/1 -ggggcgggggggggggdgfggggggggfggggghgggh -@HWI-EAS210R_0001:4:10:890:1947#0/1 -TCAACGCCGCTAATCAGGTTGTTTCTGTTGGTGCTGAT -+HWI-EAS210R_0001:4:10:890:1947#0/1 -ggggggggggggggggggeggggggggggggfgfgggg -@HWI-EAS210R_0001:4:10:890:416#0/1 -AATGTCTAAAGGTAAAAAACGTTCTGGCGCTCGCCCTG -+HWI-EAS210R_0001:4:10:890:416#0/1 -eggggggggggdcgggggfggfgggggfcgfggggggg -@HWI-EAS210R_0001:4:10:890:654#0/1 -GCAGCAAGGTCCATATCTGACTTTTTGTTAACGTATTT -+HWI-EAS210R_0001:4:10:890:654#0/1 -ggggghggggghggggghgfggggfgdfffgggggggg -@HWI-EAS210R_0001:4:10:890:269#0/1 -CTTGAAGGCTTCCCATTCATTCAGGAACCGCCTTCTGG -+HWI-EAS210R_0001:4:10:890:269#0/1 -eecaadggggggggggggggggdgg\ffffgggggggg -@HWI-EAS210R_0001:4:10:890:657#0/1 -TACCAGCTTTAGCCATAGCACCAGAAACAAAACTAGGG -+HWI-EAS210R_0001:4:10:890:657#0/1 -ggggghggggffgggfggggggfggfggggfffgfggg -@HWI-EAS210R_0001:4:10:890:1449#0/1 -TTCAAGATTGCTGGAGGCCTCCACTATGAAATCGCGTA -+HWI-EAS210R_0001:4:10:890:1449#0/1 -ggggggggggggggggfgggghgggggggggggghhfh -@HWI-EAS210R_0001:4:10:890:305#0/1 -CACGTTGGCTGACGACCGATTAGAGGCGTTTTATGATA -+HWI-EAS210R_0001:4:10:890:305#0/1 -gggegggfgggfggggggdgggdggfgffggggggfhg -@HWI-EAS210R_0001:4:10:890:1190#0/1 -AATAAGCAATGACGGCAGCAATAAACTCAACAGGAGCA -+HWI-EAS210R_0001:4:10:890:1190#0/1 -bbecb_gggggggggggggggggggcgggfVgggeggg -@HWI-EAS210R_0001:4:10:890:1586#0/1 -ATTAGCTGTACCATACTCAGGCACACAAAAATACTGAT -+HWI-EAS210R_0001:4:10:890:1586#0/1 -eggWgaa^O[\`[\_]J_^][`W`\]K^BBBBBBBBBB -@HWI-EAS210R_0001:4:10:890:617#0/1 -AAACGCAAGCCTCAACGCAGCGACGAGCACGAGAGCGG -+HWI-EAS210R_0001:4:10:890:617#0/1 -gggggggggggggggggggggggggggggggggggggg -@HWI-EAS210R_0001:4:10:890:1562#0/1 -GTGGACTGCTGGCGGAAAATGAGAAAATTCGACCTATC -+HWI-EAS210R_0001:4:10:890:1562#0/1 -hggffggggdgggggaageef`Waegggbgggcgddgg -@HWI-EAS210R_0001:4:10:890:1410#0/1 -CATAAAAAAGCCTCCAAGATTTGGAGGCATGAAAACAT -+HWI-EAS210R_0001:4:10:890:1410#0/1 -\geedggfffcd\gd`\edeggY_Zda`gggXgadeeg -@HWI-EAS210R_0001:4:10:890:465#0/1 -AGCGTTGACCCTAATTTTGGTCGTCGGGTACGCAATCG -+HWI-EAS210R_0001:4:10:890:465#0/1 -gggggfgggggggfgggeggggbgggggagf^ffefea -@HWI-EAS210R_0001:4:10:890:1323#0/1 -ATGACAAGTAAAGGACGGTTGTCAGCGTCATAAGAGGT -+HWI-EAS210R_0001:4:10:890:1323#0/1 -gggggggfggdggggggggggggggggggggfgghggg -@HWI-EAS210R_0001:4:10:890:1064#0/1 -TTTCATGGTATTGATAAAGCTGTTGCCGATACTTGGAA -+HWI-EAS210R_0001:4:10:890:1064#0/1 -gggggggcegggfgfggfgfgggdgggggghfggggdf -@HWI-EAS210R_0001:4:10:890:637#0/1 -ATAGTGCCATGCTCAGGAACAAAGAAACGCGGCACAGA -+HWI-EAS210R_0001:4:10:890:637#0/1 -ggggggggggggggggggeggggggfddgggcgggggd -@HWI-EAS210R_0001:4:10:890:1825#0/1 -TCCATCTGAATGCAATGAAGAAAACCACCATTACCAGC -+HWI-EAS210R_0001:4:10:890:1825#0/1 -gggggggghgggffgggggegggffgghgggggggggg -@HWI-EAS210R_0001:4:10:890:1697#0/1 -ACGGTTAATGCTGGTAATGGTGGTTTTCTTCATTGCAT -+HWI-EAS210R_0001:4:10:890:1697#0/1 -eecaadeffedeggcabebeagggdecL_aNTTTTeg_ -@HWI-EAS210R_0001:4:10:890:1479#0/1 -ATTGCTGGCGACCCTGTTTTGTATGGCAACTTGCCGCC -+HWI-EAS210R_0001:4:10:890:1479#0/1 -ggggggggggggggggggggfggggggggghgbgggfg -@HWI-EAS210R_0001:4:10:890:1838#0/1 -ATGTGACCGTTTATCGCAATCTGCCGACCACTCGCGAT -+HWI-EAS210R_0001:4:10:890:1838#0/1 -ggfgfggfggggggfgggggggaggggfegfhggdggg -@HWI-EAS210R_0001:4:10:890:988#0/1 -CATTCAGTCGGCGACTTCACGCCAGAATACGAAAGACC -+HWI-EAS210R_0001:4:10:890:988#0/1 -ggghggfggggggegghgfggfgggggggggggggggg -@HWI-EAS210R_0001:4:10:890:1902#0/1 -CTTCCTCGTACGCCGGGCAATAATGTTTATGTTGGTTT -+HWI-EAS210R_0001:4:10:890:1902#0/1 -gggggggegggggggggggggggggggggfgggggggg -@HWI-EAS210R_0001:4:10:890:1983#0/1 -TTAAGGTACTGAATCTCTTTAGTCGCAGTAGGCGGAAA -+HWI-EAS210R_0001:4:10:890:1983#0/1 -ffdfbaQa_c_Y\]Yeceeeege_gYR^VS]ZW[\Lcc -@HWI-EAS210R_0001:4:10:890:1058#0/1 -GCTCGCCCTGGTCGTCCGCAGCCGTTGCGAGGTACTAA -+HWI-EAS210R_0001:4:10:890:1058#0/1 -ggggdgggggggggggggggggggggggggggfggggg -@HWI-EAS210R_0001:4:10:890:287#0/1 -GTATCCAACCTGCAGAGTTTTATCGCTTCCATGACGCA -+HWI-EAS210R_0001:4:10:890:287#0/1 -ggggggfcggggg^fbe``egggggggdgg`dddfggg -@HWI-EAS210R_0001:4:10:890:335#0/1 -AAGAGGTTTTACCTCCAAATGAAGAAATAACATCATGG -+HWI-EAS210R_0001:4:10:890:335#0/1 -`^_``Q[cccggfgggggggbddg\dXdbegggddfg` -@HWI-EAS210R_0001:4:10:891:149#0/1 -TTTAAGAGCCTCGATACGCTCAAAGTCAAAATAATCAG -+HWI-EAS210R_0001:4:10:891:149#0/1 -ggggghgggggghggggggggggggfgggggggffggg -@HWI-EAS210R_0001:4:10:891:445#0/1 -ATATTTTTCATGGTATTGATAAAGCTGTTGCCGATACT -+HWI-EAS210R_0001:4:10:891:445#0/1 -gggggggddggggggggggggggggggggggggggggg -@HWI-EAS210R_0001:4:10:891:1476#0/1 -GGCGACTCCTTCGAGATGGACGCCGTTGGCGCTCTCCG -+HWI-EAS210R_0001:4:10:891:1476#0/1 -ggegggffghhggfhggfgeggffgggffggagfggfg -@HWI-EAS210R_0001:4:10:891:323#0/1 -TGTAAAACAGGTGCCGAAGAAGCTGGAGTAACAGAAGT -+HWI-EAS210R_0001:4:10:891:323#0/1 -gggcgfefghgggghgfgfgggggggggegaaeeagge -@HWI-EAS210R_0001:4:10:891:69#0/1 -CTTGGCTTCCTTGCTGGTCAGATTGGTCGTCTTATTAC -+HWI-EAS210R_0001:4:10:891:69#0/1 -gggefgggfgafP_Vdbacbgegebd`fbaeggaggQd -@HWI-EAS210R_0001:4:10:891:1379#0/1 -GACCCTGTTTTGTATGGCAACTTGCCGCCGCGTGAAAT -+HWI-EAS210R_0001:4:10:891:1379#0/1 -gggggggggggggggggggggggggggggfgefggggg -@HWI-EAS210R_0001:4:10:891:608#0/1 -CTTATGCTAATTTGCATACTGACCAAGAACGTGATTAC -+HWI-EAS210R_0001:4:10:891:608#0/1 -ggggggggggggggggggggggggfggggggggggggg -@HWI-EAS210R_0001:4:10:891:1831#0/1 -GTGGATTACTATCTGAGTCCGATGCTGTTCAACCACTA -+HWI-EAS210R_0001:4:10:891:1831#0/1 -ggggggggggggggggghggggggggghgggggfgggg -@HWI-EAS210R_0001:4:10:891:412#0/1 -TAAGAAATCATGAGTCAAGTTACTGAACAATCCGTACG -+HWI-EAS210R_0001:4:10:891:412#0/1 -gggggggggggggggggggggggggggggggggggggg -@HWI-EAS210R_0001:4:10:891:346#0/1 -AATTCATCCATTAACTTCTCATCAACATATACAAACTC -+HWI-EAS210R_0001:4:10:891:346#0/1 -^W][_b^be_cRgaggdgdgbL_^_\ZN\R]]`W]cYe -@HWI-EAS210R_0001:4:10:891:174#0/1 -AGTGGAGGCCTCCAGCAATCTTGAACACTCATCCTTAA -+HWI-EAS210R_0001:4:10:891:174#0/1 -ggggggggggggggggggggggcgggggfgggghghcg -@HWI-EAS210R_0001:4:10:891:1415#0/1 -ACCAACCATCAGCATGAGCCTGTCGCATTGCATTCATC -+HWI-EAS210R_0001:4:10:891:1415#0/1 -gggggggggggdghgggggggggggggggggggggggg -@HWI-EAS210R_0001:4:10:891:705#0/1 -TTTCCGTTGCTGCCATCTCAAAAACATTTGGACTGCTC -+HWI-EAS210R_0001:4:10:891:705#0/1 -gfgggggggggfgggggggggggfgddgggggggeggg -@HWI-EAS210R_0001:4:10:891:1398#0/1 -GCTGAACGCCCTCTTAAGGATATTCGCGATGAGTATAA -+HWI-EAS210R_0001:4:10:891:1398#0/1 -ebehggdhdfgffdda`e\ecgfggedgegeggdfdfg -@HWI-EAS210R_0001:4:10:891:971#0/1 -TAGCTTTAAGCGGCTCACCTTTAGCATCAACAGGCCAC -+HWI-EAS210R_0001:4:10:891:971#0/1 -ggfgggghggggggfggfgghggfggggfghggffghg -@HWI-EAS210R_0001:4:10:891:627#0/1 -GTCGCAGTAGGCGGAAAACGAACAAGCGCAAGAGTAAA -+HWI-EAS210R_0001:4:10:891:627#0/1 -dfdffaeaaagggg[bgggghgghgggfgg\efefggd -@HWI-EAS210R_0001:4:10:891:1822#0/1 -GAGTAGTTGAAATGGTAATAAGACGACCAATCTGACCA -+HWI-EAS210R_0001:4:10:891:1822#0/1 -gggeggfggegggggdggggghgfgedgggggcfgdcg -@HWI-EAS210R_0001:4:10:891:1103#0/1 -AAGGGTAATAAGAACGAACCATAAAAAAGCCTCCAAGA -+HWI-EAS210R_0001:4:10:891:1103#0/1 -ggeggfggggggggghggggggggggfffgdggggggb -@HWI-EAS210R_0001:4:10:891:586#0/1 -TATGTCTAATATTCAAACTGGCGCCGAGCGTATGCCGC -+HWI-EAS210R_0001:4:10:891:586#0/1 -ggggggggggggegfgggfcgggggffggggggggggg -@HWI-EAS210R_0001:4:10:891:1620#0/1 -TTTTGTGTGCCTGAGTATGGTACAGCTAATGGCCGTCT -+HWI-EAS210R_0001:4:10:891:1620#0/1 -gggggfggggghgggggghcgggdgggegggefgfT`` -@HWI-EAS210R_0001:4:10:891:42#0/1 -CTAAAGGCAAGCGTAAAGGCGCTCGTCTTTGGTATGTA -+HWI-EAS210R_0001:4:10:891:42#0/1 -ggefggggggfggggfaf_fggggdfggggfaYbfd]b -@HWI-EAS210R_0001:4:10:891:1609#0/1 -GCCATAGCACCAGAAACAAAACTAGGGGCGGCCTCATC -+HWI-EAS210R_0001:4:10:891:1609#0/1 -gggghgggghfgghgggggfffggggcgggfdggfggf -@HWI-EAS210R_0001:4:10:891:1028#0/1 -AATCGCGTAGAGGCTTTGCTATTCAGCGTTTGATGAAT -+HWI-EAS210R_0001:4:10:891:1028#0/1 -gfgggggggdgbggfgegeeggggggggdggegggddg -@HWI-EAS210R_0001:4:10:891:902#0/1 -ATAAACATCATAGGCAGTCGGGAGGGTAGTCGGAACCG -+HWI-EAS210R_0001:4:10:891:902#0/1 -ggggggfgggggggggggggggggfddggggggggggg