extended_htslib/bam/
ext.rs

1//* Copyright 2019 Johannes Köster and Florian Finkernagel, 
2// Copyright 2025 Guilhem Zeitoun.
3// Licensed under the MIT license (http://opensource.org/licenses/MIT)
4// This file may not be copied, modified, or distributed
5// except according to those terms.
6
7// Extensions for BAM records beyond htslib */
8use bio_types::genome::AbstractInterval;
9
10use crate::bam;
11use crate::bam::record::Cigar;
12use crate::htslib;
13use std::borrow::Cow;
14use std::collections::{BTreeMap, HashMap};
15
16use std::convert::TryInto;
17use std::ops::{Range, RangeBounds, RangeInclusive};
18#[derive(Debug, Clone, Copy)]
19pub struct MovingPos {
20    fakepos: i64,
21    isvalid: bool
22}
23impl MovingPos {
24    fn new(pos: i64, isvalid: bool) -> Self {
25        MovingPos {
26            fakepos: pos,
27            isvalid
28        }
29    }
30}
31#[derive(Debug, Clone)]
32pub struct CsData {
33    ///Get the genome align position
34    pub genome_pos: MovingPos,
35    //Get the read align position
36    pub read_pos: MovingPos,
37    //Get CS value
38    pub state: CsValue,
39    //Get sequence if existing else None
40    pub sequence: SeqPos,
41}
42impl CsData {
43    //Get genome pos or none if not existing
44    pub fn getgenomepos(&self) -> Option<i64> {
45        match self.genome_pos.isvalid {
46            true => Some(self.genome_pos.fakepos),
47            false => None
48        }
49    }
50    //Get genome pos or the genomic position nefore
51    pub fn getgenomepos_zero(&self) -> i64 {
52        self.genome_pos.fakepos
53    }
54    //Get read pos or none if not existing
55    pub fn getreadpos(&self) -> Option<i64> {
56        match self.read_pos.isvalid {
57            true => Some(self.read_pos.fakepos),
58            false => None
59        }
60    }
61    //Get read pos or or the read position nefore
62    pub fn getreadpos_zero(&self) -> i64 {
63        self.read_pos.fakepos
64    }
65    fn new(genome_pos: (i64,bool), read_pos: (i64,bool), state: CsValue, sequence: SeqPos) -> Self {
66        CsData {
67            genome_pos: MovingPos::new(genome_pos.0,genome_pos.1),
68            read_pos: MovingPos::new(read_pos.0,read_pos.1),
69            state,
70            sequence,
71        }
72    }
73}
74#[derive(Debug, Clone)]
75pub struct SeqPos {
76    ///Get genomic sequence, None if not available
77    genome_seq: Option<String>,
78    ///Get read sequence, None if not available
79    read_seq: Option<String>,
80}
81impl SeqPos {
82    //Check genome seq is equal to given seq (None == None)
83    pub fn genomematch<T>(&self, genome_match: Option<T>) -> bool where T: AsRef<str> {
84        match (&self.genome_seq,genome_match) {
85            (Some(d),Some(q)) if d.to_lowercase()==q.as_ref().to_lowercase() => true,
86            (None,None) => true,
87            _ => false
88        }
89    }
90    //Check read seq is equal to given seq (None == None)
91    pub fn readmatch<T>(&self, read_match: Option<T>) -> bool where T: AsRef<str> {
92        match (&self.read_seq,read_match) {
93            (Some(d),Some(q)) if d.to_lowercase()==q.as_ref().to_lowercase() => true,
94            (None,None) => true,
95            _ => false
96        }
97    }
98}
99pub struct CgAlignedBlockPairs {
100    //Contig name, use getcontig()
101    pub contig: Vec<u8>,
102    //Starting position in the genome, 0-based
103    pub genome_pos: i64,
104    //Length of the alignment
105    pub genomelen: usize,
106    cs_index: usize,
107    csdata: Vec<CsData>,
108}
109impl CgAlignedBlockPairs {
110    ///Get contig name
111    pub fn getcontig(&self) -> &[u8] {
112        &self.contig
113    }
114    ///Restrict Cgblocks to a specific region
115    pub fn restrict<T>(&mut self, contig: &[u8], range: T)
116    where
117        T: RangeBounds<usize>,
118    {
119        if self.contig != contig || !range.contains(&self.genome_pos.try_into().unwrap()) {
120            self.csdata.clear();
121            return;
122        }
123        let new = self
124            .filter(|p| range.contains(&p.getgenomepos_zero().try_into().unwrap()))
125            .collect();
126        self.csdata = new;
127    }
128}
129impl Iterator for CgAlignedBlockPairs {
130    type Item = CsData;
131
132    fn next(&mut self) -> Option<Self::Item> {
133        match self.csdata.get(self.cs_index) {
134            Some(value) => {
135                self.cs_index += 1;
136                Some(value.clone())
137            }
138            None => None,
139        }
140    }
141}
142///Value of CS tag
143#[derive(Clone, Debug, PartialEq, Eq)]
144pub enum CsValue {
145    //Equal base
146    Same(usize),
147    //One substitution
148    Substitution,
149    //Insertion
150    Insertion(usize),
151    //Deletion
152    Deletion(usize),
153    //Intron
154    Intron(usize),
155}
156impl std::fmt::Display for CsValue {
157    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
158        match self {
159            CsValue::Same(_) => write!(f, "="),
160            CsValue::Substitution => write!(f, "!"),
161            CsValue::Insertion(_) => write!(f, "+"),
162            CsValue::Deletion(_) => write!(f, "-"),
163            CsValue::Intron(_) => write!(f, "I"),
164        }
165    }
166}
167impl CsValue {
168    pub fn issame(&self) -> bool {
169        matches!(self, CsValue::Same(_))
170    }
171    pub fn isubstitution(&self) -> bool {
172        self == &CsValue::Substitution
173    }
174    pub fn isinsertion(&self) -> bool {
175        matches!(self, CsValue::Insertion(_))
176    }
177    pub fn isdeletion(&self) -> bool {
178        matches!(self, CsValue::Deletion(_))
179    }
180    fn getlength(&self) -> usize {
181        match self {
182            CsValue::Intron(d) => d + 4,
183            CsValue::Deletion(d) | CsValue::Same(d) | CsValue::Insertion(d) => *d,
184            CsValue::Substitution => 1,
185        }
186    }
187    pub fn isintron(&self) -> bool {
188        matches!(self, CsValue::Intron(_))
189    }
190}
191impl CsValue {
192    //Value is the symbol and valtocheck is the value associated
193    pub fn new<T>(
194        value: char,
195        valtocheck: T,
196    ) -> Result<(Option<String>, CsValue), crate::bam::Error>
197    where
198        T: AsRef<str>,
199    {
200        let valtocheck = valtocheck.as_ref();
201        match value {
202            '=' | ':' => {
203                match valtocheck.parse::<usize>() {
204                    Ok(d) => Ok((None, CsValue::Same(d))),
205                    Err(_) => {
206                        //Long form
207                        let seq = Some(String::from(valtocheck));
208                        let length = valtocheck.len();
209                        Ok((seq, CsValue::Same(length)))
210                    }
211                }
212            }
213            id @ ('-' | '+' | '*') => {
214                let seq = Some(String::from(valtocheck));
215                let length = valtocheck.len();
216                let state = match id {
217                    '-' => CsValue::Deletion(length),
218                    '+' => CsValue::Insertion(length),
219                    '*' => CsValue::Substitution,
220                    _ => todo!(),
221                };
222                Ok((seq, state))
223            }
224            '~' => {
225                if valtocheck.len() <= 5 {
226                    panic!("Invalid CS tag");
227                }
228                let seq = &valtocheck[..2];
229                let seq2 = &valtocheck[valtocheck.len() - 2..];
230                let mut intron = String::from(seq);
231                intron.push_str(seq2);
232                let ilength = &valtocheck[2..valtocheck.len() - 2];
233                let ilength = match ilength.parse::<usize>() {
234                    Ok(d) => d,
235                    Err(_) => {
236                        panic!("Invalid CS tag")
237                    }
238                };
239                Ok((Some(intron), CsValue::Intron(ilength)))
240            }
241            _ => Err(crate::bam::Error::BamAuxParsingError),
242        }
243    }
244}
245impl CgAlignedBlockPairs {
246    fn increasecounting(mut genome_pos: i64, mut query_pos: i64, state: &CsValue) -> (i64, i64) {
247        match state {
248            CsValue::Same(_) | CsValue::Intron(_) => {
249                genome_pos += state.getlength() as i64;
250                query_pos += state.getlength() as i64;
251                (genome_pos, query_pos)
252            }
253            CsValue::Deletion(_) => {
254                genome_pos += state.getlength() as i64;
255                (genome_pos, query_pos)
256            }
257            CsValue::Insertion(_) => {
258                query_pos += state.getlength() as i64;
259                (genome_pos, query_pos)
260            }
261            CsValue::Substitution => {
262                genome_pos += 1;
263                query_pos += 1;
264                (genome_pos, query_pos)
265            }
266        }
267    }
268    fn createfromcs<T>(csstring: T, contig: Vec<u8>, old_genome_pos: i64) -> Self
269    where
270        T: AsRef<str>,
271    {
272        let (mut genome_pos, mut query_pos) = (old_genome_pos, 0);
273        let csstring = csstring.as_ref();
274        let isnotalphanum = |p: char| !p.is_alphanumeric();
275        if !csstring.starts_with(isnotalphanum) {
276            panic!("CS tag starts with an alphanumeric char");
277        }
278        let s_reversed = csstring.chars().rev().collect::<String>();
279        let blocks = s_reversed
280            .split_inclusive(isnotalphanum)
281            // reverse each block in the iterator...
282            .map(|block| block.chars().rev().collect::<String>())
283            // and then reverse the whole iterator
284            .rev();
285        let mut list = Vec::new();
286        for block in blocks {
287            let block = block.trim();
288            if block.is_empty() {
289                panic!("Invalid CS tag");
290            }
291            let element = block.split_at(1);
292            let value = element.0.chars().next().unwrap();
293            let valtocheck = element.1;
294            let (seq, state) = CsValue::new(value, valtocheck).unwrap();
295            let (seq1, seq2) = match state {
296                CsValue::Substitution => {
297                    let twoseq = seq.as_ref().unwrap().split_at(1);
298                    (Some(String::from(twoseq.0)), Some(String::from(twoseq.1)))
299                }
300                CsValue::Same(_) => match seq {
301                    None => (None, None),
302                    Some(d) => (Some(d.clone()), Some(d.clone())),
303                },
304                CsValue::Deletion(_) => {
305                    let seq = seq.as_ref().unwrap();
306                    (None, Some(seq.clone()))
307                }
308                CsValue::Insertion(_) | CsValue::Intron(_) => {
309                    let seq = seq.as_ref().unwrap();
310                    (Some(seq.clone()), None)
311                }
312            };
313            let seq = SeqPos {
314                genome_seq: seq1,
315                read_seq: seq2,
316            };
317            let genome_bool = !matches!(state,CsValue::Insertion(_));
318            let read_bool = !matches!(state,CsValue::Deletion(_));
319            let elem = CsData::new((genome_pos,genome_bool), (query_pos,read_bool), state.clone(), seq);
320            (genome_pos, query_pos) = Self::increasecounting(genome_pos, query_pos, &state);
321            list.push(elem);
322        }
323        CgAlignedBlockPairs {
324            contig,
325            genome_pos: old_genome_pos,
326            genomelen: std::convert::TryInto::<usize>::try_into(genome_pos - old_genome_pos + 1)
327                .unwrap(),
328            cs_index: 0,
329            csdata: list,
330        }
331    }
332    fn createfrommdtag<T>(
333        md: T,
334        seq: T,
335        cigar: &[Cigar],
336        line: T,
337        long_cs: bool,
338        contig: Vec<u8>,
339        genome_pos: i64,
340    ) -> Result<Self, bam::Error>
341    where
342        T: AsRef<str>,
343    {
344        let mut cs = String::new();
345        let (md, seq, line) = (
346            md.as_ref().trim(),
347            seq.as_ref().trim(),
348            line.as_ref().trim(),
349        );
350        if md.is_empty() || seq.is_empty() || cigar.is_empty() {
351            //TODO: Secondary alignments does not have sequence
352            eprintln!("at line {}: Invalid MD, SEQ or cigar tag", line);
353            return Err(bam::Error::BamInvalidRecord);
354        }
355        let mut cx = 0;
356        let mut cy = 0;
357        let mut k = 0;
358        let mut mx = 0;
359        let mut my: usize = 0; // cx: cigar ref position; cy: cigar query; mx: MD ref; my: MD query
360        let re_md = regex::Regex::new(r"(\d+)|(\^[A-Za-z]+)|([A-Za-z])").unwrap(); // Replace with actual regex pattern
361        let captures = re_md.captures_iter(md);
362        for m in captures {
363            if let Some(deletion) = m.get(2) {
364                // deletion from the reference
365                let deletionstring = &deletion.as_str()[1..];
366                let len = deletionstring.len();
367                cs.push('-');
368                cs.push_str(deletionstring);
369                mx += len;
370                cx += len;
371                k += 1;
372            } else {
373                // copy or mismatch
374                let mut ml = m.get(1).map_or(1, |m| m.as_str().parse::<usize>().unwrap());
375                while let Some(elem) = cigar.get(k) {
376                    match elem {
377                        Cigar::Del(_) => break, //Don't take deletions
378                        Cigar::Equal(cl) | Cigar::Diff(cl) | Cigar::Match(cl) => {
379                            let cl: usize = (*cl).try_into().unwrap();
380                            if my + ml < cy + cl {
381                                if ml > 0 {
382                                    if let Some(m3) = m.get(3) {
383                                        cs.push('*');
384                                        cs.push_str(m3.as_str());
385                                        let mut seqc = seq.char_indices();
386                                        let (start, _) = seqc.nth(my).unwrap();
387                                        let (end, _) = seqc.next().unwrap();
388                                        cs.push_str(&seq[start..end]);
389                                    } else if long_cs {
390                                        cs.push('=');
391                                        let mut seqc = seq.char_indices();
392                                        let (start, _) = seqc.nth(my).unwrap();
393                                        let (end, _) = seqc.nth(ml - 1).unwrap();
394                                        cs.push_str(&seq[start..end]);
395                                    } else {
396                                        cs.push(':');
397                                        cs.push_str(&ml.to_string());
398                                    }
399                                }
400                                mx += ml;
401                                my += ml;
402                                ml = 0;
403                                break;
404                            } else {
405                                let dl = (cy + cl)
406                                    .checked_sub(my)
407                                    .unwrap_or_else(|| panic!("{}/{}/{} are invalid", cy, cl, my));
408                                if long_cs {
409                                    cs.push('=');
410                                    let mut seqc = seq.char_indices();
411                                    let (start, _) = seqc.nth(my).unwrap();
412                                    let seqc2 = seqc.clone();
413                                    let (end, _) = if dl - 1 != seqc2.count() {
414                                        seqc.nth(dl - 1).unwrap_or_else(|| {
415                                            panic!("Wanted {}/{}/{}", start, my, dl - 1)
416                                        })
417                                    } else {
418                                        let mut elem = seqc.last().unwrap();
419                                        elem.0 += 1;
420                                        elem
421                                    };
422                                    cs.push_str(&seq[start..end]);
423                                } else {
424                                    cs.push(':');
425                                    cs.push_str(&dl.to_string());
426                                }
427                                cx += cl;
428                                cy += cl;
429                                mx += dl;
430                                my += dl;
431                                ml = ml
432                                    .checked_sub(dl)
433                                    .unwrap_or_else(|| panic!("{}/{} are invalid", ml, dl));
434                            }
435                        }
436                        Cigar::Ins(cl) => {
437                            let cl: usize = (*cl).try_into().unwrap();
438                            cs.push('+');
439                            let mut seqc = seq.char_indices();
440                            let (start, _) = seqc.nth(cy).unwrap();
441                            let seqc2 = seqc.clone();
442                            let (end, _) = if cl - 1 != seqc2.count() {
443                                seqc.nth(cl - 1)
444                                    .unwrap_or_else(|| panic!("Wanted {}/{}/{}", start, my, cl - 1))
445                            } else {
446                                let mut elem = seqc.last().unwrap();
447                                elem.0 += 1;
448                                elem
449                            };
450                            cs.push_str(&seq[start..end]);
451                            cy += cl;
452                            my += cl;
453                        }
454                        Cigar::SoftClip(cl) => {
455                            let cl: usize = (*cl).try_into().unwrap();
456                            cy += cl;
457                            my += cl;
458                        }
459                        Cigar::RefSkip(cl) => {
460                            let cl: usize = (*cl).try_into().unwrap();
461                            cx += cl;
462                            mx += cl;
463                        }
464                        Cigar::HardClip(_) | Cigar::Pad(_) => (),
465                    }
466                    k += 1;
467                }
468                if ml != 0 {
469                    panic!("at line {}: inconsistent MD tag", line);
470                }
471            }
472        }
473        if cx != mx || cy != my {
474            panic!("at line {}: inconsistent MD tag", line);
475        }
476        Ok(Self::createfromcs(cs, contig, genome_pos))
477    }
478}
479pub trait MatchIter {
480    ///Only print matched bases?
481    fn ismatchonly(&self) -> bool;
482    ///Set match state
483    fn setmatchstate(&mut self, matchs: bool);
484}
485pub struct IterAlignedBlockPairs {
486    genome_pos: i64,
487    read_pos: i64,
488    cigar_index: usize,
489    cigar: Vec<Cigar>,
490    r#match: bool,
491}
492impl MatchIter for IterAlignedBlockPairs {
493    fn ismatchonly(&self) -> bool {
494        self.r#match
495    }
496
497    fn setmatchstate(&mut self, matchs: bool) {
498        self.r#match = matchs;
499    }
500}
501impl Iterator for IterAlignedBlockPairs {
502    type Item = ([i64; 2], [i64; 2]);
503    fn next(&mut self) -> Option<Self::Item> {
504        while self.cigar_index < self.cigar.len() {
505            let entry = self.cigar[self.cigar_index];
506            match entry {
507                Cigar::Match(len) | Cigar::Equal(len) | Cigar::Diff(len) => {
508                    let qstart = self.read_pos;
509                    let qend = qstart + len as i64;
510                    let rstart = self.genome_pos;
511                    let rend = self.genome_pos + len as i64;
512                    self.read_pos += len as i64;
513                    self.genome_pos += len as i64;
514                    #[allow(clippy::nonminimal_bool)]
515                    if (self.r#match && matches!(entry, Cigar::Equal(_))) || !self.r#match {
516                        self.cigar_index += 1;
517                        return Some(([qstart, qend], [rstart, rend]));
518                    }
519                }
520                Cigar::Ins(len) | Cigar::SoftClip(len) => {
521                    self.read_pos += len as i64;
522                }
523                Cigar::Del(len) | Cigar::RefSkip(len) => {
524                    self.genome_pos += len as i64;
525                }
526                Cigar::HardClip(_) => {} // no advance
527                Cigar::Pad(_) => panic!("Padding (Cigar::Pad) is not supported."), //padding is only used for multiple sequence alignment
528            }
529            self.cigar_index += 1;
530        }
531        None
532    }
533}
534#[derive(Ord, PartialOrd, Eq, PartialEq, Debug, Copy, Clone)]
535pub struct RangePos {
536    pub start: i64,
537    pub end: i64,
538}
539impl RangePos {
540    pub fn getrange(&self) -> Range<i64> {
541        self.start..self.end
542    }
543    pub fn start(&self) -> i64 {
544        self.start
545    }
546    pub fn end(&self) -> i64 {
547        self.end
548    }
549    fn new(start: i64, end: i64) -> Self {
550        let (start,end) = match start.cmp(&end) {
551            std::cmp::Ordering::Greater => (end,start),
552            _ => (start,end)
553        };
554        RangePos {
555            start,
556            end
557        }
558    }
559}
560/// Matching sequence, return a genomic range and associated sequence
561/// ```
562/// use extended_htslib::bam::ext::MatchSequence;
563/// let test = MatchSequence::default();
564/// for (range, sequence) in test.gethash() {
565///     println!("SEQ: {} for {}-{}",sequence,range.start,range.end);
566/// }
567/// ```
568pub struct MatchSequence {
569    pub hash: BTreeMap<RangePos, String>,
570}
571impl MatchSequence {
572    pub fn new(range: RangePos, text: String) -> Self {
573        let mut map = BTreeMap::new();
574        map.insert(range, text);
575        MatchSequence { hash: map }
576    }
577    pub fn gethash(&self) -> &BTreeMap<RangePos, String> {
578        &self.hash
579    }
580    ///Check if a range of genomic position is completely aligned with the read. Return the sequence if yes else return None
581    pub fn isfullymatched(&self, range: RangeInclusive<i64>) -> Option<String> {
582        let mut vec = self.hash.iter();
583        vec.find_map(|(a, b)| {
584            if a.getrange().contains(range.start()) && a.getrange().contains(range.end()) {
585                Some(b.clone())
586            } else {
587                None
588            }
589        })
590    }
591}
592impl Default for MatchSequence {
593    fn default() -> Self {
594        let default = String::new();
595        let range = RangePos { start: 1, end: 1 };
596        Self::new(range, default)
597    }
598}
599pub struct IterAlignedBlocks {
600    pos: i64,
601    cigar_index: usize,
602    cigar: Vec<Cigar>,
603    r#match: bool,
604}
605impl MatchIter for IterAlignedBlocks {
606    fn ismatchonly(&self) -> bool {
607        self.r#match
608    }
609
610    fn setmatchstate(&mut self, matchs: bool) {
611        self.r#match = matchs;
612    }
613}
614impl Iterator for IterAlignedBlocks {
615    type Item = [i64; 2];
616    fn next(&mut self) -> Option<Self::Item> {
617        while self.cigar_index < self.cigar.len() {
618            let entry = self.cigar[self.cigar_index];
619            match entry {
620                Cigar::Match(len) | Cigar::Equal(len) | Cigar::Diff(len) => {
621                    let out_pos = self.pos;
622                    //result.push([pos, pos + *len as i64]);
623                    self.pos += len as i64;
624                    #[allow(clippy::nonminimal_bool)]
625                    if (self.r#match && matches!(entry, Cigar::Equal(_))) || !self.r#match {
626                        self.cigar_index += 1;
627                        return Some([out_pos, out_pos + len as i64]);
628                    }
629                }
630                Cigar::Del(len) => self.pos += len as i64,
631                Cigar::RefSkip(len) => self.pos += len as i64,
632                _ => (),
633            }
634            self.cigar_index += 1;
635        }
636        None
637    }
638}
639
640pub struct IterIntrons {
641    pos: i64,
642    cigar_index: usize,
643    cigar: Vec<Cigar>,
644}
645
646impl Iterator for IterIntrons {
647    type Item = [i64; 2];
648    fn next(&mut self) -> Option<Self::Item> {
649        while self.cigar_index < self.cigar.len() {
650            let entry = self.cigar[self.cigar_index];
651            match entry {
652                Cigar::Match(len) | Cigar::Equal(len) | Cigar::Diff(len) | Cigar::Del(len) => {
653                    self.pos += len as i64
654                }
655                Cigar::RefSkip(len) => {
656                    let junc_start = self.pos;
657                    self.pos += len as i64;
658                    self.cigar_index += 1;
659                    return Some([junc_start, self.pos]); //self.pos is  junc_start + len
660                }
661                _ => {}
662            }
663            self.cigar_index += 1;
664        }
665        None
666    }
667}
668
669pub struct IterAlignedPairs {
670    genome_pos: i64,
671    read_pos: i64,
672    cigar: Vec<Cigar>,
673    remaining_match_bp: u32,
674    cigar_index: usize,
675    r#match: bool,
676}
677impl MatchIter for IterAlignedPairs {
678    fn ismatchonly(&self) -> bool {
679        self.r#match
680    }
681
682    fn setmatchstate(&mut self, matchs: bool) {
683        self.r#match = matchs;
684    }
685}
686impl Iterator for IterAlignedPairs {
687    type Item = [i64; 2];
688    fn next(&mut self) -> Option<Self::Item> {
689        if self.remaining_match_bp > 0 {
690            self.remaining_match_bp -= 1;
691            self.genome_pos += 1;
692            self.read_pos += 1;
693            return Some([self.read_pos - 1, self.genome_pos - 1]);
694        }
695
696        while self.cigar_index < self.cigar.len() {
697            let entry = self.cigar[self.cigar_index];
698            match entry {
699                Cigar::Match(len) | Cigar::Equal(len) | Cigar::Diff(len) => {
700                    self.genome_pos += 1;
701                    self.read_pos += 1;
702                    self.remaining_match_bp = len - 1;
703                    #[allow(clippy::nonminimal_bool)]
704                    if (self.r#match && matches!(entry, Cigar::Equal(_))) || !self.r#match {
705                        self.cigar_index += 1;
706                        return Some([self.read_pos - 1, self.genome_pos - 1]);
707                    }
708                }
709                Cigar::Ins(len) | Cigar::SoftClip(len) => {
710                    self.read_pos += len as i64;
711                }
712                Cigar::Del(len) | Cigar::RefSkip(len) => {
713                    self.genome_pos += len as i64;
714                }
715                Cigar::HardClip(_) => {} // no advance
716                Cigar::Pad(_) => panic!("Padding (Cigar::Pad) is not supported."), //padding is only used for multiple sequence alignment
717            }
718            self.cigar_index += 1;
719        }
720        None
721    }
722}
723
724pub struct IterAlignedPairsFull {
725    genome_pos: i64,
726    read_pos: i64,
727    cigar: Vec<Cigar>,
728    remaining_match_bp: u32,
729    remaining_ins_bp: u32,
730    remaining_del_bp: u32,
731    cigar_index: usize,
732}
733
734impl Iterator for IterAlignedPairsFull {
735    type Item = (Option<i64>, Option<i64>, Cigar);
736    fn next(&mut self) -> Option<Self::Item> {
737        let cigar = self.cigar[self.cigar_index.saturating_sub(1)];
738        if self.remaining_match_bp > 0 {
739            self.remaining_match_bp -= 1;
740            self.genome_pos += 1;
741            self.read_pos += 1;
742            return Some((Some(self.read_pos - 1), Some(self.genome_pos - 1), cigar));
743        }
744        if self.remaining_ins_bp > 0 {
745            self.remaining_ins_bp -= 1;
746            self.read_pos += 1;
747            return Some((Some(self.read_pos - 1), None, cigar));
748        }
749        if self.remaining_del_bp > 0 {
750            self.remaining_del_bp -= 1;
751            self.genome_pos += 1;
752            return Some((None, Some(self.genome_pos - 1), cigar));
753        }
754        while self.cigar_index < self.cigar.len() {
755            let entry = self.cigar[self.cigar_index];
756            match entry {
757                Cigar::Match(len) | Cigar::Equal(len) | Cigar::Diff(len) => {
758                    self.genome_pos += 1;
759                    self.read_pos += 1;
760                    self.remaining_match_bp = len - 1;
761                    self.cigar_index += 1;
762                    return Some((Some(self.read_pos - 1), Some(self.genome_pos - 1), entry));
763                }
764                Cigar::Ins(len) | Cigar::SoftClip(len) => {
765                    self.read_pos += 1;
766                    self.remaining_ins_bp = len - 1;
767                    self.cigar_index += 1;
768                    return Some((Some(self.read_pos - 1), None, entry));
769                }
770                Cigar::Del(len) | Cigar::RefSkip(len) => {
771                    self.genome_pos += 1;
772                    self.remaining_del_bp = len - 1;
773                    self.cigar_index += 1;
774                    return Some((None, Some(self.genome_pos - 1), entry));
775                }
776                Cigar::HardClip(_) => {
777                    // no advance
778                }
779                Cigar::Pad(_) => panic!("Padding (Cigar::Pad) is not supported."), //padding is only used for multiple sequence alignment
780            }
781            self.cigar_index += 1;
782        }
783        None
784    }
785}
786
787/// Extra functionality for BAM records
788///
789/// Inspired by pysam
790pub trait BamRecordExtensions {
791    /// iterator over start and end positions with the sequence of matched
792    /// blocks.
793    /// Return None if CIGAR does not contain any = or sequence is not present.
794    fn matched_sequence(&self) -> Option<MatchSequence>;
795    /// iterator over start and end positions of aligned gapless blocks
796    ///
797    /// The start and end positions are in genomic coordinates.
798    /// There is not necessarily a gap between blocks on the genome,
799    /// this happens on insertions.
800    ///
801    /// pysam: blocks
802    /// See also: [aligned_block_pairs](#tymethod.aligned_block_pairs) if you need
803    /// the read coordinates as well.
804    fn aligned_blocks(&self) -> IterAlignedBlocks;
805    /// iterator over start and end positions of aligned matched blocks.
806    /// Return None if CIGAR does not contain any = or sequence is not present.
807    ///
808    /// The start and end positions are in genomic coordinates.
809    /// There is not necessarily a gap between blocks on the genome,
810    /// this happens on insertions.
811    ///
812    fn aligned_blocks_match(&self) -> Option<IterAlignedBlocks>;
813    ///Iter over <([read_start, read_stop], [genome_start, genome_stop]) blocks
814    ///of continously aligned reads.
815    ///
816    ///In contrast to [aligned_blocks](#tymethod.aligned_blocks), this returns
817    ///read and genome coordinates.
818    ///In contrast to aligned_pairs, this returns just the start-stop
819    ///coordinates of each block.
820    ///
821    ///There is not necessarily a gap between blocks in either coordinate space
822    ///(this happens in in-dels).
823    fn aligned_block_pairs(&self) -> IterAlignedBlockPairs;
824    ///Iter over <([read_start, read_stop], [genome_start, genome_stop]) blocks
825    ///of continously matched reads.
826    /// Return None if CIGAR does not contain any = or sequence is not present.
827    ///
828    ///In contrast to [aligned_blocks](#tymethod.aligned_blocks), this returns
829    ///read and genome coordinates.
830    ///In contrast to aligned_pairs, this returns just the start-stop
831    ///coordinates of each block.
832    ///
833    ///There is not necessarily a gap between blocks in either coordinate space
834    ///(this happens in in-dels).
835    fn aligned_block_pairs_match(&self) -> Option<IterAlignedBlockPairs>;
836    /// This scans the CIGAR for reference skips
837    /// and reports their positions.
838    /// It does not inspect the reported regions
839    /// for actual splice sites.
840    /// pysam: get_introns
841    fn introns(&self) -> IterIntrons;
842    /// iter aligned read and reference positions on a basepair level
843    ///
844    /// Return None if CIGAR does not contain any = or sequence is not present.
845    /// 
846    /// No entry for mismatches, insertions, deletions or skipped pairs
847    ///
848    /// pysam: get_aligned_pairs(matches_only = True) but only matched bases
849    ///
850    /// See also [aligned_block_pairs](#tymethod.aligned_block_pairs)
851    /// if you just need start&end coordinates of each block.
852    /// That way you can allocate less memory for the same
853    /// informational content.
854    fn aligned_pairs_match(&self) -> Option<IterAlignedPairs>;
855    /// iter aligned read and reference positions on a basepair level
856    ///
857    /// No entry for insertions, deletions or skipped pairs
858    ///
859    /// pysam: get_aligned_pairs(matches_only = True)
860    ///
861    /// See also [aligned_block_pairs](#tymethod.aligned_block_pairs)
862    /// if you just need start&end coordinates of each block.
863    /// That way you can allocate less memory for the same
864    /// informational content.
865    fn aligned_pairs(&self) -> IterAlignedPairs;
866
867    /// iter list of read and reference positions on a basepair level with cigar.
868    ///
869    /// Unlike `aligned_pairs` this returns None in
870    /// either the read positions or the reference position
871    /// for insertions, deletions or skipped pairs
872    ///
873    /// pysam: aligned_pairs(matches_only = False) + cigar. For compatibility call .map(|p| [p.0,p.1]) on the result
874    fn aligned_pairs_full(&self) -> IterAlignedPairsFull;
875
876    /// the number of nucleotides covered by each Cigar::* variant.
877    ///
878    /// Result is a Hashmap Cigar::*(0) => covered nucleotides
879    ///
880    /// pysam: first result from get_cigar_stats
881    fn cigar_stats_nucleotides(&self) -> HashMap<Cigar, i32>;
882
883    /// the number of occurrences of each each Cigar::* variant
884    ///
885    /// Result is a Hashmap Cigar::*(0) => number of times this Cigar::
886    /// appeared
887    ///
888    /// pysam: second result from get_cigar_stats
889    fn cigar_stats_blocks(&self) -> HashMap<Cigar, i32>;
890
891    /// iter over  reference positions that this read aligns to
892    ///
893    /// only returns positions that are aligned, excluding any soft-clipped
894    /// or unaligned positions within the read
895    ///
896    /// pysam: get_reference_positions(full_length=False)
897    fn reference_positions(&self) -> Box<dyn Iterator<Item = i64>>;
898    /// iter over reference positions that this read aligns to
899    ///
900    /// only returns positions that are matched, excluding any soft-clipped
901    /// or mismatched positions, unaligned positions within the read. Return None if cigar has no =
902    ///
903    /// pysam: get_reference_positions(full_length=False)
904    fn reference_positions_match(&self) -> Option<Box<dyn Iterator<Item = i64>>>;
905    ///
906    /// iter over reference positions that this read aligns to
907    ///
908    /// include soft-clipped or skipped positions as None
909    ///
910    /// pysam: get_reference_positions(full_length=True)
911    fn reference_positions_full(&self) -> Box<dyn Iterator<Item = Option<i64>>>;
912
913    /// left most aligned reference position of the read on the reference genome.
914    fn reference_start(&self) -> i64;
915
916    /// right most aligned reference position of the read on the reference genome.
917    fn reference_end(&self) -> i64;
918
919    /// infer the query length from the cigar string, optionally include hard clipped bases
920    ///
921    /// Contrast with record::seq_len which returns the length of the sequence stored
922    /// in the BAM file, and as such is 0 if the BAM file omits sequences
923    ///
924    /// pysam: infer_query_length / infer_read_length
925    fn seq_len_from_cigar(&self, include_hard_clip: bool) -> usize;
926    /// Get CS tag and perfect match alignment from BAM, try to use MD if existing else None if extension does not exist
927    fn getcsaligned(&self) -> Option<CgAlignedBlockPairs>;
928}
929fn strandseq(input: &mut Cow<str>) {
930    *input = Cow::Owned(
931        input
932            .replace("a", "x")
933            .replace("t", "a")
934            .replace("x", "t")
935            .replace("c", "x")
936            .replace("g", "c")
937            .replace("x", "g"),
938    );
939}
940fn checkcigarmatchvalid(info: &bam::Record) -> bool {
941    info.cigar_stats_blocks()
942        .into_iter()
943        .filter_map(|(cigar, count)| match cigar {
944            Cigar::Equal(_) | Cigar::Diff(_) => Some(count),
945            _ => None,
946        })
947        .sum::<i32>()
948        > 0
949}
950impl BamRecordExtensions for bam::Record {
951    fn matched_sequence(&self) -> Option<MatchSequence> {
952        let aligned = self.aligned_block_pairs_match()?;
953        let sequence = self.seq();
954        if sequence.is_empty() {
955            return None;
956        }
957        let mut hash = BTreeMap::new();
958        for ([rstart, rend], [gstart, gend]) in aligned {
959            let (rstart, rend) = (rstart.try_into().unwrap(), rend.try_into().unwrap());
960            let mut sequence = sequence.rangeextract(rstart..rend).unwrap();
961            if self.is_reverse() {
962                strandseq(&mut sequence);
963            }
964            hash.insert(
965                RangePos {
966                    start: gstart,
967                    end: gend,
968                },
969                sequence.to_string(),
970            );
971        }
972        Some(MatchSequence { hash })
973    }
974    fn aligned_blocks(&self) -> IterAlignedBlocks {
975        IterAlignedBlocks {
976            pos: self.pos(),
977            cigar: self.cigar().take().0,
978            cigar_index: 0,
979            r#match: false,
980        }
981    }
982    fn aligned_blocks_match(&self) -> Option<IterAlignedBlocks> {
983        if !checkcigarmatchvalid(self) {
984            return None;
985        };
986        Some(IterAlignedBlocks {
987            pos: self.pos(),
988            cigar: self.cigar().take().0,
989            cigar_index: 0,
990            r#match: true,
991        })
992    }
993    fn getcsaligned(&self) -> Option<CgAlignedBlockPairs> {
994        let ext = self.aux(b"cs");
995        let answer = match ext {
996            Err(_) => {
997                let ext = self.aux(b"MD");
998                if let Ok(bam::record::Aux::String(d)) = ext {
999                    let line = String::from_utf8_lossy(self.qname());
1000                    let cigar = &self.cigar().0;
1001                    let seq = String::from_utf8(self.seq().as_bytes())
1002                        .unwrap_or_else(|_| panic!("Invalid sequence for {}", line));
1003                    CgAlignedBlockPairs::createfrommdtag(
1004                        d,
1005                        &seq,
1006                        cigar,
1007                        &line,
1008                        true,
1009                        self.contig().as_bytes().to_vec(),
1010                        self.reference_start(),
1011                    )
1012                    .unwrap()
1013                } else {
1014                    return None;
1015                }
1016            }
1017            Ok(d) => {
1018                if let bam::record::Aux::String(data) = d {
1019                    CgAlignedBlockPairs::createfromcs(
1020                        data,
1021                        self.contig().as_bytes().to_vec(),
1022                        self.reference_start(),
1023                    )
1024                } else {
1025                    return None;
1026                }
1027            }
1028        };
1029        Some(answer)
1030    }
1031    fn introns(&self) -> IterIntrons {
1032        IterIntrons {
1033            pos: self.pos(),
1034            cigar: self.cigar().take().0,
1035            cigar_index: 0,
1036        }
1037    }
1038
1039    fn aligned_block_pairs(&self) -> IterAlignedBlockPairs {
1040        IterAlignedBlockPairs {
1041            genome_pos: self.pos(),
1042            read_pos: 0,
1043            cigar: self.cigar().take().0,
1044            cigar_index: 0,
1045            r#match: false,
1046        }
1047    }
1048    fn aligned_block_pairs_match(&self) -> Option<IterAlignedBlockPairs> {
1049        if !checkcigarmatchvalid(self) {
1050            return None;
1051        };
1052        Some(IterAlignedBlockPairs {
1053            genome_pos: self.pos(),
1054            read_pos: 0,
1055            cigar: self.cigar().take().0,
1056            cigar_index: 0,
1057            r#match: true,
1058        })
1059    }
1060    fn aligned_pairs_match(&self) -> Option<IterAlignedPairs> {
1061        if !checkcigarmatchvalid(self) {
1062            return None;
1063        };
1064        Some(IterAlignedPairs {
1065            genome_pos: self.pos(),
1066            read_pos: 0,
1067            cigar: self.cigar().take().0,
1068            remaining_match_bp: 0,
1069            cigar_index: 0,
1070            r#match: true,
1071        })
1072    }
1073    fn aligned_pairs(&self) -> IterAlignedPairs {
1074        IterAlignedPairs {
1075            genome_pos: self.pos(),
1076            read_pos: 0,
1077            cigar: self.cigar().take().0,
1078            remaining_match_bp: 0,
1079            cigar_index: 0,
1080            r#match: false,
1081        }
1082    }
1083
1084    fn aligned_pairs_full(&self) -> IterAlignedPairsFull {
1085        IterAlignedPairsFull {
1086            genome_pos: self.pos(),
1087            read_pos: 0,
1088            cigar: self.cigar().take().0,
1089            remaining_match_bp: 0,
1090            remaining_ins_bp: 0,
1091            remaining_del_bp: 0,
1092            cigar_index: 0,
1093        }
1094    }
1095
1096    fn cigar_stats_nucleotides(&self) -> HashMap<Cigar, i32> {
1097        let mut result = HashMap::new();
1098        result.insert(Cigar::Match(0), 0); // M
1099        result.insert(Cigar::Ins(0), 0); // I
1100        result.insert(Cigar::Del(0), 0); // D
1101        result.insert(Cigar::RefSkip(0), 0); // N
1102        result.insert(Cigar::SoftClip(0), 0); // S
1103        result.insert(Cigar::HardClip(0), 0); // H
1104        result.insert(Cigar::Pad(0), 0); // P
1105        result.insert(Cigar::Equal(0), 0); // =
1106        result.insert(Cigar::Diff(0), 0); // X
1107        for entry in self.cigar().iter() {
1108            match entry {
1109                Cigar::Match(len) => *result.get_mut(&Cigar::Match(0)).unwrap() += *len as i32, // M
1110                Cigar::Ins(len) => *result.get_mut(&Cigar::Ins(0)).unwrap() += *len as i32,     // I
1111                Cigar::Del(len) => *result.get_mut(&Cigar::Del(0)).unwrap() += *len as i32,     // D
1112                Cigar::RefSkip(len) => *result.get_mut(&Cigar::RefSkip(0)).unwrap() += *len as i32, // N
1113                Cigar::SoftClip(len) => {
1114                    *result.get_mut(&Cigar::SoftClip(0)).unwrap() += *len as i32
1115                } // S
1116                Cigar::HardClip(len) => {
1117                    *result.get_mut(&Cigar::HardClip(0)).unwrap() += *len as i32
1118                } // H
1119                Cigar::Pad(len) => *result.get_mut(&Cigar::Pad(0)).unwrap() += *len as i32, // P
1120                Cigar::Equal(len) => *result.get_mut(&Cigar::Equal(0)).unwrap() += *len as i32, // =
1121                Cigar::Diff(len) => *result.get_mut(&Cigar::Diff(0)).unwrap() += *len as i32, // X
1122            }
1123        }
1124        result
1125    }
1126
1127    fn cigar_stats_blocks(&self) -> HashMap<Cigar, i32> {
1128        let mut result = HashMap::new();
1129        result.insert(Cigar::Match(0), 0); // M
1130        result.insert(Cigar::Ins(0), 0); // I
1131        result.insert(Cigar::Del(0), 0); // D
1132        result.insert(Cigar::RefSkip(0), 0); // N
1133        result.insert(Cigar::SoftClip(0), 0); // S
1134        result.insert(Cigar::HardClip(0), 0); // H
1135        result.insert(Cigar::Pad(0), 0); // P
1136        result.insert(Cigar::Equal(0), 0); // =
1137        result.insert(Cigar::Diff(0), 0); // X
1138        for entry in self.cigar().iter() {
1139            match entry {
1140                Cigar::Match(_) => *result.get_mut(&Cigar::Match(0)).unwrap() += 1, // M
1141                Cigar::Ins(_) => *result.get_mut(&Cigar::Ins(0)).unwrap() += 1,     // I
1142                Cigar::Del(_) => *result.get_mut(&Cigar::Del(0)).unwrap() += 1,     // D
1143                Cigar::RefSkip(_) => *result.get_mut(&Cigar::RefSkip(0)).unwrap() += 1, // N
1144                Cigar::SoftClip(_) => *result.get_mut(&Cigar::SoftClip(0)).unwrap() += 1, // S
1145                Cigar::HardClip(_) => *result.get_mut(&Cigar::HardClip(0)).unwrap() += 1, // H
1146                Cigar::Pad(_) => *result.get_mut(&Cigar::Pad(0)).unwrap() += 1,     // P
1147                Cigar::Equal(_) => *result.get_mut(&Cigar::Equal(0)).unwrap() += 1, // =
1148                Cigar::Diff(_) => *result.get_mut(&Cigar::Diff(0)).unwrap() += 1,   // X
1149            }
1150        }
1151        result
1152    }
1153
1154    fn reference_positions(&self) -> Box<dyn Iterator<Item = i64>> {
1155        Box::new(self.aligned_pairs().map(|x| x[1]))
1156    }
1157    fn reference_positions_match(&self) -> Option<Box<dyn Iterator<Item = i64>>> {
1158        match self.aligned_pairs_match() {
1159            Some(b) => Some(Box::new(b.map(|x| x[1]))),
1160            None => None,
1161        }
1162    }
1163    fn reference_positions_full(&self) -> Box<dyn Iterator<Item = Option<i64>>> {
1164        Box::new(
1165            self.aligned_pairs_full()
1166                .filter(|x| x.0.is_some())
1167                .map(|x| x.1),
1168        )
1169    }
1170
1171    fn reference_start(&self) -> i64 {
1172        self.pos()
1173    }
1174
1175    /// Calculate the rightmost base position of an alignment on the reference genome.
1176    /// Returns the coordinate of the first base after the alignment (0-based).
1177    fn reference_end(&self) -> i64 {
1178        unsafe { htslib::bam_endpos(self.inner_ptr()) }
1179    }
1180
1181    fn seq_len_from_cigar(&self, include_hard_clip: bool) -> usize {
1182        let mut result = 0;
1183        for entry in self.cigar().iter() {
1184            match entry {
1185                Cigar::Match(len)
1186                | Cigar::Ins(len)
1187                | Cigar::SoftClip(len)
1188                | Cigar::Equal(len)
1189                | Cigar::Diff(len) => {
1190                    result += len;
1191                }
1192                Cigar::HardClip(len) => {
1193                    if include_hard_clip {
1194                        result += len;
1195                    }
1196                }
1197                _ => {}
1198            }
1199        }
1200        result as usize
1201    }
1202}
1203
1204#[cfg(test)]
1205mod tests {
1206    use crate::bam;
1207    use crate::bam::ext::BamRecordExtensions;
1208    use crate::bam::record::{Cigar, CigarString};
1209    use crate::bam::Read;
1210    use bio_types::genome::AbstractInterval;
1211    use std::collections::HashMap;
1212    use crate::bam::ext::RangePos;
1213    use crate::bam::ext::CsValue;
1214    #[test]
1215    fn testcs() {
1216        let mut read = crate::bam::Reader::from_path("test/locus.bam").unwrap();
1217       let mut element = read.records().filter_map(Result::ok).skip(1).take(1);
1218        let element = element.next().unwrap();
1219        assert_eq!(element.qname(),b"SRR11292120.509914");
1220        assert_eq!(element.contig(),"chr14");
1221        let mut cs = element.getcsaligned().unwrap();
1222        let val = cs.next().unwrap();
1223        assert_eq!(val.getreadpos(),Some(0));
1224        assert_eq!(val.getgenomepos(),Some(99813318));
1225        let val = cs.nth(2).unwrap();
1226        assert_eq!(val.getreadpos(),None);
1227        assert_eq!(val.getgenomepos(),Some(99813465));
1228        assert_eq!(val.state,CsValue::Deletion(1));
1229        assert!(val.sequence.genomematch(None::<&str>));
1230        assert!(val.sequence.readmatch(Some("c")));
1231    }
1232    #[test]
1233    fn testmd() {
1234        let mut read = crate::bam::Reader::from_path("test/locusmd.bam").unwrap();
1235        let mut element = read.records().filter_map(Result::ok).skip(1).take(1);
1236        let element = element.next().unwrap();
1237        assert_eq!(element.qname(),b"SRR11292120.509914");
1238        assert_eq!(element.contig(),"chr14");
1239        let mut cs = element.getcsaligned().unwrap();
1240        let val = cs.next().unwrap();
1241        assert_eq!(val.getreadpos(),Some(0));
1242        assert_eq!(val.getgenomepos(),Some(99813318));
1243        let val = cs.nth(2).unwrap();
1244        assert_eq!(val.getreadpos(),None);
1245        assert_eq!(val.getgenomepos(),Some(99813465));
1246        assert_eq!(val.state,CsValue::Deletion(1));
1247        assert!(val.sequence.genomematch(None::<&str>));
1248        assert!(val.sequence.readmatch(Some("c")));
1249    }
1250    #[test]
1251    fn testcigar() {
1252        let mut read = crate::bam::Reader::from_path("test/locus.bam").unwrap();
1253        let elem = read.records().filter_map(Result::ok).take(1).next().unwrap();
1254        let mut cigar = elem.aligned_pairs_match().unwrap();
1255        let _ = cigar.next();
1256        let align = cigar.next();
1257        assert_eq!(align,Some([1,99812480]));
1258        let align = cigar.nth(40);
1259        assert_eq!(align,Some([43,99812521]));
1260    }
1261    #[test]
1262    fn testblock() {
1263        let mut read = crate::bam::Reader::from_path("test/locus.bam").unwrap();
1264        let elem = read.records().filter_map(Result::ok).nth(3).unwrap();
1265        assert_eq!(elem.qname(),b"SRR11292123.1482913");
1266        assert_eq!(elem.contig(),"chr14");
1267        let mut element = elem.aligned_blocks_match().unwrap();
1268        assert_eq!(element.next(),Some([99814926,99816399]));
1269        assert_eq!(element.next(),Some([99816400,99817131]));
1270        assert_eq!(element.next(),Some([99817132,99830222]));
1271        assert!(element.next().is_none());
1272    }
1273    #[test]
1274    fn testseq() {
1275        let mut read = crate::bam::Reader::from_path("test/locus.bam").unwrap();
1276        let elem = read.records().filter_map(Result::ok).nth(7).unwrap();
1277        let val = elem.matched_sequence().unwrap();
1278        assert!(val.isfullymatched(99820271..=99826916).is_some());
1279        assert!(val.isfullymatched(99820271..=99826917).is_none());
1280        let mut elem = val.gethash().iter();
1281        let test = elem.next();
1282        let rangepos = RangePos::new(99820271,99826917);
1283        assert_eq!(test,Some((&rangepos,&String::from("AGAGGCAGGGATGACAGAGACAGACACAAAGCAGAGAGACGGAGGCAGAGGGAGACATGCAGAGTCGCGGAGACATCCGGGCTCAGGCCCCGACTCTCAGGGGCCACCCCCAGGGAGGACACGCAGTGCACCCCCACACCCACACCTCACACACACACTCACACCCACATACCCCCATCCACACACACCCAGAGACACACAGACACCCACAGCCACACACTCACACTCACGAACTTATCCAGTCACGTCCCACACACTCCCACCCAACCCATACACCACACACCTACACAACCCATACACCACACACACTCACAAACTATATACCACACACACACCAACCATACACCTATATACACTCACACACCCATATACCACACACTCACACACAACCCATACACCACACGCACACAACCCATACACCTATACACACTCACACCTACAAACTATATACTACACACTCACACACAACCCATACACCTATACACACACACCCATATACCACACACAACCCATACACCACACACACAAACCATATACCACACACTCACACAACCCATACACCTATACACACTCATACCCATATACCACATACAACCAATATACCACACACACACAACCCATACACCTATACACACACACCTATACACCACACACAGCCCATACACTACACAATCACACCACAAACTGTATACCACACACTCACACATAACCCATACACCTATACACACACACCCATATACCACACACACAACCTGTGCACCTACACACACACATACACCACACACACACAACTCCTACACCTACACACACCCACCACCCATACACACACAGCCTATACACCTACACACACTCATACACTCATATAGCACACACACAACCCATATACCACACACACAACCCACATACCTATACACACACGCCCATACACCACACACTCACACAACCCATGCACCACATACACCCACAAACTATATGCTACACGCTCACACACAACCCATACACCTATACACAATCCCACAACCCATACACACTTACACAACCTATACACCACACACACTCACAATCTGTATACCACACACACAACCCATACAGTTATACACACACACCCATATACCACACACACACAACCCATATACCACACACTCACACACAAACCATACATCTATACACATACCCATATGCCACACATACAACCCATACACCACACACTCACACACAACACATACACCACACACACAACCCATAGAACACAAACACAAGTCATAACCACACACACAGCCCATATACCTATACACATTCACACACACAACCCATACACTACACACACAACACATACACCTATACACACTCACACTCAATTCATACACCACACACACACAGCCCATACATCTATACACAAACTCACACACAATCCATATACCACAAACTCACACACAACGCATACACCTATACACACACACGCAACTCATACAGCACACACTCACACAACCCACAGACCATAAACACACACAAGCCATAACCACACACAAACCCATACACCTATACACACACTCATAAACAAGCCATACACCCCTACACAACCCATACACCACACACTCACAACCCATACACCTATATACACACACAACCATATACCACAAACTCACGCTCAACACATACACCTATACACACACACAACTCATACACCACACACTCATACACAACGCACAGACCACATACACAAGCCATAACCACACACACACAACCCGTACACATATATACACACTAATAAACAAGCCATACACCTACACATACAACCCATACACCACACATTCACACATAACCCATACACCTATACACACACACACACAACCCATATACCACAAACACACACAACCTATACACACATACAACCCATACACCACACACACAACACATACACACCACACACACACAGAATACTCATACACACACCCATACACCACCCCCACACAGAACCCATACACCACACACACACAACCTATACACCTATACACACACTCACACACACAACTCATATACCACAAACACACACAACACATACACCTATGCACACACACAACCCATACACCACACATTCACATACAACCCATACACCACACACACACAACACATACATGAAACATACATACAACCCACACACCACCCACTCATACACAACCTATACACCACACACACAACTCATACACCTATACACACACAACACATACACCTATCATACACTCACAACACATACACCTCCTATACACACACAACACACACACTTCCTATACACACAACCCACACGCCTATACACACATCCTCACTCACACTCACCCTCACATTCATATACTCACTAACACACTTCCACACTCACACCCTCACCCACACTTACACCCCCACCCACACTCAAACCCCGACGCTAAGTCACTGTCACATTTGTACCCATGCTCACACGCTCACACGCTCACACACTCACCCCCCACCAGCTCCAGGGCTCACTGGTGTGTGCCCACCAAACCCCCCTCGGGGGTCCCCTCGGTAAGCCGACAGTGCTCTGCTCATCGGTGGCCTGGGGAAACAGGGCCCACCCAAGGCCTGGCTCAGGAAAGGCTCCAAACACACATGGCCCAGGAGCAAATGGGCAGAGCTCAGCCTGCAGCTGGGAGCGGCCGAGCGGGTGCTGGGCCAGAGTCGGGGCCTGTCTGTGGGTGAGGGGCACGGCAGCACGGGCCCACCTGCACCTACAAGGCCTGGCCCCCGAGGTCACTGGGCCACCACCCAGCCCTCGCCCTGTTCCCCGTCTGTGCTGGCCGGGGCAGGACTCTGAGCCTCGGGGAAACCCACAGATACACACGGGACCCCGAACATCGGGCTGGGGAGGCTGGGGTGGGTAACAACATCCCAGAGGCAGGAGCAGGAGGTCCTGGGACCCTGCACACTGCGACCCCAGCCCTGGGGGCTGAAGCCCAGGACAGCCTCAGGTCTCCCAGGAGGGACTGGATAGTGGGGGATGGTCAGAGAACAGGACAGCCAGCAGGGTGCAGCCCGAGGACAGGGATGGATGCTGGGAGGTCAACAGGACAGGGGCAGGGGCAGGGGCTGTGGAGTGTGAGAAGGTCCTGGAGGGCCTGGAGAACCTGTGGGTCAGTGTCTGTGGGAAGGAGGCCAGGAGCAGCCCTGAGTGGCCAGGCTGGCAGGGGTGAGGAGGTGGGGGCAGTGAGGTGAGGGTGACCGAGACAGGCCTCTGGCCAGGGAGGGGACCTTGGCTGGGCTCTGACTGAACCCAGGGCTCCTGGAGAAGGGGCCCCAGGCGGGGATGAGGATGTGGGCATCTGACTCCATCAACAATGGGGCTTCCAACACGCACAGCCTGGGCCTCGGAGACCTGGGCCCTGACCCGCCTCCCCCTGGCACTGGGCCGGGTGCCGTGTGTGGTCCCCAGTCCCCGCAGCACCTCCCCCACACTGGTCACGTTCCAGGGCCCCTCTGAAGCACCTGCTGTGAGGGGATGTGAGGAGGGGACAGGGACTTGGGCCTGAGCTGCCGGGTCGGGGGGGAGTCGGGGACCCAGGCTCAGCGTGTGGCTGGGGACCAGACAGATGGGGATGGAGGAGGACACGCCCTGTACCCACTGCCTGCCAAGGGGCTGGACCCACGCCCAGTCTAGGCCATGTCCCCCGAGGCCTGTGAACCTTCACTCTGAGCCACTAAAACATTCAGGAGCTTTGAAAGCAGCCCCCGTCCTTGTCACTATGCGATGACTCTGAGCATCACGCTGTCCCTGCTGGATCCACCCTCCAGCCCCAGCGAGGGAGGCTGGGCCCCGGGCAGCAGGTGGTGAGGGCAGCGGGCACAGCCACCCTACAGCACACACAGGGTCTCAGGGACGCGTCCACCACAGCCCGTGCACAGGCTCCTCACGGCACTGAGTTCACCCGGGGCGCGGGCCGTTTGTCCTCAGGAGTCCCACTGTGCCCTCCGCCCCCAGCCCTGTCCTGCTGAGGCTGCAGCTGGGTCCCGGGGCACAGGGCGGCCCTGAGCACCTTGTCATGTTGGTCCCTGTCGGGTGGGCTGCTGGCTGTCTGTGGAGCTGGCAGAGCCGCGGTTCAGCCTTGGAGGCCGGTCCTGGGGCCCAGCAGCCGTGGGGAGCACTGCCCAGTCCCGTGCCCACAGGGAATCACCTGGGCTGAGGAAGGGCCCACACGCCGACGGGATCGGGGTCAGGCAGCGCACGCCTGGCACCGAGATCCCACGTCCCGAAGTGGGGACACGGCCCAGGGGCACTGTTCCGGGAGGGTCTCAAGATGGGGTCTCCTATTTCAATCTTCACTCCTTCTGCACCTGTTAGCTGGGAACCTTCTAGAAGGAGGGGTGTCCTCAATCATGGGGTGGTTGTGAGCTGAGCACAGATCATGCAGGAAGGTACATGGCTTCTCCTTCACCAGGAAAACAGTGCAGAGAGACAGAGACACAGAGACAGAGTAACAGAGAAAGACAGAGAGACAGAGACACAGAGACAGAGACAGAGTAACAGAGAAAGACAGAGAGACAGAGAGACACAGACAGAGACAGAGTAACAGAGAAAGGCAGAGAGACAGAGAGAGACAGAGACAGAGTAACAGAGAAAGACAGAGAGGCAGAGAGAGAGAGACAGAGACAGAGACAGAGTAACAGAGATAGACAGAGAGACACAGAGACAGAGACAGAGTAACAGAGATAGAGAGACAGAGAGAGACACAGAGACAGAGTAACAGACAGAGACAGAGACAGGCACAGAGATAAGAAAGATACACAGAAACAGAGAGAGACAGAGACAGAGATAGTCACTGTCACATTCATACCCACGCTCACCTGCTCACACACACACACCTCACACACACTCACACTCACACTCACCTCACACACACAGTCACACACACACTCACACACACTCACACACACACACTGAGCTTCCCTCAGGCCCTGTCACTTCCGATGGGGCCTACGGCCTGTCTAAGCCTCTGGGCCACCAGCCCCTGGCTCACCGGTGTGTGCCCACCACACCCCGCCTTGGGGGTCTCCTCTATGAGCTGGGCACATGCCCTCCGCTCTGTTCATGGCTGGCCTGGGGGAAACAGGGCCCACCCAAGGCCTGGCTCAGGGAAGGCCTCAAACACACATGGCCCAGGAGCAAAGGGGCAGAGCTCAGCCTGCAGCTGGGAGCGGGCAGGGGTAGTGGAGTGGGCGGAGGGCCTGGAGAACCTGCAGGGCTACGATGTCTCTGGGAAGGGGGCCCAGGAGCAGCTCAGCGTGGCTGGGCCGGCAGGGCCGAGGAGGTGGGGGCCGTGAGGGAGGGGTGACTCGGCTGTGTGGGGTGCCGGGGGACACGGGCTTTGCTCCGGCTGAGCCCAGGCAGTGGCGAATCCCTGAGCTGCCAGGAGGAGAGCAGGGCCGGGGTCAGGCAGAGGTGGGCCGCGGGGCCGAGGGCTGCGGCCGGTCGGGAGCAGTCGGTCGGTTGAGGGCACCATTACATGGAGGGCTGTGAGACGGGAGACCCCATTCCCTTCATTCCTTGTGCACGTGTTAGTGAGGAAGCTTCTAGAAGGAGGGCATTGCTCGTAGTGGGTGAGTGTGAGCACAGATCATGCAGGCTGGCGTGCTGCCGTGAAGTGCCTCTCTTTACTTTCCAGACCTCAGCATGGCAAGCCCGTCCTGCGCCCCAGGGTCTTTCTGGAGTACACGCCGCGCGGTCCTGGTGGGCACCATACCTGGCACCCACGCTTTGGCCGGGCCCGAACCTTGCGCCCTCCCAGCCCCCATGTGGCTCTCCCTTGGCCATACTGGCCTTTTGCCAGTCCTCCTACCTCACCCTAGGGTCTGCCTGGCCCTGCCCTCCCTTCCTAGCCCCCCAAGGAGGCTGGAGGGCACCCCTGCGTCCACCAGCAGCAGCTCCTCATGGGCGAGTCTCCTTGGGCCAGTGACACATAGTGTGCCCCGATGGTGCCACGGCAGCCTGGGCCCTCCGCCTTCCTGCTTGGCAGGCACCCCCGCTCCCTGCACCCTCACCGGGGCACCTGTGAGCCCTGAGGGCCAGTGGGGGTCTCACTGCTGCTCCCTCCCACAGCCTAGCCTCGGGCCTCAGGGCTCTGCATCCAAGCGGCCCAGGGCTCCCTGAGGTCTCAGCCCGAGTGGGCCTTTGAGCCTTCGCGTTCTCTGCAGGGTGGGACCTGCCCAAGGGCTGCTGAGGGCTTCCCAGGGGTCCTGTGGGTCCCACCTAGGGGCAAGCTGGTGAGGAAAGTGGGTCCTGCCATGGCGGCCGGGTGGGCTGAGTTTTCGGCATCTCTGGGCCCAACAGCAGGTCCCTGGAGCGGCGCCCACCCCTCCCCCAGGCAGGTGTGAGGGCTCTGATCTGTTTCTCCTTGAGTGACTCATTCTGGGCAGACTTGGCCCTCAGGGCACATGCAAATGGTTGTTTGTTCCACACCGAAAACATGTTTCTTGCCCTCTGAGGCTGTTTCCAGAAATAGCTTGCACGATTCTCCACCTGCAGCTGCAGCCGCCACCCACCCAGTGTGGCCAGGCTGGCCCAGGCCTCCAGATTCGGGGACACCCCCCGCCCCCTCCCCCAGCGTGGCCAGGCTGGCTCAGGCCTCCAGATTCGGGGACA"))));
1284        let test = elem.next();
1285        let rangepos = RangePos::new(99826917,99827017);
1286        assert_eq!(test,Some((&rangepos,&String::from("CCCCCCCCCCCCAACAGCGTGGCCAGGCTGGCTCAGGCCTCCAGATTCGGGGACACCCCCCCACCACAGCGTGGCCAGGCTGGCTCAGGCCTCCAGATTC"))));
1287        let test = elem.next();
1288        let rangepos = RangePos::new(99827017,99829102);
1289        assert_eq!(test,Some((&rangepos,&String::from("GGGGACACCCGCCCCCTCCCCCAGGACAGGCCCACTTGGGTTACTGACACTGGGACCACCCTGCAAACGTCAACTTTATTGAATTCAGTGGTTCTGAACTTGTTGCCATCTTTGGGACCAGGACCCAGGGGCAGCCCCCAGGTTGGCAGGAAGGGCAGGGGAGCCAACGCTGGCAGGGCCCCCAGCCAACCCCCACCCCAGAAGCCCCAAGGAGGCTGAGCGGAGGTGGCCCTGGTGGCCTGGGCACAGGCAGCCCGATTGGTACAGGGCCTGTCTGGTGCAGGCCCGCACCTCCCCCACCCTCATGGCCTGGTGGTCCCCACTGTACAGAGAGAACACTGAGGCTCAGCAGGGCCAGGGACATGGCCTGAGGTTACATGGTGATGGGGGCTGGGTCTCCGGGCCTGGGGGCCGTGGTGGGTGCAGCACCCGGACTGCGTGGGCTGTGGCCTCCCTGCTCCCAGCTCTGTCACACCCGTCTCCATCTGAGCCTCCAGCTCCATCTTTCCCGCTGTCCCTGTCTCTGGCCACCCTTCTGTCTCCCTGTCTCTCTGCCTCTCTGAAGGTATCTCCCTGCCCGAATCTCTGTCTCTGTCCCATTGTCGGTGTCTCTGACTCATCTCTGTCAAGCCCGTCTGCTGGGCTTTGTCCCGCCATCTTGCCTGTCTTGGCCTCTCTCTCTTTCTGTGTGTCTCCGTCGGTGCCTCCTTTCTCCATCCATCTCTCCCCCGTGTCTGTCTCTATCCCTCCGTCTCTCTTCCCGTCTATCCCTCCCTCTGTGCCTGTCCCTTTGCTGTGTCCCTTTCTTTGCCTCTGTCTCTCTGTCTGTCTCTTCGTGTCCCTGTGTGTGTCTCTCTCTTCTCTCTGCTTCTCTTTCTGTATCTCTGTCTATATCTCAGCCTCTTTGTGTCCCTGTGTGTGTGTCTCTCTCTTCTCTGTCTTTCCATGTCTCTGTCTATATCTCTGTCTCTCTGCCTCTGTATCTCTGTCTGTCTGTTCGTGTCCCTGTGTATGTCTCTCTCTGTCTCTTTCTGTATCTCTGTCTATATCTGTCTCTCTCATCTGTCTCTTCCTGTGTGTGTCTCTCTGTCTCTCTGCCTCTGTCTCTGTCTCTCTGTCTCTTCATCTCTGTCTGTCTCTGCCTGTCTGTGTCATTTGGTGTCTCTGTTTTTGTATGTCTCTCTGTTTGTCTGTGTCTCTTCCTCTCTGTAGCTCTGCCTCTCTCTATCTCTCCTTATATCTGTCTTTCTCTCTCCCTGTTTCTTTCTCTGTCTCTTTTTGTCTTTCTGAGTCTGTCTCTGTCTCTGTCTCTTCCTCTCTGTATATACCTCTCTGTCTTTCTGTTGCTGTCTGTCTCTGTTTCTCTTCTCCTCTCTCTATCTCTCTTTGTCTGTCTTTCTCTGCCTTTCTAACTCTGTCTTTCTCTGTCTCTCTGTCTCTATCTCAGTCTCTCTTCTTATCTCTCTCTCTGTCTCTCTCACTCTCTGTATCTCTTTGTCTCTGTCTTTCTCTTATCTCTATCGCTCTGTCTCTATCTCTCTTTCTGTCTCTCTGTATCTCTATCTCTGTCTCTCTCATGTCTATCTCTCTGTCTTTCTCTGTCTCTCTGTATCTCTGTCTTTCATCTCTATCTCTATCTCTGTCTTTCTGTCTCTATCTCTGTCTCTCTATCTCTTTCTCTGTCTGTATCTCTCTGTCTCTATCTCTCTCTGTCTTTCTCTGTGTCTCTGTATCTCTGTCTCTATCTCTGTCTCTCTATCTCTCTCTGTCTCTCCCTGTCTCTCTCTATCTCTGTCTCTCCATCCCATGTGGGTCTGTGGGTTTCCCCGAGGCTCAGAGCCCTGCCCCGGTCAGCACAGACAGGGAACAGGGCGAGGGCTGGGTGGTGGCCCAGTGACCTTGGGGGCCAGGCCTTGGGGGTGCAGGTGGGCCCGTGCTGCCGTGCCCCCCACCCACAGACAGGCCCCGGCTCTGGCCCAGCACCCGCTCCGCCGCTCCCAGCTGCAGGCTGAGCTCTGCCCGTTTGCTGCTGGGCCATGTGTGTTTGGGGCCTTTCCTGAGCCAGGCCTTGGGTGGGCCCTGTTT"))));
1290        let test = elem.next();
1291        let rangepos = RangePos::new(99829102,99835825);
1292        assert_eq!(test,Some((&rangepos,&String::from("CCCCAGACCACCCATGAGCAGAGTGTAGGGCACGTGCCCAGCTCACAGAGGGGACCTCTGAGGCGGGGTGTGGTGGGCACACAGCAGTGAGCCATGAGGCTGGTGGCCCAGAGGCTTGGACATGCCGTGGGCCCCATAGGAAGTGACAGGGCTTGAGGGAAGCTCAGTGTGAGTGTGTGAGCGTGGGTATGAATGTGACAGTGACTCTCTATCTGTCTCTTTGTATCTCTGTCTCTCTGTGTGTATCTTTCTATCTCTGTCTCTCTATATGTCTCTCTATCTCTGTCTCTCTGTATCTCTATCTCTCTGTGTGTATCTTTCTATCTCTGTCTCTCTTTCTTGATCTCTCTCTATCTCTGTCTCTGTAACTCTCTTTATCTCTTACTGCTTCTGTTTCTCTCACTCTGTCTCTGTCTCTCTTTATCTCTGTCTTGCTCTCTCTCTCTGTAACTTTATCTCTGTCTCTCTGTTTCTATCTCTGTTTTTCTCTGTCTCTGTCTGTATCTCTGTCTCTCTTTATCTGTCTCTCTGTCTCTGTGTATCTCTGTCTCTCTGTAACTTTATCTCTGTCTTTTTCTGTCTCTGTGTGTGTCTGTCTCTGTGTCTTTGTTTTTCTCTCTGTCTCTGTCAATGTCTCTTTCTGTATCTGTTTCTTTCTCTCTGTCTCTGTCTCTCTATCTCTGTCTCTATCTCTCTGTCTCTCTGTAACTCCTCATCTCTGTCTCTGTGTCTGCATGTCTCTTTCTGTGTCTCTGTTTCTCTCTCTGTCTCTGTCTCTCTGTGACTCTGTCTCTGTCTCTGTCTCTGTCTTTCTCTGTTACTCTGTCTCTCTCTCTGTCTCTCTGTGACTCTATCTGTTACTCTGTCTCTGTCTCTGTCTCTCTCTGTCTCTCTTTCTCTGTTACTCTGTCTGTGTCTCTGTGTCTCTCTCTCGTCTGTCTTTCTCTGTTACTCTGTCTCTGTCTCTGTGTCTCTGTCTCTCTGCACTGTTTTCCTGGTGAAGGAGAAGCCATGTACCTTCCTGCATGATCTGTGCTCAGCTCACAACCACCCCATGATTGAGGACACCCCTCCTTCTAGAAGGTTCCCAGCTAACAGGTGCAGAAGGAGTGAAGATTGAAATAGGAGACCCCATCTTGAGACCCTCCCGGAACAGTGCCCCTGGGCCGTGTCCCCACTTCGGGACGTGGGATCTCGGTGCCAGGCGTGCGCTGCCTGACCCCGATCCCGTCGGCGTGTGGGCCCTTCCTCAGCCCAGGTGATTCCCTGTGGGCACGGGACTGGGCAGTGCTCCCCACGGCTGCTGGGCCCCAGGACCGGCCTCCAAGGCTGAACCGCGGCTCTGCCAGCTCCACAGACAGCCAGCAGCCCACCCGACAGGGACCAACATGACAAGGTGCTCAGGGCCGCCCTGTGCCCCGGGACCCAGCTGCAGCCTCAGCAGGACAGGGCTGGGGGTGGAGGGCACAGCCGGACTCCTGAGGACAAACGGCCCGCGCCCCGGGTGAACTCAGTGCCGTGGGGAGCCTGTGCACGGGCTGTGGTGGACGCGTCCCTGAGACCCTGTGTGTGCTGTAGGGTGGCTGTGCCCGCTGCCCTCACCACCTGCTGCCCGGGGCCCAGCCTCCCTCGCTGGGGCTGGAGGGTGGATCCAGCAGGGACAGCGTGATGCTCAGAGTCATCGCATAGTGACAAGGACGGGGGCTGCTTTCAAAGCTCCTGAATGTTTTAGTGGCTCAGAGTGAAGGTTCACAGGCCTCGGGGGACATGGCCTAGACTGGGCGTGGGTCCAGCCCCTTGGCAAGCAGTGGGTACATGGCGTGTCCTCCTCCATCCCCATCTGTCTGGTCCCCAGCCACACGCTGAGCCTGGGTCCCCGACTCCCCCCCGACCCGGCAGCTCAGGCCCAAGTCCCTGTCCCCTCCCCACATCCCCTCACAGCAGGTGCTTCAGAGGGGCCCTGGAACGTGACCAGTGTGGGGGAGGTGCTGCGGGGACTGGGGACCACACACGGCACCCGGCCCAGTGCCAGGGGGAGGCGGGTCAGGGCCCAGGTCTCCGAGGCCCAGGCTGTGCGTGTTGGAAGCCCCATTGTTGATGGAGTCAGATGCCCACATCCTCATCCCCGCCTGGGGCCCCTTCTTCAGGAGCCCTGGGTTCAGTCAGAGCCCAGCCAAGGTCCCCTCCCTGGCCAGAGGCCTCACTGTCTCGGTCACCCTCACCTCACTGCCCCCACCTCCTCACCCCTGCCAGCCTGGCCACTCTGGGCTGCTCCTGGCCTCCTTCCCACAAACACGGACCCACAGGTTCTCTAGGCCCTCCAGGACCTTCGCCCACTCCACGGCCCCTGCCCCTGTCCTGTTGACCTCCCAGCGTCCATCCCTGTCCTCGGGCTGCACCCTGCTGGCTATCCTGTTCTCTGACCATCCCCCACTGTCCAGTCCCTCCTGGGAGACCTGAGGCCGTCCTGGGCTTCAGCCCCCAGGGCTGGGGTCGCAGTGCGCAGGGTCCTGGGACCTCCTGCTCCCGCCTCTCCCATGTTGTTACCCACCCCAGCCCGATGTTCGGGGTCCTGTGTGGATCTGTAGGTTTCCCCGAGGCTCAGAGTCCTGCCCCGTCCAGCACAGACGGGGAACAGGGCGAGGGCTGGGTGGTGGCCCAGTGACCTCGGGGGCCAGGCCTTGTAGGTGCAGGTGGGCCCGTGCTGCCGTGCCCCCCACCCACAGACAGGCCCCGACTCTGGCCCAGCGCCCGCTCGGCCGCTCCCAGCTGCAGGCTGAGGTCTCCCCATTTGCTCCTGGGCCATGTGTGTTTGGGTGTGAGTGTGGGTATGGATGTGACAGTGACTTAGTGTGTGGCTGTGAGCGTGGGTATGTTTCTGTGTGTTTGTGTGTGAATGTTGTATAATAGTCGTGGTGTGTGTTTGTGAGAGTGACTGTGTGAGAGGGGCTTGCAGCTGAGTTCCTGGGCCCATCTTGCTGCCTCTTTCTCTCCCTGTGTGTTCTCTGCCTCTGTTGTGTTCTCTCTGCATGTCTGTCTCCATGTCTCTTTTTCCCTGTTCCCATCTCCTCCCTTTTTCTCCCATCTCTGTCTCTGTTTCTTATCTATCTCATCTCATCTCTCTCTTTCTGTCTCTTGTGTCTCTGTCCCTCCCCATCCCTGTCTCTTATCTCTCTCCATCCCCATCTCTCTCTCTGTGTCTGTCTTTGTCTCTGTCTCTATGTCTCTTGTCTCTCCCCATCCCTGTCTCTCTCTATGTCTCTGTGTCTCTTATCTCTCCCCATCCCTGTCTCTCTATGTCTCTGTGTCTCTTATCTCTCCTTGTCCTTGTCTTTCTCTGTCTACGTCTCTGTGTCTCTCTCCATCCCTGTCTCTCTCTATGTCTCTGTGTCTCTTATCTCTCCCTATCCCTGTCTCTCTATGTCTCTTGTCTCTCCCCATCCCTGTCTCTCTCTCTCTATGTCTCTGTGTCTCTTATCTCTCCCCATCCCTGTCTCTCTCTATGTCTCTTCATCTCTTATCTCTCTCCCCATCCCTGTCTCTATGTCTCTGTGTCTCTTATCTCTCCCCATCCTTGTCTCTGTCTATGTCTCTGTGTCTCTTGTCTCTCCCTGTCCCTGTCTCTCTCTATGTCTCTGTGTCTCTCTGGGCCCCTGGTCCAATGTCCCCTTCCCAGAACCCCTGTTTCCCTGGTGTGGGGTGCAGGTCCTTCTGTGGCCCTGTGGGCCGTGCTTGTGCTGGGCACAGCCTGCCAGGGCAGCCACTCAAGCCCCAGGGCTGGGCACTGCGTCCTGGCTCTGGCCAAGGGCCCTGGGGAGAGCTGAGGGAGGTGCATGCAGGGTGTGAGGCCCACCACAGTCACTGCCAGATGCTCAGTGCTGGTGCTTCCCTGGGTCTGCTGTGTGGTGGGCACAGCCCTCGTGAGGGCTGCCCATGGAGGAGGCCTGCCGCCTAGAGAGCCCGGACAGGGGGACAATGGCCTGTGCTGACCCTGGCGGAACCCTGGCTGGCCCCAGATGACCCCAGATGGCCCTGGCTGACCCTGGCGGAACCCAGATGACCCTGGCTGACCCTGGCTGGCCCTGGCTGACCCCAGATGACCCTGGCTGACCCTGGCTGATCCTGGCTGACCCTGGCTGACCTCTGCCTAACCCTGGACCTGGAAAGCCCTAGCTGACCCCGGGCTGGTTGGGGCTGGGCCTCCCTGTGGCTGCAGCCCCTCGCTCAGGCCCCAGGCACACCTGGCCAGGTCTCGGTTTTGGGGCATGTTTCTCAGAACAGCAGTTCTCTGGCTGGAACACCTGGCCTGGGCTGTGTTCACAATGACTCAGCCGCCCCACAGGGCTATTTTGGATATTTCTGCAGGTGATGGGGTACAAGAGGCTTCAGGAGAGAGAGAAAAGCAAGAGAATACAAACAGCATGGCCTCCCCCGACCTTCCTGTCCCCACTCCTGTACTGTACCCCCTCCCCAGTGCTAAGTCGAGACCTGGCGACCCCTTAGGGGCTGGGGCTGGGTGTAGCTCACAGGGCCTGGGCTGGTCCTCTCCCCACCAAGTCCTCCTGGGGCCTACACACCCCTCTGAGCCTGGAAAAATGGAGCAAGCCATTGGGGTCATTTCTTCATCTACCAGTGAGTACATGCACTGAGAGGGTCTCGGCTCCCCTGGAGGCCTCCCTCCACCACTGCAGGTCACTTACTCATGAGGGCCAAGGCTCAGAAATCAGACAGGACTCAGTGTCTAGTCAGACTGATACATGCTCAGAAAAGGAATCAGATTTCAAAATGAATATGTATAAGAAAAGAACCGGGGATCAGTGATCAGGAACAGGGATCCATGATCTGGTCCAGGGCTCAGCGGTCAGGAACAGGGCCCAGCGATCAGGACCAGGGCTCAGTAATCAGGACCAGGGCCCAGTGATCAGGACCAGGGCCCAGCGATTGGGTCCAGGGCTCAGTGATCAGGAACAGGGCTCAGTGATCAGGACCAGGGCCCAGTGATCAGGAACAGGGGCCAGTGACTGGGTCCAGGGCTCAGTAATCAGGACCAGGGCTCAGTGATCAGGACCAGGGCTCAGTGATCAGGAACAGGGGTTAGTGATCAGGAACAGGGCTCAGTGATCAGGACCAGCATTCAGTGATCAGGACCAGGGCTCAGTGATCAGGAACAGGGCTCAGTGATCAGGAACAGGGGTTAGTGATCAGGAACAGGGCTCAGTGATCAGGACCAGCACTCAGTGATCAGGACCAGGGCCCAGTGATCAGGAACAGGGGCCAGTGACTGGGTCCAGGGCTCAGTAATCAGGACCAGGGCTCAGTGATCAGGACCAGGGCTCAGTGATCAGGAATAGGGGTTAGTGATCAGGAACAGGGCTCAGTGATCAGGACCAGGGCTCAGTGATCAGGAACAGGGCTCAGTGATCAGGAACAGTGGTCAGTGATCAGGAACAGGGGTTAGTGATCAGGAACAGGGCTCAGTGATCGGGACCAGGGCTCAGTGATCAGGACCAGGGCCCAGTGATTGTGTCCAGGGCTCAGTGATCAGGACCAGGGCTCAGTGATCAGGAACAGGGCTCAGTGATCAGGAACAGGGGTTAGTGATCAGGAACAGGGCTCAGTGATCAGGACCAGCACTCAGTGATCAGGACCAGGGCCCAGTGATCAGGACCAGGGCCCAGCGATTGGGTCCAGGGCTCAGTAATCAGGACCAGGGCCCAGTGATCAGGAACAGGGCTCAGTGATCAGGAACAGGGGTTAGTGATCAGGAACAGGGGTTAGTGATCAGGAACAGGGCTCAGTGATCAGGAACAGGGCTCAGAGATCAGGACCAGGGCCCAGCGATTGGGTCCAGAGCTCAGTGATCAGGAACAGGGCCCAGCGATCAGGACCAGGGCTCAGTAATCAGGACCAGGGCTCAGTGATCAGGACCAGGGCCCAGTGATCAGGAACAGGGGCCAGTGACTGGGTCCAGGGCTCAGTAATCAGGACCAGGGCTCAGTGATCAGGAACAGCGGTTAGTGATCAGGAACAGGGCTCAGTGATCAGGACCAGCGCTCAGTGATCAGGAGCAGGGCTCAGTAATCAGGACCAGGGCCCAGTGATCAGGAACAGGGCTCAGTGATCAGGAACAGGGGTTAGTGATCAGGAACAGGGCTCAGTGATCAGGACCAGGGCCCAGCGATTGGGTCCAGAGCTCAGTGATCAGGAACAGGGCCCAGCGATCAGGACCAGGGCTCAGTAATCAGGACCAGGGCTCAGTGATCAGTACCAGGGCCCAGCGATTGGGTCCAGGGCTCAGTGATCAGGACCAGGGCCCAGCGATTGGGTCCAGGGCTCAGTGATCAGGAACAGGGCCCAGCGATCAGGACCAGGGCTCAGTAATCAGGACCAGGGCTCAGTGATCAGGACCAGGGCCCAGCGATTGGGTCCAGGGCTCAGTGATCAGGAACAGGGCCCAGCGATTGGGTCCAGGGCTCAGTGATCAGGAACAGGGCCCAGCGATCAGGACCAGGGCTCAGTAATCAGGACCAGGGCTCAGTGATCAGGACCAGGGCCCAGCGATTGGGTCCAGGGCTCAGTGATCAGGACCAGGGCCCAGCGATTGGGTCCAGGGCTCAGTGATCAGGAACAGGGGTTAGTGATCAGGAACAGGGCTCAGTGATCAGGAACAGGGGTTAGTGATCAGGAACAGGGCTCAGTGATCAGGACCAGGGCCCAGTGATT"))));
1293        assert!(elem.next().is_none());
1294    }
1295    #[test]
1296    fn spliced_reads() {
1297        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
1298        let mut it = bam.records();
1299        let blocks: Vec<_> = it.next().expect("iter").unwrap().aligned_blocks().collect();
1300        //6S45M - 0
1301        assert!(blocks[0] == [16050676, 16050721]);
1302
1303        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1304        //7M2D44M - 1
1305        assert!(blocks[0] == [16096878, 16096885]);
1306        //7M2D44M - 1
1307        assert!(blocks[1] == [16096887, 16096931]);
1308
1309        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1310        //29M2D22M - 2
1311        assert!(blocks[0] == [16097145, 16097174]);
1312        //29M2D22M - 2
1313        assert!(blocks[1] == [16097176, 16097198]);
1314
1315        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1316        //51M - 3
1317        assert!(blocks[0] == [16117350, 16117401]);
1318
1319        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1320        //51M - 4
1321        assert!(blocks[0] == [16118483, 16118534]);
1322
1323        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1324        //51M - 5
1325        assert!(blocks[0] == [16118499, 16118550]);
1326
1327        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1328        //51M - 6
1329        assert!(blocks[0] == [16118499, 16118550]);
1330
1331        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1332        //51M - 7
1333        assert!(blocks[0] == [16118499, 16118550]);
1334
1335        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1336        //51M - 8
1337        assert!(blocks[0] == [16123411, 16123462]);
1338
1339        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1340        //6S45M - 9
1341        assert!(blocks[0] == [16123417, 16123462]);
1342
1343        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1344        //41M10S - 10
1345        assert!(blocks[0] == [16165860, 16165901]);
1346
1347        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1348        //51M - 11
1349        assert!(blocks[0] == [16180871, 16180922]);
1350
1351        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1352        //51M - 12
1353        assert!(blocks[0] == [16189705, 16189756]);
1354
1355        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1356        //51M - 13
1357        assert!(blocks[0] == [16231271, 16231322]);
1358
1359        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1360        //51M - 14
1361        assert!(blocks[0] == [16237657, 16237708]);
1362
1363        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1364        //9S42M - 15
1365        assert!(blocks[0] == [16255012, 16255054]);
1366
1367        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1368        //51M - 16
1369        assert!(blocks[0] == [16255391, 16255442]);
1370
1371        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1372        //50M1S - 17
1373        assert!(blocks[0] == [16255392, 16255442]);
1374
1375        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1376        //45M6S - 18
1377        assert!(blocks[0] == [16256084, 16256129]);
1378
1379        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1380        //3S48M - 19
1381        assert!(blocks[0] == [16256224, 16256272]);
1382
1383        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1384        //42M9S - 20
1385        assert!(blocks[0] == [16325199, 16325241]);
1386
1387        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1388        //13S38M - 21
1389        assert!(blocks[0] == [16352865, 16352903]);
1390
1391        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1392        //44M7S - 22
1393        assert!(blocks[0] == [16352968, 16353012]);
1394
1395        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1396        //5S46M - 23
1397        assert!(blocks[0] == [16414998, 16415044]);
1398
1399        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1400        //23M4I24M - 24
1401        assert!(blocks[0] == [17031591, 17031614]);
1402        //23M4I24M - 24
1403        assert!(blocks[1] == [17031614, 17031638]);
1404
1405        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1406        //18M1I32M - 25
1407        assert!(blocks[0] == [17057382, 17057400]);
1408        //18M1I32M - 25
1409        assert!(blocks[1] == [17057400, 17057432]);
1410
1411        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1412        //17M2183N34M - 26
1413        assert!(blocks[0] == [17092766, 17092783]);
1414        //17M2183N34M - 26
1415        assert!(blocks[1] == [17094966, 17095000]);
1416
1417        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1418        //1M2183N50M - 27
1419        assert!(blocks[0] == [17092782, 17092783]);
1420        //1M2183N50M - 27
1421        assert!(blocks[1] == [17094966, 17095016]);
1422
1423        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1424        //1M2183N50M - 28
1425        assert!(blocks[0] == [17092782, 17092783]);
1426        //1M2183N50M - 28
1427        assert!(blocks[1] == [17094966, 17095016]);
1428
1429        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1430        //9S33M9S - 29
1431        assert!(blocks[0] == [17137287, 17137320]);
1432
1433        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1434        //2S48M1S - 30
1435        assert!(blocks[0] == [17306238, 17306286]);
1436
1437        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1438        //4S45M2S - 31
1439        assert!(blocks[0] == [17561868, 17561913]);
1440
1441        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1442        //41M11832N10M - 32
1443        assert!(blocks[0] == [17566078, 17566119]);
1444        //41M11832N10M - 32
1445        assert!(blocks[1] == [17577951, 17577961]);
1446
1447        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1448        //11M11832N25M710N15M - 33
1449        assert!(blocks[0] == [17566108, 17566119]);
1450        //11M11832N25M710N15M - 33
1451        assert!(blocks[1] == [17577951, 17577976]);
1452        //11M11832N25M710N15M - 33
1453        assert!(blocks[2] == [17578686, 17578701]);
1454
1455        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1456        //8M11832N25M710N18M - 34
1457        assert!(blocks[0] == [17566111, 17566119]);
1458        //8M11832N25M710N18M - 34
1459        assert!(blocks[1] == [17577951, 17577976]);
1460        //8M11832N25M710N18M - 34
1461        assert!(blocks[2] == [17578686, 17578704]);
1462
1463        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1464        //8M11832N25M710N18M - 35
1465        assert!(blocks[0] == [17566111, 17566119]);
1466        //8M11832N25M710N18M - 35
1467        assert!(blocks[1] == [17577951, 17577976]);
1468        //8M11832N25M710N18M - 35
1469        assert!(blocks[2] == [17578686, 17578704]);
1470
1471        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1472        //8M11832N25M710N18M - 36
1473        assert!(blocks[0] == [17566111, 17566119]);
1474        //8M11832N25M710N18M - 36
1475        assert!(blocks[1] == [17577951, 17577976]);
1476        //8M11832N25M710N18M - 36
1477        assert!(blocks[2] == [17578686, 17578704]);
1478
1479        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1480        //8M11832N25M710N18M - 37
1481        assert!(blocks[0] == [17566111, 17566119]);
1482        //8M11832N25M710N18M - 37
1483        assert!(blocks[1] == [17577951, 17577976]);
1484        //8M11832N25M710N18M - 37
1485        assert!(blocks[2] == [17578686, 17578704]);
1486
1487        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1488        //7M11832N25M710N19M - 38
1489        assert!(blocks[0] == [17566112, 17566119]);
1490        //7M11832N25M710N19M - 38
1491        assert!(blocks[1] == [17577951, 17577976]);
1492        //7M11832N25M710N19M - 38
1493        assert!(blocks[2] == [17578686, 17578705]);
1494
1495        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1496        //6M11832N25M710N20M - 39
1497        assert!(blocks[0] == [17566113, 17566119]);
1498        //6M11832N25M710N20M - 39
1499        assert!(blocks[1] == [17577951, 17577976]);
1500        //6M11832N25M710N20M - 39
1501        assert!(blocks[2] == [17578686, 17578706]);
1502
1503        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1504        //6M11832N25M710N20M - 40
1505        assert!(blocks[0] == [17566113, 17566119]);
1506        //6M11832N25M710N20M - 40
1507        assert!(blocks[1] == [17577951, 17577976]);
1508        //6M11832N25M710N20M - 40
1509        assert!(blocks[2] == [17578686, 17578706]);
1510
1511        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1512        //1S44M1467N6M - 41
1513        assert!(blocks[0] == [17579733, 17579777]);
1514        //1S44M1467N6M - 41
1515        assert!(blocks[1] == [17581244, 17581250]);
1516
1517        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1518        //2M1514N48M95N1M - 42
1519        assert!(blocks[0] == [17581369, 17581371]);
1520        //2M1514N48M95N1M - 42
1521        assert!(blocks[1] == [17582885, 17582933]);
1522        //2M1514N48M95N1M - 42
1523        assert!(blocks[2] == [17583028, 17583029]);
1524
1525        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1526        //1M1514N48M95N2M - 43
1527        assert!(blocks[0] == [17581370, 17581371]);
1528        //1M1514N48M95N2M - 43
1529        assert!(blocks[1] == [17582885, 17582933]);
1530        //1M1514N48M95N2M - 43
1531        assert!(blocks[2] == [17583028, 17583030]);
1532
1533        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1534        //1M1514N48M95N2M - 44
1535        assert!(blocks[0] == [17581370, 17581371]);
1536        //1M1514N48M95N2M - 44
1537        assert!(blocks[1] == [17582885, 17582933]);
1538        //1M1514N48M95N2M - 44
1539        assert!(blocks[2] == [17583028, 17583030]);
1540
1541        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1542        //1S22M95N28M - 45
1543        assert!(blocks[0] == [17582911, 17582933]);
1544        //1S22M95N28M - 45
1545        assert!(blocks[1] == [17583028, 17583056]);
1546
1547        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1548        //37M538N13M1S - 46
1549        assert!(blocks[0] == [17588621, 17588658]);
1550        //37M538N13M1S - 46
1551        assert!(blocks[1] == [17589196, 17589209]);
1552
1553        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1554        //37M538N13M1S - 47
1555        assert!(blocks[0] == [17588621, 17588658]);
1556        //37M538N13M1S - 47
1557        assert!(blocks[1] == [17589196, 17589209]);
1558
1559        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1560        //37M538N13M1S - 48
1561        assert!(blocks[0] == [17588621, 17588658]);
1562        //37M538N13M1S - 48
1563        assert!(blocks[1] == [17589196, 17589209]);
1564
1565        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1566        //1S25M1D25M - 49
1567        assert!(blocks[0] == [17591770, 17591795]);
1568        //1S25M1D25M - 49
1569        assert!(blocks[1] == [17591796, 17591821]);
1570
1571        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1572        //24M1D24M3S - 50
1573        assert!(blocks[0] == [17593855, 17593879]);
1574        //24M1D24M3S - 50
1575        assert!(blocks[1] == [17593880, 17593904]);
1576
1577        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1578        //16M1D28M7S - 51
1579        assert!(blocks[0] == [17593863, 17593879]);
1580        //16M1D28M7S - 51
1581        assert!(blocks[1] == [17593880, 17593908]);
1582
1583        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1584        //11S7M1I32M - 52
1585        assert!(blocks[0] == [17596476, 17596483]);
1586        //11S7M1I32M - 52
1587        assert!(blocks[1] == [17596483, 17596515]);
1588
1589        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1590        //5S9M1892N37M - 53
1591        assert!(blocks[0] == [17624012, 17624021]);
1592        //5S9M1892N37M - 53
1593        assert!(blocks[1] == [17625913, 17625950]);
1594
1595        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1596        //2S9M1892N40M - 54
1597        assert!(blocks[0] == [17624012, 17624021]);
1598        //2S9M1892N40M - 54
1599        assert!(blocks[1] == [17625913, 17625953]);
1600
1601        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1602        //1S7M3D19M2285N24M - 55
1603        assert!(blocks[0] == [31796700, 31796707]);
1604        //1S7M3D19M2285N24M - 55
1605        assert!(blocks[1] == [31796710, 31796729]);
1606        //1S7M3D19M2285N24M - 55
1607        assert!(blocks[2] == [31799014, 31799038]);
1608
1609        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1610        //14M799N28M13881N7M2S - 56
1611        assert!(blocks[0] == [36722692, 36722706]);
1612        //14M799N28M13881N7M2S - 56
1613        assert!(blocks[1] == [36723505, 36723533]);
1614        //14M799N28M13881N7M2S - 56
1615        assert!(blocks[2] == [36737414, 36737421]);
1616
1617        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
1618        //4S21M1696N23M2331N3M - 57
1619        assert!(blocks[0] == [44587963, 44587984]);
1620        //4S21M1696N23M2331N3M - 57
1621        assert!(blocks[1] == [44589680, 44589703]);
1622        //4S21M1696N23M2331N3M - 57
1623        assert!(blocks[2] == [44592034, 44592037]);
1624    }
1625
1626    #[test]
1627    fn test_introns() {
1628        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
1629        let mut it = bam.records();
1630
1631        //6S45M - 0
1632        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1633        assert_eq!(introns.len(), 0);
1634        //7M2D44M - 1
1635        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1636        assert_eq!(introns.len(), 0);
1637        //29M2D22M - 2
1638        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1639        assert_eq!(introns.len(), 0);
1640        //51M - 3
1641        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1642        assert_eq!(introns.len(), 0);
1643        //51M - 4
1644        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1645        assert_eq!(introns.len(), 0);
1646        //51M - 5
1647        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1648        assert_eq!(introns.len(), 0);
1649        //51M - 6
1650        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1651        assert_eq!(introns.len(), 0);
1652        //51M - 7
1653        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1654        assert_eq!(introns.len(), 0);
1655        //51M - 8
1656        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1657        assert_eq!(introns.len(), 0);
1658        //6S45M - 9
1659        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1660        assert_eq!(introns.len(), 0);
1661        //41M10S - 10
1662        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1663        assert_eq!(introns.len(), 0);
1664        //51M - 11
1665        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1666        assert_eq!(introns.len(), 0);
1667        //51M - 12
1668        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1669        assert_eq!(introns.len(), 0);
1670        //51M - 13
1671        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1672        assert_eq!(introns.len(), 0);
1673        //51M - 14
1674        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1675        assert_eq!(introns.len(), 0);
1676        //9S42M - 15
1677        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1678        assert_eq!(introns.len(), 0);
1679        //51M - 16
1680        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1681        assert_eq!(introns.len(), 0);
1682        //50M1S - 17
1683        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1684        assert_eq!(introns.len(), 0);
1685        //45M6S - 18
1686        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1687        assert_eq!(introns.len(), 0);
1688        //3S48M - 19
1689        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1690        assert_eq!(introns.len(), 0);
1691        //42M9S - 20
1692        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1693        assert_eq!(introns.len(), 0);
1694        //13S38M - 21
1695        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1696        assert_eq!(introns.len(), 0);
1697        //44M7S - 22
1698        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1699        assert_eq!(introns.len(), 0);
1700        //5S46M - 23
1701        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1702        assert_eq!(introns.len(), 0);
1703        //23M4I24M - 24
1704        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1705        assert_eq!(introns.len(), 0);
1706        //18M1I32M - 25
1707        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1708        assert_eq!(introns.len(), 0);
1709        //17M2183N34M - 26
1710        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1711        assert_eq!(introns.len(), 1);
1712        assert_eq!(introns[0], [17092783, 17094966]);
1713        //1M2183N50M - 27
1714        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1715        assert_eq!(introns.len(), 1);
1716        assert_eq!(introns[0], [17092783, 17094966]);
1717        //1M2183N50M - 28
1718        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1719        assert_eq!(introns.len(), 1);
1720        assert_eq!(introns[0], [17092783, 17094966]);
1721        //9S33M9S - 29
1722        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1723        assert_eq!(introns.len(), 0);
1724        //2S48M1S - 30
1725        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1726        assert_eq!(introns.len(), 0);
1727        //4S45M2S - 31
1728        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1729        assert_eq!(introns.len(), 0);
1730        //41M11832N10M - 32
1731        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1732        assert_eq!(introns.len(), 1);
1733        assert_eq!(introns[0], [17566119, 17577951]);
1734        //11M11832N25M710N15M - 33
1735        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1736        assert_eq!(introns.len(), 2);
1737        assert_eq!(introns[0], [17566119, 17577951]);
1738        assert_eq!(introns[1], [17577976, 17578686]);
1739        //8M11832N25M710N18M - 34
1740        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1741        assert_eq!(introns.len(), 2);
1742        assert_eq!(introns[0], [17566119, 17577951]);
1743        assert_eq!(introns[1], [17577976, 17578686]);
1744        //8M11832N25M710N18M - 35
1745        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1746        assert_eq!(introns.len(), 2);
1747        assert_eq!(introns[0], [17566119, 17577951]);
1748        assert_eq!(introns[1], [17577976, 17578686]);
1749        //8M11832N25M710N18M - 36
1750        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1751        assert_eq!(introns.len(), 2);
1752        assert_eq!(introns[0], [17566119, 17577951]);
1753        assert_eq!(introns[1], [17577976, 17578686]);
1754        //8M11832N25M710N18M - 37
1755        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1756        assert_eq!(introns.len(), 2);
1757        assert_eq!(introns[0], [17566119, 17577951]);
1758        assert_eq!(introns[1], [17577976, 17578686]);
1759        //7M11832N25M710N19M - 38
1760        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1761        assert_eq!(introns.len(), 2);
1762        assert_eq!(introns[0], [17566119, 17577951]);
1763        assert_eq!(introns[1], [17577976, 17578686]);
1764        //6M11832N25M710N20M - 39
1765        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1766        assert_eq!(introns.len(), 2);
1767        assert_eq!(introns[0], [17566119, 17577951]);
1768        assert_eq!(introns[1], [17577976, 17578686]);
1769        //6M11832N25M710N20M - 40
1770        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1771        assert_eq!(introns.len(), 2);
1772        assert_eq!(introns[0], [17566119, 17577951]);
1773        assert_eq!(introns[1], [17577976, 17578686]);
1774        //1S44M1467N6M - 41
1775        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1776        assert_eq!(introns.len(), 1);
1777        assert_eq!(introns[0], [17579777, 17581244]);
1778        //2M1514N48M95N1M - 42
1779        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1780        assert_eq!(introns.len(), 2);
1781        assert_eq!(introns[0], [17581371, 17582885]);
1782        assert_eq!(introns[1], [17582933, 17583028]);
1783        //1M1514N48M95N2M - 43
1784        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1785        assert_eq!(introns.len(), 2);
1786        assert_eq!(introns[0], [17581371, 17582885]);
1787        assert_eq!(introns[1], [17582933, 17583028]);
1788        //1M1514N48M95N2M - 44
1789        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1790        assert_eq!(introns.len(), 2);
1791        assert_eq!(introns[0], [17581371, 17582885]);
1792        assert_eq!(introns[1], [17582933, 17583028]);
1793        //1S22M95N28M - 45
1794        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1795        assert_eq!(introns.len(), 1);
1796        assert_eq!(introns[0], [17582933, 17583028]);
1797        //37M538N13M1S - 46
1798        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1799        assert_eq!(introns.len(), 1);
1800        assert_eq!(introns[0], [17588658, 17589196]);
1801        //37M538N13M1S - 47
1802        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1803        assert_eq!(introns.len(), 1);
1804        assert_eq!(introns[0], [17588658, 17589196]);
1805        //37M538N13M1S - 48
1806        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1807        assert_eq!(introns.len(), 1);
1808        assert_eq!(introns[0], [17588658, 17589196]);
1809        //1S25M1D25M - 49
1810        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1811        assert_eq!(introns.len(), 0);
1812        //24M1D24M3S - 50
1813        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1814        assert_eq!(introns.len(), 0);
1815        //16M1D28M7S - 51
1816        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1817        assert_eq!(introns.len(), 0);
1818        //11S7M1I32M - 52
1819        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1820        assert_eq!(introns.len(), 0);
1821        //5S9M1892N37M - 53
1822        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1823        assert_eq!(introns.len(), 1);
1824        assert_eq!(introns[0], [17624021, 17625913]);
1825        //2S9M1892N40M - 54
1826        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1827        assert_eq!(introns.len(), 1);
1828        assert_eq!(introns[0], [17624021, 17625913]);
1829        //1S7M3D19M2285N24M - 55
1830        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1831        assert_eq!(introns.len(), 1);
1832        assert_eq!(introns[0], [31796729, 31799014]);
1833        //14M799N28M13881N7M2S - 56
1834        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1835        assert_eq!(introns.len(), 2);
1836        assert_eq!(introns[0], [36722706, 36723505]);
1837        assert_eq!(introns[1], [36723533, 36737414]);
1838        //4S21M1696N23M2331N3M - 57
1839        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
1840        assert_eq!(introns.len(), 2);
1841        assert_eq!(introns[0], [44587984, 44589680]);
1842        assert_eq!(introns[1], [44589703, 44592034]);
1843    }
1844
1845    #[test]
1846    fn test_aligned_pairs() {
1847        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
1848        let mut it = bam.records();
1849
1850        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
1851        assert_eq!(
1852            pairs,
1853            vec![
1854                [6, 16050676],
1855                [7, 16050677],
1856                [8, 16050678],
1857                [9, 16050679],
1858                [10, 16050680],
1859                [11, 16050681],
1860                [12, 16050682],
1861                [13, 16050683],
1862                [14, 16050684],
1863                [15, 16050685],
1864                [16, 16050686],
1865                [17, 16050687],
1866                [18, 16050688],
1867                [19, 16050689],
1868                [20, 16050690],
1869                [21, 16050691],
1870                [22, 16050692],
1871                [23, 16050693],
1872                [24, 16050694],
1873                [25, 16050695],
1874                [26, 16050696],
1875                [27, 16050697],
1876                [28, 16050698],
1877                [29, 16050699],
1878                [30, 16050700],
1879                [31, 16050701],
1880                [32, 16050702],
1881                [33, 16050703],
1882                [34, 16050704],
1883                [35, 16050705],
1884                [36, 16050706],
1885                [37, 16050707],
1886                [38, 16050708],
1887                [39, 16050709],
1888                [40, 16050710],
1889                [41, 16050711],
1890                [42, 16050712],
1891                [43, 16050713],
1892                [44, 16050714],
1893                [45, 16050715],
1894                [46, 16050716],
1895                [47, 16050717],
1896                [48, 16050718],
1897                [49, 16050719],
1898                [50, 16050720]
1899            ]
1900        );
1901        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
1902        assert_eq!(
1903            pairs,
1904            vec![
1905                [0, 16096878],
1906                [1, 16096879],
1907                [2, 16096880],
1908                [3, 16096881],
1909                [4, 16096882],
1910                [5, 16096883],
1911                [6, 16096884],
1912                [7, 16096887],
1913                [8, 16096888],
1914                [9, 16096889],
1915                [10, 16096890],
1916                [11, 16096891],
1917                [12, 16096892],
1918                [13, 16096893],
1919                [14, 16096894],
1920                [15, 16096895],
1921                [16, 16096896],
1922                [17, 16096897],
1923                [18, 16096898],
1924                [19, 16096899],
1925                [20, 16096900],
1926                [21, 16096901],
1927                [22, 16096902],
1928                [23, 16096903],
1929                [24, 16096904],
1930                [25, 16096905],
1931                [26, 16096906],
1932                [27, 16096907],
1933                [28, 16096908],
1934                [29, 16096909],
1935                [30, 16096910],
1936                [31, 16096911],
1937                [32, 16096912],
1938                [33, 16096913],
1939                [34, 16096914],
1940                [35, 16096915],
1941                [36, 16096916],
1942                [37, 16096917],
1943                [38, 16096918],
1944                [39, 16096919],
1945                [40, 16096920],
1946                [41, 16096921],
1947                [42, 16096922],
1948                [43, 16096923],
1949                [44, 16096924],
1950                [45, 16096925],
1951                [46, 16096926],
1952                [47, 16096927],
1953                [48, 16096928],
1954                [49, 16096929],
1955                [50, 16096930]
1956            ]
1957        );
1958        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
1959        assert_eq!(
1960            pairs,
1961            vec![
1962                [0, 16097145],
1963                [1, 16097146],
1964                [2, 16097147],
1965                [3, 16097148],
1966                [4, 16097149],
1967                [5, 16097150],
1968                [6, 16097151],
1969                [7, 16097152],
1970                [8, 16097153],
1971                [9, 16097154],
1972                [10, 16097155],
1973                [11, 16097156],
1974                [12, 16097157],
1975                [13, 16097158],
1976                [14, 16097159],
1977                [15, 16097160],
1978                [16, 16097161],
1979                [17, 16097162],
1980                [18, 16097163],
1981                [19, 16097164],
1982                [20, 16097165],
1983                [21, 16097166],
1984                [22, 16097167],
1985                [23, 16097168],
1986                [24, 16097169],
1987                [25, 16097170],
1988                [26, 16097171],
1989                [27, 16097172],
1990                [28, 16097173],
1991                [29, 16097176],
1992                [30, 16097177],
1993                [31, 16097178],
1994                [32, 16097179],
1995                [33, 16097180],
1996                [34, 16097181],
1997                [35, 16097182],
1998                [36, 16097183],
1999                [37, 16097184],
2000                [38, 16097185],
2001                [39, 16097186],
2002                [40, 16097187],
2003                [41, 16097188],
2004                [42, 16097189],
2005                [43, 16097190],
2006                [44, 16097191],
2007                [45, 16097192],
2008                [46, 16097193],
2009                [47, 16097194],
2010                [48, 16097195],
2011                [49, 16097196],
2012                [50, 16097197]
2013            ]
2014        );
2015        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
2016        assert_eq!(
2017            pairs,
2018            vec![
2019                [0, 16117350],
2020                [1, 16117351],
2021                [2, 16117352],
2022                [3, 16117353],
2023                [4, 16117354],
2024                [5, 16117355],
2025                [6, 16117356],
2026                [7, 16117357],
2027                [8, 16117358],
2028                [9, 16117359],
2029                [10, 16117360],
2030                [11, 16117361],
2031                [12, 16117362],
2032                [13, 16117363],
2033                [14, 16117364],
2034                [15, 16117365],
2035                [16, 16117366],
2036                [17, 16117367],
2037                [18, 16117368],
2038                [19, 16117369],
2039                [20, 16117370],
2040                [21, 16117371],
2041                [22, 16117372],
2042                [23, 16117373],
2043                [24, 16117374],
2044                [25, 16117375],
2045                [26, 16117376],
2046                [27, 16117377],
2047                [28, 16117378],
2048                [29, 16117379],
2049                [30, 16117380],
2050                [31, 16117381],
2051                [32, 16117382],
2052                [33, 16117383],
2053                [34, 16117384],
2054                [35, 16117385],
2055                [36, 16117386],
2056                [37, 16117387],
2057                [38, 16117388],
2058                [39, 16117389],
2059                [40, 16117390],
2060                [41, 16117391],
2061                [42, 16117392],
2062                [43, 16117393],
2063                [44, 16117394],
2064                [45, 16117395],
2065                [46, 16117396],
2066                [47, 16117397],
2067                [48, 16117398],
2068                [49, 16117399],
2069                [50, 16117400]
2070            ]
2071        );
2072        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
2073        assert_eq!(
2074            pairs,
2075            vec![
2076                [0, 16118483],
2077                [1, 16118484],
2078                [2, 16118485],
2079                [3, 16118486],
2080                [4, 16118487],
2081                [5, 16118488],
2082                [6, 16118489],
2083                [7, 16118490],
2084                [8, 16118491],
2085                [9, 16118492],
2086                [10, 16118493],
2087                [11, 16118494],
2088                [12, 16118495],
2089                [13, 16118496],
2090                [14, 16118497],
2091                [15, 16118498],
2092                [16, 16118499],
2093                [17, 16118500],
2094                [18, 16118501],
2095                [19, 16118502],
2096                [20, 16118503],
2097                [21, 16118504],
2098                [22, 16118505],
2099                [23, 16118506],
2100                [24, 16118507],
2101                [25, 16118508],
2102                [26, 16118509],
2103                [27, 16118510],
2104                [28, 16118511],
2105                [29, 16118512],
2106                [30, 16118513],
2107                [31, 16118514],
2108                [32, 16118515],
2109                [33, 16118516],
2110                [34, 16118517],
2111                [35, 16118518],
2112                [36, 16118519],
2113                [37, 16118520],
2114                [38, 16118521],
2115                [39, 16118522],
2116                [40, 16118523],
2117                [41, 16118524],
2118                [42, 16118525],
2119                [43, 16118526],
2120                [44, 16118527],
2121                [45, 16118528],
2122                [46, 16118529],
2123                [47, 16118530],
2124                [48, 16118531],
2125                [49, 16118532],
2126                [50, 16118533]
2127            ]
2128        );
2129        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
2130        assert_eq!(
2131            pairs,
2132            vec![
2133                [0, 16118499],
2134                [1, 16118500],
2135                [2, 16118501],
2136                [3, 16118502],
2137                [4, 16118503],
2138                [5, 16118504],
2139                [6, 16118505],
2140                [7, 16118506],
2141                [8, 16118507],
2142                [9, 16118508],
2143                [10, 16118509],
2144                [11, 16118510],
2145                [12, 16118511],
2146                [13, 16118512],
2147                [14, 16118513],
2148                [15, 16118514],
2149                [16, 16118515],
2150                [17, 16118516],
2151                [18, 16118517],
2152                [19, 16118518],
2153                [20, 16118519],
2154                [21, 16118520],
2155                [22, 16118521],
2156                [23, 16118522],
2157                [24, 16118523],
2158                [25, 16118524],
2159                [26, 16118525],
2160                [27, 16118526],
2161                [28, 16118527],
2162                [29, 16118528],
2163                [30, 16118529],
2164                [31, 16118530],
2165                [32, 16118531],
2166                [33, 16118532],
2167                [34, 16118533],
2168                [35, 16118534],
2169                [36, 16118535],
2170                [37, 16118536],
2171                [38, 16118537],
2172                [39, 16118538],
2173                [40, 16118539],
2174                [41, 16118540],
2175                [42, 16118541],
2176                [43, 16118542],
2177                [44, 16118543],
2178                [45, 16118544],
2179                [46, 16118545],
2180                [47, 16118546],
2181                [48, 16118547],
2182                [49, 16118548],
2183                [50, 16118549]
2184            ]
2185        );
2186        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
2187        assert_eq!(
2188            pairs,
2189            vec![
2190                [0, 16118499],
2191                [1, 16118500],
2192                [2, 16118501],
2193                [3, 16118502],
2194                [4, 16118503],
2195                [5, 16118504],
2196                [6, 16118505],
2197                [7, 16118506],
2198                [8, 16118507],
2199                [9, 16118508],
2200                [10, 16118509],
2201                [11, 16118510],
2202                [12, 16118511],
2203                [13, 16118512],
2204                [14, 16118513],
2205                [15, 16118514],
2206                [16, 16118515],
2207                [17, 16118516],
2208                [18, 16118517],
2209                [19, 16118518],
2210                [20, 16118519],
2211                [21, 16118520],
2212                [22, 16118521],
2213                [23, 16118522],
2214                [24, 16118523],
2215                [25, 16118524],
2216                [26, 16118525],
2217                [27, 16118526],
2218                [28, 16118527],
2219                [29, 16118528],
2220                [30, 16118529],
2221                [31, 16118530],
2222                [32, 16118531],
2223                [33, 16118532],
2224                [34, 16118533],
2225                [35, 16118534],
2226                [36, 16118535],
2227                [37, 16118536],
2228                [38, 16118537],
2229                [39, 16118538],
2230                [40, 16118539],
2231                [41, 16118540],
2232                [42, 16118541],
2233                [43, 16118542],
2234                [44, 16118543],
2235                [45, 16118544],
2236                [46, 16118545],
2237                [47, 16118546],
2238                [48, 16118547],
2239                [49, 16118548],
2240                [50, 16118549]
2241            ]
2242        );
2243        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
2244        assert_eq!(
2245            pairs,
2246            vec![
2247                [0, 16118499],
2248                [1, 16118500],
2249                [2, 16118501],
2250                [3, 16118502],
2251                [4, 16118503],
2252                [5, 16118504],
2253                [6, 16118505],
2254                [7, 16118506],
2255                [8, 16118507],
2256                [9, 16118508],
2257                [10, 16118509],
2258                [11, 16118510],
2259                [12, 16118511],
2260                [13, 16118512],
2261                [14, 16118513],
2262                [15, 16118514],
2263                [16, 16118515],
2264                [17, 16118516],
2265                [18, 16118517],
2266                [19, 16118518],
2267                [20, 16118519],
2268                [21, 16118520],
2269                [22, 16118521],
2270                [23, 16118522],
2271                [24, 16118523],
2272                [25, 16118524],
2273                [26, 16118525],
2274                [27, 16118526],
2275                [28, 16118527],
2276                [29, 16118528],
2277                [30, 16118529],
2278                [31, 16118530],
2279                [32, 16118531],
2280                [33, 16118532],
2281                [34, 16118533],
2282                [35, 16118534],
2283                [36, 16118535],
2284                [37, 16118536],
2285                [38, 16118537],
2286                [39, 16118538],
2287                [40, 16118539],
2288                [41, 16118540],
2289                [42, 16118541],
2290                [43, 16118542],
2291                [44, 16118543],
2292                [45, 16118544],
2293                [46, 16118545],
2294                [47, 16118546],
2295                [48, 16118547],
2296                [49, 16118548],
2297                [50, 16118549]
2298            ]
2299        );
2300        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
2301        assert_eq!(
2302            pairs,
2303            vec![
2304                [0, 16123411],
2305                [1, 16123412],
2306                [2, 16123413],
2307                [3, 16123414],
2308                [4, 16123415],
2309                [5, 16123416],
2310                [6, 16123417],
2311                [7, 16123418],
2312                [8, 16123419],
2313                [9, 16123420],
2314                [10, 16123421],
2315                [11, 16123422],
2316                [12, 16123423],
2317                [13, 16123424],
2318                [14, 16123425],
2319                [15, 16123426],
2320                [16, 16123427],
2321                [17, 16123428],
2322                [18, 16123429],
2323                [19, 16123430],
2324                [20, 16123431],
2325                [21, 16123432],
2326                [22, 16123433],
2327                [23, 16123434],
2328                [24, 16123435],
2329                [25, 16123436],
2330                [26, 16123437],
2331                [27, 16123438],
2332                [28, 16123439],
2333                [29, 16123440],
2334                [30, 16123441],
2335                [31, 16123442],
2336                [32, 16123443],
2337                [33, 16123444],
2338                [34, 16123445],
2339                [35, 16123446],
2340                [36, 16123447],
2341                [37, 16123448],
2342                [38, 16123449],
2343                [39, 16123450],
2344                [40, 16123451],
2345                [41, 16123452],
2346                [42, 16123453],
2347                [43, 16123454],
2348                [44, 16123455],
2349                [45, 16123456],
2350                [46, 16123457],
2351                [47, 16123458],
2352                [48, 16123459],
2353                [49, 16123460],
2354                [50, 16123461]
2355            ]
2356        );
2357        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
2358        assert_eq!(
2359            pairs,
2360            vec![
2361                [6, 16123417],
2362                [7, 16123418],
2363                [8, 16123419],
2364                [9, 16123420],
2365                [10, 16123421],
2366                [11, 16123422],
2367                [12, 16123423],
2368                [13, 16123424],
2369                [14, 16123425],
2370                [15, 16123426],
2371                [16, 16123427],
2372                [17, 16123428],
2373                [18, 16123429],
2374                [19, 16123430],
2375                [20, 16123431],
2376                [21, 16123432],
2377                [22, 16123433],
2378                [23, 16123434],
2379                [24, 16123435],
2380                [25, 16123436],
2381                [26, 16123437],
2382                [27, 16123438],
2383                [28, 16123439],
2384                [29, 16123440],
2385                [30, 16123441],
2386                [31, 16123442],
2387                [32, 16123443],
2388                [33, 16123444],
2389                [34, 16123445],
2390                [35, 16123446],
2391                [36, 16123447],
2392                [37, 16123448],
2393                [38, 16123449],
2394                [39, 16123450],
2395                [40, 16123451],
2396                [41, 16123452],
2397                [42, 16123453],
2398                [43, 16123454],
2399                [44, 16123455],
2400                [45, 16123456],
2401                [46, 16123457],
2402                [47, 16123458],
2403                [48, 16123459],
2404                [49, 16123460],
2405                [50, 16123461]
2406            ]
2407        );
2408        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
2409        assert_eq!(
2410            pairs,
2411            vec![
2412                [0, 16165860],
2413                [1, 16165861],
2414                [2, 16165862],
2415                [3, 16165863],
2416                [4, 16165864],
2417                [5, 16165865],
2418                [6, 16165866],
2419                [7, 16165867],
2420                [8, 16165868],
2421                [9, 16165869],
2422                [10, 16165870],
2423                [11, 16165871],
2424                [12, 16165872],
2425                [13, 16165873],
2426                [14, 16165874],
2427                [15, 16165875],
2428                [16, 16165876],
2429                [17, 16165877],
2430                [18, 16165878],
2431                [19, 16165879],
2432                [20, 16165880],
2433                [21, 16165881],
2434                [22, 16165882],
2435                [23, 16165883],
2436                [24, 16165884],
2437                [25, 16165885],
2438                [26, 16165886],
2439                [27, 16165887],
2440                [28, 16165888],
2441                [29, 16165889],
2442                [30, 16165890],
2443                [31, 16165891],
2444                [32, 16165892],
2445                [33, 16165893],
2446                [34, 16165894],
2447                [35, 16165895],
2448                [36, 16165896],
2449                [37, 16165897],
2450                [38, 16165898],
2451                [39, 16165899],
2452                [40, 16165900]
2453            ]
2454        );
2455        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
2456        assert_eq!(
2457            pairs,
2458            vec![
2459                [0, 16180871],
2460                [1, 16180872],
2461                [2, 16180873],
2462                [3, 16180874],
2463                [4, 16180875],
2464                [5, 16180876],
2465                [6, 16180877],
2466                [7, 16180878],
2467                [8, 16180879],
2468                [9, 16180880],
2469                [10, 16180881],
2470                [11, 16180882],
2471                [12, 16180883],
2472                [13, 16180884],
2473                [14, 16180885],
2474                [15, 16180886],
2475                [16, 16180887],
2476                [17, 16180888],
2477                [18, 16180889],
2478                [19, 16180890],
2479                [20, 16180891],
2480                [21, 16180892],
2481                [22, 16180893],
2482                [23, 16180894],
2483                [24, 16180895],
2484                [25, 16180896],
2485                [26, 16180897],
2486                [27, 16180898],
2487                [28, 16180899],
2488                [29, 16180900],
2489                [30, 16180901],
2490                [31, 16180902],
2491                [32, 16180903],
2492                [33, 16180904],
2493                [34, 16180905],
2494                [35, 16180906],
2495                [36, 16180907],
2496                [37, 16180908],
2497                [38, 16180909],
2498                [39, 16180910],
2499                [40, 16180911],
2500                [41, 16180912],
2501                [42, 16180913],
2502                [43, 16180914],
2503                [44, 16180915],
2504                [45, 16180916],
2505                [46, 16180917],
2506                [47, 16180918],
2507                [48, 16180919],
2508                [49, 16180920],
2509                [50, 16180921]
2510            ]
2511        );
2512        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
2513        assert_eq!(
2514            pairs,
2515            vec![
2516                [0, 16189705],
2517                [1, 16189706],
2518                [2, 16189707],
2519                [3, 16189708],
2520                [4, 16189709],
2521                [5, 16189710],
2522                [6, 16189711],
2523                [7, 16189712],
2524                [8, 16189713],
2525                [9, 16189714],
2526                [10, 16189715],
2527                [11, 16189716],
2528                [12, 16189717],
2529                [13, 16189718],
2530                [14, 16189719],
2531                [15, 16189720],
2532                [16, 16189721],
2533                [17, 16189722],
2534                [18, 16189723],
2535                [19, 16189724],
2536                [20, 16189725],
2537                [21, 16189726],
2538                [22, 16189727],
2539                [23, 16189728],
2540                [24, 16189729],
2541                [25, 16189730],
2542                [26, 16189731],
2543                [27, 16189732],
2544                [28, 16189733],
2545                [29, 16189734],
2546                [30, 16189735],
2547                [31, 16189736],
2548                [32, 16189737],
2549                [33, 16189738],
2550                [34, 16189739],
2551                [35, 16189740],
2552                [36, 16189741],
2553                [37, 16189742],
2554                [38, 16189743],
2555                [39, 16189744],
2556                [40, 16189745],
2557                [41, 16189746],
2558                [42, 16189747],
2559                [43, 16189748],
2560                [44, 16189749],
2561                [45, 16189750],
2562                [46, 16189751],
2563                [47, 16189752],
2564                [48, 16189753],
2565                [49, 16189754],
2566                [50, 16189755]
2567            ]
2568        );
2569        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
2570        assert_eq!(
2571            pairs,
2572            vec![
2573                [0, 16231271],
2574                [1, 16231272],
2575                [2, 16231273],
2576                [3, 16231274],
2577                [4, 16231275],
2578                [5, 16231276],
2579                [6, 16231277],
2580                [7, 16231278],
2581                [8, 16231279],
2582                [9, 16231280],
2583                [10, 16231281],
2584                [11, 16231282],
2585                [12, 16231283],
2586                [13, 16231284],
2587                [14, 16231285],
2588                [15, 16231286],
2589                [16, 16231287],
2590                [17, 16231288],
2591                [18, 16231289],
2592                [19, 16231290],
2593                [20, 16231291],
2594                [21, 16231292],
2595                [22, 16231293],
2596                [23, 16231294],
2597                [24, 16231295],
2598                [25, 16231296],
2599                [26, 16231297],
2600                [27, 16231298],
2601                [28, 16231299],
2602                [29, 16231300],
2603                [30, 16231301],
2604                [31, 16231302],
2605                [32, 16231303],
2606                [33, 16231304],
2607                [34, 16231305],
2608                [35, 16231306],
2609                [36, 16231307],
2610                [37, 16231308],
2611                [38, 16231309],
2612                [39, 16231310],
2613                [40, 16231311],
2614                [41, 16231312],
2615                [42, 16231313],
2616                [43, 16231314],
2617                [44, 16231315],
2618                [45, 16231316],
2619                [46, 16231317],
2620                [47, 16231318],
2621                [48, 16231319],
2622                [49, 16231320],
2623                [50, 16231321]
2624            ]
2625        );
2626        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
2627        assert_eq!(
2628            pairs,
2629            vec![
2630                [0, 16237657],
2631                [1, 16237658],
2632                [2, 16237659],
2633                [3, 16237660],
2634                [4, 16237661],
2635                [5, 16237662],
2636                [6, 16237663],
2637                [7, 16237664],
2638                [8, 16237665],
2639                [9, 16237666],
2640                [10, 16237667],
2641                [11, 16237668],
2642                [12, 16237669],
2643                [13, 16237670],
2644                [14, 16237671],
2645                [15, 16237672],
2646                [16, 16237673],
2647                [17, 16237674],
2648                [18, 16237675],
2649                [19, 16237676],
2650                [20, 16237677],
2651                [21, 16237678],
2652                [22, 16237679],
2653                [23, 16237680],
2654                [24, 16237681],
2655                [25, 16237682],
2656                [26, 16237683],
2657                [27, 16237684],
2658                [28, 16237685],
2659                [29, 16237686],
2660                [30, 16237687],
2661                [31, 16237688],
2662                [32, 16237689],
2663                [33, 16237690],
2664                [34, 16237691],
2665                [35, 16237692],
2666                [36, 16237693],
2667                [37, 16237694],
2668                [38, 16237695],
2669                [39, 16237696],
2670                [40, 16237697],
2671                [41, 16237698],
2672                [42, 16237699],
2673                [43, 16237700],
2674                [44, 16237701],
2675                [45, 16237702],
2676                [46, 16237703],
2677                [47, 16237704],
2678                [48, 16237705],
2679                [49, 16237706],
2680                [50, 16237707]
2681            ]
2682        );
2683        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
2684        assert_eq!(
2685            pairs,
2686            vec![
2687                [9, 16255012],
2688                [10, 16255013],
2689                [11, 16255014],
2690                [12, 16255015],
2691                [13, 16255016],
2692                [14, 16255017],
2693                [15, 16255018],
2694                [16, 16255019],
2695                [17, 16255020],
2696                [18, 16255021],
2697                [19, 16255022],
2698                [20, 16255023],
2699                [21, 16255024],
2700                [22, 16255025],
2701                [23, 16255026],
2702                [24, 16255027],
2703                [25, 16255028],
2704                [26, 16255029],
2705                [27, 16255030],
2706                [28, 16255031],
2707                [29, 16255032],
2708                [30, 16255033],
2709                [31, 16255034],
2710                [32, 16255035],
2711                [33, 16255036],
2712                [34, 16255037],
2713                [35, 16255038],
2714                [36, 16255039],
2715                [37, 16255040],
2716                [38, 16255041],
2717                [39, 16255042],
2718                [40, 16255043],
2719                [41, 16255044],
2720                [42, 16255045],
2721                [43, 16255046],
2722                [44, 16255047],
2723                [45, 16255048],
2724                [46, 16255049],
2725                [47, 16255050],
2726                [48, 16255051],
2727                [49, 16255052],
2728                [50, 16255053]
2729            ]
2730        );
2731        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
2732        assert_eq!(
2733            pairs,
2734            vec![
2735                [0, 16255391],
2736                [1, 16255392],
2737                [2, 16255393],
2738                [3, 16255394],
2739                [4, 16255395],
2740                [5, 16255396],
2741                [6, 16255397],
2742                [7, 16255398],
2743                [8, 16255399],
2744                [9, 16255400],
2745                [10, 16255401],
2746                [11, 16255402],
2747                [12, 16255403],
2748                [13, 16255404],
2749                [14, 16255405],
2750                [15, 16255406],
2751                [16, 16255407],
2752                [17, 16255408],
2753                [18, 16255409],
2754                [19, 16255410],
2755                [20, 16255411],
2756                [21, 16255412],
2757                [22, 16255413],
2758                [23, 16255414],
2759                [24, 16255415],
2760                [25, 16255416],
2761                [26, 16255417],
2762                [27, 16255418],
2763                [28, 16255419],
2764                [29, 16255420],
2765                [30, 16255421],
2766                [31, 16255422],
2767                [32, 16255423],
2768                [33, 16255424],
2769                [34, 16255425],
2770                [35, 16255426],
2771                [36, 16255427],
2772                [37, 16255428],
2773                [38, 16255429],
2774                [39, 16255430],
2775                [40, 16255431],
2776                [41, 16255432],
2777                [42, 16255433],
2778                [43, 16255434],
2779                [44, 16255435],
2780                [45, 16255436],
2781                [46, 16255437],
2782                [47, 16255438],
2783                [48, 16255439],
2784                [49, 16255440],
2785                [50, 16255441]
2786            ]
2787        );
2788        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
2789        assert_eq!(
2790            pairs,
2791            vec![
2792                [0, 16255392],
2793                [1, 16255393],
2794                [2, 16255394],
2795                [3, 16255395],
2796                [4, 16255396],
2797                [5, 16255397],
2798                [6, 16255398],
2799                [7, 16255399],
2800                [8, 16255400],
2801                [9, 16255401],
2802                [10, 16255402],
2803                [11, 16255403],
2804                [12, 16255404],
2805                [13, 16255405],
2806                [14, 16255406],
2807                [15, 16255407],
2808                [16, 16255408],
2809                [17, 16255409],
2810                [18, 16255410],
2811                [19, 16255411],
2812                [20, 16255412],
2813                [21, 16255413],
2814                [22, 16255414],
2815                [23, 16255415],
2816                [24, 16255416],
2817                [25, 16255417],
2818                [26, 16255418],
2819                [27, 16255419],
2820                [28, 16255420],
2821                [29, 16255421],
2822                [30, 16255422],
2823                [31, 16255423],
2824                [32, 16255424],
2825                [33, 16255425],
2826                [34, 16255426],
2827                [35, 16255427],
2828                [36, 16255428],
2829                [37, 16255429],
2830                [38, 16255430],
2831                [39, 16255431],
2832                [40, 16255432],
2833                [41, 16255433],
2834                [42, 16255434],
2835                [43, 16255435],
2836                [44, 16255436],
2837                [45, 16255437],
2838                [46, 16255438],
2839                [47, 16255439],
2840                [48, 16255440],
2841                [49, 16255441]
2842            ]
2843        );
2844        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
2845        assert_eq!(
2846            pairs,
2847            vec![
2848                [0, 16256084],
2849                [1, 16256085],
2850                [2, 16256086],
2851                [3, 16256087],
2852                [4, 16256088],
2853                [5, 16256089],
2854                [6, 16256090],
2855                [7, 16256091],
2856                [8, 16256092],
2857                [9, 16256093],
2858                [10, 16256094],
2859                [11, 16256095],
2860                [12, 16256096],
2861                [13, 16256097],
2862                [14, 16256098],
2863                [15, 16256099],
2864                [16, 16256100],
2865                [17, 16256101],
2866                [18, 16256102],
2867                [19, 16256103],
2868                [20, 16256104],
2869                [21, 16256105],
2870                [22, 16256106],
2871                [23, 16256107],
2872                [24, 16256108],
2873                [25, 16256109],
2874                [26, 16256110],
2875                [27, 16256111],
2876                [28, 16256112],
2877                [29, 16256113],
2878                [30, 16256114],
2879                [31, 16256115],
2880                [32, 16256116],
2881                [33, 16256117],
2882                [34, 16256118],
2883                [35, 16256119],
2884                [36, 16256120],
2885                [37, 16256121],
2886                [38, 16256122],
2887                [39, 16256123],
2888                [40, 16256124],
2889                [41, 16256125],
2890                [42, 16256126],
2891                [43, 16256127],
2892                [44, 16256128]
2893            ]
2894        );
2895        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
2896        assert_eq!(
2897            pairs,
2898            vec![
2899                [3, 16256224],
2900                [4, 16256225],
2901                [5, 16256226],
2902                [6, 16256227],
2903                [7, 16256228],
2904                [8, 16256229],
2905                [9, 16256230],
2906                [10, 16256231],
2907                [11, 16256232],
2908                [12, 16256233],
2909                [13, 16256234],
2910                [14, 16256235],
2911                [15, 16256236],
2912                [16, 16256237],
2913                [17, 16256238],
2914                [18, 16256239],
2915                [19, 16256240],
2916                [20, 16256241],
2917                [21, 16256242],
2918                [22, 16256243],
2919                [23, 16256244],
2920                [24, 16256245],
2921                [25, 16256246],
2922                [26, 16256247],
2923                [27, 16256248],
2924                [28, 16256249],
2925                [29, 16256250],
2926                [30, 16256251],
2927                [31, 16256252],
2928                [32, 16256253],
2929                [33, 16256254],
2930                [34, 16256255],
2931                [35, 16256256],
2932                [36, 16256257],
2933                [37, 16256258],
2934                [38, 16256259],
2935                [39, 16256260],
2936                [40, 16256261],
2937                [41, 16256262],
2938                [42, 16256263],
2939                [43, 16256264],
2940                [44, 16256265],
2941                [45, 16256266],
2942                [46, 16256267],
2943                [47, 16256268],
2944                [48, 16256269],
2945                [49, 16256270],
2946                [50, 16256271]
2947            ]
2948        );
2949        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
2950        assert_eq!(
2951            pairs,
2952            vec![
2953                [0, 16325199],
2954                [1, 16325200],
2955                [2, 16325201],
2956                [3, 16325202],
2957                [4, 16325203],
2958                [5, 16325204],
2959                [6, 16325205],
2960                [7, 16325206],
2961                [8, 16325207],
2962                [9, 16325208],
2963                [10, 16325209],
2964                [11, 16325210],
2965                [12, 16325211],
2966                [13, 16325212],
2967                [14, 16325213],
2968                [15, 16325214],
2969                [16, 16325215],
2970                [17, 16325216],
2971                [18, 16325217],
2972                [19, 16325218],
2973                [20, 16325219],
2974                [21, 16325220],
2975                [22, 16325221],
2976                [23, 16325222],
2977                [24, 16325223],
2978                [25, 16325224],
2979                [26, 16325225],
2980                [27, 16325226],
2981                [28, 16325227],
2982                [29, 16325228],
2983                [30, 16325229],
2984                [31, 16325230],
2985                [32, 16325231],
2986                [33, 16325232],
2987                [34, 16325233],
2988                [35, 16325234],
2989                [36, 16325235],
2990                [37, 16325236],
2991                [38, 16325237],
2992                [39, 16325238],
2993                [40, 16325239],
2994                [41, 16325240]
2995            ]
2996        );
2997        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
2998        assert_eq!(
2999            pairs,
3000            vec![
3001                [13, 16352865],
3002                [14, 16352866],
3003                [15, 16352867],
3004                [16, 16352868],
3005                [17, 16352869],
3006                [18, 16352870],
3007                [19, 16352871],
3008                [20, 16352872],
3009                [21, 16352873],
3010                [22, 16352874],
3011                [23, 16352875],
3012                [24, 16352876],
3013                [25, 16352877],
3014                [26, 16352878],
3015                [27, 16352879],
3016                [28, 16352880],
3017                [29, 16352881],
3018                [30, 16352882],
3019                [31, 16352883],
3020                [32, 16352884],
3021                [33, 16352885],
3022                [34, 16352886],
3023                [35, 16352887],
3024                [36, 16352888],
3025                [37, 16352889],
3026                [38, 16352890],
3027                [39, 16352891],
3028                [40, 16352892],
3029                [41, 16352893],
3030                [42, 16352894],
3031                [43, 16352895],
3032                [44, 16352896],
3033                [45, 16352897],
3034                [46, 16352898],
3035                [47, 16352899],
3036                [48, 16352900],
3037                [49, 16352901],
3038                [50, 16352902]
3039            ]
3040        );
3041        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3042        assert_eq!(
3043            pairs,
3044            vec![
3045                [0, 16352968],
3046                [1, 16352969],
3047                [2, 16352970],
3048                [3, 16352971],
3049                [4, 16352972],
3050                [5, 16352973],
3051                [6, 16352974],
3052                [7, 16352975],
3053                [8, 16352976],
3054                [9, 16352977],
3055                [10, 16352978],
3056                [11, 16352979],
3057                [12, 16352980],
3058                [13, 16352981],
3059                [14, 16352982],
3060                [15, 16352983],
3061                [16, 16352984],
3062                [17, 16352985],
3063                [18, 16352986],
3064                [19, 16352987],
3065                [20, 16352988],
3066                [21, 16352989],
3067                [22, 16352990],
3068                [23, 16352991],
3069                [24, 16352992],
3070                [25, 16352993],
3071                [26, 16352994],
3072                [27, 16352995],
3073                [28, 16352996],
3074                [29, 16352997],
3075                [30, 16352998],
3076                [31, 16352999],
3077                [32, 16353000],
3078                [33, 16353001],
3079                [34, 16353002],
3080                [35, 16353003],
3081                [36, 16353004],
3082                [37, 16353005],
3083                [38, 16353006],
3084                [39, 16353007],
3085                [40, 16353008],
3086                [41, 16353009],
3087                [42, 16353010],
3088                [43, 16353011]
3089            ]
3090        );
3091        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3092        assert_eq!(
3093            pairs,
3094            vec![
3095                [5, 16414998],
3096                [6, 16414999],
3097                [7, 16415000],
3098                [8, 16415001],
3099                [9, 16415002],
3100                [10, 16415003],
3101                [11, 16415004],
3102                [12, 16415005],
3103                [13, 16415006],
3104                [14, 16415007],
3105                [15, 16415008],
3106                [16, 16415009],
3107                [17, 16415010],
3108                [18, 16415011],
3109                [19, 16415012],
3110                [20, 16415013],
3111                [21, 16415014],
3112                [22, 16415015],
3113                [23, 16415016],
3114                [24, 16415017],
3115                [25, 16415018],
3116                [26, 16415019],
3117                [27, 16415020],
3118                [28, 16415021],
3119                [29, 16415022],
3120                [30, 16415023],
3121                [31, 16415024],
3122                [32, 16415025],
3123                [33, 16415026],
3124                [34, 16415027],
3125                [35, 16415028],
3126                [36, 16415029],
3127                [37, 16415030],
3128                [38, 16415031],
3129                [39, 16415032],
3130                [40, 16415033],
3131                [41, 16415034],
3132                [42, 16415035],
3133                [43, 16415036],
3134                [44, 16415037],
3135                [45, 16415038],
3136                [46, 16415039],
3137                [47, 16415040],
3138                [48, 16415041],
3139                [49, 16415042],
3140                [50, 16415043]
3141            ]
3142        );
3143        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3144        assert_eq!(
3145            pairs,
3146            vec![
3147                [0, 17031591],
3148                [1, 17031592],
3149                [2, 17031593],
3150                [3, 17031594],
3151                [4, 17031595],
3152                [5, 17031596],
3153                [6, 17031597],
3154                [7, 17031598],
3155                [8, 17031599],
3156                [9, 17031600],
3157                [10, 17031601],
3158                [11, 17031602],
3159                [12, 17031603],
3160                [13, 17031604],
3161                [14, 17031605],
3162                [15, 17031606],
3163                [16, 17031607],
3164                [17, 17031608],
3165                [18, 17031609],
3166                [19, 17031610],
3167                [20, 17031611],
3168                [21, 17031612],
3169                [22, 17031613],
3170                [27, 17031614],
3171                [28, 17031615],
3172                [29, 17031616],
3173                [30, 17031617],
3174                [31, 17031618],
3175                [32, 17031619],
3176                [33, 17031620],
3177                [34, 17031621],
3178                [35, 17031622],
3179                [36, 17031623],
3180                [37, 17031624],
3181                [38, 17031625],
3182                [39, 17031626],
3183                [40, 17031627],
3184                [41, 17031628],
3185                [42, 17031629],
3186                [43, 17031630],
3187                [44, 17031631],
3188                [45, 17031632],
3189                [46, 17031633],
3190                [47, 17031634],
3191                [48, 17031635],
3192                [49, 17031636],
3193                [50, 17031637]
3194            ]
3195        );
3196        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3197        assert_eq!(
3198            pairs,
3199            vec![
3200                [0, 17057382],
3201                [1, 17057383],
3202                [2, 17057384],
3203                [3, 17057385],
3204                [4, 17057386],
3205                [5, 17057387],
3206                [6, 17057388],
3207                [7, 17057389],
3208                [8, 17057390],
3209                [9, 17057391],
3210                [10, 17057392],
3211                [11, 17057393],
3212                [12, 17057394],
3213                [13, 17057395],
3214                [14, 17057396],
3215                [15, 17057397],
3216                [16, 17057398],
3217                [17, 17057399],
3218                [19, 17057400],
3219                [20, 17057401],
3220                [21, 17057402],
3221                [22, 17057403],
3222                [23, 17057404],
3223                [24, 17057405],
3224                [25, 17057406],
3225                [26, 17057407],
3226                [27, 17057408],
3227                [28, 17057409],
3228                [29, 17057410],
3229                [30, 17057411],
3230                [31, 17057412],
3231                [32, 17057413],
3232                [33, 17057414],
3233                [34, 17057415],
3234                [35, 17057416],
3235                [36, 17057417],
3236                [37, 17057418],
3237                [38, 17057419],
3238                [39, 17057420],
3239                [40, 17057421],
3240                [41, 17057422],
3241                [42, 17057423],
3242                [43, 17057424],
3243                [44, 17057425],
3244                [45, 17057426],
3245                [46, 17057427],
3246                [47, 17057428],
3247                [48, 17057429],
3248                [49, 17057430],
3249                [50, 17057431]
3250            ]
3251        );
3252        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3253        assert_eq!(
3254            pairs,
3255            vec![
3256                [0, 17092766],
3257                [1, 17092767],
3258                [2, 17092768],
3259                [3, 17092769],
3260                [4, 17092770],
3261                [5, 17092771],
3262                [6, 17092772],
3263                [7, 17092773],
3264                [8, 17092774],
3265                [9, 17092775],
3266                [10, 17092776],
3267                [11, 17092777],
3268                [12, 17092778],
3269                [13, 17092779],
3270                [14, 17092780],
3271                [15, 17092781],
3272                [16, 17092782],
3273                [17, 17094966],
3274                [18, 17094967],
3275                [19, 17094968],
3276                [20, 17094969],
3277                [21, 17094970],
3278                [22, 17094971],
3279                [23, 17094972],
3280                [24, 17094973],
3281                [25, 17094974],
3282                [26, 17094975],
3283                [27, 17094976],
3284                [28, 17094977],
3285                [29, 17094978],
3286                [30, 17094979],
3287                [31, 17094980],
3288                [32, 17094981],
3289                [33, 17094982],
3290                [34, 17094983],
3291                [35, 17094984],
3292                [36, 17094985],
3293                [37, 17094986],
3294                [38, 17094987],
3295                [39, 17094988],
3296                [40, 17094989],
3297                [41, 17094990],
3298                [42, 17094991],
3299                [43, 17094992],
3300                [44, 17094993],
3301                [45, 17094994],
3302                [46, 17094995],
3303                [47, 17094996],
3304                [48, 17094997],
3305                [49, 17094998],
3306                [50, 17094999]
3307            ]
3308        );
3309        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3310        assert_eq!(
3311            pairs,
3312            vec![
3313                [0, 17092782],
3314                [1, 17094966],
3315                [2, 17094967],
3316                [3, 17094968],
3317                [4, 17094969],
3318                [5, 17094970],
3319                [6, 17094971],
3320                [7, 17094972],
3321                [8, 17094973],
3322                [9, 17094974],
3323                [10, 17094975],
3324                [11, 17094976],
3325                [12, 17094977],
3326                [13, 17094978],
3327                [14, 17094979],
3328                [15, 17094980],
3329                [16, 17094981],
3330                [17, 17094982],
3331                [18, 17094983],
3332                [19, 17094984],
3333                [20, 17094985],
3334                [21, 17094986],
3335                [22, 17094987],
3336                [23, 17094988],
3337                [24, 17094989],
3338                [25, 17094990],
3339                [26, 17094991],
3340                [27, 17094992],
3341                [28, 17094993],
3342                [29, 17094994],
3343                [30, 17094995],
3344                [31, 17094996],
3345                [32, 17094997],
3346                [33, 17094998],
3347                [34, 17094999],
3348                [35, 17095000],
3349                [36, 17095001],
3350                [37, 17095002],
3351                [38, 17095003],
3352                [39, 17095004],
3353                [40, 17095005],
3354                [41, 17095006],
3355                [42, 17095007],
3356                [43, 17095008],
3357                [44, 17095009],
3358                [45, 17095010],
3359                [46, 17095011],
3360                [47, 17095012],
3361                [48, 17095013],
3362                [49, 17095014],
3363                [50, 17095015]
3364            ]
3365        );
3366        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3367        assert_eq!(
3368            pairs,
3369            vec![
3370                [0, 17092782],
3371                [1, 17094966],
3372                [2, 17094967],
3373                [3, 17094968],
3374                [4, 17094969],
3375                [5, 17094970],
3376                [6, 17094971],
3377                [7, 17094972],
3378                [8, 17094973],
3379                [9, 17094974],
3380                [10, 17094975],
3381                [11, 17094976],
3382                [12, 17094977],
3383                [13, 17094978],
3384                [14, 17094979],
3385                [15, 17094980],
3386                [16, 17094981],
3387                [17, 17094982],
3388                [18, 17094983],
3389                [19, 17094984],
3390                [20, 17094985],
3391                [21, 17094986],
3392                [22, 17094987],
3393                [23, 17094988],
3394                [24, 17094989],
3395                [25, 17094990],
3396                [26, 17094991],
3397                [27, 17094992],
3398                [28, 17094993],
3399                [29, 17094994],
3400                [30, 17094995],
3401                [31, 17094996],
3402                [32, 17094997],
3403                [33, 17094998],
3404                [34, 17094999],
3405                [35, 17095000],
3406                [36, 17095001],
3407                [37, 17095002],
3408                [38, 17095003],
3409                [39, 17095004],
3410                [40, 17095005],
3411                [41, 17095006],
3412                [42, 17095007],
3413                [43, 17095008],
3414                [44, 17095009],
3415                [45, 17095010],
3416                [46, 17095011],
3417                [47, 17095012],
3418                [48, 17095013],
3419                [49, 17095014],
3420                [50, 17095015]
3421            ]
3422        );
3423        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3424        assert_eq!(
3425            pairs,
3426            vec![
3427                [9, 17137287],
3428                [10, 17137288],
3429                [11, 17137289],
3430                [12, 17137290],
3431                [13, 17137291],
3432                [14, 17137292],
3433                [15, 17137293],
3434                [16, 17137294],
3435                [17, 17137295],
3436                [18, 17137296],
3437                [19, 17137297],
3438                [20, 17137298],
3439                [21, 17137299],
3440                [22, 17137300],
3441                [23, 17137301],
3442                [24, 17137302],
3443                [25, 17137303],
3444                [26, 17137304],
3445                [27, 17137305],
3446                [28, 17137306],
3447                [29, 17137307],
3448                [30, 17137308],
3449                [31, 17137309],
3450                [32, 17137310],
3451                [33, 17137311],
3452                [34, 17137312],
3453                [35, 17137313],
3454                [36, 17137314],
3455                [37, 17137315],
3456                [38, 17137316],
3457                [39, 17137317],
3458                [40, 17137318],
3459                [41, 17137319]
3460            ]
3461        );
3462        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3463        assert_eq!(
3464            pairs,
3465            vec![
3466                [2, 17306238],
3467                [3, 17306239],
3468                [4, 17306240],
3469                [5, 17306241],
3470                [6, 17306242],
3471                [7, 17306243],
3472                [8, 17306244],
3473                [9, 17306245],
3474                [10, 17306246],
3475                [11, 17306247],
3476                [12, 17306248],
3477                [13, 17306249],
3478                [14, 17306250],
3479                [15, 17306251],
3480                [16, 17306252],
3481                [17, 17306253],
3482                [18, 17306254],
3483                [19, 17306255],
3484                [20, 17306256],
3485                [21, 17306257],
3486                [22, 17306258],
3487                [23, 17306259],
3488                [24, 17306260],
3489                [25, 17306261],
3490                [26, 17306262],
3491                [27, 17306263],
3492                [28, 17306264],
3493                [29, 17306265],
3494                [30, 17306266],
3495                [31, 17306267],
3496                [32, 17306268],
3497                [33, 17306269],
3498                [34, 17306270],
3499                [35, 17306271],
3500                [36, 17306272],
3501                [37, 17306273],
3502                [38, 17306274],
3503                [39, 17306275],
3504                [40, 17306276],
3505                [41, 17306277],
3506                [42, 17306278],
3507                [43, 17306279],
3508                [44, 17306280],
3509                [45, 17306281],
3510                [46, 17306282],
3511                [47, 17306283],
3512                [48, 17306284],
3513                [49, 17306285]
3514            ]
3515        );
3516        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3517        assert_eq!(
3518            pairs,
3519            vec![
3520                [4, 17561868],
3521                [5, 17561869],
3522                [6, 17561870],
3523                [7, 17561871],
3524                [8, 17561872],
3525                [9, 17561873],
3526                [10, 17561874],
3527                [11, 17561875],
3528                [12, 17561876],
3529                [13, 17561877],
3530                [14, 17561878],
3531                [15, 17561879],
3532                [16, 17561880],
3533                [17, 17561881],
3534                [18, 17561882],
3535                [19, 17561883],
3536                [20, 17561884],
3537                [21, 17561885],
3538                [22, 17561886],
3539                [23, 17561887],
3540                [24, 17561888],
3541                [25, 17561889],
3542                [26, 17561890],
3543                [27, 17561891],
3544                [28, 17561892],
3545                [29, 17561893],
3546                [30, 17561894],
3547                [31, 17561895],
3548                [32, 17561896],
3549                [33, 17561897],
3550                [34, 17561898],
3551                [35, 17561899],
3552                [36, 17561900],
3553                [37, 17561901],
3554                [38, 17561902],
3555                [39, 17561903],
3556                [40, 17561904],
3557                [41, 17561905],
3558                [42, 17561906],
3559                [43, 17561907],
3560                [44, 17561908],
3561                [45, 17561909],
3562                [46, 17561910],
3563                [47, 17561911],
3564                [48, 17561912]
3565            ]
3566        );
3567        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3568        assert_eq!(
3569            pairs,
3570            vec![
3571                [0, 17566078],
3572                [1, 17566079],
3573                [2, 17566080],
3574                [3, 17566081],
3575                [4, 17566082],
3576                [5, 17566083],
3577                [6, 17566084],
3578                [7, 17566085],
3579                [8, 17566086],
3580                [9, 17566087],
3581                [10, 17566088],
3582                [11, 17566089],
3583                [12, 17566090],
3584                [13, 17566091],
3585                [14, 17566092],
3586                [15, 17566093],
3587                [16, 17566094],
3588                [17, 17566095],
3589                [18, 17566096],
3590                [19, 17566097],
3591                [20, 17566098],
3592                [21, 17566099],
3593                [22, 17566100],
3594                [23, 17566101],
3595                [24, 17566102],
3596                [25, 17566103],
3597                [26, 17566104],
3598                [27, 17566105],
3599                [28, 17566106],
3600                [29, 17566107],
3601                [30, 17566108],
3602                [31, 17566109],
3603                [32, 17566110],
3604                [33, 17566111],
3605                [34, 17566112],
3606                [35, 17566113],
3607                [36, 17566114],
3608                [37, 17566115],
3609                [38, 17566116],
3610                [39, 17566117],
3611                [40, 17566118],
3612                [41, 17577951],
3613                [42, 17577952],
3614                [43, 17577953],
3615                [44, 17577954],
3616                [45, 17577955],
3617                [46, 17577956],
3618                [47, 17577957],
3619                [48, 17577958],
3620                [49, 17577959],
3621                [50, 17577960]
3622            ]
3623        );
3624        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3625        assert_eq!(
3626            pairs,
3627            vec![
3628                [0, 17566108],
3629                [1, 17566109],
3630                [2, 17566110],
3631                [3, 17566111],
3632                [4, 17566112],
3633                [5, 17566113],
3634                [6, 17566114],
3635                [7, 17566115],
3636                [8, 17566116],
3637                [9, 17566117],
3638                [10, 17566118],
3639                [11, 17577951],
3640                [12, 17577952],
3641                [13, 17577953],
3642                [14, 17577954],
3643                [15, 17577955],
3644                [16, 17577956],
3645                [17, 17577957],
3646                [18, 17577958],
3647                [19, 17577959],
3648                [20, 17577960],
3649                [21, 17577961],
3650                [22, 17577962],
3651                [23, 17577963],
3652                [24, 17577964],
3653                [25, 17577965],
3654                [26, 17577966],
3655                [27, 17577967],
3656                [28, 17577968],
3657                [29, 17577969],
3658                [30, 17577970],
3659                [31, 17577971],
3660                [32, 17577972],
3661                [33, 17577973],
3662                [34, 17577974],
3663                [35, 17577975],
3664                [36, 17578686],
3665                [37, 17578687],
3666                [38, 17578688],
3667                [39, 17578689],
3668                [40, 17578690],
3669                [41, 17578691],
3670                [42, 17578692],
3671                [43, 17578693],
3672                [44, 17578694],
3673                [45, 17578695],
3674                [46, 17578696],
3675                [47, 17578697],
3676                [48, 17578698],
3677                [49, 17578699],
3678                [50, 17578700]
3679            ]
3680        );
3681        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3682        assert_eq!(
3683            pairs,
3684            vec![
3685                [0, 17566111],
3686                [1, 17566112],
3687                [2, 17566113],
3688                [3, 17566114],
3689                [4, 17566115],
3690                [5, 17566116],
3691                [6, 17566117],
3692                [7, 17566118],
3693                [8, 17577951],
3694                [9, 17577952],
3695                [10, 17577953],
3696                [11, 17577954],
3697                [12, 17577955],
3698                [13, 17577956],
3699                [14, 17577957],
3700                [15, 17577958],
3701                [16, 17577959],
3702                [17, 17577960],
3703                [18, 17577961],
3704                [19, 17577962],
3705                [20, 17577963],
3706                [21, 17577964],
3707                [22, 17577965],
3708                [23, 17577966],
3709                [24, 17577967],
3710                [25, 17577968],
3711                [26, 17577969],
3712                [27, 17577970],
3713                [28, 17577971],
3714                [29, 17577972],
3715                [30, 17577973],
3716                [31, 17577974],
3717                [32, 17577975],
3718                [33, 17578686],
3719                [34, 17578687],
3720                [35, 17578688],
3721                [36, 17578689],
3722                [37, 17578690],
3723                [38, 17578691],
3724                [39, 17578692],
3725                [40, 17578693],
3726                [41, 17578694],
3727                [42, 17578695],
3728                [43, 17578696],
3729                [44, 17578697],
3730                [45, 17578698],
3731                [46, 17578699],
3732                [47, 17578700],
3733                [48, 17578701],
3734                [49, 17578702],
3735                [50, 17578703]
3736            ]
3737        );
3738        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3739        assert_eq!(
3740            pairs,
3741            vec![
3742                [0, 17566111],
3743                [1, 17566112],
3744                [2, 17566113],
3745                [3, 17566114],
3746                [4, 17566115],
3747                [5, 17566116],
3748                [6, 17566117],
3749                [7, 17566118],
3750                [8, 17577951],
3751                [9, 17577952],
3752                [10, 17577953],
3753                [11, 17577954],
3754                [12, 17577955],
3755                [13, 17577956],
3756                [14, 17577957],
3757                [15, 17577958],
3758                [16, 17577959],
3759                [17, 17577960],
3760                [18, 17577961],
3761                [19, 17577962],
3762                [20, 17577963],
3763                [21, 17577964],
3764                [22, 17577965],
3765                [23, 17577966],
3766                [24, 17577967],
3767                [25, 17577968],
3768                [26, 17577969],
3769                [27, 17577970],
3770                [28, 17577971],
3771                [29, 17577972],
3772                [30, 17577973],
3773                [31, 17577974],
3774                [32, 17577975],
3775                [33, 17578686],
3776                [34, 17578687],
3777                [35, 17578688],
3778                [36, 17578689],
3779                [37, 17578690],
3780                [38, 17578691],
3781                [39, 17578692],
3782                [40, 17578693],
3783                [41, 17578694],
3784                [42, 17578695],
3785                [43, 17578696],
3786                [44, 17578697],
3787                [45, 17578698],
3788                [46, 17578699],
3789                [47, 17578700],
3790                [48, 17578701],
3791                [49, 17578702],
3792                [50, 17578703]
3793            ]
3794        );
3795        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3796        assert_eq!(
3797            pairs,
3798            vec![
3799                [0, 17566111],
3800                [1, 17566112],
3801                [2, 17566113],
3802                [3, 17566114],
3803                [4, 17566115],
3804                [5, 17566116],
3805                [6, 17566117],
3806                [7, 17566118],
3807                [8, 17577951],
3808                [9, 17577952],
3809                [10, 17577953],
3810                [11, 17577954],
3811                [12, 17577955],
3812                [13, 17577956],
3813                [14, 17577957],
3814                [15, 17577958],
3815                [16, 17577959],
3816                [17, 17577960],
3817                [18, 17577961],
3818                [19, 17577962],
3819                [20, 17577963],
3820                [21, 17577964],
3821                [22, 17577965],
3822                [23, 17577966],
3823                [24, 17577967],
3824                [25, 17577968],
3825                [26, 17577969],
3826                [27, 17577970],
3827                [28, 17577971],
3828                [29, 17577972],
3829                [30, 17577973],
3830                [31, 17577974],
3831                [32, 17577975],
3832                [33, 17578686],
3833                [34, 17578687],
3834                [35, 17578688],
3835                [36, 17578689],
3836                [37, 17578690],
3837                [38, 17578691],
3838                [39, 17578692],
3839                [40, 17578693],
3840                [41, 17578694],
3841                [42, 17578695],
3842                [43, 17578696],
3843                [44, 17578697],
3844                [45, 17578698],
3845                [46, 17578699],
3846                [47, 17578700],
3847                [48, 17578701],
3848                [49, 17578702],
3849                [50, 17578703]
3850            ]
3851        );
3852        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3853        assert_eq!(
3854            pairs,
3855            vec![
3856                [0, 17566111],
3857                [1, 17566112],
3858                [2, 17566113],
3859                [3, 17566114],
3860                [4, 17566115],
3861                [5, 17566116],
3862                [6, 17566117],
3863                [7, 17566118],
3864                [8, 17577951],
3865                [9, 17577952],
3866                [10, 17577953],
3867                [11, 17577954],
3868                [12, 17577955],
3869                [13, 17577956],
3870                [14, 17577957],
3871                [15, 17577958],
3872                [16, 17577959],
3873                [17, 17577960],
3874                [18, 17577961],
3875                [19, 17577962],
3876                [20, 17577963],
3877                [21, 17577964],
3878                [22, 17577965],
3879                [23, 17577966],
3880                [24, 17577967],
3881                [25, 17577968],
3882                [26, 17577969],
3883                [27, 17577970],
3884                [28, 17577971],
3885                [29, 17577972],
3886                [30, 17577973],
3887                [31, 17577974],
3888                [32, 17577975],
3889                [33, 17578686],
3890                [34, 17578687],
3891                [35, 17578688],
3892                [36, 17578689],
3893                [37, 17578690],
3894                [38, 17578691],
3895                [39, 17578692],
3896                [40, 17578693],
3897                [41, 17578694],
3898                [42, 17578695],
3899                [43, 17578696],
3900                [44, 17578697],
3901                [45, 17578698],
3902                [46, 17578699],
3903                [47, 17578700],
3904                [48, 17578701],
3905                [49, 17578702],
3906                [50, 17578703]
3907            ]
3908        );
3909        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3910        assert_eq!(
3911            pairs,
3912            vec![
3913                [0, 17566112],
3914                [1, 17566113],
3915                [2, 17566114],
3916                [3, 17566115],
3917                [4, 17566116],
3918                [5, 17566117],
3919                [6, 17566118],
3920                [7, 17577951],
3921                [8, 17577952],
3922                [9, 17577953],
3923                [10, 17577954],
3924                [11, 17577955],
3925                [12, 17577956],
3926                [13, 17577957],
3927                [14, 17577958],
3928                [15, 17577959],
3929                [16, 17577960],
3930                [17, 17577961],
3931                [18, 17577962],
3932                [19, 17577963],
3933                [20, 17577964],
3934                [21, 17577965],
3935                [22, 17577966],
3936                [23, 17577967],
3937                [24, 17577968],
3938                [25, 17577969],
3939                [26, 17577970],
3940                [27, 17577971],
3941                [28, 17577972],
3942                [29, 17577973],
3943                [30, 17577974],
3944                [31, 17577975],
3945                [32, 17578686],
3946                [33, 17578687],
3947                [34, 17578688],
3948                [35, 17578689],
3949                [36, 17578690],
3950                [37, 17578691],
3951                [38, 17578692],
3952                [39, 17578693],
3953                [40, 17578694],
3954                [41, 17578695],
3955                [42, 17578696],
3956                [43, 17578697],
3957                [44, 17578698],
3958                [45, 17578699],
3959                [46, 17578700],
3960                [47, 17578701],
3961                [48, 17578702],
3962                [49, 17578703],
3963                [50, 17578704]
3964            ]
3965        );
3966        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3967        assert_eq!(
3968            pairs,
3969            vec![
3970                [0, 17566113],
3971                [1, 17566114],
3972                [2, 17566115],
3973                [3, 17566116],
3974                [4, 17566117],
3975                [5, 17566118],
3976                [6, 17577951],
3977                [7, 17577952],
3978                [8, 17577953],
3979                [9, 17577954],
3980                [10, 17577955],
3981                [11, 17577956],
3982                [12, 17577957],
3983                [13, 17577958],
3984                [14, 17577959],
3985                [15, 17577960],
3986                [16, 17577961],
3987                [17, 17577962],
3988                [18, 17577963],
3989                [19, 17577964],
3990                [20, 17577965],
3991                [21, 17577966],
3992                [22, 17577967],
3993                [23, 17577968],
3994                [24, 17577969],
3995                [25, 17577970],
3996                [26, 17577971],
3997                [27, 17577972],
3998                [28, 17577973],
3999                [29, 17577974],
4000                [30, 17577975],
4001                [31, 17578686],
4002                [32, 17578687],
4003                [33, 17578688],
4004                [34, 17578689],
4005                [35, 17578690],
4006                [36, 17578691],
4007                [37, 17578692],
4008                [38, 17578693],
4009                [39, 17578694],
4010                [40, 17578695],
4011                [41, 17578696],
4012                [42, 17578697],
4013                [43, 17578698],
4014                [44, 17578699],
4015                [45, 17578700],
4016                [46, 17578701],
4017                [47, 17578702],
4018                [48, 17578703],
4019                [49, 17578704],
4020                [50, 17578705]
4021            ]
4022        );
4023        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4024        assert_eq!(
4025            pairs,
4026            vec![
4027                [0, 17566113],
4028                [1, 17566114],
4029                [2, 17566115],
4030                [3, 17566116],
4031                [4, 17566117],
4032                [5, 17566118],
4033                [6, 17577951],
4034                [7, 17577952],
4035                [8, 17577953],
4036                [9, 17577954],
4037                [10, 17577955],
4038                [11, 17577956],
4039                [12, 17577957],
4040                [13, 17577958],
4041                [14, 17577959],
4042                [15, 17577960],
4043                [16, 17577961],
4044                [17, 17577962],
4045                [18, 17577963],
4046                [19, 17577964],
4047                [20, 17577965],
4048                [21, 17577966],
4049                [22, 17577967],
4050                [23, 17577968],
4051                [24, 17577969],
4052                [25, 17577970],
4053                [26, 17577971],
4054                [27, 17577972],
4055                [28, 17577973],
4056                [29, 17577974],
4057                [30, 17577975],
4058                [31, 17578686],
4059                [32, 17578687],
4060                [33, 17578688],
4061                [34, 17578689],
4062                [35, 17578690],
4063                [36, 17578691],
4064                [37, 17578692],
4065                [38, 17578693],
4066                [39, 17578694],
4067                [40, 17578695],
4068                [41, 17578696],
4069                [42, 17578697],
4070                [43, 17578698],
4071                [44, 17578699],
4072                [45, 17578700],
4073                [46, 17578701],
4074                [47, 17578702],
4075                [48, 17578703],
4076                [49, 17578704],
4077                [50, 17578705]
4078            ]
4079        );
4080        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4081        assert_eq!(
4082            pairs,
4083            vec![
4084                [1, 17579733],
4085                [2, 17579734],
4086                [3, 17579735],
4087                [4, 17579736],
4088                [5, 17579737],
4089                [6, 17579738],
4090                [7, 17579739],
4091                [8, 17579740],
4092                [9, 17579741],
4093                [10, 17579742],
4094                [11, 17579743],
4095                [12, 17579744],
4096                [13, 17579745],
4097                [14, 17579746],
4098                [15, 17579747],
4099                [16, 17579748],
4100                [17, 17579749],
4101                [18, 17579750],
4102                [19, 17579751],
4103                [20, 17579752],
4104                [21, 17579753],
4105                [22, 17579754],
4106                [23, 17579755],
4107                [24, 17579756],
4108                [25, 17579757],
4109                [26, 17579758],
4110                [27, 17579759],
4111                [28, 17579760],
4112                [29, 17579761],
4113                [30, 17579762],
4114                [31, 17579763],
4115                [32, 17579764],
4116                [33, 17579765],
4117                [34, 17579766],
4118                [35, 17579767],
4119                [36, 17579768],
4120                [37, 17579769],
4121                [38, 17579770],
4122                [39, 17579771],
4123                [40, 17579772],
4124                [41, 17579773],
4125                [42, 17579774],
4126                [43, 17579775],
4127                [44, 17579776],
4128                [45, 17581244],
4129                [46, 17581245],
4130                [47, 17581246],
4131                [48, 17581247],
4132                [49, 17581248],
4133                [50, 17581249]
4134            ]
4135        );
4136        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4137        assert_eq!(
4138            pairs,
4139            vec![
4140                [0, 17581369],
4141                [1, 17581370],
4142                [2, 17582885],
4143                [3, 17582886],
4144                [4, 17582887],
4145                [5, 17582888],
4146                [6, 17582889],
4147                [7, 17582890],
4148                [8, 17582891],
4149                [9, 17582892],
4150                [10, 17582893],
4151                [11, 17582894],
4152                [12, 17582895],
4153                [13, 17582896],
4154                [14, 17582897],
4155                [15, 17582898],
4156                [16, 17582899],
4157                [17, 17582900],
4158                [18, 17582901],
4159                [19, 17582902],
4160                [20, 17582903],
4161                [21, 17582904],
4162                [22, 17582905],
4163                [23, 17582906],
4164                [24, 17582907],
4165                [25, 17582908],
4166                [26, 17582909],
4167                [27, 17582910],
4168                [28, 17582911],
4169                [29, 17582912],
4170                [30, 17582913],
4171                [31, 17582914],
4172                [32, 17582915],
4173                [33, 17582916],
4174                [34, 17582917],
4175                [35, 17582918],
4176                [36, 17582919],
4177                [37, 17582920],
4178                [38, 17582921],
4179                [39, 17582922],
4180                [40, 17582923],
4181                [41, 17582924],
4182                [42, 17582925],
4183                [43, 17582926],
4184                [44, 17582927],
4185                [45, 17582928],
4186                [46, 17582929],
4187                [47, 17582930],
4188                [48, 17582931],
4189                [49, 17582932],
4190                [50, 17583028]
4191            ]
4192        );
4193        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4194        assert_eq!(
4195            pairs,
4196            vec![
4197                [0, 17581370],
4198                [1, 17582885],
4199                [2, 17582886],
4200                [3, 17582887],
4201                [4, 17582888],
4202                [5, 17582889],
4203                [6, 17582890],
4204                [7, 17582891],
4205                [8, 17582892],
4206                [9, 17582893],
4207                [10, 17582894],
4208                [11, 17582895],
4209                [12, 17582896],
4210                [13, 17582897],
4211                [14, 17582898],
4212                [15, 17582899],
4213                [16, 17582900],
4214                [17, 17582901],
4215                [18, 17582902],
4216                [19, 17582903],
4217                [20, 17582904],
4218                [21, 17582905],
4219                [22, 17582906],
4220                [23, 17582907],
4221                [24, 17582908],
4222                [25, 17582909],
4223                [26, 17582910],
4224                [27, 17582911],
4225                [28, 17582912],
4226                [29, 17582913],
4227                [30, 17582914],
4228                [31, 17582915],
4229                [32, 17582916],
4230                [33, 17582917],
4231                [34, 17582918],
4232                [35, 17582919],
4233                [36, 17582920],
4234                [37, 17582921],
4235                [38, 17582922],
4236                [39, 17582923],
4237                [40, 17582924],
4238                [41, 17582925],
4239                [42, 17582926],
4240                [43, 17582927],
4241                [44, 17582928],
4242                [45, 17582929],
4243                [46, 17582930],
4244                [47, 17582931],
4245                [48, 17582932],
4246                [49, 17583028],
4247                [50, 17583029]
4248            ]
4249        );
4250        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4251        assert_eq!(
4252            pairs,
4253            vec![
4254                [0, 17581370],
4255                [1, 17582885],
4256                [2, 17582886],
4257                [3, 17582887],
4258                [4, 17582888],
4259                [5, 17582889],
4260                [6, 17582890],
4261                [7, 17582891],
4262                [8, 17582892],
4263                [9, 17582893],
4264                [10, 17582894],
4265                [11, 17582895],
4266                [12, 17582896],
4267                [13, 17582897],
4268                [14, 17582898],
4269                [15, 17582899],
4270                [16, 17582900],
4271                [17, 17582901],
4272                [18, 17582902],
4273                [19, 17582903],
4274                [20, 17582904],
4275                [21, 17582905],
4276                [22, 17582906],
4277                [23, 17582907],
4278                [24, 17582908],
4279                [25, 17582909],
4280                [26, 17582910],
4281                [27, 17582911],
4282                [28, 17582912],
4283                [29, 17582913],
4284                [30, 17582914],
4285                [31, 17582915],
4286                [32, 17582916],
4287                [33, 17582917],
4288                [34, 17582918],
4289                [35, 17582919],
4290                [36, 17582920],
4291                [37, 17582921],
4292                [38, 17582922],
4293                [39, 17582923],
4294                [40, 17582924],
4295                [41, 17582925],
4296                [42, 17582926],
4297                [43, 17582927],
4298                [44, 17582928],
4299                [45, 17582929],
4300                [46, 17582930],
4301                [47, 17582931],
4302                [48, 17582932],
4303                [49, 17583028],
4304                [50, 17583029]
4305            ]
4306        );
4307        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4308        assert_eq!(
4309            pairs,
4310            vec![
4311                [1, 17582911],
4312                [2, 17582912],
4313                [3, 17582913],
4314                [4, 17582914],
4315                [5, 17582915],
4316                [6, 17582916],
4317                [7, 17582917],
4318                [8, 17582918],
4319                [9, 17582919],
4320                [10, 17582920],
4321                [11, 17582921],
4322                [12, 17582922],
4323                [13, 17582923],
4324                [14, 17582924],
4325                [15, 17582925],
4326                [16, 17582926],
4327                [17, 17582927],
4328                [18, 17582928],
4329                [19, 17582929],
4330                [20, 17582930],
4331                [21, 17582931],
4332                [22, 17582932],
4333                [23, 17583028],
4334                [24, 17583029],
4335                [25, 17583030],
4336                [26, 17583031],
4337                [27, 17583032],
4338                [28, 17583033],
4339                [29, 17583034],
4340                [30, 17583035],
4341                [31, 17583036],
4342                [32, 17583037],
4343                [33, 17583038],
4344                [34, 17583039],
4345                [35, 17583040],
4346                [36, 17583041],
4347                [37, 17583042],
4348                [38, 17583043],
4349                [39, 17583044],
4350                [40, 17583045],
4351                [41, 17583046],
4352                [42, 17583047],
4353                [43, 17583048],
4354                [44, 17583049],
4355                [45, 17583050],
4356                [46, 17583051],
4357                [47, 17583052],
4358                [48, 17583053],
4359                [49, 17583054],
4360                [50, 17583055]
4361            ]
4362        );
4363        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4364        assert_eq!(
4365            pairs,
4366            vec![
4367                [0, 17588621],
4368                [1, 17588622],
4369                [2, 17588623],
4370                [3, 17588624],
4371                [4, 17588625],
4372                [5, 17588626],
4373                [6, 17588627],
4374                [7, 17588628],
4375                [8, 17588629],
4376                [9, 17588630],
4377                [10, 17588631],
4378                [11, 17588632],
4379                [12, 17588633],
4380                [13, 17588634],
4381                [14, 17588635],
4382                [15, 17588636],
4383                [16, 17588637],
4384                [17, 17588638],
4385                [18, 17588639],
4386                [19, 17588640],
4387                [20, 17588641],
4388                [21, 17588642],
4389                [22, 17588643],
4390                [23, 17588644],
4391                [24, 17588645],
4392                [25, 17588646],
4393                [26, 17588647],
4394                [27, 17588648],
4395                [28, 17588649],
4396                [29, 17588650],
4397                [30, 17588651],
4398                [31, 17588652],
4399                [32, 17588653],
4400                [33, 17588654],
4401                [34, 17588655],
4402                [35, 17588656],
4403                [36, 17588657],
4404                [37, 17589196],
4405                [38, 17589197],
4406                [39, 17589198],
4407                [40, 17589199],
4408                [41, 17589200],
4409                [42, 17589201],
4410                [43, 17589202],
4411                [44, 17589203],
4412                [45, 17589204],
4413                [46, 17589205],
4414                [47, 17589206],
4415                [48, 17589207],
4416                [49, 17589208]
4417            ]
4418        );
4419        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4420        assert_eq!(
4421            pairs,
4422            vec![
4423                [0, 17588621],
4424                [1, 17588622],
4425                [2, 17588623],
4426                [3, 17588624],
4427                [4, 17588625],
4428                [5, 17588626],
4429                [6, 17588627],
4430                [7, 17588628],
4431                [8, 17588629],
4432                [9, 17588630],
4433                [10, 17588631],
4434                [11, 17588632],
4435                [12, 17588633],
4436                [13, 17588634],
4437                [14, 17588635],
4438                [15, 17588636],
4439                [16, 17588637],
4440                [17, 17588638],
4441                [18, 17588639],
4442                [19, 17588640],
4443                [20, 17588641],
4444                [21, 17588642],
4445                [22, 17588643],
4446                [23, 17588644],
4447                [24, 17588645],
4448                [25, 17588646],
4449                [26, 17588647],
4450                [27, 17588648],
4451                [28, 17588649],
4452                [29, 17588650],
4453                [30, 17588651],
4454                [31, 17588652],
4455                [32, 17588653],
4456                [33, 17588654],
4457                [34, 17588655],
4458                [35, 17588656],
4459                [36, 17588657],
4460                [37, 17589196],
4461                [38, 17589197],
4462                [39, 17589198],
4463                [40, 17589199],
4464                [41, 17589200],
4465                [42, 17589201],
4466                [43, 17589202],
4467                [44, 17589203],
4468                [45, 17589204],
4469                [46, 17589205],
4470                [47, 17589206],
4471                [48, 17589207],
4472                [49, 17589208]
4473            ]
4474        );
4475        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4476        assert_eq!(
4477            pairs,
4478            vec![
4479                [0, 17588621],
4480                [1, 17588622],
4481                [2, 17588623],
4482                [3, 17588624],
4483                [4, 17588625],
4484                [5, 17588626],
4485                [6, 17588627],
4486                [7, 17588628],
4487                [8, 17588629],
4488                [9, 17588630],
4489                [10, 17588631],
4490                [11, 17588632],
4491                [12, 17588633],
4492                [13, 17588634],
4493                [14, 17588635],
4494                [15, 17588636],
4495                [16, 17588637],
4496                [17, 17588638],
4497                [18, 17588639],
4498                [19, 17588640],
4499                [20, 17588641],
4500                [21, 17588642],
4501                [22, 17588643],
4502                [23, 17588644],
4503                [24, 17588645],
4504                [25, 17588646],
4505                [26, 17588647],
4506                [27, 17588648],
4507                [28, 17588649],
4508                [29, 17588650],
4509                [30, 17588651],
4510                [31, 17588652],
4511                [32, 17588653],
4512                [33, 17588654],
4513                [34, 17588655],
4514                [35, 17588656],
4515                [36, 17588657],
4516                [37, 17589196],
4517                [38, 17589197],
4518                [39, 17589198],
4519                [40, 17589199],
4520                [41, 17589200],
4521                [42, 17589201],
4522                [43, 17589202],
4523                [44, 17589203],
4524                [45, 17589204],
4525                [46, 17589205],
4526                [47, 17589206],
4527                [48, 17589207],
4528                [49, 17589208]
4529            ]
4530        );
4531        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4532        assert_eq!(
4533            pairs,
4534            vec![
4535                [1, 17591770],
4536                [2, 17591771],
4537                [3, 17591772],
4538                [4, 17591773],
4539                [5, 17591774],
4540                [6, 17591775],
4541                [7, 17591776],
4542                [8, 17591777],
4543                [9, 17591778],
4544                [10, 17591779],
4545                [11, 17591780],
4546                [12, 17591781],
4547                [13, 17591782],
4548                [14, 17591783],
4549                [15, 17591784],
4550                [16, 17591785],
4551                [17, 17591786],
4552                [18, 17591787],
4553                [19, 17591788],
4554                [20, 17591789],
4555                [21, 17591790],
4556                [22, 17591791],
4557                [23, 17591792],
4558                [24, 17591793],
4559                [25, 17591794],
4560                [26, 17591796],
4561                [27, 17591797],
4562                [28, 17591798],
4563                [29, 17591799],
4564                [30, 17591800],
4565                [31, 17591801],
4566                [32, 17591802],
4567                [33, 17591803],
4568                [34, 17591804],
4569                [35, 17591805],
4570                [36, 17591806],
4571                [37, 17591807],
4572                [38, 17591808],
4573                [39, 17591809],
4574                [40, 17591810],
4575                [41, 17591811],
4576                [42, 17591812],
4577                [43, 17591813],
4578                [44, 17591814],
4579                [45, 17591815],
4580                [46, 17591816],
4581                [47, 17591817],
4582                [48, 17591818],
4583                [49, 17591819],
4584                [50, 17591820]
4585            ]
4586        );
4587        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4588        assert_eq!(
4589            pairs,
4590            vec![
4591                [0, 17593855],
4592                [1, 17593856],
4593                [2, 17593857],
4594                [3, 17593858],
4595                [4, 17593859],
4596                [5, 17593860],
4597                [6, 17593861],
4598                [7, 17593862],
4599                [8, 17593863],
4600                [9, 17593864],
4601                [10, 17593865],
4602                [11, 17593866],
4603                [12, 17593867],
4604                [13, 17593868],
4605                [14, 17593869],
4606                [15, 17593870],
4607                [16, 17593871],
4608                [17, 17593872],
4609                [18, 17593873],
4610                [19, 17593874],
4611                [20, 17593875],
4612                [21, 17593876],
4613                [22, 17593877],
4614                [23, 17593878],
4615                [24, 17593880],
4616                [25, 17593881],
4617                [26, 17593882],
4618                [27, 17593883],
4619                [28, 17593884],
4620                [29, 17593885],
4621                [30, 17593886],
4622                [31, 17593887],
4623                [32, 17593888],
4624                [33, 17593889],
4625                [34, 17593890],
4626                [35, 17593891],
4627                [36, 17593892],
4628                [37, 17593893],
4629                [38, 17593894],
4630                [39, 17593895],
4631                [40, 17593896],
4632                [41, 17593897],
4633                [42, 17593898],
4634                [43, 17593899],
4635                [44, 17593900],
4636                [45, 17593901],
4637                [46, 17593902],
4638                [47, 17593903]
4639            ]
4640        );
4641        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4642        assert_eq!(
4643            pairs,
4644            vec![
4645                [0, 17593863],
4646                [1, 17593864],
4647                [2, 17593865],
4648                [3, 17593866],
4649                [4, 17593867],
4650                [5, 17593868],
4651                [6, 17593869],
4652                [7, 17593870],
4653                [8, 17593871],
4654                [9, 17593872],
4655                [10, 17593873],
4656                [11, 17593874],
4657                [12, 17593875],
4658                [13, 17593876],
4659                [14, 17593877],
4660                [15, 17593878],
4661                [16, 17593880],
4662                [17, 17593881],
4663                [18, 17593882],
4664                [19, 17593883],
4665                [20, 17593884],
4666                [21, 17593885],
4667                [22, 17593886],
4668                [23, 17593887],
4669                [24, 17593888],
4670                [25, 17593889],
4671                [26, 17593890],
4672                [27, 17593891],
4673                [28, 17593892],
4674                [29, 17593893],
4675                [30, 17593894],
4676                [31, 17593895],
4677                [32, 17593896],
4678                [33, 17593897],
4679                [34, 17593898],
4680                [35, 17593899],
4681                [36, 17593900],
4682                [37, 17593901],
4683                [38, 17593902],
4684                [39, 17593903],
4685                [40, 17593904],
4686                [41, 17593905],
4687                [42, 17593906],
4688                [43, 17593907]
4689            ]
4690        );
4691        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4692        assert_eq!(
4693            pairs,
4694            vec![
4695                [11, 17596476],
4696                [12, 17596477],
4697                [13, 17596478],
4698                [14, 17596479],
4699                [15, 17596480],
4700                [16, 17596481],
4701                [17, 17596482],
4702                [19, 17596483],
4703                [20, 17596484],
4704                [21, 17596485],
4705                [22, 17596486],
4706                [23, 17596487],
4707                [24, 17596488],
4708                [25, 17596489],
4709                [26, 17596490],
4710                [27, 17596491],
4711                [28, 17596492],
4712                [29, 17596493],
4713                [30, 17596494],
4714                [31, 17596495],
4715                [32, 17596496],
4716                [33, 17596497],
4717                [34, 17596498],
4718                [35, 17596499],
4719                [36, 17596500],
4720                [37, 17596501],
4721                [38, 17596502],
4722                [39, 17596503],
4723                [40, 17596504],
4724                [41, 17596505],
4725                [42, 17596506],
4726                [43, 17596507],
4727                [44, 17596508],
4728                [45, 17596509],
4729                [46, 17596510],
4730                [47, 17596511],
4731                [48, 17596512],
4732                [49, 17596513],
4733                [50, 17596514]
4734            ]
4735        );
4736        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4737        assert_eq!(
4738            pairs,
4739            vec![
4740                [5, 17624012],
4741                [6, 17624013],
4742                [7, 17624014],
4743                [8, 17624015],
4744                [9, 17624016],
4745                [10, 17624017],
4746                [11, 17624018],
4747                [12, 17624019],
4748                [13, 17624020],
4749                [14, 17625913],
4750                [15, 17625914],
4751                [16, 17625915],
4752                [17, 17625916],
4753                [18, 17625917],
4754                [19, 17625918],
4755                [20, 17625919],
4756                [21, 17625920],
4757                [22, 17625921],
4758                [23, 17625922],
4759                [24, 17625923],
4760                [25, 17625924],
4761                [26, 17625925],
4762                [27, 17625926],
4763                [28, 17625927],
4764                [29, 17625928],
4765                [30, 17625929],
4766                [31, 17625930],
4767                [32, 17625931],
4768                [33, 17625932],
4769                [34, 17625933],
4770                [35, 17625934],
4771                [36, 17625935],
4772                [37, 17625936],
4773                [38, 17625937],
4774                [39, 17625938],
4775                [40, 17625939],
4776                [41, 17625940],
4777                [42, 17625941],
4778                [43, 17625942],
4779                [44, 17625943],
4780                [45, 17625944],
4781                [46, 17625945],
4782                [47, 17625946],
4783                [48, 17625947],
4784                [49, 17625948],
4785                [50, 17625949]
4786            ]
4787        );
4788        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4789        assert_eq!(
4790            pairs,
4791            vec![
4792                [2, 17624012],
4793                [3, 17624013],
4794                [4, 17624014],
4795                [5, 17624015],
4796                [6, 17624016],
4797                [7, 17624017],
4798                [8, 17624018],
4799                [9, 17624019],
4800                [10, 17624020],
4801                [11, 17625913],
4802                [12, 17625914],
4803                [13, 17625915],
4804                [14, 17625916],
4805                [15, 17625917],
4806                [16, 17625918],
4807                [17, 17625919],
4808                [18, 17625920],
4809                [19, 17625921],
4810                [20, 17625922],
4811                [21, 17625923],
4812                [22, 17625924],
4813                [23, 17625925],
4814                [24, 17625926],
4815                [25, 17625927],
4816                [26, 17625928],
4817                [27, 17625929],
4818                [28, 17625930],
4819                [29, 17625931],
4820                [30, 17625932],
4821                [31, 17625933],
4822                [32, 17625934],
4823                [33, 17625935],
4824                [34, 17625936],
4825                [35, 17625937],
4826                [36, 17625938],
4827                [37, 17625939],
4828                [38, 17625940],
4829                [39, 17625941],
4830                [40, 17625942],
4831                [41, 17625943],
4832                [42, 17625944],
4833                [43, 17625945],
4834                [44, 17625946],
4835                [45, 17625947],
4836                [46, 17625948],
4837                [47, 17625949],
4838                [48, 17625950],
4839                [49, 17625951],
4840                [50, 17625952]
4841            ]
4842        );
4843        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4844        assert_eq!(
4845            pairs,
4846            vec![
4847                [1, 31796700],
4848                [2, 31796701],
4849                [3, 31796702],
4850                [4, 31796703],
4851                [5, 31796704],
4852                [6, 31796705],
4853                [7, 31796706],
4854                [8, 31796710],
4855                [9, 31796711],
4856                [10, 31796712],
4857                [11, 31796713],
4858                [12, 31796714],
4859                [13, 31796715],
4860                [14, 31796716],
4861                [15, 31796717],
4862                [16, 31796718],
4863                [17, 31796719],
4864                [18, 31796720],
4865                [19, 31796721],
4866                [20, 31796722],
4867                [21, 31796723],
4868                [22, 31796724],
4869                [23, 31796725],
4870                [24, 31796726],
4871                [25, 31796727],
4872                [26, 31796728],
4873                [27, 31799014],
4874                [28, 31799015],
4875                [29, 31799016],
4876                [30, 31799017],
4877                [31, 31799018],
4878                [32, 31799019],
4879                [33, 31799020],
4880                [34, 31799021],
4881                [35, 31799022],
4882                [36, 31799023],
4883                [37, 31799024],
4884                [38, 31799025],
4885                [39, 31799026],
4886                [40, 31799027],
4887                [41, 31799028],
4888                [42, 31799029],
4889                [43, 31799030],
4890                [44, 31799031],
4891                [45, 31799032],
4892                [46, 31799033],
4893                [47, 31799034],
4894                [48, 31799035],
4895                [49, 31799036],
4896                [50, 31799037]
4897            ]
4898        );
4899        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4900        assert_eq!(
4901            pairs,
4902            vec![
4903                [0, 36722692],
4904                [1, 36722693],
4905                [2, 36722694],
4906                [3, 36722695],
4907                [4, 36722696],
4908                [5, 36722697],
4909                [6, 36722698],
4910                [7, 36722699],
4911                [8, 36722700],
4912                [9, 36722701],
4913                [10, 36722702],
4914                [11, 36722703],
4915                [12, 36722704],
4916                [13, 36722705],
4917                [14, 36723505],
4918                [15, 36723506],
4919                [16, 36723507],
4920                [17, 36723508],
4921                [18, 36723509],
4922                [19, 36723510],
4923                [20, 36723511],
4924                [21, 36723512],
4925                [22, 36723513],
4926                [23, 36723514],
4927                [24, 36723515],
4928                [25, 36723516],
4929                [26, 36723517],
4930                [27, 36723518],
4931                [28, 36723519],
4932                [29, 36723520],
4933                [30, 36723521],
4934                [31, 36723522],
4935                [32, 36723523],
4936                [33, 36723524],
4937                [34, 36723525],
4938                [35, 36723526],
4939                [36, 36723527],
4940                [37, 36723528],
4941                [38, 36723529],
4942                [39, 36723530],
4943                [40, 36723531],
4944                [41, 36723532],
4945                [42, 36737414],
4946                [43, 36737415],
4947                [44, 36737416],
4948                [45, 36737417],
4949                [46, 36737418],
4950                [47, 36737419],
4951                [48, 36737420]
4952            ]
4953        );
4954        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4955        assert_eq!(
4956            pairs,
4957            vec![
4958                [4, 44587963],
4959                [5, 44587964],
4960                [6, 44587965],
4961                [7, 44587966],
4962                [8, 44587967],
4963                [9, 44587968],
4964                [10, 44587969],
4965                [11, 44587970],
4966                [12, 44587971],
4967                [13, 44587972],
4968                [14, 44587973],
4969                [15, 44587974],
4970                [16, 44587975],
4971                [17, 44587976],
4972                [18, 44587977],
4973                [19, 44587978],
4974                [20, 44587979],
4975                [21, 44587980],
4976                [22, 44587981],
4977                [23, 44587982],
4978                [24, 44587983],
4979                [25, 44589680],
4980                [26, 44589681],
4981                [27, 44589682],
4982                [28, 44589683],
4983                [29, 44589684],
4984                [30, 44589685],
4985                [31, 44589686],
4986                [32, 44589687],
4987                [33, 44589688],
4988                [34, 44589689],
4989                [35, 44589690],
4990                [36, 44589691],
4991                [37, 44589692],
4992                [38, 44589693],
4993                [39, 44589694],
4994                [40, 44589695],
4995                [41, 44589696],
4996                [42, 44589697],
4997                [43, 44589698],
4998                [44, 44589699],
4999                [45, 44589700],
5000                [46, 44589701],
5001                [47, 44589702],
5002                [48, 44592034],
5003                [49, 44592035],
5004                [50, 44592036]
5005            ]
5006        );
5007    }
5008
5009    #[test]
5010    fn test_aligned_pairs_full() {
5011        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
5012        let mut it = bam.records();
5013        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
5014        assert_eq!(
5015            pairs.clone().into_iter().take(12).collect::<Vec<_>>(),
5016            vec![
5017                (Some(0), None, Cigar::SoftClip(6)),
5018                (Some(1), None, Cigar::SoftClip(6)),
5019                (Some(2), None, Cigar::SoftClip(6)),
5020                (Some(3), None, Cigar::SoftClip(6)),
5021                (Some(4), None, Cigar::SoftClip(6)),
5022                (Some(5), None, Cigar::SoftClip(6)),
5023                (Some(6), Some(16050676), Cigar::Match(45)),
5024                (Some(7), Some(16050677), Cigar::Match(45)),
5025                (Some(8), Some(16050678), Cigar::Match(45)),
5026                (Some(9), Some(16050679), Cigar::Match(45)),
5027                (Some(10), Some(16050680), Cigar::Match(45)),
5028                (Some(11), Some(16050681), Cigar::Match(45)),
5029            ]
5030        );
5031        let pairs: Vec<_> = pairs.into_iter().map(|p| [p.0, p.1]).collect();
5032        assert_eq!(
5033            pairs,
5034            vec![
5035                [Some(0), None],
5036                [Some(1), None],
5037                [Some(2), None],
5038                [Some(3), None],
5039                [Some(4), None],
5040                [Some(5), None],
5041                [Some(6), Some(16050676)],
5042                [Some(7), Some(16050677)],
5043                [Some(8), Some(16050678)],
5044                [Some(9), Some(16050679)],
5045                [Some(10), Some(16050680)],
5046                [Some(11), Some(16050681)],
5047                [Some(12), Some(16050682)],
5048                [Some(13), Some(16050683)],
5049                [Some(14), Some(16050684)],
5050                [Some(15), Some(16050685)],
5051                [Some(16), Some(16050686)],
5052                [Some(17), Some(16050687)],
5053                [Some(18), Some(16050688)],
5054                [Some(19), Some(16050689)],
5055                [Some(20), Some(16050690)],
5056                [Some(21), Some(16050691)],
5057                [Some(22), Some(16050692)],
5058                [Some(23), Some(16050693)],
5059                [Some(24), Some(16050694)],
5060                [Some(25), Some(16050695)],
5061                [Some(26), Some(16050696)],
5062                [Some(27), Some(16050697)],
5063                [Some(28), Some(16050698)],
5064                [Some(29), Some(16050699)],
5065                [Some(30), Some(16050700)],
5066                [Some(31), Some(16050701)],
5067                [Some(32), Some(16050702)],
5068                [Some(33), Some(16050703)],
5069                [Some(34), Some(16050704)],
5070                [Some(35), Some(16050705)],
5071                [Some(36), Some(16050706)],
5072                [Some(37), Some(16050707)],
5073                [Some(38), Some(16050708)],
5074                [Some(39), Some(16050709)],
5075                [Some(40), Some(16050710)],
5076                [Some(41), Some(16050711)],
5077                [Some(42), Some(16050712)],
5078                [Some(43), Some(16050713)],
5079                [Some(44), Some(16050714)],
5080                [Some(45), Some(16050715)],
5081                [Some(46), Some(16050716)],
5082                [Some(47), Some(16050717)],
5083                [Some(48), Some(16050718)],
5084                [Some(49), Some(16050719)],
5085                [Some(50), Some(16050720)]
5086            ]
5087        );
5088        let pairs: Vec<_> = it
5089            .next()
5090            .unwrap()
5091            .unwrap()
5092            .aligned_pairs_full()
5093            .map(|p| [p.0, p.1])
5094            .collect();
5095        assert_eq!(
5096            pairs,
5097            vec![
5098                [Some(0), Some(16096878)],
5099                [Some(1), Some(16096879)],
5100                [Some(2), Some(16096880)],
5101                [Some(3), Some(16096881)],
5102                [Some(4), Some(16096882)],
5103                [Some(5), Some(16096883)],
5104                [Some(6), Some(16096884)],
5105                [None, Some(16096885)],
5106                [None, Some(16096886)],
5107                [Some(7), Some(16096887)],
5108                [Some(8), Some(16096888)],
5109                [Some(9), Some(16096889)],
5110                [Some(10), Some(16096890)],
5111                [Some(11), Some(16096891)],
5112                [Some(12), Some(16096892)],
5113                [Some(13), Some(16096893)],
5114                [Some(14), Some(16096894)],
5115                [Some(15), Some(16096895)],
5116                [Some(16), Some(16096896)],
5117                [Some(17), Some(16096897)],
5118                [Some(18), Some(16096898)],
5119                [Some(19), Some(16096899)],
5120                [Some(20), Some(16096900)],
5121                [Some(21), Some(16096901)],
5122                [Some(22), Some(16096902)],
5123                [Some(23), Some(16096903)],
5124                [Some(24), Some(16096904)],
5125                [Some(25), Some(16096905)],
5126                [Some(26), Some(16096906)],
5127                [Some(27), Some(16096907)],
5128                [Some(28), Some(16096908)],
5129                [Some(29), Some(16096909)],
5130                [Some(30), Some(16096910)],
5131                [Some(31), Some(16096911)],
5132                [Some(32), Some(16096912)],
5133                [Some(33), Some(16096913)],
5134                [Some(34), Some(16096914)],
5135                [Some(35), Some(16096915)],
5136                [Some(36), Some(16096916)],
5137                [Some(37), Some(16096917)],
5138                [Some(38), Some(16096918)],
5139                [Some(39), Some(16096919)],
5140                [Some(40), Some(16096920)],
5141                [Some(41), Some(16096921)],
5142                [Some(42), Some(16096922)],
5143                [Some(43), Some(16096923)],
5144                [Some(44), Some(16096924)],
5145                [Some(45), Some(16096925)],
5146                [Some(46), Some(16096926)],
5147                [Some(47), Some(16096927)],
5148                [Some(48), Some(16096928)],
5149                [Some(49), Some(16096929)],
5150                [Some(50), Some(16096930)]
5151            ]
5152        );
5153        let pairs: Vec<_> = it
5154            .next()
5155            .unwrap()
5156            .unwrap()
5157            .aligned_pairs_full()
5158            .map(|p| [p.0, p.1])
5159            .collect();
5160        assert_eq!(
5161            pairs,
5162            vec![
5163                [Some(0), Some(16097145)],
5164                [Some(1), Some(16097146)],
5165                [Some(2), Some(16097147)],
5166                [Some(3), Some(16097148)],
5167                [Some(4), Some(16097149)],
5168                [Some(5), Some(16097150)],
5169                [Some(6), Some(16097151)],
5170                [Some(7), Some(16097152)],
5171                [Some(8), Some(16097153)],
5172                [Some(9), Some(16097154)],
5173                [Some(10), Some(16097155)],
5174                [Some(11), Some(16097156)],
5175                [Some(12), Some(16097157)],
5176                [Some(13), Some(16097158)],
5177                [Some(14), Some(16097159)],
5178                [Some(15), Some(16097160)],
5179                [Some(16), Some(16097161)],
5180                [Some(17), Some(16097162)],
5181                [Some(18), Some(16097163)],
5182                [Some(19), Some(16097164)],
5183                [Some(20), Some(16097165)],
5184                [Some(21), Some(16097166)],
5185                [Some(22), Some(16097167)],
5186                [Some(23), Some(16097168)],
5187                [Some(24), Some(16097169)],
5188                [Some(25), Some(16097170)],
5189                [Some(26), Some(16097171)],
5190                [Some(27), Some(16097172)],
5191                [Some(28), Some(16097173)],
5192                [None, Some(16097174)],
5193                [None, Some(16097175)],
5194                [Some(29), Some(16097176)],
5195                [Some(30), Some(16097177)],
5196                [Some(31), Some(16097178)],
5197                [Some(32), Some(16097179)],
5198                [Some(33), Some(16097180)],
5199                [Some(34), Some(16097181)],
5200                [Some(35), Some(16097182)],
5201                [Some(36), Some(16097183)],
5202                [Some(37), Some(16097184)],
5203                [Some(38), Some(16097185)],
5204                [Some(39), Some(16097186)],
5205                [Some(40), Some(16097187)],
5206                [Some(41), Some(16097188)],
5207                [Some(42), Some(16097189)],
5208                [Some(43), Some(16097190)],
5209                [Some(44), Some(16097191)],
5210                [Some(45), Some(16097192)],
5211                [Some(46), Some(16097193)],
5212                [Some(47), Some(16097194)],
5213                [Some(48), Some(16097195)],
5214                [Some(49), Some(16097196)],
5215                [Some(50), Some(16097197)]
5216            ]
5217        );
5218        let pairs: Vec<_> = it
5219            .next()
5220            .unwrap()
5221            .unwrap()
5222            .aligned_pairs_full()
5223            .map(|p| [p.0, p.1])
5224            .collect();
5225        assert_eq!(
5226            pairs,
5227            vec![
5228                [Some(0), Some(16117350)],
5229                [Some(1), Some(16117351)],
5230                [Some(2), Some(16117352)],
5231                [Some(3), Some(16117353)],
5232                [Some(4), Some(16117354)],
5233                [Some(5), Some(16117355)],
5234                [Some(6), Some(16117356)],
5235                [Some(7), Some(16117357)],
5236                [Some(8), Some(16117358)],
5237                [Some(9), Some(16117359)],
5238                [Some(10), Some(16117360)],
5239                [Some(11), Some(16117361)],
5240                [Some(12), Some(16117362)],
5241                [Some(13), Some(16117363)],
5242                [Some(14), Some(16117364)],
5243                [Some(15), Some(16117365)],
5244                [Some(16), Some(16117366)],
5245                [Some(17), Some(16117367)],
5246                [Some(18), Some(16117368)],
5247                [Some(19), Some(16117369)],
5248                [Some(20), Some(16117370)],
5249                [Some(21), Some(16117371)],
5250                [Some(22), Some(16117372)],
5251                [Some(23), Some(16117373)],
5252                [Some(24), Some(16117374)],
5253                [Some(25), Some(16117375)],
5254                [Some(26), Some(16117376)],
5255                [Some(27), Some(16117377)],
5256                [Some(28), Some(16117378)],
5257                [Some(29), Some(16117379)],
5258                [Some(30), Some(16117380)],
5259                [Some(31), Some(16117381)],
5260                [Some(32), Some(16117382)],
5261                [Some(33), Some(16117383)],
5262                [Some(34), Some(16117384)],
5263                [Some(35), Some(16117385)],
5264                [Some(36), Some(16117386)],
5265                [Some(37), Some(16117387)],
5266                [Some(38), Some(16117388)],
5267                [Some(39), Some(16117389)],
5268                [Some(40), Some(16117390)],
5269                [Some(41), Some(16117391)],
5270                [Some(42), Some(16117392)],
5271                [Some(43), Some(16117393)],
5272                [Some(44), Some(16117394)],
5273                [Some(45), Some(16117395)],
5274                [Some(46), Some(16117396)],
5275                [Some(47), Some(16117397)],
5276                [Some(48), Some(16117398)],
5277                [Some(49), Some(16117399)],
5278                [Some(50), Some(16117400)]
5279            ]
5280        );
5281        let pairs: Vec<_> = it
5282            .next()
5283            .unwrap()
5284            .unwrap()
5285            .aligned_pairs_full()
5286            .map(|p| [p.0, p.1])
5287            .collect();
5288        assert_eq!(
5289            pairs,
5290            vec![
5291                [Some(0), Some(16118483)],
5292                [Some(1), Some(16118484)],
5293                [Some(2), Some(16118485)],
5294                [Some(3), Some(16118486)],
5295                [Some(4), Some(16118487)],
5296                [Some(5), Some(16118488)],
5297                [Some(6), Some(16118489)],
5298                [Some(7), Some(16118490)],
5299                [Some(8), Some(16118491)],
5300                [Some(9), Some(16118492)],
5301                [Some(10), Some(16118493)],
5302                [Some(11), Some(16118494)],
5303                [Some(12), Some(16118495)],
5304                [Some(13), Some(16118496)],
5305                [Some(14), Some(16118497)],
5306                [Some(15), Some(16118498)],
5307                [Some(16), Some(16118499)],
5308                [Some(17), Some(16118500)],
5309                [Some(18), Some(16118501)],
5310                [Some(19), Some(16118502)],
5311                [Some(20), Some(16118503)],
5312                [Some(21), Some(16118504)],
5313                [Some(22), Some(16118505)],
5314                [Some(23), Some(16118506)],
5315                [Some(24), Some(16118507)],
5316                [Some(25), Some(16118508)],
5317                [Some(26), Some(16118509)],
5318                [Some(27), Some(16118510)],
5319                [Some(28), Some(16118511)],
5320                [Some(29), Some(16118512)],
5321                [Some(30), Some(16118513)],
5322                [Some(31), Some(16118514)],
5323                [Some(32), Some(16118515)],
5324                [Some(33), Some(16118516)],
5325                [Some(34), Some(16118517)],
5326                [Some(35), Some(16118518)],
5327                [Some(36), Some(16118519)],
5328                [Some(37), Some(16118520)],
5329                [Some(38), Some(16118521)],
5330                [Some(39), Some(16118522)],
5331                [Some(40), Some(16118523)],
5332                [Some(41), Some(16118524)],
5333                [Some(42), Some(16118525)],
5334                [Some(43), Some(16118526)],
5335                [Some(44), Some(16118527)],
5336                [Some(45), Some(16118528)],
5337                [Some(46), Some(16118529)],
5338                [Some(47), Some(16118530)],
5339                [Some(48), Some(16118531)],
5340                [Some(49), Some(16118532)],
5341                [Some(50), Some(16118533)]
5342            ]
5343        );
5344
5345        //
5346        //for the rest, we just verify that they have the expected amount of None in each position
5347        fn some_count(pairs: &[[Option<i64>; 2]], pos: usize) -> i64 {
5348            pairs.iter().filter(|x| x[pos].is_some()).count() as i64
5349        }
5350        fn none_count(pairs: &[[Option<i64>; 2]], pos: usize) -> i64 {
5351            pairs.iter().filter(|x| x[pos].is_none()).count() as i64
5352        }
5353
5354        let pairs: Vec<_> = it
5355            .next()
5356            .unwrap()
5357            .unwrap()
5358            .aligned_pairs_full()
5359            .map(|p| [p.0, p.1])
5360            .collect();
5361        assert_eq!(some_count(&pairs, 0), 51);
5362        assert_eq!(none_count(&pairs, 0), 0);
5363        assert_eq!(some_count(&pairs, 1), 51);
5364        assert_eq!(none_count(&pairs, 1), 0);
5365        let pairs: Vec<_> = it
5366            .next()
5367            .unwrap()
5368            .unwrap()
5369            .aligned_pairs_full()
5370            .map(|p| [p.0, p.1])
5371            .collect();
5372        assert_eq!(some_count(&pairs, 0), 51);
5373        assert_eq!(none_count(&pairs, 0), 0);
5374        assert_eq!(some_count(&pairs, 1), 51);
5375        assert_eq!(none_count(&pairs, 1), 0);
5376        let pairs: Vec<_> = it
5377            .next()
5378            .unwrap()
5379            .unwrap()
5380            .aligned_pairs_full()
5381            .map(|p| [p.0, p.1])
5382            .collect();
5383        assert_eq!(some_count(&pairs, 0), 51);
5384        assert_eq!(none_count(&pairs, 0), 0);
5385        assert_eq!(some_count(&pairs, 1), 51);
5386        assert_eq!(none_count(&pairs, 1), 0);
5387        let pairs: Vec<_> = it
5388            .next()
5389            .unwrap()
5390            .unwrap()
5391            .aligned_pairs_full()
5392            .map(|p| [p.0, p.1])
5393            .collect();
5394        assert_eq!(some_count(&pairs, 0), 51);
5395        assert_eq!(none_count(&pairs, 0), 0);
5396        assert_eq!(some_count(&pairs, 1), 51);
5397        assert_eq!(none_count(&pairs, 1), 0);
5398        let pairs: Vec<_> = it
5399            .next()
5400            .unwrap()
5401            .unwrap()
5402            .aligned_pairs_full()
5403            .map(|p| [p.0, p.1])
5404            .collect();
5405        assert_eq!(some_count(&pairs, 0), 51);
5406        assert_eq!(none_count(&pairs, 0), 0);
5407        assert_eq!(some_count(&pairs, 1), 45);
5408        assert_eq!(none_count(&pairs, 1), 6);
5409        let pairs: Vec<_> = it
5410            .next()
5411            .unwrap()
5412            .unwrap()
5413            .aligned_pairs_full()
5414            .map(|p| [p.0, p.1])
5415            .collect();
5416        assert_eq!(some_count(&pairs, 0), 51);
5417        assert_eq!(none_count(&pairs, 0), 0);
5418        assert_eq!(some_count(&pairs, 1), 41);
5419        assert_eq!(none_count(&pairs, 1), 10);
5420        let pairs: Vec<_> = it
5421            .next()
5422            .unwrap()
5423            .unwrap()
5424            .aligned_pairs_full()
5425            .map(|p| [p.0, p.1])
5426            .collect();
5427        assert_eq!(some_count(&pairs, 0), 51);
5428        assert_eq!(none_count(&pairs, 0), 0);
5429        assert_eq!(some_count(&pairs, 1), 51);
5430        assert_eq!(none_count(&pairs, 1), 0);
5431        let pairs: Vec<_> = it
5432            .next()
5433            .unwrap()
5434            .unwrap()
5435            .aligned_pairs_full()
5436            .map(|p| [p.0, p.1])
5437            .collect();
5438        assert_eq!(some_count(&pairs, 0), 51);
5439        assert_eq!(none_count(&pairs, 0), 0);
5440        assert_eq!(some_count(&pairs, 1), 51);
5441        assert_eq!(none_count(&pairs, 1), 0);
5442        let pairs: Vec<_> = it
5443            .next()
5444            .unwrap()
5445            .unwrap()
5446            .aligned_pairs_full()
5447            .map(|p| [p.0, p.1])
5448            .collect();
5449        assert_eq!(some_count(&pairs, 0), 51);
5450        assert_eq!(none_count(&pairs, 0), 0);
5451        assert_eq!(some_count(&pairs, 1), 51);
5452        assert_eq!(none_count(&pairs, 1), 0);
5453        let pairs: Vec<_> = it
5454            .next()
5455            .unwrap()
5456            .unwrap()
5457            .aligned_pairs_full()
5458            .map(|p| [p.0, p.1])
5459            .collect();
5460        assert_eq!(some_count(&pairs, 0), 51);
5461        assert_eq!(none_count(&pairs, 0), 0);
5462        assert_eq!(some_count(&pairs, 1), 51);
5463        assert_eq!(none_count(&pairs, 1), 0);
5464        let pairs: Vec<_> = it
5465            .next()
5466            .unwrap()
5467            .unwrap()
5468            .aligned_pairs_full()
5469            .map(|p| [p.0, p.1])
5470            .collect();
5471        assert_eq!(some_count(&pairs, 0), 51);
5472        assert_eq!(none_count(&pairs, 0), 0);
5473        assert_eq!(some_count(&pairs, 1), 42);
5474        assert_eq!(none_count(&pairs, 1), 9);
5475        let pairs: Vec<_> = it
5476            .next()
5477            .unwrap()
5478            .unwrap()
5479            .aligned_pairs_full()
5480            .map(|p| [p.0, p.1])
5481            .collect();
5482        assert_eq!(some_count(&pairs, 0), 51);
5483        assert_eq!(none_count(&pairs, 0), 0);
5484        assert_eq!(some_count(&pairs, 1), 51);
5485        assert_eq!(none_count(&pairs, 1), 0);
5486        let pairs: Vec<_> = it
5487            .next()
5488            .unwrap()
5489            .unwrap()
5490            .aligned_pairs_full()
5491            .map(|p| [p.0, p.1])
5492            .collect();
5493        assert_eq!(some_count(&pairs, 0), 51);
5494        assert_eq!(none_count(&pairs, 0), 0);
5495        assert_eq!(some_count(&pairs, 1), 50);
5496        assert_eq!(none_count(&pairs, 1), 1);
5497        let pairs: Vec<_> = it
5498            .next()
5499            .unwrap()
5500            .unwrap()
5501            .aligned_pairs_full()
5502            .map(|p| [p.0, p.1])
5503            .collect();
5504        assert_eq!(some_count(&pairs, 0), 51);
5505        assert_eq!(none_count(&pairs, 0), 0);
5506        assert_eq!(some_count(&pairs, 1), 45);
5507        assert_eq!(none_count(&pairs, 1), 6);
5508        let pairs: Vec<_> = it
5509            .next()
5510            .unwrap()
5511            .unwrap()
5512            .aligned_pairs_full()
5513            .map(|p| [p.0, p.1])
5514            .collect();
5515        assert_eq!(some_count(&pairs, 0), 51);
5516        assert_eq!(none_count(&pairs, 0), 0);
5517        assert_eq!(some_count(&pairs, 1), 48);
5518        assert_eq!(none_count(&pairs, 1), 3);
5519        let pairs: Vec<_> = it
5520            .next()
5521            .unwrap()
5522            .unwrap()
5523            .aligned_pairs_full()
5524            .map(|p| [p.0, p.1])
5525            .collect();
5526        assert_eq!(some_count(&pairs, 0), 51);
5527        assert_eq!(none_count(&pairs, 0), 0);
5528        assert_eq!(some_count(&pairs, 1), 42);
5529        assert_eq!(none_count(&pairs, 1), 9);
5530        let pairs: Vec<_> = it
5531            .next()
5532            .unwrap()
5533            .unwrap()
5534            .aligned_pairs_full()
5535            .map(|p| [p.0, p.1])
5536            .collect();
5537        assert_eq!(some_count(&pairs, 0), 51);
5538        assert_eq!(none_count(&pairs, 0), 0);
5539        assert_eq!(some_count(&pairs, 1), 38);
5540        assert_eq!(none_count(&pairs, 1), 13);
5541        let pairs: Vec<_> = it
5542            .next()
5543            .unwrap()
5544            .unwrap()
5545            .aligned_pairs_full()
5546            .map(|p| [p.0, p.1])
5547            .collect();
5548        assert_eq!(some_count(&pairs, 0), 51);
5549        assert_eq!(none_count(&pairs, 0), 0);
5550        assert_eq!(some_count(&pairs, 1), 44);
5551        assert_eq!(none_count(&pairs, 1), 7);
5552        let pairs: Vec<_> = it
5553            .next()
5554            .unwrap()
5555            .unwrap()
5556            .aligned_pairs_full()
5557            .map(|p| [p.0, p.1])
5558            .collect();
5559        assert_eq!(some_count(&pairs, 0), 51);
5560        assert_eq!(none_count(&pairs, 0), 0);
5561        assert_eq!(some_count(&pairs, 1), 46);
5562        assert_eq!(none_count(&pairs, 1), 5);
5563        let pairs: Vec<_> = it
5564            .next()
5565            .unwrap()
5566            .unwrap()
5567            .aligned_pairs_full()
5568            .map(|p| [p.0, p.1])
5569            .collect();
5570        assert_eq!(some_count(&pairs, 0), 51);
5571        assert_eq!(none_count(&pairs, 0), 0);
5572        assert_eq!(some_count(&pairs, 1), 47);
5573        assert_eq!(none_count(&pairs, 1), 4);
5574        let pairs: Vec<_> = it
5575            .next()
5576            .unwrap()
5577            .unwrap()
5578            .aligned_pairs_full()
5579            .map(|p| [p.0, p.1])
5580            .collect();
5581        assert_eq!(some_count(&pairs, 0), 51);
5582        assert_eq!(none_count(&pairs, 0), 0);
5583        assert_eq!(some_count(&pairs, 1), 50);
5584        assert_eq!(none_count(&pairs, 1), 1);
5585        let pairs: Vec<_> = it
5586            .next()
5587            .unwrap()
5588            .unwrap()
5589            .aligned_pairs_full()
5590            .map(|p| [p.0, p.1])
5591            .collect();
5592        assert_eq!(some_count(&pairs, 0), 51);
5593        assert_eq!(none_count(&pairs, 0), 2183);
5594        assert_eq!(some_count(&pairs, 1), 2234);
5595        assert_eq!(none_count(&pairs, 1), 0);
5596        let pairs: Vec<_> = it
5597            .next()
5598            .unwrap()
5599            .unwrap()
5600            .aligned_pairs_full()
5601            .map(|p| [p.0, p.1])
5602            .collect();
5603        assert_eq!(some_count(&pairs, 0), 51);
5604        assert_eq!(none_count(&pairs, 0), 2183);
5605        assert_eq!(some_count(&pairs, 1), 2234);
5606        assert_eq!(none_count(&pairs, 1), 0);
5607        let pairs: Vec<_> = it
5608            .next()
5609            .unwrap()
5610            .unwrap()
5611            .aligned_pairs_full()
5612            .map(|p| [p.0, p.1])
5613            .collect();
5614        assert_eq!(some_count(&pairs, 0), 51);
5615        assert_eq!(none_count(&pairs, 0), 2183);
5616        assert_eq!(some_count(&pairs, 1), 2234);
5617        assert_eq!(none_count(&pairs, 1), 0);
5618        let pairs: Vec<_> = it
5619            .next()
5620            .unwrap()
5621            .unwrap()
5622            .aligned_pairs_full()
5623            .map(|p| [p.0, p.1])
5624            .collect();
5625        assert_eq!(some_count(&pairs, 0), 51);
5626        assert_eq!(none_count(&pairs, 0), 0);
5627        assert_eq!(some_count(&pairs, 1), 33);
5628        assert_eq!(none_count(&pairs, 1), 18);
5629        let pairs: Vec<_> = it
5630            .next()
5631            .unwrap()
5632            .unwrap()
5633            .aligned_pairs_full()
5634            .map(|p| [p.0, p.1])
5635            .collect();
5636        assert_eq!(some_count(&pairs, 0), 51);
5637        assert_eq!(none_count(&pairs, 0), 0);
5638        assert_eq!(some_count(&pairs, 1), 48);
5639        assert_eq!(none_count(&pairs, 1), 3);
5640        let pairs: Vec<_> = it
5641            .next()
5642            .unwrap()
5643            .unwrap()
5644            .aligned_pairs_full()
5645            .map(|p| [p.0, p.1])
5646            .collect();
5647        assert_eq!(some_count(&pairs, 0), 51);
5648        assert_eq!(none_count(&pairs, 0), 0);
5649        assert_eq!(some_count(&pairs, 1), 45);
5650        assert_eq!(none_count(&pairs, 1), 6);
5651        let pairs: Vec<_> = it
5652            .next()
5653            .unwrap()
5654            .unwrap()
5655            .aligned_pairs_full()
5656            .map(|p| [p.0, p.1])
5657            .collect();
5658        assert_eq!(some_count(&pairs, 0), 51);
5659        assert_eq!(none_count(&pairs, 0), 11832);
5660        assert_eq!(some_count(&pairs, 1), 11883);
5661        assert_eq!(none_count(&pairs, 1), 0);
5662        let pairs: Vec<_> = it
5663            .next()
5664            .unwrap()
5665            .unwrap()
5666            .aligned_pairs_full()
5667            .map(|p| [p.0, p.1])
5668            .collect();
5669        assert_eq!(some_count(&pairs, 0), 51);
5670        assert_eq!(none_count(&pairs, 0), 12542);
5671        assert_eq!(some_count(&pairs, 1), 12593);
5672        assert_eq!(none_count(&pairs, 1), 0);
5673        let pairs: Vec<_> = it
5674            .next()
5675            .unwrap()
5676            .unwrap()
5677            .aligned_pairs_full()
5678            .map(|p| [p.0, p.1])
5679            .collect();
5680        assert_eq!(some_count(&pairs, 0), 51);
5681        assert_eq!(none_count(&pairs, 0), 12542);
5682        assert_eq!(some_count(&pairs, 1), 12593);
5683        assert_eq!(none_count(&pairs, 1), 0);
5684        let pairs: Vec<_> = it
5685            .next()
5686            .unwrap()
5687            .unwrap()
5688            .aligned_pairs_full()
5689            .map(|p| [p.0, p.1])
5690            .collect();
5691        assert_eq!(some_count(&pairs, 0), 51);
5692        assert_eq!(none_count(&pairs, 0), 12542);
5693        assert_eq!(some_count(&pairs, 1), 12593);
5694        assert_eq!(none_count(&pairs, 1), 0);
5695        let pairs: Vec<_> = it
5696            .next()
5697            .unwrap()
5698            .unwrap()
5699            .aligned_pairs_full()
5700            .map(|p| [p.0, p.1])
5701            .collect();
5702        assert_eq!(some_count(&pairs, 0), 51);
5703        assert_eq!(none_count(&pairs, 0), 12542);
5704        assert_eq!(some_count(&pairs, 1), 12593);
5705        assert_eq!(none_count(&pairs, 1), 0);
5706        let pairs: Vec<_> = it
5707            .next()
5708            .unwrap()
5709            .unwrap()
5710            .aligned_pairs_full()
5711            .map(|p| [p.0, p.1])
5712            .collect();
5713        assert_eq!(some_count(&pairs, 0), 51);
5714        assert_eq!(none_count(&pairs, 0), 12542);
5715        assert_eq!(some_count(&pairs, 1), 12593);
5716        assert_eq!(none_count(&pairs, 1), 0);
5717        let pairs: Vec<_> = it
5718            .next()
5719            .unwrap()
5720            .unwrap()
5721            .aligned_pairs_full()
5722            .map(|p| [p.0, p.1])
5723            .collect();
5724        assert_eq!(some_count(&pairs, 0), 51);
5725        assert_eq!(none_count(&pairs, 0), 12542);
5726        assert_eq!(some_count(&pairs, 1), 12593);
5727        assert_eq!(none_count(&pairs, 1), 0);
5728        let pairs: Vec<_> = it
5729            .next()
5730            .unwrap()
5731            .unwrap()
5732            .aligned_pairs_full()
5733            .map(|p| [p.0, p.1])
5734            .collect();
5735        assert_eq!(some_count(&pairs, 0), 51);
5736        assert_eq!(none_count(&pairs, 0), 12542);
5737        assert_eq!(some_count(&pairs, 1), 12593);
5738        assert_eq!(none_count(&pairs, 1), 0);
5739        let pairs: Vec<_> = it
5740            .next()
5741            .unwrap()
5742            .unwrap()
5743            .aligned_pairs_full()
5744            .map(|p| [p.0, p.1])
5745            .collect();
5746        assert_eq!(some_count(&pairs, 0), 51);
5747        assert_eq!(none_count(&pairs, 0), 12542);
5748        assert_eq!(some_count(&pairs, 1), 12593);
5749        assert_eq!(none_count(&pairs, 1), 0);
5750        let pairs: Vec<_> = it
5751            .next()
5752            .unwrap()
5753            .unwrap()
5754            .aligned_pairs_full()
5755            .map(|p| [p.0, p.1])
5756            .collect();
5757        assert_eq!(some_count(&pairs, 0), 51);
5758        assert_eq!(none_count(&pairs, 0), 1467);
5759        assert_eq!(some_count(&pairs, 1), 1517);
5760        assert_eq!(none_count(&pairs, 1), 1);
5761        let pairs: Vec<_> = it
5762            .next()
5763            .unwrap()
5764            .unwrap()
5765            .aligned_pairs_full()
5766            .map(|p| [p.0, p.1])
5767            .collect();
5768        assert_eq!(some_count(&pairs, 0), 51);
5769        assert_eq!(none_count(&pairs, 0), 1609);
5770        assert_eq!(some_count(&pairs, 1), 1660);
5771        assert_eq!(none_count(&pairs, 1), 0);
5772        let pairs: Vec<_> = it
5773            .next()
5774            .unwrap()
5775            .unwrap()
5776            .aligned_pairs_full()
5777            .map(|p| [p.0, p.1])
5778            .collect();
5779        assert_eq!(some_count(&pairs, 0), 51);
5780        assert_eq!(none_count(&pairs, 0), 1609);
5781        assert_eq!(some_count(&pairs, 1), 1660);
5782        assert_eq!(none_count(&pairs, 1), 0);
5783        let pairs: Vec<_> = it
5784            .next()
5785            .unwrap()
5786            .unwrap()
5787            .aligned_pairs_full()
5788            .map(|p| [p.0, p.1])
5789            .collect();
5790        assert_eq!(some_count(&pairs, 0), 51);
5791        assert_eq!(none_count(&pairs, 0), 1609);
5792        assert_eq!(some_count(&pairs, 1), 1660);
5793        assert_eq!(none_count(&pairs, 1), 0);
5794        let pairs: Vec<_> = it
5795            .next()
5796            .unwrap()
5797            .unwrap()
5798            .aligned_pairs_full()
5799            .map(|p| [p.0, p.1])
5800            .collect();
5801        assert_eq!(some_count(&pairs, 0), 51);
5802        assert_eq!(none_count(&pairs, 0), 95);
5803        assert_eq!(some_count(&pairs, 1), 145);
5804        assert_eq!(none_count(&pairs, 1), 1);
5805        let pairs: Vec<_> = it
5806            .next()
5807            .unwrap()
5808            .unwrap()
5809            .aligned_pairs_full()
5810            .map(|p| [p.0, p.1])
5811            .collect();
5812        assert_eq!(some_count(&pairs, 0), 51);
5813        assert_eq!(none_count(&pairs, 0), 538);
5814        assert_eq!(some_count(&pairs, 1), 588);
5815        assert_eq!(none_count(&pairs, 1), 1);
5816        let pairs: Vec<_> = it
5817            .next()
5818            .unwrap()
5819            .unwrap()
5820            .aligned_pairs_full()
5821            .map(|p| [p.0, p.1])
5822            .collect();
5823        assert_eq!(some_count(&pairs, 0), 51);
5824        assert_eq!(none_count(&pairs, 0), 538);
5825        assert_eq!(some_count(&pairs, 1), 588);
5826        assert_eq!(none_count(&pairs, 1), 1);
5827        let pairs: Vec<_> = it
5828            .next()
5829            .unwrap()
5830            .unwrap()
5831            .aligned_pairs_full()
5832            .map(|p| [p.0, p.1])
5833            .collect();
5834        assert_eq!(some_count(&pairs, 0), 51);
5835        assert_eq!(none_count(&pairs, 0), 538);
5836        assert_eq!(some_count(&pairs, 1), 588);
5837        assert_eq!(none_count(&pairs, 1), 1);
5838        let pairs: Vec<_> = it
5839            .next()
5840            .unwrap()
5841            .unwrap()
5842            .aligned_pairs_full()
5843            .map(|p| [p.0, p.1])
5844            .collect();
5845        assert_eq!(some_count(&pairs, 0), 51);
5846        assert_eq!(none_count(&pairs, 0), 1);
5847        assert_eq!(some_count(&pairs, 1), 51);
5848        assert_eq!(none_count(&pairs, 1), 1);
5849        let pairs: Vec<_> = it
5850            .next()
5851            .unwrap()
5852            .unwrap()
5853            .aligned_pairs_full()
5854            .map(|p| [p.0, p.1])
5855            .collect();
5856        assert_eq!(some_count(&pairs, 0), 51);
5857        assert_eq!(none_count(&pairs, 0), 1);
5858        assert_eq!(some_count(&pairs, 1), 49);
5859        assert_eq!(none_count(&pairs, 1), 3);
5860        let pairs: Vec<_> = it
5861            .next()
5862            .unwrap()
5863            .unwrap()
5864            .aligned_pairs_full()
5865            .map(|p| [p.0, p.1])
5866            .collect();
5867        assert_eq!(some_count(&pairs, 0), 51);
5868        assert_eq!(none_count(&pairs, 0), 1);
5869        assert_eq!(some_count(&pairs, 1), 45);
5870        assert_eq!(none_count(&pairs, 1), 7);
5871        let pairs: Vec<_> = it
5872            .next()
5873            .unwrap()
5874            .unwrap()
5875            .aligned_pairs_full()
5876            .map(|p| [p.0, p.1])
5877            .collect();
5878        assert_eq!(some_count(&pairs, 0), 51);
5879        assert_eq!(none_count(&pairs, 0), 0);
5880        assert_eq!(some_count(&pairs, 1), 39);
5881        assert_eq!(none_count(&pairs, 1), 12);
5882        let pairs: Vec<_> = it
5883            .next()
5884            .unwrap()
5885            .unwrap()
5886            .aligned_pairs_full()
5887            .map(|p| [p.0, p.1])
5888            .collect();
5889        assert_eq!(some_count(&pairs, 0), 51);
5890        assert_eq!(none_count(&pairs, 0), 1892);
5891        assert_eq!(some_count(&pairs, 1), 1938);
5892        assert_eq!(none_count(&pairs, 1), 5);
5893        let pairs: Vec<_> = it
5894            .next()
5895            .unwrap()
5896            .unwrap()
5897            .aligned_pairs_full()
5898            .map(|p| [p.0, p.1])
5899            .collect();
5900        assert_eq!(some_count(&pairs, 0), 51);
5901        assert_eq!(none_count(&pairs, 0), 1892);
5902        assert_eq!(some_count(&pairs, 1), 1941);
5903        assert_eq!(none_count(&pairs, 1), 2);
5904        let pairs: Vec<_> = it
5905            .next()
5906            .unwrap()
5907            .unwrap()
5908            .aligned_pairs_full()
5909            .map(|p| [p.0, p.1])
5910            .collect();
5911        assert_eq!(some_count(&pairs, 0), 51);
5912        assert_eq!(none_count(&pairs, 0), 2288);
5913        assert_eq!(some_count(&pairs, 1), 2338);
5914        assert_eq!(none_count(&pairs, 1), 1);
5915        let pairs: Vec<_> = it
5916            .next()
5917            .unwrap()
5918            .unwrap()
5919            .aligned_pairs_full()
5920            .map(|p| [p.0, p.1])
5921            .collect();
5922        assert_eq!(some_count(&pairs, 0), 51);
5923        assert_eq!(none_count(&pairs, 0), 14680);
5924        assert_eq!(some_count(&pairs, 1), 14729);
5925        assert_eq!(none_count(&pairs, 1), 2);
5926        let pairs: Vec<_> = it
5927            .next()
5928            .unwrap()
5929            .unwrap()
5930            .aligned_pairs_full()
5931            .map(|p| [p.0, p.1])
5932            .collect();
5933        assert_eq!(some_count(&pairs, 0), 51);
5934        assert_eq!(none_count(&pairs, 0), 4027);
5935        assert_eq!(some_count(&pairs, 1), 4074);
5936        assert_eq!(none_count(&pairs, 1), 4);
5937    }
5938
5939    #[test]
5940    fn test_aligned_block_pairs() {
5941        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
5942        let mut it = bam.records();
5943
5944        let read = it.next().unwrap().unwrap();
5945        let pairs: Vec<_> = read.aligned_pairs().collect();
5946        let block_pairs: Vec<_> = read.aligned_block_pairs().collect();
5947
5948        //first coordinates identical
5949        assert_eq!(pairs[0][0], block_pairs[0].0[0]); //read
5950        assert_eq!(pairs[0][1], block_pairs[0].1[0]); // genomic
5951
5952        //end coordinates are + 1, so the ranges are the same...
5953        assert_eq!(
5954            pairs[pairs.len() - 1][0],
5955            block_pairs[block_pairs.len() - 1].0[1] - 1
5956        );
5957        assert_eq!(
5958            pairs[pairs.len() - 1][1],
5959            block_pairs[block_pairs.len() - 1].1[1] - 1
5960        );
5961
5962        //let's see if they're really identical
5963        for read in it {
5964            let read = read.unwrap();
5965            let pairs: Vec<_> = read.aligned_pairs().collect();
5966            let block_pairs: Vec<_> = read.aligned_block_pairs().collect();
5967            let mut ii = 0;
5968            for ([read_start, read_stop], [genome_start, genome_stop]) in block_pairs {
5969                assert_eq!(read_stop - read_start, genome_stop - genome_start);
5970                for (read_pos, genome_pos) in (read_start..read_stop).zip(genome_start..genome_stop)
5971                {
5972                    assert_eq!(pairs[ii][0], read_pos);
5973                    assert_eq!(pairs[ii][1], genome_pos);
5974                    ii += 1;
5975                }
5976            }
5977        }
5978    }
5979
5980    #[test]
5981    fn test_get_cigar_stats() {
5982        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
5983        let mut it = bam.records();
5984
5985        fn to_arr(hm: HashMap<Cigar, i32>) -> [i32; 9] {
5986            [
5987                *hm.get(&Cigar::Match(0)).unwrap(),
5988                *hm.get(&Cigar::Ins(0)).unwrap(),
5989                *hm.get(&Cigar::Del(0)).unwrap(),
5990                *hm.get(&Cigar::RefSkip(0)).unwrap(),
5991                *hm.get(&Cigar::SoftClip(0)).unwrap(),
5992                *hm.get(&Cigar::HardClip(0)).unwrap(),
5993                *hm.get(&Cigar::Pad(0)).unwrap(),
5994                *hm.get(&Cigar::Equal(0)).unwrap(),
5995                *hm.get(&Cigar::Diff(0)).unwrap(),
5996            ]
5997        }
5998
5999        let read = it.next().unwrap().unwrap();
6000        let cigar_nucleotides = read.cigar_stats_nucleotides();
6001        assert_eq!(to_arr(cigar_nucleotides), [45, 0, 0, 0, 6, 0, 0, 0, 0]);
6002        let cigar_blocks = read.cigar_stats_blocks();
6003        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
6004        let read = it.next().unwrap().unwrap();
6005        let cigar_nucleotides = read.cigar_stats_nucleotides();
6006        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 2, 0, 0, 0, 0, 0, 0]);
6007        let cigar_blocks = read.cigar_stats_blocks();
6008        assert_eq!(to_arr(cigar_blocks), [2, 0, 1, 0, 0, 0, 0, 0, 0]);
6009        let read = it.next().unwrap().unwrap();
6010        let cigar_nucleotides = read.cigar_stats_nucleotides();
6011        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 2, 0, 0, 0, 0, 0, 0]);
6012        let cigar_blocks = read.cigar_stats_blocks();
6013        assert_eq!(to_arr(cigar_blocks), [2, 0, 1, 0, 0, 0, 0, 0, 0]);
6014        let read = it.next().unwrap().unwrap();
6015        let cigar_nucleotides = read.cigar_stats_nucleotides();
6016        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
6017        let cigar_blocks = read.cigar_stats_blocks();
6018        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
6019        let read = it.next().unwrap().unwrap();
6020        let cigar_nucleotides = read.cigar_stats_nucleotides();
6021        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
6022        let cigar_blocks = read.cigar_stats_blocks();
6023        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
6024        let read = it.next().unwrap().unwrap();
6025        let cigar_nucleotides = read.cigar_stats_nucleotides();
6026        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
6027        let cigar_blocks = read.cigar_stats_blocks();
6028        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
6029        let read = it.next().unwrap().unwrap();
6030        let cigar_nucleotides = read.cigar_stats_nucleotides();
6031        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
6032        let cigar_blocks = read.cigar_stats_blocks();
6033        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
6034        let read = it.next().unwrap().unwrap();
6035        let cigar_nucleotides = read.cigar_stats_nucleotides();
6036        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
6037        let cigar_blocks = read.cigar_stats_blocks();
6038        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
6039        let read = it.next().unwrap().unwrap();
6040        let cigar_nucleotides = read.cigar_stats_nucleotides();
6041        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
6042        let cigar_blocks = read.cigar_stats_blocks();
6043        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
6044        let read = it.next().unwrap().unwrap();
6045        let cigar_nucleotides = read.cigar_stats_nucleotides();
6046        assert_eq!(to_arr(cigar_nucleotides), [45, 0, 0, 0, 6, 0, 0, 0, 0]);
6047        let cigar_blocks = read.cigar_stats_blocks();
6048        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
6049        let read = it.next().unwrap().unwrap();
6050        let cigar_nucleotides = read.cigar_stats_nucleotides();
6051        assert_eq!(to_arr(cigar_nucleotides), [41, 0, 0, 0, 10, 0, 0, 0, 0]);
6052        let cigar_blocks = read.cigar_stats_blocks();
6053        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
6054        let read = it.next().unwrap().unwrap();
6055        let cigar_nucleotides = read.cigar_stats_nucleotides();
6056        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
6057        let cigar_blocks = read.cigar_stats_blocks();
6058        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
6059        let read = it.next().unwrap().unwrap();
6060        let cigar_nucleotides = read.cigar_stats_nucleotides();
6061        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
6062        let cigar_blocks = read.cigar_stats_blocks();
6063        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
6064        let read = it.next().unwrap().unwrap();
6065        let cigar_nucleotides = read.cigar_stats_nucleotides();
6066        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
6067        let cigar_blocks = read.cigar_stats_blocks();
6068        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
6069        let read = it.next().unwrap().unwrap();
6070        let cigar_nucleotides = read.cigar_stats_nucleotides();
6071        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
6072        let cigar_blocks = read.cigar_stats_blocks();
6073        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
6074        let read = it.next().unwrap().unwrap();
6075        let cigar_nucleotides = read.cigar_stats_nucleotides();
6076        assert_eq!(to_arr(cigar_nucleotides), [42, 0, 0, 0, 9, 0, 0, 0, 0]);
6077        let cigar_blocks = read.cigar_stats_blocks();
6078        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
6079        let read = it.next().unwrap().unwrap();
6080        let cigar_nucleotides = read.cigar_stats_nucleotides();
6081        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
6082        let cigar_blocks = read.cigar_stats_blocks();
6083        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
6084        let read = it.next().unwrap().unwrap();
6085        let cigar_nucleotides = read.cigar_stats_nucleotides();
6086        assert_eq!(to_arr(cigar_nucleotides), [50, 0, 0, 0, 1, 0, 0, 0, 0]);
6087        let cigar_blocks = read.cigar_stats_blocks();
6088        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
6089        let read = it.next().unwrap().unwrap();
6090        let cigar_nucleotides = read.cigar_stats_nucleotides();
6091        assert_eq!(to_arr(cigar_nucleotides), [45, 0, 0, 0, 6, 0, 0, 0, 0]);
6092        let cigar_blocks = read.cigar_stats_blocks();
6093        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
6094        let read = it.next().unwrap().unwrap();
6095        let cigar_nucleotides = read.cigar_stats_nucleotides();
6096        assert_eq!(to_arr(cigar_nucleotides), [48, 0, 0, 0, 3, 0, 0, 0, 0]);
6097        let cigar_blocks = read.cigar_stats_blocks();
6098        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
6099        let read = it.next().unwrap().unwrap();
6100        let cigar_nucleotides = read.cigar_stats_nucleotides();
6101        assert_eq!(to_arr(cigar_nucleotides), [42, 0, 0, 0, 9, 0, 0, 0, 0]);
6102        let cigar_blocks = read.cigar_stats_blocks();
6103        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
6104        let read = it.next().unwrap().unwrap();
6105        let cigar_nucleotides = read.cigar_stats_nucleotides();
6106        assert_eq!(to_arr(cigar_nucleotides), [38, 0, 0, 0, 13, 0, 0, 0, 0]);
6107        let cigar_blocks = read.cigar_stats_blocks();
6108        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
6109        let read = it.next().unwrap().unwrap();
6110        let cigar_nucleotides = read.cigar_stats_nucleotides();
6111        assert_eq!(to_arr(cigar_nucleotides), [44, 0, 0, 0, 7, 0, 0, 0, 0]);
6112        let cigar_blocks = read.cigar_stats_blocks();
6113        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
6114        let read = it.next().unwrap().unwrap();
6115        let cigar_nucleotides = read.cigar_stats_nucleotides();
6116        assert_eq!(to_arr(cigar_nucleotides), [46, 0, 0, 0, 5, 0, 0, 0, 0]);
6117        let cigar_blocks = read.cigar_stats_blocks();
6118        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
6119        let read = it.next().unwrap().unwrap();
6120        let cigar_nucleotides = read.cigar_stats_nucleotides();
6121        assert_eq!(to_arr(cigar_nucleotides), [47, 4, 0, 0, 0, 0, 0, 0, 0]);
6122        let cigar_blocks = read.cigar_stats_blocks();
6123        assert_eq!(to_arr(cigar_blocks), [2, 1, 0, 0, 0, 0, 0, 0, 0]);
6124        let read = it.next().unwrap().unwrap();
6125        let cigar_nucleotides = read.cigar_stats_nucleotides();
6126        assert_eq!(to_arr(cigar_nucleotides), [50, 1, 0, 0, 0, 0, 0, 0, 0]);
6127        let cigar_blocks = read.cigar_stats_blocks();
6128        assert_eq!(to_arr(cigar_blocks), [2, 1, 0, 0, 0, 0, 0, 0, 0]);
6129        let read = it.next().unwrap().unwrap();
6130        let cigar_nucleotides = read.cigar_stats_nucleotides();
6131        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 2183, 0, 0, 0, 0, 0]);
6132        let cigar_blocks = read.cigar_stats_blocks();
6133        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 0, 0, 0, 0, 0]);
6134        let read = it.next().unwrap().unwrap();
6135        let cigar_nucleotides = read.cigar_stats_nucleotides();
6136        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 2183, 0, 0, 0, 0, 0]);
6137        let cigar_blocks = read.cigar_stats_blocks();
6138        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 0, 0, 0, 0, 0]);
6139        let read = it.next().unwrap().unwrap();
6140        let cigar_nucleotides = read.cigar_stats_nucleotides();
6141        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 2183, 0, 0, 0, 0, 0]);
6142        let cigar_blocks = read.cigar_stats_blocks();
6143        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 0, 0, 0, 0, 0]);
6144        let read = it.next().unwrap().unwrap();
6145        let cigar_nucleotides = read.cigar_stats_nucleotides();
6146        assert_eq!(to_arr(cigar_nucleotides), [33, 0, 0, 0, 18, 0, 0, 0, 0]);
6147        let cigar_blocks = read.cigar_stats_blocks();
6148        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 2, 0, 0, 0, 0]);
6149        let read = it.next().unwrap().unwrap();
6150        let cigar_nucleotides = read.cigar_stats_nucleotides();
6151        assert_eq!(to_arr(cigar_nucleotides), [48, 0, 0, 0, 3, 0, 0, 0, 0]);
6152        let cigar_blocks = read.cigar_stats_blocks();
6153        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 2, 0, 0, 0, 0]);
6154        let read = it.next().unwrap().unwrap();
6155        let cigar_nucleotides = read.cigar_stats_nucleotides();
6156        assert_eq!(to_arr(cigar_nucleotides), [45, 0, 0, 0, 6, 0, 0, 0, 0]);
6157        let cigar_blocks = read.cigar_stats_blocks();
6158        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 2, 0, 0, 0, 0]);
6159        let read = it.next().unwrap().unwrap();
6160        let cigar_nucleotides = read.cigar_stats_nucleotides();
6161        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 11832, 0, 0, 0, 0, 0]);
6162        let cigar_blocks = read.cigar_stats_blocks();
6163        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 0, 0, 0, 0, 0]);
6164        let read = it.next().unwrap().unwrap();
6165        let cigar_nucleotides = read.cigar_stats_nucleotides();
6166        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 12542, 0, 0, 0, 0, 0],);
6167        let cigar_blocks = read.cigar_stats_blocks();
6168        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
6169        let read = it.next().unwrap().unwrap();
6170        let cigar_nucleotides = read.cigar_stats_nucleotides();
6171        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 12542, 0, 0, 0, 0, 0],);
6172        let cigar_blocks = read.cigar_stats_blocks();
6173        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
6174        let read = it.next().unwrap().unwrap();
6175        let cigar_nucleotides = read.cigar_stats_nucleotides();
6176        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 12542, 0, 0, 0, 0, 0],);
6177        let cigar_blocks = read.cigar_stats_blocks();
6178        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
6179        let read = it.next().unwrap().unwrap();
6180        let cigar_nucleotides = read.cigar_stats_nucleotides();
6181        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 12542, 0, 0, 0, 0, 0],);
6182        let cigar_blocks = read.cigar_stats_blocks();
6183        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
6184        let read = it.next().unwrap().unwrap();
6185        let cigar_nucleotides = read.cigar_stats_nucleotides();
6186        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 12542, 0, 0, 0, 0, 0],);
6187        let cigar_blocks = read.cigar_stats_blocks();
6188        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
6189        let read = it.next().unwrap().unwrap();
6190        let cigar_nucleotides = read.cigar_stats_nucleotides();
6191        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 12542, 0, 0, 0, 0, 0],);
6192        let cigar_blocks = read.cigar_stats_blocks();
6193        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
6194        let read = it.next().unwrap().unwrap();
6195        let cigar_nucleotides = read.cigar_stats_nucleotides();
6196        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 12542, 0, 0, 0, 0, 0],);
6197        let cigar_blocks = read.cigar_stats_blocks();
6198        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
6199        let read = it.next().unwrap().unwrap();
6200        let cigar_nucleotides = read.cigar_stats_nucleotides();
6201        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 12542, 0, 0, 0, 0, 0],);
6202        let cigar_blocks = read.cigar_stats_blocks();
6203        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
6204        let read = it.next().unwrap().unwrap();
6205        let cigar_nucleotides = read.cigar_stats_nucleotides();
6206        assert_eq!(to_arr(cigar_nucleotides), [50, 0, 0, 1467, 1, 0, 0, 0, 0]);
6207        let cigar_blocks = read.cigar_stats_blocks();
6208        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 1, 0, 0, 0, 0]);
6209        let read = it.next().unwrap().unwrap();
6210        let cigar_nucleotides = read.cigar_stats_nucleotides();
6211        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 1609, 0, 0, 0, 0, 0]);
6212        let cigar_blocks = read.cigar_stats_blocks();
6213        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
6214        let read = it.next().unwrap().unwrap();
6215        let cigar_nucleotides = read.cigar_stats_nucleotides();
6216        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 1609, 0, 0, 0, 0, 0]);
6217        let cigar_blocks = read.cigar_stats_blocks();
6218        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
6219        let read = it.next().unwrap().unwrap();
6220        let cigar_nucleotides = read.cigar_stats_nucleotides();
6221        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 1609, 0, 0, 0, 0, 0]);
6222        let cigar_blocks = read.cigar_stats_blocks();
6223        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
6224        let read = it.next().unwrap().unwrap();
6225        let cigar_nucleotides = read.cigar_stats_nucleotides();
6226        assert_eq!(to_arr(cigar_nucleotides), [50, 0, 0, 95, 1, 0, 0, 0, 0]);
6227        let cigar_blocks = read.cigar_stats_blocks();
6228        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 1, 0, 0, 0, 0]);
6229        let read = it.next().unwrap().unwrap();
6230        let cigar_nucleotides = read.cigar_stats_nucleotides();
6231        assert_eq!(to_arr(cigar_nucleotides), [50, 0, 0, 538, 1, 0, 0, 0, 0]);
6232        let cigar_blocks = read.cigar_stats_blocks();
6233        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 1, 0, 0, 0, 0]);
6234        let read = it.next().unwrap().unwrap();
6235        let cigar_nucleotides = read.cigar_stats_nucleotides();
6236        assert_eq!(to_arr(cigar_nucleotides), [50, 0, 0, 538, 1, 0, 0, 0, 0]);
6237        let cigar_blocks = read.cigar_stats_blocks();
6238        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 1, 0, 0, 0, 0]);
6239        let read = it.next().unwrap().unwrap();
6240        let cigar_nucleotides = read.cigar_stats_nucleotides();
6241        assert_eq!(to_arr(cigar_nucleotides), [50, 0, 0, 538, 1, 0, 0, 0, 0]);
6242        let cigar_blocks = read.cigar_stats_blocks();
6243        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 1, 0, 0, 0, 0]);
6244        let read = it.next().unwrap().unwrap();
6245        let cigar_nucleotides = read.cigar_stats_nucleotides();
6246        assert_eq!(to_arr(cigar_nucleotides), [50, 0, 1, 0, 1, 0, 0, 0, 0]);
6247        let cigar_blocks = read.cigar_stats_blocks();
6248        assert_eq!(to_arr(cigar_blocks), [2, 0, 1, 0, 1, 0, 0, 0, 0]);
6249        let read = it.next().unwrap().unwrap();
6250        let cigar_nucleotides = read.cigar_stats_nucleotides();
6251        assert_eq!(to_arr(cigar_nucleotides), [48, 0, 1, 0, 3, 0, 0, 0, 0]);
6252        let cigar_blocks = read.cigar_stats_blocks();
6253        assert_eq!(to_arr(cigar_blocks), [2, 0, 1, 0, 1, 0, 0, 0, 0]);
6254        let read = it.next().unwrap().unwrap();
6255        let cigar_nucleotides = read.cigar_stats_nucleotides();
6256        assert_eq!(to_arr(cigar_nucleotides), [44, 0, 1, 0, 7, 0, 0, 0, 0]);
6257        let cigar_blocks = read.cigar_stats_blocks();
6258        assert_eq!(to_arr(cigar_blocks), [2, 0, 1, 0, 1, 0, 0, 0, 0]);
6259        let read = it.next().unwrap().unwrap();
6260        let cigar_nucleotides = read.cigar_stats_nucleotides();
6261        assert_eq!(to_arr(cigar_nucleotides), [39, 1, 0, 0, 11, 0, 0, 0, 0]);
6262        let cigar_blocks = read.cigar_stats_blocks();
6263        assert_eq!(to_arr(cigar_blocks), [2, 1, 0, 0, 1, 0, 0, 0, 0]);
6264        let read = it.next().unwrap().unwrap();
6265        let cigar_nucleotides = read.cigar_stats_nucleotides();
6266        assert_eq!(to_arr(cigar_nucleotides), [46, 0, 0, 1892, 5, 0, 0, 0, 0]);
6267        let cigar_blocks = read.cigar_stats_blocks();
6268        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 1, 0, 0, 0, 0]);
6269        let read = it.next().unwrap().unwrap();
6270        let cigar_nucleotides = read.cigar_stats_nucleotides();
6271        assert_eq!(to_arr(cigar_nucleotides), [49, 0, 0, 1892, 2, 0, 0, 0, 0]);
6272        let cigar_blocks = read.cigar_stats_blocks();
6273        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 1, 0, 0, 0, 0]);
6274        let read = it.next().unwrap().unwrap();
6275        let cigar_nucleotides = read.cigar_stats_nucleotides();
6276        assert_eq!(to_arr(cigar_nucleotides), [50, 0, 3, 2285, 1, 0, 0, 0, 0]);
6277        let cigar_blocks = read.cigar_stats_blocks();
6278        assert_eq!(to_arr(cigar_blocks), [3, 0, 1, 1, 1, 0, 0, 0, 0]);
6279        let read = it.next().unwrap().unwrap();
6280        let cigar_nucleotides = read.cigar_stats_nucleotides();
6281        assert_eq!(to_arr(cigar_nucleotides), [49, 0, 0, 14680, 2, 0, 0, 0, 0],);
6282        let cigar_blocks = read.cigar_stats_blocks();
6283        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 1, 0, 0, 0, 0]);
6284        let read = it.next().unwrap().unwrap();
6285        let cigar_nucleotides = read.cigar_stats_nucleotides();
6286        assert_eq!(to_arr(cigar_nucleotides), [47, 0, 0, 4027, 4, 0, 0, 0, 0]);
6287        let cigar_blocks = read.cigar_stats_blocks();
6288        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 1, 0, 0, 0, 0]);
6289    }
6290
6291    #[test]
6292    fn test_reference_positions() {
6293        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
6294        let mut it = bam.records();
6295
6296        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6297        assert_eq!(
6298            rp,
6299            vec![
6300                16050676, 16050677, 16050678, 16050679, 16050680, 16050681, 16050682, 16050683,
6301                16050684, 16050685, 16050686, 16050687, 16050688, 16050689, 16050690, 16050691,
6302                16050692, 16050693, 16050694, 16050695, 16050696, 16050697, 16050698, 16050699,
6303                16050700, 16050701, 16050702, 16050703, 16050704, 16050705, 16050706, 16050707,
6304                16050708, 16050709, 16050710, 16050711, 16050712, 16050713, 16050714, 16050715,
6305                16050716, 16050717, 16050718, 16050719, 16050720
6306            ]
6307        );
6308        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6309        assert_eq!(
6310            rp,
6311            vec![
6312                16096878, 16096879, 16096880, 16096881, 16096882, 16096883, 16096884, 16096887,
6313                16096888, 16096889, 16096890, 16096891, 16096892, 16096893, 16096894, 16096895,
6314                16096896, 16096897, 16096898, 16096899, 16096900, 16096901, 16096902, 16096903,
6315                16096904, 16096905, 16096906, 16096907, 16096908, 16096909, 16096910, 16096911,
6316                16096912, 16096913, 16096914, 16096915, 16096916, 16096917, 16096918, 16096919,
6317                16096920, 16096921, 16096922, 16096923, 16096924, 16096925, 16096926, 16096927,
6318                16096928, 16096929, 16096930
6319            ]
6320        );
6321        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6322        assert_eq!(
6323            rp,
6324            vec![
6325                16097145, 16097146, 16097147, 16097148, 16097149, 16097150, 16097151, 16097152,
6326                16097153, 16097154, 16097155, 16097156, 16097157, 16097158, 16097159, 16097160,
6327                16097161, 16097162, 16097163, 16097164, 16097165, 16097166, 16097167, 16097168,
6328                16097169, 16097170, 16097171, 16097172, 16097173, 16097176, 16097177, 16097178,
6329                16097179, 16097180, 16097181, 16097182, 16097183, 16097184, 16097185, 16097186,
6330                16097187, 16097188, 16097189, 16097190, 16097191, 16097192, 16097193, 16097194,
6331                16097195, 16097196, 16097197
6332            ]
6333        );
6334        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6335        assert_eq!(
6336            rp,
6337            vec![
6338                16117350, 16117351, 16117352, 16117353, 16117354, 16117355, 16117356, 16117357,
6339                16117358, 16117359, 16117360, 16117361, 16117362, 16117363, 16117364, 16117365,
6340                16117366, 16117367, 16117368, 16117369, 16117370, 16117371, 16117372, 16117373,
6341                16117374, 16117375, 16117376, 16117377, 16117378, 16117379, 16117380, 16117381,
6342                16117382, 16117383, 16117384, 16117385, 16117386, 16117387, 16117388, 16117389,
6343                16117390, 16117391, 16117392, 16117393, 16117394, 16117395, 16117396, 16117397,
6344                16117398, 16117399, 16117400
6345            ]
6346        );
6347        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6348        assert_eq!(
6349            rp,
6350            vec![
6351                16118483, 16118484, 16118485, 16118486, 16118487, 16118488, 16118489, 16118490,
6352                16118491, 16118492, 16118493, 16118494, 16118495, 16118496, 16118497, 16118498,
6353                16118499, 16118500, 16118501, 16118502, 16118503, 16118504, 16118505, 16118506,
6354                16118507, 16118508, 16118509, 16118510, 16118511, 16118512, 16118513, 16118514,
6355                16118515, 16118516, 16118517, 16118518, 16118519, 16118520, 16118521, 16118522,
6356                16118523, 16118524, 16118525, 16118526, 16118527, 16118528, 16118529, 16118530,
6357                16118531, 16118532, 16118533
6358            ]
6359        );
6360        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6361        assert_eq!(
6362            rp,
6363            vec![
6364                16118499, 16118500, 16118501, 16118502, 16118503, 16118504, 16118505, 16118506,
6365                16118507, 16118508, 16118509, 16118510, 16118511, 16118512, 16118513, 16118514,
6366                16118515, 16118516, 16118517, 16118518, 16118519, 16118520, 16118521, 16118522,
6367                16118523, 16118524, 16118525, 16118526, 16118527, 16118528, 16118529, 16118530,
6368                16118531, 16118532, 16118533, 16118534, 16118535, 16118536, 16118537, 16118538,
6369                16118539, 16118540, 16118541, 16118542, 16118543, 16118544, 16118545, 16118546,
6370                16118547, 16118548, 16118549
6371            ]
6372        );
6373        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6374        assert_eq!(
6375            rp,
6376            vec![
6377                16118499, 16118500, 16118501, 16118502, 16118503, 16118504, 16118505, 16118506,
6378                16118507, 16118508, 16118509, 16118510, 16118511, 16118512, 16118513, 16118514,
6379                16118515, 16118516, 16118517, 16118518, 16118519, 16118520, 16118521, 16118522,
6380                16118523, 16118524, 16118525, 16118526, 16118527, 16118528, 16118529, 16118530,
6381                16118531, 16118532, 16118533, 16118534, 16118535, 16118536, 16118537, 16118538,
6382                16118539, 16118540, 16118541, 16118542, 16118543, 16118544, 16118545, 16118546,
6383                16118547, 16118548, 16118549
6384            ]
6385        );
6386        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6387        assert_eq!(
6388            rp,
6389            vec![
6390                16118499, 16118500, 16118501, 16118502, 16118503, 16118504, 16118505, 16118506,
6391                16118507, 16118508, 16118509, 16118510, 16118511, 16118512, 16118513, 16118514,
6392                16118515, 16118516, 16118517, 16118518, 16118519, 16118520, 16118521, 16118522,
6393                16118523, 16118524, 16118525, 16118526, 16118527, 16118528, 16118529, 16118530,
6394                16118531, 16118532, 16118533, 16118534, 16118535, 16118536, 16118537, 16118538,
6395                16118539, 16118540, 16118541, 16118542, 16118543, 16118544, 16118545, 16118546,
6396                16118547, 16118548, 16118549
6397            ]
6398        );
6399        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6400        assert_eq!(
6401            rp,
6402            vec![
6403                16123411, 16123412, 16123413, 16123414, 16123415, 16123416, 16123417, 16123418,
6404                16123419, 16123420, 16123421, 16123422, 16123423, 16123424, 16123425, 16123426,
6405                16123427, 16123428, 16123429, 16123430, 16123431, 16123432, 16123433, 16123434,
6406                16123435, 16123436, 16123437, 16123438, 16123439, 16123440, 16123441, 16123442,
6407                16123443, 16123444, 16123445, 16123446, 16123447, 16123448, 16123449, 16123450,
6408                16123451, 16123452, 16123453, 16123454, 16123455, 16123456, 16123457, 16123458,
6409                16123459, 16123460, 16123461
6410            ]
6411        );
6412        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6413        assert_eq!(
6414            rp,
6415            vec![
6416                16123417, 16123418, 16123419, 16123420, 16123421, 16123422, 16123423, 16123424,
6417                16123425, 16123426, 16123427, 16123428, 16123429, 16123430, 16123431, 16123432,
6418                16123433, 16123434, 16123435, 16123436, 16123437, 16123438, 16123439, 16123440,
6419                16123441, 16123442, 16123443, 16123444, 16123445, 16123446, 16123447, 16123448,
6420                16123449, 16123450, 16123451, 16123452, 16123453, 16123454, 16123455, 16123456,
6421                16123457, 16123458, 16123459, 16123460, 16123461
6422            ]
6423        );
6424        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6425        assert_eq!(
6426            rp,
6427            vec![
6428                16165860, 16165861, 16165862, 16165863, 16165864, 16165865, 16165866, 16165867,
6429                16165868, 16165869, 16165870, 16165871, 16165872, 16165873, 16165874, 16165875,
6430                16165876, 16165877, 16165878, 16165879, 16165880, 16165881, 16165882, 16165883,
6431                16165884, 16165885, 16165886, 16165887, 16165888, 16165889, 16165890, 16165891,
6432                16165892, 16165893, 16165894, 16165895, 16165896, 16165897, 16165898, 16165899,
6433                16165900
6434            ]
6435        );
6436        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6437        assert_eq!(
6438            rp,
6439            vec![
6440                16180871, 16180872, 16180873, 16180874, 16180875, 16180876, 16180877, 16180878,
6441                16180879, 16180880, 16180881, 16180882, 16180883, 16180884, 16180885, 16180886,
6442                16180887, 16180888, 16180889, 16180890, 16180891, 16180892, 16180893, 16180894,
6443                16180895, 16180896, 16180897, 16180898, 16180899, 16180900, 16180901, 16180902,
6444                16180903, 16180904, 16180905, 16180906, 16180907, 16180908, 16180909, 16180910,
6445                16180911, 16180912, 16180913, 16180914, 16180915, 16180916, 16180917, 16180918,
6446                16180919, 16180920, 16180921
6447            ]
6448        );
6449        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6450        assert_eq!(
6451            rp,
6452            vec![
6453                16189705, 16189706, 16189707, 16189708, 16189709, 16189710, 16189711, 16189712,
6454                16189713, 16189714, 16189715, 16189716, 16189717, 16189718, 16189719, 16189720,
6455                16189721, 16189722, 16189723, 16189724, 16189725, 16189726, 16189727, 16189728,
6456                16189729, 16189730, 16189731, 16189732, 16189733, 16189734, 16189735, 16189736,
6457                16189737, 16189738, 16189739, 16189740, 16189741, 16189742, 16189743, 16189744,
6458                16189745, 16189746, 16189747, 16189748, 16189749, 16189750, 16189751, 16189752,
6459                16189753, 16189754, 16189755
6460            ]
6461        );
6462        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6463        assert_eq!(
6464            rp,
6465            vec![
6466                16231271, 16231272, 16231273, 16231274, 16231275, 16231276, 16231277, 16231278,
6467                16231279, 16231280, 16231281, 16231282, 16231283, 16231284, 16231285, 16231286,
6468                16231287, 16231288, 16231289, 16231290, 16231291, 16231292, 16231293, 16231294,
6469                16231295, 16231296, 16231297, 16231298, 16231299, 16231300, 16231301, 16231302,
6470                16231303, 16231304, 16231305, 16231306, 16231307, 16231308, 16231309, 16231310,
6471                16231311, 16231312, 16231313, 16231314, 16231315, 16231316, 16231317, 16231318,
6472                16231319, 16231320, 16231321
6473            ]
6474        );
6475        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6476        assert_eq!(
6477            rp,
6478            vec![
6479                16237657, 16237658, 16237659, 16237660, 16237661, 16237662, 16237663, 16237664,
6480                16237665, 16237666, 16237667, 16237668, 16237669, 16237670, 16237671, 16237672,
6481                16237673, 16237674, 16237675, 16237676, 16237677, 16237678, 16237679, 16237680,
6482                16237681, 16237682, 16237683, 16237684, 16237685, 16237686, 16237687, 16237688,
6483                16237689, 16237690, 16237691, 16237692, 16237693, 16237694, 16237695, 16237696,
6484                16237697, 16237698, 16237699, 16237700, 16237701, 16237702, 16237703, 16237704,
6485                16237705, 16237706, 16237707
6486            ]
6487        );
6488        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6489        assert_eq!(
6490            rp,
6491            vec![
6492                16255012, 16255013, 16255014, 16255015, 16255016, 16255017, 16255018, 16255019,
6493                16255020, 16255021, 16255022, 16255023, 16255024, 16255025, 16255026, 16255027,
6494                16255028, 16255029, 16255030, 16255031, 16255032, 16255033, 16255034, 16255035,
6495                16255036, 16255037, 16255038, 16255039, 16255040, 16255041, 16255042, 16255043,
6496                16255044, 16255045, 16255046, 16255047, 16255048, 16255049, 16255050, 16255051,
6497                16255052, 16255053
6498            ]
6499        );
6500        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6501        assert_eq!(
6502            rp,
6503            vec![
6504                16255391, 16255392, 16255393, 16255394, 16255395, 16255396, 16255397, 16255398,
6505                16255399, 16255400, 16255401, 16255402, 16255403, 16255404, 16255405, 16255406,
6506                16255407, 16255408, 16255409, 16255410, 16255411, 16255412, 16255413, 16255414,
6507                16255415, 16255416, 16255417, 16255418, 16255419, 16255420, 16255421, 16255422,
6508                16255423, 16255424, 16255425, 16255426, 16255427, 16255428, 16255429, 16255430,
6509                16255431, 16255432, 16255433, 16255434, 16255435, 16255436, 16255437, 16255438,
6510                16255439, 16255440, 16255441
6511            ]
6512        );
6513        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6514        assert_eq!(
6515            rp,
6516            vec![
6517                16255392, 16255393, 16255394, 16255395, 16255396, 16255397, 16255398, 16255399,
6518                16255400, 16255401, 16255402, 16255403, 16255404, 16255405, 16255406, 16255407,
6519                16255408, 16255409, 16255410, 16255411, 16255412, 16255413, 16255414, 16255415,
6520                16255416, 16255417, 16255418, 16255419, 16255420, 16255421, 16255422, 16255423,
6521                16255424, 16255425, 16255426, 16255427, 16255428, 16255429, 16255430, 16255431,
6522                16255432, 16255433, 16255434, 16255435, 16255436, 16255437, 16255438, 16255439,
6523                16255440, 16255441
6524            ]
6525        );
6526        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6527        assert_eq!(
6528            rp,
6529            vec![
6530                16256084, 16256085, 16256086, 16256087, 16256088, 16256089, 16256090, 16256091,
6531                16256092, 16256093, 16256094, 16256095, 16256096, 16256097, 16256098, 16256099,
6532                16256100, 16256101, 16256102, 16256103, 16256104, 16256105, 16256106, 16256107,
6533                16256108, 16256109, 16256110, 16256111, 16256112, 16256113, 16256114, 16256115,
6534                16256116, 16256117, 16256118, 16256119, 16256120, 16256121, 16256122, 16256123,
6535                16256124, 16256125, 16256126, 16256127, 16256128
6536            ]
6537        );
6538        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6539        assert_eq!(
6540            rp,
6541            vec![
6542                16256224, 16256225, 16256226, 16256227, 16256228, 16256229, 16256230, 16256231,
6543                16256232, 16256233, 16256234, 16256235, 16256236, 16256237, 16256238, 16256239,
6544                16256240, 16256241, 16256242, 16256243, 16256244, 16256245, 16256246, 16256247,
6545                16256248, 16256249, 16256250, 16256251, 16256252, 16256253, 16256254, 16256255,
6546                16256256, 16256257, 16256258, 16256259, 16256260, 16256261, 16256262, 16256263,
6547                16256264, 16256265, 16256266, 16256267, 16256268, 16256269, 16256270, 16256271
6548            ]
6549        );
6550        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6551        assert_eq!(
6552            rp,
6553            vec![
6554                16325199, 16325200, 16325201, 16325202, 16325203, 16325204, 16325205, 16325206,
6555                16325207, 16325208, 16325209, 16325210, 16325211, 16325212, 16325213, 16325214,
6556                16325215, 16325216, 16325217, 16325218, 16325219, 16325220, 16325221, 16325222,
6557                16325223, 16325224, 16325225, 16325226, 16325227, 16325228, 16325229, 16325230,
6558                16325231, 16325232, 16325233, 16325234, 16325235, 16325236, 16325237, 16325238,
6559                16325239, 16325240
6560            ]
6561        );
6562        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6563        assert_eq!(
6564            rp,
6565            vec![
6566                16352865, 16352866, 16352867, 16352868, 16352869, 16352870, 16352871, 16352872,
6567                16352873, 16352874, 16352875, 16352876, 16352877, 16352878, 16352879, 16352880,
6568                16352881, 16352882, 16352883, 16352884, 16352885, 16352886, 16352887, 16352888,
6569                16352889, 16352890, 16352891, 16352892, 16352893, 16352894, 16352895, 16352896,
6570                16352897, 16352898, 16352899, 16352900, 16352901, 16352902
6571            ]
6572        );
6573        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6574        assert_eq!(
6575            rp,
6576            vec![
6577                16352968, 16352969, 16352970, 16352971, 16352972, 16352973, 16352974, 16352975,
6578                16352976, 16352977, 16352978, 16352979, 16352980, 16352981, 16352982, 16352983,
6579                16352984, 16352985, 16352986, 16352987, 16352988, 16352989, 16352990, 16352991,
6580                16352992, 16352993, 16352994, 16352995, 16352996, 16352997, 16352998, 16352999,
6581                16353000, 16353001, 16353002, 16353003, 16353004, 16353005, 16353006, 16353007,
6582                16353008, 16353009, 16353010, 16353011
6583            ]
6584        );
6585        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6586        assert_eq!(
6587            rp,
6588            vec![
6589                16414998, 16414999, 16415000, 16415001, 16415002, 16415003, 16415004, 16415005,
6590                16415006, 16415007, 16415008, 16415009, 16415010, 16415011, 16415012, 16415013,
6591                16415014, 16415015, 16415016, 16415017, 16415018, 16415019, 16415020, 16415021,
6592                16415022, 16415023, 16415024, 16415025, 16415026, 16415027, 16415028, 16415029,
6593                16415030, 16415031, 16415032, 16415033, 16415034, 16415035, 16415036, 16415037,
6594                16415038, 16415039, 16415040, 16415041, 16415042, 16415043
6595            ]
6596        );
6597        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6598        assert_eq!(
6599            rp,
6600            vec![
6601                17031591, 17031592, 17031593, 17031594, 17031595, 17031596, 17031597, 17031598,
6602                17031599, 17031600, 17031601, 17031602, 17031603, 17031604, 17031605, 17031606,
6603                17031607, 17031608, 17031609, 17031610, 17031611, 17031612, 17031613, 17031614,
6604                17031615, 17031616, 17031617, 17031618, 17031619, 17031620, 17031621, 17031622,
6605                17031623, 17031624, 17031625, 17031626, 17031627, 17031628, 17031629, 17031630,
6606                17031631, 17031632, 17031633, 17031634, 17031635, 17031636, 17031637
6607            ]
6608        );
6609        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6610        assert_eq!(
6611            rp,
6612            vec![
6613                17057382, 17057383, 17057384, 17057385, 17057386, 17057387, 17057388, 17057389,
6614                17057390, 17057391, 17057392, 17057393, 17057394, 17057395, 17057396, 17057397,
6615                17057398, 17057399, 17057400, 17057401, 17057402, 17057403, 17057404, 17057405,
6616                17057406, 17057407, 17057408, 17057409, 17057410, 17057411, 17057412, 17057413,
6617                17057414, 17057415, 17057416, 17057417, 17057418, 17057419, 17057420, 17057421,
6618                17057422, 17057423, 17057424, 17057425, 17057426, 17057427, 17057428, 17057429,
6619                17057430, 17057431
6620            ]
6621        );
6622        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6623        assert_eq!(
6624            rp,
6625            vec![
6626                17092766, 17092767, 17092768, 17092769, 17092770, 17092771, 17092772, 17092773,
6627                17092774, 17092775, 17092776, 17092777, 17092778, 17092779, 17092780, 17092781,
6628                17092782, 17094966, 17094967, 17094968, 17094969, 17094970, 17094971, 17094972,
6629                17094973, 17094974, 17094975, 17094976, 17094977, 17094978, 17094979, 17094980,
6630                17094981, 17094982, 17094983, 17094984, 17094985, 17094986, 17094987, 17094988,
6631                17094989, 17094990, 17094991, 17094992, 17094993, 17094994, 17094995, 17094996,
6632                17094997, 17094998, 17094999
6633            ]
6634        );
6635        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6636        assert_eq!(
6637            rp,
6638            vec![
6639                17092782, 17094966, 17094967, 17094968, 17094969, 17094970, 17094971, 17094972,
6640                17094973, 17094974, 17094975, 17094976, 17094977, 17094978, 17094979, 17094980,
6641                17094981, 17094982, 17094983, 17094984, 17094985, 17094986, 17094987, 17094988,
6642                17094989, 17094990, 17094991, 17094992, 17094993, 17094994, 17094995, 17094996,
6643                17094997, 17094998, 17094999, 17095000, 17095001, 17095002, 17095003, 17095004,
6644                17095005, 17095006, 17095007, 17095008, 17095009, 17095010, 17095011, 17095012,
6645                17095013, 17095014, 17095015
6646            ]
6647        );
6648        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6649        assert_eq!(
6650            rp,
6651            vec![
6652                17092782, 17094966, 17094967, 17094968, 17094969, 17094970, 17094971, 17094972,
6653                17094973, 17094974, 17094975, 17094976, 17094977, 17094978, 17094979, 17094980,
6654                17094981, 17094982, 17094983, 17094984, 17094985, 17094986, 17094987, 17094988,
6655                17094989, 17094990, 17094991, 17094992, 17094993, 17094994, 17094995, 17094996,
6656                17094997, 17094998, 17094999, 17095000, 17095001, 17095002, 17095003, 17095004,
6657                17095005, 17095006, 17095007, 17095008, 17095009, 17095010, 17095011, 17095012,
6658                17095013, 17095014, 17095015
6659            ]
6660        );
6661        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6662        assert_eq!(
6663            rp,
6664            vec![
6665                17137287, 17137288, 17137289, 17137290, 17137291, 17137292, 17137293, 17137294,
6666                17137295, 17137296, 17137297, 17137298, 17137299, 17137300, 17137301, 17137302,
6667                17137303, 17137304, 17137305, 17137306, 17137307, 17137308, 17137309, 17137310,
6668                17137311, 17137312, 17137313, 17137314, 17137315, 17137316, 17137317, 17137318,
6669                17137319
6670            ]
6671        );
6672        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6673        assert_eq!(
6674            rp,
6675            vec![
6676                17306238, 17306239, 17306240, 17306241, 17306242, 17306243, 17306244, 17306245,
6677                17306246, 17306247, 17306248, 17306249, 17306250, 17306251, 17306252, 17306253,
6678                17306254, 17306255, 17306256, 17306257, 17306258, 17306259, 17306260, 17306261,
6679                17306262, 17306263, 17306264, 17306265, 17306266, 17306267, 17306268, 17306269,
6680                17306270, 17306271, 17306272, 17306273, 17306274, 17306275, 17306276, 17306277,
6681                17306278, 17306279, 17306280, 17306281, 17306282, 17306283, 17306284, 17306285
6682            ]
6683        );
6684        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6685        assert_eq!(
6686            rp,
6687            vec![
6688                17561868, 17561869, 17561870, 17561871, 17561872, 17561873, 17561874, 17561875,
6689                17561876, 17561877, 17561878, 17561879, 17561880, 17561881, 17561882, 17561883,
6690                17561884, 17561885, 17561886, 17561887, 17561888, 17561889, 17561890, 17561891,
6691                17561892, 17561893, 17561894, 17561895, 17561896, 17561897, 17561898, 17561899,
6692                17561900, 17561901, 17561902, 17561903, 17561904, 17561905, 17561906, 17561907,
6693                17561908, 17561909, 17561910, 17561911, 17561912
6694            ]
6695        );
6696        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6697        assert_eq!(
6698            rp,
6699            vec![
6700                17566078, 17566079, 17566080, 17566081, 17566082, 17566083, 17566084, 17566085,
6701                17566086, 17566087, 17566088, 17566089, 17566090, 17566091, 17566092, 17566093,
6702                17566094, 17566095, 17566096, 17566097, 17566098, 17566099, 17566100, 17566101,
6703                17566102, 17566103, 17566104, 17566105, 17566106, 17566107, 17566108, 17566109,
6704                17566110, 17566111, 17566112, 17566113, 17566114, 17566115, 17566116, 17566117,
6705                17566118, 17577951, 17577952, 17577953, 17577954, 17577955, 17577956, 17577957,
6706                17577958, 17577959, 17577960
6707            ]
6708        );
6709        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6710        assert_eq!(
6711            rp,
6712            vec![
6713                17566108, 17566109, 17566110, 17566111, 17566112, 17566113, 17566114, 17566115,
6714                17566116, 17566117, 17566118, 17577951, 17577952, 17577953, 17577954, 17577955,
6715                17577956, 17577957, 17577958, 17577959, 17577960, 17577961, 17577962, 17577963,
6716                17577964, 17577965, 17577966, 17577967, 17577968, 17577969, 17577970, 17577971,
6717                17577972, 17577973, 17577974, 17577975, 17578686, 17578687, 17578688, 17578689,
6718                17578690, 17578691, 17578692, 17578693, 17578694, 17578695, 17578696, 17578697,
6719                17578698, 17578699, 17578700
6720            ]
6721        );
6722        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6723        assert_eq!(
6724            rp,
6725            vec![
6726                17566111, 17566112, 17566113, 17566114, 17566115, 17566116, 17566117, 17566118,
6727                17577951, 17577952, 17577953, 17577954, 17577955, 17577956, 17577957, 17577958,
6728                17577959, 17577960, 17577961, 17577962, 17577963, 17577964, 17577965, 17577966,
6729                17577967, 17577968, 17577969, 17577970, 17577971, 17577972, 17577973, 17577974,
6730                17577975, 17578686, 17578687, 17578688, 17578689, 17578690, 17578691, 17578692,
6731                17578693, 17578694, 17578695, 17578696, 17578697, 17578698, 17578699, 17578700,
6732                17578701, 17578702, 17578703
6733            ]
6734        );
6735        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6736        assert_eq!(
6737            rp,
6738            vec![
6739                17566111, 17566112, 17566113, 17566114, 17566115, 17566116, 17566117, 17566118,
6740                17577951, 17577952, 17577953, 17577954, 17577955, 17577956, 17577957, 17577958,
6741                17577959, 17577960, 17577961, 17577962, 17577963, 17577964, 17577965, 17577966,
6742                17577967, 17577968, 17577969, 17577970, 17577971, 17577972, 17577973, 17577974,
6743                17577975, 17578686, 17578687, 17578688, 17578689, 17578690, 17578691, 17578692,
6744                17578693, 17578694, 17578695, 17578696, 17578697, 17578698, 17578699, 17578700,
6745                17578701, 17578702, 17578703
6746            ]
6747        );
6748        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6749        assert_eq!(
6750            rp,
6751            vec![
6752                17566111, 17566112, 17566113, 17566114, 17566115, 17566116, 17566117, 17566118,
6753                17577951, 17577952, 17577953, 17577954, 17577955, 17577956, 17577957, 17577958,
6754                17577959, 17577960, 17577961, 17577962, 17577963, 17577964, 17577965, 17577966,
6755                17577967, 17577968, 17577969, 17577970, 17577971, 17577972, 17577973, 17577974,
6756                17577975, 17578686, 17578687, 17578688, 17578689, 17578690, 17578691, 17578692,
6757                17578693, 17578694, 17578695, 17578696, 17578697, 17578698, 17578699, 17578700,
6758                17578701, 17578702, 17578703
6759            ]
6760        );
6761        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6762        assert_eq!(
6763            rp,
6764            vec![
6765                17566111, 17566112, 17566113, 17566114, 17566115, 17566116, 17566117, 17566118,
6766                17577951, 17577952, 17577953, 17577954, 17577955, 17577956, 17577957, 17577958,
6767                17577959, 17577960, 17577961, 17577962, 17577963, 17577964, 17577965, 17577966,
6768                17577967, 17577968, 17577969, 17577970, 17577971, 17577972, 17577973, 17577974,
6769                17577975, 17578686, 17578687, 17578688, 17578689, 17578690, 17578691, 17578692,
6770                17578693, 17578694, 17578695, 17578696, 17578697, 17578698, 17578699, 17578700,
6771                17578701, 17578702, 17578703
6772            ]
6773        );
6774        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6775        assert_eq!(
6776            rp,
6777            vec![
6778                17566112, 17566113, 17566114, 17566115, 17566116, 17566117, 17566118, 17577951,
6779                17577952, 17577953, 17577954, 17577955, 17577956, 17577957, 17577958, 17577959,
6780                17577960, 17577961, 17577962, 17577963, 17577964, 17577965, 17577966, 17577967,
6781                17577968, 17577969, 17577970, 17577971, 17577972, 17577973, 17577974, 17577975,
6782                17578686, 17578687, 17578688, 17578689, 17578690, 17578691, 17578692, 17578693,
6783                17578694, 17578695, 17578696, 17578697, 17578698, 17578699, 17578700, 17578701,
6784                17578702, 17578703, 17578704
6785            ]
6786        );
6787        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6788        assert_eq!(
6789            rp,
6790            vec![
6791                17566113, 17566114, 17566115, 17566116, 17566117, 17566118, 17577951, 17577952,
6792                17577953, 17577954, 17577955, 17577956, 17577957, 17577958, 17577959, 17577960,
6793                17577961, 17577962, 17577963, 17577964, 17577965, 17577966, 17577967, 17577968,
6794                17577969, 17577970, 17577971, 17577972, 17577973, 17577974, 17577975, 17578686,
6795                17578687, 17578688, 17578689, 17578690, 17578691, 17578692, 17578693, 17578694,
6796                17578695, 17578696, 17578697, 17578698, 17578699, 17578700, 17578701, 17578702,
6797                17578703, 17578704, 17578705
6798            ]
6799        );
6800        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6801        assert_eq!(
6802            rp,
6803            vec![
6804                17566113, 17566114, 17566115, 17566116, 17566117, 17566118, 17577951, 17577952,
6805                17577953, 17577954, 17577955, 17577956, 17577957, 17577958, 17577959, 17577960,
6806                17577961, 17577962, 17577963, 17577964, 17577965, 17577966, 17577967, 17577968,
6807                17577969, 17577970, 17577971, 17577972, 17577973, 17577974, 17577975, 17578686,
6808                17578687, 17578688, 17578689, 17578690, 17578691, 17578692, 17578693, 17578694,
6809                17578695, 17578696, 17578697, 17578698, 17578699, 17578700, 17578701, 17578702,
6810                17578703, 17578704, 17578705
6811            ]
6812        );
6813        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6814        assert_eq!(
6815            rp,
6816            vec![
6817                17579733, 17579734, 17579735, 17579736, 17579737, 17579738, 17579739, 17579740,
6818                17579741, 17579742, 17579743, 17579744, 17579745, 17579746, 17579747, 17579748,
6819                17579749, 17579750, 17579751, 17579752, 17579753, 17579754, 17579755, 17579756,
6820                17579757, 17579758, 17579759, 17579760, 17579761, 17579762, 17579763, 17579764,
6821                17579765, 17579766, 17579767, 17579768, 17579769, 17579770, 17579771, 17579772,
6822                17579773, 17579774, 17579775, 17579776, 17581244, 17581245, 17581246, 17581247,
6823                17581248, 17581249
6824            ]
6825        );
6826        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6827        assert_eq!(
6828            rp,
6829            vec![
6830                17581369, 17581370, 17582885, 17582886, 17582887, 17582888, 17582889, 17582890,
6831                17582891, 17582892, 17582893, 17582894, 17582895, 17582896, 17582897, 17582898,
6832                17582899, 17582900, 17582901, 17582902, 17582903, 17582904, 17582905, 17582906,
6833                17582907, 17582908, 17582909, 17582910, 17582911, 17582912, 17582913, 17582914,
6834                17582915, 17582916, 17582917, 17582918, 17582919, 17582920, 17582921, 17582922,
6835                17582923, 17582924, 17582925, 17582926, 17582927, 17582928, 17582929, 17582930,
6836                17582931, 17582932, 17583028
6837            ]
6838        );
6839        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6840        assert_eq!(
6841            rp,
6842            vec![
6843                17581370, 17582885, 17582886, 17582887, 17582888, 17582889, 17582890, 17582891,
6844                17582892, 17582893, 17582894, 17582895, 17582896, 17582897, 17582898, 17582899,
6845                17582900, 17582901, 17582902, 17582903, 17582904, 17582905, 17582906, 17582907,
6846                17582908, 17582909, 17582910, 17582911, 17582912, 17582913, 17582914, 17582915,
6847                17582916, 17582917, 17582918, 17582919, 17582920, 17582921, 17582922, 17582923,
6848                17582924, 17582925, 17582926, 17582927, 17582928, 17582929, 17582930, 17582931,
6849                17582932, 17583028, 17583029
6850            ]
6851        );
6852        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6853        assert_eq!(
6854            rp,
6855            vec![
6856                17581370, 17582885, 17582886, 17582887, 17582888, 17582889, 17582890, 17582891,
6857                17582892, 17582893, 17582894, 17582895, 17582896, 17582897, 17582898, 17582899,
6858                17582900, 17582901, 17582902, 17582903, 17582904, 17582905, 17582906, 17582907,
6859                17582908, 17582909, 17582910, 17582911, 17582912, 17582913, 17582914, 17582915,
6860                17582916, 17582917, 17582918, 17582919, 17582920, 17582921, 17582922, 17582923,
6861                17582924, 17582925, 17582926, 17582927, 17582928, 17582929, 17582930, 17582931,
6862                17582932, 17583028, 17583029
6863            ]
6864        );
6865        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6866        assert_eq!(
6867            rp,
6868            vec![
6869                17582911, 17582912, 17582913, 17582914, 17582915, 17582916, 17582917, 17582918,
6870                17582919, 17582920, 17582921, 17582922, 17582923, 17582924, 17582925, 17582926,
6871                17582927, 17582928, 17582929, 17582930, 17582931, 17582932, 17583028, 17583029,
6872                17583030, 17583031, 17583032, 17583033, 17583034, 17583035, 17583036, 17583037,
6873                17583038, 17583039, 17583040, 17583041, 17583042, 17583043, 17583044, 17583045,
6874                17583046, 17583047, 17583048, 17583049, 17583050, 17583051, 17583052, 17583053,
6875                17583054, 17583055
6876            ]
6877        );
6878        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6879        assert_eq!(
6880            rp,
6881            vec![
6882                17588621, 17588622, 17588623, 17588624, 17588625, 17588626, 17588627, 17588628,
6883                17588629, 17588630, 17588631, 17588632, 17588633, 17588634, 17588635, 17588636,
6884                17588637, 17588638, 17588639, 17588640, 17588641, 17588642, 17588643, 17588644,
6885                17588645, 17588646, 17588647, 17588648, 17588649, 17588650, 17588651, 17588652,
6886                17588653, 17588654, 17588655, 17588656, 17588657, 17589196, 17589197, 17589198,
6887                17589199, 17589200, 17589201, 17589202, 17589203, 17589204, 17589205, 17589206,
6888                17589207, 17589208
6889            ]
6890        );
6891        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6892        assert_eq!(
6893            rp,
6894            vec![
6895                17588621, 17588622, 17588623, 17588624, 17588625, 17588626, 17588627, 17588628,
6896                17588629, 17588630, 17588631, 17588632, 17588633, 17588634, 17588635, 17588636,
6897                17588637, 17588638, 17588639, 17588640, 17588641, 17588642, 17588643, 17588644,
6898                17588645, 17588646, 17588647, 17588648, 17588649, 17588650, 17588651, 17588652,
6899                17588653, 17588654, 17588655, 17588656, 17588657, 17589196, 17589197, 17589198,
6900                17589199, 17589200, 17589201, 17589202, 17589203, 17589204, 17589205, 17589206,
6901                17589207, 17589208
6902            ]
6903        );
6904        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6905        assert_eq!(
6906            rp,
6907            vec![
6908                17588621, 17588622, 17588623, 17588624, 17588625, 17588626, 17588627, 17588628,
6909                17588629, 17588630, 17588631, 17588632, 17588633, 17588634, 17588635, 17588636,
6910                17588637, 17588638, 17588639, 17588640, 17588641, 17588642, 17588643, 17588644,
6911                17588645, 17588646, 17588647, 17588648, 17588649, 17588650, 17588651, 17588652,
6912                17588653, 17588654, 17588655, 17588656, 17588657, 17589196, 17589197, 17589198,
6913                17589199, 17589200, 17589201, 17589202, 17589203, 17589204, 17589205, 17589206,
6914                17589207, 17589208
6915            ]
6916        );
6917        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6918        assert_eq!(
6919            rp,
6920            vec![
6921                17591770, 17591771, 17591772, 17591773, 17591774, 17591775, 17591776, 17591777,
6922                17591778, 17591779, 17591780, 17591781, 17591782, 17591783, 17591784, 17591785,
6923                17591786, 17591787, 17591788, 17591789, 17591790, 17591791, 17591792, 17591793,
6924                17591794, 17591796, 17591797, 17591798, 17591799, 17591800, 17591801, 17591802,
6925                17591803, 17591804, 17591805, 17591806, 17591807, 17591808, 17591809, 17591810,
6926                17591811, 17591812, 17591813, 17591814, 17591815, 17591816, 17591817, 17591818,
6927                17591819, 17591820
6928            ]
6929        );
6930        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6931        assert_eq!(
6932            rp,
6933            vec![
6934                17593855, 17593856, 17593857, 17593858, 17593859, 17593860, 17593861, 17593862,
6935                17593863, 17593864, 17593865, 17593866, 17593867, 17593868, 17593869, 17593870,
6936                17593871, 17593872, 17593873, 17593874, 17593875, 17593876, 17593877, 17593878,
6937                17593880, 17593881, 17593882, 17593883, 17593884, 17593885, 17593886, 17593887,
6938                17593888, 17593889, 17593890, 17593891, 17593892, 17593893, 17593894, 17593895,
6939                17593896, 17593897, 17593898, 17593899, 17593900, 17593901, 17593902, 17593903
6940            ]
6941        );
6942        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6943        assert_eq!(
6944            rp,
6945            vec![
6946                17593863, 17593864, 17593865, 17593866, 17593867, 17593868, 17593869, 17593870,
6947                17593871, 17593872, 17593873, 17593874, 17593875, 17593876, 17593877, 17593878,
6948                17593880, 17593881, 17593882, 17593883, 17593884, 17593885, 17593886, 17593887,
6949                17593888, 17593889, 17593890, 17593891, 17593892, 17593893, 17593894, 17593895,
6950                17593896, 17593897, 17593898, 17593899, 17593900, 17593901, 17593902, 17593903,
6951                17593904, 17593905, 17593906, 17593907
6952            ]
6953        );
6954        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6955        assert_eq!(
6956            rp,
6957            vec![
6958                17596476, 17596477, 17596478, 17596479, 17596480, 17596481, 17596482, 17596483,
6959                17596484, 17596485, 17596486, 17596487, 17596488, 17596489, 17596490, 17596491,
6960                17596492, 17596493, 17596494, 17596495, 17596496, 17596497, 17596498, 17596499,
6961                17596500, 17596501, 17596502, 17596503, 17596504, 17596505, 17596506, 17596507,
6962                17596508, 17596509, 17596510, 17596511, 17596512, 17596513, 17596514
6963            ]
6964        );
6965        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6966        assert_eq!(
6967            rp,
6968            vec![
6969                17624012, 17624013, 17624014, 17624015, 17624016, 17624017, 17624018, 17624019,
6970                17624020, 17625913, 17625914, 17625915, 17625916, 17625917, 17625918, 17625919,
6971                17625920, 17625921, 17625922, 17625923, 17625924, 17625925, 17625926, 17625927,
6972                17625928, 17625929, 17625930, 17625931, 17625932, 17625933, 17625934, 17625935,
6973                17625936, 17625937, 17625938, 17625939, 17625940, 17625941, 17625942, 17625943,
6974                17625944, 17625945, 17625946, 17625947, 17625948, 17625949
6975            ]
6976        );
6977        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6978        assert_eq!(
6979            rp,
6980            vec![
6981                17624012, 17624013, 17624014, 17624015, 17624016, 17624017, 17624018, 17624019,
6982                17624020, 17625913, 17625914, 17625915, 17625916, 17625917, 17625918, 17625919,
6983                17625920, 17625921, 17625922, 17625923, 17625924, 17625925, 17625926, 17625927,
6984                17625928, 17625929, 17625930, 17625931, 17625932, 17625933, 17625934, 17625935,
6985                17625936, 17625937, 17625938, 17625939, 17625940, 17625941, 17625942, 17625943,
6986                17625944, 17625945, 17625946, 17625947, 17625948, 17625949, 17625950, 17625951,
6987                17625952
6988            ]
6989        );
6990        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
6991        assert_eq!(
6992            rp,
6993            vec![
6994                31796700, 31796701, 31796702, 31796703, 31796704, 31796705, 31796706, 31796710,
6995                31796711, 31796712, 31796713, 31796714, 31796715, 31796716, 31796717, 31796718,
6996                31796719, 31796720, 31796721, 31796722, 31796723, 31796724, 31796725, 31796726,
6997                31796727, 31796728, 31799014, 31799015, 31799016, 31799017, 31799018, 31799019,
6998                31799020, 31799021, 31799022, 31799023, 31799024, 31799025, 31799026, 31799027,
6999                31799028, 31799029, 31799030, 31799031, 31799032, 31799033, 31799034, 31799035,
7000                31799036, 31799037
7001            ]
7002        );
7003        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7004        assert_eq!(
7005            rp,
7006            vec![
7007                36722692, 36722693, 36722694, 36722695, 36722696, 36722697, 36722698, 36722699,
7008                36722700, 36722701, 36722702, 36722703, 36722704, 36722705, 36723505, 36723506,
7009                36723507, 36723508, 36723509, 36723510, 36723511, 36723512, 36723513, 36723514,
7010                36723515, 36723516, 36723517, 36723518, 36723519, 36723520, 36723521, 36723522,
7011                36723523, 36723524, 36723525, 36723526, 36723527, 36723528, 36723529, 36723530,
7012                36723531, 36723532, 36737414, 36737415, 36737416, 36737417, 36737418, 36737419,
7013                36737420
7014            ]
7015        );
7016        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7017        assert_eq!(
7018            rp,
7019            vec![
7020                44587963, 44587964, 44587965, 44587966, 44587967, 44587968, 44587969, 44587970,
7021                44587971, 44587972, 44587973, 44587974, 44587975, 44587976, 44587977, 44587978,
7022                44587979, 44587980, 44587981, 44587982, 44587983, 44589680, 44589681, 44589682,
7023                44589683, 44589684, 44589685, 44589686, 44589687, 44589688, 44589689, 44589690,
7024                44589691, 44589692, 44589693, 44589694, 44589695, 44589696, 44589697, 44589698,
7025                44589699, 44589700, 44589701, 44589702, 44592034, 44592035, 44592036
7026            ]
7027        );
7028    }
7029
7030    #[test]
7031    fn test_reference_positions_full() {
7032        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
7033        let mut it = bam.records();
7034
7035        let rp: Vec<_> = it
7036            .next()
7037            .unwrap()
7038            .unwrap()
7039            .reference_positions_full()
7040            .collect();
7041        assert_eq!(
7042            rp,
7043            vec![
7044                None,
7045                None,
7046                None,
7047                None,
7048                None,
7049                None,
7050                Some(16050676),
7051                Some(16050677),
7052                Some(16050678),
7053                Some(16050679),
7054                Some(16050680),
7055                Some(16050681),
7056                Some(16050682),
7057                Some(16050683),
7058                Some(16050684),
7059                Some(16050685),
7060                Some(16050686),
7061                Some(16050687),
7062                Some(16050688),
7063                Some(16050689),
7064                Some(16050690),
7065                Some(16050691),
7066                Some(16050692),
7067                Some(16050693),
7068                Some(16050694),
7069                Some(16050695),
7070                Some(16050696),
7071                Some(16050697),
7072                Some(16050698),
7073                Some(16050699),
7074                Some(16050700),
7075                Some(16050701),
7076                Some(16050702),
7077                Some(16050703),
7078                Some(16050704),
7079                Some(16050705),
7080                Some(16050706),
7081                Some(16050707),
7082                Some(16050708),
7083                Some(16050709),
7084                Some(16050710),
7085                Some(16050711),
7086                Some(16050712),
7087                Some(16050713),
7088                Some(16050714),
7089                Some(16050715),
7090                Some(16050716),
7091                Some(16050717),
7092                Some(16050718),
7093                Some(16050719),
7094                Some(16050720)
7095            ]
7096        );
7097        let rp: Vec<_> = it
7098            .next()
7099            .unwrap()
7100            .unwrap()
7101            .reference_positions_full()
7102            .collect();
7103        assert_eq!(
7104            rp,
7105            vec![
7106                Some(16096878),
7107                Some(16096879),
7108                Some(16096880),
7109                Some(16096881),
7110                Some(16096882),
7111                Some(16096883),
7112                Some(16096884),
7113                Some(16096887),
7114                Some(16096888),
7115                Some(16096889),
7116                Some(16096890),
7117                Some(16096891),
7118                Some(16096892),
7119                Some(16096893),
7120                Some(16096894),
7121                Some(16096895),
7122                Some(16096896),
7123                Some(16096897),
7124                Some(16096898),
7125                Some(16096899),
7126                Some(16096900),
7127                Some(16096901),
7128                Some(16096902),
7129                Some(16096903),
7130                Some(16096904),
7131                Some(16096905),
7132                Some(16096906),
7133                Some(16096907),
7134                Some(16096908),
7135                Some(16096909),
7136                Some(16096910),
7137                Some(16096911),
7138                Some(16096912),
7139                Some(16096913),
7140                Some(16096914),
7141                Some(16096915),
7142                Some(16096916),
7143                Some(16096917),
7144                Some(16096918),
7145                Some(16096919),
7146                Some(16096920),
7147                Some(16096921),
7148                Some(16096922),
7149                Some(16096923),
7150                Some(16096924),
7151                Some(16096925),
7152                Some(16096926),
7153                Some(16096927),
7154                Some(16096928),
7155                Some(16096929),
7156                Some(16096930)
7157            ]
7158        );
7159        let rp: Vec<_> = it
7160            .next()
7161            .unwrap()
7162            .unwrap()
7163            .reference_positions_full()
7164            .collect();
7165        assert_eq!(
7166            rp,
7167            vec![
7168                Some(16097145),
7169                Some(16097146),
7170                Some(16097147),
7171                Some(16097148),
7172                Some(16097149),
7173                Some(16097150),
7174                Some(16097151),
7175                Some(16097152),
7176                Some(16097153),
7177                Some(16097154),
7178                Some(16097155),
7179                Some(16097156),
7180                Some(16097157),
7181                Some(16097158),
7182                Some(16097159),
7183                Some(16097160),
7184                Some(16097161),
7185                Some(16097162),
7186                Some(16097163),
7187                Some(16097164),
7188                Some(16097165),
7189                Some(16097166),
7190                Some(16097167),
7191                Some(16097168),
7192                Some(16097169),
7193                Some(16097170),
7194                Some(16097171),
7195                Some(16097172),
7196                Some(16097173),
7197                Some(16097176),
7198                Some(16097177),
7199                Some(16097178),
7200                Some(16097179),
7201                Some(16097180),
7202                Some(16097181),
7203                Some(16097182),
7204                Some(16097183),
7205                Some(16097184),
7206                Some(16097185),
7207                Some(16097186),
7208                Some(16097187),
7209                Some(16097188),
7210                Some(16097189),
7211                Some(16097190),
7212                Some(16097191),
7213                Some(16097192),
7214                Some(16097193),
7215                Some(16097194),
7216                Some(16097195),
7217                Some(16097196),
7218                Some(16097197)
7219            ]
7220        );
7221        let rp: Vec<_> = it
7222            .next()
7223            .unwrap()
7224            .unwrap()
7225            .reference_positions_full()
7226            .collect();
7227        assert_eq!(
7228            rp,
7229            vec![
7230                Some(16117350),
7231                Some(16117351),
7232                Some(16117352),
7233                Some(16117353),
7234                Some(16117354),
7235                Some(16117355),
7236                Some(16117356),
7237                Some(16117357),
7238                Some(16117358),
7239                Some(16117359),
7240                Some(16117360),
7241                Some(16117361),
7242                Some(16117362),
7243                Some(16117363),
7244                Some(16117364),
7245                Some(16117365),
7246                Some(16117366),
7247                Some(16117367),
7248                Some(16117368),
7249                Some(16117369),
7250                Some(16117370),
7251                Some(16117371),
7252                Some(16117372),
7253                Some(16117373),
7254                Some(16117374),
7255                Some(16117375),
7256                Some(16117376),
7257                Some(16117377),
7258                Some(16117378),
7259                Some(16117379),
7260                Some(16117380),
7261                Some(16117381),
7262                Some(16117382),
7263                Some(16117383),
7264                Some(16117384),
7265                Some(16117385),
7266                Some(16117386),
7267                Some(16117387),
7268                Some(16117388),
7269                Some(16117389),
7270                Some(16117390),
7271                Some(16117391),
7272                Some(16117392),
7273                Some(16117393),
7274                Some(16117394),
7275                Some(16117395),
7276                Some(16117396),
7277                Some(16117397),
7278                Some(16117398),
7279                Some(16117399),
7280                Some(16117400)
7281            ]
7282        );
7283        let rp: Vec<_> = it
7284            .next()
7285            .unwrap()
7286            .unwrap()
7287            .reference_positions_full()
7288            .collect();
7289        assert_eq!(
7290            rp,
7291            vec![
7292                Some(16118483),
7293                Some(16118484),
7294                Some(16118485),
7295                Some(16118486),
7296                Some(16118487),
7297                Some(16118488),
7298                Some(16118489),
7299                Some(16118490),
7300                Some(16118491),
7301                Some(16118492),
7302                Some(16118493),
7303                Some(16118494),
7304                Some(16118495),
7305                Some(16118496),
7306                Some(16118497),
7307                Some(16118498),
7308                Some(16118499),
7309                Some(16118500),
7310                Some(16118501),
7311                Some(16118502),
7312                Some(16118503),
7313                Some(16118504),
7314                Some(16118505),
7315                Some(16118506),
7316                Some(16118507),
7317                Some(16118508),
7318                Some(16118509),
7319                Some(16118510),
7320                Some(16118511),
7321                Some(16118512),
7322                Some(16118513),
7323                Some(16118514),
7324                Some(16118515),
7325                Some(16118516),
7326                Some(16118517),
7327                Some(16118518),
7328                Some(16118519),
7329                Some(16118520),
7330                Some(16118521),
7331                Some(16118522),
7332                Some(16118523),
7333                Some(16118524),
7334                Some(16118525),
7335                Some(16118526),
7336                Some(16118527),
7337                Some(16118528),
7338                Some(16118529),
7339                Some(16118530),
7340                Some(16118531),
7341                Some(16118532),
7342                Some(16118533)
7343            ]
7344        );
7345        let rp: Vec<_> = it
7346            .next()
7347            .unwrap()
7348            .unwrap()
7349            .reference_positions_full()
7350            .collect();
7351        assert_eq!(
7352            rp,
7353            vec![
7354                Some(16118499),
7355                Some(16118500),
7356                Some(16118501),
7357                Some(16118502),
7358                Some(16118503),
7359                Some(16118504),
7360                Some(16118505),
7361                Some(16118506),
7362                Some(16118507),
7363                Some(16118508),
7364                Some(16118509),
7365                Some(16118510),
7366                Some(16118511),
7367                Some(16118512),
7368                Some(16118513),
7369                Some(16118514),
7370                Some(16118515),
7371                Some(16118516),
7372                Some(16118517),
7373                Some(16118518),
7374                Some(16118519),
7375                Some(16118520),
7376                Some(16118521),
7377                Some(16118522),
7378                Some(16118523),
7379                Some(16118524),
7380                Some(16118525),
7381                Some(16118526),
7382                Some(16118527),
7383                Some(16118528),
7384                Some(16118529),
7385                Some(16118530),
7386                Some(16118531),
7387                Some(16118532),
7388                Some(16118533),
7389                Some(16118534),
7390                Some(16118535),
7391                Some(16118536),
7392                Some(16118537),
7393                Some(16118538),
7394                Some(16118539),
7395                Some(16118540),
7396                Some(16118541),
7397                Some(16118542),
7398                Some(16118543),
7399                Some(16118544),
7400                Some(16118545),
7401                Some(16118546),
7402                Some(16118547),
7403                Some(16118548),
7404                Some(16118549)
7405            ]
7406        );
7407        let rp: Vec<_> = it
7408            .next()
7409            .unwrap()
7410            .unwrap()
7411            .reference_positions_full()
7412            .collect();
7413        assert_eq!(
7414            rp,
7415            vec![
7416                Some(16118499),
7417                Some(16118500),
7418                Some(16118501),
7419                Some(16118502),
7420                Some(16118503),
7421                Some(16118504),
7422                Some(16118505),
7423                Some(16118506),
7424                Some(16118507),
7425                Some(16118508),
7426                Some(16118509),
7427                Some(16118510),
7428                Some(16118511),
7429                Some(16118512),
7430                Some(16118513),
7431                Some(16118514),
7432                Some(16118515),
7433                Some(16118516),
7434                Some(16118517),
7435                Some(16118518),
7436                Some(16118519),
7437                Some(16118520),
7438                Some(16118521),
7439                Some(16118522),
7440                Some(16118523),
7441                Some(16118524),
7442                Some(16118525),
7443                Some(16118526),
7444                Some(16118527),
7445                Some(16118528),
7446                Some(16118529),
7447                Some(16118530),
7448                Some(16118531),
7449                Some(16118532),
7450                Some(16118533),
7451                Some(16118534),
7452                Some(16118535),
7453                Some(16118536),
7454                Some(16118537),
7455                Some(16118538),
7456                Some(16118539),
7457                Some(16118540),
7458                Some(16118541),
7459                Some(16118542),
7460                Some(16118543),
7461                Some(16118544),
7462                Some(16118545),
7463                Some(16118546),
7464                Some(16118547),
7465                Some(16118548),
7466                Some(16118549)
7467            ]
7468        );
7469        let rp: Vec<_> = it
7470            .next()
7471            .unwrap()
7472            .unwrap()
7473            .reference_positions_full()
7474            .collect();
7475        assert_eq!(
7476            rp,
7477            vec![
7478                Some(16118499),
7479                Some(16118500),
7480                Some(16118501),
7481                Some(16118502),
7482                Some(16118503),
7483                Some(16118504),
7484                Some(16118505),
7485                Some(16118506),
7486                Some(16118507),
7487                Some(16118508),
7488                Some(16118509),
7489                Some(16118510),
7490                Some(16118511),
7491                Some(16118512),
7492                Some(16118513),
7493                Some(16118514),
7494                Some(16118515),
7495                Some(16118516),
7496                Some(16118517),
7497                Some(16118518),
7498                Some(16118519),
7499                Some(16118520),
7500                Some(16118521),
7501                Some(16118522),
7502                Some(16118523),
7503                Some(16118524),
7504                Some(16118525),
7505                Some(16118526),
7506                Some(16118527),
7507                Some(16118528),
7508                Some(16118529),
7509                Some(16118530),
7510                Some(16118531),
7511                Some(16118532),
7512                Some(16118533),
7513                Some(16118534),
7514                Some(16118535),
7515                Some(16118536),
7516                Some(16118537),
7517                Some(16118538),
7518                Some(16118539),
7519                Some(16118540),
7520                Some(16118541),
7521                Some(16118542),
7522                Some(16118543),
7523                Some(16118544),
7524                Some(16118545),
7525                Some(16118546),
7526                Some(16118547),
7527                Some(16118548),
7528                Some(16118549)
7529            ]
7530        );
7531        let rp: Vec<_> = it
7532            .next()
7533            .unwrap()
7534            .unwrap()
7535            .reference_positions_full()
7536            .collect();
7537        assert_eq!(
7538            rp,
7539            vec![
7540                Some(16123411),
7541                Some(16123412),
7542                Some(16123413),
7543                Some(16123414),
7544                Some(16123415),
7545                Some(16123416),
7546                Some(16123417),
7547                Some(16123418),
7548                Some(16123419),
7549                Some(16123420),
7550                Some(16123421),
7551                Some(16123422),
7552                Some(16123423),
7553                Some(16123424),
7554                Some(16123425),
7555                Some(16123426),
7556                Some(16123427),
7557                Some(16123428),
7558                Some(16123429),
7559                Some(16123430),
7560                Some(16123431),
7561                Some(16123432),
7562                Some(16123433),
7563                Some(16123434),
7564                Some(16123435),
7565                Some(16123436),
7566                Some(16123437),
7567                Some(16123438),
7568                Some(16123439),
7569                Some(16123440),
7570                Some(16123441),
7571                Some(16123442),
7572                Some(16123443),
7573                Some(16123444),
7574                Some(16123445),
7575                Some(16123446),
7576                Some(16123447),
7577                Some(16123448),
7578                Some(16123449),
7579                Some(16123450),
7580                Some(16123451),
7581                Some(16123452),
7582                Some(16123453),
7583                Some(16123454),
7584                Some(16123455),
7585                Some(16123456),
7586                Some(16123457),
7587                Some(16123458),
7588                Some(16123459),
7589                Some(16123460),
7590                Some(16123461)
7591            ]
7592        );
7593        let rp: Vec<_> = it
7594            .next()
7595            .unwrap()
7596            .unwrap()
7597            .reference_positions_full()
7598            .collect();
7599        assert_eq!(
7600            rp,
7601            vec![
7602                None,
7603                None,
7604                None,
7605                None,
7606                None,
7607                None,
7608                Some(16123417),
7609                Some(16123418),
7610                Some(16123419),
7611                Some(16123420),
7612                Some(16123421),
7613                Some(16123422),
7614                Some(16123423),
7615                Some(16123424),
7616                Some(16123425),
7617                Some(16123426),
7618                Some(16123427),
7619                Some(16123428),
7620                Some(16123429),
7621                Some(16123430),
7622                Some(16123431),
7623                Some(16123432),
7624                Some(16123433),
7625                Some(16123434),
7626                Some(16123435),
7627                Some(16123436),
7628                Some(16123437),
7629                Some(16123438),
7630                Some(16123439),
7631                Some(16123440),
7632                Some(16123441),
7633                Some(16123442),
7634                Some(16123443),
7635                Some(16123444),
7636                Some(16123445),
7637                Some(16123446),
7638                Some(16123447),
7639                Some(16123448),
7640                Some(16123449),
7641                Some(16123450),
7642                Some(16123451),
7643                Some(16123452),
7644                Some(16123453),
7645                Some(16123454),
7646                Some(16123455),
7647                Some(16123456),
7648                Some(16123457),
7649                Some(16123458),
7650                Some(16123459),
7651                Some(16123460),
7652                Some(16123461)
7653            ]
7654        );
7655        let rp: Vec<_> = it
7656            .next()
7657            .unwrap()
7658            .unwrap()
7659            .reference_positions_full()
7660            .collect();
7661        assert_eq!(
7662            rp,
7663            vec![
7664                Some(16165860),
7665                Some(16165861),
7666                Some(16165862),
7667                Some(16165863),
7668                Some(16165864),
7669                Some(16165865),
7670                Some(16165866),
7671                Some(16165867),
7672                Some(16165868),
7673                Some(16165869),
7674                Some(16165870),
7675                Some(16165871),
7676                Some(16165872),
7677                Some(16165873),
7678                Some(16165874),
7679                Some(16165875),
7680                Some(16165876),
7681                Some(16165877),
7682                Some(16165878),
7683                Some(16165879),
7684                Some(16165880),
7685                Some(16165881),
7686                Some(16165882),
7687                Some(16165883),
7688                Some(16165884),
7689                Some(16165885),
7690                Some(16165886),
7691                Some(16165887),
7692                Some(16165888),
7693                Some(16165889),
7694                Some(16165890),
7695                Some(16165891),
7696                Some(16165892),
7697                Some(16165893),
7698                Some(16165894),
7699                Some(16165895),
7700                Some(16165896),
7701                Some(16165897),
7702                Some(16165898),
7703                Some(16165899),
7704                Some(16165900),
7705                None,
7706                None,
7707                None,
7708                None,
7709                None,
7710                None,
7711                None,
7712                None,
7713                None,
7714                None
7715            ]
7716        );
7717        let rp: Vec<_> = it
7718            .next()
7719            .unwrap()
7720            .unwrap()
7721            .reference_positions_full()
7722            .collect();
7723        assert_eq!(
7724            rp,
7725            vec![
7726                Some(16180871),
7727                Some(16180872),
7728                Some(16180873),
7729                Some(16180874),
7730                Some(16180875),
7731                Some(16180876),
7732                Some(16180877),
7733                Some(16180878),
7734                Some(16180879),
7735                Some(16180880),
7736                Some(16180881),
7737                Some(16180882),
7738                Some(16180883),
7739                Some(16180884),
7740                Some(16180885),
7741                Some(16180886),
7742                Some(16180887),
7743                Some(16180888),
7744                Some(16180889),
7745                Some(16180890),
7746                Some(16180891),
7747                Some(16180892),
7748                Some(16180893),
7749                Some(16180894),
7750                Some(16180895),
7751                Some(16180896),
7752                Some(16180897),
7753                Some(16180898),
7754                Some(16180899),
7755                Some(16180900),
7756                Some(16180901),
7757                Some(16180902),
7758                Some(16180903),
7759                Some(16180904),
7760                Some(16180905),
7761                Some(16180906),
7762                Some(16180907),
7763                Some(16180908),
7764                Some(16180909),
7765                Some(16180910),
7766                Some(16180911),
7767                Some(16180912),
7768                Some(16180913),
7769                Some(16180914),
7770                Some(16180915),
7771                Some(16180916),
7772                Some(16180917),
7773                Some(16180918),
7774                Some(16180919),
7775                Some(16180920),
7776                Some(16180921)
7777            ]
7778        );
7779        let rp: Vec<_> = it
7780            .next()
7781            .unwrap()
7782            .unwrap()
7783            .reference_positions_full()
7784            .collect();
7785        assert_eq!(
7786            rp,
7787            vec![
7788                Some(16189705),
7789                Some(16189706),
7790                Some(16189707),
7791                Some(16189708),
7792                Some(16189709),
7793                Some(16189710),
7794                Some(16189711),
7795                Some(16189712),
7796                Some(16189713),
7797                Some(16189714),
7798                Some(16189715),
7799                Some(16189716),
7800                Some(16189717),
7801                Some(16189718),
7802                Some(16189719),
7803                Some(16189720),
7804                Some(16189721),
7805                Some(16189722),
7806                Some(16189723),
7807                Some(16189724),
7808                Some(16189725),
7809                Some(16189726),
7810                Some(16189727),
7811                Some(16189728),
7812                Some(16189729),
7813                Some(16189730),
7814                Some(16189731),
7815                Some(16189732),
7816                Some(16189733),
7817                Some(16189734),
7818                Some(16189735),
7819                Some(16189736),
7820                Some(16189737),
7821                Some(16189738),
7822                Some(16189739),
7823                Some(16189740),
7824                Some(16189741),
7825                Some(16189742),
7826                Some(16189743),
7827                Some(16189744),
7828                Some(16189745),
7829                Some(16189746),
7830                Some(16189747),
7831                Some(16189748),
7832                Some(16189749),
7833                Some(16189750),
7834                Some(16189751),
7835                Some(16189752),
7836                Some(16189753),
7837                Some(16189754),
7838                Some(16189755)
7839            ]
7840        );
7841        let rp: Vec<_> = it
7842            .next()
7843            .unwrap()
7844            .unwrap()
7845            .reference_positions_full()
7846            .collect();
7847        assert_eq!(
7848            rp,
7849            vec![
7850                Some(16231271),
7851                Some(16231272),
7852                Some(16231273),
7853                Some(16231274),
7854                Some(16231275),
7855                Some(16231276),
7856                Some(16231277),
7857                Some(16231278),
7858                Some(16231279),
7859                Some(16231280),
7860                Some(16231281),
7861                Some(16231282),
7862                Some(16231283),
7863                Some(16231284),
7864                Some(16231285),
7865                Some(16231286),
7866                Some(16231287),
7867                Some(16231288),
7868                Some(16231289),
7869                Some(16231290),
7870                Some(16231291),
7871                Some(16231292),
7872                Some(16231293),
7873                Some(16231294),
7874                Some(16231295),
7875                Some(16231296),
7876                Some(16231297),
7877                Some(16231298),
7878                Some(16231299),
7879                Some(16231300),
7880                Some(16231301),
7881                Some(16231302),
7882                Some(16231303),
7883                Some(16231304),
7884                Some(16231305),
7885                Some(16231306),
7886                Some(16231307),
7887                Some(16231308),
7888                Some(16231309),
7889                Some(16231310),
7890                Some(16231311),
7891                Some(16231312),
7892                Some(16231313),
7893                Some(16231314),
7894                Some(16231315),
7895                Some(16231316),
7896                Some(16231317),
7897                Some(16231318),
7898                Some(16231319),
7899                Some(16231320),
7900                Some(16231321)
7901            ]
7902        );
7903        let rp: Vec<_> = it
7904            .next()
7905            .unwrap()
7906            .unwrap()
7907            .reference_positions_full()
7908            .collect();
7909        assert_eq!(
7910            rp,
7911            vec![
7912                Some(16237657),
7913                Some(16237658),
7914                Some(16237659),
7915                Some(16237660),
7916                Some(16237661),
7917                Some(16237662),
7918                Some(16237663),
7919                Some(16237664),
7920                Some(16237665),
7921                Some(16237666),
7922                Some(16237667),
7923                Some(16237668),
7924                Some(16237669),
7925                Some(16237670),
7926                Some(16237671),
7927                Some(16237672),
7928                Some(16237673),
7929                Some(16237674),
7930                Some(16237675),
7931                Some(16237676),
7932                Some(16237677),
7933                Some(16237678),
7934                Some(16237679),
7935                Some(16237680),
7936                Some(16237681),
7937                Some(16237682),
7938                Some(16237683),
7939                Some(16237684),
7940                Some(16237685),
7941                Some(16237686),
7942                Some(16237687),
7943                Some(16237688),
7944                Some(16237689),
7945                Some(16237690),
7946                Some(16237691),
7947                Some(16237692),
7948                Some(16237693),
7949                Some(16237694),
7950                Some(16237695),
7951                Some(16237696),
7952                Some(16237697),
7953                Some(16237698),
7954                Some(16237699),
7955                Some(16237700),
7956                Some(16237701),
7957                Some(16237702),
7958                Some(16237703),
7959                Some(16237704),
7960                Some(16237705),
7961                Some(16237706),
7962                Some(16237707)
7963            ]
7964        );
7965        let rp: Vec<_> = it
7966            .next()
7967            .unwrap()
7968            .unwrap()
7969            .reference_positions_full()
7970            .collect();
7971        assert_eq!(
7972            rp,
7973            vec![
7974                None,
7975                None,
7976                None,
7977                None,
7978                None,
7979                None,
7980                None,
7981                None,
7982                None,
7983                Some(16255012),
7984                Some(16255013),
7985                Some(16255014),
7986                Some(16255015),
7987                Some(16255016),
7988                Some(16255017),
7989                Some(16255018),
7990                Some(16255019),
7991                Some(16255020),
7992                Some(16255021),
7993                Some(16255022),
7994                Some(16255023),
7995                Some(16255024),
7996                Some(16255025),
7997                Some(16255026),
7998                Some(16255027),
7999                Some(16255028),
8000                Some(16255029),
8001                Some(16255030),
8002                Some(16255031),
8003                Some(16255032),
8004                Some(16255033),
8005                Some(16255034),
8006                Some(16255035),
8007                Some(16255036),
8008                Some(16255037),
8009                Some(16255038),
8010                Some(16255039),
8011                Some(16255040),
8012                Some(16255041),
8013                Some(16255042),
8014                Some(16255043),
8015                Some(16255044),
8016                Some(16255045),
8017                Some(16255046),
8018                Some(16255047),
8019                Some(16255048),
8020                Some(16255049),
8021                Some(16255050),
8022                Some(16255051),
8023                Some(16255052),
8024                Some(16255053)
8025            ]
8026        );
8027        let rp: Vec<_> = it
8028            .next()
8029            .unwrap()
8030            .unwrap()
8031            .reference_positions_full()
8032            .collect();
8033        assert_eq!(
8034            rp,
8035            vec![
8036                Some(16255391),
8037                Some(16255392),
8038                Some(16255393),
8039                Some(16255394),
8040                Some(16255395),
8041                Some(16255396),
8042                Some(16255397),
8043                Some(16255398),
8044                Some(16255399),
8045                Some(16255400),
8046                Some(16255401),
8047                Some(16255402),
8048                Some(16255403),
8049                Some(16255404),
8050                Some(16255405),
8051                Some(16255406),
8052                Some(16255407),
8053                Some(16255408),
8054                Some(16255409),
8055                Some(16255410),
8056                Some(16255411),
8057                Some(16255412),
8058                Some(16255413),
8059                Some(16255414),
8060                Some(16255415),
8061                Some(16255416),
8062                Some(16255417),
8063                Some(16255418),
8064                Some(16255419),
8065                Some(16255420),
8066                Some(16255421),
8067                Some(16255422),
8068                Some(16255423),
8069                Some(16255424),
8070                Some(16255425),
8071                Some(16255426),
8072                Some(16255427),
8073                Some(16255428),
8074                Some(16255429),
8075                Some(16255430),
8076                Some(16255431),
8077                Some(16255432),
8078                Some(16255433),
8079                Some(16255434),
8080                Some(16255435),
8081                Some(16255436),
8082                Some(16255437),
8083                Some(16255438),
8084                Some(16255439),
8085                Some(16255440),
8086                Some(16255441)
8087            ]
8088        );
8089        let rp: Vec<_> = it
8090            .next()
8091            .unwrap()
8092            .unwrap()
8093            .reference_positions_full()
8094            .collect();
8095        assert_eq!(
8096            rp,
8097            vec![
8098                Some(16255392),
8099                Some(16255393),
8100                Some(16255394),
8101                Some(16255395),
8102                Some(16255396),
8103                Some(16255397),
8104                Some(16255398),
8105                Some(16255399),
8106                Some(16255400),
8107                Some(16255401),
8108                Some(16255402),
8109                Some(16255403),
8110                Some(16255404),
8111                Some(16255405),
8112                Some(16255406),
8113                Some(16255407),
8114                Some(16255408),
8115                Some(16255409),
8116                Some(16255410),
8117                Some(16255411),
8118                Some(16255412),
8119                Some(16255413),
8120                Some(16255414),
8121                Some(16255415),
8122                Some(16255416),
8123                Some(16255417),
8124                Some(16255418),
8125                Some(16255419),
8126                Some(16255420),
8127                Some(16255421),
8128                Some(16255422),
8129                Some(16255423),
8130                Some(16255424),
8131                Some(16255425),
8132                Some(16255426),
8133                Some(16255427),
8134                Some(16255428),
8135                Some(16255429),
8136                Some(16255430),
8137                Some(16255431),
8138                Some(16255432),
8139                Some(16255433),
8140                Some(16255434),
8141                Some(16255435),
8142                Some(16255436),
8143                Some(16255437),
8144                Some(16255438),
8145                Some(16255439),
8146                Some(16255440),
8147                Some(16255441),
8148                None
8149            ]
8150        );
8151        let rp: Vec<_> = it
8152            .next()
8153            .unwrap()
8154            .unwrap()
8155            .reference_positions_full()
8156            .collect();
8157        assert_eq!(
8158            rp,
8159            vec![
8160                Some(16256084),
8161                Some(16256085),
8162                Some(16256086),
8163                Some(16256087),
8164                Some(16256088),
8165                Some(16256089),
8166                Some(16256090),
8167                Some(16256091),
8168                Some(16256092),
8169                Some(16256093),
8170                Some(16256094),
8171                Some(16256095),
8172                Some(16256096),
8173                Some(16256097),
8174                Some(16256098),
8175                Some(16256099),
8176                Some(16256100),
8177                Some(16256101),
8178                Some(16256102),
8179                Some(16256103),
8180                Some(16256104),
8181                Some(16256105),
8182                Some(16256106),
8183                Some(16256107),
8184                Some(16256108),
8185                Some(16256109),
8186                Some(16256110),
8187                Some(16256111),
8188                Some(16256112),
8189                Some(16256113),
8190                Some(16256114),
8191                Some(16256115),
8192                Some(16256116),
8193                Some(16256117),
8194                Some(16256118),
8195                Some(16256119),
8196                Some(16256120),
8197                Some(16256121),
8198                Some(16256122),
8199                Some(16256123),
8200                Some(16256124),
8201                Some(16256125),
8202                Some(16256126),
8203                Some(16256127),
8204                Some(16256128),
8205                None,
8206                None,
8207                None,
8208                None,
8209                None,
8210                None
8211            ]
8212        );
8213        let rp: Vec<_> = it
8214            .next()
8215            .unwrap()
8216            .unwrap()
8217            .reference_positions_full()
8218            .collect();
8219        assert_eq!(
8220            rp,
8221            vec![
8222                None,
8223                None,
8224                None,
8225                Some(16256224),
8226                Some(16256225),
8227                Some(16256226),
8228                Some(16256227),
8229                Some(16256228),
8230                Some(16256229),
8231                Some(16256230),
8232                Some(16256231),
8233                Some(16256232),
8234                Some(16256233),
8235                Some(16256234),
8236                Some(16256235),
8237                Some(16256236),
8238                Some(16256237),
8239                Some(16256238),
8240                Some(16256239),
8241                Some(16256240),
8242                Some(16256241),
8243                Some(16256242),
8244                Some(16256243),
8245                Some(16256244),
8246                Some(16256245),
8247                Some(16256246),
8248                Some(16256247),
8249                Some(16256248),
8250                Some(16256249),
8251                Some(16256250),
8252                Some(16256251),
8253                Some(16256252),
8254                Some(16256253),
8255                Some(16256254),
8256                Some(16256255),
8257                Some(16256256),
8258                Some(16256257),
8259                Some(16256258),
8260                Some(16256259),
8261                Some(16256260),
8262                Some(16256261),
8263                Some(16256262),
8264                Some(16256263),
8265                Some(16256264),
8266                Some(16256265),
8267                Some(16256266),
8268                Some(16256267),
8269                Some(16256268),
8270                Some(16256269),
8271                Some(16256270),
8272                Some(16256271)
8273            ]
8274        );
8275        let rp: Vec<_> = it
8276            .next()
8277            .unwrap()
8278            .unwrap()
8279            .reference_positions_full()
8280            .collect();
8281        assert_eq!(
8282            rp,
8283            vec![
8284                Some(16325199),
8285                Some(16325200),
8286                Some(16325201),
8287                Some(16325202),
8288                Some(16325203),
8289                Some(16325204),
8290                Some(16325205),
8291                Some(16325206),
8292                Some(16325207),
8293                Some(16325208),
8294                Some(16325209),
8295                Some(16325210),
8296                Some(16325211),
8297                Some(16325212),
8298                Some(16325213),
8299                Some(16325214),
8300                Some(16325215),
8301                Some(16325216),
8302                Some(16325217),
8303                Some(16325218),
8304                Some(16325219),
8305                Some(16325220),
8306                Some(16325221),
8307                Some(16325222),
8308                Some(16325223),
8309                Some(16325224),
8310                Some(16325225),
8311                Some(16325226),
8312                Some(16325227),
8313                Some(16325228),
8314                Some(16325229),
8315                Some(16325230),
8316                Some(16325231),
8317                Some(16325232),
8318                Some(16325233),
8319                Some(16325234),
8320                Some(16325235),
8321                Some(16325236),
8322                Some(16325237),
8323                Some(16325238),
8324                Some(16325239),
8325                Some(16325240),
8326                None,
8327                None,
8328                None,
8329                None,
8330                None,
8331                None,
8332                None,
8333                None,
8334                None
8335            ]
8336        );
8337        let rp: Vec<_> = it
8338            .next()
8339            .unwrap()
8340            .unwrap()
8341            .reference_positions_full()
8342            .collect();
8343        assert_eq!(
8344            rp,
8345            vec![
8346                None,
8347                None,
8348                None,
8349                None,
8350                None,
8351                None,
8352                None,
8353                None,
8354                None,
8355                None,
8356                None,
8357                None,
8358                None,
8359                Some(16352865),
8360                Some(16352866),
8361                Some(16352867),
8362                Some(16352868),
8363                Some(16352869),
8364                Some(16352870),
8365                Some(16352871),
8366                Some(16352872),
8367                Some(16352873),
8368                Some(16352874),
8369                Some(16352875),
8370                Some(16352876),
8371                Some(16352877),
8372                Some(16352878),
8373                Some(16352879),
8374                Some(16352880),
8375                Some(16352881),
8376                Some(16352882),
8377                Some(16352883),
8378                Some(16352884),
8379                Some(16352885),
8380                Some(16352886),
8381                Some(16352887),
8382                Some(16352888),
8383                Some(16352889),
8384                Some(16352890),
8385                Some(16352891),
8386                Some(16352892),
8387                Some(16352893),
8388                Some(16352894),
8389                Some(16352895),
8390                Some(16352896),
8391                Some(16352897),
8392                Some(16352898),
8393                Some(16352899),
8394                Some(16352900),
8395                Some(16352901),
8396                Some(16352902)
8397            ]
8398        );
8399        let rp: Vec<_> = it
8400            .next()
8401            .unwrap()
8402            .unwrap()
8403            .reference_positions_full()
8404            .collect();
8405        assert_eq!(
8406            rp,
8407            vec![
8408                Some(16352968),
8409                Some(16352969),
8410                Some(16352970),
8411                Some(16352971),
8412                Some(16352972),
8413                Some(16352973),
8414                Some(16352974),
8415                Some(16352975),
8416                Some(16352976),
8417                Some(16352977),
8418                Some(16352978),
8419                Some(16352979),
8420                Some(16352980),
8421                Some(16352981),
8422                Some(16352982),
8423                Some(16352983),
8424                Some(16352984),
8425                Some(16352985),
8426                Some(16352986),
8427                Some(16352987),
8428                Some(16352988),
8429                Some(16352989),
8430                Some(16352990),
8431                Some(16352991),
8432                Some(16352992),
8433                Some(16352993),
8434                Some(16352994),
8435                Some(16352995),
8436                Some(16352996),
8437                Some(16352997),
8438                Some(16352998),
8439                Some(16352999),
8440                Some(16353000),
8441                Some(16353001),
8442                Some(16353002),
8443                Some(16353003),
8444                Some(16353004),
8445                Some(16353005),
8446                Some(16353006),
8447                Some(16353007),
8448                Some(16353008),
8449                Some(16353009),
8450                Some(16353010),
8451                Some(16353011),
8452                None,
8453                None,
8454                None,
8455                None,
8456                None,
8457                None,
8458                None
8459            ]
8460        );
8461        let rp: Vec<_> = it
8462            .next()
8463            .unwrap()
8464            .unwrap()
8465            .reference_positions_full()
8466            .collect();
8467        assert_eq!(
8468            rp,
8469            vec![
8470                None,
8471                None,
8472                None,
8473                None,
8474                None,
8475                Some(16414998),
8476                Some(16414999),
8477                Some(16415000),
8478                Some(16415001),
8479                Some(16415002),
8480                Some(16415003),
8481                Some(16415004),
8482                Some(16415005),
8483                Some(16415006),
8484                Some(16415007),
8485                Some(16415008),
8486                Some(16415009),
8487                Some(16415010),
8488                Some(16415011),
8489                Some(16415012),
8490                Some(16415013),
8491                Some(16415014),
8492                Some(16415015),
8493                Some(16415016),
8494                Some(16415017),
8495                Some(16415018),
8496                Some(16415019),
8497                Some(16415020),
8498                Some(16415021),
8499                Some(16415022),
8500                Some(16415023),
8501                Some(16415024),
8502                Some(16415025),
8503                Some(16415026),
8504                Some(16415027),
8505                Some(16415028),
8506                Some(16415029),
8507                Some(16415030),
8508                Some(16415031),
8509                Some(16415032),
8510                Some(16415033),
8511                Some(16415034),
8512                Some(16415035),
8513                Some(16415036),
8514                Some(16415037),
8515                Some(16415038),
8516                Some(16415039),
8517                Some(16415040),
8518                Some(16415041),
8519                Some(16415042),
8520                Some(16415043)
8521            ]
8522        );
8523        let rp: Vec<_> = it
8524            .next()
8525            .unwrap()
8526            .unwrap()
8527            .reference_positions_full()
8528            .collect();
8529        assert_eq!(
8530            rp,
8531            vec![
8532                Some(17031591),
8533                Some(17031592),
8534                Some(17031593),
8535                Some(17031594),
8536                Some(17031595),
8537                Some(17031596),
8538                Some(17031597),
8539                Some(17031598),
8540                Some(17031599),
8541                Some(17031600),
8542                Some(17031601),
8543                Some(17031602),
8544                Some(17031603),
8545                Some(17031604),
8546                Some(17031605),
8547                Some(17031606),
8548                Some(17031607),
8549                Some(17031608),
8550                Some(17031609),
8551                Some(17031610),
8552                Some(17031611),
8553                Some(17031612),
8554                Some(17031613),
8555                None,
8556                None,
8557                None,
8558                None,
8559                Some(17031614),
8560                Some(17031615),
8561                Some(17031616),
8562                Some(17031617),
8563                Some(17031618),
8564                Some(17031619),
8565                Some(17031620),
8566                Some(17031621),
8567                Some(17031622),
8568                Some(17031623),
8569                Some(17031624),
8570                Some(17031625),
8571                Some(17031626),
8572                Some(17031627),
8573                Some(17031628),
8574                Some(17031629),
8575                Some(17031630),
8576                Some(17031631),
8577                Some(17031632),
8578                Some(17031633),
8579                Some(17031634),
8580                Some(17031635),
8581                Some(17031636),
8582                Some(17031637)
8583            ]
8584        );
8585        let rp: Vec<_> = it
8586            .next()
8587            .unwrap()
8588            .unwrap()
8589            .reference_positions_full()
8590            .collect();
8591        assert_eq!(
8592            rp,
8593            vec![
8594                Some(17057382),
8595                Some(17057383),
8596                Some(17057384),
8597                Some(17057385),
8598                Some(17057386),
8599                Some(17057387),
8600                Some(17057388),
8601                Some(17057389),
8602                Some(17057390),
8603                Some(17057391),
8604                Some(17057392),
8605                Some(17057393),
8606                Some(17057394),
8607                Some(17057395),
8608                Some(17057396),
8609                Some(17057397),
8610                Some(17057398),
8611                Some(17057399),
8612                None,
8613                Some(17057400),
8614                Some(17057401),
8615                Some(17057402),
8616                Some(17057403),
8617                Some(17057404),
8618                Some(17057405),
8619                Some(17057406),
8620                Some(17057407),
8621                Some(17057408),
8622                Some(17057409),
8623                Some(17057410),
8624                Some(17057411),
8625                Some(17057412),
8626                Some(17057413),
8627                Some(17057414),
8628                Some(17057415),
8629                Some(17057416),
8630                Some(17057417),
8631                Some(17057418),
8632                Some(17057419),
8633                Some(17057420),
8634                Some(17057421),
8635                Some(17057422),
8636                Some(17057423),
8637                Some(17057424),
8638                Some(17057425),
8639                Some(17057426),
8640                Some(17057427),
8641                Some(17057428),
8642                Some(17057429),
8643                Some(17057430),
8644                Some(17057431)
8645            ]
8646        );
8647        let rp: Vec<_> = it
8648            .next()
8649            .unwrap()
8650            .unwrap()
8651            .reference_positions_full()
8652            .collect();
8653        assert_eq!(
8654            rp,
8655            vec![
8656                Some(17092766),
8657                Some(17092767),
8658                Some(17092768),
8659                Some(17092769),
8660                Some(17092770),
8661                Some(17092771),
8662                Some(17092772),
8663                Some(17092773),
8664                Some(17092774),
8665                Some(17092775),
8666                Some(17092776),
8667                Some(17092777),
8668                Some(17092778),
8669                Some(17092779),
8670                Some(17092780),
8671                Some(17092781),
8672                Some(17092782),
8673                Some(17094966),
8674                Some(17094967),
8675                Some(17094968),
8676                Some(17094969),
8677                Some(17094970),
8678                Some(17094971),
8679                Some(17094972),
8680                Some(17094973),
8681                Some(17094974),
8682                Some(17094975),
8683                Some(17094976),
8684                Some(17094977),
8685                Some(17094978),
8686                Some(17094979),
8687                Some(17094980),
8688                Some(17094981),
8689                Some(17094982),
8690                Some(17094983),
8691                Some(17094984),
8692                Some(17094985),
8693                Some(17094986),
8694                Some(17094987),
8695                Some(17094988),
8696                Some(17094989),
8697                Some(17094990),
8698                Some(17094991),
8699                Some(17094992),
8700                Some(17094993),
8701                Some(17094994),
8702                Some(17094995),
8703                Some(17094996),
8704                Some(17094997),
8705                Some(17094998),
8706                Some(17094999)
8707            ]
8708        );
8709        let rp: Vec<_> = it
8710            .next()
8711            .unwrap()
8712            .unwrap()
8713            .reference_positions_full()
8714            .collect();
8715        assert_eq!(
8716            rp,
8717            vec![
8718                Some(17092782),
8719                Some(17094966),
8720                Some(17094967),
8721                Some(17094968),
8722                Some(17094969),
8723                Some(17094970),
8724                Some(17094971),
8725                Some(17094972),
8726                Some(17094973),
8727                Some(17094974),
8728                Some(17094975),
8729                Some(17094976),
8730                Some(17094977),
8731                Some(17094978),
8732                Some(17094979),
8733                Some(17094980),
8734                Some(17094981),
8735                Some(17094982),
8736                Some(17094983),
8737                Some(17094984),
8738                Some(17094985),
8739                Some(17094986),
8740                Some(17094987),
8741                Some(17094988),
8742                Some(17094989),
8743                Some(17094990),
8744                Some(17094991),
8745                Some(17094992),
8746                Some(17094993),
8747                Some(17094994),
8748                Some(17094995),
8749                Some(17094996),
8750                Some(17094997),
8751                Some(17094998),
8752                Some(17094999),
8753                Some(17095000),
8754                Some(17095001),
8755                Some(17095002),
8756                Some(17095003),
8757                Some(17095004),
8758                Some(17095005),
8759                Some(17095006),
8760                Some(17095007),
8761                Some(17095008),
8762                Some(17095009),
8763                Some(17095010),
8764                Some(17095011),
8765                Some(17095012),
8766                Some(17095013),
8767                Some(17095014),
8768                Some(17095015)
8769            ]
8770        );
8771        let rp: Vec<_> = it
8772            .next()
8773            .unwrap()
8774            .unwrap()
8775            .reference_positions_full()
8776            .collect();
8777        assert_eq!(
8778            rp,
8779            vec![
8780                Some(17092782),
8781                Some(17094966),
8782                Some(17094967),
8783                Some(17094968),
8784                Some(17094969),
8785                Some(17094970),
8786                Some(17094971),
8787                Some(17094972),
8788                Some(17094973),
8789                Some(17094974),
8790                Some(17094975),
8791                Some(17094976),
8792                Some(17094977),
8793                Some(17094978),
8794                Some(17094979),
8795                Some(17094980),
8796                Some(17094981),
8797                Some(17094982),
8798                Some(17094983),
8799                Some(17094984),
8800                Some(17094985),
8801                Some(17094986),
8802                Some(17094987),
8803                Some(17094988),
8804                Some(17094989),
8805                Some(17094990),
8806                Some(17094991),
8807                Some(17094992),
8808                Some(17094993),
8809                Some(17094994),
8810                Some(17094995),
8811                Some(17094996),
8812                Some(17094997),
8813                Some(17094998),
8814                Some(17094999),
8815                Some(17095000),
8816                Some(17095001),
8817                Some(17095002),
8818                Some(17095003),
8819                Some(17095004),
8820                Some(17095005),
8821                Some(17095006),
8822                Some(17095007),
8823                Some(17095008),
8824                Some(17095009),
8825                Some(17095010),
8826                Some(17095011),
8827                Some(17095012),
8828                Some(17095013),
8829                Some(17095014),
8830                Some(17095015)
8831            ]
8832        );
8833        let rp: Vec<_> = it
8834            .next()
8835            .unwrap()
8836            .unwrap()
8837            .reference_positions_full()
8838            .collect();
8839        assert_eq!(
8840            rp,
8841            vec![
8842                None,
8843                None,
8844                None,
8845                None,
8846                None,
8847                None,
8848                None,
8849                None,
8850                None,
8851                Some(17137287),
8852                Some(17137288),
8853                Some(17137289),
8854                Some(17137290),
8855                Some(17137291),
8856                Some(17137292),
8857                Some(17137293),
8858                Some(17137294),
8859                Some(17137295),
8860                Some(17137296),
8861                Some(17137297),
8862                Some(17137298),
8863                Some(17137299),
8864                Some(17137300),
8865                Some(17137301),
8866                Some(17137302),
8867                Some(17137303),
8868                Some(17137304),
8869                Some(17137305),
8870                Some(17137306),
8871                Some(17137307),
8872                Some(17137308),
8873                Some(17137309),
8874                Some(17137310),
8875                Some(17137311),
8876                Some(17137312),
8877                Some(17137313),
8878                Some(17137314),
8879                Some(17137315),
8880                Some(17137316),
8881                Some(17137317),
8882                Some(17137318),
8883                Some(17137319),
8884                None,
8885                None,
8886                None,
8887                None,
8888                None,
8889                None,
8890                None,
8891                None,
8892                None
8893            ]
8894        );
8895        let rp: Vec<_> = it
8896            .next()
8897            .unwrap()
8898            .unwrap()
8899            .reference_positions_full()
8900            .collect();
8901        assert_eq!(
8902            rp,
8903            vec![
8904                None,
8905                None,
8906                Some(17306238),
8907                Some(17306239),
8908                Some(17306240),
8909                Some(17306241),
8910                Some(17306242),
8911                Some(17306243),
8912                Some(17306244),
8913                Some(17306245),
8914                Some(17306246),
8915                Some(17306247),
8916                Some(17306248),
8917                Some(17306249),
8918                Some(17306250),
8919                Some(17306251),
8920                Some(17306252),
8921                Some(17306253),
8922                Some(17306254),
8923                Some(17306255),
8924                Some(17306256),
8925                Some(17306257),
8926                Some(17306258),
8927                Some(17306259),
8928                Some(17306260),
8929                Some(17306261),
8930                Some(17306262),
8931                Some(17306263),
8932                Some(17306264),
8933                Some(17306265),
8934                Some(17306266),
8935                Some(17306267),
8936                Some(17306268),
8937                Some(17306269),
8938                Some(17306270),
8939                Some(17306271),
8940                Some(17306272),
8941                Some(17306273),
8942                Some(17306274),
8943                Some(17306275),
8944                Some(17306276),
8945                Some(17306277),
8946                Some(17306278),
8947                Some(17306279),
8948                Some(17306280),
8949                Some(17306281),
8950                Some(17306282),
8951                Some(17306283),
8952                Some(17306284),
8953                Some(17306285),
8954                None
8955            ]
8956        );
8957        let rp: Vec<_> = it
8958            .next()
8959            .unwrap()
8960            .unwrap()
8961            .reference_positions_full()
8962            .collect();
8963        assert_eq!(
8964            rp,
8965            vec![
8966                None,
8967                None,
8968                None,
8969                None,
8970                Some(17561868),
8971                Some(17561869),
8972                Some(17561870),
8973                Some(17561871),
8974                Some(17561872),
8975                Some(17561873),
8976                Some(17561874),
8977                Some(17561875),
8978                Some(17561876),
8979                Some(17561877),
8980                Some(17561878),
8981                Some(17561879),
8982                Some(17561880),
8983                Some(17561881),
8984                Some(17561882),
8985                Some(17561883),
8986                Some(17561884),
8987                Some(17561885),
8988                Some(17561886),
8989                Some(17561887),
8990                Some(17561888),
8991                Some(17561889),
8992                Some(17561890),
8993                Some(17561891),
8994                Some(17561892),
8995                Some(17561893),
8996                Some(17561894),
8997                Some(17561895),
8998                Some(17561896),
8999                Some(17561897),
9000                Some(17561898),
9001                Some(17561899),
9002                Some(17561900),
9003                Some(17561901),
9004                Some(17561902),
9005                Some(17561903),
9006                Some(17561904),
9007                Some(17561905),
9008                Some(17561906),
9009                Some(17561907),
9010                Some(17561908),
9011                Some(17561909),
9012                Some(17561910),
9013                Some(17561911),
9014                Some(17561912),
9015                None,
9016                None
9017            ]
9018        );
9019        let rp: Vec<_> = it
9020            .next()
9021            .unwrap()
9022            .unwrap()
9023            .reference_positions_full()
9024            .collect();
9025        assert_eq!(
9026            rp,
9027            vec![
9028                Some(17566078),
9029                Some(17566079),
9030                Some(17566080),
9031                Some(17566081),
9032                Some(17566082),
9033                Some(17566083),
9034                Some(17566084),
9035                Some(17566085),
9036                Some(17566086),
9037                Some(17566087),
9038                Some(17566088),
9039                Some(17566089),
9040                Some(17566090),
9041                Some(17566091),
9042                Some(17566092),
9043                Some(17566093),
9044                Some(17566094),
9045                Some(17566095),
9046                Some(17566096),
9047                Some(17566097),
9048                Some(17566098),
9049                Some(17566099),
9050                Some(17566100),
9051                Some(17566101),
9052                Some(17566102),
9053                Some(17566103),
9054                Some(17566104),
9055                Some(17566105),
9056                Some(17566106),
9057                Some(17566107),
9058                Some(17566108),
9059                Some(17566109),
9060                Some(17566110),
9061                Some(17566111),
9062                Some(17566112),
9063                Some(17566113),
9064                Some(17566114),
9065                Some(17566115),
9066                Some(17566116),
9067                Some(17566117),
9068                Some(17566118),
9069                Some(17577951),
9070                Some(17577952),
9071                Some(17577953),
9072                Some(17577954),
9073                Some(17577955),
9074                Some(17577956),
9075                Some(17577957),
9076                Some(17577958),
9077                Some(17577959),
9078                Some(17577960)
9079            ]
9080        );
9081        let rp: Vec<_> = it
9082            .next()
9083            .unwrap()
9084            .unwrap()
9085            .reference_positions_full()
9086            .collect();
9087        assert_eq!(
9088            rp,
9089            vec![
9090                Some(17566108),
9091                Some(17566109),
9092                Some(17566110),
9093                Some(17566111),
9094                Some(17566112),
9095                Some(17566113),
9096                Some(17566114),
9097                Some(17566115),
9098                Some(17566116),
9099                Some(17566117),
9100                Some(17566118),
9101                Some(17577951),
9102                Some(17577952),
9103                Some(17577953),
9104                Some(17577954),
9105                Some(17577955),
9106                Some(17577956),
9107                Some(17577957),
9108                Some(17577958),
9109                Some(17577959),
9110                Some(17577960),
9111                Some(17577961),
9112                Some(17577962),
9113                Some(17577963),
9114                Some(17577964),
9115                Some(17577965),
9116                Some(17577966),
9117                Some(17577967),
9118                Some(17577968),
9119                Some(17577969),
9120                Some(17577970),
9121                Some(17577971),
9122                Some(17577972),
9123                Some(17577973),
9124                Some(17577974),
9125                Some(17577975),
9126                Some(17578686),
9127                Some(17578687),
9128                Some(17578688),
9129                Some(17578689),
9130                Some(17578690),
9131                Some(17578691),
9132                Some(17578692),
9133                Some(17578693),
9134                Some(17578694),
9135                Some(17578695),
9136                Some(17578696),
9137                Some(17578697),
9138                Some(17578698),
9139                Some(17578699),
9140                Some(17578700)
9141            ]
9142        );
9143        let rp: Vec<_> = it
9144            .next()
9145            .unwrap()
9146            .unwrap()
9147            .reference_positions_full()
9148            .collect();
9149        assert_eq!(
9150            rp,
9151            vec![
9152                Some(17566111),
9153                Some(17566112),
9154                Some(17566113),
9155                Some(17566114),
9156                Some(17566115),
9157                Some(17566116),
9158                Some(17566117),
9159                Some(17566118),
9160                Some(17577951),
9161                Some(17577952),
9162                Some(17577953),
9163                Some(17577954),
9164                Some(17577955),
9165                Some(17577956),
9166                Some(17577957),
9167                Some(17577958),
9168                Some(17577959),
9169                Some(17577960),
9170                Some(17577961),
9171                Some(17577962),
9172                Some(17577963),
9173                Some(17577964),
9174                Some(17577965),
9175                Some(17577966),
9176                Some(17577967),
9177                Some(17577968),
9178                Some(17577969),
9179                Some(17577970),
9180                Some(17577971),
9181                Some(17577972),
9182                Some(17577973),
9183                Some(17577974),
9184                Some(17577975),
9185                Some(17578686),
9186                Some(17578687),
9187                Some(17578688),
9188                Some(17578689),
9189                Some(17578690),
9190                Some(17578691),
9191                Some(17578692),
9192                Some(17578693),
9193                Some(17578694),
9194                Some(17578695),
9195                Some(17578696),
9196                Some(17578697),
9197                Some(17578698),
9198                Some(17578699),
9199                Some(17578700),
9200                Some(17578701),
9201                Some(17578702),
9202                Some(17578703)
9203            ]
9204        );
9205        let rp: Vec<_> = it
9206            .next()
9207            .unwrap()
9208            .unwrap()
9209            .reference_positions_full()
9210            .collect();
9211        assert_eq!(
9212            rp,
9213            vec![
9214                Some(17566111),
9215                Some(17566112),
9216                Some(17566113),
9217                Some(17566114),
9218                Some(17566115),
9219                Some(17566116),
9220                Some(17566117),
9221                Some(17566118),
9222                Some(17577951),
9223                Some(17577952),
9224                Some(17577953),
9225                Some(17577954),
9226                Some(17577955),
9227                Some(17577956),
9228                Some(17577957),
9229                Some(17577958),
9230                Some(17577959),
9231                Some(17577960),
9232                Some(17577961),
9233                Some(17577962),
9234                Some(17577963),
9235                Some(17577964),
9236                Some(17577965),
9237                Some(17577966),
9238                Some(17577967),
9239                Some(17577968),
9240                Some(17577969),
9241                Some(17577970),
9242                Some(17577971),
9243                Some(17577972),
9244                Some(17577973),
9245                Some(17577974),
9246                Some(17577975),
9247                Some(17578686),
9248                Some(17578687),
9249                Some(17578688),
9250                Some(17578689),
9251                Some(17578690),
9252                Some(17578691),
9253                Some(17578692),
9254                Some(17578693),
9255                Some(17578694),
9256                Some(17578695),
9257                Some(17578696),
9258                Some(17578697),
9259                Some(17578698),
9260                Some(17578699),
9261                Some(17578700),
9262                Some(17578701),
9263                Some(17578702),
9264                Some(17578703)
9265            ]
9266        );
9267        let rp: Vec<_> = it
9268            .next()
9269            .unwrap()
9270            .unwrap()
9271            .reference_positions_full()
9272            .collect();
9273        assert_eq!(
9274            rp,
9275            vec![
9276                Some(17566111),
9277                Some(17566112),
9278                Some(17566113),
9279                Some(17566114),
9280                Some(17566115),
9281                Some(17566116),
9282                Some(17566117),
9283                Some(17566118),
9284                Some(17577951),
9285                Some(17577952),
9286                Some(17577953),
9287                Some(17577954),
9288                Some(17577955),
9289                Some(17577956),
9290                Some(17577957),
9291                Some(17577958),
9292                Some(17577959),
9293                Some(17577960),
9294                Some(17577961),
9295                Some(17577962),
9296                Some(17577963),
9297                Some(17577964),
9298                Some(17577965),
9299                Some(17577966),
9300                Some(17577967),
9301                Some(17577968),
9302                Some(17577969),
9303                Some(17577970),
9304                Some(17577971),
9305                Some(17577972),
9306                Some(17577973),
9307                Some(17577974),
9308                Some(17577975),
9309                Some(17578686),
9310                Some(17578687),
9311                Some(17578688),
9312                Some(17578689),
9313                Some(17578690),
9314                Some(17578691),
9315                Some(17578692),
9316                Some(17578693),
9317                Some(17578694),
9318                Some(17578695),
9319                Some(17578696),
9320                Some(17578697),
9321                Some(17578698),
9322                Some(17578699),
9323                Some(17578700),
9324                Some(17578701),
9325                Some(17578702),
9326                Some(17578703)
9327            ]
9328        );
9329        let rp: Vec<_> = it
9330            .next()
9331            .unwrap()
9332            .unwrap()
9333            .reference_positions_full()
9334            .collect();
9335        assert_eq!(
9336            rp,
9337            vec![
9338                Some(17566111),
9339                Some(17566112),
9340                Some(17566113),
9341                Some(17566114),
9342                Some(17566115),
9343                Some(17566116),
9344                Some(17566117),
9345                Some(17566118),
9346                Some(17577951),
9347                Some(17577952),
9348                Some(17577953),
9349                Some(17577954),
9350                Some(17577955),
9351                Some(17577956),
9352                Some(17577957),
9353                Some(17577958),
9354                Some(17577959),
9355                Some(17577960),
9356                Some(17577961),
9357                Some(17577962),
9358                Some(17577963),
9359                Some(17577964),
9360                Some(17577965),
9361                Some(17577966),
9362                Some(17577967),
9363                Some(17577968),
9364                Some(17577969),
9365                Some(17577970),
9366                Some(17577971),
9367                Some(17577972),
9368                Some(17577973),
9369                Some(17577974),
9370                Some(17577975),
9371                Some(17578686),
9372                Some(17578687),
9373                Some(17578688),
9374                Some(17578689),
9375                Some(17578690),
9376                Some(17578691),
9377                Some(17578692),
9378                Some(17578693),
9379                Some(17578694),
9380                Some(17578695),
9381                Some(17578696),
9382                Some(17578697),
9383                Some(17578698),
9384                Some(17578699),
9385                Some(17578700),
9386                Some(17578701),
9387                Some(17578702),
9388                Some(17578703)
9389            ]
9390        );
9391        let rp: Vec<_> = it
9392            .next()
9393            .unwrap()
9394            .unwrap()
9395            .reference_positions_full()
9396            .collect();
9397        assert_eq!(
9398            rp,
9399            vec![
9400                Some(17566112),
9401                Some(17566113),
9402                Some(17566114),
9403                Some(17566115),
9404                Some(17566116),
9405                Some(17566117),
9406                Some(17566118),
9407                Some(17577951),
9408                Some(17577952),
9409                Some(17577953),
9410                Some(17577954),
9411                Some(17577955),
9412                Some(17577956),
9413                Some(17577957),
9414                Some(17577958),
9415                Some(17577959),
9416                Some(17577960),
9417                Some(17577961),
9418                Some(17577962),
9419                Some(17577963),
9420                Some(17577964),
9421                Some(17577965),
9422                Some(17577966),
9423                Some(17577967),
9424                Some(17577968),
9425                Some(17577969),
9426                Some(17577970),
9427                Some(17577971),
9428                Some(17577972),
9429                Some(17577973),
9430                Some(17577974),
9431                Some(17577975),
9432                Some(17578686),
9433                Some(17578687),
9434                Some(17578688),
9435                Some(17578689),
9436                Some(17578690),
9437                Some(17578691),
9438                Some(17578692),
9439                Some(17578693),
9440                Some(17578694),
9441                Some(17578695),
9442                Some(17578696),
9443                Some(17578697),
9444                Some(17578698),
9445                Some(17578699),
9446                Some(17578700),
9447                Some(17578701),
9448                Some(17578702),
9449                Some(17578703),
9450                Some(17578704)
9451            ]
9452        );
9453        let rp: Vec<_> = it
9454            .next()
9455            .unwrap()
9456            .unwrap()
9457            .reference_positions_full()
9458            .collect();
9459        assert_eq!(
9460            rp,
9461            vec![
9462                Some(17566113),
9463                Some(17566114),
9464                Some(17566115),
9465                Some(17566116),
9466                Some(17566117),
9467                Some(17566118),
9468                Some(17577951),
9469                Some(17577952),
9470                Some(17577953),
9471                Some(17577954),
9472                Some(17577955),
9473                Some(17577956),
9474                Some(17577957),
9475                Some(17577958),
9476                Some(17577959),
9477                Some(17577960),
9478                Some(17577961),
9479                Some(17577962),
9480                Some(17577963),
9481                Some(17577964),
9482                Some(17577965),
9483                Some(17577966),
9484                Some(17577967),
9485                Some(17577968),
9486                Some(17577969),
9487                Some(17577970),
9488                Some(17577971),
9489                Some(17577972),
9490                Some(17577973),
9491                Some(17577974),
9492                Some(17577975),
9493                Some(17578686),
9494                Some(17578687),
9495                Some(17578688),
9496                Some(17578689),
9497                Some(17578690),
9498                Some(17578691),
9499                Some(17578692),
9500                Some(17578693),
9501                Some(17578694),
9502                Some(17578695),
9503                Some(17578696),
9504                Some(17578697),
9505                Some(17578698),
9506                Some(17578699),
9507                Some(17578700),
9508                Some(17578701),
9509                Some(17578702),
9510                Some(17578703),
9511                Some(17578704),
9512                Some(17578705)
9513            ]
9514        );
9515        let rp: Vec<_> = it
9516            .next()
9517            .unwrap()
9518            .unwrap()
9519            .reference_positions_full()
9520            .collect();
9521        assert_eq!(
9522            rp,
9523            vec![
9524                Some(17566113),
9525                Some(17566114),
9526                Some(17566115),
9527                Some(17566116),
9528                Some(17566117),
9529                Some(17566118),
9530                Some(17577951),
9531                Some(17577952),
9532                Some(17577953),
9533                Some(17577954),
9534                Some(17577955),
9535                Some(17577956),
9536                Some(17577957),
9537                Some(17577958),
9538                Some(17577959),
9539                Some(17577960),
9540                Some(17577961),
9541                Some(17577962),
9542                Some(17577963),
9543                Some(17577964),
9544                Some(17577965),
9545                Some(17577966),
9546                Some(17577967),
9547                Some(17577968),
9548                Some(17577969),
9549                Some(17577970),
9550                Some(17577971),
9551                Some(17577972),
9552                Some(17577973),
9553                Some(17577974),
9554                Some(17577975),
9555                Some(17578686),
9556                Some(17578687),
9557                Some(17578688),
9558                Some(17578689),
9559                Some(17578690),
9560                Some(17578691),
9561                Some(17578692),
9562                Some(17578693),
9563                Some(17578694),
9564                Some(17578695),
9565                Some(17578696),
9566                Some(17578697),
9567                Some(17578698),
9568                Some(17578699),
9569                Some(17578700),
9570                Some(17578701),
9571                Some(17578702),
9572                Some(17578703),
9573                Some(17578704),
9574                Some(17578705)
9575            ]
9576        );
9577        let rp: Vec<_> = it
9578            .next()
9579            .unwrap()
9580            .unwrap()
9581            .reference_positions_full()
9582            .collect();
9583        assert_eq!(
9584            rp,
9585            vec![
9586                None,
9587                Some(17579733),
9588                Some(17579734),
9589                Some(17579735),
9590                Some(17579736),
9591                Some(17579737),
9592                Some(17579738),
9593                Some(17579739),
9594                Some(17579740),
9595                Some(17579741),
9596                Some(17579742),
9597                Some(17579743),
9598                Some(17579744),
9599                Some(17579745),
9600                Some(17579746),
9601                Some(17579747),
9602                Some(17579748),
9603                Some(17579749),
9604                Some(17579750),
9605                Some(17579751),
9606                Some(17579752),
9607                Some(17579753),
9608                Some(17579754),
9609                Some(17579755),
9610                Some(17579756),
9611                Some(17579757),
9612                Some(17579758),
9613                Some(17579759),
9614                Some(17579760),
9615                Some(17579761),
9616                Some(17579762),
9617                Some(17579763),
9618                Some(17579764),
9619                Some(17579765),
9620                Some(17579766),
9621                Some(17579767),
9622                Some(17579768),
9623                Some(17579769),
9624                Some(17579770),
9625                Some(17579771),
9626                Some(17579772),
9627                Some(17579773),
9628                Some(17579774),
9629                Some(17579775),
9630                Some(17579776),
9631                Some(17581244),
9632                Some(17581245),
9633                Some(17581246),
9634                Some(17581247),
9635                Some(17581248),
9636                Some(17581249)
9637            ]
9638        );
9639        let rp: Vec<_> = it
9640            .next()
9641            .unwrap()
9642            .unwrap()
9643            .reference_positions_full()
9644            .collect();
9645        assert_eq!(
9646            rp,
9647            vec![
9648                Some(17581369),
9649                Some(17581370),
9650                Some(17582885),
9651                Some(17582886),
9652                Some(17582887),
9653                Some(17582888),
9654                Some(17582889),
9655                Some(17582890),
9656                Some(17582891),
9657                Some(17582892),
9658                Some(17582893),
9659                Some(17582894),
9660                Some(17582895),
9661                Some(17582896),
9662                Some(17582897),
9663                Some(17582898),
9664                Some(17582899),
9665                Some(17582900),
9666                Some(17582901),
9667                Some(17582902),
9668                Some(17582903),
9669                Some(17582904),
9670                Some(17582905),
9671                Some(17582906),
9672                Some(17582907),
9673                Some(17582908),
9674                Some(17582909),
9675                Some(17582910),
9676                Some(17582911),
9677                Some(17582912),
9678                Some(17582913),
9679                Some(17582914),
9680                Some(17582915),
9681                Some(17582916),
9682                Some(17582917),
9683                Some(17582918),
9684                Some(17582919),
9685                Some(17582920),
9686                Some(17582921),
9687                Some(17582922),
9688                Some(17582923),
9689                Some(17582924),
9690                Some(17582925),
9691                Some(17582926),
9692                Some(17582927),
9693                Some(17582928),
9694                Some(17582929),
9695                Some(17582930),
9696                Some(17582931),
9697                Some(17582932),
9698                Some(17583028)
9699            ]
9700        );
9701        let rp: Vec<_> = it
9702            .next()
9703            .unwrap()
9704            .unwrap()
9705            .reference_positions_full()
9706            .collect();
9707        assert_eq!(
9708            rp,
9709            vec![
9710                Some(17581370),
9711                Some(17582885),
9712                Some(17582886),
9713                Some(17582887),
9714                Some(17582888),
9715                Some(17582889),
9716                Some(17582890),
9717                Some(17582891),
9718                Some(17582892),
9719                Some(17582893),
9720                Some(17582894),
9721                Some(17582895),
9722                Some(17582896),
9723                Some(17582897),
9724                Some(17582898),
9725                Some(17582899),
9726                Some(17582900),
9727                Some(17582901),
9728                Some(17582902),
9729                Some(17582903),
9730                Some(17582904),
9731                Some(17582905),
9732                Some(17582906),
9733                Some(17582907),
9734                Some(17582908),
9735                Some(17582909),
9736                Some(17582910),
9737                Some(17582911),
9738                Some(17582912),
9739                Some(17582913),
9740                Some(17582914),
9741                Some(17582915),
9742                Some(17582916),
9743                Some(17582917),
9744                Some(17582918),
9745                Some(17582919),
9746                Some(17582920),
9747                Some(17582921),
9748                Some(17582922),
9749                Some(17582923),
9750                Some(17582924),
9751                Some(17582925),
9752                Some(17582926),
9753                Some(17582927),
9754                Some(17582928),
9755                Some(17582929),
9756                Some(17582930),
9757                Some(17582931),
9758                Some(17582932),
9759                Some(17583028),
9760                Some(17583029)
9761            ]
9762        );
9763        let rp: Vec<_> = it
9764            .next()
9765            .unwrap()
9766            .unwrap()
9767            .reference_positions_full()
9768            .collect();
9769        assert_eq!(
9770            rp,
9771            vec![
9772                Some(17581370),
9773                Some(17582885),
9774                Some(17582886),
9775                Some(17582887),
9776                Some(17582888),
9777                Some(17582889),
9778                Some(17582890),
9779                Some(17582891),
9780                Some(17582892),
9781                Some(17582893),
9782                Some(17582894),
9783                Some(17582895),
9784                Some(17582896),
9785                Some(17582897),
9786                Some(17582898),
9787                Some(17582899),
9788                Some(17582900),
9789                Some(17582901),
9790                Some(17582902),
9791                Some(17582903),
9792                Some(17582904),
9793                Some(17582905),
9794                Some(17582906),
9795                Some(17582907),
9796                Some(17582908),
9797                Some(17582909),
9798                Some(17582910),
9799                Some(17582911),
9800                Some(17582912),
9801                Some(17582913),
9802                Some(17582914),
9803                Some(17582915),
9804                Some(17582916),
9805                Some(17582917),
9806                Some(17582918),
9807                Some(17582919),
9808                Some(17582920),
9809                Some(17582921),
9810                Some(17582922),
9811                Some(17582923),
9812                Some(17582924),
9813                Some(17582925),
9814                Some(17582926),
9815                Some(17582927),
9816                Some(17582928),
9817                Some(17582929),
9818                Some(17582930),
9819                Some(17582931),
9820                Some(17582932),
9821                Some(17583028),
9822                Some(17583029)
9823            ]
9824        );
9825        let rp: Vec<_> = it
9826            .next()
9827            .unwrap()
9828            .unwrap()
9829            .reference_positions_full()
9830            .collect();
9831        assert_eq!(
9832            rp,
9833            vec![
9834                None,
9835                Some(17582911),
9836                Some(17582912),
9837                Some(17582913),
9838                Some(17582914),
9839                Some(17582915),
9840                Some(17582916),
9841                Some(17582917),
9842                Some(17582918),
9843                Some(17582919),
9844                Some(17582920),
9845                Some(17582921),
9846                Some(17582922),
9847                Some(17582923),
9848                Some(17582924),
9849                Some(17582925),
9850                Some(17582926),
9851                Some(17582927),
9852                Some(17582928),
9853                Some(17582929),
9854                Some(17582930),
9855                Some(17582931),
9856                Some(17582932),
9857                Some(17583028),
9858                Some(17583029),
9859                Some(17583030),
9860                Some(17583031),
9861                Some(17583032),
9862                Some(17583033),
9863                Some(17583034),
9864                Some(17583035),
9865                Some(17583036),
9866                Some(17583037),
9867                Some(17583038),
9868                Some(17583039),
9869                Some(17583040),
9870                Some(17583041),
9871                Some(17583042),
9872                Some(17583043),
9873                Some(17583044),
9874                Some(17583045),
9875                Some(17583046),
9876                Some(17583047),
9877                Some(17583048),
9878                Some(17583049),
9879                Some(17583050),
9880                Some(17583051),
9881                Some(17583052),
9882                Some(17583053),
9883                Some(17583054),
9884                Some(17583055)
9885            ]
9886        );
9887        let rp: Vec<_> = it
9888            .next()
9889            .unwrap()
9890            .unwrap()
9891            .reference_positions_full()
9892            .collect();
9893        assert_eq!(
9894            rp,
9895            vec![
9896                Some(17588621),
9897                Some(17588622),
9898                Some(17588623),
9899                Some(17588624),
9900                Some(17588625),
9901                Some(17588626),
9902                Some(17588627),
9903                Some(17588628),
9904                Some(17588629),
9905                Some(17588630),
9906                Some(17588631),
9907                Some(17588632),
9908                Some(17588633),
9909                Some(17588634),
9910                Some(17588635),
9911                Some(17588636),
9912                Some(17588637),
9913                Some(17588638),
9914                Some(17588639),
9915                Some(17588640),
9916                Some(17588641),
9917                Some(17588642),
9918                Some(17588643),
9919                Some(17588644),
9920                Some(17588645),
9921                Some(17588646),
9922                Some(17588647),
9923                Some(17588648),
9924                Some(17588649),
9925                Some(17588650),
9926                Some(17588651),
9927                Some(17588652),
9928                Some(17588653),
9929                Some(17588654),
9930                Some(17588655),
9931                Some(17588656),
9932                Some(17588657),
9933                Some(17589196),
9934                Some(17589197),
9935                Some(17589198),
9936                Some(17589199),
9937                Some(17589200),
9938                Some(17589201),
9939                Some(17589202),
9940                Some(17589203),
9941                Some(17589204),
9942                Some(17589205),
9943                Some(17589206),
9944                Some(17589207),
9945                Some(17589208),
9946                None
9947            ]
9948        );
9949        let rp: Vec<_> = it
9950            .next()
9951            .unwrap()
9952            .unwrap()
9953            .reference_positions_full()
9954            .collect();
9955        assert_eq!(
9956            rp,
9957            vec![
9958                Some(17588621),
9959                Some(17588622),
9960                Some(17588623),
9961                Some(17588624),
9962                Some(17588625),
9963                Some(17588626),
9964                Some(17588627),
9965                Some(17588628),
9966                Some(17588629),
9967                Some(17588630),
9968                Some(17588631),
9969                Some(17588632),
9970                Some(17588633),
9971                Some(17588634),
9972                Some(17588635),
9973                Some(17588636),
9974                Some(17588637),
9975                Some(17588638),
9976                Some(17588639),
9977                Some(17588640),
9978                Some(17588641),
9979                Some(17588642),
9980                Some(17588643),
9981                Some(17588644),
9982                Some(17588645),
9983                Some(17588646),
9984                Some(17588647),
9985                Some(17588648),
9986                Some(17588649),
9987                Some(17588650),
9988                Some(17588651),
9989                Some(17588652),
9990                Some(17588653),
9991                Some(17588654),
9992                Some(17588655),
9993                Some(17588656),
9994                Some(17588657),
9995                Some(17589196),
9996                Some(17589197),
9997                Some(17589198),
9998                Some(17589199),
9999                Some(17589200),
10000                Some(17589201),
10001                Some(17589202),
10002                Some(17589203),
10003                Some(17589204),
10004                Some(17589205),
10005                Some(17589206),
10006                Some(17589207),
10007                Some(17589208),
10008                None
10009            ]
10010        );
10011        let rp: Vec<_> = it
10012            .next()
10013            .unwrap()
10014            .unwrap()
10015            .reference_positions_full()
10016            .collect();
10017        assert_eq!(
10018            rp,
10019            vec![
10020                Some(17588621),
10021                Some(17588622),
10022                Some(17588623),
10023                Some(17588624),
10024                Some(17588625),
10025                Some(17588626),
10026                Some(17588627),
10027                Some(17588628),
10028                Some(17588629),
10029                Some(17588630),
10030                Some(17588631),
10031                Some(17588632),
10032                Some(17588633),
10033                Some(17588634),
10034                Some(17588635),
10035                Some(17588636),
10036                Some(17588637),
10037                Some(17588638),
10038                Some(17588639),
10039                Some(17588640),
10040                Some(17588641),
10041                Some(17588642),
10042                Some(17588643),
10043                Some(17588644),
10044                Some(17588645),
10045                Some(17588646),
10046                Some(17588647),
10047                Some(17588648),
10048                Some(17588649),
10049                Some(17588650),
10050                Some(17588651),
10051                Some(17588652),
10052                Some(17588653),
10053                Some(17588654),
10054                Some(17588655),
10055                Some(17588656),
10056                Some(17588657),
10057                Some(17589196),
10058                Some(17589197),
10059                Some(17589198),
10060                Some(17589199),
10061                Some(17589200),
10062                Some(17589201),
10063                Some(17589202),
10064                Some(17589203),
10065                Some(17589204),
10066                Some(17589205),
10067                Some(17589206),
10068                Some(17589207),
10069                Some(17589208),
10070                None
10071            ]
10072        );
10073        let rp: Vec<_> = it
10074            .next()
10075            .unwrap()
10076            .unwrap()
10077            .reference_positions_full()
10078            .collect();
10079        assert_eq!(
10080            rp,
10081            vec![
10082                None,
10083                Some(17591770),
10084                Some(17591771),
10085                Some(17591772),
10086                Some(17591773),
10087                Some(17591774),
10088                Some(17591775),
10089                Some(17591776),
10090                Some(17591777),
10091                Some(17591778),
10092                Some(17591779),
10093                Some(17591780),
10094                Some(17591781),
10095                Some(17591782),
10096                Some(17591783),
10097                Some(17591784),
10098                Some(17591785),
10099                Some(17591786),
10100                Some(17591787),
10101                Some(17591788),
10102                Some(17591789),
10103                Some(17591790),
10104                Some(17591791),
10105                Some(17591792),
10106                Some(17591793),
10107                Some(17591794),
10108                Some(17591796),
10109                Some(17591797),
10110                Some(17591798),
10111                Some(17591799),
10112                Some(17591800),
10113                Some(17591801),
10114                Some(17591802),
10115                Some(17591803),
10116                Some(17591804),
10117                Some(17591805),
10118                Some(17591806),
10119                Some(17591807),
10120                Some(17591808),
10121                Some(17591809),
10122                Some(17591810),
10123                Some(17591811),
10124                Some(17591812),
10125                Some(17591813),
10126                Some(17591814),
10127                Some(17591815),
10128                Some(17591816),
10129                Some(17591817),
10130                Some(17591818),
10131                Some(17591819),
10132                Some(17591820)
10133            ]
10134        );
10135        let rp: Vec<_> = it
10136            .next()
10137            .unwrap()
10138            .unwrap()
10139            .reference_positions_full()
10140            .collect();
10141        assert_eq!(
10142            rp,
10143            vec![
10144                Some(17593855),
10145                Some(17593856),
10146                Some(17593857),
10147                Some(17593858),
10148                Some(17593859),
10149                Some(17593860),
10150                Some(17593861),
10151                Some(17593862),
10152                Some(17593863),
10153                Some(17593864),
10154                Some(17593865),
10155                Some(17593866),
10156                Some(17593867),
10157                Some(17593868),
10158                Some(17593869),
10159                Some(17593870),
10160                Some(17593871),
10161                Some(17593872),
10162                Some(17593873),
10163                Some(17593874),
10164                Some(17593875),
10165                Some(17593876),
10166                Some(17593877),
10167                Some(17593878),
10168                Some(17593880),
10169                Some(17593881),
10170                Some(17593882),
10171                Some(17593883),
10172                Some(17593884),
10173                Some(17593885),
10174                Some(17593886),
10175                Some(17593887),
10176                Some(17593888),
10177                Some(17593889),
10178                Some(17593890),
10179                Some(17593891),
10180                Some(17593892),
10181                Some(17593893),
10182                Some(17593894),
10183                Some(17593895),
10184                Some(17593896),
10185                Some(17593897),
10186                Some(17593898),
10187                Some(17593899),
10188                Some(17593900),
10189                Some(17593901),
10190                Some(17593902),
10191                Some(17593903),
10192                None,
10193                None,
10194                None
10195            ]
10196        );
10197        let rp: Vec<_> = it
10198            .next()
10199            .unwrap()
10200            .unwrap()
10201            .reference_positions_full()
10202            .collect();
10203        assert_eq!(
10204            rp,
10205            vec![
10206                Some(17593863),
10207                Some(17593864),
10208                Some(17593865),
10209                Some(17593866),
10210                Some(17593867),
10211                Some(17593868),
10212                Some(17593869),
10213                Some(17593870),
10214                Some(17593871),
10215                Some(17593872),
10216                Some(17593873),
10217                Some(17593874),
10218                Some(17593875),
10219                Some(17593876),
10220                Some(17593877),
10221                Some(17593878),
10222                Some(17593880),
10223                Some(17593881),
10224                Some(17593882),
10225                Some(17593883),
10226                Some(17593884),
10227                Some(17593885),
10228                Some(17593886),
10229                Some(17593887),
10230                Some(17593888),
10231                Some(17593889),
10232                Some(17593890),
10233                Some(17593891),
10234                Some(17593892),
10235                Some(17593893),
10236                Some(17593894),
10237                Some(17593895),
10238                Some(17593896),
10239                Some(17593897),
10240                Some(17593898),
10241                Some(17593899),
10242                Some(17593900),
10243                Some(17593901),
10244                Some(17593902),
10245                Some(17593903),
10246                Some(17593904),
10247                Some(17593905),
10248                Some(17593906),
10249                Some(17593907),
10250                None,
10251                None,
10252                None,
10253                None,
10254                None,
10255                None,
10256                None
10257            ]
10258        );
10259        let rp: Vec<_> = it
10260            .next()
10261            .unwrap()
10262            .unwrap()
10263            .reference_positions_full()
10264            .collect();
10265        assert_eq!(
10266            rp,
10267            vec![
10268                None,
10269                None,
10270                None,
10271                None,
10272                None,
10273                None,
10274                None,
10275                None,
10276                None,
10277                None,
10278                None,
10279                Some(17596476),
10280                Some(17596477),
10281                Some(17596478),
10282                Some(17596479),
10283                Some(17596480),
10284                Some(17596481),
10285                Some(17596482),
10286                None,
10287                Some(17596483),
10288                Some(17596484),
10289                Some(17596485),
10290                Some(17596486),
10291                Some(17596487),
10292                Some(17596488),
10293                Some(17596489),
10294                Some(17596490),
10295                Some(17596491),
10296                Some(17596492),
10297                Some(17596493),
10298                Some(17596494),
10299                Some(17596495),
10300                Some(17596496),
10301                Some(17596497),
10302                Some(17596498),
10303                Some(17596499),
10304                Some(17596500),
10305                Some(17596501),
10306                Some(17596502),
10307                Some(17596503),
10308                Some(17596504),
10309                Some(17596505),
10310                Some(17596506),
10311                Some(17596507),
10312                Some(17596508),
10313                Some(17596509),
10314                Some(17596510),
10315                Some(17596511),
10316                Some(17596512),
10317                Some(17596513),
10318                Some(17596514)
10319            ]
10320        );
10321        let rp: Vec<_> = it
10322            .next()
10323            .unwrap()
10324            .unwrap()
10325            .reference_positions_full()
10326            .collect();
10327        assert_eq!(
10328            rp,
10329            vec![
10330                None,
10331                None,
10332                None,
10333                None,
10334                None,
10335                Some(17624012),
10336                Some(17624013),
10337                Some(17624014),
10338                Some(17624015),
10339                Some(17624016),
10340                Some(17624017),
10341                Some(17624018),
10342                Some(17624019),
10343                Some(17624020),
10344                Some(17625913),
10345                Some(17625914),
10346                Some(17625915),
10347                Some(17625916),
10348                Some(17625917),
10349                Some(17625918),
10350                Some(17625919),
10351                Some(17625920),
10352                Some(17625921),
10353                Some(17625922),
10354                Some(17625923),
10355                Some(17625924),
10356                Some(17625925),
10357                Some(17625926),
10358                Some(17625927),
10359                Some(17625928),
10360                Some(17625929),
10361                Some(17625930),
10362                Some(17625931),
10363                Some(17625932),
10364                Some(17625933),
10365                Some(17625934),
10366                Some(17625935),
10367                Some(17625936),
10368                Some(17625937),
10369                Some(17625938),
10370                Some(17625939),
10371                Some(17625940),
10372                Some(17625941),
10373                Some(17625942),
10374                Some(17625943),
10375                Some(17625944),
10376                Some(17625945),
10377                Some(17625946),
10378                Some(17625947),
10379                Some(17625948),
10380                Some(17625949)
10381            ]
10382        );
10383        let rp: Vec<_> = it
10384            .next()
10385            .unwrap()
10386            .unwrap()
10387            .reference_positions_full()
10388            .collect();
10389        assert_eq!(
10390            rp,
10391            vec![
10392                None,
10393                None,
10394                Some(17624012),
10395                Some(17624013),
10396                Some(17624014),
10397                Some(17624015),
10398                Some(17624016),
10399                Some(17624017),
10400                Some(17624018),
10401                Some(17624019),
10402                Some(17624020),
10403                Some(17625913),
10404                Some(17625914),
10405                Some(17625915),
10406                Some(17625916),
10407                Some(17625917),
10408                Some(17625918),
10409                Some(17625919),
10410                Some(17625920),
10411                Some(17625921),
10412                Some(17625922),
10413                Some(17625923),
10414                Some(17625924),
10415                Some(17625925),
10416                Some(17625926),
10417                Some(17625927),
10418                Some(17625928),
10419                Some(17625929),
10420                Some(17625930),
10421                Some(17625931),
10422                Some(17625932),
10423                Some(17625933),
10424                Some(17625934),
10425                Some(17625935),
10426                Some(17625936),
10427                Some(17625937),
10428                Some(17625938),
10429                Some(17625939),
10430                Some(17625940),
10431                Some(17625941),
10432                Some(17625942),
10433                Some(17625943),
10434                Some(17625944),
10435                Some(17625945),
10436                Some(17625946),
10437                Some(17625947),
10438                Some(17625948),
10439                Some(17625949),
10440                Some(17625950),
10441                Some(17625951),
10442                Some(17625952)
10443            ]
10444        );
10445        let rp: Vec<_> = it
10446            .next()
10447            .unwrap()
10448            .unwrap()
10449            .reference_positions_full()
10450            .collect();
10451        assert_eq!(
10452            rp,
10453            vec![
10454                None,
10455                Some(31796700),
10456                Some(31796701),
10457                Some(31796702),
10458                Some(31796703),
10459                Some(31796704),
10460                Some(31796705),
10461                Some(31796706),
10462                Some(31796710),
10463                Some(31796711),
10464                Some(31796712),
10465                Some(31796713),
10466                Some(31796714),
10467                Some(31796715),
10468                Some(31796716),
10469                Some(31796717),
10470                Some(31796718),
10471                Some(31796719),
10472                Some(31796720),
10473                Some(31796721),
10474                Some(31796722),
10475                Some(31796723),
10476                Some(31796724),
10477                Some(31796725),
10478                Some(31796726),
10479                Some(31796727),
10480                Some(31796728),
10481                Some(31799014),
10482                Some(31799015),
10483                Some(31799016),
10484                Some(31799017),
10485                Some(31799018),
10486                Some(31799019),
10487                Some(31799020),
10488                Some(31799021),
10489                Some(31799022),
10490                Some(31799023),
10491                Some(31799024),
10492                Some(31799025),
10493                Some(31799026),
10494                Some(31799027),
10495                Some(31799028),
10496                Some(31799029),
10497                Some(31799030),
10498                Some(31799031),
10499                Some(31799032),
10500                Some(31799033),
10501                Some(31799034),
10502                Some(31799035),
10503                Some(31799036),
10504                Some(31799037)
10505            ]
10506        );
10507        let rp: Vec<_> = it
10508            .next()
10509            .unwrap()
10510            .unwrap()
10511            .reference_positions_full()
10512            .collect();
10513        assert_eq!(
10514            rp,
10515            vec![
10516                Some(36722692),
10517                Some(36722693),
10518                Some(36722694),
10519                Some(36722695),
10520                Some(36722696),
10521                Some(36722697),
10522                Some(36722698),
10523                Some(36722699),
10524                Some(36722700),
10525                Some(36722701),
10526                Some(36722702),
10527                Some(36722703),
10528                Some(36722704),
10529                Some(36722705),
10530                Some(36723505),
10531                Some(36723506),
10532                Some(36723507),
10533                Some(36723508),
10534                Some(36723509),
10535                Some(36723510),
10536                Some(36723511),
10537                Some(36723512),
10538                Some(36723513),
10539                Some(36723514),
10540                Some(36723515),
10541                Some(36723516),
10542                Some(36723517),
10543                Some(36723518),
10544                Some(36723519),
10545                Some(36723520),
10546                Some(36723521),
10547                Some(36723522),
10548                Some(36723523),
10549                Some(36723524),
10550                Some(36723525),
10551                Some(36723526),
10552                Some(36723527),
10553                Some(36723528),
10554                Some(36723529),
10555                Some(36723530),
10556                Some(36723531),
10557                Some(36723532),
10558                Some(36737414),
10559                Some(36737415),
10560                Some(36737416),
10561                Some(36737417),
10562                Some(36737418),
10563                Some(36737419),
10564                Some(36737420),
10565                None,
10566                None
10567            ]
10568        );
10569        let rp: Vec<_> = it
10570            .next()
10571            .unwrap()
10572            .unwrap()
10573            .reference_positions_full()
10574            .collect();
10575        assert_eq!(
10576            rp,
10577            vec![
10578                None,
10579                None,
10580                None,
10581                None,
10582                Some(44587963),
10583                Some(44587964),
10584                Some(44587965),
10585                Some(44587966),
10586                Some(44587967),
10587                Some(44587968),
10588                Some(44587969),
10589                Some(44587970),
10590                Some(44587971),
10591                Some(44587972),
10592                Some(44587973),
10593                Some(44587974),
10594                Some(44587975),
10595                Some(44587976),
10596                Some(44587977),
10597                Some(44587978),
10598                Some(44587979),
10599                Some(44587980),
10600                Some(44587981),
10601                Some(44587982),
10602                Some(44587983),
10603                Some(44589680),
10604                Some(44589681),
10605                Some(44589682),
10606                Some(44589683),
10607                Some(44589684),
10608                Some(44589685),
10609                Some(44589686),
10610                Some(44589687),
10611                Some(44589688),
10612                Some(44589689),
10613                Some(44589690),
10614                Some(44589691),
10615                Some(44589692),
10616                Some(44589693),
10617                Some(44589694),
10618                Some(44589695),
10619                Some(44589696),
10620                Some(44589697),
10621                Some(44589698),
10622                Some(44589699),
10623                Some(44589700),
10624                Some(44589701),
10625                Some(44589702),
10626                Some(44592034),
10627                Some(44592035),
10628                Some(44592036)
10629            ]
10630        );
10631    }
10632
10633    #[test]
10634    fn test_reference_start_end() {
10635        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
10636        let mut it = bam.records();
10637        let read = it.next().unwrap().unwrap();
10638        assert_eq!(read.reference_start(), 16050676);
10639        assert_eq!(read.reference_end(), 16050721);
10640        let read = it.next().unwrap().unwrap();
10641        assert_eq!(read.reference_start(), 16096878);
10642        assert_eq!(read.reference_end(), 16096931);
10643        let read = it.next().unwrap().unwrap();
10644        assert_eq!(read.reference_start(), 16097145);
10645        assert_eq!(read.reference_end(), 16097198);
10646        let read = it.next().unwrap().unwrap();
10647        assert_eq!(read.reference_start(), 16117350);
10648        assert_eq!(read.reference_end(), 16117401);
10649        let read = it.next().unwrap().unwrap();
10650        assert_eq!(read.reference_start(), 16118483);
10651        assert_eq!(read.reference_end(), 16118534);
10652        let read = it.next().unwrap().unwrap();
10653        assert_eq!(read.reference_start(), 16118499);
10654        assert_eq!(read.reference_end(), 16118550);
10655        let read = it.next().unwrap().unwrap();
10656        assert_eq!(read.reference_start(), 16118499);
10657        assert_eq!(read.reference_end(), 16118550);
10658        let read = it.next().unwrap().unwrap();
10659        assert_eq!(read.reference_start(), 16118499);
10660        assert_eq!(read.reference_end(), 16118550);
10661        let read = it.next().unwrap().unwrap();
10662        assert_eq!(read.reference_start(), 16123411);
10663        assert_eq!(read.reference_end(), 16123462);
10664        let read = it.next().unwrap().unwrap();
10665        assert_eq!(read.reference_start(), 16123417);
10666        assert_eq!(read.reference_end(), 16123462);
10667        let read = it.next().unwrap().unwrap();
10668        assert_eq!(read.reference_start(), 16165860);
10669        assert_eq!(read.reference_end(), 16165901);
10670        let read = it.next().unwrap().unwrap();
10671        assert_eq!(read.reference_start(), 16180871);
10672        assert_eq!(read.reference_end(), 16180922);
10673        let read = it.next().unwrap().unwrap();
10674        assert_eq!(read.reference_start(), 16189705);
10675        assert_eq!(read.reference_end(), 16189756);
10676        let read = it.next().unwrap().unwrap();
10677        assert_eq!(read.reference_start(), 16231271);
10678        assert_eq!(read.reference_end(), 16231322);
10679        let read = it.next().unwrap().unwrap();
10680        assert_eq!(read.reference_start(), 16237657);
10681        assert_eq!(read.reference_end(), 16237708);
10682        let read = it.next().unwrap().unwrap();
10683        assert_eq!(read.reference_start(), 16255012);
10684        assert_eq!(read.reference_end(), 16255054);
10685        let read = it.next().unwrap().unwrap();
10686        assert_eq!(read.reference_start(), 16255391);
10687        assert_eq!(read.reference_end(), 16255442);
10688        let read = it.next().unwrap().unwrap();
10689        assert_eq!(read.reference_start(), 16255392);
10690        assert_eq!(read.reference_end(), 16255442);
10691        let read = it.next().unwrap().unwrap();
10692        assert_eq!(read.reference_start(), 16256084);
10693        assert_eq!(read.reference_end(), 16256129);
10694        let read = it.next().unwrap().unwrap();
10695        assert_eq!(read.reference_start(), 16256224);
10696        assert_eq!(read.reference_end(), 16256272);
10697        let read = it.next().unwrap().unwrap();
10698        assert_eq!(read.reference_start(), 16325199);
10699        assert_eq!(read.reference_end(), 16325241);
10700        let read = it.next().unwrap().unwrap();
10701        assert_eq!(read.reference_start(), 16352865);
10702        assert_eq!(read.reference_end(), 16352903);
10703        let read = it.next().unwrap().unwrap();
10704        assert_eq!(read.reference_start(), 16352968);
10705        assert_eq!(read.reference_end(), 16353012);
10706        let read = it.next().unwrap().unwrap();
10707        assert_eq!(read.reference_start(), 16414998);
10708        assert_eq!(read.reference_end(), 16415044);
10709        let read = it.next().unwrap().unwrap();
10710        assert_eq!(read.reference_start(), 17031591);
10711        assert_eq!(read.reference_end(), 17031638);
10712        let read = it.next().unwrap().unwrap();
10713        assert_eq!(read.reference_start(), 17057382);
10714        assert_eq!(read.reference_end(), 17057432);
10715        let read = it.next().unwrap().unwrap();
10716        assert_eq!(read.reference_start(), 17092766);
10717        assert_eq!(read.reference_end(), 17095000);
10718        let read = it.next().unwrap().unwrap();
10719        assert_eq!(read.reference_start(), 17092782);
10720        assert_eq!(read.reference_end(), 17095016);
10721        let read = it.next().unwrap().unwrap();
10722        assert_eq!(read.reference_start(), 17092782);
10723        assert_eq!(read.reference_end(), 17095016);
10724        let read = it.next().unwrap().unwrap();
10725        assert_eq!(read.reference_start(), 17137287);
10726        assert_eq!(read.reference_end(), 17137320);
10727        let read = it.next().unwrap().unwrap();
10728        assert_eq!(read.reference_start(), 17306238);
10729        assert_eq!(read.reference_end(), 17306286);
10730        let read = it.next().unwrap().unwrap();
10731        assert_eq!(read.reference_start(), 17561868);
10732        assert_eq!(read.reference_end(), 17561913);
10733        let read = it.next().unwrap().unwrap();
10734        assert_eq!(read.reference_start(), 17566078);
10735        assert_eq!(read.reference_end(), 17577961);
10736        let read = it.next().unwrap().unwrap();
10737        assert_eq!(read.reference_start(), 17566108);
10738        assert_eq!(read.reference_end(), 17578701);
10739        let read = it.next().unwrap().unwrap();
10740        assert_eq!(read.reference_start(), 17566111);
10741        assert_eq!(read.reference_end(), 17578704);
10742        let read = it.next().unwrap().unwrap();
10743        assert_eq!(read.reference_start(), 17566111);
10744        assert_eq!(read.reference_end(), 17578704);
10745        let read = it.next().unwrap().unwrap();
10746        assert_eq!(read.reference_start(), 17566111);
10747        assert_eq!(read.reference_end(), 17578704);
10748        let read = it.next().unwrap().unwrap();
10749        assert_eq!(read.reference_start(), 17566111);
10750        assert_eq!(read.reference_end(), 17578704);
10751        let read = it.next().unwrap().unwrap();
10752        assert_eq!(read.reference_start(), 17566112);
10753        assert_eq!(read.reference_end(), 17578705);
10754        let read = it.next().unwrap().unwrap();
10755        assert_eq!(read.reference_start(), 17566113);
10756        assert_eq!(read.reference_end(), 17578706);
10757        let read = it.next().unwrap().unwrap();
10758        assert_eq!(read.reference_start(), 17566113);
10759        assert_eq!(read.reference_end(), 17578706);
10760        let read = it.next().unwrap().unwrap();
10761        assert_eq!(read.reference_start(), 17579733);
10762        assert_eq!(read.reference_end(), 17581250);
10763        let read = it.next().unwrap().unwrap();
10764        assert_eq!(read.reference_start(), 17581369);
10765        assert_eq!(read.reference_end(), 17583029);
10766        let read = it.next().unwrap().unwrap();
10767        assert_eq!(read.reference_start(), 17581370);
10768        assert_eq!(read.reference_end(), 17583030);
10769        let read = it.next().unwrap().unwrap();
10770        assert_eq!(read.reference_start(), 17581370);
10771        assert_eq!(read.reference_end(), 17583030);
10772        let read = it.next().unwrap().unwrap();
10773        assert_eq!(read.reference_start(), 17582911);
10774        assert_eq!(read.reference_end(), 17583056);
10775        let read = it.next().unwrap().unwrap();
10776        assert_eq!(read.reference_start(), 17588621);
10777        assert_eq!(read.reference_end(), 17589209);
10778        let read = it.next().unwrap().unwrap();
10779        assert_eq!(read.reference_start(), 17588621);
10780        assert_eq!(read.reference_end(), 17589209);
10781        let read = it.next().unwrap().unwrap();
10782        assert_eq!(read.reference_start(), 17588621);
10783        assert_eq!(read.reference_end(), 17589209);
10784        let read = it.next().unwrap().unwrap();
10785        assert_eq!(read.reference_start(), 17591770);
10786        assert_eq!(read.reference_end(), 17591821);
10787        let read = it.next().unwrap().unwrap();
10788        assert_eq!(read.reference_start(), 17593855);
10789        assert_eq!(read.reference_end(), 17593904);
10790        let read = it.next().unwrap().unwrap();
10791        assert_eq!(read.reference_start(), 17593863);
10792        assert_eq!(read.reference_end(), 17593908);
10793        let read = it.next().unwrap().unwrap();
10794        assert_eq!(read.reference_start(), 17596476);
10795        assert_eq!(read.reference_end(), 17596515);
10796        let read = it.next().unwrap().unwrap();
10797        assert_eq!(read.reference_start(), 17624012);
10798        assert_eq!(read.reference_end(), 17625950);
10799        let read = it.next().unwrap().unwrap();
10800        assert_eq!(read.reference_start(), 17624012);
10801        assert_eq!(read.reference_end(), 17625953);
10802        let read = it.next().unwrap().unwrap();
10803        assert_eq!(read.reference_start(), 31796700);
10804        assert_eq!(read.reference_end(), 31799038);
10805        let read = it.next().unwrap().unwrap();
10806        assert_eq!(read.reference_start(), 36722692);
10807        assert_eq!(read.reference_end(), 36737421);
10808        let read = it.next().unwrap().unwrap();
10809        assert_eq!(read.reference_start(), 44587963);
10810        assert_eq!(read.reference_end(), 44592037);
10811    }
10812
10813    #[test]
10814    fn test_infer_seq_len() {
10815        use std::convert::TryFrom;
10816        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
10817        for read in bam.records() {
10818            let read = read.unwrap();
10819            assert_eq!(read.seq_len_from_cigar(false), 51);
10820            assert_eq!(read.seq_len_from_cigar(true), 51);
10821        }
10822
10823        let mut read = bam::Record::new();
10824        for (input_cigar, supposed_length_wo_hard_clip, supposed_length_with_hard_clip) in &[
10825            ("40M", 40, 40),
10826            ("40=", 40, 40),
10827            ("40X", 40, 40),
10828            ("20M5I20M", 45, 45),
10829            ("20M5D20M", 40, 40),
10830            ("5H35M", 35, 40),
10831            ("5S35M", 40, 40),
10832            ("35M5H", 35, 40),
10833            ("35M5S", 40, 40),
10834            ("", 0, 0),
10835        ] {
10836            read.set(
10837                b"test",
10838                Some(&CigarString::try_from(*input_cigar).unwrap()),
10839                b"agtc",
10840                b"BBBB",
10841            );
10842            assert_eq!(
10843                &read.seq_len_from_cigar(false),
10844                supposed_length_wo_hard_clip
10845            );
10846            assert_eq!(
10847                &read.seq_len_from_cigar(true),
10848                supposed_length_with_hard_clip
10849            );
10850        }
10851    }
10852}
extended_htslib/bam/ext.rs

extended_htslib/bam/
ext.rs
