diff --git a/CHANGELOG.md b/CHANGELOG.md index b6e4893..756c187 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,6 +13,43 @@ Sections commonly used: Features, Bug fixes, Other changes. ### Features +- **`--clipAdapterType CellRanger4` now matches STAR exactly**, both halves of the + clip. The 5' TSO trim is an overlap alignment against the first 91 bases of the + read, replicating `ClipCR4`'s Opal call (ACGTN alphabet; match +1, mismatch -2, + any-vs-N -2, N-vs-N 0; gap open = gap extend = 2; overlap mode with end + tracking), followed by STAR's acceptance gate + `S<20 || (S==20 && L>26) || (S==21 && L>30)`. The 3' trim is STAR's scored + `polyTail3p` scan, replacing a "trailing run of A >= 8" approximation that was + wrong in both directions (a read ending in 10 A's was trimmed by 10 where STAR + trims 0; `A*15 + C + A*15` was trimmed by 15 where STAR trims 31). The poly-A + transcription is taken from Benjamin Demaille's #148 and moved onto the solo + path, which is where `CellRanger4` is actually reached; #148's `clip_mate` + wiring is not used and that PR is superseded. + + The overlap alignment comes from [`hyalite`](https://crates.io/crates/hyalite) + 0.2 — a new dependency, pure Rust with no dependencies of its own. Reads are + scanned a batch at a time via `Database::scan_all`, mirroring STAR's + `ClipMate::clipChunk`, which aligns the adapter against a chunk of reads in one + Opal call. + + Both halves are gated against STAR's own C++: `tests/data/cr4_opal_oracle.cpp` + links STAR's `opal.cpp` and reproduces `ClipCR4` + `ClipMate::clipChunk` + verbatim, and the committed `cr4_opal_oracle.tsv` is its output over 938 reads + chosen to straddle both decision boundaries. `cr4_tso_matches_star_opal_oracle` + checks every one against the scalar path, a forced-SIMD path, and the + production batch path. + + Measured on 10x mouse chr19 with both tools under `--clipAdapterType + CellRanger4`: clip-amount differences against STARsolo drop from 154 to **0**, + and the soft-clipped share moves from 39% (STAR 41%) to 34.9% (STAR 35.0%). + Default SE/PE alignment is untouched, as `CellRanger4` is opt-in: SE 8788/8926 + and PE 8390 both-mapped / 0 half-mapped, both unchanged. + + Known limitation: `CellRanger4` combined with a non-zero `--clip5pNbases` / + `--clip3pNbases` misplaces most reads by `clip5pNbases`. That is a pre-existing + bug, not introduced here, and is tracked separately; `CellRanger4` on its own + and the fixed clips on their own are both unaffected. + - **STARsolo single-cell quantification (`--soloType`)** — the 10x Chromium / plate-based count-matrix pipeline, ported from STAR and verified against real STARsolo (#90). diff --git a/Cargo.lock b/Cargo.lock index 7c26d8a..79c84fd 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -451,6 +451,12 @@ version = "0.5.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea" +[[package]] +name = "hyalite" +version = "0.2.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "928dd1c1c1bb653798ceed0f98d334225629a4d345f0cf8fa4d6b2998f6b8255" + [[package]] name = "iana-time-zone" version = "0.1.65" @@ -980,6 +986,7 @@ dependencies = [ "dashmap", "env_logger", "flate2", + "hyalite", "libdeflater", "libmimalloc-sys", "log", diff --git a/Cargo.toml b/Cargo.toml index 8a4638f..cdcb72f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -65,6 +65,11 @@ mimalloc = { version = "0.1", default-features = false } libmimalloc-sys = { version = "0.1.49", features = ["extended"] } # mi_option_set (purge_delay); see main.rs libdeflater = "1.25.2" noodles-bgzf = { version = "0.49", features = ["libdeflate"] } +# Deterministic SIMD overlap aligner for the CellRanger4 5' TSO clip (STAR +# links Opal for this). Pure Rust, zero dependencies, bit-identical across +# backends. 0.2 is the first release with `Database::scan_all`, the per-target +# scan the batched clip path needs. +hyalite = "0.2" [dev-dependencies] assert_cmd = "2" diff --git a/src/lib.rs b/src/lib.rs index 6fce173..3465ebf 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -2135,6 +2135,18 @@ fn align_reads_solo( move |base: u64, batch: Vec| -> BatchOut { let params: &Parameters = ¶ms_arc; let index = &index; + // CellRanger4 5' TSO clip: resolved for the whole batch in one + // SIMD pass (hyalite `Database::scan_all`), mirroring STAR's + // `ClipMate::clipChunk`, which aligns the adapter against a + // chunk of reads in a single Opal call. Bit-identical to the + // per-read path, ~7x faster on AVX2. + let cr4_tso: Vec = if cr4_clip { + let seqs: Vec<&[u8]> = + batch.iter().map(|s| s.cdna.sequence.as_slice()).collect(); + crate::solo::tso_clip_lens_cr4_batch(&seqs) + } else { + Vec::new() + }; batch .par_iter() .enumerate() @@ -2155,7 +2167,11 @@ fn align_reads_solo( // CellRanger4 adapter clipping (TSO 5' + polyA 3') runs before // the fixed clip5p/clip3p Nbases trimming. let (cr_seq, cr_qual, cr4_5p, cr4_3p) = if cr4_clip { - crate::solo::clip_adapter_cr4(&read.sequence, &read.quality) + crate::solo::clip_adapter_cr4_with_tso( + &read.sequence, + &read.quality, + cr4_tso[read_idx], + ) } else { (read.sequence.clone(), read.quality.clone(), 0, 0) }; diff --git a/src/solo/mod.rs b/src/solo/mod.rs index 2253dee..43acf7a 100644 --- a/src/solo/mod.rs +++ b/src/solo/mod.rs @@ -387,44 +387,227 @@ pub fn open_paired_reader(params: &Parameters) -> Result &'static hyalite::Scoring { + static SCORING: std::sync::OnceLock = std::sync::OnceLock::new(); + SCORING.get_or_init(|| { + #[rustfmt::skip] + let matrix = vec![ + 1, -2, -2, -2, -2, + -2, 1, -2, -2, -2, + -2, -2, 1, -2, -2, + -2, -2, -2, 1, -2, + -2, -2, -2, -2, 0, + ]; + hyalite::Scoring::new(5, matrix, 2, 2).expect("valid CR4 scoring matrix") + }) +} + +/// The TSO query, encoded once (0=A..3=T). +fn tso_query() -> &'static [u8] { + static Q: std::sync::OnceLock> = std::sync::OnceLock::new(); + Q.get_or_init(|| { + TSO_SEQ + .iter() + .map(|&b| crate::io::fastq::encode_base(b)) + .collect() + }) +} + +/// STAR-faithful 5' TSO clip length via a hyalite overlap alignment, replacing +/// STAR's Opal call (`ClipCR4::opalAlign` + `ClipMate_clipChunk.cpp:41-49`). +/// +/// `read` is encoded (0=A..4=N). The target is the first `min(len, 91)` bases, +/// N-padded to 91 (exactly `ClipCR4::opalFillOneSeq`); query is the TSO; overlap +/// mode with end tracking. The clip is `L = target_end + 1`, rejected to 0 by +/// STAR's score gate: `S < 20 || (S == 20 && L > 26) || (S == 21 && L > 30)`. +fn tso_clip_len_cr4(read: &[u8]) -> usize { + if read.is_empty() { + return 0; + } + let target = cr4_target(read); + + let Ok(hit) = hyalite::align_pair( + tso_query(), + &target, + cr4_scoring(), + hyalite::Mode::Ov, + hyalite::SearchType::ScoreEnd, + ) else { + return 0; + }; + + cr4_gate(&hit, read.len()) +} + +/// Apply STAR's clip gate to one hyalite hit, yielding the 5' clip length. +/// +/// `S < 20 || (S == 20 && L > 26) || (S == 21 && L > 30)` rejects to 0 +/// (`ClipMate_clipChunk.cpp:44-47`), then STAR takes `min(clip, Lread)` +/// (`ClipMate_clip.cpp:53`). +fn cr4_gate(hit: &hyalite::BestHit, read_len: usize) -> usize { + let s = hit.score; + let l = hit.target_end.map_or(0, |e| e + 1) as i32; // ScoreEnd ⇒ Some + let reject = s < 20 || (s == 20 && l > 26) || (s == 21 && l > 30); + if reject { + 0 + } else { + (l as usize).min(read_len) + } +} + +/// Build the N-padded 91-base target for one read, exactly `ClipCR4::opalFillOneSeq`. +fn cr4_target(read: &[u8]) -> Vec { + let take = read.len().min(CR4_READ_LEN); + let mut target = Vec::with_capacity(CR4_READ_LEN); + target.extend_from_slice(&read[..take]); + target.resize(CR4_READ_LEN, 4); // pad with N + target +} + +/// How many reads share one hyalite `Database` in the batched TSO scan. STAR uses +/// 64 (`ClipCR4::dbN`); throughput here is flat from 128 to 10k, so this is sized +/// to give rayon enough chunks to spread across cores rather than to tune SIMD. +const CR4_SCAN_CHUNK: usize = 512; + +/// Batched 5' TSO clip lengths for a whole read batch — the SIMD counterpart to +/// [`tso_clip_len_cr4`], via hyalite's per-target `Database::scan_all`. +/// +/// STAR does the same thing: `ClipMate::clipChunk` fills an Opal "database" with +/// a chunk of reads and aligns the adapter against all of them in one call. The +/// results are bit-identical to the per-read path on every backend (see the +/// `cr4_tso_scan_all_batch_matches_scalar_and_is_backend_stable` test), and ~7x +/// faster than per-read `align_pair` on AVX2 including the per-chunk build. +/// +/// Falls back to the per-read scalar path for any chunk whose `Database` fails to +/// build, so this can never change results — only how fast they are computed. +pub fn tso_clip_lens_cr4_batch(reads: &[&[u8]]) -> Vec { + use rayon::prelude::*; + + reads + .par_chunks(CR4_SCAN_CHUNK) + .flat_map_iter(|chunk| { + let targets: Vec> = chunk.iter().map(|r| cr4_target(r)).collect(); + let db = hyalite::Database::builder() + .sequences(&targets) + .scoring(cr4_scoring().clone()) + .mode(hyalite::Mode::Ov) + .search_type(hyalite::SearchType::ScoreEnd) + .max_query_len(TSO_SEQ.len()) + .build(); + + let Ok(db) = db else { + // Should not happen for this fixed shape; degrade to scalar rather + // than change results. + return chunk + .iter() + .map(|r| tso_clip_len_cr4(r)) + .collect::>(); + }; + + let mut scratch = hyalite::Scratch::new(&db); + let mut hits = Vec::with_capacity(chunk.len()); + db.scan_all(&mut scratch, tso_query(), &mut hits); + + chunk + .iter() + .zip(&hits) + .map(|(read, hit)| { + if read.is_empty() { + 0 + } else { + cr4_gate(hit, read.len()) + } + }) + .collect::>() + }) + .collect() +} + +/// Number of 3' bases to trim as a CellRanger4 polyA tail — STAR +/// `ClipCR4::polyTail3p`. +/// +/// Walks in from the 3' end scoring +1 per `A` (encoded 0) and -2 per non-`A`, +/// remembering the longest prefix of that walk whose running score still clears +/// a 70% density threshold (`score * 10 >= ib * 7`). It gives up once the score +/// has fallen more than 27 behind the position, and returns nothing unless the +/// remembered score reached 20. Reads shorter than 20 bases are never trimmed. +/// +/// Note the scan does **not** stop at the tail boundary, so A-rich sequence +/// upstream of a clean run legitimately extends the trim. That reads like an +/// off-by-one but is STAR's behaviour; the oracle pins it. +/// +/// Ported from STAR; the Rust transcription is [Benjamin Demaille's in PR +/// #148](https://github.com/Psy-Fer/rustar-aligner/pull/148), moved here onto +/// the solo path (the only place `--clipAdapterType CellRanger4` is reached) +/// and validated against STAR's own compiled `polyTail3p` — see +/// `cr4_tso_matches_star_opal_oracle`. +fn poly_tail_3p(seq: &[u8]) -> usize { + let seq_len = seq.len(); + if seq_len < 20 { + return 0; + } + let mut best_len: i64 = seq_len as i64 - 1; + let mut score: i64 = 0; + let mut best_score: i64 = 0; + for ib in 1..=seq_len as i64 { + if seq[seq_len - ib as usize] == 0 { + score += 1; + if score * 10 >= ib * 7 { + best_len = ib; + best_score = score; + } + } else { + score -= 2; + if ib - score > 27 { + break; + } + } + } + if best_score < 20 { + 0 + } else { + best_len as usize + } +} + /// Clip the 10x TSO from the 5' end and trim a 3' polyA tail of the cDNA read, /// matching `--clipAdapterType CellRanger4`. Operates on encoded bases /// (0=A..3=T,4=N) with parallel quality bytes. Returns the clipped read. /// -/// Conservative thresholds (full-length TSO match ≤ 3 mismatches at the 5' -/// anchor; trailing polyA run ≥ 8) keep this a no-op on adapter-free reads. +/// The 5' TSO clip is a STAR-faithful overlap alignment (see [`tso_clip_len_cr4`]); +/// the 3' polyA trim is STAR's scored scan (see [`poly_tail_3p`]). /// Returns `(clipped_seq, clipped_qual, clip5p, clip3p)` — the CR4-clipped read plus /// the bases trimmed from the 5' (TSO) and 3' (polyA) ends, so the caller can soft-clip /// them (STARsolo keeps them in SEQ as soft-clips, e.g. `60M30S`, not dropped). pub fn clip_adapter_cr4(seq: &[u8], qual: &[u8]) -> (Vec, Vec, usize, usize) { - let mut start = 0usize; - let mut end = seq.len(); + // 5' TSO: STAR-faithful overlap alignment (ClipCR4's Opal call → hyalite). + clip_adapter_cr4_with_tso(seq, qual, tso_clip_len_cr4(seq)) +} - // 5' TSO: compare the read prefix against the full TSO; clip on a match. - if seq.len() >= TSO_SEQ.len() { - let tso: Vec = TSO_SEQ - .iter() - .map(|&b| crate::io::fastq::encode_base(b)) - .collect(); - let mismatches = seq[..tso.len()] - .iter() - .zip(&tso) - .filter(|(a, b)| a != b) - .count(); - if mismatches <= 3 { - start = tso.len(); - } - } - - // 3' polyA: trim a trailing run of A (encoded 0) of length >= 8. - let mut run = 0usize; - while end > start && seq[end - 1] == 0 { - run += 1; - end -= 1; - } - if run < 8 { - end += run; // not a real polyA tail; keep those bases - } +/// [`clip_adapter_cr4`] with the 5' TSO clip length already computed — the entry +/// point for the batched scan, which resolves every read's clip up front via +/// [`tso_clip_lens_cr4_batch`]. +pub fn clip_adapter_cr4_with_tso( + seq: &[u8], + qual: &[u8], + start: usize, +) -> (Vec, Vec, usize, usize) { + let start = start.min(seq.len()); + + // 3' polyA, on the read as it stands after the 5' clip — STAR clips type 10 + // (which shifts the sequence and shrinks Lread) before type 11. + // + // NB: with a non-zero --clip5pNbases/--clip3pNbases alongside CellRanger4, + // STAR's window differs (it applies those fixed trims first). Narrowing the + // window to match made agreement *worse*, because that pairing has a larger + // pre-existing +/-clip5pNbases position bug that swamps it — see TODO.md. + // Left matching the default (fixed clips = 0) case, which is validated. + let end = seq.len() - poly_tail_3p(&seq[start..]); if start == 0 && end == seq.len() { return (seq.to_vec(), qual.to_vec(), 0, 0); @@ -915,6 +1098,353 @@ mod tests { } } + fn enc(s: &str) -> Vec { + s.bytes().map(encode_base).collect() + } + + #[test] + fn cr4_tso_clip_removes_exact_tso_prefix() { + // Read = exact TSO (30 nt) + 61 nt of cDNA (all C, so the 3' polyA trim + // is a no-op). Overlap of the 30-nt TSO against target[0..30] scores 30, + // ends at target index 29 ⇒ L = 30, well above STAR's gate. + let cdna: String = std::iter::repeat_n('C', 61).collect(); + let read = format!("AAGCAGTGGTATCAACGCAGAGTACATGGG{cdna}"); + let seq = enc(&read); + assert_eq!(seq.len(), 91); + assert_eq!(tso_clip_len_cr4(&seq), 30); + + let qual = vec![b'I'; seq.len()]; + let (clipped, _q, c5, c3) = clip_adapter_cr4(&seq, &qual); + assert_eq!(c5, 30, "5' TSO clipped"); + assert_eq!(c3, 0, "no polyA tail"); + assert_eq!(clipped, enc(&cdna)); + } + + /// `clip_adapter_cr4` must run [`poly_tail_3p`] on the read *after* the 5' + /// TSO clip (STAR clips type 10 before type 11), and must use STAR's scored + /// scan rather than the old "trailing run of A >= 8" rule. + #[test] + fn cr4_polya_trim_follows_star_not_a_run_length_rule() { + let qual = |n: usize| vec![b'I'; n]; + + // 10 clean A's: the old >=8 run rule trimmed these; STAR does not, + // because polyTail3p's best score (10) never reaches the 20 floor. + let seq = enc(&format!("{}{}", "CGT".repeat(20), "A".repeat(10))); + let (_, _, c5, c3) = clip_adapter_cr4(&seq, &qual(seq.len())); + assert_eq!( + (c5, c3), + (0, 0), + "a 10 base tail is below STAR's score floor" + ); + + // 25 clean A's clears the floor and is trimmed whole. + let seq = enc(&format!("{}{}", "CGT".repeat(20), "A".repeat(25))); + let (_, _, c5, c3) = clip_adapter_cr4(&seq, &qual(seq.len())); + assert_eq!((c5, c3), (0, 25)); + + // An interrupted tail survives at 70% density — the run-length rule + // would have stopped at the first non-A and trimmed only 15. + let seq = enc(&format!( + "{}{}C{}", + "CGT".repeat(20), + "A".repeat(15), + "A".repeat(15) + )); + let (_, _, _, c3) = clip_adapter_cr4(&seq, &qual(seq.len())); + assert_eq!(c3, 31, "scored scan spans the interruption"); + + // Both halves together: the polyA scan sees the post-TSO-clip read, so + // the 5' and 3' clips are independent and both apply. + let cdna = "CGT".repeat(15); // 45 nt, A-free + let seq = enc(&format!( + "AAGCAGTGGTATCAACGCAGAGTACATGGG{cdna}{}", + "A".repeat(30) + )); + let (clipped, _, c5, c3) = clip_adapter_cr4(&seq, &qual(seq.len())); + assert_eq!((c5, c3), (30, 30), "TSO off the 5', polyA off the 3'"); + assert_eq!(clipped, enc(&cdna)); + } + + #[test] + fn cr4_tso_clip_is_noop_without_adapter() { + // Homopolymer read with no TSO similarity ⇒ score below STAR's gate ⇒ 0. + assert_eq!(tso_clip_len_cr4(&[3u8; 91]), 0); + } + + #[test] + fn cr4_tso_clip_handles_short_and_empty_reads() { + assert_eq!(tso_clip_len_cr4(&[]), 0); + // Shorter than the TSO: target is N-padded to 91; no qualifying match. + assert_eq!(tso_clip_len_cr4(&enc("ACGTACGT")), 0); + } + + /// Backend-forcing twin of [`tso_clip_lens_cr4_batch`], so the determinism + /// test can pin a specific backend (the production function uses runtime + /// dispatch and offers no such knob). + fn tso_clip_lens_batch(reads: &[Vec], backend: hyalite::BackendChoice) -> Vec { + use hyalite::{Database, Mode, Scratch, SearchType}; + let targets: Vec> = reads + .iter() + .map(|r| { + let take = r.len().min(CR4_READ_LEN); + let mut t = r[..take].to_vec(); + t.resize(CR4_READ_LEN, 4); + t + }) + .collect(); + let db = Database::builder() + .sequences(&targets) + .scoring(cr4_scoring().clone()) + .mode(Mode::Ov) + .search_type(SearchType::ScoreEnd) + .max_query_len(TSO_SEQ.len()) + .backend(backend) + .build() + .expect("build cr4 database"); + let mut scratch = Scratch::new(&db); + let mut out = Vec::new(); + db.scan_all(&mut scratch, tso_query(), &mut out); + reads + .iter() + .zip(&out) + .map(|(r, hit)| { + let s = hit.score; + let l = hit.target_end.map_or(0, |e| e + 1) as i32; + let reject = s < 20 || (s == 20 && l > 26) || (s == 21 && l > 30); + if reject { 0 } else { (l as usize).min(r.len()) } + }) + .collect() + } + + /// A deterministic, diverse CR4 read set (TSO with mutations/shifts + random), + /// all length 91, for exercising the batched path in-tree without fixtures. + fn synthetic_cr4_reads() -> Vec> { + let mut st = 0x51ED_2701_u64; + let mut lcg = || { + st = st + .wrapping_mul(6_364_136_223_846_793_005) + .wrapping_add(1_442_695_040_888_963_407); + st >> 33 + }; + let tso = tso_query().to_vec(); + let mut reads = Vec::new(); + for _ in 0..400 { + let mut r = tso.clone(); + let k = (lcg() % 13) as usize; // 0..12 mismatches + for _ in 0..k { + let p = (lcg() as usize) % r.len(); + r[p] = ((r[p] as u64 + 1 + lcg() % 3) % 4) as u8; + } + let shift = (lcg() % 6) as usize; + let mut read: Vec = (0..shift).map(|_| (lcg() % 4) as u8).collect(); + read.extend(r); + while read.len() < CR4_READ_LEN { + read.push((lcg() % 4) as u8); + } + read.truncate(CR4_READ_LEN); + reads.push(read); + } + for _ in 0..100 { + reads.push((0..CR4_READ_LEN).map(|_| (lcg() % 4) as u8).collect()); + } + reads + } + + /// Confirms the patched per-target `scan_all` (SIMD) path serves CR4: it + /// agrees with the scalar `align_pair` clip we ship, is identical across + /// backends, and (when the oracle fixture is provided) matches STAR's Opal. + #[test] + fn cr4_tso_scan_all_batch_matches_scalar_and_is_backend_stable() { + let reads = synthetic_cr4_reads(); + let scalar_ref: Vec = reads.iter().map(|r| tso_clip_len_cr4(r)).collect(); + + // Batched scan_all on Scalar must equal the per-read scalar path. + let batch_scalar = tso_clip_lens_batch( + &reads, + hyalite::BackendChoice::Force(hyalite::Backend::Scalar), + ); + assert_eq!(batch_scalar, scalar_ref, "scan_all(Scalar) vs align_pair"); + + // And every available SIMD backend must match it bit-for-bit. + for b in [hyalite::Backend::Sse41, hyalite::Backend::Avx2] { + if b.is_available() { + let batch = tso_clip_lens_batch(&reads, hyalite::BackendChoice::Force(b)); + assert_eq!(batch, scalar_ref, "scan_all({b:?}) diverged"); + } + } + + // The production batch entry point (runtime-dispatched backend, rayon + // chunking) must land on the same clips as the per-read scalar path. + let refs: Vec<&[u8]> = reads.iter().map(Vec::as_slice).collect(); + assert_eq!( + tso_clip_lens_cr4_batch(&refs), + scalar_ref, + "tso_clip_lens_cr4_batch vs align_pair" + ); + } + + /// Faithfulness gate: our CR4 clip — both halves — vs STAR's own C++. + /// + /// `tests/data/cr4_opal_oracle.tsv` (columns: read, clip, score, L, polyA) + /// is generated by `tests/data/cr4_opal_oracle.cpp`, which links STAR's own + /// `opal.cpp` and reproduces `ClipCR4` + `ClipMate::clipChunk` verbatim. + /// 900 reads straddle the 5' gate `S<20 / S==20&&L>26 / S==21&&L>30` (TSO + /// with 0-14 mismatches, 5' shifts, truncations, indels, embedded Ns, polyA, + /// random, short reads); a further 38 straddle `polyTail3p`'s own boundaries + /// (the score>=20 floor, the 70% density rule, the `ib-score>27` give-up, + /// the `seqLen<20` early return, and A-rich sequence upstream of the tail). + /// + /// The polyA column is computed on the read *after* the 5' clip, matching + /// `ClipMate::clip`'s ordering. Committing the expected output lets this run + /// in CI with no Opal build; regenerate with the recipe at the top of the + /// `.cpp` and override the path via `RUSTAR_CR4_ORACLE`. + #[test] + fn cr4_tso_matches_star_opal_oracle() { + let path = std::env::var("RUSTAR_CR4_ORACLE").unwrap_or_else(|_| { + format!( + "{}/tests/data/cr4_opal_oracle.tsv", + env!("CARGO_MANIFEST_DIR") + ) + }); + let data = std::fs::read_to_string(&path).expect("read oracle tsv"); + let mut reads: Vec> = Vec::new(); + let mut expected: Vec = Vec::new(); + let mut expected_polya: Vec = Vec::new(); + for line in data.lines() { + let f: Vec<&str> = line.split('\t').collect(); + if f.len() < 5 { + continue; + } + reads.push(f[0].bytes().map(encode_base).collect()); + expected.push(f[1].parse().expect("clip int")); + expected_polya.push(f[4].parse().expect("polyA int")); + } + assert!(!reads.is_empty(), "oracle file was empty"); + + // 3' polyA half: STAR's polyTail3p on the post-5'-clip read. + let mut polya_mism = 0usize; + for (i, read) in reads.iter().enumerate() { + let got = poly_tail_3p(&read[expected[i].min(read.len())..]); + if got != expected_polya[i] { + eprintln!("POLYA MISMATCH star={} ours={got}", expected_polya[i]); + polya_mism += 1; + } + } + assert_eq!( + polya_mism, + 0, + "{polya_mism}/{} reads disagreed with STAR's polyTail3p", + reads.len() + ); + + // Scalar per-read path (what we ship). + let scalar: Vec = reads.iter().map(|r| tso_clip_len_cr4(r)).collect(); + // Batched SIMD per-target path (scan_all), on the best available backend. + let backend = if hyalite::Backend::Avx2.is_available() { + hyalite::Backend::Avx2 + } else if hyalite::Backend::Sse41.is_available() { + hyalite::Backend::Sse41 + } else { + hyalite::Backend::Scalar + }; + let batch = tso_clip_lens_batch(&reads, hyalite::BackendChoice::Force(backend)); + // The production entry point, exactly as the solo read loop calls it. + let refs: Vec<&[u8]> = reads.iter().map(Vec::as_slice).collect(); + let prod = tso_clip_lens_cr4_batch(&refs); + + let mut mism = 0usize; + for i in 0..reads.len() { + if scalar[i] != expected[i] || batch[i] != expected[i] || prod[i] != expected[i] { + eprintln!( + "MISMATCH star={} scalar={} simd={} prod={}", + expected[i], scalar[i], batch[i], prod[i] + ); + mism += 1; + } + } + assert_eq!( + mism, + 0, + "{mism}/{} reads disagreed with STAR's Opal (scalar, {backend:?}, or production batch)", + reads.len() + ); + } + + /// Kicks hyalite's headline "bit-identical across backends" guarantee on the + /// CR4 workload shape, and cross-checks the SIMD `Database` path against the + /// scalar `align_pair` path we actually ship in `tso_clip_len_cr4`. + /// + /// NB: `Database::scan` returns the single best hit over the DB (with + /// `db_index`), not a per-sequence result, so this validates the best-hit + /// only. STAR's CR4 needs a per-read result, which is what + /// [`tso_clip_lens_cr4_batch`] gets from `scan_all` (0.2.0); this test keeps + /// the single-best `scan` path covered alongside it. + #[test] + fn cr4_tso_database_is_deterministic_across_backends_and_matches_scalar() { + use hyalite::{Backend, BackendChoice, Database, Mode, Scratch, SearchType}; + + // Reads-as-targets, TSO-as-query (STAR's orientation → target_end is the + // read coordinate). Read 0 is TSO-led, so it is the unambiguous winner. + let mut reads: Vec> = Vec::new(); + let mut tso_led = tso_query().to_vec(); + tso_led.extend(std::iter::repeat_n(1u8, CR4_READ_LEN - tso_led.len())); // + C's → 91 + reads.push(tso_led); + reads.push(enc( + "ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACG", + )); // 91 + reads.push(vec![3u8; CR4_READ_LEN]); // homopolymer T + + let mut backends = vec![Backend::Scalar]; + for b in [Backend::Sse41, Backend::Avx2, Backend::Neon] { + if b.is_available() { + backends.push(b); + } + } + + let mut per_backend: Vec<(i32, usize, usize)> = Vec::new(); // (score, db_index, target_end) + for backend in &backends { + let Ok(db) = Database::builder() + .sequences(&reads) + .scoring(cr4_scoring().clone()) + .mode(Mode::Ov) + .search_type(SearchType::ScoreEnd) + .max_query_len(TSO_SEQ.len()) + .backend(BackendChoice::Force(*backend)) + .build() + else { + continue; // backend not applicable to this DB; skip + }; + let mut scratch = Scratch::new(&db); + let hit = db.scan(&mut scratch, tso_query()); + per_backend.push((hit.score, hit.db_index, hit.target_end.unwrap())); + } + + // Every available backend agrees, bit for bit. + assert!(!per_backend.is_empty()); + let first = per_backend[0]; + for (i, r) in per_backend.iter().enumerate() { + assert_eq!(*r, first, "backend {:?} diverged", backends[i]); + } + + // The SIMD/Database best hit matches the scalar align_pair path on the + // winning read — same score, same end coordinate. + let (score, db_index, target_end) = first; + let scalar = hyalite::align_pair( + tso_query(), + &reads[db_index], + cr4_scoring(), + Mode::Ov, + SearchType::ScoreEnd, + ) + .unwrap(); + assert_eq!(scalar.score, score); + assert_eq!(scalar.target_end.unwrap(), target_end); + + // And that winner is the TSO-led read, clipped at the full TSO. + assert_eq!(db_index, 0); + assert_eq!(target_end + 1, TSO_SEQ.len()); + } + fn v2_layout() -> SoloBarcodeLayout { // 10x v2: CB at 1..16 (16 bp), UMI at 17..26 (10 bp). SoloBarcodeLayout::Simple { diff --git a/tests/alignment_features.rs b/tests/alignment_features.rs index 2db7d39..2124a68 100644 --- a/tests/alignment_features.rs +++ b/tests/alignment_features.rs @@ -2024,3 +2024,134 @@ fn test_wasp_samtag() { "all 10 unique reads overlapping the het SNV should pass WASP (vW:i:1)" ); } + +// --------------------------------------------------------------------------- +// Test — CellRanger4 TSO clip is applied per read within a batch +// +// The 5' TSO clip is resolved for a whole read batch in one hyalite +// `Database::scan_all` pass (`solo::tso_clip_lens_cr4_batch`), then indexed back +// out per read in the parallel align loop. This test interleaves TSO-bearing and +// TSO-free reads so that any off-by-one or reordering between the batched scan +// and the per-read loop lands a clip on the wrong read and fails here. +// --------------------------------------------------------------------------- + +#[test] +fn test_starsolo_cr4_tso_clip_is_per_read_within_batch() { + const TSO: &str = "AAGCAGTGGTATCAACGCAGAGTACATGGG"; + + let tmpdir = TempDir::new().unwrap(); + let genome = build_genome(); + let fasta = write_fasta(&tmpdir, &genome); + let gtf = write_gtf(&tmpdir); + + let genome_dir = tmpdir.path().join("genome"); + build_index(&fasta, &genome_dir, "7", Some(>f)); + + let cdna_path = tmpdir.path().join("cdna.fq"); + let barcode_path = tmpdir.path().join("barcode.fq"); + let wl_path = tmpdir.path().join("whitelist.txt"); + + let cb = "AAAACCCCGGGGTTTT"; + // Exon2 (chr1:10251-10300) — the 50 bp the cDNA part of every read carries. + let exon2 = String::from_utf8(genome[10250..10300].to_vec()).unwrap(); + assert!( + !exon2.ends_with("AAAAAAAA"), + "exon2 must not end in a polyA run, or the 3' CR4 trim would confound this test" + ); + + // 12 reads, alternating TSO-prefixed and bare, each with a distinct UMI so + // none are deduplicated away. + let n_pairs = 6; + { + let mut cf = fs::File::create(&cdna_path).unwrap(); + let mut bf = fs::File::create(&barcode_path).unwrap(); + for i in 0..n_pairs { + for tso in [true, false] { + let name = if tso { "tso" } else { "bare" }; + let seq = if tso { + format!("{TSO}{exon2}") + } else { + exon2.clone() + }; + writeln!(cf, "@{name}{i}\n{seq}\n+\n{}", "I".repeat(seq.len())).unwrap(); + // Distinct 10 bp UMI per record: "UMI" + 7 digits. + let umi = format!("ACG{:07}", i * 2 + usize::from(!tso)) + .replace('0', "T") + .replace(['1', '2', '3', '4', '5', '6', '7', '8', '9'], "C"); + let umi: String = umi.chars().take(10).collect(); + writeln!( + bf, + "@{name}{i}\n{cb}{umi}\n+\n{}", + "I".repeat(cb.len() + umi.len()) + ) + .unwrap(); + } + } + } + fs::write(&wl_path, format!("{cb}\n")).unwrap(); + + let output_dir = tmpdir.path().join("out_cr4_tso"); + fs::create_dir_all(&output_dir).unwrap(); + let prefix = format!("{}/", output_dir.display()); + + cargo_bin_cmd!("rustar-aligner") + .args([ + "--runMode", + "alignReads", + "--genomeDir", + genome_dir.to_str().unwrap(), + "--readFilesIn", + cdna_path.to_str().unwrap(), + barcode_path.to_str().unwrap(), + "--soloType", + "CB_UMI_Simple", + "--soloCBwhitelist", + wl_path.to_str().unwrap(), + "--soloCBstart", + "1", + "--soloCBlen", + "16", + "--soloUMIstart", + "17", + "--soloUMIlen", + "10", + "--sjdbGTFfile", + gtf.to_str().unwrap(), + "--clipAdapterType", + "CellRanger4", + "--outSAMtype", + "SAM", + "--outFileNamePrefix", + &prefix, + ]) + .assert() + .success(); + + let sam = fs::read_to_string(output_dir.join("Aligned.out.sam")).unwrap(); + + let mut n_tso = 0; + let mut n_bare = 0; + for line in sam.lines().filter(|l| !l.starts_with('@')) { + let f: Vec<&str> = line.split('\t').collect(); + let (qname, pos, cigar) = (f[0], f[3], f[5]); + assert_eq!(pos, "10251", "{qname}: cDNA should map to Exon2"); + + if qname.starts_with("tso") { + // The 30 nt TSO is clipped from the 5' and retained as a soft clip. + assert_eq!( + cigar, "30S50M", + "{qname}: TSO-bearing read should carry a 30 base 5' soft clip" + ); + n_tso += 1; + } else { + assert_eq!( + cigar, "50M", + "{qname}: TSO-free read must not be clipped (a clip here means the \ + batched TSO scan was indexed onto the wrong read)" + ); + n_bare += 1; + } + } + assert_eq!(n_tso, n_pairs, "every TSO read should be reported"); + assert_eq!(n_bare, n_pairs, "every TSO-free read should be reported"); +} diff --git a/tests/data/cr4_opal_oracle.cpp b/tests/data/cr4_opal_oracle.cpp new file mode 100644 index 0000000..08c41cc --- /dev/null +++ b/tests/data/cr4_opal_oracle.cpp @@ -0,0 +1,206 @@ +// CR4 TSO-clip oracle: STAR's real Opal call, transcribed from ClipCR4.cpp + +// ClipMate_clipChunk.cpp, emitting `read \t clip \t score \t L` per read. +// +// Generates a deterministic, boundary-heavy CR4 read corpus, runs it through +// Opal in STAR's 64-read chunks with STAR's exact parameters, and applies +// STAR's clip gate. The TSV it prints is the committed expected output for +// rustar-aligner's `cr4_tso_matches_star_opal_oracle` test. +// +// Regenerate (needs a STAR checkout for opal.cpp — MIT, (c) Alexander Dobin): +// +// OPAL=/path/to/STAR/source/opal +// g++ -O2 -std=c++11 -I"$OPAL" tests/data/cr4_opal_oracle.cpp "$OPAL/opal.cpp" \ +// -o /tmp/cr4_opal_oracle +// /tmp/cr4_opal_oracle > tests/data/cr4_opal_oracle.tsv +// +// The corpus is driven by a fixed-seed LCG, so the output is reproducible; any +// change to the generator invalidates the committed TSV and must be regenerated. +#include "opal.h" +#include +#include +#include +#include +#include +#include + +static const char *TSO = "AAGCAGTGGTATCAACGCAGAGTACATGGG"; +static const uint32_t READ_LEN = 91; +static const int DBN = 64; + +static uint64_t st = 0x51ED2701ULL; +static uint64_t lcg() { + st = st * 6364136223846793005ULL + 1442695040888963407ULL; + return st >> 33; +} +static char base(uint64_t v) { return "ACGT"[v % 4]; } + +// A corpus that straddles STAR's S<20 / S==20&&L>26 / S==21&&L>30 decision +// boundary: TSO with 0..14 mismatches, 5' shifts, truncations (overlap mode's +// whole point), indels, embedded Ns, polyA, and pure random. +static std::vector corpus() { + std::vector reads; + std::string tso(TSO); + + for (int i = 0; i < 600; i++) { + std::string r = tso; + int k = lcg() % 15; // 0..14 mismatches + for (int j = 0; j < k; j++) { + size_t p = lcg() % r.size(); + r[p] = base(lcg()); + } + if (lcg() % 4 == 0) { // truncate the TSO (partial overlap) + r = r.substr(lcg() % 12); + } + if (lcg() % 5 == 0) { // indel inside the adapter + size_t p = lcg() % r.size(); + if (lcg() % 2) r.erase(p, 1); else r.insert(p, 1, base(lcg())); + } + size_t shift = lcg() % 6; // 5' offset before the TSO + std::string read; + for (size_t j = 0; j < shift; j++) read += base(lcg()); + read += r; + while (read.size() < READ_LEN) read += base(lcg()); + read = read.substr(0, READ_LEN); + if (lcg() % 8 == 0) read[lcg() % read.size()] = 'N'; + reads.push_back(read); + } + for (int i = 0; i < 150; i++) { // pure random + std::string read; + for (uint32_t j = 0; j < READ_LEN; j++) read += base(lcg()); + reads.push_back(read); + } + for (int i = 0; i < 50; i++) { // polyA / polyT / N-heavy + char c = (i % 3 == 0) ? 'A' : (i % 3 == 1) ? 'T' : 'N'; + reads.push_back(std::string(READ_LEN, c)); + } + for (int i = 0; i < 100; i++) { // short reads (STAR N-pads to 91) + size_t len = 5 + (lcg() % 80); + std::string read = tso.substr(0, std::min(len, tso.size())); + while (read.size() < len) read += base(lcg()); + reads.push_back(read); + } + + // ---- poly-A corpus, for polyTail3p (appended last so the reads above keep + // their sequences and the TSO expectations stay stable) ---- + // Straddles polyTail3p's own boundaries: the score>=20 floor, the 70% + // density rule, the ib-score>27 give-up, and the seqLen<20 early return. + for (size_t tail : {0, 1, 5, 9, 10, 15, 19, 20, 21, 25, 30, 40, 60, 91}) { + std::string head; + while (head.size() + tail < READ_LEN) head += "CGT"[head.size() % 3]; + reads.push_back(head + std::string(tail, 'A')); + } + // A-rich upstream: the scan does not stop at the tail boundary. + for (size_t tail : {20, 25, 30}) { + std::string head; + while (head.size() + tail < READ_LEN) head += "ACGT"[head.size() % 4]; + reads.push_back(head + std::string(tail, 'A')); + } + // Interrupted tails: one or more non-A inside an otherwise clean run. + for (size_t gap = 1; gap <= 12; gap++) { + std::string read(READ_LEN - 40, 'C'); + std::string tail(40, 'A'); + for (size_t j = 0; j < gap && j * 3 + 1 < tail.size(); j++) tail[j * 3 + 1] = 'C'; + reads.push_back(read + tail); + } + // Short reads around the seqLen<20 floor, and TSO+polyA together. + for (size_t len : {5, 15, 19, 20, 21, 25}) reads.push_back(std::string(len, 'A')); + for (size_t tail : {10, 25, 40}) { + std::string read = tso; + while (read.size() + tail < READ_LEN) read += base(lcg()); + reads.push_back(read + std::string(tail, 'A')); + } + return reads; +} + +/// STAR `ClipCR4::polyTail3p`, transcribed verbatim. `seq` is numeric (A == 0) +/// and is the read *after* the 5' TSO clip, matching `ClipMate::clip`'s order +/// (type 10 shifts the sequence and shrinks Lread, then type 11 runs on it). +static uint32_t polyTail3p(const uint8_t *seq, uint32_t seqLen) { + if (seqLen < 20) return 0; + uint32_t ib1 = seqLen - 1; + int32_t score = 0, score1 = 0; + for (uint32_t ib = 1; ib <= seqLen; ib++) { + if (seq[seqLen - ib] == 0) { + score += 1; + if (score * 10 >= (int)ib * 7) { ib1 = ib; score1 = score; } + } else { + score -= 2; + if (ib - score > 27) break; + } + } + if (score1 < 20) ib1 = 0; + return ib1; +} + +static void encode(const std::string &s, uint8_t *dst) { + uint32_t minLen = std::min((uint32_t)s.size(), READ_LEN); + for (uint32_t i = 0; i < minLen; i++) { + switch (s[i]) { + case 'A': dst[i] = 0; break; + case 'C': dst[i] = 1; break; + case 'G': dst[i] = 2; break; + case 'T': dst[i] = 3; break; + default: dst[i] = 4; + } + } + if (s.size() < READ_LEN) memset(dst + s.size(), 4, READ_LEN - s.size()); +} + +int main() { + // STAR's ClipCR4 constructor, verbatim. + std::vector scoreMatrix = { + 1, -2, -2, -2, -2, + -2, 1, -2, -2, -2, + -2, -2, 1, -2, -2, + -2, -2, -2, 1, -2, + -2, -2, -2, -2, 0 + }; + int alphabetLength = 5, gapOpen = 2, gapExt = 2; + + std::vector dbSeqArr(DBN * READ_LEN); + std::vector dbSeqs(DBN); + std::vector dbSeqsLen(DBN, (int)READ_LEN); + for (int i = 0; i < DBN; i++) dbSeqs[i] = dbSeqArr.data() + i * READ_LEN; + + std::vector opalRes(DBN); + std::vector opalResP(DBN); + for (int i = 0; i < DBN; i++) opalResP[i] = &opalRes[i]; + + std::vector query; + for (const char *p = TSO; *p; p++) { + query.push_back(*p == 'A' ? 0 : *p == 'C' ? 1 : *p == 'G' ? 2 : *p == 'T' ? 3 : 4); + } + + std::vector reads = corpus(); + + for (size_t off = 0; off < reads.size(); off += DBN) { + int dbN1 = (int)std::min((size_t)DBN, reads.size() - off); + for (int i = 0; i < dbN1; i++) encode(reads[off + i], dbSeqs[i]); + for (int i = 0; i < dbN1; i++) opalInitSearchResult(opalResP[i]); + + opalSearchDatabase(query.data(), (int)query.size(), dbSeqs.data(), dbN1, + dbSeqsLen.data(), gapOpen, gapExt, scoreMatrix.data(), + alphabetLength, opalResP.data(), + OPAL_SEARCH_SCORE_END, OPAL_MODE_OV, OPAL_OVERFLOW_BUCKETS); + + for (int i = 0; i < dbN1; i++) { + int L = opalRes[i].endLocationTarget + 1; + int S = opalRes[i].score; + bool L0 = S < 20 || (S == 20 && L > 26) || (S == 21 && L > 30); + // STAR then applies min(clippedInfo, Lread) in ClipMate_clip.cpp. + const std::string &r = reads[off + i]; + uint32_t clip = L0 ? 0 : (uint32_t)L; + clip = std::min(clip, (uint32_t)r.size()); + + // 3' poly-A, on the read as it stands after the 5' clip. + std::vector enc(r.size()); + for (size_t j = 0; j < r.size(); j++) { + enc[j] = r[j] == 'A' ? 0 : r[j] == 'C' ? 1 : r[j] == 'G' ? 2 : r[j] == 'T' ? 3 : 4; + } + uint32_t polya = polyTail3p(enc.data() + clip, (uint32_t)(r.size() - clip)); + + printf("%s\t%u\t%d\t%d\t%u\n", r.c_str(), clip, S, L, polya); + } + } + return 0; +} diff --git a/tests/data/cr4_opal_oracle.tsv b/tests/data/cr4_opal_oracle.tsv new file mode 100644 index 0000000..14049a7 --- /dev/null +++ b/tests/data/cr4_opal_oracle.tsv @@ -0,0 +1,938 @@ +GGAGCAGTGGTATGAACGCAATGCAAAGGGACGACTTCCAACTCGTGTGAGTGTCTGAGTGATATGCTTCCTCATAGATTCTGCTTCGACG 0 10 30 0 +ATAACCACAGGTAACAACGCAGAGTACATGGGCATTGGATCAACACGGGACCAGAGTGGAGGCGGGCGATTTATCTCTAGTCTAGCTACGT 0 18 32 0 +TGAAGCAGTGGTATCAACGCAGAGTACATGGGGATTAGGTACGCCGCGCTGGGGCAGGGTTAGCGCTGGAGCCCTCAGTTGCCGCTAGCGC 32 30 32 0 +TCAAGCAGAGGTATCAACGAAGATTACATGTGCCACCCTCCGTGGGTAGCTGAAGGAACACTTCTACATCTCAAAGGAGCATACATAGCTT 0 18 32 0 +AAANCAGTCGTATCTGAGCAGAGTACGGAGGGATGTTGGAGTGAAGTCATCCAATAAAGTACTAGTCGTGCGTAAACCAGGCGGGTGAGTG 0 9 32 0 +TGATCAGGCAGGGTACCAACGCCGAGTACAAGGATAGGGTACTGTATCCCGAAATTCTTGTTATCAGTCTGTATTTGCAGTATTAGGGAAC 0 12 33 0 +TGGGCTATGAACTCAGAGTACATGAGACTCACGAGGAGTGACCGACTGCGAGGATGAATACAAGCCTAAGTTCTTGATTAGTGATCGGGCT 0 11 26 0 +AGTATCAACGCCGATTACATGGGACTACGCGGAAGTGGGATTAAATCGACCATAGGGAAATCGTCCCAGCGACCCGATATGTAGCTTACTG 0 14 23 0 +GGAAGCACTGGTATCGACGCTGAGTACATGGGTATAGGAACTTGTGACAAAGTTGTCAATCTGAACTAAAGAATTCCTAACAAAGCAGGGT 0 21 32 0 +TTCAAGCAGTGGTATCAACGCAGAGTACATGGGCGGTGTTACTCGTCCAACATGCCGCTTGAGGTTTTAGGACCGAGTTAGGGCCATAACA 33 30 33 0 +TAGTGTACCAACGCAGAGAACTGAGGCCCATTCCAGATCTACTGTAATTTTGAAACTCACAGGAGCGAATCCCTGGACCGGTGACGGGGGT 0 10 26 0 +TCGTGGGAGTGGTATCAACGCAGAGTACATGGCAGAGGACCTATCAGTAGACTGACCCGACAAAGCTCGAGCTGTCGCGAAATCCCGGTGG 0 18 32 0 +CATTCAAGCAGCGGTAACACCGTACAGTACAGGGGAGAAACCCCCCCGCATAACGGGATTGGGATTGTATAATAGAATTCTTTATGTTTCG 0 12 34 0 +TTCTTAAGCAGTTGACGAACGCAAAGTACATGTCGGCATCCGAACCGATAGGACTTTCGAGCTCGCACAGTCGTACGTGATCTCCGAAGTC 0 12 36 0 +ATCCACGCAGAGTTTATGGAACAACCTGAAAATATCTAACAGTGGAGCGACTGGTCGCTTCGGATTAGGATAGTGTATACTCATTTGCTTA 0 8 19 0 +AGCAAGCAGTGGTAGCAACGGACAGTACATGGGGTATTAGAAGTGGCTCGCATGAAACTCGAAAGCAAATGCATNTTCGAGGTTTTGTCCG 0 21 33 0 +CGAGTTGTTGTATAAACGCAGAGTACAGTGTGCTAGTAAAGTGGAGATAGGTCCCAATTACATTTTAGGTATCCAAATCAGGCGCCATATC 0 11 32 0 +AAAGCTGTGGTATCCACGCAGAGTACATGGGAAACGATACGCCGAGCCGAATGTACTTCCATAGTCGGTTAAGACGAACGCCCAGCCTCAG 31 24 31 0 +TAGGCAAGTATTGGTAGCAAAGCCAACTACAGGTGACACTATCAGAAGGCTGAACGACGCAGCCACAAAGGCACCTTCGACTATCCTTGCG 0 5 35 0 +GGATGCAGTGGTAACACCGCAGAGTACAAGGGCGTGGACTTGGCTTCTGATGCCGCGCGGCTCTCCAAGCATAACCTATTAGGCGCACTTG 0 18 32 0 +GGGTCTATAAACGAACATTTCATGGTATGATATCGGGTCATAAACCGCATTAGCGCCGTGAGGCATGTGCGGGGCTCAACGAAAAGACAGT 0 5 91 0 +AGAAGCAGTAGTAGCAGCGCAGAGTAGTCCGCTGCTGTACGCCGTAGAGGCCTCGGGACGTAGACCACACACAACTGTTGGTTCCGGCGGA 0 9 31 0 +GAAAGTATTAGAATCAAAGCAGAGTAAATGGATTAAACACTAATATTGATGTGGATTAACCTTAGAGCCCGTTCCCTTGGCATCGCCTCAA 0 9 31 0 +CAAGAGCAGTCGTATCGACGCAGAGTACATGGCTGCAAGCTGCAACTGAACGGCCCGCGGTGGGTCCTCCGGGCGAGGATAAGATCCAATG 0 19 32 0 +GATAAGCAGTGGTATCAACGAAGAGTACATGGGCGCAGTCACCTAGGCGACATGCGGAGTGCGCCCAGTAGGAATTGAATTATGAGCGGAT 33 27 33 0 +AGTCAGTGATATTAACGCTGAGTACATTGTCCCACCTGCCTGGACTCTTAAAGCAATCCTTTTTCTCGAGCTTGTTCCCCTGGCCAGTGGT 0 12 29 0 +GCTCAGAAATGTCATCAAAGCAGAGTATATAGGTCAAAGGTCCTGGATAAAAGGCTGCCACATGTCTAAGCGNGAATACCAAAAGCTTTCG 0 7 33 0 +AAAAGTCGTGATATCAACGCAGANGACATGTGCTCTGTGATACACGCTCGGGGGCCACCGAATTGAAATAAGAGGACTAGCACACTAGCTC 0 14 32 0 +AAGCAGTGTTATCAACGGTAGAGTACACAGGACACCCCCGTCTAAGTCATCGCCGGGTACACTGCCGCCTCTTTGCATCAAGGACCCAGAG 0 16 31 0 +GGTATAAGCCGTGGTATCAACGAAGAGTACATGCGGACTTATTGGAACTATCATGTACAACCCATACGCCGGATGCGAAAAGTACTCACCG 36 22 36 0 +ACACGAAGTGGAATCGACGCAGAGTACATGGGTGTGTGGAGACATATACGATAAGTAGGAGGCTAATAGGATCAGAAGCTTCGAATTTCAC 0 18 32 0 +GAAGCGGTCGTATCAACGCAGAGTTCATGGGCCGTACTCAGTATGGCTGGGTATGACACTAGCGCCTGACCTATGTGACTTGAGACTGAAT 0 21 31 0 +AAGAATCAACGAAGAATACGGGGGCCCCTCACATTGTGCGATTGGGATCGACTGAGCGTCTGACAGCCATGACGATTGCAAGTTCTGCGCA 0 3 22 0 +GAGGAGAGCAGTGGTATCAACGCAGAGTACATGGGCAATCCGCAGGCTTTGTGTGGACAAACTCGCCCGCCCATGATATAGAATGGAAGGG 35 28 35 0 +GGTAAGCAGTGGTATCAACGCAGANTACATGGGGCTAGGTTTAGGATATACACTGAATGGCACGGCCGAAGCGAAACACCGCTTACCGGGA 33 27 33 0 +AAGTAAGCAGTGGCATTAACGCAGAGCACATGGGTGCGACTTAAGTCGGTCCCCCGGCTTCGCTGCGAGCCGAGCATCAGCGAACGCACGG 0 21 34 0 +CAGAAGCATTAGTATCAATTTGGAGTAGCCGGGCAATAACTCCCCATTCCCACAAGTCTGGGAGCATTCAGTGCCCCTATCCGCGGCACGC 0 4 33 0 +GTCCGTATCAACGCAGAGTAATTGGGCTGTAGTTTGTGTCTTGGCAACTAGTCAGGGCGCCAGTAAGGAACGCAATCACGAACTAAGACAC 0 15 26 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGTGTAAGTGCCACTACAAGCGCTCAAGGGTACGAAGCCTGACAAGCCTCCTGCAAGAACTCA 30 30 30 0 +GTTGCAGTGGTATAACCCCGAATACATGGCCGCACCATTGTAGTTAGGGTTTTACTGTTATATCCGAATCGCTAATCGCAAAGACGCTCAA 0 9 29 0 +TCAGCAGTGGTATCAATGCAGATGAGAGGGCGGTATGACGTGGGAATATAGTACAATGGTGTTTGCATATCATTATCGTAACGTGTGTTAA 0 13 30 0 +TCAGCAGTGGTATCAACGCAGAGTACATGGGGGACGGGGCGCCCATTTGTTCAGGATTTTTTACTCTGAAAAGCAAGNAACCCCCACTAAG 31 27 31 0 +GTGGGGTGGTAACAATCAAGAGCACAGGGGTCCGGGTGTCACTCCCCAGGCAAGCAAGTGAGGCTGGGGCTCTGCGACTGCTATAGATACC 0 2 5 0 +AAGCAGTGGTTATAAACGCAGAGTACATTGGAATCCAGTGTTCACGAGAAACTTAAATCAACCAACGAGACATTGTTTCGAGACCGCGTGC 31 22 31 0 +CAAAGCAGTGGTATCAACGCAGAGTACATGAGTCCGGCGAGGGGTGGACCGCCCAACACCTACGCTGACGTTGTACTAAAACTTTAGCGTA 32 27 32 0 +AATTATGGTATCAACGCCGAGTACATGGGTCTGGTTCCCAAACTGACGTGGGTCATGACAGCCATATTACTGAGAGTGCGGTGGGTCCATT 0 18 29 0 +TATCAACAGAGAGGAGATGGGGTCGATCCTAACTGAGTGACCGCACCATCAAAGCAAAAAGCAGCATTTTCTTACCGTTAGTTCATGCGTC 0 10 21 0 +TCATAAGGAGTAGTATCAACGCAAAGTGCAGGGAAACCTATCTGGAGGCGAAGCTACGGCGGAGCTGAGCGGCGCAACGAATAACTGGGTC 0 15 33 0 +GTATCAACGAAGAGTACACCGGCGAGGCTCCATCTGACTGGAAACGGATAATAATCTTGCAGTGTTGTCAGGTATGAAGGCGTTTTAAAGG 0 13 22 0 +TGAAGCAGTGGAATCAAAGCAGAGTGCATGGGGAACAAGATATTCCAAAATAACCTATCAGCATGGTATCCTAATCGCAGTTCGACGAGCG 0 21 32 0 +TGAAGCAGTGGTAACAACGAAGGGTTCATGGAGACGGAAGTCGGCCTGAAAGCACTGAATTGTGTATCGCAAATAGTAATGTCGGGTTCAG 0 16 33 0 +AAAAGCAGTGGTATCAACGCAGAGTACATGGGGCGGCGCCAGTGGGCTTCATCAGAGCGGCGTTAGTGGTATGGGCAGTCGTTTTGTAACA 32 30 32 0 +CCAGCAGTGGAATCTCCTCAATGTTAATGGGTATGAGTGGCCTCACAAGTACCTCAATACACCCGTAAGCCAGCTTAGCCATTAGAAACTG 0 5 31 0 +TGACCAGAGATCTCGACGCCGAGTACATAGGCGCGTCGCTAGGTATTAAGTTTCGAAATCATCAGGCCGGTCGTGGGAGGAGGATGCATGC 0 6 31 0 +GCTAAAACAGTGGTATCAAGGAAGAATATATGCNGAACTTTATCGACGGGGGAGCACGTTGTGGCCATTCAGGTATCGCGTGGTGGTGATA 0 10 35 0 +CGTGAAACCGCTGGTATCAACGCGTAGTAAAGGGGAGTGAGGCCAAAACGCCGGCGCGTATGTAAGTCCTCGGAAATGGGACAACTTTGCA 0 11 34 0 +GGAAGCAGGGGTATCAGAGCAGAGTACATTGGCGGTTAGATGTATGGTCGGTATAGGGGTAAGAAACGGCTGATTCATGTCTAACAGATAA 0 19 32 0 +AAGCAGTGGTATGAACGCTGAGCACATGGCAAGGTACTGACTACTTCGGGTCAACCTGCAACTGACCCCGTAAATCAGAAAGCAGCCGCTA 0 18 29 0 +TTGCCCCGCAATGGTATCACCGAAGAGTCCCATGGTGTTCCCAATTGCGTGTGCTTGTGAATTTACCGGTCCCCTGAATGATTGCTGGAAC 0 8 37 0 +ACGCCTTGTCATCTACGCAGTAGACAATTCGAACATAGTAATTCGGGATTCCTGTACGCCCGACCCCACTGGGGATTTTCGCATGGACGGG 0 0 31 0 +TTTAAAGCAGTCGTATCAACGCAGAGTACATGGGGCATCATACACAGCGTTGGGGTTGAAANTCTTCCAGTTTCGTACCTGAATTCTTACG 34 27 34 0 +AAGCACTGGTATAACGCAGAGTACATGGGTAATATGAATCGTTCACCCTGGTATGAAGACTTATTGTATCGCTTCTTNGAGAAAGTCAAAT 29 24 29 0 +GAGTGGTATCAATTCAGAGTACATGGAGAAACTCGTCAACAAAACGTGGACCAGCCATCCCTCCCGACCACCTGATGTCATCTGATATGAG 0 17 28 0 +CACTAGGGGTGCCAACTTATAGAACATGGGAGGGATCCACGCGTTGTCAATATTTAATATACTGCCGGCGAAGGCCGAGCATCGGACTCCT 0 2 8 0 +GCTACGTTGCTGCAACGCAGAGTACATGGAACGCCCGTCGGATGAGGGATATGTAACTAACAGCTAGGAGAATGTTCAAGGCGGAGATTTG 0 10 29 0 +ATCACCTCAGAGTACCTGGGTCAGTCTCAATGATCTCAAGGAACATGTCCCGGAGGAACTTGCTGGTGGACGGCAATGGTTCACCAAACTG 0 11 20 0 +ACAGGTATCAACGCATAGTACATGGGGGTCCCTGTTACTGTTACGCCATCAATGCGTTTCACTGAAAATCACGGCAACTCCTTTAAGGGTA 0 17 26 0 +AAGCTGTGGTATCAACGCAGAGTACATGCTATACGACAGATTCGCTACTGCCGGTAGGGTAAGCATATGCTGCAAAATGTCCTGCAAGGTG 28 21 28 0 +GTGCTAAGAAGTGGTGTCCACGCAGAGCACAGAGGCCGTCCAGGATGGTCCCTTGAACGGTAGGTCACGACACTGGTTATAGCTGCAGCGA 0 13 35 0 +CACAAGCAGTGGTATCAACGCATAATCCATAGGGCTCTGTTTTACCGGTACTGTGCCCCCCCAGCTACTCAACTGGGAGGCACTTGACGAG 0 19 34 0 +TCGTCAAGCAGTGGTATCAACGCAGAGTACATGGGGTTTAGGATACACGTCGAAGGTGGGTGCTGTGACAGCCTGTCATGACATTTGCAAC 35 30 35 0 +CAATAAAGCAGTGGTATCAACGCAGAGTACATGCGAGGACTCCCATAACTAGCCGCCTCGCGACTTTGGCGATTATAAACCCCGTAGTGAG 35 27 35 0 +GAAAAAGCAGTGGTATCAACGCAGAGTACATGGGTAGCTCCGGTAGTTAGTGGAGCCAGGTAAGCGTATGTGCAACAAGAAGTGCAGGGCA 34 30 34 0 +GCAGTGGTATCGCCGCAGAGTACTTGCGCTGGCGCCGTGTCTTTAGCCAGACAAGCAGATTGGGCGGGTATACCTGAAAGAATAACTACCT 0 16 28 0 +AAGCAGTGGTATCAACACAGAGTACATTGGAGTCGTTTGAAAACTTACTNTGTCTGACTGGTTTCTTACCGATTGTCTTGTGACCATGTAC 30 24 30 0 +GAGGAAGCAGTAGTATCTACGGAGAGTACATGAGCTTTCTCTCTATCCGTAGACAGCAAACCTCCCCCACTATTTGTCGTACATAACATTG 0 18 34 0 +ATGAAGCAACCATATTATGGCATAGTACAGGCGACATGTACAATATGGAATGGGTAGGGTAAATGAAGTGCGAAACAAGCGATACTGGTTA 0 2 88 0 +TGCGAATCAGTGATATCAACGCAGTGTACACGGTTCCGGCACTTGGTCCGGGTCTTACGAGGGCTACTACCTATAGTCCTCGGGATTCAGC 0 15 33 0 +TAAGGCAGTGCTAGCAACAAGGAGTTCAGATGTTTAACTACCATCTCGGCTTGATCCTTGAGAACTCTTTCCATCCCCTGTTAGCATCGAT 0 3 32 0 +AAGGCAGTGTCATCAACGCTGAGTCCATGGACTTTGGGGGAGTAGTAGCCCACACGCTGTGTTCTTCGCCCAGTTGCATGTTTAAAAGCAG 0 14 30 0 +AAACAATGGTATCAACGCAGAGTACATGGGCTATTGCAAAGGCGCCAGCCGGTCCAATGAGCGTTAGACGCCGATGAAGGCTAAGATAGGG 30 24 30 0 +AAGCAGGGGTATCAACGCAGAGTTCATTGGGTGCTGAGCGGGCATCAGTACTGGAGCCTATCTGTGTCATTCACGAGCTTTAGACAGGGCT 31 22 31 0 +GAAAGCAGTGGTATCATCGGAAAGTACCTGGGACGAATACCGGAAGGAGCTGGGTATCGATTTGCTTTGGGATAAGATGCTACGACACACG 0 18 32 0 +GACGGAAGAAGGGGAGTCTACGACGAGTAGATGGCTCCTTCACGAGATTATGGTGTACGCTTAACAACGGATATACATCCGGTCAACACAC 0 5 34 0 +TGGAGCGGTATCAAGGCAGAGTACATGGGGAGTTCCCCTTAGGGAAGGATGGATCGTCCGTACTGTGAAACTACCCCCCACCACAAATAAT 0 17 29 0 +TCTTAAAGCAGTGGCGTCAACGCAGAGTACATGGTTTTATGTATAGCTTCCCTACTGCGTAACACCCGAAGCCATTTCTTATGAGTGATGA 0 21 34 0 +AAGCAGTGGTATCAACGCATAGTACATGGGTCCACGGCAGCGGGTAGGCACGCGGGNATCTGTAACCTCCTTACGCCTCGCCCCTGATTTA 30 27 30 0 +ACGCAGTGTTATCAACANATGGTACGTGGGGCCAATTTACTGAGGGCCGACGATAACAGATAAAAAAAGTGAGACTAATTATATGTTCACG 0 10 30 0 +ACAAGCGGTGGTATCGACGCGGAGAAACTGGTGATTGTGCCGCTGCCTGTCGCCAGTGTGACAGCGTAGTGCTCTACTACAATGCATGCCT 0 11 33 0 +CGGAGACCAATAGTATGAAACAAGAGGACAAGGTAGGAGAGGAGCATTGCCGGGGGCATATGCCCCTCCCTGAGGCATTACAAGGGCGCAC 0 0 3 0 +GCGAAACGTTTGTACCAACGCAGCGCAAAGGGGTACAGGTACTATAACTATAATCAAGTGAGCAACCCCGTATTTTGTCGGTAGTGTATCA 0 4 32 0 +AGGCAGTGGTATCAGACGAATAGTTCTAGTGAGACATAAAGGCACAATAGGGCGATCTTTAAAAGCCAAACTAGTAATCGCGACGGCCTAT 0 9 33 0 +AAGCATTAGCAGCAACGCCGAGTACTTGGGCCGCTCATGCGAGCCGTCCATCAGTCGGCAGCGAATTTCGATCGAGACGTATGGTCGACAG 0 12 30 0 +TGGAACCAGTGGTATCAACGCATAGTACATGGGTCACCCCGGACGCAGCAATGCGGAGCACGGGAGGTTGCGTTTTAGTCAATGAATCTTA 33 24 33 0 +GGATGCTGTGGTAACAACTCAGAGCACAAGGCCTGAGCCCGGTCGAGTGGCCCCGAGAATGAAATTTCATAGGTCATGTTAACCGACCTTC 0 9 31 0 +TCTGGTGGGAGCAACGCACAGTACATGAGACCTAACTGTCCCACTGGCACCTGTGTTGACGCGCGGGAAAGTGATTGGAGAGGGCTTATCT 0 8 29 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGTGTAAGCAACGTAGAAAGAATCCTTCAACCTCGTCAATATAGCACGCCGGGAGAAGAAACA 30 30 30 0 +GGATGCAGTGAGACCAACTCAGATTACATGGGCCGTGCATGAGAAGAATGCAAGACTCAGTTGACTTTACTAACCGATATGTCTTCCCTGA 0 13 32 0 +GAAGCAGTGGTATCAACGCAGAGTACCTGGGTTACCCCGAAGAGAATGCGTTTAGTCAGAGCTGAAACGAATGCGCGCCTCCTGGGAATTT 31 27 31 0 +GAAAAGCAGTTGGATCAACCCACAGTACACGGGAACGATTGTTTCTGCCTATTGTGTCCAAACCAGACTACTCTGCATCCTTACGACCTGT 0 16 33 0 +TACCGAAGGAGTGGTATCACCGCAGTGTACATAGAGTGGAGTTCATTCCCTATAGTCGGATTATCACAACTCCCCCTTTAAAGCCTATTCG 0 16 36 0 +ATAAAGCAGTGGTATCAACGCAGAGCACATGGGCAAGTATCTCGCACGCCCGCAATAAGTAGTGTTAACCGCGCACTCGCACAGAACGCCT 33 27 33 0 +ACCATGTATCAAAGTACTGGACATGGGATCGAACCAGCATTAGGCTATTTTCCTATTTAAGTCCCCATTAGTGCTCTACTTAACACCGTGG 0 5 27 0 +TTAGTGGTATCAACACAGAGTACATGGGGAGCGCGTGCGGGGATGCTGTGGTGCAATTAACCCCCACATTCGCAACTTATGCGGGCTTTCG 0 19 28 0 +TCGCGAGTCAGTTGTTTCAACGGACAGTATATCAGGGCTACGGGGAACCTGTCCTGCTGCTCGCTCTGAGGCGAACTAATGGGTCCCTCCC 0 6 37 0 +GCGAAGCAATGGTATCAACGCACAGTACATTGGCTGGGGGAAGTATGGAGACGAATAACCGAGGGATATCTGTCGGGCGTCCGTGACAATA 0 21 33 0 +CCGCGCTATCAATGCCGAGTACATGGGATCTGCTGTCTCATGGCCCTTACTCTAGAGTCCACGCGTTCATCCAACAATGCAATCATATCAG 0 12 27 0 +CAGTGGTATCAACGCAGAGTACATGGGGCCGCATCTTCACAATGCACGGCTGGGGAAGGCCCGTGGACCGCGGATATTGAAGACCACAGCG 27 27 27 0 +GTGGTATCAACGCACCGTACACGGGCCGATGATTAGATGTGCTTATCCATCTGAGGCGGACGATTTTTCTTGGAGCGATCCAATATGCGGC 0 16 25 0 +TCAGGGTGGTATCAACGCAGAGTACATGGGTGGGGAGGTCACAGACTGGCTTCGTCCGCAAAGCGGCGTAGAACGAGGTCGAGGTTTCAGC 30 21 30 0 +TGCTAAGCAGTGGTATCAACGCAGAGTACATGGGTTATATTAGTCTTATCGTAATTGATCGTTTTCCAAGAGCCGTACGCGGGTCAGCGAA 34 30 34 0 +GAAGCAGTGGTATCAATGCAGAGTACGTGGGTACGTATGTATCGCGCATTATTAGTAAATTCCCTTCGGAGAAAAGAATAGTTATTACCTA 31 24 31 0 +AGCAAGCATCAACGTAGGGTACATAGGATGTCAAGAGGTAATACGTAAGTTGGCCTACATACTTCAACGAAAAGGCGATGGGCCATGCCTC 0 8 27 0 +AGCGGTATCGTCTCAGAGTACATGGGCTCCTGAGCCTTCCAATCTTGATACATGCTGTCTTCATTTAGACGGATGTGCGTCATTCTGAGGG 0 14 26 0 +CGTATTAACACAGAGTAATAGGGTCTGCCAATGGCTGGGTCTGTACCCAAGGATGTCGGGACGCAGATAAGTCATATTCTATTGCCTTGAC 0 9 23 0 +TGCATAACCAGTCGTATCAACGCAGAGTAGATGCGAAAAGTTCGCGATAATTGCGCCTCCTCTGGGTCTGAGGGCTCTTGTAGGACGCGTA 0 18 35 0 +AAGCCGTGGTATCAACGCAGAGTACATGGGTAAAAGCAACTGACGAAAGATAACTAATTTTTTTAGCTAAAGGGATTGGGGACCGAACCAC 30 27 30 0 +TCGAGGCAGGGGTGTTAACACACAGCACGTGGGGACTGATCCCATGCCCCAATTACTTGTAAAACCCTAGGTTTCGGACAAACTGCCTTTC 0 6 33 0 +CTTAGCAATGGAATCAACGCAGACTGCATGGGAGTTTCAGCCAGAGACTCTGCGTCGTGGCGTTGCCAAAGGCGGCAACGCAAGCTTGACA 0 15 32 0 +AAGCAGTGGTATCAACAGCAGAGTACATCGGGTGCGCATAAATCGTGCGACCGGCTCAACCGGCATGACATCAGAGGGTCGGTCACATTGA 32 26 32 0 +TAGGCCGTGGTATCAACGCAGAGGTACATGGGTGTAATATCTCCGCCGTCTGGGACGGCCAAAAGCTAGTTCTATGATGGGTCGAGGCCTA 32 22 32 0 +TAGGGTGGTATCAACGCCGTAATACACGGTCCGCTGGCCAATTGTGAACGACGCGCCAGGACGTCGGGTGTGTTTGACGCGTTCACACTCT 0 7 29 0 +ACGGACGCAGGGGTTATCAGGGGAGAGTACATGGCTGCACACGTCGGGGTCTGTGGATACCCACGCCGGTGTCACCGTCAGTGGCTCAGGA 0 10 34 0 +ACATTAGGCAATGATGAAGACGCAGCGTACACGTGCTCCTAAGCCGGGCGAGTAGATGCATGGAAGCTCAATTTGAAAGCGCGAGGCGCGC 0 2 8 0 +GCGGGTTTCAACGAAGAGTATGTGAGTCAACGTCATTCTACCCAGCTTCCACACACGAGGTTGTGTGCCAGCCGACCCTCCGCGTCAGTAA 0 7 24 0 +ACTGATATCAACACAGCGTACATACGTGAGAGTGTACGCTTATCCTTCAAGGCCAATCAAACCCTCTCTCGCACCCCATCGGCGGCAGTGT 0 8 26 0 +TCNAAGCAGTGGTATCAATGCCAGTACACGGGGGAGCAGCGAATGTACCGAACCGGAGCCGTGGTAGCGACCGCTCTTAAAGGGCGAACCC 0 18 32 0 +AATAAGTGGGAACAACGCACAGTACATGATCGGGAGCGTTTTTCAAGGCGTAGCAAAATGCCAGATAGCTGTGCGCAATTGAACCGGAGGC 0 9 28 0 +CGTGGTACGGACGCAGAGTAGATGGGTTATAATAAGCTGACACCGGGTGCGTCGGAACGGAGACTTGGCTCCGGCTACTATAATTTCCTAC 0 13 26 0 +CCGAGCACTGGTATCAACGCAGAGTACATGGGCTCCCTGAAATTGTCTCCTAGATACGGACAACACAGTAGGACGTAATCGGCAATGCTAT 32 24 32 0 +CTATGGTATCAACGCAGAGTACATGGGCTCATTCATGGCATAAGCGAACGTAGCAAACGGCCACTAACCGACGGGCTTAGCCCCGTATAAC 27 22 27 0 +GTAAGCAGCTGGTATCAACGCAGAGTACATGGGTACAATAGAAAGTCGGTCCTCCACAGTGGGCCCCCCAACATATGGCGGCGCGTCACAT 33 28 33 0 +TGCGAAGTCAGGGGCATCTACGCAGAGTACATGGGTTATTGCGGGACTCGCGCTAGAACGGTACCGTGGGCTGGCTATGGNTTCAAGGCAT 0 19 35 0 +AGTAAGCAGTGGTATCAAAGCCTACTACCGCGGTAGTGACTTTTGGTGCCCGACTCTCATTTTTCCGCTTCGCGACCGTGAACCCCACCCC 0 10 33 0 +ATTATAGACCTGCTATCGTCCAGCGTACATGCCATAATGCATTGGCCATGCTCACGTAGGGTTCACGTTTTTTTGGACCAGGTAGTGTTGG 0 -1 31 0 +GAAAACAATGATATCAACGCAGAGTACACGGGTTACAAGCGTGACACCGCCCTGCGGCCCTACAGCGCAGCAGAAACATTGTTCCCAGTGC 0 18 32 0 +AAGACAAGCACTGTGAACAACGCTGATTGCATGGGGTATTCCGCATGCTCATAATGCAAATGATTGTCCATCCCCATTTGACCGTAACAAG 0 10 35 0 +AAGCGGGAGGATCAAAGCAGGTTGCATGGCCGATCTGTGCGCGCGTGCGCGGCCAAAAGCAGGGCATTAACTCCTTATGGTATGCCCCCGA 0 5 29 0 +AAGCAGTGGTATCATGGCAGAGTGCATGGGGATTCAAGAGGCCAAGCGAGGGTTGTTGAATGCGCACCACAGTCGCGCGGCCCGAAGGGCG 30 21 30 0 +AAAGCAGTGGTTTCAATTCAGCGTACCTGGTTAACAAAAAAGCGTAGACACGACCTTTCTGCCTCCGTCGCAATACCGTGAGCGACCAGCC 0 12 30 0 +GGCAAGAAGTGGTAGCGACGTAGTGTACACCGTGGGAAACAGCCGCTGATCTCTAGAGAAGGGTGTCAGTACACGTTTCTAGACGATACGT 0 9 36 0 +CGGAGGATGAATGGTATCGACGCAGAGTTCATGGGGGAGAATAACTTGGCGGCGGCGCTTGTATGTTTGCTTATCCAGCAAGAGCACCAGT 0 15 35 0 +CTTGCGGTTTCAAGGCGGAGTACGTTGGCTCTAAGTGTATGTAGATCCTTGGGACACGCGTCATCCGACGAGCGTTAAGCCGTAGAGCTCC 0 4 28 0 +GACTAGTGGTATCAACCCGGAGTACTTAGGCGAACGTCTCTAGGTGGCGCCCTTATTCATGGCAGTATAAGCCTTCCTACTTCGTCTGAGG 0 12 30 0 +CAAACCTCTGGTATCAACGGAGAGTACGGGGGAGGACGCTATACGCAGTTACAGCATGGTAGGATACCAAGGATCACATGGTGTGTCCTCC 0 12 30 0 +TGTGGTATCAACGCAGAGTACGTGGGCCTAGCGCGGAGTCTCGACCAGATCTCAGGTAATGAAATACAGACACGCATGGCTCGTTCACGTC 26 20 26 0 +GGACAGTGTCATCAACGCTGAGCATATGGGCACCATTACCTCGAGGCACTGGTGTAGATTCGATACCTAACGTGAGTGAGCGTGGGTTTCC 0 10 30 0 +GATGTCAACGTTGAGTACCTGGGAGGCAATCGTCGACGCACTTACCCAGGAGAGTTTCAAACGATGAGCCGAATTTGGGTGTTTACCGGCT 0 8 23 0 +TATGAACGCAGAGTACATGGGACCCACACTACATATAGCAGTTGAGTCGTCGATTGGGGCTTGGAAAAAATGGCGCTGTGCGACCAGACGA 0 18 21 0 +CATGCAGTGGTGTCCAACGCAGAGTACATGTGTATCAGATCTTGCTCTTCATCGGGCGCTTTCTCTCTGGCTGGAGGAGCTACTCCTACAC 0 19 32 0 +CGTTTAAGCAGGGGTATCAACGCAGAGTACATAGGAGTTAGATGCCTGAGTGCTACCTTAACACCCTTCAGAGGAGATAAAACCTAGATAT 35 24 35 0 +TTTCGAGCAGGGATATCAACGCAGGTACATGGGTTGGGAGCAATTTAAATAGCCTCGAAGTTTGCACAGACGCTCGCTTATGTTCCATAGA 0 19 33 0 +ATGAGCAGAGGTACCAACGCAGGGTACACGGGAACATGTATAGCGGACTGTTAAACGCTGGGCGGTCGCCTGTTCTTTGTTTGAGGCGAAC 0 15 32 0 +TACCAAGCAGTGGTATCAACGGAGAGTAAATGGGTCCTGGGGCGTGGTGAATCAAGACGCCGTCTACAACTAAGAGACAGGTGCCGATGTT 34 24 34 0 +GCAAAGCAGTGCTATCAACGCAGAGTACATGGGTTGGCAAGGCGTATCCTTTCAATGGACACGAACCATGCCAAACGTCAGAGTATAATCC 33 27 33 0 +CGATCCAAGTGGTATCAACGCCGAGTACCTGGGTGGCGCGTGGAGGAGTGATGGTTACGTTAGGTAGGGACGGGTCTTAACTTAACACCGG 0 16 33 0 +ACGAAGCTGAGGTATCAACTCGGGATACTTTGGCTTTGGCCGCGACTAGCTCCGTCAAATAGCAACGGTCACTCGAACCTCCCGGGGATTC 0 7 33 0 +ACGCAATGGTATCAACGCAGATTACTTGATGTCTAATCCGCCGTGTTATTGCGTCCTAATCCACCGAGGAAAGCCTAGTCAATGGATAAAC 0 13 31 0 +ATTGGTATTAACGTAGAGTTCATGGGGTTGTCAGTTAGGGAGTACTAGGCTTTATTTCGGAGAGAACGAAGAAGTTTATTCTCAGGGAATA 0 14 26 0 +CAGCGGTGGTACCACCGCAGAGAACCTTGGTTTTATGAAACTTTGGAAGGTCGCAAGGATAAAGGACGGAGTGGGGCGAGGAAGACCGCCT 0 9 30 0 +GGTAGGCAGTGGTATCAACGCAGAGTACATGGGAAGAGCCCGACCAAAAAGCGAGACAGGTAAACGAGAATAAGGTTATCAAAACTAGTCT 33 27 33 0 +TACCCAATTCGAGGTATCAACGCAGAGTACGTCATCACGTTGCACGAAGCACGTCCCTCCTGTATAACCTATTAGGACGGCCGGCTTCTAG 0 7 31 0 +TCGGAGCAGTGGTATCAACGCAGAGTACATGGGATCGATGTTTTTTCACGCCGAGACCGCCGTGGCGAGTAACCAGATACAAGGCATGGTG 33 27 33 0 +AAGCAGTGGTATTAACGCAGAGCACATGCCCATATTGCTACCCTAAGAGAGCGCTTATTGAGGAGCCAGTGGTCGGGCAGGCGACAGAGGT 0 18 28 0 +AATAAGCAGTTGTATCAACGCAGAGTACAAGGGTCTAGTACTCATATGACTGTCCTATCGTCCGCTATAGAGCAATATCGGTGTCGCGGTC 33 24 33 0 +CATAAGCAGTCGTATCAACGCAGAGTACATGGTCCTGACTACTCACATTATGGGTGTTTTATCTAGGTTGTAGGAACTATCGTTTTACTAT 32 24 32 0 +GCGAAGCAGTGGTATCAACGCAGAGTACAAGGGTGAAATGGCGATGCGCACAGTGTGTTGGCCGCCTCCCAGCCACCGGGACACAAGTGCG 33 27 33 0 +GCGCAATCGTCTCAACCACCGAGTACATGGGCGCAAAATCTTCTCCCGCAGAGATCTGGCGCAGGCGGAGTTCACATAGCGGACATCGAGG 0 8 31 0 +GATCTATGCAGTGGTTTCAACGCAGATTACTNGCGACATTCAAAAAACGTCATAGTCCAAACGCGCAAGCTAACATTCTACTACGCTTCTT 0 13 35 0 +GAAGCAGTTGTATCAACGCAGAGTACAAGGGCAGTTGATGGGGTTAGGACTGCCAGAGATTAGTACAACGAGATCACGCCGGAATCTGGCA 31 24 31 0 +TCTCTGACATCAACGCGTGGAACATAGGCGCGAAATGTCCCTCGCGTTATCCTACAGGAGCCCCCAATCTGCCGTTGCTCACTCACAGCAT 0 2 91 0 +TCTAAGCAGTAGTATCAACGCAGAGTACATGGGCTTCCCTATACCAGACCTCGAATCTCCCGATCCGACAATTAGCCCCTAGAGCTATAGA 33 27 33 0 +TGAAGCAGTGGTATCAACGCAGCGTACATGGGCAGGGTTAGGGCCCATGTGACTGCGTGTTATTCGAACTACGCTCAGAAGCCAGTCCGCA 32 27 32 0 +GACGCAGTGGTATCAACGCAGATAAATGGGTTTGATAATTTTTGTCTTGGGGTTAGGCCTACATGAAGGGGAATACTGGCTTCTGTTATGA 30 21 30 0 +CCTATCAGTGGTATCAACGCAGATTGCTTGCGTTTCAAGTTTCGTTTTTTGAAGTACGCGTCACGAGTGAGACCTAGAGACAAGGATACCC 0 12 32 0 +CGCCAAGCGGTGGTATCCGGCCTGAGAGCATGGGGAGTCAGATCCACTGGCCAAACTGTCACATTGGGGCAGTGCGCTCGAGCAGATCACA 0 9 34 0 +CAATTGCAGTGGTCGGAACGCAGAGTACATGGGGCGGTCCAATGAAGAAGAATTACGGAGCTGGGGTATTCTGGCTCCGCTGGGAACGTGT 0 17 33 0 +CGGTAGGCAGTGGTATCAACGCAGAGTATAGGGGTCGTACCCGTTATGTTCGGTAGGCCGCTGATTTAGCCCAACCGCTAATGCGTCGCCG 0 21 33 0 +CAGTAAGCGCTGGCATCAAACCAAAGTACATAGGCTTGTTACCTTGCTATCGGGGCCTCGTACTCGGAGGTTGCGTTGCTTAGCCATGTCT 0 11 34 0 +TGAAACAAGGGCATGAAGGTAGACTAGATTGGTAGCGAATCCATTGATCGGTGAAGTGATAAAAGGAAAATGGACTCTTTTATTCCCAGGC 0 1 32 0 +AAGCAGTGGTATCAATGCAGAGTACATGGGAAATCCTGGCGTACGCGCAAACATGGCGAGGAAAGGTGACTCGGTCGAGTCGTAGTGAGAC 30 27 30 0 +CTTAACAAGTATCAGCGACACATTGTACATGGGAAGGTGTCAAAGTATAATCCGTTCTGTTTCGCAACGACAGCCTTGACCTGATGGATTA 0 6 33 0 +ATAACGCAGTGGATATCTACGAGGAGCACATGGGGTTTATGCGTTGTTAACATTCCGTTCATCAGCGGGTATAAATGTCGCCCCTCTATGG 0 15 34 0 +ACCCGAAGCAGTGCTATAAAATGAGAGTACATCTGCCAGAGGGTGTTGTCAGTGTGTTGAGATCGAAAGCTCGGCTTATGAAATCGCCGGT 0 10 35 0 +AAGCTGTAGTATCACCGCAGAATAACTGGGGCAGAGACTGGGCCGTTGTAGAACTTGTCGTGTGAACAGTCCACGGCACTAGTGTTAGCTT 0 13 30 0 +AGCGAAGTAGTGGTATCAACCGCAAAGTAGATGGGAGGGCGGTACAGAGACGGGCAGGATAACGGCAGGGATGTGTATAGTTTCGCCAGAG 0 19 35 0 +TGGCCAAGCACTTGGATCCCCACAGAGTTGATGGGTCATTGTGTTTAGAGACTTAGGACCGCCGCTTCTTAGCTTTTACTGCGTAAGAGTA 0 7 35 0 +AGTCGCAGTGGCACCAACGAGGAGTGCAGGGGCTAACCACATGCATTAAGGCACTTCAAACTCTTGCTCCTCATTCACTAAACCGTACCTT 0 7 31 0 +GNTAAGCAGTGCGATCCACGCAAAGGACATGTGAGGTACGAGTGGAGGAATCTTGCATTGTAACCTAATTACGATACTATTTGCCGGCATG 0 13 33 0 +CTTATCAACACACAGTACGTGTGCAGTATTATAGGGATTCTGGATTGTGGAATAGCAGGACATCGGCCCATCAATACCTATACCACTGAGG 0 5 23 0 +CACGGACTGGTACCAACCCTTACTATAAGGTCAGCCAACTGCCGTTAGATAATCGTAGGACACGTGGATTCTAACAAGCTCAGCAGCAATT 0 0 5 0 +GAAGAAGTGTCAACAACGCAGAGTACATGAGTATACTCAAAGACGGTTNGTTCAACTTAGATTCATTGATCGGGGTCATGAGGGTTCAATT 0 16 31 0 +AATTTGGTATCAACGCCGAATCCATGGGAAGATTAACGTGGTGTATCCTTCACAGCCCGTCATAGGCACCACATATGATAACTCTCTGAAG 0 10 28 0 +CCAAGCAGCGGTATCCACGCTGAGTCCATGGGTAGTGCCGATGCAAAGCGTAAATCGGGCAGCGTCCATCCCTTTCTGATTCCTCTATTTT 0 18 32 0 +TATGCAGTGGTCTCGACGCATAGTACAGGTGGTAACGGCTCGGTTCGTTCTGGGATCCCGCTTAATTACACAATCGCCGCGTCTCTATCGG 0 13 31 0 +GACAAGCAGTGGTATCAACGAAGGGTCAATCTGCAAGCACTTACCCCCGATTCCTTAGATACCGACAGGCTTGCTAACAGCTTGGATCGTA 0 13 33 0 +GTTCAACCAGTGGTATCAAAGTCGAGCACAGGGAATGGTAGCCGGCCCTGACCTTGTTGTTAGGACAGGACCCGGACCGTGCCCCTATCCT 0 13 33 0 +AAATGGGACAGCTCAGAGTACATGGGAGCATTAATTCATGCTTCACTGCCACTTTTGCGCATTTAGAAGACTACTTGGAGTTAGTCCCAGA 0 9 26 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGGATAAATCAATTCGATACAGCTACTACGAGAATCGTGATGTGTCTCTTCGAAGAGCACACT 30 30 30 0 +TCGCTAGTTTTAGCAACGCAGAGTACGTGGATCAAGCAATGTAGACCGGTAGCGCCCATCCGTGCGAACCTAATGGTGGTATCTCGCCCGA 0 7 30 0 +AGATAAACGCAGAGTACATGGTCCTTGGCGTAGGGTGCTTAGGCTCCCCAAAGTACGGCGATTCTTAGATATCTATGCTGTGCATTAGACA 0 11 21 0 +TTTCAAAGGTCTGGTGTCATCGCAGAGTCATGGGCGCTCTGCGTATAAAATTATAGAAAGGCTAAAAGTCACCCGCGAGCGCTAAGGCTAA 0 12 34 0 +TAGCAGCGGTATCAACACGTAGTACATGAGAACGCGCTAAAAGTGCATTAGCCAGAGACGTCATAAAGATTCTTAGGCTTTTGGGGATTTT 0 13 30 0 +GGAGCAGTGGTATCAACGCAGAGTACATGGGCTTAAGTCTGAGCTGTATCTTCTGGCTACGCTAGGCCGACAAGGCAGAGGATTGCGAAGC 31 27 31 0 +AGATAAGCAGTGGTATCAACGCAGAGTACATGCGCACGTTCCGCGAGGACCGAGCGCCTCACCGTCCCAGCAGATACAACAAAGAATAATC 34 27 34 0 +AATTAAGGCAGACCGCATGTTATAGGGAACATATTTCCTAACAGCACCTGTGCATTTGTGATTAGGGAAGCAGTTATATAACACAACTCTG 0 4 91 0 +CTTAGAAGCAGTGGTATCGACGCAGAGTACATGGGGTTCAAAACTAGATGATTCACGTCCCAGCCCGCCTGATCATCGACACGATGCTGGC 35 27 35 0 +TCAGCAGTGGTATCAACAGAAAGGACCTGGGAAAACTCGAATTCGGTCTATCAGGGGGTCGGTCTCGGACACCTTATAGCAATAGGACACG 0 13 31 0 +TTGTAAAGCAGTCGTATAAATGTGGAGTACATGGGTCCGCAAGAATAACGCCCATGGAACTGCTCGGGGGGTAATTGGGCGACGCGCTACC 0 15 35 0 +TCGGAAGCAGTGGTATAGACGCAGAGCCCACGGTTATCCGATACGTCACCCGTAAAATCTGTACACTCCCAGGGATTCGATTGCCGCTTCT 0 13 33 0 +CAGGCGGTGGTACCTAGGCAGAGTACATGGGAGACCTGGGGTTTATTGTTATACACTCCGTAGGCGGAGACCTGTAGTTCTTGCAGTGGAG 0 15 31 0 +TCCACAAGCAGTGGTATCAAAGCAGAGTACATGGGTCCCCTTCATCAGACCTGCCTCGGTGCCCCCGCTCAACCACGGATGCAAAATTCCC 35 27 35 0 +CGAAGCAGTGCTATCAACGTAGAGTACAAGGGGTCTTGATCATGAGACGCTTATAAGTCCCACCTGCCTTTGTACAAGGTATTCGGCACCA 0 21 32 0 +GGATGGAGTCGTATCAACGGCAGATTACAGCGGCCGATGTATCGTTTTTCGCTCCNATTTAAAGCAATTTATGACCTCGGAGTCGAACGGC 0 11 33 0 +TAAGCAGAGGCAGCAACGCAGAGCTCATGGATCCTCTGGTCCGCATCAAAAGGTTCGTCCGCTCGCGATGTTTAGCGCAACCAGGTCAAGG 0 13 30 0 +TTAACTATACGCCTAGTACATGGGAATACGCAGGGGCGTGATAACCGAACCACGACNAAACGGTCGTATATCGTTTCATGAGGACCCAATG 0 6 24 0 +ACGTAGTATTAACAACGCAGAGTTCATCGGGGCCAGCGCCGAGGTAGTTTAGGAGTGCGCCGGGCTCCATCTACCGACATATTTAAGCGTT 0 10 31 0 +CTAAAGAAGCGGTGTCAACTCAGTGTACATGGGAGAAACGATCAAGAGTCTACTGTGCAGATTACCTCAGGGCCGCTTCACGCGTTGATAC 0 15 33 0 +CCTAAGATCAGTCGTATCAATGAAGAGTACATTGGGTGCAATTGTAGGTTGTCCGGCAAATTCGAATTTTGGATCATTGAACCCGTGCAGA 0 15 36 0 +GAGCAATGGTATGAACGCAGCGCATATAGGCACGGGTATAGACGTGAGTTCTGAGGCCATGCTTAATACCAGTGGCCGAGGAGGATGAATG 0 9 30 0 +AAACGGTATCTCCGCAGAATACATGGGGACTGACCCCGCATCACAGTAAATGATCCTGGTGCGTTACGGCAGTTACACGATGGAGATCCAA 0 9 27 0 +AATTAACGCAGTAGTATCATCGCAGAGCAGATCGGAAAGATATTCCGCATACCGATTTGGTGGAGGGACATATCGACGCCGTGGTGGGCTT 0 13 35 0 +GGGAAGCGGTGGCATCAACACAGAGCACAAGGGAGGACTCGCTATATGGCAGAGAAACAGCACCTAGCGTTAGCAGCCTGGAGTCTAGCGG 0 15 33 0 +GCACTAAGCAGTGGTAGAAAAGCAGAGTACATGGGACAGGTGAACTTGACCAGAAACCGGGCCCCACACGTTCCCGGATCGCCCTGCCCAG 0 21 35 0 +TTTAACCAGTGGTATCAGCGCAGAGTACATGGGCTGTCCCATGAACACCCGATTCCAGTCGAAATGCCAGTCGCCATGCAGGAGTTGCGAG 33 24 33 0 +TTTAAGCAGTGGTATCAACGCAGAGTACATGGGACCATGGCTCCTCCTCCACGACTATTTTCGACGATCGTCTTATGCACCCGTCCAGGAG 33 30 33 0 +GCCGTGGTATCAACGCAGAGTACATGGTGATATAATAAGACATCCTTCACTCCAAGAGTATATTGACTCGCAAACTATTTCTCGCTTGTGG 29 23 29 0 +ACGAAGCCGTGGTACCAACACAAAGAACATGGGGTTGAAAAACACCTTACTAGCAGAAGCCTATTTAGGGCTCCCGGTCCTGGAATAAGAA 0 15 33 0 +AAGCAGTGGTATCAACCCAGACTAAGTGGGCAGCATACGTCGAGCACCATGTAAGGAGACCTTTGCCTGAGTAACAGACGGGAACGGTCAA 0 19 30 0 +TTAAGCAGTGGTATCAACGCAGAGTACATGGGCCTAGCACCTCTACTCATATCCCAGGGTAAGGTGATCAACTTGCCACGATTCGACGCTT 32 30 32 0 +ACCGAAGCAGTGGTATCCACGCAGAGTACATGGGGGGACTCGATTTTGCATTTATAGTGGAATCGTCCTTATAAGCGAGCTGCACCCTGCC 34 27 34 0 +ATGGCAAGCAGAGGTAACAACAGTGGGAGCTTGGAATCGACTCATAGGAGGTAGCTTTGCTATCGTCGGTTCTAACGTGCACCGTACCCGG 0 2 4 0 +GTTTGAAGCAGTGGTATCAACGTAGATTACATGGGACAATGACCATCCAAATACATTTTACAATTTCGCCCGAGAATTCCCGCATGGATCC 35 24 35 0 +CAGGGTAATGGTATAAACGAAGAGTACATGGGCTCTGCCCGGGTAAAACATCCTACCCGGCACTTTGGGTGGATTGCCCTCCATTCAGCAG 0 13 32 0 +GAGGCAGTGGGATCTACAATGCGTAAAAGGCTAGAAGGTTTCGACCAAACTTCGTCGGACTGTTTGGATTTCTAATGAGTCGAGACGACTG 0 3 11 0 +GCAAAAGCAGTGGTATCAATGCAGAGTACATGGGGGCGTCGAGAGGCGCTATTCTCCATACTCTAGCCCGCTGTCGAAATAAGTGCCCATC 34 27 34 0 +CTGGTATCAACGCAATAGGTCTTGCGGTGAATGGTATCATGAGCACAGGATCGATTGAAACCGCGCGTAGGTAACCGTGATTTAGGAAAAC 0 7 27 0 +GATCCAGCAGTGGTATCAACGCAGAGTACATGGGGGCAGGTCATTGATCCATACGAATTTACGCAAGTCTAAACGGTGGTTTTACGCTATG 34 27 34 0 +TTAAGGAGACGTATCACCGTAGAGTACAAGGGGATGGGTCTACTTAATCTTTGCGTTTTTAGACTCCAGGTCGTCCCCGACTTCCTCCGAA 0 12 32 0 +TTACACAGTGGCAGCAACGCAGAGGTACATGCGCAAGGTATCTAGTCCGACAACACTCTCCAACCCGTCAGGTACGCGAATGCCTAGGAGT 0 14 33 0 +CATTCCGTCGATATCGACGCAGAGGACATGGGTATGTGCTNCGTTCGTTAGGGCGTTCTTCCTTCAGCCACCTATAAACCAACAAGGGGAC 0 10 32 0 +TGTAAGCAGTGGTACCTACGCAGAATCCAGGGGCTCTTCGGCGGCGACGCCACCGATGAGCCAGCCCCTCGCAGCGTGCGCGGACAGGGCC 0 15 32 0 +ACGTGGTGGTATCAACTCAGTGTACAGGGGGCGGCCGGGGGTGGCCGGGACCAGAAAATTTCGGGCGGCCAGACGAACTTAGACGATCCAG 0 12 29 0 +CTTAAACCGTGGTATAAAGGCAGAATACCTGGGCTGTTGCCCATCGGTATCCAGACTGGAGGGATCCTTACACACAACTTGACGTCGGGCA 0 12 33 0 +GAAAGCAGTGGTATCAACCCAGAGTACATGGGAAAGACCCCACGGGTAGAAATGAGTATCGCGTGGCTAGTAGACTGCCGAGACCGCAGTG 32 27 32 0 +GTGCAAAGCAGTGGTATTACCGCAGAGGACATGGGGCACAAACGTAAACGCTGATGTGTCGGCACAGGGATTCGCAAGCGGCGGGAATGAT 0 21 35 0 +AGGAAGCAGTGGTATAAACACAGAGTACATGGGGCTCTCGAAACTGACACAACATTTTCTGGGTTCAACGGCACTCAAATGTGCGTACCAA 33 24 33 0 +GGCAGCCGTGGGTATCAACGCAGATTACATGGGTCTAAACCCTATCAAGCTATAATTTTGGCGATTGAGTTCGAATTCTGACAAGAGTAAC 0 19 33 0 +GTGGTATCAACTCAGAGTACATGGGACTAAAGGCCTATGCGCGCCCCGATACGATCGATTGTACAAGTCCCTGCGGATGGGTATAAGATGC 25 22 25 0 +CCAAGCAGTGGTATCAACACAGAGTTCCTGGGAAGCCACGCTACTCGGCACAAGCTATCCCAACCATCATTCGAGCTTCGTAGCATGCGCC 0 21 32 0 +ACGCTGTGGTATCAACGCAGAGTACATGGGTGCAGCACTTGCAAGTCGGGTCCGGGTCCTGGAATGAATCGGTACGGCGGTATTAAAGGTT 30 24 30 0 +GGGAAGAGGTTGTATGAAAGCGGAGTACAGTGCCGGGGCGACTCTTGGGACACAGCAATGGATCGGGCGGCTACGGCCTTCTTCCCGCAGG 0 7 32 0 +TCTGACAGCACTCGTATCAGCGCAGAGTATACGGGAGTCACAGTCCCCGTGGGTAACATGACTTAGGACTACGCCCCCTAAGAAACGTTGA 0 13 35 0 +AAAAGNATTGGTTCAACGCAGAGTACCTGGGAAGATAGCCCGGGACCCTGCTAGTAGCTTCCAGCAGGGATACCTATTGGTGGTATTTGGT 0 18 31 0 +AATAATCAGTGGTAGCCGCGCCGAGTACATCGGCGCGACTACGCGCAATATAGGATTTGTAAATAATTCCTTAATCTTGAGCTGCGCTATT 0 12 33 0 +GGCAGGCAGTGGTATCAACGCAGAGTACATGGGATGGACCAACCACCGCCTAAAGCCCTCATTATGTGGATCGTGTCTTAAGGACCGTACT 33 27 33 0 +GAAACTGTAGTATCAACGTCGCGTCTAANGGCCGTGGGCCGGGAAGTTTGATCTTGCGCTAAGAGCATAAGGTGGGTTTTTATCTATTAGT 0 2 31 0 +AGTCGTATCTACGCAGCGTCTGTGGGAACGCTGTGACTAGCTGGGACTATGACTCTCGGTATAATCAAAGCCTGTAGATGCGCAGCCATTT 0 9 25 0 +CGAAAAGCAGCGGTATCAACGCCGGGAACATGGGCGCAACATTCACACGGTATTTTGAGACTGCAAAGTAGCAGCCGCAGGTATGGCACTT 0 18 34 0 +AGAGCAGTGGCGTCAAGGCAGACTTAGTCCGGATAGGTACAGTATAGTTATGCAGAATTTCCTCTGAGCATCGACTTGAACGCGCTTACCC 0 3 32 0 +CAAGCAGTTGTAACAACGACGAGTACATGGGGTAGGGGAAGTGCGATCCTTTCGCTGCATCAGTTTTTCATACTACATATCAATCGGTATC 0 19 31 0 +TCACCAGTGCTATTAACGCAGATTCCATGGGCAGTCCAGTCTAGGCGTAGGGCCTTGAGGATAGGCGCATATTAAGCGAGCTGGGATAAGG 0 12 31 0 +ACAAACAAGTGTTATCAATGGAGAGTACATGGGCTCAACGGATACTATATTTATATGTAGCTTATAGGACACCGGAAGTGCCTACCTGATC 0 16 33 0 +GAAAAAGCAGTGATATCGACGCAGAGAACATCGACTGTACTTAGCCTGATCTCCCCCACTTGTTGCTAGTGTATCAATCGATTTCGCACAA 0 15 33 0 +AGGAAGAGGTGGTATTCACGTAGAGCAGGTGGTCGGCTTTGGCGTAGGAACTGTGCACGTATGCTACCTAAGGCAATTTGCGTCCATACTC 0 6 31 0 +CGTAAAAGCAGTGCTATCAACGCACAGTACGTGGGTCACAGCAAAATGGGTACCATAAATTATCCTGATAGCCTCTACCAGAGGCCTCGAA 0 21 35 0 +TTGTAAAGCTGTGGCACCGACGCAGAGTATATAGGCGCCTGCTCCTTACTCCTTTAATTCATGTTGTGATCGTGAAGCCTTCTGCACCGAA 0 12 35 0 +TGTGGAAGCAGGGGTATCAACGCAGAGTACTTAGGCTTGGCACCGTTAGTGGCCGAGGATCAATCTCCAAGGATTGCGCTACGGAAATTCC 0 21 35 0 +AATCAGCGGATCAACGCAGAGCACTTTGGTACTGACGATGAAAGCGCGACGGCTAAGATATTGTCGAACTCTAGCGACCATGCGTCTTACG 0 12 29 0 +ACCAAGCTGTGGTATCAACGCAGAGTACATGGGGAACGCTAAGACCCTAAGGACACAACCAGACCACCCGTCTCCGTAAGGGAGGTGACTG 33 27 33 0 +CAACCAGTGGTATCAGCGCCGCCTACGTTGGGCGTAAGAGTGGAGTACGAACCAGAGGTTAACTTCCGTGCCAAGGCATCGGGTAGATAGT 0 10 32 0 +TAAGCAGTGGTATCTACGCAGAGTACATGGGCCCGACGTGAATTTGGTCCCCTATCCTTGCCTGCCGGGAAAGCAAAGCCGACGATGATAT 31 27 31 0 +AAGCTCTGGTATCTACGCGGAGTCCATGGAGCTATGGTAAAAAGCGTTCTCTCAGGTCCACAATGAGTTCGGATACAACCCGGCACCTGAA 0 13 31 0 +GAAAGCAGTGGTACCACCGCAGAGTCCATGGGGAATCATGGGTCGCGTCCGACACGAGGACCGTCAGTGCCCGCTGCGACTCGAGCACGAG 0 21 32 0 +AAGCAGTGGTATCAACGCAGAATACATGGGGGCCGGACGCATTCGGTGGCTAGTTGTGCAGTACCCTGACGTGTAAGCACTTTCTAGTGTA 30 27 30 0 +CCAGCCGGTGGTATGAGCGCAGACCACATGGGATGTCTCAGTTGGAGGACTGCCTGGGAATGACAGGGTTGGGATTAAGCCTAGACCTGTC 0 10 32 0 +ATGTAGGCAGTGGTATCTAAGCCTAGTACATGCGTTTGTGGATATACTAGGTGCCTCCCGGGTTGGGATCCAGGATCCCTAAGAAGGTACG 0 13 34 0 +TCCCAGTTGTCTCAAGGCGGAGTACATGGCCGTTTCCGGTCTGTACCTGAAGAGGGGGATCGCCCCCCATACAAATCGCTAATTGATAGAA 0 6 29 0 +TTGGGGTGCTATCAGCGGACGGTACATGGGATGACTAGGAATGGATGACCTGATCTCGCGCAGTCTGAGGAAAGCCTCCCAAGGTGCAAAT 0 4 30 0 +TANAGCAGTGGTATCAACGCAGAGTAGATGGGTGCTATTTGCGCACCGGATCTAGCCTGGTTGAGCCCATTTGCAAATGGGAAGCTAGTTC 32 25 32 0 +AAACAAAGCAGAGGTGTAAACGCAGAGTACATTGGCAATGAAGGGCGTTATCAGCTTACGCCGGAGTTAGCAATTCCGTACTTATGATACT 0 18 35 0 +TCATAAGCAGTGGTATCAACGCAGAGTACATGGGCATTGCCGTTGAGACCTTAATTTGGTGAAAATTAAACCTAGTTGGGTCACGCTTTCT 34 30 34 0 +AAGCAGTGGCATCAACGCAGAGTACATAGTAAGAGGGCTGGCATTAACACGTACGGTAACGACCCCTGATCTACATGGCCAGCCTGGTGAC 29 21 29 0 +TACTATCAACGCAGAGTACATGGGGGTTTCAAAATCCCTGGCACACTGGGACTCTGCTCCCTGGCGCTCGGTCGAGTCGGGACGTGAGATC 0 18 24 0 +GAAAAAGCGGTGGAGTCAACGCTAAGTATATGGGCTAAACGACTACAGCCATAGTCATATCCTGTCCTCGCTAAGCCCAGGTTTAGATGGT 0 14 34 0 +CAAGCAGTGGTATGAACGCAGAGTACATGGGCGCGTTTCTTGGGGAAAACACAAAATTACGTAACGCAGGTATTCGACGTGCATGTTCTGC 31 27 31 0 +CAGCAGTCGTATCAACGTAAAGAACATGGCTAAAAGAGCCATCCCGACTTTGGCGTCCCCAGAAACCCAGGCATCTGAGGCTTATGCTAAC 0 12 29 0 +CGCAGTCATTGGGATCGACGCAGGGCACAAAGGTGAGCCTGAAGTGGATGCAAAAAATGTACATGAGATTGGAGGGCTCAGCATGCAGAAT 0 4 13 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGATGATACGAGTGACTTACATCATTCCTCTCCATCAGCGGCGTCACCCAAAACCTTGCCAAA 30 30 30 0 +CCACAAAGAAGTGGTACTAATCAGAGTACATGGGGCATCGAGAAAACCGGATCCGCAATAAACCAAATGTGTCAAAGCACATCTCGTGCTT 0 16 34 0 +GTAGCCGGGGTATCAACGCAGAGTACTTGGAGTTTGACTTCGGGCCACCGGTAGTGATAGCCAACTCATCACGTTTCAATTTTGCTATGGA 0 16 32 0 +TGCCAAGCAGTGGTATNAACGTTGAGTACTTGGGTGGAGCCAAAGATCACAAATTGGGGCCTTTAGGGGCCCCTACCGTGCGCAATGCGGG 0 18 34 0 +AAGCGGTGGTCGCAACGCAGAATACCTGCGGGTTTATTATATGATGGGCAGGTGCACAGGAGATCGCACCGGACCTCCAGAAGCACTAGAG 0 13 31 0 +GAAAAGCATTCGAATTAACGCTGATTACAACGGTTGACAGCTGTCCAGAACGTATATTGGCGTTGGCGGACAGACTGCGAGTGACACTTCC 0 6 33 0 +AATCTGCGGTACCAAAGTATAGTTCATGGGCCTCGCGAGGTATTCTAAGCACCAAGGCACAGCCTGGAAACGAATATGAAGATGCGAAACG 0 6 30 0 +CGAAACAGTGGAAATCACCCAGCGTAAATGGGTTTGAGCTGTCCACTATACCACTAGCCCTTACTACATGAATCGGAGGACTATCGATTGC 0 10 32 0 +CCGTTGAGAAGGTGTATCAACGCAGAGTCTATGGGGAGGAAGATAACAGTTCTCAAGTTCCTAGGATACACGGGAGTTCTTGGTACTTACG 0 16 35 0 +AAGCAGTGGTATCCACGCAGAGTACATGTGTCGCTACCAGGATGGGGGAGGGGTGCTCAGAGGTGATGAGTCCACCAGTATTGATCCTGTC 30 24 30 0 +CTGAGCTATATTATCAACGGAGAGTCCAGATGTGCAGAAGTGCATTCGTAAATCCGCAAAGAACTTCGTTATAACTGCCTGAATGCCACGT 0 3 34 0 +CCTTGAGCAGTGCAACCAACTCAGAGTAAATGGCAGGTAGCGATATTAGAAGGTGCCCCTTAATCAGCCAGTGAGGCTACTTGAGGAGTCC 0 9 33 0 +GAGGTAGCATCACCGCAGAGTACGTTGGGGGCCTAGAAAGATCTTTTAATGTGATACATTGGCCTCAGATAATTCCGGATTCTCACTGAGT 0 9 29 0 +TGAAGCAGCGGTGTCTACGCCAGAGTACATGGGTAAAATACCAGTCCTGACAAATCCGTGCGGCCAGAATTGAAACCTGTAGTCAAAGAAT 0 19 33 0 +TCGCAGCAGTGGTATCGACGCCGAGTACCTTGGAAGAGACAATCACGTGACTATTAGACGTCAGTGTTAGGTTTATCCATGGTGACGAGTG 0 15 33 0 +TCTATCAGATGTAATGACGCTGAAGTCAAGGGATTATAACGCAATACTAATCGAGCTCACACGCGCCATAGGCATACACCAAGAATAAGGT 0 1 55 0 +CGGAAGCTTTGGTATCAACGCAGAGTACATGGGCATGAAACTCACCACTATCGTAGCCGTCAATGCCGTGCACAAACCGTATCGGCCACAT 33 24 33 0 +GTTCAGTGGTTTCAAGGCAGAGGACATTGGCTAAGTAGGCGTCTGAACCATCATATTACTGCTCGGTACTAGAGTGCGGCTAAAAAGAGGA 0 12 30 0 +TTAAGCAATGGTATCAACGCGGGTACATGGGGGGGTGGTTACGCCGGCCTTGTGAATGTCACTCCAACGTGAGCTCAGCACACGATTTGGT 0 21 31 0 +AGGACATGCAGTGGTTTGATCGCAGAGTACATGGGTTGTTGTAGTGTGGGGACATCACCGAATTAGCTCAAGATCTAAGCCGTCTGTGCCT 0 18 35 0 +CCCTTGGTATCAACGCAGAATACATGCGGGCGTTGACTACTAGTACCTAAACACCATTAGTTACGAAGGAAACAGCATGTTTATTCATATC 0 14 29 0 +CAAGCATGGTATCAACGCAGAGTACATGAGGCAAGATCACCATCGGGCAGGGCTGAGTACAGACTGTAATATCACAAGACCCCTCACGTTC 31 25 31 0 +TCAGAAGGCGTGGTATATACCCGGCGTAGAGTGGTATATCTACGTCCTTCCTAGTTTTCATCATCATTAGGAAATCGAACGGAGTGTCCGA 0 3 34 0 +AAAGCAGTGGTATCAACGCAGAGTACATGGAGTTGTCGAAGACCCGTTATAGTTGAAGTGTGTAACCGCTATAGGTCTAACTATTGTGCTA 32 28 32 0 +AAGCAGTGGTATCAACGCAGAGTACAATGGGGTGAAATCGCTGAATCAGTAGCGCTACTCCAGTTGACTCGTGCACCGGCTCGTGCGAGGA 31 28 31 0 +TCAGCGGTGGTATTTCCACCGAGTACATGGGATTGAGCAGGTATGGTTTCTCCATGTTGTACCCGTGATGAAGAGCGACGTCAACACACGC 0 11 31 0 +CGATAGCAGTGGCCTTCACGCAGAGTACATGGCTTCAACGCGAGTTGACCCGTCACTCAGATTACATATGGGGGGTGAAAGTCCTGGTACA 0 15 32 0 +CAAGCAGGGGAATCAGCGCAGATTATAGTGGAACAGAACCCCGACACGACTTGTCCTAATATTCAGTGGAACCTTCGACCTAGGCCGGCCT 0 10 31 0 +AAAGAAGAAGTGGTATCTCACGCAGAGTACATGGGGCATTCCGAGGACGGCTTAATCTATTCTCAAGAACTGCACTTACTGGCAAACAATA 35 22 35 0 +AAAGCAGTGTTAACAACGCAGAGTACATGGGTCTAGATACGCGAGCTCAATTGACTGTAAGGAAAGACTCACGGAATACTCTCGGGTTTTG 31 24 31 0 +TCTCAGTATTGGGAACGCAGATTACATGAGGAGGGTCTTGGCCACAACATCTAAGGCTAGCAGGCTGTGGTTCATACATGGGTGAGAGACT 0 4 31 0 +GAGCAGTGGGATCATCGCAGACTACCTGAGTGGCCTAGCATTGGATTCGACGCAGCAGCCGGTGCAGCTGCAGCAGATGGTTATTAATTAC 0 12 30 0 +CTTAAAAGCAGTGGTATCAACGCAGAGTACATGGGACATTGGCTGTGCGACTCTCATAACTCCCACGACGCATTCACCCGCTGGACGGTCA 35 30 35 0 +CCATAAGCACTGGTATCAACGCGGACGAATCGGGCGCGCGACGAGGTGTATGATAGCCCGCTCTCCGCTTTAGTTGTGGAAATTCAAGCTC 0 14 34 0 +GTGTAATAGTACTATCAAGGCGGAGTGCAGGGGCTAACAAAGTTCTCTACACGGACGGTAGTAGCAGTCAGAACACCTGAATGAGGGAGAT 0 6 32 0 +CAAGNAGTTGTATAAACGCCCAATCCATACGAATGAGCCCCCAGGCGCTTAACGACCTATTCCTCACCAAGACGATTAGGGATAGTGCAGC 0 3 31 0 +CCCCATAGCAGTGGTATCAACGCNGAGTACATGGGCGGCTCAGTGAGATCCGGCAATACCTGTGTTATGGGCAAGTAAACGTATTTCACCG 35 25 35 0 +GTCAACTCAGTGGTATCAGCGCCTAGTACCTGGGCAGTAAGTGCATGTCAGATCGTCCTCAAGCCGCTCTATCTCAATTACACCCTAAGCT 0 13 34 0 +CAAGCAGTAGTCCAACGCAGAGTACAGGTGCAGGCGGAATTATGGACTCTCACGATCGTTGGGGTCGATGGTANGGAAAGGTGTACACCAG 0 16 30 0 +TGCAGTGGTATCAACGCAGACTACATGTGAATTAAACTTTCACTGATCTCAACTATGGGGAACCACATCACGGGTATATCTAACCATTAAG 0 20 29 0 +CCAGCAGTGGTATCAACGCAAAGTACATGGGGCAGCCATCTCATGGAACTGCTGATGTTGTACATTCGCCTACCGGTCCAATTTCAACGCT 31 24 31 0 +GCGAAGCAGTGGAATCGACACAGCGAGCATGAGTCATTTATGGCACAACTCACGACCAGTTGCAGATGTACTTTCCTCTACGTCGCGACTC 0 10 33 0 +AAGCAGTGGTATCAACGCAGAGTATACGGGTCCTCGCAGGATAACCGTATGTGATTACTCGGCCACCAAATACACAGATTAAACGGTTTAA 30 24 30 0 +GTAAAAGCAGTGGGACCCAACGTCGACTACATGGGTGTATACCACGACTCTGTGTACCACTACAGTAAGGGCCTACATTCGCAGGCTTTAC 0 14 35 0 +GAGCATTGGTAGCAACCCAGAGTACAAGAAGCTTCGGGATTCATTTCAGAGTGCAAAGCAACCTACGTGCCGAGTTTCACTGGTCCTGCAG 0 10 31 0 +AAAGCAGTGGTATCAACGCATAGTTCATGGGGCTATAATACCGACCTGCAGTTTCGTATCACCCCGTTTGGTACCAGCTATCCTTCCCCGC 31 24 31 0 +CATATGCAGTGGTTTCAACGCTGAGTATATGGGCTGTACAGGAGAAATAGGCTTTTGTCGCCAGTTTTCGCCGTTTGGAAAACGGCATCCC 0 18 33 0 +AAGCAGTGGTATCAGCGCAGAGTACATGGGCATGTTCGATCGCCTCCAATCGGGAATTACCGCGTCACCCCGATCATATCCCCCCACGGAT 30 27 30 0 +TGTATCAACGCAGAGTACATGGGCTCCCGCGTTGTACTTACGCCAGTGGCGGGAACACCGACAATCATCCGAAGCCTTAGTGGGATCGGCC 23 21 23 0 +GCCGTAGCAGGGGTATCAACGCAGAGTACATTGGGCTTTGGCCTTAATTGATCTAAGTCTCTACCTCCCTGTTTCGTACACATGGGTTATA 35 22 35 0 +ATCAAGCAGTGGTGTCAACGCAGACTACATGGGTCAACGTGTGGCCGTAAGAAGCCGCACACCAGTGATAATTTATGTGAAGTACGTGGAT 33 24 33 0 +ATTACGGTATCAACGCAGGGTTCATAGCTCAATCTAAGACTCATTATTTTTTCCCTCAGGCCAGGGGCGTGGGCAGAACTCTGTTGCCTCC 0 7 27 0 +CAAGCAGTGGTATCAACGCAGAGTACATGGTTAACTACTCCGTGACATCGAGGCGCCCAAAATACCGCCCTCTTTTCGTCACTCTAAACCA 30 27 30 0 +CGTTTCAACGCAAAGTACCTGTGGGCGACAATACGGTAGGCTACAACCTTTCACAAAAGCCTCGAGTGAGAATGGGTGCGTAAGCTTGCTT 0 9 24 0 +GTTTCAACGCAGAGTACATGGGGACGAAACACAATCTTGCACGCACTCTCCTGGCACGACATCCATGCAGGCGATTAGGCATCACCGCATC 0 19 22 0 +CGAGGCAATGAGATCAACGTAGAATACATGATAGTACGCTGCGCAGAAACACATGAAAAAGCGCGGTTGAAAAGGCACGCTCGCTGTATCT 0 7 30 0 +ACGAGCGATATCAACGCAGAGTACATGGGTCCTATCCGAAGATAAACGGAGATGGAACCAAGACGGTCGATCGCGTAGCGACGCCGCTATC 0 18 29 0 +AAAGCAGTGGCATCAACGCAGACTAGATGAGAACCTCGTGCCAAGATGGCCCCACTATTAAACGCTCAATAGCTACACCAGAAGAGTCAGA 0 18 31 0 +AATCAGTGGTATGAAGGCAGAGTACATGGGATTTGTTCTATCCTCACATGGAGAGATCACGGGGTTGGAAGCTGCTCGCTGCTATGCATCC 30 21 30 0 +AGGAAGCAGTGGCATCAACGCTGGGGCCGTGGGGTGTTCCGAGGTCTACCGCTGTCCCTGGAGTGCTGGGAAATAGTGCACTGCCTGTAAG 0 12 33 0 +TACGGAGAGGTTCAAACGCCGGGTCCNTGGGAATGGAGCACGCTCTCATGAAGCTAACAACGGAAATTCTCGACCTTGCGATCTTCCTGGA 0 4 31 0 +GGGCAGCGGTATCAACTCAGAGCACATGGTCAAACGAGGCTACAAGCTGTGCGGCACTAGGTCTCTATTGCTGCGATCTAGCTATATCTGC 0 12 29 0 +GGCCCAAGCAGTGGTATCAACACATAGTAAATGGGCTACTGTAACTTCCCGTGAGGAAGACTTCTCAGTATAAGCGAGCTTGGAATTGCAA 0 21 35 0 +CAGCAGCGGTATACACGCAGAGTACATGGTAACTAATCCCACGAAACTCGGATGTACGTCAGCGGTGCTGGTAATCAGGGGCCATCTTAGA 0 16 29 0 +TTGCAGTGGTATCAACGCAGATTACATGGGCATGGGAGGTGGGGAACTCGCTACCTTAGCCGATGTTCCGAAGCTGCATAAGAGGAATCTC 30 21 30 0 +GTTATCCGGTGGTATCAACGCAGAGAACCTCTATGATCGGTGGCTTCCGGTCACAGTCTAGGGCGTCTCAGCCAAACGTAACCTACACTGA 0 6 30 0 +AGGCTCTCAACGCAGAGTACAGGAGTTATCTTAGACCAGACAGGAACCGAAGAATTAGAGAGTCTAATGTCAGACCATCCACCTAGCTCTT 0 12 25 0 +AAGCAGTGGTATCAACGCAGAGTACACGGGTCCCGTACACAGGATTGTATTGTAACTTTCCACGCTATTCTCCAGTACGAACTAGTAACGG 30 27 30 0 +AAGGATTGCGATAAACGCGCGGTAAATGGGCAGAGCGCGACGATCCTAGTCAGCGAGTAAGGGACCAACCCTGCTATCACCCACCAATTAT 0 5 30 0 +TTAAGCAGCGGTATCAACTCAGAGTACATGAGGTGTAGGTTCGTCGCTGGGTACATATCCTTAGACACTTGTATCTCCGTAATGAGATCAG 33 22 33 0 +TATAGACCATTGGAATCAACGAATAATACATGGGGTGGAATCAACATGCGCGAACGTTGGAAACTGCTTCCTTGTGGGAGTCGTCTGACCA 0 10 34 0 +GCGAATGCAGCGGTATCAACGCACAGTGCATGGGATTCACGAGCGTTCGATCGCTGGGTCTCAGTGGGANATTCTTCTGCCCGCGTAAATG 0 19 34 0 +TCAGTGGTATCAACGCAGAGTACATGGGGTAGCTGCTGCCACGCAGGAACGCGCGTAAACGATCTATACAAAGTACTCCCTGACCAGTCCA 28 25 28 0 +ATGAATCAGTGGTAGCAATGCAGAATACATGCTTGGATCTAATTTCGAGTAGGCACCCCAAATTCTACTTTACACCGATCCAGAAGTGGAT 0 12 31 0 +GCTATGCTGTGGATTCAACGAATGAGAGCATGGGTAGTCCGGTAGCCCAATAAGAGTTAAGAACACCAAAACTAGACAGTGTGCATTGAAG 0 9 34 0 +TGAAGCATGGTATCAACCCAGTGGACATGCGCGTGGTGCGTTCTCAGGAGTTTGGCAGACTGCTACGACAGTGAAAGAGGAATTTGCCTTG 0 15 31 0 +AGGTATTGGTATCAACGCAGTGTGGATGGGGTTGGAACTGTCCTCCGCTCGAAGCTGATCTACGCTTCGATGAAAGCAGCGGGCTGGGGCT 0 12 30 0 +GCCCAAGCAGTTGTATAAATGCAGAGTGCATGCGCTAGCGGTGCAGTTCTAATCTTGCGCTTATGGGCCTTACCGCTAGCCTTGTTTCCGC 0 15 34 0 +GGAAGCAGTGGTATAGACGCAGAGAATATGGGTGCTAAAAACCGACCCGTGCGGTGAACACAAAGACTGAAGGAGGATCCTTTTGTCCTTG 0 19 32 0 +TTAAAAGCTGTGTATTAACGCAGGGTACGTGGTCCAGTCTNGCTACTCACCATACTGCGATAAGTACATCGTGGCGAGACAGAGCTCGAAA 0 12 32 0 +AAGCATTGGTATCAGCGCAGAGTACATGGGATTTTCGTAGTGATGGCAAAGCCGTAGGAAGTCCATATCAGCTCATGGCACAACGCAATAT 30 24 30 0 +TGTTGTTGGGCTGGTGTCGTCGCAGAGTACATGGGTCCATGGCACTCTCGTAACGGATAGTGATAACATCTATAACCTCGGGGCTGTGTCA 0 9 35 0 +GGCGTAGCAAGTCACTGTATATGGGGATTTAATCCTGGACAAGGGTTTGAAGATACAGTCCCTTATCTACCAATCGCACAACTACCGTCTT 0 3 25 0 +CTACTAAAAAGTGGTTTCGACGCAGAGTACGTGGGCCCGCTTCTCATTTTAGGCTGAGGTCGCACCAAATCAACAGGGTCCCTATCGCTGA 0 15 35 0 +GTAGCAGCGGTATCAACGAGGAGTATATGAGGCTTGAGCTCGGCTAGTTCTCAAATAACGTTTGGTTTGCCCGACGGTTGTCAAGGTAGGG 0 14 32 0 +TAGGCAGAGGTTTCAACGTAGAGCACATTCGCGTAAGCAGCATTGTCAGGGCGGGTGAATGCGGTGTTCGCCATGGCCCTCTTTTCCGGTG 0 9 31 0 +GAAGAAGGGGTATCAACGCAGAGTACAATGGGAGCATTCTAGCATCAGAGATATGTGCCACGGCACGTAAGGGACCTGGTGATCTAGCAAT 32 22 32 0 +CATAAGCTGAGAGTACATGGGCCGTATNGATCCGGCGGCAAACGAGCAATAGTCCTAGTAGCGAATCAACATTTACCGGCATGATGCTATG 0 9 21 0 +TCGCATGCAGTGGTATCAACGCAGAGTACATGGGTCGTTGTTTCCGGGTGGGGGTTGGGAGTTCACCGCTGTCTGAAACAATTGAGGTATC 34 27 34 0 +CCACGCAGCTGTATCAACGCAGGGTACACGAGCACTGCACAGTTCCTTCAAGCGCTTTTCTGGAGACGGTGGAGGCGTAATATTTTTTGAA 0 13 32 0 +TCAACGAGTGGAATCAACTCAGAGTACATCGGACTTCGCGTGAGCAAGACGGCCCCGCCCACATGCGATCGCGTTCGTGTATTCGAGGTGC 0 16 32 0 +CTAAGCGGGGATAATTAGGCAGAGTCCATAGGTATCTCACCTAGTACTTCGCCAGATAGAGGCAGTGAGGCAGCTGACGGACAAAAACGAA 0 5 32 0 +CCAAGCAGTGGTCACAACGCTGAGCAGACGGCGGTTTTATTACAACTTTGCTCACGGCTGGAAGGAGAGCACACTCGCCGCGAAGTAATTT 0 11 33 0 +CGAAGTGGTATCAACGCACACTACATGGGTGATACAACAGGTAGGATTACCGGAACGAGGGTACCGAGTCGTTTCGGAAGGCGAGATTTAC 0 17 29 0 +GAAAAGGAGTCTTATCAACGCAGACTCCAACCCAGTCACCGACCCATAACCGAAGTATATCTGCGTTCCGTTCGAATTTCATTTTAAATCT 0 3 29 0 +AGTGGTATCAACGCNGAGTACATGGGCGGGAGCGGACTGCGTCTTATGTTGTTCTAAGTGCAGAGAACCGATCACTCTGATCGCTACACTC 26 23 26 0 +CCGTAGCAGTGGTCTCAACCCAGAGTATAAGGGATCTACAAACGTTAAGCGGAGGACCGTGGAGTGCTGTTCAACTTGTAGCGTAAGAGCA 0 15 33 0 +TCAAAGCAGTAGTATCCTCGCACAGTACTAGGACGCAGATCCCGCGGTGGATTCAGCGTGTGGGAGGACAACAACATGCTATCTTATAACT 0 12 32 0 +AGTCAAGTAGCGGTATCTATGCAAAGTACAGCGGCGCCGGAGACACAAATCGATATAAGCCTTTTTATAGTAAGCTAGTTTAGGGGTAACC 0 10 34 0 +GCAAGCAGTGGTATCAACGCAGAGTACATGGGATCCGATGGAGAAGTACGGTCTCATCCAATTAACGATAGATCATCAGAAAAATTCGCCC 32 30 32 0 +AAGCAGTGGTGTCAACGCNGAGTACATTGGGGGTGAAGTAGCCCATCCAGGACGGATTCATTAAACTTTTTTTATGGATACGTCTCGCTTA 31 22 31 0 +CGTTAATCAGTGGTATAAACGCAGAGGAAATGGGCTACTAGTCAGACGTCGACGCACCGAAAACAACCAAAATTGCGAGATGATCTTCAGT 0 18 34 0 +AGCAAACAATGGTATCACCTCAGTGTTCATTGCGGACCTATAGTGGACAACGTACGCCAATTCAACTGCACTTGTCCGGGGTGCGCTAAAT 0 8 35 0 +AAGCAGTGGTGTCAACGCAGAGTACATGGGCATATATATGGGCGCGGTGGACCGCATGAGCCATGTATGGACCTCCCTATTGTATGCCTCC 30 27 30 0 +CCGTCAATCAGTGGTATCAACGCAGAGTACATGGGACTCACCTTGGCGTGGCATTAGGCTCAGCGATGGATGACGGTTTTGTGGAGGCAGA 35 27 35 0 +GCCCTCAGCAGTGGTGTCAACGCAGAGTACATGGGTTCGATTCATCCAAAATCTGATTTCTATACCGGGTGAACTGCCTATAACTTGGGTA 35 24 35 0 +GAAAAAGCCGGGGTATCAACGCATTATATCTGGGCCCTCACCACAGCAGATGCCATATCCGAAGCTAGACATGTGTTTTCAACGTAGTTGT 0 11 34 0 +AAAAGCAACAGTATCAAGGGCGAGTACATGGGGTGTACGAGTTGGGATCATCGCCCGATATAAATATCTGATTCGAATTGGTGGTTACCGC 0 13 32 0 +AGCGCAGTGAGATCACCGCAGGGTACAGGGAGAGCACCCTGCTCTAACACGAATGAGTGCGTCTGTTACCGCCGAGAAATCTTTGGGTGTC 0 11 30 0 +TTATGCAGAGGTACCAGCGCAGACTACGTGGGCTCTGGATACTGTTCTGCGGCATTAGTACAGTAATGTAGAAGCAGGCTTATCATGTATG 0 12 32 0 +CAAGCAGGAGGATCAAGCAAAGTGTAGATGGAGGAGTAGTCTACGTGTAAAAGCTCAGATCCCGAACCGAATTATAATTTGCCACAGCTTA 0 7 33 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGGACAGTACGGGTTAATTCTCTATTGAACCATTTTGAGACCTAAGGCATACTCGTACGCCAC 30 30 30 0 +GCTGCACGCAGTGGTATCAACGAAGAGTGCATGGGTCGCTTCCCTCCCGCGGTATTCAGCGTGAAGACGGAACCCATGACACGATTTATGA 0 21 35 0 +ACAAAATCACTGGTATCAAACGCAGAGTACTTGGCTCGCCTCAGGGCCTGCAANCTATACAGCGTAATGTGGACGCCGAGTAGTTTTGGAC 0 16 34 0 +TAAAAGCAGGGGTAACAACTCAGAGACCATGGGCGGCCTGCCTAACACCGTATGGGCTCGGGCCGACGAAAATACGACTACTTTCACAACT 0 16 33 0 +GTGAATCAGTGGTATCAACGCAGATTATATGGAATACGATACGCCCCAGAGACTAAGTCTATAACGAAGGGCCCTCCCACGTACGGCGACT 0 18 32 0 +GTAAGCAGTGGTATCAACTCAGAGTACATGGGACATGTGTCAGCCCGGCGGACGGTTGTAAGAACCTTCACACTAATCAGTTTCCGCATAT 32 27 32 0 +GAAAGCACTGGTATCCCCGCAGATTACATGGGGAGACAAAAAATCAGCACATACTGGTTGCTTGATGCAAATAGCGTCCTAAACCTGTCGG 0 18 32 0 +TGACTAGGCAGCGGTATCGACGCCTAGTACATGGATGGACCTCCAGGAACCAGTAGCTTACTAGTCCAAACACGCGCCTTCGCCACCCAAC 0 12 34 0 +TTTGAAGCAGTGGTATCAACGCAGAGTCCATGGAAGACTCAAGGCCGGCCAACACCCACTGTCAGCAGTTTTCGTGCGACAGAAGAACGCA 33 24 33 0 +ACCCAAAGCAGTGGTATCAACGCAGAGTAGATGTGGACTCTCGGTGAGCGTATATGAGTTGTGAAATGTAGAGTTCCGTAGTTACTCTTCT 36 25 36 0 +AGATGAAGCAGTGGTATCAACGCAGAGTGCAGGGGGCATAAAAAGCGCCACGTCAGCGACAGGTGGAACATGGGCGGTGTGGATCCGCTCA 34 24 34 0 +CAGCAGTGGTATCAACGCAGAGTACATGGGAAACTTGTAGGAACGTTTCATTTTAGGGTCGCGCAGATGACTGCATCCTCTTCGGAGCCGC 30 27 30 0 +CGAGAAGCAGTGGTATCAATGTAGAGTACATGGGGCCATGGAACAAAGCGCCCTTACCGAACACGTGCGCGTATGACGTCTAGACGGTTTC 34 24 34 0 +CGGAAACCAGTGGATTGAACGCAGCGTACATGCGGCTAAGTGAACCCAAGCGCTATCGACACTAAAGCACCTTGTACGGTTTNGAGGTCTA 0 14 35 0 +TAAGCAGTGGTATCAACGCAGAGTACATGGGCATCCAGTAAAAATATAGGAGACCCTTGGGCAAGTAGTCTAGTCACAGACAAGTCTGAGG 31 30 31 0 +AAAGCAGTGGTATCAACGCAGAGTACATGGGTATGCCTGATAGTCTTACCGTACGGTTATTCCGTTCGCTCGTAGTCGAACTGACTTCAAG 31 30 31 0 +AACTCACGGGTATCTAACGCTGTGCACATGGGTAGGGAACATGGGTTTGGGCGCATACAAAAGGCGAAACACTAGTTGTCTTGACTAAAGA 0 9 32 0 +CATCTAAGCAGTTGTATCAACGCAGAGTACATGGGGTAGAAGCGGCTCTGTGGTGCCTACGCCCTCCTAGAACGGCACGGAGTTTTCGACT 35 27 35 0 +TTAAGAATCAACGCTGCGTACTAGGGCCAACACAGTTCAGGAACCTACTAGCTCGCCTCAACAGCCGGAATGGGGAAGGTGGGCAANACAT 0 3 26 0 +GATAGAAGCAGCATTATCAACGTAGAGTACTTGGGACTCAAGACGTTAACCAGATTAGGCCTTATACCAGGTCTGCTATAAGAAACCAGAC 0 15 35 0 +GAAGCAGTGGTATCAACGCAGAGTACATGCGCCGACCTAGTGTACGGCTTCTATAGGTCATGGGCCGCCATACGTAGACGATATCCCATGG 31 27 31 0 +ATAAAGCAGTGGTATCAACGCAGAGTACATGGGGCTGTAAGTCCTACCCTACATTTTGTTATAATATCTTTGAAGTAATATGAAAGACTCG 33 30 33 0 +GAAGCTAGTGGTATCAACGCAGAGTACATGGGCTCAGCATCTCCAAGCAGTAGCGCAGGCGCATATGATGGAAAAGTCAGGCATCACGATA 32 28 32 0 +AAGCAGTGGTACCAACGCATAGTATGTCGGAGGGGAACTAACGTACCCGACTGCTAAACGTCGCGAGGTGAATTGACGGGTACTGAAGCCA 0 15 30 0 +CCAAGCAGTGGTATCAACGCAGAGTACACGGGTGGCCGAGCGCCTCTCGTCAGCCGCTTGGCGATCACCCGAGGCATCATTTTCTTTTCAA 32 27 32 0 +CTGAAGCAGTGCGTGCCAGCGCAGTTTAGTCGGGATATTTCGACTACTGGACGGCCGTGGGGTTGCCATTCCTAGCCCGGCCTATAGTCCT 0 5 34 0 +TTAAGCAAAGANTGAACGCAAAGTACATGGGGGGTCGATGGTTGGAATTGAATGCGGATACGCTCCCGACTCGAGAAGAGATTCAGGCGGG 0 10 31 0 +CCCCCAGCAGTGGTATCAACGCAGAGTGCATGGGGCCCCCGTATCCTGCAGTGGATGCCTCTTCAGGACTAGTGCTAGGGTCAATACGCGA 34 24 34 0 +AAGCAGTNGTATCAACGCAGAGTACATGGGCTAATGACGTAAAGTGGAACGGTTGAGGTCACATAGGGTCTACAGTTAGGCCGACACCGAG 30 27 30 0 +CTTCAAGCAGTGCTATCAACGCAGCGTACATGGTAGAGCTGGTTCAGATAGGTGGCCGTCTCTGTCACTAGTTGTATCTAAACATAGCGTG 0 21 33 0 +TTCCAAGTCATAGTACGTGGGGTAGAGGTTCAAGGACGGGGTGCGTGCTAGGACGGGCTCGCGTAAATAGCCTAACTACTAAGCAGTAGAA 0 5 21 0 +CAAACAGTGGTATCACCGCAGAGAACATGGGCCACTGATGTTAGCTTATCTGAAAATTGACAGCGATCCTAAGGGTATTATGTTTTTTTGG 0 21 31 0 +CCCAAGCAGTGGTATCAACGCAGAGTACATGGGGAAGGTAACAGACCACATCACTTAAGTAACGCCGCCTGTTACCAGTCTGTGGCTCGAA 33 30 33 0 +CGAAGCAGTTGAATCAACGCGGACTAAATGGGCTTAACATTTCCCCAAATTCTACCCCACTACTGTTTGATTACTTGCTCGAGTCTGAAGA 0 15 32 0 +CCTAAGCAGTGGTATCAACGCAGAGTACATGGGTCGCGAGACAGTTTCCGTGCTTTGCGGAAACTTACCGGGTTGGGTCCAGTCGCTACAG 33 30 33 0 +CAGCAGTGGGATCACCGGTGAATACATGGGCTAGTAGCTACCCAGTGAAAGCGTTAACAACACTGCGCGTTAAATCCTATGCTGGTTAAGA 0 12 30 0 +TGACGAAGTGGTAGCCACGCAGAGTAAATGGGTACGACTGGACTGAACCTTTGAAAAGTCCTCATCGGGGCGCTAACAACGCGAAGCTACG 0 15 32 0 +CCAACAGTGGTATCAACGTAGAGTACATGGGGAGCTGGGCCATTTGCATCGGGGACTACGCTAGAGCTGACTAATCGACGTCGCATCTAGT 31 24 31 0 +GATTCAAGCGGTGGTATCAACGCAGAGGACATGGGCTCGCCAGCCAGGCGCCACACCAGCCGTCAGGATGGCAGGCCCATCTCTGGTCGCA 35 24 35 0 +AAGCAGTGGTATCTACGCAGAGTAGATACGACCGTGCCCTCGCGCAAACAGACAAGCGACAGCATGACAATAGGGCAAAAGTTATAGTACG 0 18 30 0 +CAGGAAAGGAGTGGTATCAACGCAGATTACATGGGGCCGAATGGCACTGAAGGTTGAAAGCCGAGCAAGGGGTCGTCTCTTTGACAATCGA 35 24 35 0 +CAAGCAGTTGAATAATCCCACTGTGCATGGGTCCCTTTCTGTCCTTGCCTTGCGAAACTAGATGNCAGTACAGGAGCAGACTCACACTAAC 0 7 31 0 +ATAAAAACCAGTGGTTACTCCGCCGCGAGCACGGGGGCGGGCATTTGTAAATCATTGGTAAGCAATATTGCTAGTGACTCGAACGAGTAAG 0 3 35 0 +GGGATGCAGAATTTTCAACGCAGAGTGAATGTGAGCAGAGTATTGGTTACTTTGCGCCTTCTTAGTTGAAGGTGGTAAGTCGCAAGCGGGA 0 7 33 0 +TACCAGTCGTAACACGGTTTTGTAGACGGGTTTATTGTTGAGGCTTTTACTTACCAAGTACTAGCAGGTAGGAGTAGGCATGGGTTACGTC 0 -1 91 0 +CAACTAGCACTGGTATCAACGCAGAGCGGTGGCGGCGAATGTACATGAGGGGTAGGTCACCACCATGTTGTAGGTCATACCTCGAGTGTTT 0 11 34 0 +ATTAAAAGCAGTCGTGTCAACGCAGAGTACATGTGAGAGTTATACCCCCGCTGGANCGTCGAGCCGTCTCGTTTACATAGGTGAACATAGC 0 21 35 0 +CCTTAGGCAGCGCTAAAGCCGTACGGTAGATGGGCATCAGCTCGGGGTCGCAATTTAACATATCNTTGGGGCGAAGCAAACGATGTATAGA 0 1 91 0 +ATCCAAAGCAGTGGTATCGACGCAGAGAACATGCGCCCAACGAGTGGCCAAAGCCTACTTGACGGTAAGCTCCTCGTCTACGACCTTGTTC 0 21 35 0 +AAACAATGGTATAATGGCAGCGGACAAGGGCATATGACACTCTGGTATACTCACGGAAGAAGAAAACCACACCAGTGGTGCCGGCGGATAG 0 7 30 0 +CTGATAGTGTTATCAACGACCGAGCACATGAGTTTCTTTCACTCTACCGTAAGGGACTCCCACATCACCTACCGTCGCATCGAAAAGTATG 0 7 32 0 +CAAGCATTGGTATCAACGCAGGGGTTATGGGAGATCGCCTTGATGTGTCAACATCCTTTTTATTATCCATGGCTGAGCAGCATTCACCCTA 0 16 31 0 +ACGATAAGCAGTGGTATCAATGTAGAATTCATGGGCAATCGCGTGGAATCACCGCGCAACGGCTGGCCAGGCAGCAATCATATTCAGACAC 0 18 35 0 +GAAGCATAGGAATCAACGCAGAGTACCTGGGCCTATTCATTGGGTAGTGGTCTACTACCCATGGCCTGAAATTCACCGTCATTCACCTCCC 0 19 31 0 +ATAAGTAGTCCCATCGACGCAGACTACACTGGGATGCGGGCGTTCTGTGACGCACCTGGCTCAAGTAGAATATAGGGAATGTCGCGCCGTC 0 10 33 0 +ATATAAGATCGCAGAGACATGGGACTATCGGAGGCTCTGCCATACACGTTCCTTGACAGCGTGCTTCACACTAATTACGGAACCGATCGCG 0 9 23 0 +TGCTATTAGGGCAGAGAACAGGGTTCCCCGGCGCTTTTAGCTTCAAGGGGGCCGACATCGCAGCCTATATGAATGCTCCAGAGCCCTATCA 0 6 23 0 +GAAGCAAGTGGTATCAACTCAGATTACATGGGAACTGTAGCACCCAGCCCCTGAGGTGAAATTGGACCGATAGGCCATGGAAGCAACAGTA 32 22 32 0 +TAGGAGCGGGCGTAGTAACGTAGTGTAAATGGGTGAAGATTGTATGATTGTTCGTTAACGGATCACATTACCCTTTACAGATGCACCTTAT 0 5 33 0 +AAGCAGTGGCATCAACGCAGTGCACATGGAAGTACGCACTAGGCTGGGCTCGACGCGATGCTACGCCGTCTACCCTCTGCGGCTTTTTGAA 0 18 29 0 +TAAGCAGTGGTATCAACGCAGAGTACATGGGATAGCTCAAGACGTTGAGGCAAACAGGTCAGGGTGGGATGTCCCAACACAGCGGGCCTAG 31 30 31 0 +CGAGCAGTGGTATCAACTCAGAGTACATGGGTACCCATCCATTGTGGGAGCGCTCCTATTGGATGGTGTGACAAACGTACCCCAGCCGTTC 31 24 31 0 +CTCAATGCAACCGTTTCAACTCAAAGTACCTGGGTACGTNAATATATGTACGTCGACTTGGTTGCGAAAGGTTCATAGACTCTCTCAGTCA 0 7 34 0 +AAGCAGTTGTTTGAAGCAGAGTTCATGGGTGAGGAGGTCGTCCGCCGCGGGTTTTGTTCAGGAGTACGCTTGTGCCGGACATCAATCTTTG 0 15 29 0 +CATGCAGTGGTATCAACGCAGAGTAAATGGGCTTGATATTGCGAGGAAATATGAGTGCATGGCATAATGTGTTGTCATCAACATCCCCGTC 31 24 31 0 +GCGATCTCGTGGTATCAATGAAGCGTTCATGATGAGACAAGCGCGGGCTGCCGCGAAAAACACGGTGGTACTCATCTAAGACATCGATCTC 0 2 34 0 +GAAGCAGTGGTAGCAACNCAGAGTACATGGGAGAACTGAGTAGGCCTTTTCAAATCCGTGTGCTAATTCAGTTATCGGAACATTGGTGAAT 31 24 31 0 +CTGTCAACTGGTATCANCGCAGAGTACATGGGAAATGGTACTTTGGGGGCCATGTCCCCTGTTTTAAAATGAGTTTGGGCGGCCTACTTCA 0 18 32 0 +TAGCGGTGGTATCAATGCAGAGACCATAACAATTAATAAGACGCAAGCTCCCGAATAAGGGAGACGAATAGGTTTGGATCAGATCGCTGAG 0 7 27 0 +CTTCAAAGCAGTGGCATCAACCGGAGTTTACACGGGCAGTGCGCGTCCCTAGTTAAACATGAAAGACATCCTAATACTTCCTGTCTAGATT 0 14 36 0 +ACGAGCCGGGTTAACTGAGCAGAGTACCTAGGAGAGAACCATTGGCCGCCGACTGCGACCGTGTGGGAGGAAGGCCGTCGGATTAGCTTAA 0 3 32 0 +GAGCAACGGGATCAACGCATAGGAATGGGTCGATCCCTCTAGACGCCGTTCCCATGTGGAATCTCGGCTCTTGTGCCTAGATGTCAACGAT 0 9 29 0 +AAACAGTTGTATCAATGGCAGAGTACAAGGGACTTAGCCGCGGGTCCGGCCTGTCGCTTAGGAGCTGTGTTCAGCTAGAAGGTCGTTCGCC 0 16 31 0 +ATGTCACGGAGTGAGAACACCGCTGAGTACATGGTTTGGTAATGAAAAATGTTTAGTCGTTTCCTTCCTTTGAATAAGACTCACACTCGCG 0 7 34 0 +CAAGCAGTGGTATCNTCGCAGAGAACATGGGCATTTAGTCCCCATGGAGATTGAAATTAAGTATGGGCCTGCAAGTCAAATCTCTTTTACG 0 21 31 0 +CTAAAAAACAGTGGTACCAACGCAGACGAGAGGGGACGGATAGTTCACACCCGTGCATGAGGTCGCAGAGTGAGGGTAGCACTAATGGAAA 0 13 34 0 +CATGGGAAGTGGTATCAGCTCAGAGTACATGTGGAGAACGTGTAACTGTTTTAATCCGAGATCCGTCCGGGCGCACCTTGCCTCCACTGTT 0 13 34 0 +GATTTAGCCAGAGGTATGAACGCATAGTACATGGGGTTGCGTAATCTACCATACCCCGGACTTTGTACCATCCAGACGCGTAATAGACGGT 0 16 35 0 +ATGCAGTGATATCCACGGACGGTACATGGGCCTGCTTGTAACATCCCGCAATGCAAGGCCAGTCAAGTTCTAGCAGCCCCGTGTCTACGAT 0 13 30 0 +ATCGGTTGTTCGACCCAGATTAAACGGGCAGAGCGTCGTGTATGTACGCCCTCGGGAGTCCCTAACCATCAGGATTATGGTCGTCGTCTTA 0 2 5 0 +GAAAGGAGAGGTATTAACTCAGAGAAAATGGGGCTCCCGTTATCCGCTGTCTATGGGTACGTATGTGGACACACTAACCCGATATAGCCAA 0 12 32 0 +ATCCACGCGGTGCTATGAACCGCGCCACTTGGGCCCCGGACGCGGAATTACATCGAGCCCAAATAAGAGCTAGCTATAGTCGGAGACCACT 0 1 33 0 +AGCGGTATCAACGCAGAGTTCATGGGATAGAANGGAAGCAGTCCAAATTTAGCGACGAGGAAAGCTACATCACGGACACAACAGACCAAAG 26 20 26 0 +AGTAGTACCAACGCAGAGTCCATGGGATCTGCGAGGCTCTTCCCATTGTCAGGCCNGAGCTGCTCAGTATGCTTGTAGTTGGGTCACCAAG 0 17 26 0 +ATCCCAGCCCGTGGTATCAACTCAGAGTACATGGGCTAGGGCACAGCCTGGGGGTTACTATTGTAGCTCTCTTATAGTTAAGTTTAACCCA 0 19 35 0 +ATATACGCAGATTACATGAGATCTTCATCCTTAGGTACGAGTTGGTAAGATTTAAAGTCTACACTTCAATTAAAAGCTAGAAAGCCGGGCC 0 9 20 0 +AAACGAGAAGTGGTATCAAGCCAGCGTACACCGGGAATGACGTAGCCTATACGCACGCGGTCTGTCGCGCTCCGCGTGGTCGTTCCGGTGG 0 11 35 0 +GGAGAGTAGTGGTATCAACGGAGATAACATGGCCATAAGGCCGTCCAGCTTTGTTTCGCGTTGGCAACAGCGTTGGACACCATTTGGGAGG 0 14 32 0 +ATATGCAGTGGTAGCCACGCGAGCCCATGGGGATTNTTCCATACGCGCTTGCTTAGTTTAAGATCTGTCTCGGCCCACCTGTAATTCGATC 0 12 31 0 +CATAATCGGTCCGATCTCCGCAGTGTACATCTGGTAGGTGGGTTTGTGACTCAATACTTCCCCGCATCGTCCTTACCGTGCTTTTAGCGAA 0 2 34 0 +GAATGAAGTGGAACCTCCGCAGAGTACACGGTATCATCAAATAGTAATACGTTCTATAATGACGTATCAACAAAACACGGTTCAGTATCTC 0 7 31 0 +ACAAGCAGTGCGATCAACGCATGGTACATGCCGACTGGATCACATCCATCATTTGTCACCTCCGCTGAACCCGCTGATTTTATTAGCGGTA 0 15 33 0 +CGAAGCAGTGTTATGAACGCATAGAACATGGGCGAGTTGTAGACTATTTGTCTTCGCGTGCGCGGGAATTCTGAGTGCTAAATACCGTAAC 0 18 32 0 +AAGAAGTGGAATCAACGCAGAGTACAGGGGACGCATGCAAGCACCGNCACTAGGTTTCGTATTTAAAGATGAGCTTCCGCGCTGGCCTGTG 29 21 29 0 +ACAGAAAGCAGTGTTATCATCCAAAAGGACATAGGGGATGCTCCTCGAATTTCATATACCAGTTGGTCACCGCTATTCGCACGCGGTACGG 0 11 36 0 +AAGAAGAAGTACTATGAACGCAGCGTACATGTGCTGAACTGATTGGTGTTGTGCGTTTTAGATTAAGGCACCTCTTGTCGAACGCCAAATA 0 12 33 0 +TAAAAGCAGGGGTATCAACGCTGAGTACCTGGACCCATCCAAGCCCCGGAACTATCAGGCTTTAGGTGACCCAGCCATTTGGTGAGGCAAC 0 18 32 0 +AAGCAGCTGTATCTACGCAGAGTAATTGCGCCGCGATCGAGGCGCCGAATGTCATTTAGTATATACGGGGCCACTCGGCCACGCGACTGAG 0 14 30 0 +GTTAAGCAGTGGTGTGAAAGCAGAGTACTGGGGGAGAACAGCGACCCTGGAATGCCAGGTTACTGCTAACCGAGGCAAGTAACCAGCATGG 0 18 32 0 +AAGCGGTGGTATCAACACAGAGTTCAGGGGCAACGTACAGGACACAACCCGTCTACATGCGAATCAACCAGTGGGTCCAAACAGACTGTGG 0 18 29 0 +CTAGAAGCGCTGGCATCAAAGCCGAGTACCTTGGGGACCTAAGCATGGAAGCAACTTTCCTAATCAACAGGGGCGCTGACACGGGGCACNA 0 11 35 0 +CGGATAAGAAGTGGTATCAACGCAGAGTACATGGGAGACCTGGGATGCGGGGCAGGTCGGCGATTATTGTATCTTGACCCACTGCAGCAGC 35 27 35 0 +GCGATCCACCGGTATCAGCACGGAGTACGTGGGCAGGAGGAAGAAAGGGTACGCTCACCTCCGTTGCAATCCTCCGATAGGGGGTCTGGAC 0 6 33 0 +CGTGTGGTATCAACGCAGAGTACATGGGGGCCTCCGCATACCGATGACAGCTGTTATGGCATCCCTTGTTTTTTTAAAATAAGCCAATGGG 28 22 28 0 +TATAAAGCAACGGTGCATCGCTGAGTTCACAGGGTTCCTCTCTTGAGAGTAACCCCTCTTTGCCTACAACGATCGAATAATGCGGTCCTGA 0 5 34 0 +TCATACAGATTACCTCGAACAGTGCGCTCGTAACGTCTGTGTTATAGCCTCTAAGATGCGTTGACGCTAGANTCGGCCAGTGTTTTCTACA 0 1 91 0 +GAGCACTGGTAGAATATCAGAGTACATGGTCCAGTGGAGCAGAACTATACGTTCTGCCGATTGTACACCGCAAGACGTTTAAGTAGTACAG 0 7 29 0 +AAGGGAAGCTGCGGTATCTACTCTGAGCAGATGCGACGTATACGTGTCCAGATACTGATTCACGGTCGCGTCGCAAAACCAACCAGAACAC 0 6 35 0 +CGTAAGCAGTGGTATCAATGAAGCGTACATGGGGCNTCATAAAATACGCTCCATTCAATCGGGAACAAGTCATACCGTGCCAATCCAACAG 0 21 33 0 +AAGCCGTGGTATCAACGCACAGTACGTGGGGAAGAACCCAAAGCCCTGTCGGGGTATATCTGTGAACTTCTCCTCCCAAGCCTTCTGCAGT 30 21 30 0 +AGACCAAACAGTGGTATCTCGCAGTGTTTCTGCGCTAAGATTCCCATTGTCTGGTCCCGGAGGCAACCGCGTCGTTTCGGTTCTGTTTCGT 0 7 34 0 +CGACTCAGTGGTAACTACGAAGATTACACGGGGTAGAGTGTTTTATCTGTCCGACCCGGCCCGTGGTGAGCTGGGAAGTGAGCCATGTGCC 0 9 32 0 +CTGAATCAGTGGTGTGGAGGCAGAGTGCGTGGGCCGGGCGTAGTATGGGGAGTACGTGAAACCTCGCAGGGGTACCGTACAGCTTTTCAGT 0 9 33 0 +TGGTATCAACGCAGAGTACATGGGTGAGAGGTGGAAGCAGCTAATCTTCTGAGAATGGTTAGCAAGTATTACAGTCGCGGCCACGGCTGTC 24 24 24 0 +ACTCAAACAGAGGTATCAACGCATGGTACGTGGGACTATCGGGTGGGCGCGACAGGTACCAGGCGTACATAAGTGATCCTACATATCGAGA 0 16 34 0 +TAAGAAGTGGTATCAACGCAACGTACATGTGAAGGGATCTTGNTATGCTTCGAAGGCTGCCAAGCTGTTACTGTCGTATCTTGTCTGTTGG 0 19 31 0 +AAGCAGTGGTATCAACACTGAGTACATGAGGTATGTGTGGTGCCAAAGGCTTTACGATGTATAGGCCGATACGCCGGGCAATATGTGGGGG 31 22 31 0 +TTGCGATCGGCGCGGAGCACATGGACTCCTCAATGAGATTCGACTAACGCTGCCCCTAGCTCCTTCACATGCCCGATACGGACGTCTTAGT 0 2 24 0 +TTTGGGTATCAACGCAGAGTACATGGGATTATTCAGGTCTGAGAGAAGTGCAAGCAGTCGATACAAGAGTTTCTGCGCTTTGTATATTTTC 0 18 27 0 +AAGCAGTGGTATCAACCCAGACTACATGGGAGAACCGTTAACCGCCACGTCTAGACAGCTGTGATTTCCTGTCGATCCATGGTACTCNCGT 30 24 30 0 +ATCGTATCAACGCAGAGTACANGGGCGCCCCTCAGTTACGGCTCATAAAGGATTTGAACAGTTTATTGCGGGAATAAACAACCCGAGGCTG 0 17 25 0 +AACAATCAGGGGGATCTACGAAGAGTACAGGGGAATGGACATATGAGGTGGGCCCTGGTGTCCGTGTATCTTTGAACCCCATTGAAAGTGT 0 12 32 0 +CAGCCCCTGGTATTAACGCAGATTACGGGGGGCTTATTCGCCAGATGGCTGTGGCTCCCTAGTATANGAGGAAGCACCATAAGCCGCATGC 0 7 29 0 +ATGGTTTCAGTGGTGTCAACGCAGAGTACATGGTCAAGGGTAACCGAAAATCCACTAAATCGTGTCCCTGACTGATCCAAATTAACGCTCA 0 15 33 0 +CTTTGGGGTATACAACTTGGGGTTCTTTGGTTCTAATGTTCAAACCCTAAGGTCCTGAAAAGTCGGACCTTCGGAGCTTGGCATGGAGAGA 0 1 7 0 +CCAGGCCAACGCAGAGTACATGGGGGATCTCCCAGCCCACCCCAGACGTTGTTGACATCATTTACTAAAGGGTCGCAGGTTCCACCGCTCA 0 10 24 0 +AAAGCAGTGGTATCAACGCAGAGTACATGGGGCGCTACGCTGCCTGGATAAGGTCTTCAATGACCCGGAACAAGATGTTTTCGTTGACCAT 31 30 31 0 +TTTAAGCAGTGGTATCAGTGCAGAGTACATGGGTACCGTTACTGGCCTTACAGAAGGCTCTCACTCCGATGCTATATGCCCGTCTAACCCA 33 24 33 0 +ATAAGCAGTGGTATCAACGCAGAGTAAATGGGNCGCGAGGCCTGAGATTGTGCTCGTTGGATCTCAAAAAGGCGAGTGAGCCTATATGTAT 32 27 32 0 +GTTTAAGCAGTGGTATCAACGCAGAGTACATGGGCAATACAACGTCAAGGCAGACGTATACAGCTACGCGCTTCTGGCCCTTTTCACGCGC 34 30 34 0 +TTTCAAAGCAGTGGTATCAACGCAGAGAACATGGGGGAGTACCAATTCCGTACTAGTGGCGGAATGGGACACTCTTAACTCTAGCGTTGAT 35 27 35 0 +CCGCAGTGGTATCAACGCAGAGTACATGGGCAATTTCCCTCTCAAGGTCTGATTCCTATAGAAGGCGCCAAAAGATACACGCTTAAAGTCA 30 24 30 0 +TAAGCAGTGGTATCGACGTATAGGACATCCGCGGCACGATTCGTATATCCCTGCTGTGACCGCAGGATGCACCGCAACTTACTCACGGCTA 0 12 31 0 +CGAAGCAGAGGTATCAACGGCGAGTTGAGGGATAGGGTACCAAGCACATCCTAGGTGCTCTGTTTGGATGAGTTCCCCCGCCGTCATGAGG 0 13 31 0 +TCATAAAGGAGTAGAATCAACTCATAGAACAGGGTGTACTCATACGCCGACCAGGCACTGAAGAGTGTGTTTTATTTCGAGTCCGCGCCAA 0 9 34 0 +GAGGCGTAGTGGTACCGAAGCAGAGTTCATGGGGAGTCGTCGTGGTCGGGGACATGGTGACGGTTTCATAACCGCTCGATGTTCGTTGAGT 0 12 33 0 +CACGTATTAACGCAGAGTACATTGGTGCTCGGTGATGACTTAACCCTCCTTGAATACCTGCCGCTCCCCTGGCTACAACGTGGGATAGATG 0 12 25 0 +GCAGCAGTGTGGTCAGGGCGAGGGTACATGGGGTGCGCGGCCTGAGAATCTCGAGGATTGGCATGCCACAATGAAGGATGCTCTGGTATGG 0 8 32 0 +TTTAAAAGCAGTGGTATCAACGCAGAGTACATGGGGAGACGTGAAAATTCTGCCCGTCCTTCGGCTAGATGCCTGCACAAAGTCCAGTTGA 35 30 35 0 +CGCTAACCACTGGTCCCCACGCAGTGTACATAGGTGGGTGGGGAGTTCAATTCACGGGGTAATTAACGCCAAGCCCCCCTGGTAACCTCTA 0 9 34 0 +TGCCATCAGTCGTTTATACCCACAGTAAATGGGGGGCCTTTGGTCTAGGGCTCATCTCTCTAAGAGCTCGGCATTACATGTTTTTGGCGTA 0 4 33 0 +AGATAGTGCTTGCAACGACAGTACAGGGGGCACAGTCACGTACCCCCGTGGCAGATACGTGTTCTTGAGTTTCGTGACGCAGAATACAGTC 0 7 28 0 +CCGATGCAGTGGTATCGACCCAGATGTACACGGGAATTCGTCGCCCGACTCATAGTACCGTCAATAGCGTTCGCTTCAAAACAGCAGTCGC 0 16 34 0 +ATGCAGTCGTACCAACGCAGGTACATGGGACTGTATTTGACTTCTTTCGCCCCTTTGCCCCCCAAGGAATCTCAAAAAAGATCTCCACCCT 0 18 29 0 +GAAGCAGGGGTATCAACGCACAGTACATGGGTGGCGTTCTATGTTGTAAACCCATAGGCCCAGGTCTGGCCTAAGCTTCCAGGCATTTCTA 31 24 31 0 +CATAACGGGGTCGTACCAACGCAGAGTACATGGGGTAGAACCCGTCTCATGGACAATCGTCAGCCCGTAACGCCCTTGTGCATTCAGCGTC 0 16 34 0 +TAAGCAGGCCTCTAAACGCAGAAAACATGGGTGTCCCAGTACGGCAATGCGTGTTGCGCTATGCGGGCATTCGCATCGACTAGAACGTACA 0 10 31 0 +TGGACAAGCAGTGGTATCAACGCAAAGTACATCGGTTTAGCAGCCCCCAGAGAGACCACTGTATACAGCCGANTGTTACGTCTTGGCATTA 35 24 35 0 +AAGGAGTGGTATCAACGCAGAGTACATGAGCGATGGTCCCGTCTCCTGGGGTATTGAGATATTCTTTACGACGGATTTGAACTAACACCCT 30 24 30 0 +ATATAGCAGTGGCATCAACGCAGAGTATATGGGAATCCCAGCACTAAGCTACATTATAATTGGCATCCTACCCTATAACCGCTAATCCCGC 33 22 33 0 +GTAGCTGGTATCAATACAGAGTACTTGGGACTACCAGTTGGGGCTGCTGTCCCGCTAGAGATCTACATACCCTCAGGCTGAAGATATAACT 0 14 29 0 +GAAGCTGTGGTATCAACGCAGAGTACATGGGACAGGGGTCGATACATTTTTCTCATCGATCTAGATCATCAGATGCTTCTTCTGATGATAG 31 27 31 0 +CCAAGCAGTGGTATCAACGCAGAGTACATGGGCTGTTCCTTTATTCACCACAAGTTGAGACAAGAATCCCTAGTCAGCCTTCACTTATTAC 32 30 32 0 +TTAACCAGGAGTTGGAGCAACTCAGAGTACATGGGGTGTGCAAAAAACTGCCGATCTGGAGAGCGTCTCGTCCCCGTCTATAAGAGATCGA 0 13 35 0 +TTAAGCAGTGGCAGCAACATAGAGTCCATGGGAATGCGATAAGAAAAAGGCCGTAAACACGGGGTCATACAGTCTTTCAACCCTTCGAGTG 0 15 32 0 +ATCAGTGGACTTCAAGCAAAGAACATGATGGAGGGGGCAGCATAGAGTCTAGCGGGGCTACATTGCGGCCATGGGGACGACACACGCGCTG 0 6 31 0 +AAGCGTTGGTATCGAGGCAGAGTAGATGGGTGCATTAATTGGTAATAACTCCATAGGGATAAAGCTAGCCCGTAATCCGTTGCGGGCCACG 0 16 30 0 +CCTCAATGCAGTGGGACCATCGCAGAGCACATGGGAGACATACAGTCTGATGTAAGCATGGTACCAGAGTAATTTTACCACGTGGAACGCT 0 16 35 0 +TTGATCCCTTGGTAGCATGGCGGAATAGATGGGATGCGTCGACTTGTCCACCCCCTGCCTATAACTCTTCCCCAACGCCAGTCAAAACGTC 0 0 33 0 +TAAGCAGTGGTATCAACTCAGAGTACATGGGCGGTTCGAACGAGCGACTTGGAGACGATGTCCGCCACCAGTAGGATATACCTTGTCTTCA 31 27 31 0 +GGAGTGGTATCGACGCAGAGTACATGGGAAAATATCGTTCCTCAAGATGAGTCACTACACCCTCTGGGTACGCTGCAAGCCTAATCTTAGT 28 22 28 0 +ACCACGCAGTGGATGAACGCAGAGTGCAGGGGGGAATGCAAGGATACGTCCATGTAGTCTGCCTGGGTTAGAAATAGCAATAGTCTTGTTT 0 15 31 0 +TTCAGCAGTGGTATCAACTCAGAGTTCATGATGTGCTCACGTGAAGATGTTTTCGGACGTCTTACCACTAATGCCGGCATCCTCGGATAAT 0 16 33 0 +CAGCAAGCAGAGCTATCATGACCGAGTACATGGGGTCACCGTATCCCCCCAACTACGGCTAACTGCACACCCCAGCGGGAATGTTTTGGCC 0 14 34 0 +ATAGTATCAACGGCTGGTACATGGGGGCCGTGTGTTCGGTAGTCAAAGGAATGTTCAGCAGCACGCACAGTAACTTTCTTCTCTGTATCTC 0 12 25 0 +GAAGTAGTGATTTCAGCACAGAGTACATGGGGTCCAGTTCTCGGCCACAGGTAGTGAAGCATTAAACATCCGCAAACGGGAGCTGCGCCCA 0 15 31 0 +TACCTATCAACGTAGAGTATATGGGATATTCATAACCGCTACGCCGTGACTCATTCTGTTCTTTTTGGGGGTGCCAAAACGAAGGGCCTAC 0 10 25 0 +AATAGGCACTGGCATCAAGGCACACTACATTGTGGTGTCACGACCCTTGTGTTGTGAATTTGCCCCTGTCCACCTCGGGGGTGACCCTACT 0 8 35 0 +TAAGCAGTGGTACCAACGCAGAGTACATGGGTCAACTTCTAGTGGCGTTATTAATGGCGGGCGGACTGCGGTCTCTTCGTGGATACCACCA 31 27 31 0 +TGAAAGCAGGAGTATCAACTCCCAGACCAGGGATGTACTCCTGCATATATTAAATAGCGCGACCAGTGGTGTGAATCGGCCACCTTACCCA 0 8 32 0 +CAAGCAGAGGTATGAGCGCAGAGTGAAATGCGACCCGTGAGACGCGATCCCTATGTCGAACTGATTACCGAGGAACCGTGCATTGGAGTAG 0 13 32 0 +CAAAAGCAGTGGTATCAACGCAGAGTTCATGCCGAATGAAAGTTGTGCAGGTTACTCGACCCGTCAAGCGTATATAGTTAAAGGAAAATCC 34 22 34 0 +CTAAGAGTGGGATCACTGCAGAGTTCTTGAGCTGAGATCACGTCCAGCACATGAGGTCGACTCGTGCAACTGTAAAGGGATTTGCGCTGGC 0 10 31 0 +GTAAGAAGTGGTATCAACGCAGAGTACAAGGGTTTGGTTAGCTTCCACTACCACTAGATTATCCATTCGTTTGCCACGATCAACCTCTTGT 32 24 32 0 +CGATAAGGCAGTGGTATCAACGCAGAGTACATGGGACGCGTCGCACATGTAGTTTTAGTGTCAATTATTCACGTTTCAACGCGGTGGCGAC 35 28 35 0 +TATAAGCGGCGGAATCAATGCATAGTACATGGTTACCGCGGCGCGCCCGTACCAGCGTAACTTATCAACCCCTAGTATCAAGCTCCCGGGT 0 12 32 0 +GGGAAGCAGTGGTATCAATGGAAGGTGCATGGGTACGACCTGACAAAACGCCACATGCCCGCACGTCTGATGGAGAGAACTGCGGTTATCA 0 16 33 0 +TACCACTAGAAACAGCGCAAAGGACATCGGTATGGCAGTTACGGTATGGCTCACTCTGCCGGTTCGCTTGCTTTCCTGCCGGCTGGTACCT 0 0 30 0 +GGGAACCAGTGTTATCTACGCATTGTACATGGGGGTAGAAGGCTTCCACACAGGCAATGGCGTAGTGGGTTTCGAACTATCTAGGCCGTAC 0 15 33 0 +CCAGCACTGGCGTCAACGAAAAGTACATGGGCGTGTCAAATGTCGTACACGTCAATCGCCCACAGGGAGTAAGAGTCGGTGTGCTTCTACT 0 12 31 0 +TACCATTGGTATCGACGCATAGTCAAGGGGTTTACTCTGTGCAATATGGAACGGGCCACCATAGACCACTCGCACAAGGCTATCCTAATGA 0 9 29 0 +ACTAAGCAGTGGTATCACCGAAGAGTAGATGGGTCGATCACAAACCGTACTGTTCTTGCTTGCGCCGTGTCGCCGAGGAGACTGCTCTGAC 0 21 33 0 +CAAAAAAGTAGTATTATCAACGCCGAGTACATGGGCGTGCATCGGCGGAGGGGTTATCCCGTTCCCAGAACAATTCGTACACGTAGACAAC 0 18 35 0 +TCAAGCAGTGGTATCAACGCAGAGTACATGGGCAGGTGGCCCATTCGGAACCTCGTCCCAGGAGCAGCGGTCTGCCTCCGGCGCGTGTTAG 32 30 32 0 +AAGCAATGGTATAAAGGAGATTACATTGGACTCGAACAAGGAAGATGGTTACCTCGTCCATTCCATGTGATGCCTCCCAGCCACACCGAAC 0 12 29 0 +TATAAGCAGTGGTATCAACGCAGAGCACATGGGAGTGAGGATATGTAATGTGTGATTTGGGTCACTTTGAACGATACCTTAACATACTGAG 33 27 33 0 +CACGAAGCAGTGGTATCAACGCAGAGTACATGGGCGCCCAAGTTCGTCAACGGGTCACGCCGAACTCTGGGGCTCGTCACTGATGCTGTGC 34 30 34 0 +AATCAGCAGTGGTATCAACGCAGAGTACATGGGTGGTTTCAATAGTACCGCAGGAGGATGCCTGAATGAGAAGGGAACATCTGGTTAATGT 33 27 33 0 +CGGTTTAAACGCAGCGTGCAAGGCTTTCTGGCCAGATCGACGAGGTCGCGACAGCGTGCAGTCATAGACCTAAGTTTATAACCCGAACACT 0 3 23 0 +AGCAGCCTTAGTATCAACGCAGTGTAGATCGGCTTAATAGCCACNTCTCCGCGTTTGTCAGCGGTTCCTAGCACGAATACTCGGGACATTT 0 11 32 0 +ACAAGCATGGGTATCATCTCAGAGTACATGGGCCTGGCGTGATCAAGACCCCGAGCCTCTACAGATTCTTGAGATTTGTTAACCGATCTTC 0 19 32 0 +TTATCAGTGGTATCAATGTAGAGTATATGAGGCGCCTAGTTAATCGTTGACAGTATGACGAGAATTTGTTGTTTTCCACGGGCATCAAGAA 0 13 32 0 +AGTGGCTGTATCAACGCAAAGTACATTGGTGCGTGATGCGCGGATTCGGTTTTCCTGTCTCTTGAGGTGCTCTGGATCGGAGTTTCCTACT 0 14 29 0 +GCCTCACTAGAGGTATCAACGCAGGAGCACATGGCCCGTGCGACGGAGCTCATGGGCCTCTCTGCTTATCTGTATTGCTTTGCGATACTTA 0 11 34 0 +TTATTAACAGTGGTATCAACGCAGAGTACATGGGTATAGTCTGCGGGAATTTTTAATGTATGGTAAGTCGCTGCTGGCCACGAGGAAGCGG 34 27 34 0 +ACCACAAGCAATGGTATCAACGCGGGAGTACATGGGCTTATATTATTGGTTCACGCAAAAGCGCGCCGAAAAAGTGGTTTCTAATTCACCG 36 22 36 0 +TGGGATGAAGCTGTATCAGCGCAGAATAACGGGTCTGCCATGAATGCTGAAGAATAACGCTGCGCATTTTAGGGTGTGAACTATGCATTAT 0 9 33 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGGAACGCAGAGGCGAGCAATGNTACAATCGCTTTAAGCAAGTCGCTCCCCGAGTCTGGTTAT 30 30 30 0 +AAGTGCTGGTACTAACGGAGAGTGCATATGTCGGGCCTGGTAGCCAGGAACCGGAGGCTGAGAAACGTTGTTTAACCGGAGCACTCAATAA 0 5 30 0 +CCAAGGCAGTCGTATGAATGCAGTATTCATGTGCAGTATAACTACGTAGCAGGGTCACCAGCAAATCCTTGTCACACAGACAAATTCTCCG 0 8 33 0 +AAAACAGTGTGTACCAGCGCATAGTACATGGGGACAACGACAAGGCCTAGTGACTACATGACTGCGGCAAACACTGGCATGGTAGGGGCTT 0 16 32 0 +GAGTACTTCTACGGTTCGGGGCGTTTTTTGAGTCGCTCACCGCTCTGCTCGCCACTATTCGATTCCAAACTCTCGCACGGTCCGCATAGTG 0 1 1 0 +TGGCCAAATGCGCTCGCGAGGTATGCTCTCGACCCGCGTTCTAGTCATTCTCCAACTGCAGGCCGAGGTTGTCTTACTTCAATTTGCTACA 0 1 3 0 +ATATACAGTTCTTACATGTCGTAGCGATAAGAGGGTTGTTATAATGGCCGGTAACACACCACCACATGTAGATGTCGGTCCAGGACTTATC 0 -2 1 0 +GCTGGGAACCTCTTAAAGATGATCGCCTACAGGTGCACAATGCGAGCGACTCTGAAAATACCGCTTTCCTGCTTCGCGGGTGCATGTATCA 0 2 91 0 +TCGGTTACTTATTAGTCTAATGATCTTCTTACTCGGACACAACTGGAAAATCGTTTTCACGGAGCTAGCGAGGATGGCGGAGCGTTGGTCG 0 1 4 0 +AAAATTTCCAATTCTCCACCTTGGTGACCGCCCACGTCCATTTCACCAACCAGTCGGACTTGTTCGTGTACGGCACGCATCTAGAGCGGCA 0 1 91 0 +TGGCCAAGCCGCTCACGTCTCCTTTAATTCATGTAGGAAAAAGAGTACTAGCGTTAGGTCTCAAGAGCCTGGTTTTTATACTTCACGTACC 0 1 3 0 +GTCCTTGGTGCATGCAACAACCGGCAGACGATCTTGAAGAGTATTGAACATTCGTGTAGTGGTCATGGTCGACGCGCTGACTTAGTTTGGG 0 1 1 0 +ACCTGCACTGTTTTCAGGGACCAAAGTACAGCTATTGGACCACTAGCCGGACGCACAACAAATAGTTAGCTCGGGGCGTTCAAGGAACCGG 0 0 91 0 +GGTTGTAAGAGTGGGAACATCGCATACTGTGCCTCCACATAGGACCCATGGGTAGCCAGTATCTAATGACTCGCAGATAAATAGGTTTGGT 0 3 31 0 +TCGACGAGTCGTTCTGGGTACCGTCCCATCATAAGCTCTTCTCATACGCAGTTTCTGGGTGTGCGGTTGAGGTGATACAGCTCCGTAATCA 0 2 18 0 +TCGGCTTGAATCCCGGCTGCTGTCTTTAGGATAACTAAACGCTGTTGTCGGTCGGCCCAGCGTCAAAAGAAGGATTAACGGCTAGTACCCG 0 1 4 0 +ACCTTATAGCTAATAAGATGCATAACTAACGGGATAACTTGCCGGTATGAAAGGGTGCTGGACGCACCACGATCGACGCATGATCCTCACC 0 -1 91 0 +GGTCTCCGACTTTGTTATGTACGCTGGTGGGCAGAATCCTCTTTTTGTGCGTTTTATCCCTGGAACGCTGTCTTCTTCTCACTGCCCGGGT 0 2 2 0 +GCTTCGAAGGTGTTCGCGTATCTCTACCTCAGGTAGGGTGCTCTGGTTACCACAATGCCTGCCAGTTCTAACTTTGTTGTACCGCGAGTGT 0 1 1 0 +CAAACGTGTAGCCGTATGGCACCCCATTGCCAGTATCTTAGCGGTAGGTAATCCCCGTTGGCAATCCGGACCGCCCGCAAAGAGTTATTAC 0 1 91 0 +GCAGATCCTTATATCTCCGTCTATGAAGATCACATGAGCGATCACAATAAAACCCCCGAGCGAGTAGCACCGTATGTGGCTCTTAAAACCC 0 1 1 0 +GCAGTGGTTAGTTTTGTTTCCCAATTAGGCAGACAAAGTTACTTTACATACCGGCCTATCTCGAAGACTCCGAGGGATAACTCAGGCCTAA 0 2 91 0 +ACATTATTTCGGCGTAGGGTCCCAAACCGAACGACGCAGGCTTGGACATCATGCTCTCCATGAAAGTGAGAATTTCCAAATCATCTAGGGC 0 -1 91 0 +GGCGCGATGCAATGCCACTGATGATCGGTTGTAACTGAAACGAACAACGCTGCGCCGTAAGCGTCAGGGAAGGGAATGCACAAAAGTTCTA 0 2 2 0 +ATGCCATGTCTTCCCGCACGGCATGTGAATGACTCAACTGCCAAGGGTCGAGGTCCGGCTGGGCCGTCTACACGCTAAATACAACGGCACT 0 0 91 0 +TGCAGACGGCTAGATAACGTCATTAGACAAACCACAGCCTTTGTGTTCCACCCCGCAAGATTCGTGACGGGCTATCGTAATTCGGAACGCG 0 1 91 0 +ACTCCAGCCTATACTCACCCCGAGAATATAATCCGCACCCGAACACTAGCGATCGTTCAATGCGTCGGGCGTCTAGCCTCATAGCGCCTTC 0 -2 1 0 +CGTATACCGTAATGTCCCGTCCCGATATCCGGGGTTCTATTCAAAACCTCTGGGGATAGTCCAACACATCCGGTCTAACATGGCATCCCAC 0 2 91 0 +CCACGGCTACAAGCCTCCTATGATAATGCAAACGTCTCTTACCCTTGGAGAACGTAGAGTACGCCAATGGTGATTTCCTGCTGCGATGCAA 0 2 91 0 +TGTCCCTTTGGAGCCTAGTAGGCCCGCTACTGAGTCGGTTACATAACGGCGATCTATTTTACATTGATCACGTGCTTTCCCACGGCTACGT 0 -1 2 0 +ACAGCGTATCTATATAGTGGGTCCGTGATATCTTAAGTATCAGCCGCATACCCGGTCCGATATTGCAAGATAACTCGATGACACAGCCATC 0 1 6 0 +ACTTTAGCCCGGCGCTAAGGGGGTCCACCGGTATGGGCACGGCCTAACGTCGATAGGGGGGACTCTTTCGATAGTGAGTGTGGCTGGTGCC 0 -2 1 0 +GGCTCGACCCATCCGGTGGAGCTTTGGAAGATCGGTAACGTGCCAATACACCTGAGGCGATTATTAAGGCAGTACCATCTATGGTTGTCGG 0 2 2 0 +GATAAGAAGACTATCCGGGTACGCGCGGCTATGCCGTGCGTTTACAGTAGAGGCCTGCTATCTAGAAGGTTACGGATGTTGTGCGCCGGCG 0 1 1 0 +GCACGGATCTACCATTTAACGTGCCGCCTCAGATATATCTAAGTGCGGGTAGCCCGTAAGACGGACCTATTATGCTACCGATGGTTTGTTA 0 1 1 0 +ATTTGTCCCCCAAGGCGTATCCTGTAGAGAGAGTCCACGATGCCTACGAGCAGTCACACCCATACCTTTATTGGCGTGAACTCGGATATCC 0 -1 5 0 +CTGTGGTTCATGGCCCGACTTACGGCTTCGGGCTTCTACGCAACTAACAGCAGCTGGCGGCTTGCGTTTCATCATCACCTCCGCATGGACA 0 1 6 0 +GTTGGGAGGACCAGATGCACGAAGCAGTCAAGTGCCCGGCACGCCGGTAAAAATCAAAATTACACGTGAATTCCTGATCATGCGCACGTGA 0 1 1 0 +AGGGTAACCGAGAAAGGCACTCACGATGAACCTAAACCGCGTTTGCGGAGTGCTGCCCCTCACCCTCGTTAGAGTCCATTTAAGTCATAAT 0 2 4 0 +GAGTGGGTGGACGTGGGAGCACCCCGTAATATTTCGTATAGTCGGTCCGCGTTACATCAATAGTGTTAAGGGTGACAAGCTCCGCTAGATG 0 1 1 0 +TCCTAGCGGCACCTAGCATTCTGCTGTCATGTCTTGCTCAATCCCAGCGTAAGATCGGATACCGTCACGTCCGTTAGGCTATCCAACCTGC 0 -2 1 0 +GGCTCCTGCGTTGTAAGAGGTATTGACTGTTTCGCTCACAATCAGGGGTACCTCCGAACAGTACTCATTCGTCAAGGAGCAGTAGTACTCA 0 6 91 0 +CAGAATCGGGGAGCATGTGGATCTTATTTATGAGCCGGGAAGTCTAAATGCACCCAGAATCTGTACGCCCTCTTAATCGTGGCAACAGCGG 0 3 91 0 +CAACTCTTCAATTGGGTGGTATACTGTCAGCCGAGCAAACAAGGGAAACGCGCATGAGTGTGGGGAAGTAACCTGCTCCGTGGCTGACCAC 0 -1 64 0 +GTTGAGGCAACTGAGTGATTCTCATACGCCCTTCCCTAACTGGCTACCCTCTCTGCTACCTGGGTATAGGGTCGCGTAGACGAAAGTCGGA 0 1 1 0 +TTGCTATTAAGAATGGGTGGTACGGAATCTAGAAAGCGCTATTGGGTCGAGGTCTCGTGCAGTTCTCAACAACTTACCAGAAAGCCGGGGA 0 2 91 0 +CCGGTAGGGCGAAAGTCCTTCAACAGCGATTCAGTTCCCGTCAATAAAAGGAGCTAGCAGTGCACGCATGAGCCGGACTTGTGAGCTGAAG 0 3 91 0 +CCACCTACGGGAGTCACAAATCATGTGGCTGAAGGGCGAATGGGACCATCTACGGGTATGATATACACGTCCAAGTAACGCTCCGTTGCTC 0 -2 1 0 +TCATAGACGCCTACTCCACAATTTCCCCCACTTATCCAAGTCACTCCAAGTAGTTCGTGTCGCGGTTCAGCATAGAATAGTTCCTGATTTG 0 -1 6 0 +ACGCGCTCTACTTTAGCTCGGTATAGGATGCCTGTCATAAAAATACGGAAGGAGGACTTGCCCCGCAGTCGGTTCGTCACCAAATTCTGGC 0 -1 5 0 +GAGAGCGGCTAGGAGAGCTAATGCTATTGTGCCTTGTCGTCTTAGTTGGAGCCCAGGGATCGTAATATGACATTTGTTCAGAGTTGGCGTT 0 1 1 0 +CTTACGGATCTACGTAATAGTGCGCAACGTCAGGGCACCCTCCATACAATTCTCTGACTCCGATCGGGCAGTACCTATTAGGACCAATCGA 0 1 91 0 +TTGCTCGGCCTCACCCTAGGGCGGTGTATTGTCCTAGGTTGTGCGTTCACTAAATCACGTGTTGGCATGCCAAGCGCAACCTGGACTCTAA 0 2 91 0 +TTTAGAACATGATAACCTCACCATAGCTAGGTGAAAGCGCATGAGATGGCCTCCAATTAACCCGGCGCTACGACGTGGACAACCGGTAGGG 0 -1 91 0 +TTCTCGAGGGTGAGATTTAAATCATTACATGGAGATATGTATTTTGGCGCCCTTGGGAATCCGGACGGCTCACCCCCGCTAACTGCATTTC 0 -2 1 0 +GGCTTTTCATGCATAAAAGTTAATTGGCCGTAGGTAATAGCGTAGCCATCTCGGCAGATTTATCGTTCCGAACTCATCTCAGACACCCTTA 0 2 2 0 +TAAACAGTTATGTTTGACACAGCAGATATGCTATGGCTTATCTGGCGAACATAAGAATAAGCTTGTAGTGCTAGGTGAACGTACTAATCAA 0 2 91 0 +TGTTCTCAGCGTAAGAATTCCCCGCGGACCTATGCCTAAATCATAAACGGGATTGATCATGCCACTCTCCTTAATTGCAATGCACGTGCTA 0 4 91 0 +CCGCCTGGCCTTCTCACTCATGCTCCAGGGAAGTGCAGCCTCTTTAAGAACCGAACCTACGTCCGAAGGACCTCTAGTTTGCCGCTTTATG 0 0 91 0 +GTTACCCGGCAGGGGTAGAAGGGTTTGCGCGGAATTTGAGCCCCACGGACCACGCGGACCTCAAAGACCCGCTTGAATGGCGGGACAGCTT 0 1 1 0 +TTTGTCGGCATCCCGTTTAGGTCCCGTTAAATTCAGGTTGCTGATATCTTGTGAGGGCTCCAACCCCTAGTCGACCCAAAACCGCAAACTG 0 0 91 0 +CCTCCGAGGTTCTGCTGTAATAATTTAGATGCCCGTCATCCAACCGTACATCGACGACTCAATAAAGCCAAGGTTACATCAGTAGCACTGA 0 1 91 0 +CTAAGACCCAGTACCGATTCCTCGGGGATTGAGGGCGACGCAGGGGTCCCTCATCAGTCGAACAAGTACCTTGTTGTCCTATTTAACCCTT 0 -2 1 0 +TTAGCCAATGCAACAGCTGTGTTCGTACATTATTCGTCAGCGGCTACCAAAGGTTAGAACGTGACCTATCACGCGCGTGTCGGGATAACGC 0 2 91 0 +GCGTCGGTGGCTTGGCTAGATGAAATGAAGAGGGCTTGTGCGATCGGCACTCGCGAAGAGTATGTGCGAGTGGTTGGTACTGTAGATAGAT 0 1 1 0 +AACGGTGGACATTAGTATGCGTTGGCCTTATTCGATCAAGGGATACCGACTAAGCAACGATTGCAACTCCTTTGTAGGGGACAGCCTATGT 0 -1 5 0 +TGCCCGACAACTTCTCTCGCGGCATTGGGTTCATTCTCAAGGGGATGCTATAGGGGATAGAAGGCTAAGGCGCCTGGCACCTGAGAAGACC 0 0 91 0 +CGATGCACGGTGACTAGTTGTAGTACATCGCAATCCCTCCGGCCGAAGGGTGTTCGAGAAGTATATTAAAAATTGATGAATTGTGAGAGGC 0 1 91 0 +TTCATACGACCATCTACCTCTGTTTCAGTCCAGTTGATAGTTAATGCGGCGCTAGGGTCAATTGGCAAGGAGGTAACATCCCCCAAAAAAT 0 0 91 0 +TGTTCTAGCACATGAGCGACGGAGACCAAAGGTAGACCTCTTTTGGGATAATCGCCGGTTTACACTCGCCCCCTTTAGCTCACTATGTCTA 0 1 91 0 +CGAAAGGACCATAGATATCATCGTCCCCTACCCCCTAGCGCGGCGCCGAGGCCGCCAATCTCTAGAATGGATTAACTTTTGGAATGGTTTG 0 -1 2 0 +GGTAACGAAAACGGTTCAATCACTCTCAGGCAAGGGTAGCGCCCCTTACCATGTAGTTCCCCATCGAACAGTTGAACAATTCGGCCAACTT 0 2 2 0 +AAATTTGCCAGTACACTGATTCACACCGCAGTAGGTCGGATGTTTACCTGCGGCGTCCCCTGCACTCTGGCTCACTTTACTGCGCGTCTTA 0 1 91 0 +CTTCACTTAGCTGTCACTATAGGACCAAGCGGTCTCCGTTCATCCCGGGACTATGACTCCCGATAATTTAAATAACGTGGCGCGACAGCCG 0 1 91 0 +TCCCTATACCAGCAGCGAGTACCGTAGCCCCGTATTTAGATGCGACGGGGTCCGACCTTCATCTGGTTCTGTTCCAGTCCTCTATGACGCG 0 0 91 0 +TTATTAATGGGCTGATTATCCAGACTGAGCTAGAACCGGTTAGTCTCAACCGTGCTTCACTCAGGACTAATGCCACAGGTAATGATCTCCC 0 0 11 0 +TCAATGAGATGCGGAGAAGGTAGGGGTGCCACTGGATAACGCTTGTGCGGACGCGATTCGACCTACATCGCAAATATTCTGGTCTCTGACA 0 1 91 0 +AGGGTATTTGGAGCGAAGCCGAGGGCCCGAGACGGAAACACGCCCGGCTTTTTAGCTTCATCGAACAGTGACGATCTTTGTCGCTAGCGAA 0 2 4 0 +GACGTGGTCGAGATGCCAGCAAAATTAAGTTGATTGGATCTCATGCGTCCGGTATCTTGGGCTGCCGTTACAGTGGCCTTGCGTGGCGACC 0 1 1 0 +ATCAACACTCATATGCTATTTGAAGAGACAACGACCAATGAAATATCGACGGCGTTCCATAGGGACCTATATTCCTTCAAATAAATGCGCT 0 0 91 0 +AGATCTTTGGATCATGTTCGTCCCTGGTTTACTCCAGTAAGTTCGCATCGATAGCCTTACTTTGACTTAATACACGCCACCTTCTGAGTCT 0 0 10 0 +TGGTCTGAACGTAGGTCACAGAACCTGCACAACCATATTTTAATTGCACAATTGTCTTCGCCTTACGAGATAGTCCTTCGATGCGCTTATC 0 1 3 0 +CAGACAATCTATACCCCCGCAGAAATTGTCGGTCATTGGAGCATCCATTCGACTAAATGTTACAGCGTCGTGTAACCGAATTCATTAGAGA 0 1 91 0 +GAGAGGGCATATGCAAGCGCAGTGGTCCCTATCTAGGTCGTAGTAACAATAAACACTTCTCCGAGACAGAACGGCAGTACGCCAAAAGTGC 0 1 1 0 +TTTAGTCGTACTCGTTAGCGGAAGCTAGGACGTGCCTGTCACGTTTAGGGTCTGAGTATTTAATTACTCTATCCTCGCACTGTACCGAGTG 0 0 91 0 +TGTCCCTATAGCAGCCTACAGTCAGAGGTTCTTTTTAAGAAGTCGGGCATCATCGTTGATGTGTCTATTACCTGGATCCCCTATCCTCTCT 0 -1 2 0 +TAAAGGCGCAAGCAGACCAGTAACGCATTGCTGACCGGGATTTCAAGACTACCCTCTTATTCGTGCAGCGAGATAGATTTTGATATCTGTC 0 0 8 0 +AGCGATATGCGTGCGTTGCTATGTTTAAGCGTCACTGGAAGCTGACCGGGTCGTTGCAAGCGAGGTTGATCGTCGATTATCACCCCCTACG 0 0 11 0 +TCATGAAGCAGCGCTCCGATCACCAAGAAAACGTAGGGTGGTGAAGTTTTCAATGGTCTGAGTCGATGGTGCTTAGTGCTTCTTTATAAAA 0 2 91 0 +GCCCCTGCATGCATATAGTCGCAGTCCACATAGACGCCAGGTAATAGAACCTATAAATTCCCCACGTCACTGGAGACTCTTACTGCCCCTA 0 1 1 0 +ATGGTAGTGAGTATAGTCGATCTTTCCCGTCAACGGGATAGACGGCCTATAAGTGACAGTACCGAAAGTCGTCGAACTGGTACTCGGCGCG 0 2 4 0 +ATGAAGTCCAGATAACTTTAGCGTCGTCCGGATAGTTGACTCATCGCTCTACAACGCTACGTAAAGTATTGGCGGGTGCGAGGGGCTCCCG 0 0 6 0 +ATATCATAGCGGCCTTGGGGATGATCTCTAGTTTCCGTTCCCGGCCATAGAGGGTCTAACGGTAGGAACCGAGTTCTTTATGATCCGTTGT 0 1 12 0 +CCGCGACCTTGAGATTAGCTCCGCGACGTGCGTGGGGGTAAAAACTTTTCATGGATTGAGGGGTACTGGCGCTGCTCCTTAAATAAAAGTT 0 -1 91 0 +CACGCCGCTACTTGCCATCTCGCATTCACCTCTATACGTTCGGGGAGCCAGTTGGCCGATGAAAGGCAGTTCGATGCAAGCCGCCGCCTTA 0 1 91 0 +ATGTCGGAGGGACAATCCCAATGACGCGTCCATTCTTACTTTTGACAAACTAACATATATGTAGTGGGGGCCTGCTTTTTCCCGTTGTCGT 0 1 7 0 +GTATTACGAGGATATAACCCGGAGTTTTAGACGCCCTGAAAGGCAACCACCAGCCGGATATAGAGCTGCATGGAATCGGTCGCCGTACTAT 0 1 1 0 +TAAGGCCAGTCTGGAAGTTTCCAAACGTCAGTGCCTTAGTAGACTGATTTGTGCTCCAGGGGTCTGCTATGTCGTTTCTAGTACGCTTTAT 0 -1 5 0 +GGGCACAGCGACCACGGTAGTCCCTAGAATAACCGAGGCTGGTCAGGCGCCTACTATTTACTAACTGTCGTAAGCGGACTTCTGAAAAATC 0 3 3 0 +AGGGGAATTACTCGGGCACTATAAAAACATTCCGATAGTGAGGCCAGAACGAATCGGTCGTAGACATCATCGAAACCACTTTCCCACCGGC 0 2 4 0 +CATTTGGCCTGCCATAATGCCACGACCACCTTTGCACACCCTTAACCAGGATTTCTACCAATAATTTATAGCATGAATACTGCTGGGGAGC 0 1 7 0 +TGGACGTGGGGTCAGTAATTGTGATGTCAAGTAAAGAGCCTGCTTATAGCGTAGGGCAAAGACTGTTTATCTCGGATTATAGAGATTGAGA 0 1 3 0 +CAAGCACTTCTTGAATCTCGATTGTGTTTGCGATCACACGCTCTCTTGACGCATCTGCCAACACTTGGGAAGAGATTCCTGCTTCTTAACT 0 -1 91 0 +TTGTAGGTACGTGGGTTCACCTGCGCGTGCAATCTAAGCCATGAGAAACCTCTACCCACAATCGGTCCATGCCACAAGGTGAGGTTCCTCG 0 1 15 0 +TCCCCCCACGGAACAAGGTGTTCATTGGCTTCCGCTCGCCAATGTCGTGATTATCCCAAAACGAAATAAAGCTTTGTTTTCGGATCAAGCG 0 3 91 0 +AAGAGGATCTCACGAAGAAGGCGCCTATCGGCTCGTAGTATATTCCGAGATACAAAGGATGTATAGGTAAACTTTTGGCTCTCCTCGTCCA 0 1 91 0 +CCTGTGCATTTTTTCATGAGCTTTACGGACGAAGTGGTCAGAGGCAGGGGTCAATTACCCTCTCTCGTATTCGGACACGAAAGCGTGTCAG 0 1 91 0 +TGCAGCCCTATTATCCGAGACTAAAGTTTAGCAGGCTTGGGCGGCAACGAGAAGCTTTGAAAATAATCCGGCGCTCACAAGAACCCCACAA 0 2 91 0 +AGTAGTCCCCGGAGGGGACATCCCGTTCGAGTCATAGAGGACGACAGGTCCACGCGCGAATGTGATTGAGCCCAGTATAAATTTCCGACCT 0 -1 2 0 +GTTTCCCGTGTCCCACGAACGTTGATCCTAGCCCGATAGCGAGGGCACACGCTTCACGTCCAGCATGTAGCACCAGAGCGGCCCTGCAGCG 0 1 1 0 +CTGCCGATGGCCCGATTCATATCCATCTAATCCTGCCGATTGTTCCTCTATTACCTCTTCTCACTATCGAGACCGAGGCTGCAGCTCGTAG 0 0 91 0 +AGTAGACCTCCGCCATTTCTAAGTTAAGCTGCGGAGTGTACGCACTGGCTACAGTAAGCGGTTATAACGCCATAGACTGTATCGCAATATA 0 1 79 0 +AAGTATGCTCTACAAGGGCCGGCATTTTTTTGGGGAAACAAGCGACGAAATTCTATATGGCACCGGTGCGGCGTGGGAAGTACATGGCAAC 0 1 91 0 +AAGTTGCCACGAACCAATTTCAGGTGCTTCCTTTAGCGGTCGTCCAGAGCTTGAGTATTGCTGGGGTACCGCGATGCGCTCCCGGCCATGT 0 -2 1 0 +CCTACAAATCCTGCTGCTACATGTACGCCGGGACTACGCGCGGGTATGAGCATCACGGCTCTGCGGCTTTTCCCTAACGTGAACTGAAGCG 0 3 91 0 +TATTGGTCTAACGGGGTATTGTGATGGAGATAGTTGAGAAACGTATTTCTGTATGTAGCTCTAGACCAGTAGTTTACTGCAGAGAGCCGCG 0 0 6 0 +AGTTACCAGCGCGTGTATTCTCTTTGCGCTACTAGCCAGCGCGAAAGCTCCGTATTCGTTGTGGCTCGTCAGCTGTTCCTCACCTGGGGCA 0 1 91 0 +GTCCTAACGAATCGAACGCGGTCGCGCATAACAAAGTCTTCGTCGGGGAGCCTGGTTATCAAGACAATATTTTTCATTAGCACACGGATAC 0 1 1 0 +GTTCGACATCTCCAAGGGGTGGAGCGCATTCCACAAAATGATCGCGGACCCACACTTGAGGAACCTAGCGTCGAGTAGCCGCGTTGAGAGC 0 2 91 0 +CGCCGATTTTGGCACTTTGTGACAGTCACACCTGTGTCTATTCCCAATTCCGCAGCTAAGCCGTGGAATAAACCCCACGTCGGCCTCCATC 0 -1 2 0 +GATAACGGAGTGATTTAATGCGAGGATCGGTGGGAACACTACCACTCATGACGGCGATTTCAAAACGCTGGATGCCGCTCGCTAAGCGTGC 0 3 91 0 +CCGCGGGGGAGGTGATCATGCCTTGTTGCTACGACAAAAGGGATTAACGAGGCACGCGCGTGGGCAGCACGTGTGATTGGTTAGTCGCAAG 0 3 91 0 +GGGCACATAGGTCCCCACAATGAGCTGAGCTGGGAGCCGCGCAAGAGTCGGGTAATTCCCGTACCCCGTGCACCAATCGTGCGTGGCTTTC 0 3 3 0 +CTAACTCGCGGTATGCGCAGGCGCCACCCCGTTGGACATCCGACCGTGTAGATGGAATTGCCACGCATCATCCTGACAATTTTGTATACGT 0 -1 91 0 +CGCCGTCTTACGATATCTACCGAGGTGGAAGTGTGCCTACGCCTAACGGAGAATTAGCTTACGATCCCTTATCAGTCCTAACACTGAAAAA 0 2 91 0 +GGACACATCTTGCCAAGGACGAATCTCGTCTTCCATGTTAGCCTGAACGGGCATTTAGTGGCGATCTTTGCTCAAGACCAACTAGGAAGGC 0 2 2 0 +CTACTCTCTCTGCTGTGAAAATCATCCGATGGTTGAAGGGCCGATGCGACTGCGAGCTCACGTACGAGAGAGCGCGATTCGGCTCGACAAA 0 2 91 0 +TGAATTTTATGATAGCTCTCCAAGGTTCCTCGCCGAACAATTAAGTCATGATTGATCGCCGATGGCCAGAAATTGGTTATGTACTAATGAC 0 0 91 0 +TATAAAACAATGTCACCGAAATTTCCTTCAAATTGTTACATTCGGTCGTAAACATCGACGTCGAGGTTGTCATGTCGCGTGACGGTCGATG 0 0 91 0 +CGGCTCTATACGTGCAAAGTCCTTATAGGCATATATCTGCCGATGGCCAGCTATGGGCCTCATAACCTACAGAGATATATCAGACAATATA 0 1 91 0 +TTTAGAACCGGATATATATCCAGAGCTAAGAATATCAATAGTATTAAGCCGTCCATAAGGCTAGCCTGCACCAGAGAACAACACGCTGTGG 0 3 91 0 +AGAGTCGGGCAAGGGACCGCGTAACAAACGTAGGGCGATGGGTGGCTCTAAAGCTGTTCAGTTGAGTACGGGGGAAGAGGATAGTCCCCGG 0 3 9 0 +CTAGAACTTGCTTCTGGGCTGGCTGCCGTCGAGCGACAGTCTGGGAAGACAATGCACTGGAACGAGCGTCGAGCCCGCCCCCCTCTGCGAC 0 -1 91 0 +TACTACTGGCTTGGATCACTTGTGCTCAGATTGCTACATTTGCTACAGGTAGGCCGAGACGTGGGCAACCGCGATCACGTTCAAGCCCCGA 0 1 9 0 +TGGAGTCGGTCAAGCCCTGTCTTTCAATCCTTGCTTCCTGACATTAGTGAGCAACATGCATTTTGGACAACAGCAGAATCGGCTTGGTGAA 0 2 5 0 +AATTGTGGTACTACCCCGCCACCGCCTTACCTAGTGCGGTAAGGTAGAAGCCAGGACTCTGAAGTTAACTCGTTGTAAAGGAGCGTTACAA 0 3 91 0 +CATCCCACCATACACGGTGTTAGTGCAGCGAGCAAGTTGTTAGAACATCGACTAACGTCCCTACCGTATGTCTCTCCCGCCGCGCGTTAGA 0 1 91 0 +AAGCGTCTACCAAGGTAACAAAGTCTCACGGAAAATTCAGCGAACCCTGCTCGGGATACACGATCATGGCTATGGGAAGAAGTAAGCGTAT 0 3 91 0 +GGTATTGATACAGCCCTTGCACACGAAACGAGGCGCTCTAGCGCAGCGGAACTACCCAACATTTCAGTTGAACGAGCACGAAGCTGCCGAA 0 2 2 0 +GAGTCGTCTCGGATTGTAAGCTGCCAAGCAGTCGCGGACTAGTAACGAGCACAAGTCGCTCAGGACTCACAGGACACCACCGGTAGGGATA 0 1 1 0 +GACTACCGGAGTGACTGAAGTGAAATTCCGATGATCCACTCCGTAAATACAACTTTGCTGTCATCGGTTACTACGTTAACAGAGTCATACG 0 1 1 0 +ACTACTTTCAGATCTACCCAGTTCTCTATCAGGAAACCCTGTTCTAGTACCCCACAGCGTACGCACAGGCATTTTGCATCCAGCTGAAGTG 0 0 91 0 +TTGCCACCATGCCCGAATTGTAAATATGACTTTGGCAGGATAACATGTACACGCGAACCAACCCCGTGTTTTGGTGGACAACTACACTCCT 0 -2 1 0 +ATGACGGTTTTGTTCTTATGTTAGCATCGAAACACAATCCTGTCATCCCCTACTCTATTAATAGTCTCAGAAATCATACCGCCGCCGGCAG 0 1 7 0 +GACAATGCCGGCCGGAACCTAGTAAAATACTCCTGTTGTACCCTTCTCTTGAACCAATTCGGATCAACTGGAATCGACTCGTCACTCGACG 0 1 1 0 +GGCGGTGCCACTTGCTAGGCCATGTAGTAGTGACGGGTGCAAGCGTTGCGTCCCCCATTACGGTTCCATTGAGGTCGAGCGTGTGCTCAAA 0 2 2 0 +AGTACCAGTGCTTCTTAAAACGTGTACGAGGCTGTTTGGAAGCGAGGCGGTAGCACGTGGTGTCTATCCGGCCCATTTCGATCTCACTCAG 0 2 10 0 +TGAATATTCCGGTGCGAATCTCGCCCATTCAGAATAGTGTACTTCAGCATCATACGAAGCAAGAGAAGTTCAGGCGTACGAAGTAAACGGT 0 1 91 0 +TGTTTATATTAGGTGCCGACGAGGCGGGAAGTCTCCGGCACCAAGTCTTGCAATCGAAGATGCCGGTGTCCACAGGGTGAGTTCTACAGGT 0 -1 2 0 +GCACTTACTGTCGGAAAACGTCCGGTCCTCAAGGGCTACCGCACGTTTTTGATAGTGATCTAAGAGTCCCCAGACTGCTTCCGCTATTCTA 0 1 1 0 +TGTTAGCTGGAGTATGTCATGTGGAAGCAGTACCGGTAGGACAGAGCAACCACGCCTGTACTGCTGCTGAGTAGCTCCGAGGCCCAGTCAA 0 2 91 0 +TTGGTTGCGGTCCGCGCCAATGTCTGATGCAGCGGTGAAAGGTATAAAGTCGTATGTAATGCCTCAGTTGGAGGTCGGAAATAATGGACAG 0 1 4 0 +ATCGTTGGCGTATCTATTAGCACCATCTTGACAGAGACACATTTTGAGGCAAGCCAACAGGAACTTGCATGACAGTCATGGATACGAGAAA 0 2 91 0 +TCTTCAAGATCATTAGCACTTTTGGTTGCAAGCAACCCCTATATTCTGGAGTACTGTTGACAAGCTCCAATTTAGGCTTACGTGAGAGCCG 0 1 91 0 +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 91 +TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT 0 -2 1 0 +NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN 0 -2 1 0 +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 91 +TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT 0 -2 1 0 +NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN 0 -2 1 0 +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 91 +TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT 0 -2 1 0 +NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN 0 -2 1 0 +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 91 +TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT 0 -2 1 0 +NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN 0 -2 1 0 +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 91 +TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT 0 -2 1 0 +NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN 0 -2 1 0 +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 91 +TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT 0 -2 1 0 +NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN 0 -2 1 0 +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 91 +TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT 0 -2 1 0 +NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN 0 -2 1 0 +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 91 +TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT 0 -2 1 0 +NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN 0 -2 1 0 +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 91 +TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT 0 -2 1 0 +NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN 0 -2 1 0 +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 91 +TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT 0 -2 1 0 +NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN 0 -2 1 0 +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 91 +TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT 0 -2 1 0 +NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN 0 -2 1 0 +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 91 +TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT 0 -2 1 0 +NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN 0 -2 1 0 +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 91 +TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT 0 -2 1 0 +NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN 0 -2 1 0 +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 91 +TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT 0 -2 1 0 +NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN 0 -2 1 0 +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 91 +TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT 0 -2 1 0 +NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN 0 -2 1 0 +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 91 +TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT 0 -2 1 0 +NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN 0 -2 1 0 +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 91 +TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT 0 -2 1 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGAAACT 30 30 30 0 +AAGCAGTGGTATCAACGCAGA 0 3 21 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGTGATCGTACATT 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGA 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGCTACTTCTTCACAAAACCGAGCCGACGAATGTAGTCAAT 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGTGGAGTAGATGACTGTGCTTCAACGTTGCATCGATACCGT 30 30 30 0 +AAGCAGTGGTATCAA 0 -2 1 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGAACCTAGCACCCACGTAAGCTATAAACCGATACA 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGG 29 27 29 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGGGCACGCCTGGATATTTCTAGTA 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGTGATTTTTGCTCTACG 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGAACCAAATTCCCCACGCAGTTTTTTTGCCCCATAGTGGCGCTCACGCTA 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGGTTGACGTGTAAATTGCGCGAGAGGGCTTGGCGGTCCGGCC 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGGTCTGTTGAGCTTTGAATAATTTTAGCCTACGTCGAC 30 30 30 0 +AAGCAGTGGTATCAACGC 0 -2 1 0 +AAGCAGTGGTATCAACGCA 0 -2 1 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGTTTTGTAATTGCCGTTAGACAGCTCATTGACAACCGCTGAAGG 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGGTAGTTGCACAAGAGATACTCTGGGTAGA 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGCATGTTA 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGACTTAGGAAAACGTCCAAA 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGCGGCCTAGATGGAATCGGTTATAGAAATG 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGCAGGTGCACCTAGGCATAGATCACTCCTTTGAAGGTGGCTGGTGGTC 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGG 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGCCGCACGCTGACGAGACATTCTGTTCGATAAGGGTCTTTTTAT 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGTCTTCATGC 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGAGGCGCCTCAACATTAAAGTATACTGGA 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGAATTCATACGGGGGTGCGACTTCAGCAGAGTT 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGGAACGAGTACGGCTTTGACACTATGCGAAA 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGTCCCTAGTAGGCGTTCGAAGCCGTATTAAGATGAAATTATAAGCTATT 30 30 30 0 +AAGCAGTGGTA 0 -2 1 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGGATCTGAAGTGATTTGGTAGAAAGTGGCGACTA 30 30 30 0 +AAGCAGTGGTATCA 0 -2 1 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGCGTAGT 30 30 30 0 +AAGCAGTGGTATCAAC 0 -2 1 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGGAACCTGT 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGCCAGGCGGTTGTCTTCTATCTGGGGACTTCTCATCGACTCACCTTAA 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGGGAATTTGTGTCCTGACTTTTTCGGATTCGGCTCCCTGATTGATGAT 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGACAAAATACTCCGCTCAGATAGTACTGGGTCTTGTGCCAT 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGATTCC 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGTACCACACACAGGCACACCTTGAG 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTA 0 12 24 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGTAGTG 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGAAATTCACATGACGC 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATG 28 24 28 0 +AAGCAGTGGTATCAACGCAGAGTACATGG 29 27 29 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGGTATTTTGGCTGACCTCCT 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGTATACTCCATAGAACCCTCCTATTTCTCAGCTTGCCAGTGGA 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGATGAGGGATGGACCTAGCATTCTAATA 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGT 30 30 30 0 +AAGCAGTGG 0 -2 1 0 +AAGCAGTG 0 -2 1 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGGCCCAGTAAGGTATATGAAACTCAGGGTCTAAGGTAATAACCA 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGA 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGGGAGGTCCGATAA 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGTG 30 30 30 0 +AAGCAG 0 -2 1 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGGTATCCAATCTATTCGGGATTTACCATTCTACGA 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGGCCCAGATAGCGTTACTTATACCTGTTTCTACCCGC 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGT 0 9 23 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGAAAGAGTCGGGGA 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGGGGTTTTAGTCTTCGTAACCTCATCACAATTTGCTTTTCCCGACTCACCTCAGG 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGTTGGCTAATCGAACTCCA 30 30 30 0 +AAGCAGTGGTATCA 0 -2 1 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGCGAAAACACGCCTAGACAAGCTAGGCACGACAG 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGACGCCGTAAGTATC 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACAT 27 21 27 0 +AAGCAGTGGTATCAAC 0 -2 1 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGAAGCAAACATGACATTGTTCGAAGT 30 30 30 0 +AAGCAGTGGTATCA 0 -2 1 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGAATCA 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGCGAAGTCTGCCGCAAGCACATAGTC 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGG 29 27 29 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGGCATGGGCAACAGATAGAGCCTGTACAGAACGCGCCATA 30 30 30 0 +AAGCAGTGGTAT 0 -2 1 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGAGGGAGTTTAGGAAATTACGGTACGGTCTTCTATGCTAGTCTCCCCTAAG 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGTCATCCCTGCTACTCTT 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGTATCCTAATTCTCCCTGCCGTGTTATCCTAATACCCCGTGGACTAA 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGCAGCTTTATGCAAGCGC 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGGCGACCGTTTAACTTATGAGAGACAGTTCGTACGCTCC 30 30 30 0 +AAGCAGTGGTATCAACGC 0 -2 1 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGGTAATCGGGTCAGATTGAACGAAGTC 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGCCTCCGGAGGCGACGATGAAACAGCTT 30 30 30 0 +AAGCAGTGG 0 -2 1 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGTAGAGTACACGGGGCGAATTAAGCACGT 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGAGGATATGCCCACTCTCCCAGACGCCATGAACTTTGTACACCACTTCCACATTA 30 30 30 0 +AAGCAGTG 0 -2 1 0 +AAGCAGTGGTAT 0 -2 1 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGTCCAATAAATAT 30 30 30 0 +AAGCAGTGGTATCAAC 0 -2 1 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGCAGACGGATCAGCGGATGCTACGTACGGGGTATTCGATGGGAAATCCT 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGCCTCCAAGCTGTAGTATAGCTCCAAGCCGCGATTA 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGGAGACCCCACAATCAGTTCCTTAAAAATCTG 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGCTTATAGTTATACTACATTACTGTCG 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGAGTTCCTGTTCAT 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGTCCGC 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGTG 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACA 0 18 26 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGCTACGGGGACCCTGTCATG 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGGATTGTACATCGCATCGCTTTTCATCGG 30 30 30 0 +AAGCAGT 0 -2 1 0 +CGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTC 0 -1 2 0 +CGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTA 0 1 91 0 +CGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGAAAAA 0 2 91 0 +CGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCAAAAAAAAA 0 2 91 0 +CGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTAAAAAAAAAA 0 2 91 0 +CGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCAAAAAAAAAAAAAAA 0 2 91 0 +CGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTAAAAAAAAAAAAAAAAAAA 0 2 91 0 +CGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGAAAAAAAAAAAAAAAAAAAA 0 2 91 20 +CGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCAAAAAAAAAAAAAAAAAAAAA 0 2 91 21 +CGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 25 +CGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 30 +CGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCGTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 40 +CGTCGTCGTCGTCGTCGTCGTCGTCGTCGTCAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 60 +AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 91 +ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGAAAAAAAAAAAAAAAAAAAA 0 2 91 0 +ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 27 +ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 35 +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 40 +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCACAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 40 +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCACAACAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 40 +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCACAACAACAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 40 +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCACAACAACAACAACAAAAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 35 +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCACAACAACAACAACAACAAAAAAAAAAAAAAAAAAAAAAA 0 2 91 32 +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCACAACAACAACAACAACAACAAAAAAAAAAAAAAAAAAAA 0 2 91 26 +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCACAACAACAACAACAACAACAACAAAAAAAAAAAAAAAAA 0 2 91 0 +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCACAACAACAACAACAACAACAACAACAAAAAAAAAAAAAA 0 2 91 0 +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCACAACAACAACAACAACAACAACAACAACAAAAAAAAAAA 0 2 91 0 +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCACAACAACAACAACAACAACAACAACAACAACAAAAAAAA 0 2 91 0 +CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCACAACAACAACAACAACAACAACAACAACAACAACAAAAA 0 2 91 0 +AAAAA 0 -2 1 0 +AAAAAAAAAAAAAAA 0 -2 1 0 +AAAAAAAAAAAAAAAAAAA 0 -2 1 0 +AAAAAAAAAAAAAAAAAAAA 0 -2 1 20 +AAAAAAAAAAAAAAAAAAAAA 0 -2 1 21 +AAAAAAAAAAAAAAAAAAAAAAAAA 0 -2 1 25 +AAGCAGTGGTATCAACGCAGAGTACATGGGTCCTGTAGTGTGAAATCTCTGAAGCGCTATGCTGGGTCAGCACTCATCTTGAAAAAAAAAA 30 30 30 0 +AAGCAGTGGTATCAACGCAGAGTACATGGGGCCAACAGACATAGCGTAATTATATCAGATCCATCGAAAAAAAAAAAAAAAAAAAAAAAAA 30 30 30 25 +AAGCAGTGGTATCAACGCAGAGTACATGGGGCGAAAAGATGCGCGCTAATGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA 30 30 30 44