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::{Aux, CsString};
12use crate::bam::record::{
13    Cigar, CigarString,
14    CsValue::{self, *},
15};
16use crate::htslib;
17use std::collections::{BTreeMap, HashMap};
18
19use std::convert::TryInto;
20use std::ops::{Range, RangeBounds, RangeInclusive};
21use std::str::FromStr;
22#[derive(Debug, Clone, Copy)]
23pub struct MovingPos {
24    fakepos: i64,
25    isvalid: bool,
26}
27impl MovingPos {
28    fn new(pos: i64, isvalid: bool) -> Self {
29        MovingPos {
30            fakepos: pos,
31            isvalid,
32        }
33    }
34}
35#[derive(Debug, Clone)]
36pub struct CsData {
37    ///Get the genome align position
38    pub genome_pos: MovingPos,
39    //Get the read align position
40    pub read_pos: MovingPos,
41    //Get CS value
42    pub state: CsValue,
43    //Get sequence if existing else None
44    pub sequence: SeqPos,
45}
46impl CsData {
47    //Get genome pos or none if not existing
48    pub fn getgenomepos(&self) -> Option<i64> {
49        match self.genome_pos.isvalid {
50            true => Some(self.genome_pos.fakepos),
51            false => None,
52        }
53    }
54    //Get genome pos or the genomic position nefore
55    pub fn getgenomepos_zero(&self) -> i64 {
56        self.genome_pos.fakepos
57    }
58    //Get read pos or none if not existing
59    pub fn getreadpos(&self) -> Option<i64> {
60        match self.read_pos.isvalid {
61            true => Some(self.read_pos.fakepos),
62            false => None,
63        }
64    }
65    //Get read pos or or the read position nefore
66    pub fn getreadpos_zero(&self) -> i64 {
67        self.read_pos.fakepos
68    }
69    fn new(
70        genome_pos: (i64, bool),
71        read_pos: (i64, bool),
72        state: CsValue,
73        sequence: SeqPos,
74    ) -> Self {
75        CsData {
76            genome_pos: MovingPos::new(genome_pos.0, genome_pos.1),
77            read_pos: MovingPos::new(read_pos.0, read_pos.1),
78            state,
79            sequence,
80        }
81    }
82}
83#[derive(Debug, Clone)]
84pub struct SeqPos {
85    ///Get genomic sequence, None if not available
86    genome_seq: Option<String>,
87    ///Get read sequence, None if not available
88    read_seq: Option<String>,
89}
90impl SeqPos {
91    //Check genome seq is equal to given seq (None == None)
92    pub fn genomematch<T>(&self, genome_match: Option<T>) -> bool
93    where
94        T: AsRef<str>,
95    {
96        match (&self.genome_seq, genome_match) {
97            (Some(d), Some(q)) if d.to_lowercase() == q.as_ref().to_lowercase() => true,
98            (None, None) => true,
99            _ => false,
100        }
101    }
102    //Check read seq is equal to given seq (None == None)
103    pub fn readmatch<T>(&self, read_match: Option<T>) -> bool
104    where
105        T: AsRef<str>,
106    {
107        match (&self.read_seq, read_match) {
108            (Some(d), Some(q)) if d.to_lowercase() == q.as_ref().to_lowercase() => true,
109            (None, None) => true,
110            _ => false,
111        }
112    }
113}
114/// Block of aligned pairs
115pub struct CgAlignedBlockPairs {
116    /// Contig name, use getcontig()
117    pub contig: Vec<u8>,
118    /// Starting position in the genome, 0-based
119    pub genome_pos: i64,
120    /// Length of the alignment
121    pub genomelen: usize,
122    cs_index: usize,
123    csdata: Vec<CsData>,
124    /// Cs String
125    pub cs: CsString,
126}
127impl CgAlignedBlockPairs {
128    ///Get contig name
129    pub fn getcontig(&self) -> &[u8] {
130        &self.contig
131    }
132    /// Is a long cs
133    pub fn islongcs(&self) -> bool {
134        self.cs.islongcs()
135    }
136    /// Get CS tag
137    pub fn getcs(&self) -> &CsString {
138        &self.cs
139    }
140    ///Restrict Cgblocks to a specific region
141    pub fn restrict<T>(&mut self, contig: &[u8], range: T)
142    where
143        T: RangeBounds<usize>,
144    {
145        let genomepos = match self.genome_pos.try_into() {
146            Ok(a) => a,
147            Err(_a) => {
148                return;
149            }
150        };
151        if self.contig != contig || !range.contains(&genomepos) {
152            self.csdata.clear();
153            return;
154        }
155        let new = self
156            .filter(|p| {
157                if let Ok(a) = p.getgenomepos_zero().try_into() {
158                    range.contains(&a)
159                } else {
160                    false
161                }
162            })
163            .collect();
164        self.csdata = new;
165    }
166}
167impl Iterator for CgAlignedBlockPairs {
168    type Item = CsData;
169
170    fn next(&mut self) -> Option<Self::Item> {
171        match self.csdata.get(self.cs_index) {
172            Some(value) => {
173                self.cs_index += 1;
174                Some(value.clone())
175            }
176            None => None,
177        }
178    }
179}
180impl Into<CsString> for CgAlignedBlockPairs {
181    fn into(self) -> CsString {
182        self.cs
183    }
184}
185impl CgAlignedBlockPairs {
186    fn increasecounting(mut genome_pos: i64, mut query_pos: i64, state: &CsValue) -> (i64, i64) {
187        match state {
188            CsValue::Same(_) | CsValue::Intron(_) => {
189                genome_pos += state.getlength() as i64;
190                query_pos += state.getlength() as i64;
191                (genome_pos, query_pos)
192            }
193            CsValue::Deletion(_) => {
194                genome_pos += state.getlength() as i64;
195                (genome_pos, query_pos)
196            }
197            CsValue::Insertion(_) => {
198                query_pos += state.getlength() as i64;
199                (genome_pos, query_pos)
200            }
201            CsValue::Substitution(_) => {
202                genome_pos += 1;
203                query_pos += 1;
204                (genome_pos, query_pos)
205            }
206        }
207    }
208    /// Transform a CSstring into a CgAlignedBlockPairs
209    fn createfromcs<T, F>(
210        csstring: F,
211        seq: Option<T>,
212        contig: Vec<u8>,
213        old_genome_pos: i64,
214    ) -> Result<Self, crate::bam::Error>
215    where
216        T: Into<String>,
217        F: Into<CsString>,
218    {
219        let (mut genome_pos, mut query_pos): (i64, i64) = (old_genome_pos, 0);
220        let csstring = csstring.into();
221        let seq = seq.map(|p| p.into()).and_then(|f| {
222            if f.trim().is_empty() {
223                None
224            } else {
225                Some(f.trim().to_string())
226            }
227        });
228        let mut list = Vec::new();
229        for block in csstring.into_iter() {
230            let (seq, state) = match (seq.as_ref(), block) {
231                //Cs tag does not provide sequence (short form) but we have a cigar tag that can help us
232                (Some(s), a) if a.issame() => {
233                    let val: String = s
234                        .char_indices()
235                        .skip(query_pos.try_into().unwrap_or_default())
236                        .take(a.getlength())
237                        .into_iter()
238                        .map(|(_a, b)| b)
239                        .collect();
240                    if val.trim().is_empty() {
241                        return Err(crate::errors::Error::BamParseCS {
242                            rec: format!("Invalid format for CS tag at value {}", a),
243                        });
244                    }
245                    (Some(val), a)
246                }
247                (None, a) if a.issame() => {
248                    return Err(crate::errors::Error::BamParseCS {
249                        rec: format!("No seq provided to match for CS tag at value {}", a),
250                    });
251                }
252                (_, s) if s.isintron() => (None, s),
253                //Cs tag provides the sequence
254                (_, s) if let Some(a) = s.getseq() => (Some(a), s),
255                (_, b) => {
256                    return Err(crate::errors::Error::BamParseCS {
257                        rec: format!("Invalid format for CS tag at value {}", b),
258                    });
259                }
260            };
261            let (seq1, seq2) = match state {
262                CsValue::Substitution((a, b)) => (Some(a.to_string()), Some(b.to_string())),
263                CsValue::Same(_) => match seq {
264                    None => (None, None),
265                    Some(d) => (Some(d.clone()), Some(d.clone())),
266                },
267                CsValue::Deletion(_) => {
268                    let seq = seq
269                        .as_ref()
270                        .ok_or_else(|| crate::errors::Error::BamParseCS {
271                            rec: "Invalid string CS".to_string(),
272                        })?;
273                    (None, Some(seq.clone()))
274                }
275                CsValue::Insertion(_) | CsValue::Intron(_) => {
276                    let seq = seq
277                        .as_ref()
278                        .ok_or_else(|| crate::errors::Error::BamParseCS {
279                            rec: "Invalid string CS".to_string(),
280                        })?;
281                    (Some(seq.clone()), None)
282                }
283            };
284            let seq = SeqPos {
285                genome_seq: seq1,
286                read_seq: seq2,
287            };
288            let genome_bool = !matches!(state, CsValue::Insertion(_));
289            let read_bool = !matches!(state, CsValue::Deletion(_));
290            let elem = CsData::new(
291                (genome_pos, genome_bool),
292                (query_pos, read_bool),
293                state.clone(),
294                seq,
295            );
296            (genome_pos, query_pos) = Self::increasecounting(genome_pos, query_pos, &state);
297            list.push(elem);
298        }
299        Ok(CgAlignedBlockPairs {
300            contig,
301            genome_pos: old_genome_pos,
302            genomelen: std::convert::TryInto::<usize>::try_into(genome_pos - old_genome_pos + 1)
303                .unwrap(),
304            cs_index: 0,
305            csdata: list,
306            cs: csstring,
307        })
308    }
309    /// Parses an MD tag (from SAM format) and a CIGAR string to generate a consensus sequence (CS).
310    ///
311    /// # Arguments
312    /// * `md` - The MD tag string (e.g., "147^C4418^C731^G").
313    /// * `seq` - The read sequence (e.g., "ACGTACGT...").
314    /// * `cigar` - The CIGAR string as a slice of `Cigar` operations.
315    /// * `line` - A identifier for the current line (used for error reporting).
316    /// * `long_cs` - If true, generates a detailed consensus sequence with explicit matches/mismatches.
317    /// * `contig` - The contig (chromosome) name.
318    /// * `genome_pos` - The starting genome position of the alignment.
319    ///
320    /// # Returns
321    /// A `Result` containing the parsed consensus sequence or an error if parsing fails.
322    ///
323    /// # Errors
324    /// Returns `bam::Error::BamParseMD` if:
325    /// - The MD tag, sequence, or CIGAR string is empty.
326    /// - The MD tag starts or ends with a deletion (`^`).
327    /// - The MD tag or CIGAR string is malformed.
328    /// - The MD tag and CIGAR string are inconsistent (e.g., lengths do not match).
329    ///
330    /// # SAM Format Notes
331    /// - The MD tag describes mismatches and deletions in the reference.
332    ///   - Matches: `\d+` (e.g., "10" for 10 matches).
333    ///   - Mismatches: `[A-Za-z]` (e.g., "A" for a mismatch with base `A`).
334    ///   - Deletions: `\^[A-Za-z]+` (e.g., "^ATG" for a deletion of "ATG" in the reference).
335    /// - The CIGAR string describes the alignment:
336    ///   - `M`/`=`/`X`: Match/mismatch (consumes both read and reference).
337    ///   - `I`: Insertion (consumes read only).
338    ///   - `D`: Deletion (consumes reference only).
339    ///   - `N`: Reference skip (consumes reference only).
340    ///   - `S`/`H`: Soft/hard clip (ignored for MD tag parsing).
341    fn createfrommdtag<T>(
342        md: T,
343        seq: T,
344        cigar: &[Cigar],
345        line: T,
346        long_cs: bool,
347        contig: Vec<u8>,
348        genome_pos: i64,
349    ) -> Result<Self, bam::Error>
350    where
351        T: AsRef<str>,
352    {
353        // Trim and validate inputs
354        let md = md.as_ref().trim();
355        let seq = seq.as_ref().trim();
356        let line = line.as_ref().trim();
357
358        if md.is_empty() || seq.is_empty() || cigar.is_empty() {
359            return Err(bam::Error::BamParseMD {
360                rec: format!("at line {}: MD, SEQ, or CIGAR tag is empty", line),
361            });
362        }
363
364        if md.starts_with('^') || md.ends_with('^') {
365            return Err(bam::Error::BamParseMD {
366                rec: format!("at line {}: MD tag cannot start or end with '^'", line),
367            });
368        }
369
370        // Regex to parse the MD tag:
371        // - Group 1: Matches (digits, e.g., "10").
372        // - Group 2: Deletion marker (`^`).
373        // - Group 3: Deletion bases (e.g., "ATG" in "^ATG").
374        // - Group 4: Mismatch base(s) (e.g., "A" or "A0T").
375        let re_md = regex::RegexBuilder::new(r"(\d+)|(\^)([a-z]+)|((?:[a-z]0?)+)")
376            .case_insensitive(true)
377            .build()
378            .map_err(|e| bam::Error::BamParseMD {
379                rec: format!("at line {}: Invalid MD tag regex: {}", line, e),
380            })?;
381
382        // Initialize positions:
383        // - `cx`: Current reference position (from CIGAR).
384        // - `cy`: Current read position (from CIGAR).
385        // - `mx`: Current reference position (from MD tag).
386        // - `my`: Current read position (from MD tag).
387        let mut cx = 0;
388        let mut cy = 0;
389        let mut mx = 0;
390        let mut my: usize = 0;
391        let mut k = 0; // CIGAR index
392        let mut rem_cl: usize = 0; // Cigar last bases (M/=/X)
393        let mut cs = String::new(); // Consensus sequence
394
395        for cap in re_md.captures_iter(md) {
396            // --- Handle deletions in the MD tag (e.g., "^ATG") ---
397            if let Some(deletion) = cap.get(3) {
398                let deletion_len = deletion.as_str().len();
399                // Deletions in the MD tag represent bases in the reference that are not in the read.
400                // They only advance the reference position (`mx`).
401                cs.push('-');
402                cs.push_str(deletion.as_str());
403                mx += deletion_len;
404                cx += deletion_len;
405                if cigar.get(k) == Some(&Cigar::Del(deletion_len.try_into().unwrap_or_default())) {
406                    k += 1;
407                }
408                rem_cl = 0;
409                continue;
410            }
411
412            // --- Handle matches (digits) or mismatches (multiples base) ---
413            let mut ml = if let Some(match_len) = cap.get(1) {
414                // Parse match length (e.g., "10" -> 10)
415                match_len
416                    .as_str()
417                    .parse::<usize>()
418                    .map_err(|e| bam::Error::BamParseMD {
419                        rec: format!("at line {}: Invalid match length in MD tag: {}", line, e),
420                    })?
421            } else if let Some(b) = cap.get(4) {
422                // Mismatch: remove 0 match and count bases
423                b.as_str().replace("0", "").len()
424            } else {
425                return Err(bam::Error::BamParseMD {
426                    rec: format!("at line {}: Invalid MD tag component: {}", line, md),
427                });
428            };
429
430            if ml == 0 {
431                continue; // Skip zero-length matches
432            }
433
434            // --- Process CIGAR operations to align with the MD tag ---
435            while let Some(elem) = cigar.get(k) {
436                match elem {
437                    // --- Deletions in CIGAR (D) ---
438                    // Deletions in CIGAR represent bases in the reference that are not in the read.
439                    // They only advance the reference position (`cx`).
440                    Cigar::Del(cl) => {
441                        let cl: usize = (*cl).try_into().map_err(|_| bam::Error::BamParseMD {
442                            rec: format!("at line {}: Invalid CIGAR deletion length", line),
443                        })?;
444                        cx += cl;
445                        k += 1;
446                        rem_cl = 0;
447                    }
448
449                    // --- Matches, mismatches, or equal operations (M/=/X) ---
450                    // These consume both the read and reference.
451                    Cigar::Equal(cl) | Cigar::Diff(cl) | Cigar::Match(cl) => {
452                        let cl: usize = (*cl).try_into().map_err(|_| bam::Error::BamParseMD {
453                            rec: format!("at line {}: Invalid CIGAR match length", line),
454                        })?;
455                        if rem_cl == 0 {
456                            rem_cl = cl;
457                        }
458                        let take = ml.min(rem_cl);
459
460                        if let Some(mismatch_base) = cap.get(4) {
461                            // (inchangé pour le cas courant à 1 base — voir note plus bas
462                            //  si un mismatch multi-bases peut chevaucher une insertion)
463                            let mut raw = String::new();
464                            for (index, charm) in
465                                mismatch_base.as_str().replace("0", "").chars().enumerate()
466                            {
467                                raw.push('*');
468                                raw.push_str(&charm.to_string());
469                                let string: Vec<char> =
470                                    seq.chars().skip(my.saturating_add(index)).take(1).collect();
471                                let string: String = string.into_iter().collect();
472                                if string.trim().is_empty() {
473                                    return Err(bam::Error::BamParseMD {
474                                        rec: format!(
475                                            "at line {}: Read sequence too short for MD tag",
476                                            line
477                                        ),
478                                    });
479                                }
480                                raw.push_str(&string);
481                            }
482                            cs.push_str(&raw);
483                        } else if long_cs {
484                            cs.push('=');
485                            let string: Vec<char> = seq.chars().skip(my).take(take).collect();
486                            let string: String = string.into_iter().collect();
487                            if string.trim().is_empty() {
488                                return Err(bam::Error::BamParseMD {
489                                    rec: format!(
490                                        "at line {}: Read sequence too short for MD tag",
491                                        line
492                                    ),
493                                });
494                            }
495                            cs.push_str(&string);
496                        } else {
497                            cs.push(':');
498                            cs.push_str(&take.to_string()); // était `cl.to_string()`
499                        }
500
501                        mx += take;
502                        my += take;
503                        cx += take;
504                        cy += take;
505                        ml -= take;
506                        rem_cl -= take;
507
508                        if rem_cl == 0 {
509                            k += 1; // opération CIGAR épuisée seulement maintenant
510                        }
511                        if ml == 0 {
512                            break;
513                        }
514                    }
515
516                    // --- Insertions in CIGAR (I) ---
517                    // Insertions consume the read but not the reference.
518                    Cigar::Ins(cl) => {
519                        let cl: usize = (*cl).try_into().map_err(|_| bam::Error::BamParseMD {
520                            rec: format!("at line {}: Invalid CIGAR insertion length", line),
521                        })?;
522                        cs.push('+');
523                        let string: Vec<char> = seq.chars().skip(cy).take(cl).collect();
524                        let string: String = string.into_iter().collect();
525                        if string.trim().is_empty() {
526                            return Err(bam::Error::BamParseMD {
527                                rec: format!(
528                                    "at line {}: Read sequence too short for MD tag insertion. Cy is {} and CL is {}",
529                                    line, cy, cl
530                                ),
531                            });
532                        }
533                        cs.push_str(&string);
534                        cy += cl;
535                        my += cl;
536                        k += 1;
537                        rem_cl = 0;
538                    }
539
540                    // --- Soft clips (S) ---
541                    // Soft clips consume the read but not the reference.
542                    Cigar::SoftClip(cl) => {
543                        let cl: usize = (*cl).try_into().map_err(|_| bam::Error::BamParseMD {
544                            rec: format!("at line {}: Invalid CIGAR soft clip length", line),
545                        })?;
546                        cy += cl;
547                        my += cl;
548                        k += 1;
549                        rem_cl = 0;
550                    }
551
552                    // --- Reference skips (N) ---
553                    // Reference skips consume the reference but not the read.
554                    Cigar::RefSkip(cl) => {
555                        let cl: usize = (*cl).try_into().map_err(|_| bam::Error::BamParseMD {
556                            rec: format!("at line {}: Invalid CIGAR reference skip length", line),
557                        })?;
558                        cx += cl;
559                        mx += cl;
560                        k += 1;
561                        rem_cl = 0;
562                    }
563
564                    // --- Hard clips (H) and padding (P) ---
565                    // These are ignored for MD tag parsing.
566                    Cigar::HardClip(_) | Cigar::Pad(_) => {
567                        k += 1;
568                        rem_cl = 0;
569                    }
570                }
571            }
572
573            // If there's remaining `ml`, the CIGAR string is incomplete
574            if ml != 0 {
575                return Err(bam::Error::BamParseMD {
576                    rec: format!(
577                        "at line {}: Inconsistent MD tag (ml={} remaining, cx={}, mx={}, cy={}, my={}, cigarpos={}, elem={:?}, md={:?})",
578                        line,
579                        ml,
580                        cx,
581                        mx,
582                        cy,
583                        my,
584                        k,
585                        cigar.get(k.saturating_sub(1)),
586                        cap
587                    ),
588                });
589            }
590        }
591
592        // Final check: All positions must align
593        if cx != mx || cy != my {
594            return Err(bam::Error::BamParseMD {
595                rec: format!(
596                    "at line {}: Inconsistent alignment (cx={}, mx={}, cy={}, my={})",
597                    line, cx, mx, cy, my
598                ),
599            });
600        }
601
602        // Success: Create the consensus sequence
603        Ok(Self::createfromcs(
604            CsString::from_str(&cs)?,
605            Some(seq.to_string()),
606            contig,
607            genome_pos,
608        )?)
609    }
610}
611pub trait MatchIter {
612    ///Only print matched bases?
613    fn ismatchonly(&self) -> bool;
614    ///Set match state
615    fn setmatchstate(&mut self, matchs: bool);
616}
617pub struct IterAlignedBlockCigarMatchPairs {
618    genome_pos: i64,
619    read_pos: i64,
620    cigar_index: usize,
621    cigar: Vec<Cigar>,
622}
623impl Iterator for IterAlignedBlockCigarMatchPairs {
624    type Item = (Option<(Range<i64>, Range<i64>)>, Cigar);
625    fn next(&mut self) -> Option<Self::Item> {
626        while self.cigar_index < self.cigar.len() {
627            let entry = self.cigar[self.cigar_index];
628            self.cigar_index += 1;
629            match entry {
630                Cigar::Match(len) | Cigar::Equal(len) | Cigar::Diff(len) => {
631                    let qstart = self.read_pos;
632                    let qend = qstart + len as i64;
633                    let rstart = self.genome_pos;
634                    let rend = self.genome_pos + len as i64;
635                    self.read_pos += len as i64;
636                    self.genome_pos += len as i64;
637                    if matches!(entry, Cigar::Equal(_)) {
638                        return Some((Some((qstart..qend, rstart..rend)), entry));
639                    }
640                }
641                Cigar::Ins(len) | Cigar::SoftClip(len) => {
642                    self.read_pos += len as i64;
643                }
644                Cigar::Del(len) | Cigar::RefSkip(len) => {
645                    self.genome_pos += len as i64;
646                }
647                Cigar::HardClip(_) => {} // no advance
648                Cigar::Pad(_) => panic!("Padding (Cigar::Pad) is not supported."), //padding is only used for multiple sequence alignment
649            }
650            return Some((None, entry));
651        }
652        None
653    }
654}
655pub struct IterAlignedBlockCigarPairs {
656    genome_pos: i64,
657    read_pos: i64,
658    cigar_index: usize,
659    cigar: Vec<Cigar>,
660}
661impl Iterator for IterAlignedBlockCigarPairs {
662    type Item = (Range<i64>, Range<i64>, Cigar);
663    fn next(&mut self) -> Option<Self::Item> {
664        while self.cigar_index < self.cigar.len() {
665            let entry = self.cigar[self.cigar_index];
666            self.cigar_index += 1;
667            match entry {
668                Cigar::Match(len) | Cigar::Equal(len) | Cigar::Diff(len) => {
669                    let qstart = self.read_pos;
670                    let qend = qstart + len as i64;
671                    let rstart = self.genome_pos;
672                    let rend = self.genome_pos + len as i64;
673                    self.read_pos += len as i64;
674                    self.genome_pos += len as i64;
675                    return Some((qstart..qend, rstart..rend, entry));
676                }
677                Cigar::Ins(len) | Cigar::SoftClip(len) => {
678                    let qstart = self.read_pos;
679                    let qend = qstart + len as i64;
680                    let rstart = self.genome_pos;
681                    self.read_pos += len as i64;
682                    return Some((qstart..qend, rstart..rstart, entry));
683                }
684                Cigar::Del(len) | Cigar::RefSkip(len) => {
685                    let qstart = self.read_pos;
686                    let rstart = self.genome_pos;
687                    let rend = self.genome_pos + len as i64;
688                    self.genome_pos += len as i64;
689                    return Some((qstart..qstart, rstart..rend, entry));
690                }
691                Cigar::HardClip(_) => {
692                    return Some((
693                        self.read_pos..self.read_pos,
694                        self.genome_pos..self.genome_pos,
695                        entry,
696                    ));
697                } // no advance
698                Cigar::Pad(_) => panic!("Padding (Cigar::Pad) is not supported."), //padding is only used for multiple sequence alignment
699            }
700        }
701        None
702    }
703}
704pub struct IterAlignedBlockPairs {
705    genome_pos: i64,
706    read_pos: i64,
707    cigar_index: usize,
708    cigar: Vec<Cigar>,
709    r#match: bool,
710}
711impl MatchIter for IterAlignedBlockPairs {
712    fn ismatchonly(&self) -> bool {
713        self.r#match
714    }
715
716    fn setmatchstate(&mut self, matchs: bool) {
717        self.r#match = matchs;
718    }
719}
720impl Iterator for IterAlignedBlockPairs {
721    type Item = ([i64; 2], [i64; 2]);
722    fn next(&mut self) -> Option<Self::Item> {
723        while self.cigar_index < self.cigar.len() {
724            let entry = self.cigar[self.cigar_index];
725            match entry {
726                Cigar::Match(len) | Cigar::Equal(len) | Cigar::Diff(len) => {
727                    let qstart = self.read_pos;
728                    let qend = qstart + len as i64;
729                    let rstart = self.genome_pos;
730                    let rend = self.genome_pos + len as i64;
731                    self.read_pos += len as i64;
732                    self.genome_pos += len as i64;
733                    #[allow(clippy::nonminimal_bool)]
734                    if (self.r#match && matches!(entry, Cigar::Equal(_))) || !self.r#match {
735                        self.cigar_index += 1;
736                        return Some(([qstart, qend], [rstart, rend]));
737                    }
738                }
739                Cigar::Ins(len) | Cigar::SoftClip(len) => {
740                    self.read_pos += len as i64;
741                }
742                Cigar::Del(len) | Cigar::RefSkip(len) => {
743                    self.genome_pos += len as i64;
744                }
745                Cigar::HardClip(_) => {} // no advance
746                Cigar::Pad(_) => panic!("Padding (Cigar::Pad) is not supported."), //padding is only used for multiple sequence alignment
747            }
748            self.cigar_index += 1;
749        }
750        None
751    }
752}
753#[derive(Ord, PartialOrd, Eq, PartialEq, Debug, Copy, Clone)]
754pub struct RangePos {
755    pub start: i64,
756    pub end: i64,
757}
758impl RangePos {
759    pub fn getrange(&self) -> Range<i64> {
760        self.start..self.end
761    }
762    pub fn start(&self) -> i64 {
763        self.start
764    }
765    pub fn end(&self) -> i64 {
766        self.end
767    }
768    #[allow(unused)]
769    fn new(start: i64, end: i64) -> Self {
770        let (start, end) = match start.cmp(&end) {
771            std::cmp::Ordering::Greater => (end, start),
772            _ => (start, end),
773        };
774        RangePos { start, end }
775    }
776}
777/// Matching sequence, return a genomic range and associated sequence
778/// ```
779/// use extended_htslib::bam::ext::MatchSequence;
780/// let test = MatchSequence::default();
781/// for (range, sequence) in test.gethash() {
782///     println!("SEQ: {} for {}-{}",sequence,range.start,range.end);
783/// }
784/// ```
785pub struct MatchSequence {
786    pub hash: BTreeMap<RangePos, String>,
787}
788impl MatchSequence {
789    pub fn new(range: RangePos, text: String) -> Self {
790        let mut map = BTreeMap::new();
791        map.insert(range, text);
792        MatchSequence { hash: map }
793    }
794    /// return a hash of rangepos and genomic sequence
795    pub fn gethash(&self) -> &BTreeMap<RangePos, String> {
796        &self.hash
797    }
798    ///Check if a range of genomic position is completely aligned with the read. Return the sequence if yes else return None
799    pub fn isfullymatched(&self, range: RangeInclusive<i64>) -> Option<String> {
800        let mut vec = self.hash.iter();
801        vec.find_map(|(a, b)| {
802            if a.getrange().contains(range.start()) && a.getrange().contains(range.end()) {
803                Some(b.clone())
804            } else {
805                None
806            }
807        })
808    }
809}
810impl Default for MatchSequence {
811    fn default() -> Self {
812        let default = String::new();
813        let range = RangePos { start: 1, end: 1 };
814        Self::new(range, default)
815    }
816}
817pub struct IterAlignedBlocks {
818    pos: i64,
819    cigar_index: usize,
820    cigar: Vec<Cigar>,
821    r#match: bool,
822}
823impl MatchIter for IterAlignedBlocks {
824    fn ismatchonly(&self) -> bool {
825        self.r#match
826    }
827
828    fn setmatchstate(&mut self, matchs: bool) {
829        self.r#match = matchs;
830    }
831}
832impl Iterator for IterAlignedBlocks {
833    type Item = [i64; 2];
834    fn next(&mut self) -> Option<Self::Item> {
835        while self.cigar_index < self.cigar.len() {
836            let entry = self.cigar[self.cigar_index];
837            match entry {
838                Cigar::Match(len) | Cigar::Equal(len) | Cigar::Diff(len) => {
839                    let out_pos = self.pos;
840                    //result.push([pos, pos + *len as i64]);
841                    self.pos += len as i64;
842                    #[allow(clippy::nonminimal_bool)]
843                    if (self.r#match && matches!(entry, Cigar::Equal(_))) || !self.r#match {
844                        self.cigar_index += 1;
845                        return Some([out_pos, out_pos + len as i64]);
846                    }
847                }
848                Cigar::Del(len) => self.pos += len as i64,
849                Cigar::RefSkip(len) => self.pos += len as i64,
850                _ => (),
851            }
852            self.cigar_index += 1;
853        }
854        None
855    }
856}
857
858pub struct IterIntrons {
859    pos: i64,
860    cigar_index: usize,
861    cigar: Vec<Cigar>,
862}
863
864impl Iterator for IterIntrons {
865    type Item = [i64; 2];
866    fn next(&mut self) -> Option<Self::Item> {
867        while self.cigar_index < self.cigar.len() {
868            let entry = self.cigar[self.cigar_index];
869            match entry {
870                Cigar::Match(len) | Cigar::Equal(len) | Cigar::Diff(len) | Cigar::Del(len) => {
871                    self.pos += len as i64
872                }
873                Cigar::RefSkip(len) => {
874                    let junc_start = self.pos;
875                    self.pos += len as i64;
876                    self.cigar_index += 1;
877                    return Some([junc_start, self.pos]); //self.pos is  junc_start + len
878                }
879                _ => {}
880            }
881            self.cigar_index += 1;
882        }
883        None
884    }
885}
886
887pub struct IterAlignedPairs {
888    genome_pos: i64,
889    read_pos: i64,
890    cigar: Vec<Cigar>,
891    remaining_match_bp: u32,
892    cigar_index: usize,
893    r#match: bool,
894}
895impl MatchIter for IterAlignedPairs {
896    fn ismatchonly(&self) -> bool {
897        self.r#match
898    }
899
900    fn setmatchstate(&mut self, matchs: bool) {
901        self.r#match = matchs;
902    }
903}
904impl Iterator for IterAlignedPairs {
905    type Item = [i64; 2];
906    fn next(&mut self) -> Option<Self::Item> {
907        if self.remaining_match_bp > 0 {
908            self.remaining_match_bp -= 1;
909            self.genome_pos += 1;
910            self.read_pos += 1;
911            return Some([self.read_pos - 1, self.genome_pos - 1]);
912        }
913
914        while self.cigar_index < self.cigar.len() {
915            let entry = self.cigar[self.cigar_index];
916            match entry {
917                Cigar::Match(len) | Cigar::Equal(len) | Cigar::Diff(len) => {
918                    self.genome_pos += 1;
919                    self.read_pos += 1;
920                    self.remaining_match_bp = len - 1;
921                    #[allow(clippy::nonminimal_bool)]
922                    if (self.r#match && matches!(entry, Cigar::Equal(_))) || !self.r#match {
923                        self.cigar_index += 1;
924                        return Some([self.read_pos - 1, self.genome_pos - 1]);
925                    }
926                }
927                Cigar::Ins(len) | Cigar::SoftClip(len) => {
928                    self.read_pos += len as i64;
929                }
930                Cigar::Del(len) | Cigar::RefSkip(len) => {
931                    self.genome_pos += len as i64;
932                }
933                Cigar::HardClip(_) => {} // no advance
934                Cigar::Pad(_) => panic!("Padding (Cigar::Pad) is not supported."), //padding is only used for multiple sequence alignment
935            }
936            self.cigar_index += 1;
937        }
938        None
939    }
940}
941
942pub struct IterAlignedPairsFull {
943    genome_pos: i64,
944    read_pos: i64,
945    cigar: Vec<Cigar>,
946    remaining_match_bp: u32,
947    remaining_ins_bp: u32,
948    remaining_del_bp: u32,
949    cigar_index: usize,
950}
951pub(super) struct IterAlignedPairsFullCigar {
952    genome_pos: i64,
953    read_pos: i64,
954    cigar: Vec<Cigar>,
955    qual: Vec<u8>,
956    remaining_match_bp: u32,
957    remaining_ins_bp: u32,
958    remaining_del_bp: u32,
959    cigar_index: usize,
960}
961impl IterAlignedPairsFullCigar {
962    pub fn new(start: IterAlignedPairsFull, record: &bam::Record) -> Self {
963        Self {
964            genome_pos: start.genome_pos,
965            read_pos: start.read_pos,
966            cigar: start.cigar,
967            qual: record.qual().to_vec(),
968            remaining_match_bp: start.remaining_match_bp,
969            remaining_ins_bp: start.remaining_ins_bp,
970            remaining_del_bp: start.remaining_del_bp,
971            cigar_index: start.cigar_index,
972        }
973    }
974}
975/// Iterate over read pos, genome pos, cigar and quality of read
976impl Iterator for IterAlignedPairsFullCigar {
977    type Item = ([Option<i64>; 2], Cigar, u8);
978    fn next(&mut self) -> Option<Self::Item> {
979        if self.remaining_match_bp > 0 {
980            self.remaining_match_bp -= 1;
981            self.genome_pos += 1;
982            self.read_pos += 1;
983            return Some((
984                [Some(self.read_pos - 1), Some(self.genome_pos - 1)],
985                self.cigar[self.cigar_index.saturating_sub(1)],
986                self.qual
987                    .get(
988                        usize::try_from(self.read_pos)
989                            .unwrap_or_default()
990                            .saturating_sub(1),
991                    )
992                    .copied()
993                    .unwrap_or(u8::MAX),
994            ));
995        }
996        if self.remaining_ins_bp > 0 {
997            self.remaining_ins_bp -= 1;
998            self.read_pos += 1;
999            return Some((
1000                [Some(self.read_pos - 1), None],
1001                self.cigar[self.cigar_index.saturating_sub(1)],
1002                self.qual
1003                    .get(
1004                        usize::try_from(self.read_pos)
1005                            .unwrap_or_default()
1006                            .saturating_sub(1),
1007                    )
1008                    .copied()
1009                    .unwrap_or(u8::MAX),
1010            ));
1011        }
1012        if self.remaining_del_bp > 0 {
1013            self.remaining_del_bp -= 1;
1014            self.genome_pos += 1;
1015            return Some((
1016                [None, Some(self.genome_pos - 1)],
1017                self.cigar[self.cigar_index.saturating_sub(1)],
1018                self.qual
1019                    .get(usize::try_from(self.read_pos).unwrap_or_default())
1020                    .copied()
1021                    .unwrap_or(u8::MAX),
1022            ));
1023        }
1024
1025        while self.cigar_index < self.cigar.len() {
1026            let entry = self.cigar[self.cigar_index];
1027            match entry {
1028                Cigar::Match(len) | Cigar::Equal(len) | Cigar::Diff(len) => {
1029                    self.genome_pos += 1;
1030                    self.read_pos += 1;
1031                    self.remaining_match_bp = len - 1;
1032                    self.cigar_index += 1;
1033                    return Some((
1034                        [Some(self.read_pos - 1), Some(self.genome_pos - 1)],
1035                        entry,
1036                        self.qual
1037                            .get(
1038                                usize::try_from(self.read_pos)
1039                                    .unwrap_or_default()
1040                                    .saturating_sub(1),
1041                            )
1042                            .copied()
1043                            .unwrap_or(u8::MAX),
1044                    ));
1045                }
1046                Cigar::Ins(len) | Cigar::SoftClip(len) => {
1047                    self.read_pos += 1;
1048                    self.remaining_ins_bp = len - 1;
1049                    self.cigar_index += 1;
1050                    return Some((
1051                        [Some(self.read_pos - 1), None],
1052                        entry,
1053                        self.qual
1054                            .get(
1055                                usize::try_from(self.read_pos)
1056                                    .unwrap_or_default()
1057                                    .saturating_sub(1),
1058                            )
1059                            .copied()
1060                            .unwrap_or(u8::MAX),
1061                    ));
1062                }
1063                Cigar::Del(len) | Cigar::RefSkip(len) => {
1064                    self.genome_pos += 1;
1065                    self.remaining_del_bp = len - 1;
1066                    self.cigar_index += 1;
1067                    return Some((
1068                        [None, Some(self.genome_pos - 1)],
1069                        entry,
1070                        self.qual
1071                            .get(usize::try_from(self.read_pos).unwrap_or_default())
1072                            .copied()
1073                            .unwrap_or(u8::MAX),
1074                    ));
1075                }
1076                Cigar::HardClip(_) => {
1077                    // no advance
1078                }
1079                Cigar::Pad(_) => panic!("Padding (Cigar::Pad) is not supported."), //padding is only used for multiple sequence alignment
1080            }
1081            self.cigar_index += 1;
1082        }
1083        None
1084    }
1085}
1086
1087impl Iterator for IterAlignedPairsFull {
1088    type Item = [Option<i64>; 2];
1089    fn next(&mut self) -> Option<Self::Item> {
1090        if self.remaining_match_bp > 0 {
1091            self.remaining_match_bp -= 1;
1092            self.genome_pos += 1;
1093            self.read_pos += 1;
1094            return Some([Some(self.read_pos - 1), Some(self.genome_pos - 1)]);
1095        }
1096        if self.remaining_ins_bp > 0 {
1097            self.remaining_ins_bp -= 1;
1098            self.read_pos += 1;
1099            return Some([Some(self.read_pos - 1), None]);
1100        }
1101        if self.remaining_del_bp > 0 {
1102            self.remaining_del_bp -= 1;
1103            self.genome_pos += 1;
1104            return Some([None, Some(self.genome_pos - 1)]);
1105        }
1106
1107        while self.cigar_index < self.cigar.len() {
1108            let entry = self.cigar[self.cigar_index];
1109            match entry {
1110                Cigar::Match(len) | Cigar::Equal(len) | Cigar::Diff(len) => {
1111                    self.genome_pos += 1;
1112                    self.read_pos += 1;
1113                    self.remaining_match_bp = len - 1;
1114                    self.cigar_index += 1;
1115                    return Some([Some(self.read_pos - 1), Some(self.genome_pos - 1)]);
1116                }
1117                Cigar::Ins(len) | Cigar::SoftClip(len) => {
1118                    self.read_pos += 1;
1119                    self.remaining_ins_bp = len - 1;
1120                    self.cigar_index += 1;
1121                    return Some([Some(self.read_pos - 1), None]);
1122                }
1123                Cigar::Del(len) | Cigar::RefSkip(len) => {
1124                    self.genome_pos += 1;
1125                    self.remaining_del_bp = len - 1;
1126                    self.cigar_index += 1;
1127                    return Some([None, Some(self.genome_pos - 1)]);
1128                }
1129                Cigar::HardClip(_) => {
1130                    // no advance
1131                }
1132                Cigar::Pad(_) => panic!("Padding (Cigar::Pad) is not supported."), //padding is only used for multiple sequence alignment
1133            }
1134            self.cigar_index += 1;
1135        }
1136        None
1137    }
1138}
1139
1140/// Extra functionality for BAM records
1141///
1142/// Inspired by pysam
1143pub trait BamRecordExtensions {
1144    /// iterator over start and end positions with the sequence of matched
1145    /// blocks.
1146    /// # Errors
1147    /// Return None if CIGAR does not contain any = or sequence is not present.
1148    fn matched_sequence(&self) -> Option<MatchSequence>;
1149    /// iterator over start and end positions of aligned gapless blocks
1150    ///
1151    /// The start and end positions are in genomic coordinates.
1152    /// There is not necessarily a gap between blocks on the genome,
1153    /// this happens on insertions.
1154    ///
1155    /// pysam: blocks
1156    /// See also: [aligned_block_pairs](#tymethod.aligned_block_pairs) if you need
1157    /// the read coordinates as well.
1158    fn aligned_blocks(&self) -> IterAlignedBlocks;
1159    /// iterator over start and end positions of aligned matched blocks.
1160    ///
1161    /// The start and end positions are in genomic coordinates.
1162    /// There is not necessarily a gap between blocks on the genome,
1163    /// this happens on insertions.
1164    /// # Errors
1165    /// Return None if CIGAR does not contain any = or sequence is not present.
1166    fn aligned_blocks_match(&self) -> Option<IterAlignedBlocks>;
1167    ///Iter over <([read_start, read_stop], [genome_start, genome_stop]) blocks
1168    ///of continously aligned reads.
1169    ///
1170    ///In contrast to [aligned_blocks](#tymethod.aligned_blocks), this returns
1171    ///read and genome coordinates.
1172    ///
1173    ///There is not necessarily a gap between blocks in either coordinate space
1174    ///(this happens in in-dels).
1175    fn aligned_block_pairs(&self) -> IterAlignedBlockPairs;
1176    ///Iter over <([read_start, read_stop], [genome_start, genome_stop]) blocks
1177    ///of continously matched reads.
1178    ///
1179    ///In contrast to [aligned_blocks](#tymethod.aligned_blocks), this returns
1180    ///read and genome coordinates.
1181    ///In contrast to aligned_pairs, this returns only match sequence.
1182    ///
1183    ///There is not necessarily a gap between blocks in either coordinate space
1184    ///(this happens in in-dels).
1185    /// # Errors
1186    /// Return None if CIGAR does not contain any = or sequence is not present.
1187    fn aligned_block_pairs_match(&self) -> Option<IterAlignedBlockPairs>;
1188    ///Iter over <(([read_start..read_stop], [genome_start..genome_stop], Cigar)> blocks
1189    ///of cigar blocks (it is a range).
1190    ///
1191    ///In contrast to [aligned_blocks](#tymethod.aligned_blocks), this returns
1192    ///read and genome coordinates and by blocks of cigar.
1193    ///In contrast to aligned_pairs, this returns the cigar format.
1194    ///
1195    ///There is not necessarily a gap between blocks in either coordinate space
1196    ///(this happens in in-dels).
1197    fn aligned_block_pairs_cigar(&self) -> IterAlignedBlockCigarPairs;
1198    ///Iter over <(Option<([read_start..read_stop], [genome_start..genome_stop]),Cigar)> blocks
1199    ///of cigar blocks that perfectly match the reference (it is a range).
1200    ///
1201    ///In contrast to [aligned_blocks_match](#tymethod.aligned_blocks_match), this returns
1202    ///read and genome coordinates.
1203    ///In contrast to aligned_pairs_match, this returns None for every element that has no matching element and the cigar.
1204    ///
1205    ///There is not necessarily a gap between blocks in either coordinate space
1206    ///(this happens in in-dels).
1207    ///
1208    /// # Errors
1209    /// Return None if CIGAR does not contain any = or sequence is not present.
1210    fn aligned_block_pairs_cigar_match(&self) -> Option<IterAlignedBlockCigarMatchPairs>;
1211    /// This scans the CIGAR for reference skips
1212    /// and reports their positions.
1213    /// It does not inspect the reported regions
1214    /// for actual splice sites.
1215    /// pysam: get_introns
1216    fn introns(&self) -> IterIntrons;
1217    /// iter aligned read and reference positions on a basepair level
1218    ///
1219    /// No entry for mismatches, insertions, deletions or skipped pairs
1220    ///
1221    /// pysam: get_aligned_pairs(matches_only = True) but only matched bases
1222    ///
1223    /// See also [aligned_block_pairs](#tymethod.aligned_block_pairs)
1224    /// if you just need start&end coordinates of each block.
1225    /// That way you can allocate less memory for the same
1226    /// informational content.
1227    /// # Errors
1228    /// Return None if CIGAR does not contain any =/X.
1229    fn aligned_pairs_match(&self) -> Option<IterAlignedPairs>;
1230    /// iter aligned read and reference positions on a basepair level
1231    ///
1232    /// No entry for insertions, deletions or skipped pairs
1233    ///
1234    /// pysam: get_aligned_pairs(matches_only = True)
1235    ///
1236    /// See also [aligned_block_pairs](#tymethod.aligned_block_pairs)
1237    /// if you just need start&end coordinates of each block.
1238    /// That way you can allocate less memory for the same
1239    /// informational content.
1240    fn aligned_pairs(&self) -> IterAlignedPairs;
1241
1242    /// iter list of read and reference positions on a basepair level.
1243    ///
1244    /// Unlike `aligned_pairs` this returns None in
1245    /// either the read positions or the reference position
1246    /// for insertions, deletions or skipped pairs
1247    ///
1248    /// pysam: aligned_pairs(matches_only = False)
1249    fn aligned_pairs_full(&self) -> IterAlignedPairsFull;
1250
1251    /// the number of nucleotides covered by each Cigar::* variant.
1252    ///
1253    /// Result is a Hashmap Cigar::*(0) => covered nucleotides
1254    ///
1255    /// pysam: first result from get_cigar_stats
1256    fn cigar_stats_nucleotides(&self) -> HashMap<Cigar, i32>;
1257
1258    /// the number of occurrences of each each Cigar::* variant
1259    ///
1260    /// Result is a Hashmap Cigar::*(0) => number of times this Cigar::
1261    /// appeared
1262    ///
1263    /// pysam: second result from get_cigar_stats
1264    fn cigar_stats_blocks(&self) -> HashMap<Cigar, i32>;
1265
1266    /// iter over  reference positions that this read aligns to
1267    ///
1268    /// only returns positions that are aligned, excluding any soft-clipped
1269    /// or unaligned positions within the read
1270    ///
1271    /// pysam: get_reference_positions(full_length=False)
1272    fn reference_positions(&self) -> Box<dyn Iterator<Item = i64>>;
1273    /// iter over reference positions that this read aligns to
1274    ///
1275    /// only returns positions that are matched, excluding any soft-clipped
1276    /// or mismatched positions, unaligned positions within the read. Return None if cigar has no =
1277    ///
1278    /// pysam: get_reference_positions(full_length=False)
1279    fn reference_positions_match(&self) -> Option<Box<dyn Iterator<Item = i64>>>;
1280    ///
1281    /// iter over reference positions that this read aligns to
1282    ///
1283    /// include soft-clipped or skipped positions as None
1284    ///
1285    /// pysam: get_reference_positions(full_length=True)
1286    fn reference_positions_full(&self) -> Box<dyn Iterator<Item = Option<i64>>>;
1287
1288    /// left most aligned reference position of the read on the reference genome.
1289    fn reference_start(&self) -> i64;
1290
1291    /// right most aligned reference position of the read on the reference genome.
1292    fn reference_end(&self) -> i64;
1293
1294    /// infer the query length from the cigar string, optionally include hard clipped bases
1295    ///
1296    /// Contrast with record::seq_len which returns the length of the sequence stored
1297    /// in the BAM file, and as such is 0 if the BAM file omits sequences
1298    ///
1299    /// pysam: infer_query_length / infer_read_length
1300    fn seq_len_from_cigar(&self, include_hard_clip: bool) -> usize;
1301    /// Get CS tag and perfect match alignment from BAM, try to use MD if existing else None if extension does not exist
1302    #[deprecated(since = "0.3.0", note = "use getorgeneratecsblock")]
1303    fn getcsaligned(&self) -> Option<CgAlignedBlockPairs>;
1304    /// Get CS tag and perfect match alignment from BAM, try to use MD if existing else return an error. Needs also a header with contig name.
1305    /// # Errors
1306    /// No CS or MD tag.
1307    /// # Examples
1308    /// ```
1309    /// use extended_htslib::bam::{self,Read,ext::BamRecordExtensions};
1310    /// use extended_htslib::bam::record::{Aux,CsString};
1311    /// use std::str::FromStr;
1312    /// let mut t = bam::Reader::from_path("test/locusmd.bam").unwrap();
1313    /// let info = t
1314    ///     .rc_records()
1315    ///     .filter_map(Result::ok)
1316    ///     .filter(|p| p.is_primary())
1317    ///     .next()
1318    ///     .unwrap()
1319    ///     .getorgeneratecsblock(false)
1320    ///     .unwrap();
1321    /// let raw = CsString::from_str(":15+g:67+c:329-t:125+g:58-c:901+g:280-g:160-t:23-t:32-g:73+g:300-gt:16-t:401-t:5*ta:76-t:259*ta:187-a:17-a:36-a:63-t:39-g:39-g:193-c:128+c:689+c:49-t:133-g:186+g:92+g:107+g:42+c:250-g:68-c:6-c:136+g:306+c:31+c:167-g:156*ta:1319-c:308-c:67-c:208-ca:66+c:3-t:16-c:38-ac:2*ac:40-c:128-a:54+g:51-a:273-a:3-t:225-a:4-t:45-ac:53-a:227-a:37*at*ta*at:31-ac:32-ca:199*at:136-ca:41-cac:45-c:370-c:195-g:241+g:400-c:108-g:681+c:190-g:768-c:108-g:441-c:198-c:80+g:113+t:208-g:504-c:9+t:253+c:113-g:100+c:164-c:639-t:390-tc:381+c:335-t:984+c:473-c:40-c:39+c:225-g:54-g:83+c:82-c:344+c:4+g:142-t:496").unwrap();
1322    /// assert_eq!(info.cs,raw);
1323    /// ```
1324    ///
1325    /// # Panics
1326    /// ```should_panic
1327    /// use extended_htslib::bam::{self,ext::BamRecordExtensions,record::Aux};
1328    /// let mut test = bam::Record::new();
1329    /// let cigar = "20M1X3M1D2M1I30S";
1330    /// let seqread = "ctatgtcaatcaatcgcttggacaactcctgcatcacatcgagctcttgccgaaaat";
1331    /// let cigarresult = bam::record::CigarString::try_from(cigar).unwrap();
1332    /// let qual = vec![255 as u8; seqread.len()];
1333    /// test.set_tid(1);
1334    /// test.set(
1335    ///     "test".as_bytes(),
1336    ///     Some(&cigarresult),
1337    ///     seqread.as_bytes(),
1338    ///     &qual,
1339    /// );
1340    /// assert!(test.getorgeneratecsblock(false).is_err_and(|f| f.to_string().as_str() == "error parsing CS record: Absent MD tag."));
1341    /// test.update_aux(b"MD", Aux::String("20T3^C2")).unwrap();
1342    /// assert!(test.getorgeneratecsblock(false).is_ok());
1343    /// ```
1344    fn getorgeneratecsblock(&self, long_cs: bool) -> crate::bam::Result<CgAlignedBlockPairs>;
1345    /// Edit cigar to add =/X if does not contain, return None if cannot perform or =/X already present.
1346    /// Can give a CgAlignedBlockPairs or set None to extract it from the CS tag.
1347    /// # Examples
1348    /// ```
1349    /// use extended_htslib::bam::{self, Read, ext::BamRecordExtensions, record::Aux};
1350    /// let mut t = bam::Reader::from_path("test/setcigar.sam").unwrap();
1351    /// let mut info = t
1352    ///     .records()
1353    ///     .filter_map(Result::ok)
1354    ///     .filter(|p| p.is_primary())
1355    ///     .next()
1356    ///     .unwrap();
1357    /// info.setcigarfromcs(None).unwrap();
1358    /// assert_eq!(info.cigar().to_string(), "31=1X29=1I1X45=1X39=1D143=1I203=1I1404=");
1359    /// ```
1360    fn setcigarfromcs(&mut self, record: Option<&CgAlignedBlockPairs>) -> Option<()>;
1361    #[deprecated(since = "0.4.0", note = "Use setcigarfromcs")]
1362    fn setseqfromcs(&mut self, record: &CgAlignedBlockPairs) -> Option<()>;
1363    /// Edit or add cs tag to the record. Return Error is fails.
1364    /// # Examples
1365    /// ```
1366    /// use extended_htslib::bam::{self, Read, ext::BamRecordExtensions, record::Aux};
1367    /// let mut t = bam::Reader::from_path("test/locusmd.bam").unwrap();
1368    /// let mut info = t
1369    ///     .records()
1370    ///     .filter_map(Result::ok)
1371    ///     .filter(|p| p.is_primary())
1372    ///     .next()
1373    ///     .unwrap();
1374    /// assert!(info.aux(b"cs").is_err());
1375    /// if let Ok(a) = info.getorgeneratecsblock(false) {
1376    ///     info.updateorsetcstag(&a.getcs());
1377    /// }
1378    /// let string = match info.aux(b"cs").unwrap() {
1379    ///    Aux::String(a) => a,
1380    ///    _ => panic!("Invalid tag"),
1381    /// };
1382    /// assert_eq!(string, ":15+g:67+c:329-t:125+g:58-c:901+g:280-g:160-t:23-t:32-g:73+g:300-gt:16-t:401-t:5*ta:76-t:259*ta:187-a:17-a:36-a:63-t:39-g:39-g:193-c:128+c:689+c:49-t:133-g:186+g:92+g:107+g:42+c:250-g:68-c:6-c:136+g:306+c:31+c:167-g:156*ta:1319-c:308-c:67-c:208-ca:66+c:3-t:16-c:38-ac:2*ac:40-c:128-a:54+g:51-a:273-a:3-t:225-a:4-t:45-ac:53-a:227-a:37*at*ta*at:31-ac:32-ca:199*at:136-ca:41-cac:45-c:370-c:195-g:241+g:400-c:108-g:681+c:190-g:768-c:108-g:441-c:198-c:80+g:113+t:208-g:504-c:9+t:253+c:113-g:100+c:164-c:639-t:390-tc:381+c:335-t:984+c:473-c:40-c:39+c:225-g:54-g:83+c:82-c:344+c:4+g:142-t:496");
1383    /// ```
1384    fn updateorsetcstag(&mut self, string: &CsString) -> bam::Result<()>;
1385}
1386impl BamRecordExtensions for bam::Record {
1387    fn matched_sequence(&self) -> Option<MatchSequence> {
1388        let aligned = self.aligned_block_pairs_match()?;
1389        let sequence = self.seq();
1390        if sequence.is_empty() {
1391            return None;
1392        }
1393        let mut hash = BTreeMap::new();
1394        for ([rstart, rend], [gstart, gend]) in aligned {
1395            let (rstart, rend) = (rstart.try_into().unwrap(), rend.try_into().unwrap());
1396            let sequence = sequence.rangeextract(rstart..rend).unwrap();
1397            hash.insert(
1398                RangePos {
1399                    start: gstart,
1400                    end: gend,
1401                },
1402                sequence.to_string(),
1403            );
1404        }
1405        Some(MatchSequence { hash })
1406    }
1407    fn aligned_blocks(&self) -> IterAlignedBlocks {
1408        IterAlignedBlocks {
1409            pos: self.pos(),
1410            cigar: self.cigar().take().0,
1411            cigar_index: 0,
1412            r#match: false,
1413        }
1414    }
1415    fn aligned_blocks_match(&self) -> Option<IterAlignedBlocks> {
1416        if !self.cigar().containsequal() {
1417            return None;
1418        };
1419        Some(IterAlignedBlocks {
1420            pos: self.pos(),
1421            cigar: self.cigar().take().0,
1422            cigar_index: 0,
1423            r#match: true,
1424        })
1425    }
1426    fn getcsaligned(&self) -> Option<CgAlignedBlockPairs> {
1427        self.getorgeneratecsblock(true).ok()
1428    }
1429    fn setseqfromcs(&mut self, record: &CgAlignedBlockPairs) -> Option<()> {
1430        let initialcigar = self.cigar();
1431        let mycigar = initialcigar.iter();
1432        let first: Vec<&Cigar> = mycigar
1433            .take_while(|p| matches!(p, &Cigar::SoftClip(_)) || matches!(p, &Cigar::HardClip(_)))
1434            .collect();
1435        let mycigar = initialcigar.iter().skip(first.len());
1436        let mut first = first.into_iter().map(|p| p.clone()).collect();
1437        let last: Vec<&Cigar> = mycigar
1438            .skip_while(|p| !matches!(p, &Cigar::SoftClip(_)) && !matches!(p, &Cigar::HardClip(_)))
1439            .take_while(|_| true)
1440            .collect();
1441        let mut last = last.into_iter().map(|p| p.clone()).collect();
1442        let mut length: Option<usize> = None;
1443        let mut vec: Vec<Cigar> = Vec::new();
1444        vec.append(&mut first);
1445        for elem in record.csdata.iter() {
1446            if elem.state.isubstitution() {
1447                if let Some(l) = length {
1448                    length = Some(l.saturating_add(1));
1449                } else {
1450                    length = Some(1);
1451                }
1452                continue;
1453            }
1454            let lengthraw = elem.state.getlength().try_into().ok()?;
1455            if let Some(a) = length {
1456                vec.push(Cigar::Diff(a.try_into().ok()?));
1457                length = None;
1458            }
1459            let val = match elem.state {
1460                Same(_) => Cigar::Equal(lengthraw),
1461                Insertion(_) => Cigar::Ins(lengthraw),
1462                Deletion(_) => Cigar::Del(lengthraw),
1463                Intron(_) => Cigar::RefSkip(lengthraw),
1464                Substitution(_) if let Some(a) = length => Cigar::Diff(a.try_into().ok()?),
1465                Substitution(_) => unreachable!("Length must be set"),
1466            };
1467            vec.push(val);
1468        }
1469        if let Some(a) = length {
1470            vec.push(Cigar::Diff(a.try_into().ok()?));
1471        }
1472        vec.append(&mut last);
1473        self.set_cigar(Some(&CigarString::from(vec)));
1474        Some(())
1475    }
1476    fn setcigarfromcs(&mut self, record: Option<&CgAlignedBlockPairs>) -> Option<()> {
1477        if self
1478            .cigar()
1479            .iter()
1480            .any(|p| matches!(p, Cigar::Equal(_)) || matches!(p, Cigar::Diff(_)))
1481        {
1482            return None; //Already X/= in cigar
1483        }
1484        let record = match record {
1485            Some(a) => a,
1486            None => &self.getorgeneratecsblock(true).ok()?,
1487        };
1488        let initialcigar = self.cigar();
1489        let mycigar = initialcigar.iter();
1490        let first: Vec<&Cigar> = mycigar
1491            .take_while(|p| matches!(p, &Cigar::SoftClip(_)) || matches!(p, &Cigar::HardClip(_)))
1492            .collect();
1493        let mycigar = initialcigar.iter().skip(first.len());
1494        let mut first = first.into_iter().map(|p| p.clone()).collect();
1495        let last: Vec<&Cigar> = mycigar
1496            .skip_while(|p| !matches!(p, &Cigar::SoftClip(_)) && !matches!(p, &Cigar::HardClip(_)))
1497            .take_while(|_| true)
1498            .collect();
1499        let mut last = last.into_iter().map(|p| p.clone()).collect();
1500        let mut length: Option<usize> = None;
1501        let mut vec: Vec<Cigar> = Vec::new();
1502        vec.append(&mut first);
1503        for elem in record.csdata.iter() {
1504            if elem.state.isubstitution() {
1505                if let Some(l) = length {
1506                    length = Some(l.saturating_add(1));
1507                } else {
1508                    length = Some(1);
1509                }
1510                continue;
1511            }
1512            let lengthraw = elem.state.getlength().try_into().ok()?;
1513            if let Some(a) = length {
1514                vec.push(Cigar::Diff(a.try_into().ok()?));
1515                length = None;
1516            }
1517            let val = match elem.state {
1518                Same(_) => Cigar::Equal(lengthraw),
1519                Insertion(_) => Cigar::Ins(lengthraw),
1520                Deletion(_) => Cigar::Del(lengthraw),
1521                Intron(_) => Cigar::RefSkip(lengthraw),
1522                Substitution(_) if let Some(a) = length => Cigar::Diff(a.try_into().ok()?),
1523                Substitution(_) => unreachable!("Length must be set"),
1524            };
1525            vec.push(val);
1526        }
1527        if let Some(a) = length {
1528            vec.push(Cigar::Diff(a.try_into().ok()?));
1529        }
1530        vec.append(&mut last);
1531        self.set_cigar(Some(&CigarString::from(vec)));
1532        Some(())
1533    }
1534    fn updateorsetcstag(&mut self, string: &CsString) -> bam::Result<()> {
1535        self.update_aux(b"cs", Aux::String(&string.to_string()))
1536    }
1537    fn getorgeneratecsblock(&self, long_cs: bool) -> crate::bam::Result<CgAlignedBlockPairs> {
1538        let csext = self.aux(b"cs");
1539        let mdext = self.aux(b"MD");
1540        match (
1541            csext
1542                .and_then(|ext| {
1543                    if let bam::record::Aux::String(d) = ext {
1544                        Ok(d)
1545                    } else {
1546                        Err(bam::Error::BamParseCS {
1547                            rec: "Invalid CS tag found".to_string(),
1548                        })
1549                    }
1550                })
1551                .map_err(|_| bam::Error::BamParseCS {
1552                    rec: "Absent CS tag.".to_string(),
1553                }),
1554            mdext
1555                .and_then(|ext| {
1556                    if let bam::record::Aux::String(d) = ext {
1557                        Ok(d)
1558                    } else {
1559                        Err(bam::Error::BamParseMD {
1560                            rec: "Invalid MD tag found".to_string(),
1561                        })
1562                    }
1563                })
1564                .map_err(|_| bam::Error::BamParseCS {
1565                    rec: "Absent MD tag.".to_string(),
1566                }),
1567        ) {
1568            (Ok(data), _) => CgAlignedBlockPairs::createfromcs(
1569                // We have a valid CS tag
1570                CsString::from_str(data)?,
1571                String::from_utf8(self.seq().as_bytes())
1572                    .map(|a| a.to_string())
1573                    .map_err(|_| crate::bam::Error::NoSequencesInReference)
1574                    .ok(),
1575                self.contig().as_bytes().to_vec(),
1576                self.reference_start(),
1577            ),
1578            (Err(_), Ok(ext)) => {
1579                //We have a valid MD tag
1580                let line = String::from_utf8_lossy(self.qname());
1581                let cigar = &self.cigar().0;
1582                let seq = String::from_utf8(self.seq().as_bytes())
1583                    .map_err(|_| crate::bam::Error::NoSequencesInReference)?;
1584                let a = CgAlignedBlockPairs::createfrommdtag(
1585                    ext,
1586                    &seq,
1587                    cigar,
1588                    &line,
1589                    long_cs,
1590                    self.contig().as_bytes().to_vec(),
1591                    self.reference_start(),
1592                );
1593                a
1594            }
1595            (_, Err(b)) => return Err(b),
1596        }
1597    }
1598    fn introns(&self) -> IterIntrons {
1599        IterIntrons {
1600            pos: self.pos(),
1601            cigar: self.cigar().take().0,
1602            cigar_index: 0,
1603        }
1604    }
1605
1606    fn aligned_block_pairs(&self) -> IterAlignedBlockPairs {
1607        IterAlignedBlockPairs {
1608            genome_pos: self.pos(),
1609            read_pos: 0,
1610            cigar: self.cigar().take().0,
1611            cigar_index: 0,
1612            r#match: false,
1613        }
1614    }
1615    fn aligned_block_pairs_cigar_match(&self) -> Option<IterAlignedBlockCigarMatchPairs> {
1616        let cigar = self.cigar().take().0;
1617        if cigar.iter().any(|f| matches!(f, Cigar::Match(_))) {
1618            return None;
1619        }
1620        Some(IterAlignedBlockCigarMatchPairs {
1621            genome_pos: self.pos(),
1622            read_pos: 0,
1623            cigar: cigar,
1624            cigar_index: 0,
1625        })
1626    }
1627    fn aligned_block_pairs_cigar(&self) -> IterAlignedBlockCigarPairs {
1628        IterAlignedBlockCigarPairs {
1629            genome_pos: self.pos(),
1630            read_pos: 0,
1631            cigar: self.cigar().take().0,
1632            cigar_index: 0,
1633        }
1634    }
1635    fn aligned_block_pairs_match(&self) -> Option<IterAlignedBlockPairs> {
1636        if !self.cigar().containsequal() {
1637            return None;
1638        };
1639        Some(IterAlignedBlockPairs {
1640            genome_pos: self.pos(),
1641            read_pos: 0,
1642            cigar: self.cigar().take().0,
1643            cigar_index: 0,
1644            r#match: true,
1645        })
1646    }
1647    fn aligned_pairs_match(&self) -> Option<IterAlignedPairs> {
1648        if !self.cigar().containsequal() {
1649            return None;
1650        };
1651        Some(IterAlignedPairs {
1652            genome_pos: self.pos(),
1653            read_pos: 0,
1654            cigar: self.cigar().take().0,
1655            remaining_match_bp: 0,
1656            cigar_index: 0,
1657            r#match: true,
1658        })
1659    }
1660    fn aligned_pairs(&self) -> IterAlignedPairs {
1661        IterAlignedPairs {
1662            genome_pos: self.pos(),
1663            read_pos: 0,
1664            cigar: self.cigar().take().0,
1665            remaining_match_bp: 0,
1666            cigar_index: 0,
1667            r#match: false,
1668        }
1669    }
1670
1671    fn aligned_pairs_full(&self) -> IterAlignedPairsFull {
1672        IterAlignedPairsFull {
1673            genome_pos: self.pos(),
1674            read_pos: 0,
1675            cigar: self.cigar().take().0,
1676            remaining_match_bp: 0,
1677            remaining_ins_bp: 0,
1678            remaining_del_bp: 0,
1679            cigar_index: 0,
1680        }
1681    }
1682
1683    fn cigar_stats_nucleotides(&self) -> HashMap<Cigar, i32> {
1684        let mut result = HashMap::new();
1685        result.insert(Cigar::Match(0), 0); // M
1686        result.insert(Cigar::Ins(0), 0); // I
1687        result.insert(Cigar::Del(0), 0); // D
1688        result.insert(Cigar::RefSkip(0), 0); // N
1689        result.insert(Cigar::SoftClip(0), 0); // S
1690        result.insert(Cigar::HardClip(0), 0); // H
1691        result.insert(Cigar::Pad(0), 0); // P
1692        result.insert(Cigar::Equal(0), 0); // =
1693        result.insert(Cigar::Diff(0), 0); // X
1694        for entry in self.cigar().iter() {
1695            match entry {
1696                Cigar::Match(len) => *result.get_mut(&Cigar::Match(0)).unwrap() += *len as i32, // M
1697                Cigar::Ins(len) => *result.get_mut(&Cigar::Ins(0)).unwrap() += *len as i32,     // I
1698                Cigar::Del(len) => *result.get_mut(&Cigar::Del(0)).unwrap() += *len as i32,     // D
1699                Cigar::RefSkip(len) => *result.get_mut(&Cigar::RefSkip(0)).unwrap() += *len as i32, // N
1700                Cigar::SoftClip(len) => {
1701                    *result.get_mut(&Cigar::SoftClip(0)).unwrap() += *len as i32
1702                } // S
1703                Cigar::HardClip(len) => {
1704                    *result.get_mut(&Cigar::HardClip(0)).unwrap() += *len as i32
1705                } // H
1706                Cigar::Pad(len) => *result.get_mut(&Cigar::Pad(0)).unwrap() += *len as i32, // P
1707                Cigar::Equal(len) => *result.get_mut(&Cigar::Equal(0)).unwrap() += *len as i32, // =
1708                Cigar::Diff(len) => *result.get_mut(&Cigar::Diff(0)).unwrap() += *len as i32, // X
1709            }
1710        }
1711        result
1712    }
1713
1714    fn cigar_stats_blocks(&self) -> HashMap<Cigar, i32> {
1715        let mut result = HashMap::new();
1716        result.insert(Cigar::Match(0), 0); // M
1717        result.insert(Cigar::Ins(0), 0); // I
1718        result.insert(Cigar::Del(0), 0); // D
1719        result.insert(Cigar::RefSkip(0), 0); // N
1720        result.insert(Cigar::SoftClip(0), 0); // S
1721        result.insert(Cigar::HardClip(0), 0); // H
1722        result.insert(Cigar::Pad(0), 0); // P
1723        result.insert(Cigar::Equal(0), 0); // =
1724        result.insert(Cigar::Diff(0), 0); // X
1725        for entry in self.cigar().iter() {
1726            match entry {
1727                Cigar::Match(_) => *result.get_mut(&Cigar::Match(0)).unwrap() += 1, // M
1728                Cigar::Ins(_) => *result.get_mut(&Cigar::Ins(0)).unwrap() += 1,     // I
1729                Cigar::Del(_) => *result.get_mut(&Cigar::Del(0)).unwrap() += 1,     // D
1730                Cigar::RefSkip(_) => *result.get_mut(&Cigar::RefSkip(0)).unwrap() += 1, // N
1731                Cigar::SoftClip(_) => *result.get_mut(&Cigar::SoftClip(0)).unwrap() += 1, // S
1732                Cigar::HardClip(_) => *result.get_mut(&Cigar::HardClip(0)).unwrap() += 1, // H
1733                Cigar::Pad(_) => *result.get_mut(&Cigar::Pad(0)).unwrap() += 1,     // P
1734                Cigar::Equal(_) => *result.get_mut(&Cigar::Equal(0)).unwrap() += 1, // =
1735                Cigar::Diff(_) => *result.get_mut(&Cigar::Diff(0)).unwrap() += 1,   // X
1736            }
1737        }
1738        result
1739    }
1740
1741    fn reference_positions(&self) -> Box<dyn Iterator<Item = i64>> {
1742        Box::new(self.aligned_pairs().map(|x| x[1]))
1743    }
1744    fn reference_positions_match(&self) -> Option<Box<dyn Iterator<Item = i64>>> {
1745        match self.aligned_pairs_match() {
1746            Some(b) => Some(Box::new(b.map(|x| x[1]))),
1747            None => None,
1748        }
1749    }
1750    fn reference_positions_full(&self) -> Box<dyn Iterator<Item = Option<i64>>> {
1751        Box::new(
1752            self.aligned_pairs_full()
1753                .filter(|x| x.get(0).copied().flatten().is_some())
1754                .map(|x| x.get(1).copied().flatten()),
1755        )
1756    }
1757
1758    fn reference_start(&self) -> i64 {
1759        self.pos()
1760    }
1761
1762    /// Calculate the rightmost base position of an alignment on the reference genome.
1763    /// Returns the coordinate of the first base after the alignment (0-based).
1764    fn reference_end(&self) -> i64 {
1765        unsafe { htslib::bam_endpos(self.inner_ptr()) }
1766    }
1767
1768    fn seq_len_from_cigar(&self, include_hard_clip: bool) -> usize {
1769        let mut result = 0;
1770        for entry in self.cigar().iter() {
1771            match entry {
1772                Cigar::Match(len)
1773                | Cigar::Ins(len)
1774                | Cigar::SoftClip(len)
1775                | Cigar::Equal(len)
1776                | Cigar::Diff(len) => {
1777                    result += len;
1778                }
1779                Cigar::HardClip(len) => {
1780                    if include_hard_clip {
1781                        result += len;
1782                    }
1783                }
1784                _ => {}
1785            }
1786        }
1787        result as usize
1788    }
1789}
1790
1791#[cfg(test)]
1792mod tests {
1793    use crate::bam;
1794    use crate::bam::Read;
1795    use crate::bam::Record;
1796    use crate::bam::ext::BamRecordExtensions;
1797    use crate::bam::ext::CgAlignedBlockPairs;
1798    use crate::bam::ext::CsValue;
1799    use crate::bam::ext::RangePos;
1800    use crate::bam::record::CsString;
1801    use crate::bam::record::{Cigar, CigarString};
1802    use bio_types::genome::AbstractInterval;
1803    use std::collections::HashMap;
1804    use std::str::FromStr;
1805    fn mergemdandcstest(element: &Record) {
1806        assert_eq!(element.qname(), b"SRR11292120.509914");
1807        assert_eq!(element.contig(), "chr14");
1808        let mut cs = element.getorgeneratecsblock(true).unwrap();
1809        let val = cs.next().unwrap();
1810        assert_eq!(val.getreadpos(), Some(0));
1811        assert_eq!(val.getgenomepos(), Some(99813318));
1812        let val = cs.nth(2).unwrap();
1813        assert_eq!(val.getreadpos(), None);
1814        assert_eq!(val.getgenomepos(), Some(99813465));
1815        assert_eq!(val.state, CsValue::Deletion("c".to_string()));
1816        assert!(val.sequence.genomematch(None::<&str>));
1817        assert!(val.sequence.readmatch(Some("c")));
1818        let val = cs.nth(2).unwrap();
1819        assert_eq!(val.getreadpos(), Some(292));
1820        assert_eq!(val.getgenomepos(), Some(99813609));
1821        if let CsValue::Same(a) = val.state {
1822            assert_eq!(a.getsize(), 203)
1823        } else {
1824            assert!(false)
1825        };
1826    }
1827    #[test]
1828    fn testcs() {
1829        let mut read = crate::bam::Reader::from_path("test/locus.bam").unwrap();
1830        let mut element = read.records().filter_map(Result::ok).skip(1).take(1);
1831        let element = element.next().unwrap();
1832        mergemdandcstest(&element);
1833    }
1834    #[test]
1835    //#[ignore]
1836    fn testgeneratedcssame() {
1837        let mut csread = crate::bam::Reader::from_path("test/locus.bam").unwrap();
1838        let mut mdread = crate::bam::Reader::from_path("test/locusmd.bam").unwrap();
1839        let mdread = mdread
1840            .records()
1841            .filter_map(Result::ok)
1842            .filter(|a| a.is_primary())
1843            .map(|a| a.getorgeneratecsblock(false).unwrap());
1844        let csread = csread
1845            .records()
1846            .filter_map(Result::ok)
1847            .filter(|a| a.is_primary())
1848            .map(|a| a.getorgeneratecsblock(false).unwrap());
1849        for (mdread, csread) in mdread.zip(csread) {
1850            if mdread.islongcs() == csread.islongcs() {
1851                //Same form
1852                assert_eq!(mdread.cs, csread.cs)
1853            } else {
1854                panic!("Different format");
1855            }
1856        }
1857    }
1858    #[test]
1859    fn testmd() {
1860        let mut read = crate::bam::Reader::from_path("test/locusmd.bam").unwrap();
1861        let mut element = read.records().filter_map(Result::ok).skip(1).take(1);
1862        let element = element.next().unwrap();
1863        mergemdandcstest(&element);
1864    }
1865    #[test]
1866    fn testmd2() {
1867        let mut read = crate::bam::Reader::from_path("test/outlight.bam").unwrap();
1868        let mut rawelem = read.records().filter_map(Result::ok).into_iter();
1869        let element = rawelem
1870            .find(|p| p.qname() == "m84072_250402_125013_s1/241502339/ccs".as_bytes())
1871            .unwrap();
1872        let v = element.getorgeneratecsblock(false).unwrap();
1873        assert_eq!(
1874            v.cs.to_string(),
1875            ":113+t:43+t:16-a:92-g:103-g:81-g:66+a:91+t:47+g:396+a:312-a:21+t:49-tc:157-t:3-c:832*ca:103-c:294*tg:17-c:17-t:334+g:51-c:10-t:47-t:16+g:44-c:61-c:31+c:289+g:47-c:204-c:56+g:94+t:74-t:29-g:129-c:397-a:105-t:161+a:24+a:662-t:104-t:83-a:82-a:52-at:129*gt:5*at:71-c:38-g:217-t:26-g:65-a:245-t:42+c:151-t:49-ga:46-c:161*tc:19-a:27-a:12+g:378-g:518-c:547+g:170-t:160-g:669-t:351-g:147+t:74*ta:497-g:106+a:110-t:419-g:207-at:151-g:1224+a:110-a:153-a:490-t:314-g:356-t:2*ta:940-t:447-t:329-a:663*at:150+g:219-a:11-a:22-t:21-t:144+a:54+c:212-c:226*ct*tc:782-t:4+t:8-c:604+t:30-t:183-g:178-c:29+t:134+c:251+t:396-t:40-g:276-a:73-t:616-a:144-g:436+t:1014-t:446",
1876            "Cigar is invalid"
1877        );
1878        let element = rawelem
1879            .find(|p| p.qname() == "m84070_250402_111906_s3/138216250/ccs".as_bytes())
1880            .unwrap();
1881        let v = element.getorgeneratecsblock(false).unwrap();
1882        assert_eq!(v.cs,CsString::from_str(":394+C:25+A:1238+T:180-T:119+T:140+A:387+A:685-T:137+G:73+C:753+T:1625+A:736+G:223-T:363-T:3047-T:778+G:408-A:21-T:860+T:165-AT:1478-T:821-A:3*TA:5-A:309-T:1198+A:177-T:110-G:1023-A:1492+T:220+A:107+T:589+T:162-T:168+T:629+A:55-A:552-T:165+A:85-T:26-T:483+T:295+A:77-C:215+T:142-G:93-T:189-T:431+T:1031-A:415").unwrap(),"Not valid CS");
1883    }
1884    #[test]
1885    fn testcigar() {
1886        let mut read = crate::bam::Reader::from_path("test/locus.bam").unwrap();
1887        let elem = read
1888            .records()
1889            .filter_map(Result::ok)
1890            .take(1)
1891            .next()
1892            .unwrap();
1893        let mut cigar = elem.aligned_pairs_match().unwrap();
1894        let _ = cigar.next();
1895        let align = cigar.next();
1896        assert_eq!(align, Some([1, 99812480]));
1897        let align = cigar.nth(40);
1898        assert_eq!(align, Some([43, 99812521]));
1899    }
1900    #[test]
1901    fn testblock() {
1902        let mut read = crate::bam::Reader::from_path("test/locus.bam").unwrap();
1903        let elem = read.records().filter_map(Result::ok).nth(3).unwrap();
1904        assert_eq!(elem.qname(), b"SRR11292123.1482913");
1905        assert_eq!(elem.contig(), "chr14");
1906        let mut element = elem.aligned_blocks_match().unwrap();
1907        assert_eq!(element.next(), Some([99814926, 99816399]));
1908        assert_eq!(element.next(), Some([99816400, 99817131]));
1909        assert_eq!(element.next(), Some([99817132, 99830222]));
1910        assert!(element.next().is_none());
1911    }
1912    #[test]
1913    fn testseq() {
1914        let mut read = crate::bam::Reader::from_path("test/locus.bam").unwrap();
1915        let elem = read.records().filter_map(Result::ok).nth(7).unwrap();
1916        let val = elem.matched_sequence().unwrap();
1917        assert!(val.isfullymatched(99820271..=99826916).is_some());
1918        assert!(val.isfullymatched(99820271..=99826917).is_none());
1919        let mut elem = val.gethash().iter();
1920        let test = elem.next();
1921        let rangepos = RangePos::new(99820271, 99826917);
1922        assert_eq!(
1923            test,
1924            Some((
1925                &rangepos,
1926                &String::from(
1927                    "AGAGGCAGGGATGACAGAGACAGACACAAAGCAGAGAGACGGAGGCAGAGGGAGACATGCAGAGTCGCGGAGACATCCGGGCTCAGGCCCCGACTCTCAGGGGCCACCCCCAGGGAGGACACGCAGTGCACCCCCACACCCACACCTCACACACACACTCACACCCACATACCCCCATCCACACACACCCAGAGACACACAGACACCCACAGCCACACACTCACACTCACGAACTTATCCAGTCACGTCCCACACACTCCCACCCAACCCATACACCACACACCTACACAACCCATACACCACACACACTCACAAACTATATACCACACACACACCAACCATACACCTATATACACTCACACACCCATATACCACACACTCACACACAACCCATACACCACACGCACACAACCCATACACCTATACACACTCACACCTACAAACTATATACTACACACTCACACACAACCCATACACCTATACACACACACCCATATACCACACACAACCCATACACCACACACACAAACCATATACCACACACTCACACAACCCATACACCTATACACACTCATACCCATATACCACATACAACCAATATACCACACACACACAACCCATACACCTATACACACACACCTATACACCACACACAGCCCATACACTACACAATCACACCACAAACTGTATACCACACACTCACACATAACCCATACACCTATACACACACACCCATATACCACACACACAACCTGTGCACCTACACACACACATACACCACACACACACAACTCCTACACCTACACACACCCACCACCCATACACACACAGCCTATACACCTACACACACTCATACACTCATATAGCACACACACAACCCATATACCACACACACAACCCACATACCTATACACACACGCCCATACACCACACACTCACACAACCCATGCACCACATACACCCACAAACTATATGCTACACGCTCACACACAACCCATACACCTATACACAATCCCACAACCCATACACACTTACACAACCTATACACCACACACACTCACAATCTGTATACCACACACACAACCCATACAGTTATACACACACACCCATATACCACACACACACAACCCATATACCACACACTCACACACAAACCATACATCTATACACATACCCATATGCCACACATACAACCCATACACCACACACTCACACACAACACATACACCACACACACAACCCATAGAACACAAACACAAGTCATAACCACACACACAGCCCATATACCTATACACATTCACACACACAACCCATACACTACACACACAACACATACACCTATACACACTCACACTCAATTCATACACCACACACACACAGCCCATACATCTATACACAAACTCACACACAATCCATATACCACAAACTCACACACAACGCATACACCTATACACACACACGCAACTCATACAGCACACACTCACACAACCCACAGACCATAAACACACACAAGCCATAACCACACACAAACCCATACACCTATACACACACTCATAAACAAGCCATACACCCCTACACAACCCATACACCACACACTCACAACCCATACACCTATATACACACACAACCATATACCACAAACTCACGCTCAACACATACACCTATACACACACACAACTCATACACCACACACTCATACACAACGCACAGACCACATACACAAGCCATAACCACACACACACAACCCGTACACATATATACACACTAATAAACAAGCCATACACCTACACATACAACCCATACACCACACATTCACACATAACCCATACACCTATACACACACACACACAACCCATATACCACAAACACACACAACCTATACACACATACAACCCATACACCACACACACAACACATACACACCACACACACACAGAATACTCATACACACACCCATACACCACCCCCACACAGAACCCATACACCACACACACACAACCTATACACCTATACACACACTCACACACACAACTCATATACCACAAACACACACAACACATACACCTATGCACACACACAACCCATACACCACACATTCACATACAACCCATACACCACACACACACAACACATACATGAAACATACATACAACCCACACACCACCCACTCATACACAACCTATACACCACACACACAACTCATACACCTATACACACACAACACATACACCTATCATACACTCACAACACATACACCTCCTATACACACACAACACACACACTTCCTATACACACAACCCACACGCCTATACACACATCCTCACTCACACTCACCCTCACATTCATATACTCACTAACACACTTCCACACTCACACCCTCACCCACACTTACACCCCCACCCACACTCAAACCCCGACGCTAAGTCACTGTCACATTTGTACCCATGCTCACACGCTCACACGCTCACACACTCACCCCCCACCAGCTCCAGGGCTCACTGGTGTGTGCCCACCAAACCCCCCTCGGGGGTCCCCTCGGTAAGCCGACAGTGCTCTGCTCATCGGTGGCCTGGGGAAACAGGGCCCACCCAAGGCCTGGCTCAGGAAAGGCTCCAAACACACATGGCCCAGGAGCAAATGGGCAGAGCTCAGCCTGCAGCTGGGAGCGGCCGAGCGGGTGCTGGGCCAGAGTCGGGGCCTGTCTGTGGGTGAGGGGCACGGCAGCACGGGCCCACCTGCACCTACAAGGCCTGGCCCCCGAGGTCACTGGGCCACCACCCAGCCCTCGCCCTGTTCCCCGTCTGTGCTGGCCGGGGCAGGACTCTGAGCCTCGGGGAAACCCACAGATACACACGGGACCCCGAACATCGGGCTGGGGAGGCTGGGGTGGGTAACAACATCCCAGAGGCAGGAGCAGGAGGTCCTGGGACCCTGCACACTGCGACCCCAGCCCTGGGGGCTGAAGCCCAGGACAGCCTCAGGTCTCCCAGGAGGGACTGGATAGTGGGGGATGGTCAGAGAACAGGACAGCCAGCAGGGTGCAGCCCGAGGACAGGGATGGATGCTGGGAGGTCAACAGGACAGGGGCAGGGGCAGGGGCTGTGGAGTGTGAGAAGGTCCTGGAGGGCCTGGAGAACCTGTGGGTCAGTGTCTGTGGGAAGGAGGCCAGGAGCAGCCCTGAGTGGCCAGGCTGGCAGGGGTGAGGAGGTGGGGGCAGTGAGGTGAGGGTGACCGAGACAGGCCTCTGGCCAGGGAGGGGACCTTGGCTGGGCTCTGACTGAACCCAGGGCTCCTGGAGAAGGGGCCCCAGGCGGGGATGAGGATGTGGGCATCTGACTCCATCAACAATGGGGCTTCCAACACGCACAGCCTGGGCCTCGGAGACCTGGGCCCTGACCCGCCTCCCCCTGGCACTGGGCCGGGTGCCGTGTGTGGTCCCCAGTCCCCGCAGCACCTCCCCCACACTGGTCACGTTCCAGGGCCCCTCTGAAGCACCTGCTGTGAGGGGATGTGAGGAGGGGACAGGGACTTGGGCCTGAGCTGCCGGGTCGGGGGGGAGTCGGGGACCCAGGCTCAGCGTGTGGCTGGGGACCAGACAGATGGGGATGGAGGAGGACACGCCCTGTACCCACTGCCTGCCAAGGGGCTGGACCCACGCCCAGTCTAGGCCATGTCCCCCGAGGCCTGTGAACCTTCACTCTGAGCCACTAAAACATTCAGGAGCTTTGAAAGCAGCCCCCGTCCTTGTCACTATGCGATGACTCTGAGCATCACGCTGTCCCTGCTGGATCCACCCTCCAGCCCCAGCGAGGGAGGCTGGGCCCCGGGCAGCAGGTGGTGAGGGCAGCGGGCACAGCCACCCTACAGCACACACAGGGTCTCAGGGACGCGTCCACCACAGCCCGTGCACAGGCTCCTCACGGCACTGAGTTCACCCGGGGCGCGGGCCGTTTGTCCTCAGGAGTCCCACTGTGCCCTCCGCCCCCAGCCCTGTCCTGCTGAGGCTGCAGCTGGGTCCCGGGGCACAGGGCGGCCCTGAGCACCTTGTCATGTTGGTCCCTGTCGGGTGGGCTGCTGGCTGTCTGTGGAGCTGGCAGAGCCGCGGTTCAGCCTTGGAGGCCGGTCCTGGGGCCCAGCAGCCGTGGGGAGCACTGCCCAGTCCCGTGCCCACAGGGAATCACCTGGGCTGAGGAAGGGCCCACACGCCGACGGGATCGGGGTCAGGCAGCGCACGCCTGGCACCGAGATCCCACGTCCCGAAGTGGGGACACGGCCCAGGGGCACTGTTCCGGGAGGGTCTCAAGATGGGGTCTCCTATTTCAATCTTCACTCCTTCTGCACCTGTTAGCTGGGAACCTTCTAGAAGGAGGGGTGTCCTCAATCATGGGGTGGTTGTGAGCTGAGCACAGATCATGCAGGAAGGTACATGGCTTCTCCTTCACCAGGAAAACAGTGCAGAGAGACAGAGACACAGAGACAGAGTAACAGAGAAAGACAGAGAGACAGAGACACAGAGACAGAGACAGAGTAACAGAGAAAGACAGAGAGACAGAGAGACACAGACAGAGACAGAGTAACAGAGAAAGGCAGAGAGACAGAGAGAGACAGAGACAGAGTAACAGAGAAAGACAGAGAGGCAGAGAGAGAGAGACAGAGACAGAGACAGAGTAACAGAGATAGACAGAGAGACACAGAGACAGAGACAGAGTAACAGAGATAGAGAGACAGAGAGAGACACAGAGACAGAGTAACAGACAGAGACAGAGACAGGCACAGAGATAAGAAAGATACACAGAAACAGAGAGAGACAGAGACAGAGATAGTCACTGTCACATTCATACCCACGCTCACCTGCTCACACACACACACCTCACACACACTCACACTCACACTCACCTCACACACACAGTCACACACACACTCACACACACTCACACACACACACTGAGCTTCCCTCAGGCCCTGTCACTTCCGATGGGGCCTACGGCCTGTCTAAGCCTCTGGGCCACCAGCCCCTGGCTCACCGGTGTGTGCCCACCACACCCCGCCTTGGGGGTCTCCTCTATGAGCTGGGCACATGCCCTCCGCTCTGTTCATGGCTGGCCTGGGGGAAACAGGGCCCACCCAAGGCCTGGCTCAGGGAAGGCCTCAAACACACATGGCCCAGGAGCAAAGGGGCAGAGCTCAGCCTGCAGCTGGGAGCGGGCAGGGGTAGTGGAGTGGGCGGAGGGCCTGGAGAACCTGCAGGGCTACGATGTCTCTGGGAAGGGGGCCCAGGAGCAGCTCAGCGTGGCTGGGCCGGCAGGGCCGAGGAGGTGGGGGCCGTGAGGGAGGGGTGACTCGGCTGTGTGGGGTGCCGGGGGACACGGGCTTTGCTCCGGCTGAGCCCAGGCAGTGGCGAATCCCTGAGCTGCCAGGAGGAGAGCAGGGCCGGGGTCAGGCAGAGGTGGGCCGCGGGGCCGAGGGCTGCGGCCGGTCGGGAGCAGTCGGTCGGTTGAGGGCACCATTACATGGAGGGCTGTGAGACGGGAGACCCCATTCCCTTCATTCCTTGTGCACGTGTTAGTGAGGAAGCTTCTAGAAGGAGGGCATTGCTCGTAGTGGGTGAGTGTGAGCACAGATCATGCAGGCTGGCGTGCTGCCGTGAAGTGCCTCTCTTTACTTTCCAGACCTCAGCATGGCAAGCCCGTCCTGCGCCCCAGGGTCTTTCTGGAGTACACGCCGCGCGGTCCTGGTGGGCACCATACCTGGCACCCACGCTTTGGCCGGGCCCGAACCTTGCGCCCTCCCAGCCCCCATGTGGCTCTCCCTTGGCCATACTGGCCTTTTGCCAGTCCTCCTACCTCACCCTAGGGTCTGCCTGGCCCTGCCCTCCCTTCCTAGCCCCCCAAGGAGGCTGGAGGGCACCCCTGCGTCCACCAGCAGCAGCTCCTCATGGGCGAGTCTCCTTGGGCCAGTGACACATAGTGTGCCCCGATGGTGCCACGGCAGCCTGGGCCCTCCGCCTTCCTGCTTGGCAGGCACCCCCGCTCCCTGCACCCTCACCGGGGCACCTGTGAGCCCTGAGGGCCAGTGGGGGTCTCACTGCTGCTCCCTCCCACAGCCTAGCCTCGGGCCTCAGGGCTCTGCATCCAAGCGGCCCAGGGCTCCCTGAGGTCTCAGCCCGAGTGGGCCTTTGAGCCTTCGCGTTCTCTGCAGGGTGGGACCTGCCCAAGGGCTGCTGAGGGCTTCCCAGGGGTCCTGTGGGTCCCACCTAGGGGCAAGCTGGTGAGGAAAGTGGGTCCTGCCATGGCGGCCGGGTGGGCTGAGTTTTCGGCATCTCTGGGCCCAACAGCAGGTCCCTGGAGCGGCGCCCACCCCTCCCCCAGGCAGGTGTGAGGGCTCTGATCTGTTTCTCCTTGAGTGACTCATTCTGGGCAGACTTGGCCCTCAGGGCACATGCAAATGGTTGTTTGTTCCACACCGAAAACATGTTTCTTGCCCTCTGAGGCTGTTTCCAGAAATAGCTTGCACGATTCTCCACCTGCAGCTGCAGCCGCCACCCACCCAGTGTGGCCAGGCTGGCCCAGGCCTCCAGATTCGGGGACACCCCCCGCCCCCTCCCCCAGCGTGGCCAGGCTGGCTCAGGCCTCCAGATTCGGGGACA"
1928                )
1929            ))
1930        );
1931        let test = elem.next();
1932        let rangepos = RangePos::new(99826917, 99827017);
1933        assert_eq!(
1934            test,
1935            Some((
1936                &rangepos,
1937                &String::from(
1938                    "CCCCCCCCCCCCAACAGCGTGGCCAGGCTGGCTCAGGCCTCCAGATTCGGGGACACCCCCCCACCACAGCGTGGCCAGGCTGGCTCAGGCCTCCAGATTC"
1939                )
1940            ))
1941        );
1942        let test = elem.next();
1943        let rangepos = RangePos::new(99827017, 99829102);
1944        assert_eq!(
1945            test,
1946            Some((
1947                &rangepos,
1948                &String::from(
1949                    "GGGGACACCCGCCCCCTCCCCCAGGACAGGCCCACTTGGGTTACTGACACTGGGACCACCCTGCAAACGTCAACTTTATTGAATTCAGTGGTTCTGAACTTGTTGCCATCTTTGGGACCAGGACCCAGGGGCAGCCCCCAGGTTGGCAGGAAGGGCAGGGGAGCCAACGCTGGCAGGGCCCCCAGCCAACCCCCACCCCAGAAGCCCCAAGGAGGCTGAGCGGAGGTGGCCCTGGTGGCCTGGGCACAGGCAGCCCGATTGGTACAGGGCCTGTCTGGTGCAGGCCCGCACCTCCCCCACCCTCATGGCCTGGTGGTCCCCACTGTACAGAGAGAACACTGAGGCTCAGCAGGGCCAGGGACATGGCCTGAGGTTACATGGTGATGGGGGCTGGGTCTCCGGGCCTGGGGGCCGTGGTGGGTGCAGCACCCGGACTGCGTGGGCTGTGGCCTCCCTGCTCCCAGCTCTGTCACACCCGTCTCCATCTGAGCCTCCAGCTCCATCTTTCCCGCTGTCCCTGTCTCTGGCCACCCTTCTGTCTCCCTGTCTCTCTGCCTCTCTGAAGGTATCTCCCTGCCCGAATCTCTGTCTCTGTCCCATTGTCGGTGTCTCTGACTCATCTCTGTCAAGCCCGTCTGCTGGGCTTTGTCCCGCCATCTTGCCTGTCTTGGCCTCTCTCTCTTTCTGTGTGTCTCCGTCGGTGCCTCCTTTCTCCATCCATCTCTCCCCCGTGTCTGTCTCTATCCCTCCGTCTCTCTTCCCGTCTATCCCTCCCTCTGTGCCTGTCCCTTTGCTGTGTCCCTTTCTTTGCCTCTGTCTCTCTGTCTGTCTCTTCGTGTCCCTGTGTGTGTCTCTCTCTTCTCTCTGCTTCTCTTTCTGTATCTCTGTCTATATCTCAGCCTCTTTGTGTCCCTGTGTGTGTGTCTCTCTCTTCTCTGTCTTTCCATGTCTCTGTCTATATCTCTGTCTCTCTGCCTCTGTATCTCTGTCTGTCTGTTCGTGTCCCTGTGTATGTCTCTCTCTGTCTCTTTCTGTATCTCTGTCTATATCTGTCTCTCTCATCTGTCTCTTCCTGTGTGTGTCTCTCTGTCTCTCTGCCTCTGTCTCTGTCTCTCTGTCTCTTCATCTCTGTCTGTCTCTGCCTGTCTGTGTCATTTGGTGTCTCTGTTTTTGTATGTCTCTCTGTTTGTCTGTGTCTCTTCCTCTCTGTAGCTCTGCCTCTCTCTATCTCTCCTTATATCTGTCTTTCTCTCTCCCTGTTTCTTTCTCTGTCTCTTTTTGTCTTTCTGAGTCTGTCTCTGTCTCTGTCTCTTCCTCTCTGTATATACCTCTCTGTCTTTCTGTTGCTGTCTGTCTCTGTTTCTCTTCTCCTCTCTCTATCTCTCTTTGTCTGTCTTTCTCTGCCTTTCTAACTCTGTCTTTCTCTGTCTCTCTGTCTCTATCTCAGTCTCTCTTCTTATCTCTCTCTCTGTCTCTCTCACTCTCTGTATCTCTTTGTCTCTGTCTTTCTCTTATCTCTATCGCTCTGTCTCTATCTCTCTTTCTGTCTCTCTGTATCTCTATCTCTGTCTCTCTCATGTCTATCTCTCTGTCTTTCTCTGTCTCTCTGTATCTCTGTCTTTCATCTCTATCTCTATCTCTGTCTTTCTGTCTCTATCTCTGTCTCTCTATCTCTTTCTCTGTCTGTATCTCTCTGTCTCTATCTCTCTCTGTCTTTCTCTGTGTCTCTGTATCTCTGTCTCTATCTCTGTCTCTCTATCTCTCTCTGTCTCTCCCTGTCTCTCTCTATCTCTGTCTCTCCATCCCATGTGGGTCTGTGGGTTTCCCCGAGGCTCAGAGCCCTGCCCCGGTCAGCACAGACAGGGAACAGGGCGAGGGCTGGGTGGTGGCCCAGTGACCTTGGGGGCCAGGCCTTGGGGGTGCAGGTGGGCCCGTGCTGCCGTGCCCCCCACCCACAGACAGGCCCCGGCTCTGGCCCAGCACCCGCTCCGCCGCTCCCAGCTGCAGGCTGAGCTCTGCCCGTTTGCTGCTGGGCCATGTGTGTTTGGGGCCTTTCCTGAGCCAGGCCTTGGGTGGGCCCTGTTT"
1950                )
1951            ))
1952        );
1953        let test = elem.next();
1954        let rangepos = RangePos::new(99829102, 99835825);
1955        assert_eq!(
1956            test,
1957            Some((
1958                &rangepos,
1959                &String::from(
1960                    "CCCCAGACCACCCATGAGCAGAGTGTAGGGCACGTGCCCAGCTCACAGAGGGGACCTCTGAGGCGGGGTGTGGTGGGCACACAGCAGTGAGCCATGAGGCTGGTGGCCCAGAGGCTTGGACATGCCGTGGGCCCCATAGGAAGTGACAGGGCTTGAGGGAAGCTCAGTGTGAGTGTGTGAGCGTGGGTATGAATGTGACAGTGACTCTCTATCTGTCTCTTTGTATCTCTGTCTCTCTGTGTGTATCTTTCTATCTCTGTCTCTCTATATGTCTCTCTATCTCTGTCTCTCTGTATCTCTATCTCTCTGTGTGTATCTTTCTATCTCTGTCTCTCTTTCTTGATCTCTCTCTATCTCTGTCTCTGTAACTCTCTTTATCTCTTACTGCTTCTGTTTCTCTCACTCTGTCTCTGTCTCTCTTTATCTCTGTCTTGCTCTCTCTCTCTGTAACTTTATCTCTGTCTCTCTGTTTCTATCTCTGTTTTTCTCTGTCTCTGTCTGTATCTCTGTCTCTCTTTATCTGTCTCTCTGTCTCTGTGTATCTCTGTCTCTCTGTAACTTTATCTCTGTCTTTTTCTGTCTCTGTGTGTGTCTGTCTCTGTGTCTTTGTTTTTCTCTCTGTCTCTGTCAATGTCTCTTTCTGTATCTGTTTCTTTCTCTCTGTCTCTGTCTCTCTATCTCTGTCTCTATCTCTCTGTCTCTCTGTAACTCCTCATCTCTGTCTCTGTGTCTGCATGTCTCTTTCTGTGTCTCTGTTTCTCTCTCTGTCTCTGTCTCTCTGTGACTCTGTCTCTGTCTCTGTCTCTGTCTTTCTCTGTTACTCTGTCTCTCTCTCTGTCTCTCTGTGACTCTATCTGTTACTCTGTCTCTGTCTCTGTCTCTCTCTGTCTCTCTTTCTCTGTTACTCTGTCTGTGTCTCTGTGTCTCTCTCTCGTCTGTCTTTCTCTGTTACTCTGTCTCTGTCTCTGTGTCTCTGTCTCTCTGCACTGTTTTCCTGGTGAAGGAGAAGCCATGTACCTTCCTGCATGATCTGTGCTCAGCTCACAACCACCCCATGATTGAGGACACCCCTCCTTCTAGAAGGTTCCCAGCTAACAGGTGCAGAAGGAGTGAAGATTGAAATAGGAGACCCCATCTTGAGACCCTCCCGGAACAGTGCCCCTGGGCCGTGTCCCCACTTCGGGACGTGGGATCTCGGTGCCAGGCGTGCGCTGCCTGACCCCGATCCCGTCGGCGTGTGGGCCCTTCCTCAGCCCAGGTGATTCCCTGTGGGCACGGGACTGGGCAGTGCTCCCCACGGCTGCTGGGCCCCAGGACCGGCCTCCAAGGCTGAACCGCGGCTCTGCCAGCTCCACAGACAGCCAGCAGCCCACCCGACAGGGACCAACATGACAAGGTGCTCAGGGCCGCCCTGTGCCCCGGGACCCAGCTGCAGCCTCAGCAGGACAGGGCTGGGGGTGGAGGGCACAGCCGGACTCCTGAGGACAAACGGCCCGCGCCCCGGGTGAACTCAGTGCCGTGGGGAGCCTGTGCACGGGCTGTGGTGGACGCGTCCCTGAGACCCTGTGTGTGCTGTAGGGTGGCTGTGCCCGCTGCCCTCACCACCTGCTGCCCGGGGCCCAGCCTCCCTCGCTGGGGCTGGAGGGTGGATCCAGCAGGGACAGCGTGATGCTCAGAGTCATCGCATAGTGACAAGGACGGGGGCTGCTTTCAAAGCTCCTGAATGTTTTAGTGGCTCAGAGTGAAGGTTCACAGGCCTCGGGGGACATGGCCTAGACTGGGCGTGGGTCCAGCCCCTTGGCAAGCAGTGGGTACATGGCGTGTCCTCCTCCATCCCCATCTGTCTGGTCCCCAGCCACACGCTGAGCCTGGGTCCCCGACTCCCCCCCGACCCGGCAGCTCAGGCCCAAGTCCCTGTCCCCTCCCCACATCCCCTCACAGCAGGTGCTTCAGAGGGGCCCTGGAACGTGACCAGTGTGGGGGAGGTGCTGCGGGGACTGGGGACCACACACGGCACCCGGCCCAGTGCCAGGGGGAGGCGGGTCAGGGCCCAGGTCTCCGAGGCCCAGGCTGTGCGTGTTGGAAGCCCCATTGTTGATGGAGTCAGATGCCCACATCCTCATCCCCGCCTGGGGCCCCTTCTTCAGGAGCCCTGGGTTCAGTCAGAGCCCAGCCAAGGTCCCCTCCCTGGCCAGAGGCCTCACTGTCTCGGTCACCCTCACCTCACTGCCCCCACCTCCTCACCCCTGCCAGCCTGGCCACTCTGGGCTGCTCCTGGCCTCCTTCCCACAAACACGGACCCACAGGTTCTCTAGGCCCTCCAGGACCTTCGCCCACTCCACGGCCCCTGCCCCTGTCCTGTTGACCTCCCAGCGTCCATCCCTGTCCTCGGGCTGCACCCTGCTGGCTATCCTGTTCTCTGACCATCCCCCACTGTCCAGTCCCTCCTGGGAGACCTGAGGCCGTCCTGGGCTTCAGCCCCCAGGGCTGGGGTCGCAGTGCGCAGGGTCCTGGGACCTCCTGCTCCCGCCTCTCCCATGTTGTTACCCACCCCAGCCCGATGTTCGGGGTCCTGTGTGGATCTGTAGGTTTCCCCGAGGCTCAGAGTCCTGCCCCGTCCAGCACAGACGGGGAACAGGGCGAGGGCTGGGTGGTGGCCCAGTGACCTCGGGGGCCAGGCCTTGTAGGTGCAGGTGGGCCCGTGCTGCCGTGCCCCCCACCCACAGACAGGCCCCGACTCTGGCCCAGCGCCCGCTCGGCCGCTCCCAGCTGCAGGCTGAGGTCTCCCCATTTGCTCCTGGGCCATGTGTGTTTGGGTGTGAGTGTGGGTATGGATGTGACAGTGACTTAGTGTGTGGCTGTGAGCGTGGGTATGTTTCTGTGTGTTTGTGTGTGAATGTTGTATAATAGTCGTGGTGTGTGTTTGTGAGAGTGACTGTGTGAGAGGGGCTTGCAGCTGAGTTCCTGGGCCCATCTTGCTGCCTCTTTCTCTCCCTGTGTGTTCTCTGCCTCTGTTGTGTTCTCTCTGCATGTCTGTCTCCATGTCTCTTTTTCCCTGTTCCCATCTCCTCCCTTTTTCTCCCATCTCTGTCTCTGTTTCTTATCTATCTCATCTCATCTCTCTCTTTCTGTCTCTTGTGTCTCTGTCCCTCCCCATCCCTGTCTCTTATCTCTCTCCATCCCCATCTCTCTCTCTGTGTCTGTCTTTGTCTCTGTCTCTATGTCTCTTGTCTCTCCCCATCCCTGTCTCTCTCTATGTCTCTGTGTCTCTTATCTCTCCCCATCCCTGTCTCTCTATGTCTCTGTGTCTCTTATCTCTCCTTGTCCTTGTCTTTCTCTGTCTACGTCTCTGTGTCTCTCTCCATCCCTGTCTCTCTCTATGTCTCTGTGTCTCTTATCTCTCCCTATCCCTGTCTCTCTATGTCTCTTGTCTCTCCCCATCCCTGTCTCTCTCTCTCTATGTCTCTGTGTCTCTTATCTCTCCCCATCCCTGTCTCTCTCTATGTCTCTTCATCTCTTATCTCTCTCCCCATCCCTGTCTCTATGTCTCTGTGTCTCTTATCTCTCCCCATCCTTGTCTCTGTCTATGTCTCTGTGTCTCTTGTCTCTCCCTGTCCCTGTCTCTCTCTATGTCTCTGTGTCTCTCTGGGCCCCTGGTCCAATGTCCCCTTCCCAGAACCCCTGTTTCCCTGGTGTGGGGTGCAGGTCCTTCTGTGGCCCTGTGGGCCGTGCTTGTGCTGGGCACAGCCTGCCAGGGCAGCCACTCAAGCCCCAGGGCTGGGCACTGCGTCCTGGCTCTGGCCAAGGGCCCTGGGGAGAGCTGAGGGAGGTGCATGCAGGGTGTGAGGCCCACCACAGTCACTGCCAGATGCTCAGTGCTGGTGCTTCCCTGGGTCTGCTGTGTGGTGGGCACAGCCCTCGTGAGGGCTGCCCATGGAGGAGGCCTGCCGCCTAGAGAGCCCGGACAGGGGGACAATGGCCTGTGCTGACCCTGGCGGAACCCTGGCTGGCCCCAGATGACCCCAGATGGCCCTGGCTGACCCTGGCGGAACCCAGATGACCCTGGCTGACCCTGGCTGGCCCTGGCTGACCCCAGATGACCCTGGCTGACCCTGGCTGATCCTGGCTGACCCTGGCTGACCTCTGCCTAACCCTGGACCTGGAAAGCCCTAGCTGACCCCGGGCTGGTTGGGGCTGGGCCTCCCTGTGGCTGCAGCCCCTCGCTCAGGCCCCAGGCACACCTGGCCAGGTCTCGGTTTTGGGGCATGTTTCTCAGAACAGCAGTTCTCTGGCTGGAACACCTGGCCTGGGCTGTGTTCACAATGACTCAGCCGCCCCACAGGGCTATTTTGGATATTTCTGCAGGTGATGGGGTACAAGAGGCTTCAGGAGAGAGAGAAAAGCAAGAGAATACAAACAGCATGGCCTCCCCCGACCTTCCTGTCCCCACTCCTGTACTGTACCCCCTCCCCAGTGCTAAGTCGAGACCTGGCGACCCCTTAGGGGCTGGGGCTGGGTGTAGCTCACAGGGCCTGGGCTGGTCCTCTCCCCACCAAGTCCTCCTGGGGCCTACACACCCCTCTGAGCCTGGAAAAATGGAGCAAGCCATTGGGGTCATTTCTTCATCTACCAGTGAGTACATGCACTGAGAGGGTCTCGGCTCCCCTGGAGGCCTCCCTCCACCACTGCAGGTCACTTACTCATGAGGGCCAAGGCTCAGAAATCAGACAGGACTCAGTGTCTAGTCAGACTGATACATGCTCAGAAAAGGAATCAGATTTCAAAATGAATATGTATAAGAAAAGAACCGGGGATCAGTGATCAGGAACAGGGATCCATGATCTGGTCCAGGGCTCAGCGGTCAGGAACAGGGCCCAGCGATCAGGACCAGGGCTCAGTAATCAGGACCAGGGCCCAGTGATCAGGACCAGGGCCCAGCGATTGGGTCCAGGGCTCAGTGATCAGGAACAGGGCTCAGTGATCAGGACCAGGGCCCAGTGATCAGGAACAGGGGCCAGTGACTGGGTCCAGGGCTCAGTAATCAGGACCAGGGCTCAGTGATCAGGACCAGGGCTCAGTGATCAGGAACAGGGGTTAGTGATCAGGAACAGGGCTCAGTGATCAGGACCAGCATTCAGTGATCAGGACCAGGGCTCAGTGATCAGGAACAGGGCTCAGTGATCAGGAACAGGGGTTAGTGATCAGGAACAGGGCTCAGTGATCAGGACCAGCACTCAGTGATCAGGACCAGGGCCCAGTGATCAGGAACAGGGGCCAGTGACTGGGTCCAGGGCTCAGTAATCAGGACCAGGGCTCAGTGATCAGGACCAGGGCTCAGTGATCAGGAATAGGGGTTAGTGATCAGGAACAGGGCTCAGTGATCAGGACCAGGGCTCAGTGATCAGGAACAGGGCTCAGTGATCAGGAACAGTGGTCAGTGATCAGGAACAGGGGTTAGTGATCAGGAACAGGGCTCAGTGATCGGGACCAGGGCTCAGTGATCAGGACCAGGGCCCAGTGATTGTGTCCAGGGCTCAGTGATCAGGACCAGGGCTCAGTGATCAGGAACAGGGCTCAGTGATCAGGAACAGGGGTTAGTGATCAGGAACAGGGCTCAGTGATCAGGACCAGCACTCAGTGATCAGGACCAGGGCCCAGTGATCAGGACCAGGGCCCAGCGATTGGGTCCAGGGCTCAGTAATCAGGACCAGGGCCCAGTGATCAGGAACAGGGCTCAGTGATCAGGAACAGGGGTTAGTGATCAGGAACAGGGGTTAGTGATCAGGAACAGGGCTCAGTGATCAGGAACAGGGCTCAGAGATCAGGACCAGGGCCCAGCGATTGGGTCCAGAGCTCAGTGATCAGGAACAGGGCCCAGCGATCAGGACCAGGGCTCAGTAATCAGGACCAGGGCTCAGTGATCAGGACCAGGGCCCAGTGATCAGGAACAGGGGCCAGTGACTGGGTCCAGGGCTCAGTAATCAGGACCAGGGCTCAGTGATCAGGAACAGCGGTTAGTGATCAGGAACAGGGCTCAGTGATCAGGACCAGCGCTCAGTGATCAGGAGCAGGGCTCAGTAATCAGGACCAGGGCCCAGTGATCAGGAACAGGGCTCAGTGATCAGGAACAGGGGTTAGTGATCAGGAACAGGGCTCAGTGATCAGGACCAGGGCCCAGCGATTGGGTCCAGAGCTCAGTGATCAGGAACAGGGCCCAGCGATCAGGACCAGGGCTCAGTAATCAGGACCAGGGCTCAGTGATCAGTACCAGGGCCCAGCGATTGGGTCCAGGGCTCAGTGATCAGGACCAGGGCCCAGCGATTGGGTCCAGGGCTCAGTGATCAGGAACAGGGCCCAGCGATCAGGACCAGGGCTCAGTAATCAGGACCAGGGCTCAGTGATCAGGACCAGGGCCCAGCGATTGGGTCCAGGGCTCAGTGATCAGGAACAGGGCCCAGCGATTGGGTCCAGGGCTCAGTGATCAGGAACAGGGCCCAGCGATCAGGACCAGGGCTCAGTAATCAGGACCAGGGCTCAGTGATCAGGACCAGGGCCCAGCGATTGGGTCCAGGGCTCAGTGATCAGGACCAGGGCCCAGCGATTGGGTCCAGGGCTCAGTGATCAGGAACAGGGGTTAGTGATCAGGAACAGGGCTCAGTGATCAGGAACAGGGGTTAGTGATCAGGAACAGGGCTCAGTGATCAGGACCAGGGCCCAGTGATT"
1961                )
1962            ))
1963        );
1964        assert!(elem.next().is_none());
1965    }
1966    #[test]
1967    fn testseqreverse() {
1968        let mut read = crate::bam::Reader::from_path("test/locus.bam").unwrap();
1969        let elem = read.records().filter_map(Result::ok).nth(8).unwrap();
1970        let val = elem.matched_sequence().unwrap();
1971        assert!(val.isfullymatched(99820441..=99821296).is_some());
1972        assert!(val.isfullymatched(99821296..=99821298).is_none());
1973        let mut elem = val.gethash().iter();
1974        let test = elem.next();
1975        let rangepos = RangePos::new(99820441, 99821297);
1976        assert_eq!(
1977            test,
1978            Some((
1979                &rangepos,
1980                &String::from(
1981                    "ACCCCCATCCACACACACCCAGAGACACACAGACACCCACAGCCACACACTCACACTCACGAACTTATCCAGTCACGTCCCACACACTCCCACCCAACCCATACACCACACACCTACACAACCCATACACCACACACACTCACAAACTATATACCACACACACACCAACCATACACCTATATACACTCACACACCCATATACCACACACTCACACACAACCCATACACCACACGCACACAACCCATACACCTATACACACTCACACCTACAAACTATATACTACACACTCACACACAACCCATACACCTATACACACACACCCATATACCACACACAACCCATACACCACACACACAAACCATATACCACACACTCACACAACCCATACACCTATACACACTCATACCCATATACCACATACAACCAATATACCACACACACACAACCCATACACCTATACACACACACCTATACACCACACACAGCCCATACACTACACAATCACACCACAAACTGTATACCACACACTCACACATAACCCATACACCTATACACACACACCCATATACCACACACACAACCTGTGCACCTACACACACACATACACCACACACACACAACTCCTACACCTACACACACCCACCACCCATACACACACAGCCTATACACCTACACACACTCATACACTCATATAGCACACACACAACCCATATACCACACACACAACCCACATACCTATACACACACGCCCATACACCACACACTCACACAACCCATGCACCACATACACCCACAAACTATATGCTACACGCTCACACACAACCCATACACCTATACACAATCCCACAACCCATA"
1982                )
1983            ))
1984        );
1985        let test = elem.next();
1986        let rangepos = RangePos::new(99821297, 99822851);
1987        assert_eq!(
1988            test,
1989            Some((
1990                &rangepos,
1991                &String::from(
1992                    "CACACTTACACAACCTATACACCACACACACTCACAATCTGTATACCACACACACAACCCATACAGTTATACACACACACCCATATACCACACACACACAACCCATATACCACACACTCACACACAAACCATACATCTATACACATACCCATATGCCACACATACAACCCATACACCACACACTCACACACAACACATACACCACACACACAACCCATAGAACACAAACACAAGTCATAACCACACACACAGCCCATATACCTATACACATTCACACACACAACCCATACACTACACACACAACACATACACCTATACACACTCACACTCAATTCATACACCACACACACACAGCCCATACATCTATACACAAACTCACACACAATCCATATACCACAAACTCACACACAACGCATACACCTATACACACACACGCAACTCATACAGCACACACTCACACAACCCACAGACCATAAACACACACAAGCCATAACCACACACAAACCCATACACCTATACACACACTCATAAACAAGCCATACACCCCTACACAACCCATACACCACACACTCACAACCCATACACCTATATACACACACAACCATATACCACAAACTCACGCTCAACACATACACCTATACACACACACAACTCATACACCACACACTCATACACAACGCACAGACCACATACACAAGCCATAACCACACACACACAACCCGTACACATATATACACACTAATAAACAAGCCATACACCTACACATACAACCCATACACCACACATTCACACATAACCCATACACCTATACACACACACACACAACCCATATACCACAAACACACACAACCTATACACACATACAACCCATACACCACACACACAACACATACACACCACACACACACAGAATACTCATACACACACCCATACACCACCCCCACACAGAACCCATACACCACACACACACAACCTATACACCTATACACACACTCACACACACAACTCATATACCACAAACACACACAACACATACACCTATGCACACACACAACCCATACACCACACATTCACATACAACCCATACACCACACACACACAACACATACATGAAACATACATACAACCCACACACCACCCACTCATACACAACCTATACACCACACACACAACTCATACACCTATACACACACAACACATACACCTATCATACACTCACAACACATACACCTCCTATACACACACAACACACACACTTCCTATACACACAACCCACACGCCTATACACACATCCTCACTCACACTCACCCTCACATTCATATACTCACTAACACACTTCCACACTCACACCCTCACCCACACTTACACCCCCACCCACACTCAAACCCCGACGCTAAGTCACTGTCACATTTGTACCCATGCTCACACGCTCACACGCTCACACACTCACCCCCCACCAGCTCCAGGGCTCACTGGTGTGTGCCCACCAAACCCCCCTCGGGGGTCCCCTCGGTAAGCCGACAGTGCTCTGCTCATCGGTGGCCTGGGGAAACA"
1993                )
1994            ))
1995        );
1996    }
1997    #[test]
1998    fn spliced_reads() {
1999        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
2000        let mut it = bam.records();
2001        let blocks: Vec<_> = it.next().expect("iter").unwrap().aligned_blocks().collect();
2002        //6S45M - 0
2003        assert!(blocks[0] == [16050676, 16050721]);
2004
2005        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2006        //7M2D44M - 1
2007        assert!(blocks[0] == [16096878, 16096885]);
2008        //7M2D44M - 1
2009        assert!(blocks[1] == [16096887, 16096931]);
2010
2011        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2012        //29M2D22M - 2
2013        assert!(blocks[0] == [16097145, 16097174]);
2014        //29M2D22M - 2
2015        assert!(blocks[1] == [16097176, 16097198]);
2016
2017        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2018        //51M - 3
2019        assert!(blocks[0] == [16117350, 16117401]);
2020
2021        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2022        //51M - 4
2023        assert!(blocks[0] == [16118483, 16118534]);
2024
2025        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2026        //51M - 5
2027        assert!(blocks[0] == [16118499, 16118550]);
2028
2029        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2030        //51M - 6
2031        assert!(blocks[0] == [16118499, 16118550]);
2032
2033        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2034        //51M - 7
2035        assert!(blocks[0] == [16118499, 16118550]);
2036
2037        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2038        //51M - 8
2039        assert!(blocks[0] == [16123411, 16123462]);
2040
2041        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2042        //6S45M - 9
2043        assert!(blocks[0] == [16123417, 16123462]);
2044
2045        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2046        //41M10S - 10
2047        assert!(blocks[0] == [16165860, 16165901]);
2048
2049        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2050        //51M - 11
2051        assert!(blocks[0] == [16180871, 16180922]);
2052
2053        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2054        //51M - 12
2055        assert!(blocks[0] == [16189705, 16189756]);
2056
2057        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2058        //51M - 13
2059        assert!(blocks[0] == [16231271, 16231322]);
2060
2061        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2062        //51M - 14
2063        assert!(blocks[0] == [16237657, 16237708]);
2064
2065        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2066        //9S42M - 15
2067        assert!(blocks[0] == [16255012, 16255054]);
2068
2069        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2070        //51M - 16
2071        assert!(blocks[0] == [16255391, 16255442]);
2072
2073        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2074        //50M1S - 17
2075        assert!(blocks[0] == [16255392, 16255442]);
2076
2077        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2078        //45M6S - 18
2079        assert!(blocks[0] == [16256084, 16256129]);
2080
2081        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2082        //3S48M - 19
2083        assert!(blocks[0] == [16256224, 16256272]);
2084
2085        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2086        //42M9S - 20
2087        assert!(blocks[0] == [16325199, 16325241]);
2088
2089        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2090        //13S38M - 21
2091        assert!(blocks[0] == [16352865, 16352903]);
2092
2093        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2094        //44M7S - 22
2095        assert!(blocks[0] == [16352968, 16353012]);
2096
2097        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2098        //5S46M - 23
2099        assert!(blocks[0] == [16414998, 16415044]);
2100
2101        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2102        //23M4I24M - 24
2103        assert!(blocks[0] == [17031591, 17031614]);
2104        //23M4I24M - 24
2105        assert!(blocks[1] == [17031614, 17031638]);
2106
2107        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2108        //18M1I32M - 25
2109        assert!(blocks[0] == [17057382, 17057400]);
2110        //18M1I32M - 25
2111        assert!(blocks[1] == [17057400, 17057432]);
2112
2113        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2114        //17M2183N34M - 26
2115        assert!(blocks[0] == [17092766, 17092783]);
2116        //17M2183N34M - 26
2117        assert!(blocks[1] == [17094966, 17095000]);
2118
2119        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2120        //1M2183N50M - 27
2121        assert!(blocks[0] == [17092782, 17092783]);
2122        //1M2183N50M - 27
2123        assert!(blocks[1] == [17094966, 17095016]);
2124
2125        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2126        //1M2183N50M - 28
2127        assert!(blocks[0] == [17092782, 17092783]);
2128        //1M2183N50M - 28
2129        assert!(blocks[1] == [17094966, 17095016]);
2130
2131        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2132        //9S33M9S - 29
2133        assert!(blocks[0] == [17137287, 17137320]);
2134
2135        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2136        //2S48M1S - 30
2137        assert!(blocks[0] == [17306238, 17306286]);
2138
2139        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2140        //4S45M2S - 31
2141        assert!(blocks[0] == [17561868, 17561913]);
2142
2143        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2144        //41M11832N10M - 32
2145        assert!(blocks[0] == [17566078, 17566119]);
2146        //41M11832N10M - 32
2147        assert!(blocks[1] == [17577951, 17577961]);
2148
2149        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2150        //11M11832N25M710N15M - 33
2151        assert!(blocks[0] == [17566108, 17566119]);
2152        //11M11832N25M710N15M - 33
2153        assert!(blocks[1] == [17577951, 17577976]);
2154        //11M11832N25M710N15M - 33
2155        assert!(blocks[2] == [17578686, 17578701]);
2156
2157        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2158        //8M11832N25M710N18M - 34
2159        assert!(blocks[0] == [17566111, 17566119]);
2160        //8M11832N25M710N18M - 34
2161        assert!(blocks[1] == [17577951, 17577976]);
2162        //8M11832N25M710N18M - 34
2163        assert!(blocks[2] == [17578686, 17578704]);
2164
2165        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2166        //8M11832N25M710N18M - 35
2167        assert!(blocks[0] == [17566111, 17566119]);
2168        //8M11832N25M710N18M - 35
2169        assert!(blocks[1] == [17577951, 17577976]);
2170        //8M11832N25M710N18M - 35
2171        assert!(blocks[2] == [17578686, 17578704]);
2172
2173        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2174        //8M11832N25M710N18M - 36
2175        assert!(blocks[0] == [17566111, 17566119]);
2176        //8M11832N25M710N18M - 36
2177        assert!(blocks[1] == [17577951, 17577976]);
2178        //8M11832N25M710N18M - 36
2179        assert!(blocks[2] == [17578686, 17578704]);
2180
2181        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2182        //8M11832N25M710N18M - 37
2183        assert!(blocks[0] == [17566111, 17566119]);
2184        //8M11832N25M710N18M - 37
2185        assert!(blocks[1] == [17577951, 17577976]);
2186        //8M11832N25M710N18M - 37
2187        assert!(blocks[2] == [17578686, 17578704]);
2188
2189        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2190        //7M11832N25M710N19M - 38
2191        assert!(blocks[0] == [17566112, 17566119]);
2192        //7M11832N25M710N19M - 38
2193        assert!(blocks[1] == [17577951, 17577976]);
2194        //7M11832N25M710N19M - 38
2195        assert!(blocks[2] == [17578686, 17578705]);
2196
2197        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2198        //6M11832N25M710N20M - 39
2199        assert!(blocks[0] == [17566113, 17566119]);
2200        //6M11832N25M710N20M - 39
2201        assert!(blocks[1] == [17577951, 17577976]);
2202        //6M11832N25M710N20M - 39
2203        assert!(blocks[2] == [17578686, 17578706]);
2204
2205        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2206        //6M11832N25M710N20M - 40
2207        assert!(blocks[0] == [17566113, 17566119]);
2208        //6M11832N25M710N20M - 40
2209        assert!(blocks[1] == [17577951, 17577976]);
2210        //6M11832N25M710N20M - 40
2211        assert!(blocks[2] == [17578686, 17578706]);
2212
2213        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2214        //1S44M1467N6M - 41
2215        assert!(blocks[0] == [17579733, 17579777]);
2216        //1S44M1467N6M - 41
2217        assert!(blocks[1] == [17581244, 17581250]);
2218
2219        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2220        //2M1514N48M95N1M - 42
2221        assert!(blocks[0] == [17581369, 17581371]);
2222        //2M1514N48M95N1M - 42
2223        assert!(blocks[1] == [17582885, 17582933]);
2224        //2M1514N48M95N1M - 42
2225        assert!(blocks[2] == [17583028, 17583029]);
2226
2227        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2228        //1M1514N48M95N2M - 43
2229        assert!(blocks[0] == [17581370, 17581371]);
2230        //1M1514N48M95N2M - 43
2231        assert!(blocks[1] == [17582885, 17582933]);
2232        //1M1514N48M95N2M - 43
2233        assert!(blocks[2] == [17583028, 17583030]);
2234
2235        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2236        //1M1514N48M95N2M - 44
2237        assert!(blocks[0] == [17581370, 17581371]);
2238        //1M1514N48M95N2M - 44
2239        assert!(blocks[1] == [17582885, 17582933]);
2240        //1M1514N48M95N2M - 44
2241        assert!(blocks[2] == [17583028, 17583030]);
2242
2243        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2244        //1S22M95N28M - 45
2245        assert!(blocks[0] == [17582911, 17582933]);
2246        //1S22M95N28M - 45
2247        assert!(blocks[1] == [17583028, 17583056]);
2248
2249        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2250        //37M538N13M1S - 46
2251        assert!(blocks[0] == [17588621, 17588658]);
2252        //37M538N13M1S - 46
2253        assert!(blocks[1] == [17589196, 17589209]);
2254
2255        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2256        //37M538N13M1S - 47
2257        assert!(blocks[0] == [17588621, 17588658]);
2258        //37M538N13M1S - 47
2259        assert!(blocks[1] == [17589196, 17589209]);
2260
2261        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2262        //37M538N13M1S - 48
2263        assert!(blocks[0] == [17588621, 17588658]);
2264        //37M538N13M1S - 48
2265        assert!(blocks[1] == [17589196, 17589209]);
2266
2267        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2268        //1S25M1D25M - 49
2269        assert!(blocks[0] == [17591770, 17591795]);
2270        //1S25M1D25M - 49
2271        assert!(blocks[1] == [17591796, 17591821]);
2272
2273        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2274        //24M1D24M3S - 50
2275        assert!(blocks[0] == [17593855, 17593879]);
2276        //24M1D24M3S - 50
2277        assert!(blocks[1] == [17593880, 17593904]);
2278
2279        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2280        //16M1D28M7S - 51
2281        assert!(blocks[0] == [17593863, 17593879]);
2282        //16M1D28M7S - 51
2283        assert!(blocks[1] == [17593880, 17593908]);
2284
2285        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2286        //11S7M1I32M - 52
2287        assert!(blocks[0] == [17596476, 17596483]);
2288        //11S7M1I32M - 52
2289        assert!(blocks[1] == [17596483, 17596515]);
2290
2291        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2292        //5S9M1892N37M - 53
2293        assert!(blocks[0] == [17624012, 17624021]);
2294        //5S9M1892N37M - 53
2295        assert!(blocks[1] == [17625913, 17625950]);
2296
2297        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2298        //2S9M1892N40M - 54
2299        assert!(blocks[0] == [17624012, 17624021]);
2300        //2S9M1892N40M - 54
2301        assert!(blocks[1] == [17625913, 17625953]);
2302
2303        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2304        //1S7M3D19M2285N24M - 55
2305        assert!(blocks[0] == [31796700, 31796707]);
2306        //1S7M3D19M2285N24M - 55
2307        assert!(blocks[1] == [31796710, 31796729]);
2308        //1S7M3D19M2285N24M - 55
2309        assert!(blocks[2] == [31799014, 31799038]);
2310
2311        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2312        //14M799N28M13881N7M2S - 56
2313        assert!(blocks[0] == [36722692, 36722706]);
2314        //14M799N28M13881N7M2S - 56
2315        assert!(blocks[1] == [36723505, 36723533]);
2316        //14M799N28M13881N7M2S - 56
2317        assert!(blocks[2] == [36737414, 36737421]);
2318
2319        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
2320        //4S21M1696N23M2331N3M - 57
2321        assert!(blocks[0] == [44587963, 44587984]);
2322        //4S21M1696N23M2331N3M - 57
2323        assert!(blocks[1] == [44589680, 44589703]);
2324        //4S21M1696N23M2331N3M - 57
2325        assert!(blocks[2] == [44592034, 44592037]);
2326    }
2327
2328    #[test]
2329    fn test_introns() {
2330        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
2331        let mut it = bam.records();
2332
2333        //6S45M - 0
2334        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2335        assert_eq!(introns.len(), 0);
2336        //7M2D44M - 1
2337        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2338        assert_eq!(introns.len(), 0);
2339        //29M2D22M - 2
2340        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2341        assert_eq!(introns.len(), 0);
2342        //51M - 3
2343        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2344        assert_eq!(introns.len(), 0);
2345        //51M - 4
2346        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2347        assert_eq!(introns.len(), 0);
2348        //51M - 5
2349        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2350        assert_eq!(introns.len(), 0);
2351        //51M - 6
2352        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2353        assert_eq!(introns.len(), 0);
2354        //51M - 7
2355        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2356        assert_eq!(introns.len(), 0);
2357        //51M - 8
2358        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2359        assert_eq!(introns.len(), 0);
2360        //6S45M - 9
2361        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2362        assert_eq!(introns.len(), 0);
2363        //41M10S - 10
2364        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2365        assert_eq!(introns.len(), 0);
2366        //51M - 11
2367        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2368        assert_eq!(introns.len(), 0);
2369        //51M - 12
2370        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2371        assert_eq!(introns.len(), 0);
2372        //51M - 13
2373        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2374        assert_eq!(introns.len(), 0);
2375        //51M - 14
2376        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2377        assert_eq!(introns.len(), 0);
2378        //9S42M - 15
2379        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2380        assert_eq!(introns.len(), 0);
2381        //51M - 16
2382        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2383        assert_eq!(introns.len(), 0);
2384        //50M1S - 17
2385        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2386        assert_eq!(introns.len(), 0);
2387        //45M6S - 18
2388        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2389        assert_eq!(introns.len(), 0);
2390        //3S48M - 19
2391        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2392        assert_eq!(introns.len(), 0);
2393        //42M9S - 20
2394        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2395        assert_eq!(introns.len(), 0);
2396        //13S38M - 21
2397        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2398        assert_eq!(introns.len(), 0);
2399        //44M7S - 22
2400        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2401        assert_eq!(introns.len(), 0);
2402        //5S46M - 23
2403        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2404        assert_eq!(introns.len(), 0);
2405        //23M4I24M - 24
2406        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2407        assert_eq!(introns.len(), 0);
2408        //18M1I32M - 25
2409        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2410        assert_eq!(introns.len(), 0);
2411        //17M2183N34M - 26
2412        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2413        assert_eq!(introns.len(), 1);
2414        assert_eq!(introns[0], [17092783, 17094966]);
2415        //1M2183N50M - 27
2416        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2417        assert_eq!(introns.len(), 1);
2418        assert_eq!(introns[0], [17092783, 17094966]);
2419        //1M2183N50M - 28
2420        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2421        assert_eq!(introns.len(), 1);
2422        assert_eq!(introns[0], [17092783, 17094966]);
2423        //9S33M9S - 29
2424        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2425        assert_eq!(introns.len(), 0);
2426        //2S48M1S - 30
2427        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2428        assert_eq!(introns.len(), 0);
2429        //4S45M2S - 31
2430        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2431        assert_eq!(introns.len(), 0);
2432        //41M11832N10M - 32
2433        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2434        assert_eq!(introns.len(), 1);
2435        assert_eq!(introns[0], [17566119, 17577951]);
2436        //11M11832N25M710N15M - 33
2437        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2438        assert_eq!(introns.len(), 2);
2439        assert_eq!(introns[0], [17566119, 17577951]);
2440        assert_eq!(introns[1], [17577976, 17578686]);
2441        //8M11832N25M710N18M - 34
2442        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2443        assert_eq!(introns.len(), 2);
2444        assert_eq!(introns[0], [17566119, 17577951]);
2445        assert_eq!(introns[1], [17577976, 17578686]);
2446        //8M11832N25M710N18M - 35
2447        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2448        assert_eq!(introns.len(), 2);
2449        assert_eq!(introns[0], [17566119, 17577951]);
2450        assert_eq!(introns[1], [17577976, 17578686]);
2451        //8M11832N25M710N18M - 36
2452        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2453        assert_eq!(introns.len(), 2);
2454        assert_eq!(introns[0], [17566119, 17577951]);
2455        assert_eq!(introns[1], [17577976, 17578686]);
2456        //8M11832N25M710N18M - 37
2457        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2458        assert_eq!(introns.len(), 2);
2459        assert_eq!(introns[0], [17566119, 17577951]);
2460        assert_eq!(introns[1], [17577976, 17578686]);
2461        //7M11832N25M710N19M - 38
2462        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2463        assert_eq!(introns.len(), 2);
2464        assert_eq!(introns[0], [17566119, 17577951]);
2465        assert_eq!(introns[1], [17577976, 17578686]);
2466        //6M11832N25M710N20M - 39
2467        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2468        assert_eq!(introns.len(), 2);
2469        assert_eq!(introns[0], [17566119, 17577951]);
2470        assert_eq!(introns[1], [17577976, 17578686]);
2471        //6M11832N25M710N20M - 40
2472        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2473        assert_eq!(introns.len(), 2);
2474        assert_eq!(introns[0], [17566119, 17577951]);
2475        assert_eq!(introns[1], [17577976, 17578686]);
2476        //1S44M1467N6M - 41
2477        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2478        assert_eq!(introns.len(), 1);
2479        assert_eq!(introns[0], [17579777, 17581244]);
2480        //2M1514N48M95N1M - 42
2481        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2482        assert_eq!(introns.len(), 2);
2483        assert_eq!(introns[0], [17581371, 17582885]);
2484        assert_eq!(introns[1], [17582933, 17583028]);
2485        //1M1514N48M95N2M - 43
2486        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2487        assert_eq!(introns.len(), 2);
2488        assert_eq!(introns[0], [17581371, 17582885]);
2489        assert_eq!(introns[1], [17582933, 17583028]);
2490        //1M1514N48M95N2M - 44
2491        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2492        assert_eq!(introns.len(), 2);
2493        assert_eq!(introns[0], [17581371, 17582885]);
2494        assert_eq!(introns[1], [17582933, 17583028]);
2495        //1S22M95N28M - 45
2496        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2497        assert_eq!(introns.len(), 1);
2498        assert_eq!(introns[0], [17582933, 17583028]);
2499        //37M538N13M1S - 46
2500        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2501        assert_eq!(introns.len(), 1);
2502        assert_eq!(introns[0], [17588658, 17589196]);
2503        //37M538N13M1S - 47
2504        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2505        assert_eq!(introns.len(), 1);
2506        assert_eq!(introns[0], [17588658, 17589196]);
2507        //37M538N13M1S - 48
2508        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2509        assert_eq!(introns.len(), 1);
2510        assert_eq!(introns[0], [17588658, 17589196]);
2511        //1S25M1D25M - 49
2512        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2513        assert_eq!(introns.len(), 0);
2514        //24M1D24M3S - 50
2515        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2516        assert_eq!(introns.len(), 0);
2517        //16M1D28M7S - 51
2518        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2519        assert_eq!(introns.len(), 0);
2520        //11S7M1I32M - 52
2521        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2522        assert_eq!(introns.len(), 0);
2523        //5S9M1892N37M - 53
2524        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2525        assert_eq!(introns.len(), 1);
2526        assert_eq!(introns[0], [17624021, 17625913]);
2527        //2S9M1892N40M - 54
2528        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2529        assert_eq!(introns.len(), 1);
2530        assert_eq!(introns[0], [17624021, 17625913]);
2531        //1S7M3D19M2285N24M - 55
2532        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2533        assert_eq!(introns.len(), 1);
2534        assert_eq!(introns[0], [31796729, 31799014]);
2535        //14M799N28M13881N7M2S - 56
2536        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2537        assert_eq!(introns.len(), 2);
2538        assert_eq!(introns[0], [36722706, 36723505]);
2539        assert_eq!(introns[1], [36723533, 36737414]);
2540        //4S21M1696N23M2331N3M - 57
2541        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
2542        assert_eq!(introns.len(), 2);
2543        assert_eq!(introns[0], [44587984, 44589680]);
2544        assert_eq!(introns[1], [44589703, 44592034]);
2545    }
2546
2547    #[test]
2548    fn test_aligned_pairs() {
2549        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
2550        let mut it = bam.records();
2551
2552        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
2553        assert_eq!(
2554            pairs,
2555            vec![
2556                [6, 16050676],
2557                [7, 16050677],
2558                [8, 16050678],
2559                [9, 16050679],
2560                [10, 16050680],
2561                [11, 16050681],
2562                [12, 16050682],
2563                [13, 16050683],
2564                [14, 16050684],
2565                [15, 16050685],
2566                [16, 16050686],
2567                [17, 16050687],
2568                [18, 16050688],
2569                [19, 16050689],
2570                [20, 16050690],
2571                [21, 16050691],
2572                [22, 16050692],
2573                [23, 16050693],
2574                [24, 16050694],
2575                [25, 16050695],
2576                [26, 16050696],
2577                [27, 16050697],
2578                [28, 16050698],
2579                [29, 16050699],
2580                [30, 16050700],
2581                [31, 16050701],
2582                [32, 16050702],
2583                [33, 16050703],
2584                [34, 16050704],
2585                [35, 16050705],
2586                [36, 16050706],
2587                [37, 16050707],
2588                [38, 16050708],
2589                [39, 16050709],
2590                [40, 16050710],
2591                [41, 16050711],
2592                [42, 16050712],
2593                [43, 16050713],
2594                [44, 16050714],
2595                [45, 16050715],
2596                [46, 16050716],
2597                [47, 16050717],
2598                [48, 16050718],
2599                [49, 16050719],
2600                [50, 16050720]
2601            ]
2602        );
2603        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
2604        assert_eq!(
2605            pairs,
2606            vec![
2607                [0, 16096878],
2608                [1, 16096879],
2609                [2, 16096880],
2610                [3, 16096881],
2611                [4, 16096882],
2612                [5, 16096883],
2613                [6, 16096884],
2614                [7, 16096887],
2615                [8, 16096888],
2616                [9, 16096889],
2617                [10, 16096890],
2618                [11, 16096891],
2619                [12, 16096892],
2620                [13, 16096893],
2621                [14, 16096894],
2622                [15, 16096895],
2623                [16, 16096896],
2624                [17, 16096897],
2625                [18, 16096898],
2626                [19, 16096899],
2627                [20, 16096900],
2628                [21, 16096901],
2629                [22, 16096902],
2630                [23, 16096903],
2631                [24, 16096904],
2632                [25, 16096905],
2633                [26, 16096906],
2634                [27, 16096907],
2635                [28, 16096908],
2636                [29, 16096909],
2637                [30, 16096910],
2638                [31, 16096911],
2639                [32, 16096912],
2640                [33, 16096913],
2641                [34, 16096914],
2642                [35, 16096915],
2643                [36, 16096916],
2644                [37, 16096917],
2645                [38, 16096918],
2646                [39, 16096919],
2647                [40, 16096920],
2648                [41, 16096921],
2649                [42, 16096922],
2650                [43, 16096923],
2651                [44, 16096924],
2652                [45, 16096925],
2653                [46, 16096926],
2654                [47, 16096927],
2655                [48, 16096928],
2656                [49, 16096929],
2657                [50, 16096930]
2658            ]
2659        );
2660        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
2661        assert_eq!(
2662            pairs,
2663            vec![
2664                [0, 16097145],
2665                [1, 16097146],
2666                [2, 16097147],
2667                [3, 16097148],
2668                [4, 16097149],
2669                [5, 16097150],
2670                [6, 16097151],
2671                [7, 16097152],
2672                [8, 16097153],
2673                [9, 16097154],
2674                [10, 16097155],
2675                [11, 16097156],
2676                [12, 16097157],
2677                [13, 16097158],
2678                [14, 16097159],
2679                [15, 16097160],
2680                [16, 16097161],
2681                [17, 16097162],
2682                [18, 16097163],
2683                [19, 16097164],
2684                [20, 16097165],
2685                [21, 16097166],
2686                [22, 16097167],
2687                [23, 16097168],
2688                [24, 16097169],
2689                [25, 16097170],
2690                [26, 16097171],
2691                [27, 16097172],
2692                [28, 16097173],
2693                [29, 16097176],
2694                [30, 16097177],
2695                [31, 16097178],
2696                [32, 16097179],
2697                [33, 16097180],
2698                [34, 16097181],
2699                [35, 16097182],
2700                [36, 16097183],
2701                [37, 16097184],
2702                [38, 16097185],
2703                [39, 16097186],
2704                [40, 16097187],
2705                [41, 16097188],
2706                [42, 16097189],
2707                [43, 16097190],
2708                [44, 16097191],
2709                [45, 16097192],
2710                [46, 16097193],
2711                [47, 16097194],
2712                [48, 16097195],
2713                [49, 16097196],
2714                [50, 16097197]
2715            ]
2716        );
2717        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
2718        assert_eq!(
2719            pairs,
2720            vec![
2721                [0, 16117350],
2722                [1, 16117351],
2723                [2, 16117352],
2724                [3, 16117353],
2725                [4, 16117354],
2726                [5, 16117355],
2727                [6, 16117356],
2728                [7, 16117357],
2729                [8, 16117358],
2730                [9, 16117359],
2731                [10, 16117360],
2732                [11, 16117361],
2733                [12, 16117362],
2734                [13, 16117363],
2735                [14, 16117364],
2736                [15, 16117365],
2737                [16, 16117366],
2738                [17, 16117367],
2739                [18, 16117368],
2740                [19, 16117369],
2741                [20, 16117370],
2742                [21, 16117371],
2743                [22, 16117372],
2744                [23, 16117373],
2745                [24, 16117374],
2746                [25, 16117375],
2747                [26, 16117376],
2748                [27, 16117377],
2749                [28, 16117378],
2750                [29, 16117379],
2751                [30, 16117380],
2752                [31, 16117381],
2753                [32, 16117382],
2754                [33, 16117383],
2755                [34, 16117384],
2756                [35, 16117385],
2757                [36, 16117386],
2758                [37, 16117387],
2759                [38, 16117388],
2760                [39, 16117389],
2761                [40, 16117390],
2762                [41, 16117391],
2763                [42, 16117392],
2764                [43, 16117393],
2765                [44, 16117394],
2766                [45, 16117395],
2767                [46, 16117396],
2768                [47, 16117397],
2769                [48, 16117398],
2770                [49, 16117399],
2771                [50, 16117400]
2772            ]
2773        );
2774        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
2775        assert_eq!(
2776            pairs,
2777            vec![
2778                [0, 16118483],
2779                [1, 16118484],
2780                [2, 16118485],
2781                [3, 16118486],
2782                [4, 16118487],
2783                [5, 16118488],
2784                [6, 16118489],
2785                [7, 16118490],
2786                [8, 16118491],
2787                [9, 16118492],
2788                [10, 16118493],
2789                [11, 16118494],
2790                [12, 16118495],
2791                [13, 16118496],
2792                [14, 16118497],
2793                [15, 16118498],
2794                [16, 16118499],
2795                [17, 16118500],
2796                [18, 16118501],
2797                [19, 16118502],
2798                [20, 16118503],
2799                [21, 16118504],
2800                [22, 16118505],
2801                [23, 16118506],
2802                [24, 16118507],
2803                [25, 16118508],
2804                [26, 16118509],
2805                [27, 16118510],
2806                [28, 16118511],
2807                [29, 16118512],
2808                [30, 16118513],
2809                [31, 16118514],
2810                [32, 16118515],
2811                [33, 16118516],
2812                [34, 16118517],
2813                [35, 16118518],
2814                [36, 16118519],
2815                [37, 16118520],
2816                [38, 16118521],
2817                [39, 16118522],
2818                [40, 16118523],
2819                [41, 16118524],
2820                [42, 16118525],
2821                [43, 16118526],
2822                [44, 16118527],
2823                [45, 16118528],
2824                [46, 16118529],
2825                [47, 16118530],
2826                [48, 16118531],
2827                [49, 16118532],
2828                [50, 16118533]
2829            ]
2830        );
2831        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
2832        assert_eq!(
2833            pairs,
2834            vec![
2835                [0, 16118499],
2836                [1, 16118500],
2837                [2, 16118501],
2838                [3, 16118502],
2839                [4, 16118503],
2840                [5, 16118504],
2841                [6, 16118505],
2842                [7, 16118506],
2843                [8, 16118507],
2844                [9, 16118508],
2845                [10, 16118509],
2846                [11, 16118510],
2847                [12, 16118511],
2848                [13, 16118512],
2849                [14, 16118513],
2850                [15, 16118514],
2851                [16, 16118515],
2852                [17, 16118516],
2853                [18, 16118517],
2854                [19, 16118518],
2855                [20, 16118519],
2856                [21, 16118520],
2857                [22, 16118521],
2858                [23, 16118522],
2859                [24, 16118523],
2860                [25, 16118524],
2861                [26, 16118525],
2862                [27, 16118526],
2863                [28, 16118527],
2864                [29, 16118528],
2865                [30, 16118529],
2866                [31, 16118530],
2867                [32, 16118531],
2868                [33, 16118532],
2869                [34, 16118533],
2870                [35, 16118534],
2871                [36, 16118535],
2872                [37, 16118536],
2873                [38, 16118537],
2874                [39, 16118538],
2875                [40, 16118539],
2876                [41, 16118540],
2877                [42, 16118541],
2878                [43, 16118542],
2879                [44, 16118543],
2880                [45, 16118544],
2881                [46, 16118545],
2882                [47, 16118546],
2883                [48, 16118547],
2884                [49, 16118548],
2885                [50, 16118549]
2886            ]
2887        );
2888        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
2889        assert_eq!(
2890            pairs,
2891            vec![
2892                [0, 16118499],
2893                [1, 16118500],
2894                [2, 16118501],
2895                [3, 16118502],
2896                [4, 16118503],
2897                [5, 16118504],
2898                [6, 16118505],
2899                [7, 16118506],
2900                [8, 16118507],
2901                [9, 16118508],
2902                [10, 16118509],
2903                [11, 16118510],
2904                [12, 16118511],
2905                [13, 16118512],
2906                [14, 16118513],
2907                [15, 16118514],
2908                [16, 16118515],
2909                [17, 16118516],
2910                [18, 16118517],
2911                [19, 16118518],
2912                [20, 16118519],
2913                [21, 16118520],
2914                [22, 16118521],
2915                [23, 16118522],
2916                [24, 16118523],
2917                [25, 16118524],
2918                [26, 16118525],
2919                [27, 16118526],
2920                [28, 16118527],
2921                [29, 16118528],
2922                [30, 16118529],
2923                [31, 16118530],
2924                [32, 16118531],
2925                [33, 16118532],
2926                [34, 16118533],
2927                [35, 16118534],
2928                [36, 16118535],
2929                [37, 16118536],
2930                [38, 16118537],
2931                [39, 16118538],
2932                [40, 16118539],
2933                [41, 16118540],
2934                [42, 16118541],
2935                [43, 16118542],
2936                [44, 16118543],
2937                [45, 16118544],
2938                [46, 16118545],
2939                [47, 16118546],
2940                [48, 16118547],
2941                [49, 16118548],
2942                [50, 16118549]
2943            ]
2944        );
2945        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
2946        assert_eq!(
2947            pairs,
2948            vec![
2949                [0, 16118499],
2950                [1, 16118500],
2951                [2, 16118501],
2952                [3, 16118502],
2953                [4, 16118503],
2954                [5, 16118504],
2955                [6, 16118505],
2956                [7, 16118506],
2957                [8, 16118507],
2958                [9, 16118508],
2959                [10, 16118509],
2960                [11, 16118510],
2961                [12, 16118511],
2962                [13, 16118512],
2963                [14, 16118513],
2964                [15, 16118514],
2965                [16, 16118515],
2966                [17, 16118516],
2967                [18, 16118517],
2968                [19, 16118518],
2969                [20, 16118519],
2970                [21, 16118520],
2971                [22, 16118521],
2972                [23, 16118522],
2973                [24, 16118523],
2974                [25, 16118524],
2975                [26, 16118525],
2976                [27, 16118526],
2977                [28, 16118527],
2978                [29, 16118528],
2979                [30, 16118529],
2980                [31, 16118530],
2981                [32, 16118531],
2982                [33, 16118532],
2983                [34, 16118533],
2984                [35, 16118534],
2985                [36, 16118535],
2986                [37, 16118536],
2987                [38, 16118537],
2988                [39, 16118538],
2989                [40, 16118539],
2990                [41, 16118540],
2991                [42, 16118541],
2992                [43, 16118542],
2993                [44, 16118543],
2994                [45, 16118544],
2995                [46, 16118545],
2996                [47, 16118546],
2997                [48, 16118547],
2998                [49, 16118548],
2999                [50, 16118549]
3000            ]
3001        );
3002        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3003        assert_eq!(
3004            pairs,
3005            vec![
3006                [0, 16123411],
3007                [1, 16123412],
3008                [2, 16123413],
3009                [3, 16123414],
3010                [4, 16123415],
3011                [5, 16123416],
3012                [6, 16123417],
3013                [7, 16123418],
3014                [8, 16123419],
3015                [9, 16123420],
3016                [10, 16123421],
3017                [11, 16123422],
3018                [12, 16123423],
3019                [13, 16123424],
3020                [14, 16123425],
3021                [15, 16123426],
3022                [16, 16123427],
3023                [17, 16123428],
3024                [18, 16123429],
3025                [19, 16123430],
3026                [20, 16123431],
3027                [21, 16123432],
3028                [22, 16123433],
3029                [23, 16123434],
3030                [24, 16123435],
3031                [25, 16123436],
3032                [26, 16123437],
3033                [27, 16123438],
3034                [28, 16123439],
3035                [29, 16123440],
3036                [30, 16123441],
3037                [31, 16123442],
3038                [32, 16123443],
3039                [33, 16123444],
3040                [34, 16123445],
3041                [35, 16123446],
3042                [36, 16123447],
3043                [37, 16123448],
3044                [38, 16123449],
3045                [39, 16123450],
3046                [40, 16123451],
3047                [41, 16123452],
3048                [42, 16123453],
3049                [43, 16123454],
3050                [44, 16123455],
3051                [45, 16123456],
3052                [46, 16123457],
3053                [47, 16123458],
3054                [48, 16123459],
3055                [49, 16123460],
3056                [50, 16123461]
3057            ]
3058        );
3059        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3060        assert_eq!(
3061            pairs,
3062            vec![
3063                [6, 16123417],
3064                [7, 16123418],
3065                [8, 16123419],
3066                [9, 16123420],
3067                [10, 16123421],
3068                [11, 16123422],
3069                [12, 16123423],
3070                [13, 16123424],
3071                [14, 16123425],
3072                [15, 16123426],
3073                [16, 16123427],
3074                [17, 16123428],
3075                [18, 16123429],
3076                [19, 16123430],
3077                [20, 16123431],
3078                [21, 16123432],
3079                [22, 16123433],
3080                [23, 16123434],
3081                [24, 16123435],
3082                [25, 16123436],
3083                [26, 16123437],
3084                [27, 16123438],
3085                [28, 16123439],
3086                [29, 16123440],
3087                [30, 16123441],
3088                [31, 16123442],
3089                [32, 16123443],
3090                [33, 16123444],
3091                [34, 16123445],
3092                [35, 16123446],
3093                [36, 16123447],
3094                [37, 16123448],
3095                [38, 16123449],
3096                [39, 16123450],
3097                [40, 16123451],
3098                [41, 16123452],
3099                [42, 16123453],
3100                [43, 16123454],
3101                [44, 16123455],
3102                [45, 16123456],
3103                [46, 16123457],
3104                [47, 16123458],
3105                [48, 16123459],
3106                [49, 16123460],
3107                [50, 16123461]
3108            ]
3109        );
3110        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3111        assert_eq!(
3112            pairs,
3113            vec![
3114                [0, 16165860],
3115                [1, 16165861],
3116                [2, 16165862],
3117                [3, 16165863],
3118                [4, 16165864],
3119                [5, 16165865],
3120                [6, 16165866],
3121                [7, 16165867],
3122                [8, 16165868],
3123                [9, 16165869],
3124                [10, 16165870],
3125                [11, 16165871],
3126                [12, 16165872],
3127                [13, 16165873],
3128                [14, 16165874],
3129                [15, 16165875],
3130                [16, 16165876],
3131                [17, 16165877],
3132                [18, 16165878],
3133                [19, 16165879],
3134                [20, 16165880],
3135                [21, 16165881],
3136                [22, 16165882],
3137                [23, 16165883],
3138                [24, 16165884],
3139                [25, 16165885],
3140                [26, 16165886],
3141                [27, 16165887],
3142                [28, 16165888],
3143                [29, 16165889],
3144                [30, 16165890],
3145                [31, 16165891],
3146                [32, 16165892],
3147                [33, 16165893],
3148                [34, 16165894],
3149                [35, 16165895],
3150                [36, 16165896],
3151                [37, 16165897],
3152                [38, 16165898],
3153                [39, 16165899],
3154                [40, 16165900]
3155            ]
3156        );
3157        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3158        assert_eq!(
3159            pairs,
3160            vec![
3161                [0, 16180871],
3162                [1, 16180872],
3163                [2, 16180873],
3164                [3, 16180874],
3165                [4, 16180875],
3166                [5, 16180876],
3167                [6, 16180877],
3168                [7, 16180878],
3169                [8, 16180879],
3170                [9, 16180880],
3171                [10, 16180881],
3172                [11, 16180882],
3173                [12, 16180883],
3174                [13, 16180884],
3175                [14, 16180885],
3176                [15, 16180886],
3177                [16, 16180887],
3178                [17, 16180888],
3179                [18, 16180889],
3180                [19, 16180890],
3181                [20, 16180891],
3182                [21, 16180892],
3183                [22, 16180893],
3184                [23, 16180894],
3185                [24, 16180895],
3186                [25, 16180896],
3187                [26, 16180897],
3188                [27, 16180898],
3189                [28, 16180899],
3190                [29, 16180900],
3191                [30, 16180901],
3192                [31, 16180902],
3193                [32, 16180903],
3194                [33, 16180904],
3195                [34, 16180905],
3196                [35, 16180906],
3197                [36, 16180907],
3198                [37, 16180908],
3199                [38, 16180909],
3200                [39, 16180910],
3201                [40, 16180911],
3202                [41, 16180912],
3203                [42, 16180913],
3204                [43, 16180914],
3205                [44, 16180915],
3206                [45, 16180916],
3207                [46, 16180917],
3208                [47, 16180918],
3209                [48, 16180919],
3210                [49, 16180920],
3211                [50, 16180921]
3212            ]
3213        );
3214        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3215        assert_eq!(
3216            pairs,
3217            vec![
3218                [0, 16189705],
3219                [1, 16189706],
3220                [2, 16189707],
3221                [3, 16189708],
3222                [4, 16189709],
3223                [5, 16189710],
3224                [6, 16189711],
3225                [7, 16189712],
3226                [8, 16189713],
3227                [9, 16189714],
3228                [10, 16189715],
3229                [11, 16189716],
3230                [12, 16189717],
3231                [13, 16189718],
3232                [14, 16189719],
3233                [15, 16189720],
3234                [16, 16189721],
3235                [17, 16189722],
3236                [18, 16189723],
3237                [19, 16189724],
3238                [20, 16189725],
3239                [21, 16189726],
3240                [22, 16189727],
3241                [23, 16189728],
3242                [24, 16189729],
3243                [25, 16189730],
3244                [26, 16189731],
3245                [27, 16189732],
3246                [28, 16189733],
3247                [29, 16189734],
3248                [30, 16189735],
3249                [31, 16189736],
3250                [32, 16189737],
3251                [33, 16189738],
3252                [34, 16189739],
3253                [35, 16189740],
3254                [36, 16189741],
3255                [37, 16189742],
3256                [38, 16189743],
3257                [39, 16189744],
3258                [40, 16189745],
3259                [41, 16189746],
3260                [42, 16189747],
3261                [43, 16189748],
3262                [44, 16189749],
3263                [45, 16189750],
3264                [46, 16189751],
3265                [47, 16189752],
3266                [48, 16189753],
3267                [49, 16189754],
3268                [50, 16189755]
3269            ]
3270        );
3271        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3272        assert_eq!(
3273            pairs,
3274            vec![
3275                [0, 16231271],
3276                [1, 16231272],
3277                [2, 16231273],
3278                [3, 16231274],
3279                [4, 16231275],
3280                [5, 16231276],
3281                [6, 16231277],
3282                [7, 16231278],
3283                [8, 16231279],
3284                [9, 16231280],
3285                [10, 16231281],
3286                [11, 16231282],
3287                [12, 16231283],
3288                [13, 16231284],
3289                [14, 16231285],
3290                [15, 16231286],
3291                [16, 16231287],
3292                [17, 16231288],
3293                [18, 16231289],
3294                [19, 16231290],
3295                [20, 16231291],
3296                [21, 16231292],
3297                [22, 16231293],
3298                [23, 16231294],
3299                [24, 16231295],
3300                [25, 16231296],
3301                [26, 16231297],
3302                [27, 16231298],
3303                [28, 16231299],
3304                [29, 16231300],
3305                [30, 16231301],
3306                [31, 16231302],
3307                [32, 16231303],
3308                [33, 16231304],
3309                [34, 16231305],
3310                [35, 16231306],
3311                [36, 16231307],
3312                [37, 16231308],
3313                [38, 16231309],
3314                [39, 16231310],
3315                [40, 16231311],
3316                [41, 16231312],
3317                [42, 16231313],
3318                [43, 16231314],
3319                [44, 16231315],
3320                [45, 16231316],
3321                [46, 16231317],
3322                [47, 16231318],
3323                [48, 16231319],
3324                [49, 16231320],
3325                [50, 16231321]
3326            ]
3327        );
3328        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3329        assert_eq!(
3330            pairs,
3331            vec![
3332                [0, 16237657],
3333                [1, 16237658],
3334                [2, 16237659],
3335                [3, 16237660],
3336                [4, 16237661],
3337                [5, 16237662],
3338                [6, 16237663],
3339                [7, 16237664],
3340                [8, 16237665],
3341                [9, 16237666],
3342                [10, 16237667],
3343                [11, 16237668],
3344                [12, 16237669],
3345                [13, 16237670],
3346                [14, 16237671],
3347                [15, 16237672],
3348                [16, 16237673],
3349                [17, 16237674],
3350                [18, 16237675],
3351                [19, 16237676],
3352                [20, 16237677],
3353                [21, 16237678],
3354                [22, 16237679],
3355                [23, 16237680],
3356                [24, 16237681],
3357                [25, 16237682],
3358                [26, 16237683],
3359                [27, 16237684],
3360                [28, 16237685],
3361                [29, 16237686],
3362                [30, 16237687],
3363                [31, 16237688],
3364                [32, 16237689],
3365                [33, 16237690],
3366                [34, 16237691],
3367                [35, 16237692],
3368                [36, 16237693],
3369                [37, 16237694],
3370                [38, 16237695],
3371                [39, 16237696],
3372                [40, 16237697],
3373                [41, 16237698],
3374                [42, 16237699],
3375                [43, 16237700],
3376                [44, 16237701],
3377                [45, 16237702],
3378                [46, 16237703],
3379                [47, 16237704],
3380                [48, 16237705],
3381                [49, 16237706],
3382                [50, 16237707]
3383            ]
3384        );
3385        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3386        assert_eq!(
3387            pairs,
3388            vec![
3389                [9, 16255012],
3390                [10, 16255013],
3391                [11, 16255014],
3392                [12, 16255015],
3393                [13, 16255016],
3394                [14, 16255017],
3395                [15, 16255018],
3396                [16, 16255019],
3397                [17, 16255020],
3398                [18, 16255021],
3399                [19, 16255022],
3400                [20, 16255023],
3401                [21, 16255024],
3402                [22, 16255025],
3403                [23, 16255026],
3404                [24, 16255027],
3405                [25, 16255028],
3406                [26, 16255029],
3407                [27, 16255030],
3408                [28, 16255031],
3409                [29, 16255032],
3410                [30, 16255033],
3411                [31, 16255034],
3412                [32, 16255035],
3413                [33, 16255036],
3414                [34, 16255037],
3415                [35, 16255038],
3416                [36, 16255039],
3417                [37, 16255040],
3418                [38, 16255041],
3419                [39, 16255042],
3420                [40, 16255043],
3421                [41, 16255044],
3422                [42, 16255045],
3423                [43, 16255046],
3424                [44, 16255047],
3425                [45, 16255048],
3426                [46, 16255049],
3427                [47, 16255050],
3428                [48, 16255051],
3429                [49, 16255052],
3430                [50, 16255053]
3431            ]
3432        );
3433        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3434        assert_eq!(
3435            pairs,
3436            vec![
3437                [0, 16255391],
3438                [1, 16255392],
3439                [2, 16255393],
3440                [3, 16255394],
3441                [4, 16255395],
3442                [5, 16255396],
3443                [6, 16255397],
3444                [7, 16255398],
3445                [8, 16255399],
3446                [9, 16255400],
3447                [10, 16255401],
3448                [11, 16255402],
3449                [12, 16255403],
3450                [13, 16255404],
3451                [14, 16255405],
3452                [15, 16255406],
3453                [16, 16255407],
3454                [17, 16255408],
3455                [18, 16255409],
3456                [19, 16255410],
3457                [20, 16255411],
3458                [21, 16255412],
3459                [22, 16255413],
3460                [23, 16255414],
3461                [24, 16255415],
3462                [25, 16255416],
3463                [26, 16255417],
3464                [27, 16255418],
3465                [28, 16255419],
3466                [29, 16255420],
3467                [30, 16255421],
3468                [31, 16255422],
3469                [32, 16255423],
3470                [33, 16255424],
3471                [34, 16255425],
3472                [35, 16255426],
3473                [36, 16255427],
3474                [37, 16255428],
3475                [38, 16255429],
3476                [39, 16255430],
3477                [40, 16255431],
3478                [41, 16255432],
3479                [42, 16255433],
3480                [43, 16255434],
3481                [44, 16255435],
3482                [45, 16255436],
3483                [46, 16255437],
3484                [47, 16255438],
3485                [48, 16255439],
3486                [49, 16255440],
3487                [50, 16255441]
3488            ]
3489        );
3490        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3491        assert_eq!(
3492            pairs,
3493            vec![
3494                [0, 16255392],
3495                [1, 16255393],
3496                [2, 16255394],
3497                [3, 16255395],
3498                [4, 16255396],
3499                [5, 16255397],
3500                [6, 16255398],
3501                [7, 16255399],
3502                [8, 16255400],
3503                [9, 16255401],
3504                [10, 16255402],
3505                [11, 16255403],
3506                [12, 16255404],
3507                [13, 16255405],
3508                [14, 16255406],
3509                [15, 16255407],
3510                [16, 16255408],
3511                [17, 16255409],
3512                [18, 16255410],
3513                [19, 16255411],
3514                [20, 16255412],
3515                [21, 16255413],
3516                [22, 16255414],
3517                [23, 16255415],
3518                [24, 16255416],
3519                [25, 16255417],
3520                [26, 16255418],
3521                [27, 16255419],
3522                [28, 16255420],
3523                [29, 16255421],
3524                [30, 16255422],
3525                [31, 16255423],
3526                [32, 16255424],
3527                [33, 16255425],
3528                [34, 16255426],
3529                [35, 16255427],
3530                [36, 16255428],
3531                [37, 16255429],
3532                [38, 16255430],
3533                [39, 16255431],
3534                [40, 16255432],
3535                [41, 16255433],
3536                [42, 16255434],
3537                [43, 16255435],
3538                [44, 16255436],
3539                [45, 16255437],
3540                [46, 16255438],
3541                [47, 16255439],
3542                [48, 16255440],
3543                [49, 16255441]
3544            ]
3545        );
3546        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3547        assert_eq!(
3548            pairs,
3549            vec![
3550                [0, 16256084],
3551                [1, 16256085],
3552                [2, 16256086],
3553                [3, 16256087],
3554                [4, 16256088],
3555                [5, 16256089],
3556                [6, 16256090],
3557                [7, 16256091],
3558                [8, 16256092],
3559                [9, 16256093],
3560                [10, 16256094],
3561                [11, 16256095],
3562                [12, 16256096],
3563                [13, 16256097],
3564                [14, 16256098],
3565                [15, 16256099],
3566                [16, 16256100],
3567                [17, 16256101],
3568                [18, 16256102],
3569                [19, 16256103],
3570                [20, 16256104],
3571                [21, 16256105],
3572                [22, 16256106],
3573                [23, 16256107],
3574                [24, 16256108],
3575                [25, 16256109],
3576                [26, 16256110],
3577                [27, 16256111],
3578                [28, 16256112],
3579                [29, 16256113],
3580                [30, 16256114],
3581                [31, 16256115],
3582                [32, 16256116],
3583                [33, 16256117],
3584                [34, 16256118],
3585                [35, 16256119],
3586                [36, 16256120],
3587                [37, 16256121],
3588                [38, 16256122],
3589                [39, 16256123],
3590                [40, 16256124],
3591                [41, 16256125],
3592                [42, 16256126],
3593                [43, 16256127],
3594                [44, 16256128]
3595            ]
3596        );
3597        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3598        assert_eq!(
3599            pairs,
3600            vec![
3601                [3, 16256224],
3602                [4, 16256225],
3603                [5, 16256226],
3604                [6, 16256227],
3605                [7, 16256228],
3606                [8, 16256229],
3607                [9, 16256230],
3608                [10, 16256231],
3609                [11, 16256232],
3610                [12, 16256233],
3611                [13, 16256234],
3612                [14, 16256235],
3613                [15, 16256236],
3614                [16, 16256237],
3615                [17, 16256238],
3616                [18, 16256239],
3617                [19, 16256240],
3618                [20, 16256241],
3619                [21, 16256242],
3620                [22, 16256243],
3621                [23, 16256244],
3622                [24, 16256245],
3623                [25, 16256246],
3624                [26, 16256247],
3625                [27, 16256248],
3626                [28, 16256249],
3627                [29, 16256250],
3628                [30, 16256251],
3629                [31, 16256252],
3630                [32, 16256253],
3631                [33, 16256254],
3632                [34, 16256255],
3633                [35, 16256256],
3634                [36, 16256257],
3635                [37, 16256258],
3636                [38, 16256259],
3637                [39, 16256260],
3638                [40, 16256261],
3639                [41, 16256262],
3640                [42, 16256263],
3641                [43, 16256264],
3642                [44, 16256265],
3643                [45, 16256266],
3644                [46, 16256267],
3645                [47, 16256268],
3646                [48, 16256269],
3647                [49, 16256270],
3648                [50, 16256271]
3649            ]
3650        );
3651        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3652        assert_eq!(
3653            pairs,
3654            vec![
3655                [0, 16325199],
3656                [1, 16325200],
3657                [2, 16325201],
3658                [3, 16325202],
3659                [4, 16325203],
3660                [5, 16325204],
3661                [6, 16325205],
3662                [7, 16325206],
3663                [8, 16325207],
3664                [9, 16325208],
3665                [10, 16325209],
3666                [11, 16325210],
3667                [12, 16325211],
3668                [13, 16325212],
3669                [14, 16325213],
3670                [15, 16325214],
3671                [16, 16325215],
3672                [17, 16325216],
3673                [18, 16325217],
3674                [19, 16325218],
3675                [20, 16325219],
3676                [21, 16325220],
3677                [22, 16325221],
3678                [23, 16325222],
3679                [24, 16325223],
3680                [25, 16325224],
3681                [26, 16325225],
3682                [27, 16325226],
3683                [28, 16325227],
3684                [29, 16325228],
3685                [30, 16325229],
3686                [31, 16325230],
3687                [32, 16325231],
3688                [33, 16325232],
3689                [34, 16325233],
3690                [35, 16325234],
3691                [36, 16325235],
3692                [37, 16325236],
3693                [38, 16325237],
3694                [39, 16325238],
3695                [40, 16325239],
3696                [41, 16325240]
3697            ]
3698        );
3699        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3700        assert_eq!(
3701            pairs,
3702            vec![
3703                [13, 16352865],
3704                [14, 16352866],
3705                [15, 16352867],
3706                [16, 16352868],
3707                [17, 16352869],
3708                [18, 16352870],
3709                [19, 16352871],
3710                [20, 16352872],
3711                [21, 16352873],
3712                [22, 16352874],
3713                [23, 16352875],
3714                [24, 16352876],
3715                [25, 16352877],
3716                [26, 16352878],
3717                [27, 16352879],
3718                [28, 16352880],
3719                [29, 16352881],
3720                [30, 16352882],
3721                [31, 16352883],
3722                [32, 16352884],
3723                [33, 16352885],
3724                [34, 16352886],
3725                [35, 16352887],
3726                [36, 16352888],
3727                [37, 16352889],
3728                [38, 16352890],
3729                [39, 16352891],
3730                [40, 16352892],
3731                [41, 16352893],
3732                [42, 16352894],
3733                [43, 16352895],
3734                [44, 16352896],
3735                [45, 16352897],
3736                [46, 16352898],
3737                [47, 16352899],
3738                [48, 16352900],
3739                [49, 16352901],
3740                [50, 16352902]
3741            ]
3742        );
3743        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3744        assert_eq!(
3745            pairs,
3746            vec![
3747                [0, 16352968],
3748                [1, 16352969],
3749                [2, 16352970],
3750                [3, 16352971],
3751                [4, 16352972],
3752                [5, 16352973],
3753                [6, 16352974],
3754                [7, 16352975],
3755                [8, 16352976],
3756                [9, 16352977],
3757                [10, 16352978],
3758                [11, 16352979],
3759                [12, 16352980],
3760                [13, 16352981],
3761                [14, 16352982],
3762                [15, 16352983],
3763                [16, 16352984],
3764                [17, 16352985],
3765                [18, 16352986],
3766                [19, 16352987],
3767                [20, 16352988],
3768                [21, 16352989],
3769                [22, 16352990],
3770                [23, 16352991],
3771                [24, 16352992],
3772                [25, 16352993],
3773                [26, 16352994],
3774                [27, 16352995],
3775                [28, 16352996],
3776                [29, 16352997],
3777                [30, 16352998],
3778                [31, 16352999],
3779                [32, 16353000],
3780                [33, 16353001],
3781                [34, 16353002],
3782                [35, 16353003],
3783                [36, 16353004],
3784                [37, 16353005],
3785                [38, 16353006],
3786                [39, 16353007],
3787                [40, 16353008],
3788                [41, 16353009],
3789                [42, 16353010],
3790                [43, 16353011]
3791            ]
3792        );
3793        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3794        assert_eq!(
3795            pairs,
3796            vec![
3797                [5, 16414998],
3798                [6, 16414999],
3799                [7, 16415000],
3800                [8, 16415001],
3801                [9, 16415002],
3802                [10, 16415003],
3803                [11, 16415004],
3804                [12, 16415005],
3805                [13, 16415006],
3806                [14, 16415007],
3807                [15, 16415008],
3808                [16, 16415009],
3809                [17, 16415010],
3810                [18, 16415011],
3811                [19, 16415012],
3812                [20, 16415013],
3813                [21, 16415014],
3814                [22, 16415015],
3815                [23, 16415016],
3816                [24, 16415017],
3817                [25, 16415018],
3818                [26, 16415019],
3819                [27, 16415020],
3820                [28, 16415021],
3821                [29, 16415022],
3822                [30, 16415023],
3823                [31, 16415024],
3824                [32, 16415025],
3825                [33, 16415026],
3826                [34, 16415027],
3827                [35, 16415028],
3828                [36, 16415029],
3829                [37, 16415030],
3830                [38, 16415031],
3831                [39, 16415032],
3832                [40, 16415033],
3833                [41, 16415034],
3834                [42, 16415035],
3835                [43, 16415036],
3836                [44, 16415037],
3837                [45, 16415038],
3838                [46, 16415039],
3839                [47, 16415040],
3840                [48, 16415041],
3841                [49, 16415042],
3842                [50, 16415043]
3843            ]
3844        );
3845        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3846        assert_eq!(
3847            pairs,
3848            vec![
3849                [0, 17031591],
3850                [1, 17031592],
3851                [2, 17031593],
3852                [3, 17031594],
3853                [4, 17031595],
3854                [5, 17031596],
3855                [6, 17031597],
3856                [7, 17031598],
3857                [8, 17031599],
3858                [9, 17031600],
3859                [10, 17031601],
3860                [11, 17031602],
3861                [12, 17031603],
3862                [13, 17031604],
3863                [14, 17031605],
3864                [15, 17031606],
3865                [16, 17031607],
3866                [17, 17031608],
3867                [18, 17031609],
3868                [19, 17031610],
3869                [20, 17031611],
3870                [21, 17031612],
3871                [22, 17031613],
3872                [27, 17031614],
3873                [28, 17031615],
3874                [29, 17031616],
3875                [30, 17031617],
3876                [31, 17031618],
3877                [32, 17031619],
3878                [33, 17031620],
3879                [34, 17031621],
3880                [35, 17031622],
3881                [36, 17031623],
3882                [37, 17031624],
3883                [38, 17031625],
3884                [39, 17031626],
3885                [40, 17031627],
3886                [41, 17031628],
3887                [42, 17031629],
3888                [43, 17031630],
3889                [44, 17031631],
3890                [45, 17031632],
3891                [46, 17031633],
3892                [47, 17031634],
3893                [48, 17031635],
3894                [49, 17031636],
3895                [50, 17031637]
3896            ]
3897        );
3898        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3899        assert_eq!(
3900            pairs,
3901            vec![
3902                [0, 17057382],
3903                [1, 17057383],
3904                [2, 17057384],
3905                [3, 17057385],
3906                [4, 17057386],
3907                [5, 17057387],
3908                [6, 17057388],
3909                [7, 17057389],
3910                [8, 17057390],
3911                [9, 17057391],
3912                [10, 17057392],
3913                [11, 17057393],
3914                [12, 17057394],
3915                [13, 17057395],
3916                [14, 17057396],
3917                [15, 17057397],
3918                [16, 17057398],
3919                [17, 17057399],
3920                [19, 17057400],
3921                [20, 17057401],
3922                [21, 17057402],
3923                [22, 17057403],
3924                [23, 17057404],
3925                [24, 17057405],
3926                [25, 17057406],
3927                [26, 17057407],
3928                [27, 17057408],
3929                [28, 17057409],
3930                [29, 17057410],
3931                [30, 17057411],
3932                [31, 17057412],
3933                [32, 17057413],
3934                [33, 17057414],
3935                [34, 17057415],
3936                [35, 17057416],
3937                [36, 17057417],
3938                [37, 17057418],
3939                [38, 17057419],
3940                [39, 17057420],
3941                [40, 17057421],
3942                [41, 17057422],
3943                [42, 17057423],
3944                [43, 17057424],
3945                [44, 17057425],
3946                [45, 17057426],
3947                [46, 17057427],
3948                [47, 17057428],
3949                [48, 17057429],
3950                [49, 17057430],
3951                [50, 17057431]
3952            ]
3953        );
3954        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
3955        assert_eq!(
3956            pairs,
3957            vec![
3958                [0, 17092766],
3959                [1, 17092767],
3960                [2, 17092768],
3961                [3, 17092769],
3962                [4, 17092770],
3963                [5, 17092771],
3964                [6, 17092772],
3965                [7, 17092773],
3966                [8, 17092774],
3967                [9, 17092775],
3968                [10, 17092776],
3969                [11, 17092777],
3970                [12, 17092778],
3971                [13, 17092779],
3972                [14, 17092780],
3973                [15, 17092781],
3974                [16, 17092782],
3975                [17, 17094966],
3976                [18, 17094967],
3977                [19, 17094968],
3978                [20, 17094969],
3979                [21, 17094970],
3980                [22, 17094971],
3981                [23, 17094972],
3982                [24, 17094973],
3983                [25, 17094974],
3984                [26, 17094975],
3985                [27, 17094976],
3986                [28, 17094977],
3987                [29, 17094978],
3988                [30, 17094979],
3989                [31, 17094980],
3990                [32, 17094981],
3991                [33, 17094982],
3992                [34, 17094983],
3993                [35, 17094984],
3994                [36, 17094985],
3995                [37, 17094986],
3996                [38, 17094987],
3997                [39, 17094988],
3998                [40, 17094989],
3999                [41, 17094990],
4000                [42, 17094991],
4001                [43, 17094992],
4002                [44, 17094993],
4003                [45, 17094994],
4004                [46, 17094995],
4005                [47, 17094996],
4006                [48, 17094997],
4007                [49, 17094998],
4008                [50, 17094999]
4009            ]
4010        );
4011        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4012        assert_eq!(
4013            pairs,
4014            vec![
4015                [0, 17092782],
4016                [1, 17094966],
4017                [2, 17094967],
4018                [3, 17094968],
4019                [4, 17094969],
4020                [5, 17094970],
4021                [6, 17094971],
4022                [7, 17094972],
4023                [8, 17094973],
4024                [9, 17094974],
4025                [10, 17094975],
4026                [11, 17094976],
4027                [12, 17094977],
4028                [13, 17094978],
4029                [14, 17094979],
4030                [15, 17094980],
4031                [16, 17094981],
4032                [17, 17094982],
4033                [18, 17094983],
4034                [19, 17094984],
4035                [20, 17094985],
4036                [21, 17094986],
4037                [22, 17094987],
4038                [23, 17094988],
4039                [24, 17094989],
4040                [25, 17094990],
4041                [26, 17094991],
4042                [27, 17094992],
4043                [28, 17094993],
4044                [29, 17094994],
4045                [30, 17094995],
4046                [31, 17094996],
4047                [32, 17094997],
4048                [33, 17094998],
4049                [34, 17094999],
4050                [35, 17095000],
4051                [36, 17095001],
4052                [37, 17095002],
4053                [38, 17095003],
4054                [39, 17095004],
4055                [40, 17095005],
4056                [41, 17095006],
4057                [42, 17095007],
4058                [43, 17095008],
4059                [44, 17095009],
4060                [45, 17095010],
4061                [46, 17095011],
4062                [47, 17095012],
4063                [48, 17095013],
4064                [49, 17095014],
4065                [50, 17095015]
4066            ]
4067        );
4068        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4069        assert_eq!(
4070            pairs,
4071            vec![
4072                [0, 17092782],
4073                [1, 17094966],
4074                [2, 17094967],
4075                [3, 17094968],
4076                [4, 17094969],
4077                [5, 17094970],
4078                [6, 17094971],
4079                [7, 17094972],
4080                [8, 17094973],
4081                [9, 17094974],
4082                [10, 17094975],
4083                [11, 17094976],
4084                [12, 17094977],
4085                [13, 17094978],
4086                [14, 17094979],
4087                [15, 17094980],
4088                [16, 17094981],
4089                [17, 17094982],
4090                [18, 17094983],
4091                [19, 17094984],
4092                [20, 17094985],
4093                [21, 17094986],
4094                [22, 17094987],
4095                [23, 17094988],
4096                [24, 17094989],
4097                [25, 17094990],
4098                [26, 17094991],
4099                [27, 17094992],
4100                [28, 17094993],
4101                [29, 17094994],
4102                [30, 17094995],
4103                [31, 17094996],
4104                [32, 17094997],
4105                [33, 17094998],
4106                [34, 17094999],
4107                [35, 17095000],
4108                [36, 17095001],
4109                [37, 17095002],
4110                [38, 17095003],
4111                [39, 17095004],
4112                [40, 17095005],
4113                [41, 17095006],
4114                [42, 17095007],
4115                [43, 17095008],
4116                [44, 17095009],
4117                [45, 17095010],
4118                [46, 17095011],
4119                [47, 17095012],
4120                [48, 17095013],
4121                [49, 17095014],
4122                [50, 17095015]
4123            ]
4124        );
4125        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4126        assert_eq!(
4127            pairs,
4128            vec![
4129                [9, 17137287],
4130                [10, 17137288],
4131                [11, 17137289],
4132                [12, 17137290],
4133                [13, 17137291],
4134                [14, 17137292],
4135                [15, 17137293],
4136                [16, 17137294],
4137                [17, 17137295],
4138                [18, 17137296],
4139                [19, 17137297],
4140                [20, 17137298],
4141                [21, 17137299],
4142                [22, 17137300],
4143                [23, 17137301],
4144                [24, 17137302],
4145                [25, 17137303],
4146                [26, 17137304],
4147                [27, 17137305],
4148                [28, 17137306],
4149                [29, 17137307],
4150                [30, 17137308],
4151                [31, 17137309],
4152                [32, 17137310],
4153                [33, 17137311],
4154                [34, 17137312],
4155                [35, 17137313],
4156                [36, 17137314],
4157                [37, 17137315],
4158                [38, 17137316],
4159                [39, 17137317],
4160                [40, 17137318],
4161                [41, 17137319]
4162            ]
4163        );
4164        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4165        assert_eq!(
4166            pairs,
4167            vec![
4168                [2, 17306238],
4169                [3, 17306239],
4170                [4, 17306240],
4171                [5, 17306241],
4172                [6, 17306242],
4173                [7, 17306243],
4174                [8, 17306244],
4175                [9, 17306245],
4176                [10, 17306246],
4177                [11, 17306247],
4178                [12, 17306248],
4179                [13, 17306249],
4180                [14, 17306250],
4181                [15, 17306251],
4182                [16, 17306252],
4183                [17, 17306253],
4184                [18, 17306254],
4185                [19, 17306255],
4186                [20, 17306256],
4187                [21, 17306257],
4188                [22, 17306258],
4189                [23, 17306259],
4190                [24, 17306260],
4191                [25, 17306261],
4192                [26, 17306262],
4193                [27, 17306263],
4194                [28, 17306264],
4195                [29, 17306265],
4196                [30, 17306266],
4197                [31, 17306267],
4198                [32, 17306268],
4199                [33, 17306269],
4200                [34, 17306270],
4201                [35, 17306271],
4202                [36, 17306272],
4203                [37, 17306273],
4204                [38, 17306274],
4205                [39, 17306275],
4206                [40, 17306276],
4207                [41, 17306277],
4208                [42, 17306278],
4209                [43, 17306279],
4210                [44, 17306280],
4211                [45, 17306281],
4212                [46, 17306282],
4213                [47, 17306283],
4214                [48, 17306284],
4215                [49, 17306285]
4216            ]
4217        );
4218        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4219        assert_eq!(
4220            pairs,
4221            vec![
4222                [4, 17561868],
4223                [5, 17561869],
4224                [6, 17561870],
4225                [7, 17561871],
4226                [8, 17561872],
4227                [9, 17561873],
4228                [10, 17561874],
4229                [11, 17561875],
4230                [12, 17561876],
4231                [13, 17561877],
4232                [14, 17561878],
4233                [15, 17561879],
4234                [16, 17561880],
4235                [17, 17561881],
4236                [18, 17561882],
4237                [19, 17561883],
4238                [20, 17561884],
4239                [21, 17561885],
4240                [22, 17561886],
4241                [23, 17561887],
4242                [24, 17561888],
4243                [25, 17561889],
4244                [26, 17561890],
4245                [27, 17561891],
4246                [28, 17561892],
4247                [29, 17561893],
4248                [30, 17561894],
4249                [31, 17561895],
4250                [32, 17561896],
4251                [33, 17561897],
4252                [34, 17561898],
4253                [35, 17561899],
4254                [36, 17561900],
4255                [37, 17561901],
4256                [38, 17561902],
4257                [39, 17561903],
4258                [40, 17561904],
4259                [41, 17561905],
4260                [42, 17561906],
4261                [43, 17561907],
4262                [44, 17561908],
4263                [45, 17561909],
4264                [46, 17561910],
4265                [47, 17561911],
4266                [48, 17561912]
4267            ]
4268        );
4269        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4270        assert_eq!(
4271            pairs,
4272            vec![
4273                [0, 17566078],
4274                [1, 17566079],
4275                [2, 17566080],
4276                [3, 17566081],
4277                [4, 17566082],
4278                [5, 17566083],
4279                [6, 17566084],
4280                [7, 17566085],
4281                [8, 17566086],
4282                [9, 17566087],
4283                [10, 17566088],
4284                [11, 17566089],
4285                [12, 17566090],
4286                [13, 17566091],
4287                [14, 17566092],
4288                [15, 17566093],
4289                [16, 17566094],
4290                [17, 17566095],
4291                [18, 17566096],
4292                [19, 17566097],
4293                [20, 17566098],
4294                [21, 17566099],
4295                [22, 17566100],
4296                [23, 17566101],
4297                [24, 17566102],
4298                [25, 17566103],
4299                [26, 17566104],
4300                [27, 17566105],
4301                [28, 17566106],
4302                [29, 17566107],
4303                [30, 17566108],
4304                [31, 17566109],
4305                [32, 17566110],
4306                [33, 17566111],
4307                [34, 17566112],
4308                [35, 17566113],
4309                [36, 17566114],
4310                [37, 17566115],
4311                [38, 17566116],
4312                [39, 17566117],
4313                [40, 17566118],
4314                [41, 17577951],
4315                [42, 17577952],
4316                [43, 17577953],
4317                [44, 17577954],
4318                [45, 17577955],
4319                [46, 17577956],
4320                [47, 17577957],
4321                [48, 17577958],
4322                [49, 17577959],
4323                [50, 17577960]
4324            ]
4325        );
4326        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4327        assert_eq!(
4328            pairs,
4329            vec![
4330                [0, 17566108],
4331                [1, 17566109],
4332                [2, 17566110],
4333                [3, 17566111],
4334                [4, 17566112],
4335                [5, 17566113],
4336                [6, 17566114],
4337                [7, 17566115],
4338                [8, 17566116],
4339                [9, 17566117],
4340                [10, 17566118],
4341                [11, 17577951],
4342                [12, 17577952],
4343                [13, 17577953],
4344                [14, 17577954],
4345                [15, 17577955],
4346                [16, 17577956],
4347                [17, 17577957],
4348                [18, 17577958],
4349                [19, 17577959],
4350                [20, 17577960],
4351                [21, 17577961],
4352                [22, 17577962],
4353                [23, 17577963],
4354                [24, 17577964],
4355                [25, 17577965],
4356                [26, 17577966],
4357                [27, 17577967],
4358                [28, 17577968],
4359                [29, 17577969],
4360                [30, 17577970],
4361                [31, 17577971],
4362                [32, 17577972],
4363                [33, 17577973],
4364                [34, 17577974],
4365                [35, 17577975],
4366                [36, 17578686],
4367                [37, 17578687],
4368                [38, 17578688],
4369                [39, 17578689],
4370                [40, 17578690],
4371                [41, 17578691],
4372                [42, 17578692],
4373                [43, 17578693],
4374                [44, 17578694],
4375                [45, 17578695],
4376                [46, 17578696],
4377                [47, 17578697],
4378                [48, 17578698],
4379                [49, 17578699],
4380                [50, 17578700]
4381            ]
4382        );
4383        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4384        assert_eq!(
4385            pairs,
4386            vec![
4387                [0, 17566111],
4388                [1, 17566112],
4389                [2, 17566113],
4390                [3, 17566114],
4391                [4, 17566115],
4392                [5, 17566116],
4393                [6, 17566117],
4394                [7, 17566118],
4395                [8, 17577951],
4396                [9, 17577952],
4397                [10, 17577953],
4398                [11, 17577954],
4399                [12, 17577955],
4400                [13, 17577956],
4401                [14, 17577957],
4402                [15, 17577958],
4403                [16, 17577959],
4404                [17, 17577960],
4405                [18, 17577961],
4406                [19, 17577962],
4407                [20, 17577963],
4408                [21, 17577964],
4409                [22, 17577965],
4410                [23, 17577966],
4411                [24, 17577967],
4412                [25, 17577968],
4413                [26, 17577969],
4414                [27, 17577970],
4415                [28, 17577971],
4416                [29, 17577972],
4417                [30, 17577973],
4418                [31, 17577974],
4419                [32, 17577975],
4420                [33, 17578686],
4421                [34, 17578687],
4422                [35, 17578688],
4423                [36, 17578689],
4424                [37, 17578690],
4425                [38, 17578691],
4426                [39, 17578692],
4427                [40, 17578693],
4428                [41, 17578694],
4429                [42, 17578695],
4430                [43, 17578696],
4431                [44, 17578697],
4432                [45, 17578698],
4433                [46, 17578699],
4434                [47, 17578700],
4435                [48, 17578701],
4436                [49, 17578702],
4437                [50, 17578703]
4438            ]
4439        );
4440        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4441        assert_eq!(
4442            pairs,
4443            vec![
4444                [0, 17566111],
4445                [1, 17566112],
4446                [2, 17566113],
4447                [3, 17566114],
4448                [4, 17566115],
4449                [5, 17566116],
4450                [6, 17566117],
4451                [7, 17566118],
4452                [8, 17577951],
4453                [9, 17577952],
4454                [10, 17577953],
4455                [11, 17577954],
4456                [12, 17577955],
4457                [13, 17577956],
4458                [14, 17577957],
4459                [15, 17577958],
4460                [16, 17577959],
4461                [17, 17577960],
4462                [18, 17577961],
4463                [19, 17577962],
4464                [20, 17577963],
4465                [21, 17577964],
4466                [22, 17577965],
4467                [23, 17577966],
4468                [24, 17577967],
4469                [25, 17577968],
4470                [26, 17577969],
4471                [27, 17577970],
4472                [28, 17577971],
4473                [29, 17577972],
4474                [30, 17577973],
4475                [31, 17577974],
4476                [32, 17577975],
4477                [33, 17578686],
4478                [34, 17578687],
4479                [35, 17578688],
4480                [36, 17578689],
4481                [37, 17578690],
4482                [38, 17578691],
4483                [39, 17578692],
4484                [40, 17578693],
4485                [41, 17578694],
4486                [42, 17578695],
4487                [43, 17578696],
4488                [44, 17578697],
4489                [45, 17578698],
4490                [46, 17578699],
4491                [47, 17578700],
4492                [48, 17578701],
4493                [49, 17578702],
4494                [50, 17578703]
4495            ]
4496        );
4497        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4498        assert_eq!(
4499            pairs,
4500            vec![
4501                [0, 17566111],
4502                [1, 17566112],
4503                [2, 17566113],
4504                [3, 17566114],
4505                [4, 17566115],
4506                [5, 17566116],
4507                [6, 17566117],
4508                [7, 17566118],
4509                [8, 17577951],
4510                [9, 17577952],
4511                [10, 17577953],
4512                [11, 17577954],
4513                [12, 17577955],
4514                [13, 17577956],
4515                [14, 17577957],
4516                [15, 17577958],
4517                [16, 17577959],
4518                [17, 17577960],
4519                [18, 17577961],
4520                [19, 17577962],
4521                [20, 17577963],
4522                [21, 17577964],
4523                [22, 17577965],
4524                [23, 17577966],
4525                [24, 17577967],
4526                [25, 17577968],
4527                [26, 17577969],
4528                [27, 17577970],
4529                [28, 17577971],
4530                [29, 17577972],
4531                [30, 17577973],
4532                [31, 17577974],
4533                [32, 17577975],
4534                [33, 17578686],
4535                [34, 17578687],
4536                [35, 17578688],
4537                [36, 17578689],
4538                [37, 17578690],
4539                [38, 17578691],
4540                [39, 17578692],
4541                [40, 17578693],
4542                [41, 17578694],
4543                [42, 17578695],
4544                [43, 17578696],
4545                [44, 17578697],
4546                [45, 17578698],
4547                [46, 17578699],
4548                [47, 17578700],
4549                [48, 17578701],
4550                [49, 17578702],
4551                [50, 17578703]
4552            ]
4553        );
4554        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4555        assert_eq!(
4556            pairs,
4557            vec![
4558                [0, 17566111],
4559                [1, 17566112],
4560                [2, 17566113],
4561                [3, 17566114],
4562                [4, 17566115],
4563                [5, 17566116],
4564                [6, 17566117],
4565                [7, 17566118],
4566                [8, 17577951],
4567                [9, 17577952],
4568                [10, 17577953],
4569                [11, 17577954],
4570                [12, 17577955],
4571                [13, 17577956],
4572                [14, 17577957],
4573                [15, 17577958],
4574                [16, 17577959],
4575                [17, 17577960],
4576                [18, 17577961],
4577                [19, 17577962],
4578                [20, 17577963],
4579                [21, 17577964],
4580                [22, 17577965],
4581                [23, 17577966],
4582                [24, 17577967],
4583                [25, 17577968],
4584                [26, 17577969],
4585                [27, 17577970],
4586                [28, 17577971],
4587                [29, 17577972],
4588                [30, 17577973],
4589                [31, 17577974],
4590                [32, 17577975],
4591                [33, 17578686],
4592                [34, 17578687],
4593                [35, 17578688],
4594                [36, 17578689],
4595                [37, 17578690],
4596                [38, 17578691],
4597                [39, 17578692],
4598                [40, 17578693],
4599                [41, 17578694],
4600                [42, 17578695],
4601                [43, 17578696],
4602                [44, 17578697],
4603                [45, 17578698],
4604                [46, 17578699],
4605                [47, 17578700],
4606                [48, 17578701],
4607                [49, 17578702],
4608                [50, 17578703]
4609            ]
4610        );
4611        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4612        assert_eq!(
4613            pairs,
4614            vec![
4615                [0, 17566112],
4616                [1, 17566113],
4617                [2, 17566114],
4618                [3, 17566115],
4619                [4, 17566116],
4620                [5, 17566117],
4621                [6, 17566118],
4622                [7, 17577951],
4623                [8, 17577952],
4624                [9, 17577953],
4625                [10, 17577954],
4626                [11, 17577955],
4627                [12, 17577956],
4628                [13, 17577957],
4629                [14, 17577958],
4630                [15, 17577959],
4631                [16, 17577960],
4632                [17, 17577961],
4633                [18, 17577962],
4634                [19, 17577963],
4635                [20, 17577964],
4636                [21, 17577965],
4637                [22, 17577966],
4638                [23, 17577967],
4639                [24, 17577968],
4640                [25, 17577969],
4641                [26, 17577970],
4642                [27, 17577971],
4643                [28, 17577972],
4644                [29, 17577973],
4645                [30, 17577974],
4646                [31, 17577975],
4647                [32, 17578686],
4648                [33, 17578687],
4649                [34, 17578688],
4650                [35, 17578689],
4651                [36, 17578690],
4652                [37, 17578691],
4653                [38, 17578692],
4654                [39, 17578693],
4655                [40, 17578694],
4656                [41, 17578695],
4657                [42, 17578696],
4658                [43, 17578697],
4659                [44, 17578698],
4660                [45, 17578699],
4661                [46, 17578700],
4662                [47, 17578701],
4663                [48, 17578702],
4664                [49, 17578703],
4665                [50, 17578704]
4666            ]
4667        );
4668        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4669        assert_eq!(
4670            pairs,
4671            vec![
4672                [0, 17566113],
4673                [1, 17566114],
4674                [2, 17566115],
4675                [3, 17566116],
4676                [4, 17566117],
4677                [5, 17566118],
4678                [6, 17577951],
4679                [7, 17577952],
4680                [8, 17577953],
4681                [9, 17577954],
4682                [10, 17577955],
4683                [11, 17577956],
4684                [12, 17577957],
4685                [13, 17577958],
4686                [14, 17577959],
4687                [15, 17577960],
4688                [16, 17577961],
4689                [17, 17577962],
4690                [18, 17577963],
4691                [19, 17577964],
4692                [20, 17577965],
4693                [21, 17577966],
4694                [22, 17577967],
4695                [23, 17577968],
4696                [24, 17577969],
4697                [25, 17577970],
4698                [26, 17577971],
4699                [27, 17577972],
4700                [28, 17577973],
4701                [29, 17577974],
4702                [30, 17577975],
4703                [31, 17578686],
4704                [32, 17578687],
4705                [33, 17578688],
4706                [34, 17578689],
4707                [35, 17578690],
4708                [36, 17578691],
4709                [37, 17578692],
4710                [38, 17578693],
4711                [39, 17578694],
4712                [40, 17578695],
4713                [41, 17578696],
4714                [42, 17578697],
4715                [43, 17578698],
4716                [44, 17578699],
4717                [45, 17578700],
4718                [46, 17578701],
4719                [47, 17578702],
4720                [48, 17578703],
4721                [49, 17578704],
4722                [50, 17578705]
4723            ]
4724        );
4725        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4726        assert_eq!(
4727            pairs,
4728            vec![
4729                [0, 17566113],
4730                [1, 17566114],
4731                [2, 17566115],
4732                [3, 17566116],
4733                [4, 17566117],
4734                [5, 17566118],
4735                [6, 17577951],
4736                [7, 17577952],
4737                [8, 17577953],
4738                [9, 17577954],
4739                [10, 17577955],
4740                [11, 17577956],
4741                [12, 17577957],
4742                [13, 17577958],
4743                [14, 17577959],
4744                [15, 17577960],
4745                [16, 17577961],
4746                [17, 17577962],
4747                [18, 17577963],
4748                [19, 17577964],
4749                [20, 17577965],
4750                [21, 17577966],
4751                [22, 17577967],
4752                [23, 17577968],
4753                [24, 17577969],
4754                [25, 17577970],
4755                [26, 17577971],
4756                [27, 17577972],
4757                [28, 17577973],
4758                [29, 17577974],
4759                [30, 17577975],
4760                [31, 17578686],
4761                [32, 17578687],
4762                [33, 17578688],
4763                [34, 17578689],
4764                [35, 17578690],
4765                [36, 17578691],
4766                [37, 17578692],
4767                [38, 17578693],
4768                [39, 17578694],
4769                [40, 17578695],
4770                [41, 17578696],
4771                [42, 17578697],
4772                [43, 17578698],
4773                [44, 17578699],
4774                [45, 17578700],
4775                [46, 17578701],
4776                [47, 17578702],
4777                [48, 17578703],
4778                [49, 17578704],
4779                [50, 17578705]
4780            ]
4781        );
4782        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4783        assert_eq!(
4784            pairs,
4785            vec![
4786                [1, 17579733],
4787                [2, 17579734],
4788                [3, 17579735],
4789                [4, 17579736],
4790                [5, 17579737],
4791                [6, 17579738],
4792                [7, 17579739],
4793                [8, 17579740],
4794                [9, 17579741],
4795                [10, 17579742],
4796                [11, 17579743],
4797                [12, 17579744],
4798                [13, 17579745],
4799                [14, 17579746],
4800                [15, 17579747],
4801                [16, 17579748],
4802                [17, 17579749],
4803                [18, 17579750],
4804                [19, 17579751],
4805                [20, 17579752],
4806                [21, 17579753],
4807                [22, 17579754],
4808                [23, 17579755],
4809                [24, 17579756],
4810                [25, 17579757],
4811                [26, 17579758],
4812                [27, 17579759],
4813                [28, 17579760],
4814                [29, 17579761],
4815                [30, 17579762],
4816                [31, 17579763],
4817                [32, 17579764],
4818                [33, 17579765],
4819                [34, 17579766],
4820                [35, 17579767],
4821                [36, 17579768],
4822                [37, 17579769],
4823                [38, 17579770],
4824                [39, 17579771],
4825                [40, 17579772],
4826                [41, 17579773],
4827                [42, 17579774],
4828                [43, 17579775],
4829                [44, 17579776],
4830                [45, 17581244],
4831                [46, 17581245],
4832                [47, 17581246],
4833                [48, 17581247],
4834                [49, 17581248],
4835                [50, 17581249]
4836            ]
4837        );
4838        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4839        assert_eq!(
4840            pairs,
4841            vec![
4842                [0, 17581369],
4843                [1, 17581370],
4844                [2, 17582885],
4845                [3, 17582886],
4846                [4, 17582887],
4847                [5, 17582888],
4848                [6, 17582889],
4849                [7, 17582890],
4850                [8, 17582891],
4851                [9, 17582892],
4852                [10, 17582893],
4853                [11, 17582894],
4854                [12, 17582895],
4855                [13, 17582896],
4856                [14, 17582897],
4857                [15, 17582898],
4858                [16, 17582899],
4859                [17, 17582900],
4860                [18, 17582901],
4861                [19, 17582902],
4862                [20, 17582903],
4863                [21, 17582904],
4864                [22, 17582905],
4865                [23, 17582906],
4866                [24, 17582907],
4867                [25, 17582908],
4868                [26, 17582909],
4869                [27, 17582910],
4870                [28, 17582911],
4871                [29, 17582912],
4872                [30, 17582913],
4873                [31, 17582914],
4874                [32, 17582915],
4875                [33, 17582916],
4876                [34, 17582917],
4877                [35, 17582918],
4878                [36, 17582919],
4879                [37, 17582920],
4880                [38, 17582921],
4881                [39, 17582922],
4882                [40, 17582923],
4883                [41, 17582924],
4884                [42, 17582925],
4885                [43, 17582926],
4886                [44, 17582927],
4887                [45, 17582928],
4888                [46, 17582929],
4889                [47, 17582930],
4890                [48, 17582931],
4891                [49, 17582932],
4892                [50, 17583028]
4893            ]
4894        );
4895        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4896        assert_eq!(
4897            pairs,
4898            vec![
4899                [0, 17581370],
4900                [1, 17582885],
4901                [2, 17582886],
4902                [3, 17582887],
4903                [4, 17582888],
4904                [5, 17582889],
4905                [6, 17582890],
4906                [7, 17582891],
4907                [8, 17582892],
4908                [9, 17582893],
4909                [10, 17582894],
4910                [11, 17582895],
4911                [12, 17582896],
4912                [13, 17582897],
4913                [14, 17582898],
4914                [15, 17582899],
4915                [16, 17582900],
4916                [17, 17582901],
4917                [18, 17582902],
4918                [19, 17582903],
4919                [20, 17582904],
4920                [21, 17582905],
4921                [22, 17582906],
4922                [23, 17582907],
4923                [24, 17582908],
4924                [25, 17582909],
4925                [26, 17582910],
4926                [27, 17582911],
4927                [28, 17582912],
4928                [29, 17582913],
4929                [30, 17582914],
4930                [31, 17582915],
4931                [32, 17582916],
4932                [33, 17582917],
4933                [34, 17582918],
4934                [35, 17582919],
4935                [36, 17582920],
4936                [37, 17582921],
4937                [38, 17582922],
4938                [39, 17582923],
4939                [40, 17582924],
4940                [41, 17582925],
4941                [42, 17582926],
4942                [43, 17582927],
4943                [44, 17582928],
4944                [45, 17582929],
4945                [46, 17582930],
4946                [47, 17582931],
4947                [48, 17582932],
4948                [49, 17583028],
4949                [50, 17583029]
4950            ]
4951        );
4952        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
4953        assert_eq!(
4954            pairs,
4955            vec![
4956                [0, 17581370],
4957                [1, 17582885],
4958                [2, 17582886],
4959                [3, 17582887],
4960                [4, 17582888],
4961                [5, 17582889],
4962                [6, 17582890],
4963                [7, 17582891],
4964                [8, 17582892],
4965                [9, 17582893],
4966                [10, 17582894],
4967                [11, 17582895],
4968                [12, 17582896],
4969                [13, 17582897],
4970                [14, 17582898],
4971                [15, 17582899],
4972                [16, 17582900],
4973                [17, 17582901],
4974                [18, 17582902],
4975                [19, 17582903],
4976                [20, 17582904],
4977                [21, 17582905],
4978                [22, 17582906],
4979                [23, 17582907],
4980                [24, 17582908],
4981                [25, 17582909],
4982                [26, 17582910],
4983                [27, 17582911],
4984                [28, 17582912],
4985                [29, 17582913],
4986                [30, 17582914],
4987                [31, 17582915],
4988                [32, 17582916],
4989                [33, 17582917],
4990                [34, 17582918],
4991                [35, 17582919],
4992                [36, 17582920],
4993                [37, 17582921],
4994                [38, 17582922],
4995                [39, 17582923],
4996                [40, 17582924],
4997                [41, 17582925],
4998                [42, 17582926],
4999                [43, 17582927],
5000                [44, 17582928],
5001                [45, 17582929],
5002                [46, 17582930],
5003                [47, 17582931],
5004                [48, 17582932],
5005                [49, 17583028],
5006                [50, 17583029]
5007            ]
5008        );
5009        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
5010        assert_eq!(
5011            pairs,
5012            vec![
5013                [1, 17582911],
5014                [2, 17582912],
5015                [3, 17582913],
5016                [4, 17582914],
5017                [5, 17582915],
5018                [6, 17582916],
5019                [7, 17582917],
5020                [8, 17582918],
5021                [9, 17582919],
5022                [10, 17582920],
5023                [11, 17582921],
5024                [12, 17582922],
5025                [13, 17582923],
5026                [14, 17582924],
5027                [15, 17582925],
5028                [16, 17582926],
5029                [17, 17582927],
5030                [18, 17582928],
5031                [19, 17582929],
5032                [20, 17582930],
5033                [21, 17582931],
5034                [22, 17582932],
5035                [23, 17583028],
5036                [24, 17583029],
5037                [25, 17583030],
5038                [26, 17583031],
5039                [27, 17583032],
5040                [28, 17583033],
5041                [29, 17583034],
5042                [30, 17583035],
5043                [31, 17583036],
5044                [32, 17583037],
5045                [33, 17583038],
5046                [34, 17583039],
5047                [35, 17583040],
5048                [36, 17583041],
5049                [37, 17583042],
5050                [38, 17583043],
5051                [39, 17583044],
5052                [40, 17583045],
5053                [41, 17583046],
5054                [42, 17583047],
5055                [43, 17583048],
5056                [44, 17583049],
5057                [45, 17583050],
5058                [46, 17583051],
5059                [47, 17583052],
5060                [48, 17583053],
5061                [49, 17583054],
5062                [50, 17583055]
5063            ]
5064        );
5065        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
5066        assert_eq!(
5067            pairs,
5068            vec![
5069                [0, 17588621],
5070                [1, 17588622],
5071                [2, 17588623],
5072                [3, 17588624],
5073                [4, 17588625],
5074                [5, 17588626],
5075                [6, 17588627],
5076                [7, 17588628],
5077                [8, 17588629],
5078                [9, 17588630],
5079                [10, 17588631],
5080                [11, 17588632],
5081                [12, 17588633],
5082                [13, 17588634],
5083                [14, 17588635],
5084                [15, 17588636],
5085                [16, 17588637],
5086                [17, 17588638],
5087                [18, 17588639],
5088                [19, 17588640],
5089                [20, 17588641],
5090                [21, 17588642],
5091                [22, 17588643],
5092                [23, 17588644],
5093                [24, 17588645],
5094                [25, 17588646],
5095                [26, 17588647],
5096                [27, 17588648],
5097                [28, 17588649],
5098                [29, 17588650],
5099                [30, 17588651],
5100                [31, 17588652],
5101                [32, 17588653],
5102                [33, 17588654],
5103                [34, 17588655],
5104                [35, 17588656],
5105                [36, 17588657],
5106                [37, 17589196],
5107                [38, 17589197],
5108                [39, 17589198],
5109                [40, 17589199],
5110                [41, 17589200],
5111                [42, 17589201],
5112                [43, 17589202],
5113                [44, 17589203],
5114                [45, 17589204],
5115                [46, 17589205],
5116                [47, 17589206],
5117                [48, 17589207],
5118                [49, 17589208]
5119            ]
5120        );
5121        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
5122        assert_eq!(
5123            pairs,
5124            vec![
5125                [0, 17588621],
5126                [1, 17588622],
5127                [2, 17588623],
5128                [3, 17588624],
5129                [4, 17588625],
5130                [5, 17588626],
5131                [6, 17588627],
5132                [7, 17588628],
5133                [8, 17588629],
5134                [9, 17588630],
5135                [10, 17588631],
5136                [11, 17588632],
5137                [12, 17588633],
5138                [13, 17588634],
5139                [14, 17588635],
5140                [15, 17588636],
5141                [16, 17588637],
5142                [17, 17588638],
5143                [18, 17588639],
5144                [19, 17588640],
5145                [20, 17588641],
5146                [21, 17588642],
5147                [22, 17588643],
5148                [23, 17588644],
5149                [24, 17588645],
5150                [25, 17588646],
5151                [26, 17588647],
5152                [27, 17588648],
5153                [28, 17588649],
5154                [29, 17588650],
5155                [30, 17588651],
5156                [31, 17588652],
5157                [32, 17588653],
5158                [33, 17588654],
5159                [34, 17588655],
5160                [35, 17588656],
5161                [36, 17588657],
5162                [37, 17589196],
5163                [38, 17589197],
5164                [39, 17589198],
5165                [40, 17589199],
5166                [41, 17589200],
5167                [42, 17589201],
5168                [43, 17589202],
5169                [44, 17589203],
5170                [45, 17589204],
5171                [46, 17589205],
5172                [47, 17589206],
5173                [48, 17589207],
5174                [49, 17589208]
5175            ]
5176        );
5177        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
5178        assert_eq!(
5179            pairs,
5180            vec![
5181                [0, 17588621],
5182                [1, 17588622],
5183                [2, 17588623],
5184                [3, 17588624],
5185                [4, 17588625],
5186                [5, 17588626],
5187                [6, 17588627],
5188                [7, 17588628],
5189                [8, 17588629],
5190                [9, 17588630],
5191                [10, 17588631],
5192                [11, 17588632],
5193                [12, 17588633],
5194                [13, 17588634],
5195                [14, 17588635],
5196                [15, 17588636],
5197                [16, 17588637],
5198                [17, 17588638],
5199                [18, 17588639],
5200                [19, 17588640],
5201                [20, 17588641],
5202                [21, 17588642],
5203                [22, 17588643],
5204                [23, 17588644],
5205                [24, 17588645],
5206                [25, 17588646],
5207                [26, 17588647],
5208                [27, 17588648],
5209                [28, 17588649],
5210                [29, 17588650],
5211                [30, 17588651],
5212                [31, 17588652],
5213                [32, 17588653],
5214                [33, 17588654],
5215                [34, 17588655],
5216                [35, 17588656],
5217                [36, 17588657],
5218                [37, 17589196],
5219                [38, 17589197],
5220                [39, 17589198],
5221                [40, 17589199],
5222                [41, 17589200],
5223                [42, 17589201],
5224                [43, 17589202],
5225                [44, 17589203],
5226                [45, 17589204],
5227                [46, 17589205],
5228                [47, 17589206],
5229                [48, 17589207],
5230                [49, 17589208]
5231            ]
5232        );
5233        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
5234        assert_eq!(
5235            pairs,
5236            vec![
5237                [1, 17591770],
5238                [2, 17591771],
5239                [3, 17591772],
5240                [4, 17591773],
5241                [5, 17591774],
5242                [6, 17591775],
5243                [7, 17591776],
5244                [8, 17591777],
5245                [9, 17591778],
5246                [10, 17591779],
5247                [11, 17591780],
5248                [12, 17591781],
5249                [13, 17591782],
5250                [14, 17591783],
5251                [15, 17591784],
5252                [16, 17591785],
5253                [17, 17591786],
5254                [18, 17591787],
5255                [19, 17591788],
5256                [20, 17591789],
5257                [21, 17591790],
5258                [22, 17591791],
5259                [23, 17591792],
5260                [24, 17591793],
5261                [25, 17591794],
5262                [26, 17591796],
5263                [27, 17591797],
5264                [28, 17591798],
5265                [29, 17591799],
5266                [30, 17591800],
5267                [31, 17591801],
5268                [32, 17591802],
5269                [33, 17591803],
5270                [34, 17591804],
5271                [35, 17591805],
5272                [36, 17591806],
5273                [37, 17591807],
5274                [38, 17591808],
5275                [39, 17591809],
5276                [40, 17591810],
5277                [41, 17591811],
5278                [42, 17591812],
5279                [43, 17591813],
5280                [44, 17591814],
5281                [45, 17591815],
5282                [46, 17591816],
5283                [47, 17591817],
5284                [48, 17591818],
5285                [49, 17591819],
5286                [50, 17591820]
5287            ]
5288        );
5289        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
5290        assert_eq!(
5291            pairs,
5292            vec![
5293                [0, 17593855],
5294                [1, 17593856],
5295                [2, 17593857],
5296                [3, 17593858],
5297                [4, 17593859],
5298                [5, 17593860],
5299                [6, 17593861],
5300                [7, 17593862],
5301                [8, 17593863],
5302                [9, 17593864],
5303                [10, 17593865],
5304                [11, 17593866],
5305                [12, 17593867],
5306                [13, 17593868],
5307                [14, 17593869],
5308                [15, 17593870],
5309                [16, 17593871],
5310                [17, 17593872],
5311                [18, 17593873],
5312                [19, 17593874],
5313                [20, 17593875],
5314                [21, 17593876],
5315                [22, 17593877],
5316                [23, 17593878],
5317                [24, 17593880],
5318                [25, 17593881],
5319                [26, 17593882],
5320                [27, 17593883],
5321                [28, 17593884],
5322                [29, 17593885],
5323                [30, 17593886],
5324                [31, 17593887],
5325                [32, 17593888],
5326                [33, 17593889],
5327                [34, 17593890],
5328                [35, 17593891],
5329                [36, 17593892],
5330                [37, 17593893],
5331                [38, 17593894],
5332                [39, 17593895],
5333                [40, 17593896],
5334                [41, 17593897],
5335                [42, 17593898],
5336                [43, 17593899],
5337                [44, 17593900],
5338                [45, 17593901],
5339                [46, 17593902],
5340                [47, 17593903]
5341            ]
5342        );
5343        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
5344        assert_eq!(
5345            pairs,
5346            vec![
5347                [0, 17593863],
5348                [1, 17593864],
5349                [2, 17593865],
5350                [3, 17593866],
5351                [4, 17593867],
5352                [5, 17593868],
5353                [6, 17593869],
5354                [7, 17593870],
5355                [8, 17593871],
5356                [9, 17593872],
5357                [10, 17593873],
5358                [11, 17593874],
5359                [12, 17593875],
5360                [13, 17593876],
5361                [14, 17593877],
5362                [15, 17593878],
5363                [16, 17593880],
5364                [17, 17593881],
5365                [18, 17593882],
5366                [19, 17593883],
5367                [20, 17593884],
5368                [21, 17593885],
5369                [22, 17593886],
5370                [23, 17593887],
5371                [24, 17593888],
5372                [25, 17593889],
5373                [26, 17593890],
5374                [27, 17593891],
5375                [28, 17593892],
5376                [29, 17593893],
5377                [30, 17593894],
5378                [31, 17593895],
5379                [32, 17593896],
5380                [33, 17593897],
5381                [34, 17593898],
5382                [35, 17593899],
5383                [36, 17593900],
5384                [37, 17593901],
5385                [38, 17593902],
5386                [39, 17593903],
5387                [40, 17593904],
5388                [41, 17593905],
5389                [42, 17593906],
5390                [43, 17593907]
5391            ]
5392        );
5393        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
5394        assert_eq!(
5395            pairs,
5396            vec![
5397                [11, 17596476],
5398                [12, 17596477],
5399                [13, 17596478],
5400                [14, 17596479],
5401                [15, 17596480],
5402                [16, 17596481],
5403                [17, 17596482],
5404                [19, 17596483],
5405                [20, 17596484],
5406                [21, 17596485],
5407                [22, 17596486],
5408                [23, 17596487],
5409                [24, 17596488],
5410                [25, 17596489],
5411                [26, 17596490],
5412                [27, 17596491],
5413                [28, 17596492],
5414                [29, 17596493],
5415                [30, 17596494],
5416                [31, 17596495],
5417                [32, 17596496],
5418                [33, 17596497],
5419                [34, 17596498],
5420                [35, 17596499],
5421                [36, 17596500],
5422                [37, 17596501],
5423                [38, 17596502],
5424                [39, 17596503],
5425                [40, 17596504],
5426                [41, 17596505],
5427                [42, 17596506],
5428                [43, 17596507],
5429                [44, 17596508],
5430                [45, 17596509],
5431                [46, 17596510],
5432                [47, 17596511],
5433                [48, 17596512],
5434                [49, 17596513],
5435                [50, 17596514]
5436            ]
5437        );
5438        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
5439        assert_eq!(
5440            pairs,
5441            vec![
5442                [5, 17624012],
5443                [6, 17624013],
5444                [7, 17624014],
5445                [8, 17624015],
5446                [9, 17624016],
5447                [10, 17624017],
5448                [11, 17624018],
5449                [12, 17624019],
5450                [13, 17624020],
5451                [14, 17625913],
5452                [15, 17625914],
5453                [16, 17625915],
5454                [17, 17625916],
5455                [18, 17625917],
5456                [19, 17625918],
5457                [20, 17625919],
5458                [21, 17625920],
5459                [22, 17625921],
5460                [23, 17625922],
5461                [24, 17625923],
5462                [25, 17625924],
5463                [26, 17625925],
5464                [27, 17625926],
5465                [28, 17625927],
5466                [29, 17625928],
5467                [30, 17625929],
5468                [31, 17625930],
5469                [32, 17625931],
5470                [33, 17625932],
5471                [34, 17625933],
5472                [35, 17625934],
5473                [36, 17625935],
5474                [37, 17625936],
5475                [38, 17625937],
5476                [39, 17625938],
5477                [40, 17625939],
5478                [41, 17625940],
5479                [42, 17625941],
5480                [43, 17625942],
5481                [44, 17625943],
5482                [45, 17625944],
5483                [46, 17625945],
5484                [47, 17625946],
5485                [48, 17625947],
5486                [49, 17625948],
5487                [50, 17625949]
5488            ]
5489        );
5490        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
5491        assert_eq!(
5492            pairs,
5493            vec![
5494                [2, 17624012],
5495                [3, 17624013],
5496                [4, 17624014],
5497                [5, 17624015],
5498                [6, 17624016],
5499                [7, 17624017],
5500                [8, 17624018],
5501                [9, 17624019],
5502                [10, 17624020],
5503                [11, 17625913],
5504                [12, 17625914],
5505                [13, 17625915],
5506                [14, 17625916],
5507                [15, 17625917],
5508                [16, 17625918],
5509                [17, 17625919],
5510                [18, 17625920],
5511                [19, 17625921],
5512                [20, 17625922],
5513                [21, 17625923],
5514                [22, 17625924],
5515                [23, 17625925],
5516                [24, 17625926],
5517                [25, 17625927],
5518                [26, 17625928],
5519                [27, 17625929],
5520                [28, 17625930],
5521                [29, 17625931],
5522                [30, 17625932],
5523                [31, 17625933],
5524                [32, 17625934],
5525                [33, 17625935],
5526                [34, 17625936],
5527                [35, 17625937],
5528                [36, 17625938],
5529                [37, 17625939],
5530                [38, 17625940],
5531                [39, 17625941],
5532                [40, 17625942],
5533                [41, 17625943],
5534                [42, 17625944],
5535                [43, 17625945],
5536                [44, 17625946],
5537                [45, 17625947],
5538                [46, 17625948],
5539                [47, 17625949],
5540                [48, 17625950],
5541                [49, 17625951],
5542                [50, 17625952]
5543            ]
5544        );
5545        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
5546        assert_eq!(
5547            pairs,
5548            vec![
5549                [1, 31796700],
5550                [2, 31796701],
5551                [3, 31796702],
5552                [4, 31796703],
5553                [5, 31796704],
5554                [6, 31796705],
5555                [7, 31796706],
5556                [8, 31796710],
5557                [9, 31796711],
5558                [10, 31796712],
5559                [11, 31796713],
5560                [12, 31796714],
5561                [13, 31796715],
5562                [14, 31796716],
5563                [15, 31796717],
5564                [16, 31796718],
5565                [17, 31796719],
5566                [18, 31796720],
5567                [19, 31796721],
5568                [20, 31796722],
5569                [21, 31796723],
5570                [22, 31796724],
5571                [23, 31796725],
5572                [24, 31796726],
5573                [25, 31796727],
5574                [26, 31796728],
5575                [27, 31799014],
5576                [28, 31799015],
5577                [29, 31799016],
5578                [30, 31799017],
5579                [31, 31799018],
5580                [32, 31799019],
5581                [33, 31799020],
5582                [34, 31799021],
5583                [35, 31799022],
5584                [36, 31799023],
5585                [37, 31799024],
5586                [38, 31799025],
5587                [39, 31799026],
5588                [40, 31799027],
5589                [41, 31799028],
5590                [42, 31799029],
5591                [43, 31799030],
5592                [44, 31799031],
5593                [45, 31799032],
5594                [46, 31799033],
5595                [47, 31799034],
5596                [48, 31799035],
5597                [49, 31799036],
5598                [50, 31799037]
5599            ]
5600        );
5601        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
5602        assert_eq!(
5603            pairs,
5604            vec![
5605                [0, 36722692],
5606                [1, 36722693],
5607                [2, 36722694],
5608                [3, 36722695],
5609                [4, 36722696],
5610                [5, 36722697],
5611                [6, 36722698],
5612                [7, 36722699],
5613                [8, 36722700],
5614                [9, 36722701],
5615                [10, 36722702],
5616                [11, 36722703],
5617                [12, 36722704],
5618                [13, 36722705],
5619                [14, 36723505],
5620                [15, 36723506],
5621                [16, 36723507],
5622                [17, 36723508],
5623                [18, 36723509],
5624                [19, 36723510],
5625                [20, 36723511],
5626                [21, 36723512],
5627                [22, 36723513],
5628                [23, 36723514],
5629                [24, 36723515],
5630                [25, 36723516],
5631                [26, 36723517],
5632                [27, 36723518],
5633                [28, 36723519],
5634                [29, 36723520],
5635                [30, 36723521],
5636                [31, 36723522],
5637                [32, 36723523],
5638                [33, 36723524],
5639                [34, 36723525],
5640                [35, 36723526],
5641                [36, 36723527],
5642                [37, 36723528],
5643                [38, 36723529],
5644                [39, 36723530],
5645                [40, 36723531],
5646                [41, 36723532],
5647                [42, 36737414],
5648                [43, 36737415],
5649                [44, 36737416],
5650                [45, 36737417],
5651                [46, 36737418],
5652                [47, 36737419],
5653                [48, 36737420]
5654            ]
5655        );
5656        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
5657        assert_eq!(
5658            pairs,
5659            vec![
5660                [4, 44587963],
5661                [5, 44587964],
5662                [6, 44587965],
5663                [7, 44587966],
5664                [8, 44587967],
5665                [9, 44587968],
5666                [10, 44587969],
5667                [11, 44587970],
5668                [12, 44587971],
5669                [13, 44587972],
5670                [14, 44587973],
5671                [15, 44587974],
5672                [16, 44587975],
5673                [17, 44587976],
5674                [18, 44587977],
5675                [19, 44587978],
5676                [20, 44587979],
5677                [21, 44587980],
5678                [22, 44587981],
5679                [23, 44587982],
5680                [24, 44587983],
5681                [25, 44589680],
5682                [26, 44589681],
5683                [27, 44589682],
5684                [28, 44589683],
5685                [29, 44589684],
5686                [30, 44589685],
5687                [31, 44589686],
5688                [32, 44589687],
5689                [33, 44589688],
5690                [34, 44589689],
5691                [35, 44589690],
5692                [36, 44589691],
5693                [37, 44589692],
5694                [38, 44589693],
5695                [39, 44589694],
5696                [40, 44589695],
5697                [41, 44589696],
5698                [42, 44589697],
5699                [43, 44589698],
5700                [44, 44589699],
5701                [45, 44589700],
5702                [46, 44589701],
5703                [47, 44589702],
5704                [48, 44592034],
5705                [49, 44592035],
5706                [50, 44592036]
5707            ]
5708        );
5709    }
5710    #[test]
5711    fn test_cigar_full() {
5712        let mut bam = bam::Reader::from_path("./test/locusmd.bam").unwrap();
5713        let mut it = bam.records();
5714        let test = it.next().unwrap().unwrap();
5715        let pairs: Vec<_> = test.aligned_block_pairs_cigar().collect();
5716        assert_eq!(
5717            pairs,
5718            vec![
5719                (0..15, 99812479..99812494, Cigar::Equal(15)),
5720                (15..16, 99812494..99812494, Cigar::Ins(1)),
5721                (16..83, 99812494..99812561, Cigar::Equal(67)),
5722                (83..84, 99812561..99812561, Cigar::Ins(1)),
5723                (84..413, 99812561..99812890, Cigar::Equal(329)),
5724                (413..413, 99812890..99812891, Cigar::Del(1)),
5725                (413..538, 99812891..99813016, Cigar::Equal(125)),
5726                (538..539, 99813016..99813016, Cigar::Ins(1)),
5727                (539..597, 99813016..99813074, Cigar::Equal(58)),
5728                (597..597, 99813074..99813075, Cigar::Del(1)),
5729                (597..1498, 99813075..99813976, Cigar::Equal(901)),
5730                (1498..1499, 99813976..99813976, Cigar::Ins(1)),
5731                (1499..1779, 99813976..99814256, Cigar::Equal(280)),
5732                (1779..1779, 99814256..99814257, Cigar::Del(1)),
5733                (1779..1939, 99814257..99814417, Cigar::Equal(160)),
5734                (1939..1939, 99814417..99814418, Cigar::Del(1)),
5735                (1939..1962, 99814418..99814441, Cigar::Equal(23)),
5736                (1962..1962, 99814441..99814442, Cigar::Del(1)),
5737                (1962..1994, 99814442..99814474, Cigar::Equal(32)),
5738                (1994..1994, 99814474..99814475, Cigar::Del(1)),
5739                (1994..2067, 99814475..99814548, Cigar::Equal(73)),
5740                (2067..2068, 99814548..99814548, Cigar::Ins(1)),
5741                (2068..2368, 99814548..99814848, Cigar::Equal(300)),
5742                (2368..2368, 99814848..99814850, Cigar::Del(2)),
5743                (2368..2384, 99814850..99814866, Cigar::Equal(16)),
5744                (2384..2384, 99814866..99814867, Cigar::Del(1)),
5745                (2384..2785, 99814867..99815268, Cigar::Equal(401)),
5746                (2785..2785, 99815268..99815269, Cigar::Del(1)),
5747                (2785..2790, 99815269..99815274, Cigar::Equal(5)),
5748                (2790..2791, 99815274..99815275, Cigar::Diff(1)),
5749                (2791..2867, 99815275..99815351, Cigar::Equal(76)),
5750                (2867..2867, 99815351..99815352, Cigar::Del(1)),
5751                (2867..3126, 99815352..99815611, Cigar::Equal(259)),
5752                (3126..3127, 99815611..99815612, Cigar::Diff(1)),
5753                (3127..3314, 99815612..99815799, Cigar::Equal(187)),
5754                (3314..3314, 99815799..99815800, Cigar::Del(1)),
5755                (3314..3331, 99815800..99815817, Cigar::Equal(17)),
5756                (3331..3331, 99815817..99815818, Cigar::Del(1)),
5757                (3331..3367, 99815818..99815854, Cigar::Equal(36)),
5758                (3367..3367, 99815854..99815855, Cigar::Del(1)),
5759                (3367..3430, 99815855..99815918, Cigar::Equal(63)),
5760                (3430..3430, 99815918..99815919, Cigar::Del(1)),
5761                (3430..3469, 99815919..99815958, Cigar::Equal(39)),
5762                (3469..3469, 99815958..99815959, Cigar::Del(1)),
5763                (3469..3508, 99815959..99815998, Cigar::Equal(39)),
5764                (3508..3508, 99815998..99815999, Cigar::Del(1)),
5765                (3508..3701, 99815999..99816192, Cigar::Equal(193)),
5766                (3701..3701, 99816192..99816193, Cigar::Del(1)),
5767                (3701..3829, 99816193..99816321, Cigar::Equal(128)),
5768                (3829..3830, 99816321..99816321, Cigar::Ins(1)),
5769                (3830..4519, 99816321..99817010, Cigar::Equal(689)),
5770                (4519..4520, 99817010..99817010, Cigar::Ins(1)),
5771                (4520..4569, 99817010..99817059, Cigar::Equal(49)),
5772                (4569..4569, 99817059..99817060, Cigar::Del(1)),
5773                (4569..4702, 99817060..99817193, Cigar::Equal(133)),
5774                (4702..4702, 99817193..99817194, Cigar::Del(1)),
5775                (4702..4888, 99817194..99817380, Cigar::Equal(186)),
5776                (4888..4889, 99817380..99817380, Cigar::Ins(1)),
5777                (4889..4981, 99817380..99817472, Cigar::Equal(92)),
5778                (4981..4982, 99817472..99817472, Cigar::Ins(1)),
5779                (4982..5089, 99817472..99817579, Cigar::Equal(107)),
5780                (5089..5090, 99817579..99817579, Cigar::Ins(1)),
5781                (5090..5132, 99817579..99817621, Cigar::Equal(42)),
5782                (5132..5133, 99817621..99817621, Cigar::Ins(1)),
5783                (5133..5383, 99817621..99817871, Cigar::Equal(250)),
5784                (5383..5383, 99817871..99817872, Cigar::Del(1)),
5785                (5383..5451, 99817872..99817940, Cigar::Equal(68)),
5786                (5451..5451, 99817940..99817941, Cigar::Del(1)),
5787                (5451..5457, 99817941..99817947, Cigar::Equal(6)),
5788                (5457..5457, 99817947..99817948, Cigar::Del(1)),
5789                (5457..5593, 99817948..99818084, Cigar::Equal(136)),
5790                (5593..5594, 99818084..99818084, Cigar::Ins(1)),
5791                (5594..5900, 99818084..99818390, Cigar::Equal(306)),
5792                (5900..5901, 99818390..99818390, Cigar::Ins(1)),
5793                (5901..5932, 99818390..99818421, Cigar::Equal(31)),
5794                (5932..5933, 99818421..99818421, Cigar::Ins(1)),
5795                (5933..6100, 99818421..99818588, Cigar::Equal(167)),
5796                (6100..6100, 99818588..99818589, Cigar::Del(1)),
5797                (6100..6256, 99818589..99818745, Cigar::Equal(156)),
5798                (6256..6257, 99818745..99818746, Cigar::Diff(1)),
5799                (6257..7576, 99818746..99820065, Cigar::Equal(1319)),
5800                (7576..7576, 99820065..99820066, Cigar::Del(1)),
5801                (7576..7884, 99820066..99820374, Cigar::Equal(308)),
5802                (7884..7884, 99820374..99820375, Cigar::Del(1)),
5803                (7884..7951, 99820375..99820442, Cigar::Equal(67)),
5804                (7951..7951, 99820442..99820443, Cigar::Del(1)),
5805                (7951..8159, 99820443..99820651, Cigar::Equal(208)),
5806                (8159..8159, 99820651..99820653, Cigar::Del(2)),
5807                (8159..8225, 99820653..99820719, Cigar::Equal(66)),
5808                (8225..8226, 99820719..99820719, Cigar::Ins(1)),
5809                (8226..8229, 99820719..99820722, Cigar::Equal(3)),
5810                (8229..8229, 99820722..99820723, Cigar::Del(1)),
5811                (8229..8245, 99820723..99820739, Cigar::Equal(16)),
5812                (8245..8245, 99820739..99820740, Cigar::Del(1)),
5813                (8245..8283, 99820740..99820778, Cigar::Equal(38)),
5814                (8283..8283, 99820778..99820780, Cigar::Del(2)),
5815                (8283..8285, 99820780..99820782, Cigar::Equal(2)),
5816                (8285..8286, 99820782..99820783, Cigar::Diff(1)),
5817                (8286..8326, 99820783..99820823, Cigar::Equal(40)),
5818                (8326..8326, 99820823..99820824, Cigar::Del(1)),
5819                (8326..8454, 99820824..99820952, Cigar::Equal(128)),
5820                (8454..8454, 99820952..99820953, Cigar::Del(1)),
5821                (8454..8508, 99820953..99821007, Cigar::Equal(54)),
5822                (8508..8509, 99821007..99821007, Cigar::Ins(1)),
5823                (8509..8560, 99821007..99821058, Cigar::Equal(51)),
5824                (8560..8560, 99821058..99821059, Cigar::Del(1)),
5825                (8560..8833, 99821059..99821332, Cigar::Equal(273)),
5826                (8833..8833, 99821332..99821333, Cigar::Del(1)),
5827                (8833..8836, 99821333..99821336, Cigar::Equal(3)),
5828                (8836..8836, 99821336..99821337, Cigar::Del(1)),
5829                (8836..9061, 99821337..99821562, Cigar::Equal(225)),
5830                (9061..9061, 99821562..99821563, Cigar::Del(1)),
5831                (9061..9065, 99821563..99821567, Cigar::Equal(4)),
5832                (9065..9065, 99821567..99821568, Cigar::Del(1)),
5833                (9065..9110, 99821568..99821613, Cigar::Equal(45)),
5834                (9110..9110, 99821613..99821615, Cigar::Del(2)),
5835                (9110..9163, 99821615..99821668, Cigar::Equal(53)),
5836                (9163..9163, 99821668..99821669, Cigar::Del(1)),
5837                (9163..9390, 99821669..99821896, Cigar::Equal(227)),
5838                (9390..9390, 99821896..99821897, Cigar::Del(1)),
5839                (9390..9427, 99821897..99821934, Cigar::Equal(37)),
5840                (9427..9430, 99821934..99821937, Cigar::Diff(3)),
5841                (9430..9461, 99821937..99821968, Cigar::Equal(31)),
5842                (9461..9461, 99821968..99821970, Cigar::Del(2)),
5843                (9461..9493, 99821970..99822002, Cigar::Equal(32)),
5844                (9493..9493, 99822002..99822004, Cigar::Del(2)),
5845                (9493..9692, 99822004..99822203, Cigar::Equal(199)),
5846                (9692..9693, 99822203..99822204, Cigar::Diff(1)),
5847                (9693..9829, 99822204..99822340, Cigar::Equal(136)),
5848                (9829..9829, 99822340..99822342, Cigar::Del(2)),
5849                (9829..9870, 99822342..99822383, Cigar::Equal(41)),
5850                (9870..9870, 99822383..99822386, Cigar::Del(3)),
5851                (9870..9915, 99822386..99822431, Cigar::Equal(45)),
5852                (9915..9915, 99822431..99822432, Cigar::Del(1)),
5853                (9915..10285, 99822432..99822802, Cigar::Equal(370)),
5854                (10285..10285, 99822802..99822803, Cigar::Del(1)),
5855                (10285..10480, 99822803..99822998, Cigar::Equal(195)),
5856                (10480..10480, 99822998..99822999, Cigar::Del(1)),
5857                (10480..10721, 99822999..99823240, Cigar::Equal(241)),
5858                (10721..10722, 99823240..99823240, Cigar::Ins(1)),
5859                (10722..11122, 99823240..99823640, Cigar::Equal(400)),
5860                (11122..11122, 99823640..99823641, Cigar::Del(1)),
5861                (11122..11230, 99823641..99823749, Cigar::Equal(108)),
5862                (11230..11230, 99823749..99823750, Cigar::Del(1)),
5863                (11230..11911, 99823750..99824431, Cigar::Equal(681)),
5864                (11911..11912, 99824431..99824431, Cigar::Ins(1)),
5865                (11912..12102, 99824431..99824621, Cigar::Equal(190)),
5866                (12102..12102, 99824621..99824622, Cigar::Del(1)),
5867                (12102..12870, 99824622..99825390, Cigar::Equal(768)),
5868                (12870..12870, 99825390..99825391, Cigar::Del(1)),
5869                (12870..12978, 99825391..99825499, Cigar::Equal(108)),
5870                (12978..12978, 99825499..99825500, Cigar::Del(1)),
5871                (12978..13419, 99825500..99825941, Cigar::Equal(441)),
5872                (13419..13419, 99825941..99825942, Cigar::Del(1)),
5873                (13419..13617, 99825942..99826140, Cigar::Equal(198)),
5874                (13617..13617, 99826140..99826141, Cigar::Del(1)),
5875                (13617..13697, 99826141..99826221, Cigar::Equal(80)),
5876                (13697..13698, 99826221..99826221, Cigar::Ins(1)),
5877                (13698..13811, 99826221..99826334, Cigar::Equal(113)),
5878                (13811..13812, 99826334..99826334, Cigar::Ins(1)),
5879                (13812..14020, 99826334..99826542, Cigar::Equal(208)),
5880                (14020..14020, 99826542..99826543, Cigar::Del(1)),
5881                (14020..14524, 99826543..99827047, Cigar::Equal(504)),
5882                (14524..14524, 99827047..99827048, Cigar::Del(1)),
5883                (14524..14533, 99827048..99827057, Cigar::Equal(9)),
5884                (14533..14534, 99827057..99827057, Cigar::Ins(1)),
5885                (14534..14787, 99827057..99827310, Cigar::Equal(253)),
5886                (14787..14788, 99827310..99827310, Cigar::Ins(1)),
5887                (14788..14901, 99827310..99827423, Cigar::Equal(113)),
5888                (14901..14901, 99827423..99827424, Cigar::Del(1)),
5889                (14901..15001, 99827424..99827524, Cigar::Equal(100)),
5890                (15001..15002, 99827524..99827524, Cigar::Ins(1)),
5891                (15002..15166, 99827524..99827688, Cigar::Equal(164)),
5892                (15166..15166, 99827688..99827689, Cigar::Del(1)),
5893                (15166..15805, 99827689..99828328, Cigar::Equal(639)),
5894                (15805..15805, 99828328..99828329, Cigar::Del(1)),
5895                (15805..16195, 99828329..99828719, Cigar::Equal(390)),
5896                (16195..16195, 99828719..99828721, Cigar::Del(2)),
5897                (16195..16576, 99828721..99829102, Cigar::Equal(381)),
5898                (16576..16577, 99829102..99829102, Cigar::Ins(1)),
5899                (16577..16912, 99829102..99829437, Cigar::Equal(335)),
5900                (16912..16912, 99829437..99829438, Cigar::Del(1)),
5901                (16912..17896, 99829438..99830422, Cigar::Equal(984)),
5902                (17896..17897, 99830422..99830422, Cigar::Ins(1)),
5903                (17897..18370, 99830422..99830895, Cigar::Equal(473)),
5904                (18370..18370, 99830895..99830896, Cigar::Del(1)),
5905                (18370..18410, 99830896..99830936, Cigar::Equal(40)),
5906                (18410..18410, 99830936..99830937, Cigar::Del(1)),
5907                (18410..18449, 99830937..99830976, Cigar::Equal(39)),
5908                (18449..18450, 99830976..99830976, Cigar::Ins(1)),
5909                (18450..18675, 99830976..99831201, Cigar::Equal(225)),
5910                (18675..18675, 99831201..99831202, Cigar::Del(1)),
5911                (18675..18729, 99831202..99831256, Cigar::Equal(54)),
5912                (18729..18729, 99831256..99831257, Cigar::Del(1)),
5913                (18729..18812, 99831257..99831340, Cigar::Equal(83)),
5914                (18812..18813, 99831340..99831340, Cigar::Ins(1)),
5915                (18813..18895, 99831340..99831422, Cigar::Equal(82)),
5916                (18895..18895, 99831422..99831423, Cigar::Del(1)),
5917                (18895..19239, 99831423..99831767, Cigar::Equal(344)),
5918                (19239..19240, 99831767..99831767, Cigar::Ins(1)),
5919                (19240..19244, 99831767..99831771, Cigar::Equal(4)),
5920                (19244..19245, 99831771..99831771, Cigar::Ins(1)),
5921                (19245..19387, 99831771..99831913, Cigar::Equal(142)),
5922                (19387..19387, 99831913..99831914, Cigar::Del(1)),
5923                (19387..19883, 99831914..99832410, Cigar::Equal(496)),
5924            ]
5925        );
5926        assert_eq!(
5927            test.aligned_block_pairs_cigar_match()
5928                .unwrap()
5929                .into_iter()
5930                .filter_map(|a| match a {
5931                    (Some((a, b)), _) => Some(((a.start, a.end), (b.start, b.end))),
5932                    (None, _) => None,
5933                })
5934                .collect::<Vec<_>>(),
5935            //Block pairs and aligned blocks must match
5936            test.aligned_block_pairs_match()
5937                .unwrap()
5938                .into_iter()
5939                .map(|(a, b)| ((a[0], a[1]), (b[0], b[1])))
5940                .collect::<Vec<_>>(),
5941            "Invalid alignment of pairs and cigar"
5942        );
5943        let pairs: Vec<_> = test.aligned_block_pairs_cigar_match().unwrap().collect();
5944        assert_eq!(
5945            pairs,
5946            vec![
5947                (Some((0..15, 99812479..99812494)), Cigar::Equal(15)),
5948                (None, Cigar::Ins(1)),
5949                (Some((16..83, 99812494..99812561)), Cigar::Equal(67)),
5950                (None, Cigar::Ins(1)),
5951                (Some((84..413, 99812561..99812890)), Cigar::Equal(329)),
5952                (None, Cigar::Del(1)),
5953                (Some((413..538, 99812891..99813016)), Cigar::Equal(125)),
5954                (None, Cigar::Ins(1)),
5955                (Some((539..597, 99813016..99813074)), Cigar::Equal(58)),
5956                (None, Cigar::Del(1)),
5957                (Some((597..1498, 99813075..99813976)), Cigar::Equal(901)),
5958                (None, Cigar::Ins(1)),
5959                (Some((1499..1779, 99813976..99814256)), Cigar::Equal(280)),
5960                (None, Cigar::Del(1)),
5961                (Some((1779..1939, 99814257..99814417)), Cigar::Equal(160)),
5962                (None, Cigar::Del(1)),
5963                (Some((1939..1962, 99814418..99814441)), Cigar::Equal(23)),
5964                (None, Cigar::Del(1)),
5965                (Some((1962..1994, 99814442..99814474)), Cigar::Equal(32)),
5966                (None, Cigar::Del(1)),
5967                (Some((1994..2067, 99814475..99814548)), Cigar::Equal(73)),
5968                (None, Cigar::Ins(1)),
5969                (Some((2068..2368, 99814548..99814848)), Cigar::Equal(300)),
5970                (None, Cigar::Del(2)),
5971                (Some((2368..2384, 99814850..99814866)), Cigar::Equal(16)),
5972                (None, Cigar::Del(1)),
5973                (Some((2384..2785, 99814867..99815268)), Cigar::Equal(401)),
5974                (None, Cigar::Del(1)),
5975                (Some((2785..2790, 99815269..99815274)), Cigar::Equal(5)),
5976                (None, Cigar::Diff(1)),
5977                (Some((2791..2867, 99815275..99815351)), Cigar::Equal(76)),
5978                (None, Cigar::Del(1)),
5979                (Some((2867..3126, 99815352..99815611)), Cigar::Equal(259)),
5980                (None, Cigar::Diff(1)),
5981                (Some((3127..3314, 99815612..99815799)), Cigar::Equal(187)),
5982                (None, Cigar::Del(1)),
5983                (Some((3314..3331, 99815800..99815817)), Cigar::Equal(17)),
5984                (None, Cigar::Del(1)),
5985                (Some((3331..3367, 99815818..99815854)), Cigar::Equal(36)),
5986                (None, Cigar::Del(1)),
5987                (Some((3367..3430, 99815855..99815918)), Cigar::Equal(63)),
5988                (None, Cigar::Del(1)),
5989                (Some((3430..3469, 99815919..99815958)), Cigar::Equal(39)),
5990                (None, Cigar::Del(1)),
5991                (Some((3469..3508, 99815959..99815998)), Cigar::Equal(39)),
5992                (None, Cigar::Del(1)),
5993                (Some((3508..3701, 99815999..99816192)), Cigar::Equal(193)),
5994                (None, Cigar::Del(1)),
5995                (Some((3701..3829, 99816193..99816321)), Cigar::Equal(128)),
5996                (None, Cigar::Ins(1)),
5997                (Some((3830..4519, 99816321..99817010)), Cigar::Equal(689)),
5998                (None, Cigar::Ins(1)),
5999                (Some((4520..4569, 99817010..99817059)), Cigar::Equal(49)),
6000                (None, Cigar::Del(1)),
6001                (Some((4569..4702, 99817060..99817193)), Cigar::Equal(133)),
6002                (None, Cigar::Del(1)),
6003                (Some((4702..4888, 99817194..99817380)), Cigar::Equal(186)),
6004                (None, Cigar::Ins(1)),
6005                (Some((4889..4981, 99817380..99817472)), Cigar::Equal(92)),
6006                (None, Cigar::Ins(1)),
6007                (Some((4982..5089, 99817472..99817579)), Cigar::Equal(107)),
6008                (None, Cigar::Ins(1)),
6009                (Some((5090..5132, 99817579..99817621)), Cigar::Equal(42)),
6010                (None, Cigar::Ins(1)),
6011                (Some((5133..5383, 99817621..99817871)), Cigar::Equal(250)),
6012                (None, Cigar::Del(1)),
6013                (Some((5383..5451, 99817872..99817940)), Cigar::Equal(68)),
6014                (None, Cigar::Del(1)),
6015                (Some((5451..5457, 99817941..99817947)), Cigar::Equal(6)),
6016                (None, Cigar::Del(1)),
6017                (Some((5457..5593, 99817948..99818084)), Cigar::Equal(136)),
6018                (None, Cigar::Ins(1)),
6019                (Some((5594..5900, 99818084..99818390)), Cigar::Equal(306)),
6020                (None, Cigar::Ins(1)),
6021                (Some((5901..5932, 99818390..99818421)), Cigar::Equal(31)),
6022                (None, Cigar::Ins(1)),
6023                (Some((5933..6100, 99818421..99818588)), Cigar::Equal(167)),
6024                (None, Cigar::Del(1)),
6025                (Some((6100..6256, 99818589..99818745)), Cigar::Equal(156)),
6026                (None, Cigar::Diff(1)),
6027                (Some((6257..7576, 99818746..99820065)), Cigar::Equal(1319)),
6028                (None, Cigar::Del(1)),
6029                (Some((7576..7884, 99820066..99820374)), Cigar::Equal(308)),
6030                (None, Cigar::Del(1)),
6031                (Some((7884..7951, 99820375..99820442)), Cigar::Equal(67)),
6032                (None, Cigar::Del(1)),
6033                (Some((7951..8159, 99820443..99820651)), Cigar::Equal(208)),
6034                (None, Cigar::Del(2)),
6035                (Some((8159..8225, 99820653..99820719)), Cigar::Equal(66)),
6036                (None, Cigar::Ins(1)),
6037                (Some((8226..8229, 99820719..99820722)), Cigar::Equal(3)),
6038                (None, Cigar::Del(1)),
6039                (Some((8229..8245, 99820723..99820739)), Cigar::Equal(16)),
6040                (None, Cigar::Del(1)),
6041                (Some((8245..8283, 99820740..99820778)), Cigar::Equal(38)),
6042                (None, Cigar::Del(2)),
6043                (Some((8283..8285, 99820780..99820782)), Cigar::Equal(2)),
6044                (None, Cigar::Diff(1)),
6045                (Some((8286..8326, 99820783..99820823)), Cigar::Equal(40)),
6046                (None, Cigar::Del(1)),
6047                (Some((8326..8454, 99820824..99820952)), Cigar::Equal(128)),
6048                (None, Cigar::Del(1)),
6049                (Some((8454..8508, 99820953..99821007)), Cigar::Equal(54)),
6050                (None, Cigar::Ins(1)),
6051                (Some((8509..8560, 99821007..99821058)), Cigar::Equal(51)),
6052                (None, Cigar::Del(1)),
6053                (Some((8560..8833, 99821059..99821332)), Cigar::Equal(273)),
6054                (None, Cigar::Del(1)),
6055                (Some((8833..8836, 99821333..99821336)), Cigar::Equal(3)),
6056                (None, Cigar::Del(1)),
6057                (Some((8836..9061, 99821337..99821562)), Cigar::Equal(225)),
6058                (None, Cigar::Del(1)),
6059                (Some((9061..9065, 99821563..99821567)), Cigar::Equal(4)),
6060                (None, Cigar::Del(1)),
6061                (Some((9065..9110, 99821568..99821613)), Cigar::Equal(45)),
6062                (None, Cigar::Del(2)),
6063                (Some((9110..9163, 99821615..99821668)), Cigar::Equal(53)),
6064                (None, Cigar::Del(1)),
6065                (Some((9163..9390, 99821669..99821896)), Cigar::Equal(227)),
6066                (None, Cigar::Del(1)),
6067                (Some((9390..9427, 99821897..99821934)), Cigar::Equal(37)),
6068                (None, Cigar::Diff(3)),
6069                (Some((9430..9461, 99821937..99821968)), Cigar::Equal(31)),
6070                (None, Cigar::Del(2)),
6071                (Some((9461..9493, 99821970..99822002)), Cigar::Equal(32)),
6072                (None, Cigar::Del(2)),
6073                (Some((9493..9692, 99822004..99822203)), Cigar::Equal(199)),
6074                (None, Cigar::Diff(1)),
6075                (Some((9693..9829, 99822204..99822340)), Cigar::Equal(136)),
6076                (None, Cigar::Del(2)),
6077                (Some((9829..9870, 99822342..99822383)), Cigar::Equal(41)),
6078                (None, Cigar::Del(3)),
6079                (Some((9870..9915, 99822386..99822431)), Cigar::Equal(45)),
6080                (None, Cigar::Del(1)),
6081                (Some((9915..10285, 99822432..99822802)), Cigar::Equal(370)),
6082                (None, Cigar::Del(1)),
6083                (Some((10285..10480, 99822803..99822998)), Cigar::Equal(195)),
6084                (None, Cigar::Del(1)),
6085                (Some((10480..10721, 99822999..99823240)), Cigar::Equal(241)),
6086                (None, Cigar::Ins(1)),
6087                (Some((10722..11122, 99823240..99823640)), Cigar::Equal(400)),
6088                (None, Cigar::Del(1)),
6089                (Some((11122..11230, 99823641..99823749)), Cigar::Equal(108)),
6090                (None, Cigar::Del(1)),
6091                (Some((11230..11911, 99823750..99824431)), Cigar::Equal(681)),
6092                (None, Cigar::Ins(1)),
6093                (Some((11912..12102, 99824431..99824621)), Cigar::Equal(190)),
6094                (None, Cigar::Del(1)),
6095                (Some((12102..12870, 99824622..99825390)), Cigar::Equal(768)),
6096                (None, Cigar::Del(1)),
6097                (Some((12870..12978, 99825391..99825499)), Cigar::Equal(108)),
6098                (None, Cigar::Del(1)),
6099                (Some((12978..13419, 99825500..99825941)), Cigar::Equal(441)),
6100                (None, Cigar::Del(1)),
6101                (Some((13419..13617, 99825942..99826140)), Cigar::Equal(198)),
6102                (None, Cigar::Del(1)),
6103                (Some((13617..13697, 99826141..99826221)), Cigar::Equal(80)),
6104                (None, Cigar::Ins(1)),
6105                (Some((13698..13811, 99826221..99826334)), Cigar::Equal(113)),
6106                (None, Cigar::Ins(1)),
6107                (Some((13812..14020, 99826334..99826542)), Cigar::Equal(208)),
6108                (None, Cigar::Del(1)),
6109                (Some((14020..14524, 99826543..99827047)), Cigar::Equal(504)),
6110                (None, Cigar::Del(1)),
6111                (Some((14524..14533, 99827048..99827057)), Cigar::Equal(9)),
6112                (None, Cigar::Ins(1)),
6113                (Some((14534..14787, 99827057..99827310)), Cigar::Equal(253)),
6114                (None, Cigar::Ins(1)),
6115                (Some((14788..14901, 99827310..99827423)), Cigar::Equal(113)),
6116                (None, Cigar::Del(1)),
6117                (Some((14901..15001, 99827424..99827524)), Cigar::Equal(100)),
6118                (None, Cigar::Ins(1)),
6119                (Some((15002..15166, 99827524..99827688)), Cigar::Equal(164)),
6120                (None, Cigar::Del(1)),
6121                (Some((15166..15805, 99827689..99828328)), Cigar::Equal(639)),
6122                (None, Cigar::Del(1)),
6123                (Some((15805..16195, 99828329..99828719)), Cigar::Equal(390)),
6124                (None, Cigar::Del(2)),
6125                (Some((16195..16576, 99828721..99829102)), Cigar::Equal(381)),
6126                (None, Cigar::Ins(1)),
6127                (Some((16577..16912, 99829102..99829437)), Cigar::Equal(335)),
6128                (None, Cigar::Del(1)),
6129                (Some((16912..17896, 99829438..99830422)), Cigar::Equal(984)),
6130                (None, Cigar::Ins(1)),
6131                (Some((17897..18370, 99830422..99830895)), Cigar::Equal(473)),
6132                (None, Cigar::Del(1)),
6133                (Some((18370..18410, 99830896..99830936)), Cigar::Equal(40)),
6134                (None, Cigar::Del(1)),
6135                (Some((18410..18449, 99830937..99830976)), Cigar::Equal(39)),
6136                (None, Cigar::Ins(1)),
6137                (Some((18450..18675, 99830976..99831201)), Cigar::Equal(225)),
6138                (None, Cigar::Del(1)),
6139                (Some((18675..18729, 99831202..99831256)), Cigar::Equal(54)),
6140                (None, Cigar::Del(1)),
6141                (Some((18729..18812, 99831257..99831340)), Cigar::Equal(83)),
6142                (None, Cigar::Ins(1)),
6143                (Some((18813..18895, 99831340..99831422)), Cigar::Equal(82)),
6144                (None, Cigar::Del(1)),
6145                (Some((18895..19239, 99831423..99831767)), Cigar::Equal(344)),
6146                (None, Cigar::Ins(1)),
6147                (Some((19240..19244, 99831767..99831771)), Cigar::Equal(4)),
6148                (None, Cigar::Ins(1)),
6149                (Some((19245..19387, 99831771..99831913)), Cigar::Equal(142)),
6150                (None, Cigar::Del(1)),
6151                (Some((19387..19883, 99831914..99832410)), Cigar::Equal(496))
6152            ]
6153        );
6154        let mut bam = bam::Reader::from_path("./test/setcigar.sam").unwrap();
6155        let mut it = bam.rc_records();
6156        let hit = it
6157            .next()
6158            .unwrap()
6159            .unwrap()
6160            .aligned_block_pairs_cigar_match();
6161        assert!(hit.is_none())
6162    }
6163    #[test]
6164    fn test_aligned_pairs_full() {
6165        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
6166        let mut it = bam.records();
6167        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6168        assert_eq!(
6169            pairs.clone().into_iter().take(12).collect::<Vec<_>>(),
6170            vec![
6171                [Some(0), None],
6172                [Some(1), None],
6173                [Some(2), None],
6174                [Some(3), None],
6175                [Some(4), None],
6176                [Some(5), None],
6177                [Some(6), Some(16050676)],
6178                [Some(7), Some(16050677)],
6179                [Some(8), Some(16050678)],
6180                [Some(9), Some(16050679)],
6181                [Some(10), Some(16050680)],
6182                [Some(11), Some(16050681)],
6183            ]
6184        );
6185        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6186        assert_eq!(
6187            pairs,
6188            vec![
6189                [Some(0), Some(16096878)],
6190                [Some(1), Some(16096879)],
6191                [Some(2), Some(16096880)],
6192                [Some(3), Some(16096881)],
6193                [Some(4), Some(16096882)],
6194                [Some(5), Some(16096883)],
6195                [Some(6), Some(16096884)],
6196                [None, Some(16096885)],
6197                [None, Some(16096886)],
6198                [Some(7), Some(16096887)],
6199                [Some(8), Some(16096888)],
6200                [Some(9), Some(16096889)],
6201                [Some(10), Some(16096890)],
6202                [Some(11), Some(16096891)],
6203                [Some(12), Some(16096892)],
6204                [Some(13), Some(16096893)],
6205                [Some(14), Some(16096894)],
6206                [Some(15), Some(16096895)],
6207                [Some(16), Some(16096896)],
6208                [Some(17), Some(16096897)],
6209                [Some(18), Some(16096898)],
6210                [Some(19), Some(16096899)],
6211                [Some(20), Some(16096900)],
6212                [Some(21), Some(16096901)],
6213                [Some(22), Some(16096902)],
6214                [Some(23), Some(16096903)],
6215                [Some(24), Some(16096904)],
6216                [Some(25), Some(16096905)],
6217                [Some(26), Some(16096906)],
6218                [Some(27), Some(16096907)],
6219                [Some(28), Some(16096908)],
6220                [Some(29), Some(16096909)],
6221                [Some(30), Some(16096910)],
6222                [Some(31), Some(16096911)],
6223                [Some(32), Some(16096912)],
6224                [Some(33), Some(16096913)],
6225                [Some(34), Some(16096914)],
6226                [Some(35), Some(16096915)],
6227                [Some(36), Some(16096916)],
6228                [Some(37), Some(16096917)],
6229                [Some(38), Some(16096918)],
6230                [Some(39), Some(16096919)],
6231                [Some(40), Some(16096920)],
6232                [Some(41), Some(16096921)],
6233                [Some(42), Some(16096922)],
6234                [Some(43), Some(16096923)],
6235                [Some(44), Some(16096924)],
6236                [Some(45), Some(16096925)],
6237                [Some(46), Some(16096926)],
6238                [Some(47), Some(16096927)],
6239                [Some(48), Some(16096928)],
6240                [Some(49), Some(16096929)],
6241                [Some(50), Some(16096930)]
6242            ]
6243        );
6244        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6245        assert_eq!(
6246            pairs,
6247            vec![
6248                [Some(0), Some(16097145)],
6249                [Some(1), Some(16097146)],
6250                [Some(2), Some(16097147)],
6251                [Some(3), Some(16097148)],
6252                [Some(4), Some(16097149)],
6253                [Some(5), Some(16097150)],
6254                [Some(6), Some(16097151)],
6255                [Some(7), Some(16097152)],
6256                [Some(8), Some(16097153)],
6257                [Some(9), Some(16097154)],
6258                [Some(10), Some(16097155)],
6259                [Some(11), Some(16097156)],
6260                [Some(12), Some(16097157)],
6261                [Some(13), Some(16097158)],
6262                [Some(14), Some(16097159)],
6263                [Some(15), Some(16097160)],
6264                [Some(16), Some(16097161)],
6265                [Some(17), Some(16097162)],
6266                [Some(18), Some(16097163)],
6267                [Some(19), Some(16097164)],
6268                [Some(20), Some(16097165)],
6269                [Some(21), Some(16097166)],
6270                [Some(22), Some(16097167)],
6271                [Some(23), Some(16097168)],
6272                [Some(24), Some(16097169)],
6273                [Some(25), Some(16097170)],
6274                [Some(26), Some(16097171)],
6275                [Some(27), Some(16097172)],
6276                [Some(28), Some(16097173)],
6277                [None, Some(16097174)],
6278                [None, Some(16097175)],
6279                [Some(29), Some(16097176)],
6280                [Some(30), Some(16097177)],
6281                [Some(31), Some(16097178)],
6282                [Some(32), Some(16097179)],
6283                [Some(33), Some(16097180)],
6284                [Some(34), Some(16097181)],
6285                [Some(35), Some(16097182)],
6286                [Some(36), Some(16097183)],
6287                [Some(37), Some(16097184)],
6288                [Some(38), Some(16097185)],
6289                [Some(39), Some(16097186)],
6290                [Some(40), Some(16097187)],
6291                [Some(41), Some(16097188)],
6292                [Some(42), Some(16097189)],
6293                [Some(43), Some(16097190)],
6294                [Some(44), Some(16097191)],
6295                [Some(45), Some(16097192)],
6296                [Some(46), Some(16097193)],
6297                [Some(47), Some(16097194)],
6298                [Some(48), Some(16097195)],
6299                [Some(49), Some(16097196)],
6300                [Some(50), Some(16097197)]
6301            ]
6302        );
6303        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6304        assert_eq!(
6305            pairs,
6306            vec![
6307                [Some(0), Some(16117350)],
6308                [Some(1), Some(16117351)],
6309                [Some(2), Some(16117352)],
6310                [Some(3), Some(16117353)],
6311                [Some(4), Some(16117354)],
6312                [Some(5), Some(16117355)],
6313                [Some(6), Some(16117356)],
6314                [Some(7), Some(16117357)],
6315                [Some(8), Some(16117358)],
6316                [Some(9), Some(16117359)],
6317                [Some(10), Some(16117360)],
6318                [Some(11), Some(16117361)],
6319                [Some(12), Some(16117362)],
6320                [Some(13), Some(16117363)],
6321                [Some(14), Some(16117364)],
6322                [Some(15), Some(16117365)],
6323                [Some(16), Some(16117366)],
6324                [Some(17), Some(16117367)],
6325                [Some(18), Some(16117368)],
6326                [Some(19), Some(16117369)],
6327                [Some(20), Some(16117370)],
6328                [Some(21), Some(16117371)],
6329                [Some(22), Some(16117372)],
6330                [Some(23), Some(16117373)],
6331                [Some(24), Some(16117374)],
6332                [Some(25), Some(16117375)],
6333                [Some(26), Some(16117376)],
6334                [Some(27), Some(16117377)],
6335                [Some(28), Some(16117378)],
6336                [Some(29), Some(16117379)],
6337                [Some(30), Some(16117380)],
6338                [Some(31), Some(16117381)],
6339                [Some(32), Some(16117382)],
6340                [Some(33), Some(16117383)],
6341                [Some(34), Some(16117384)],
6342                [Some(35), Some(16117385)],
6343                [Some(36), Some(16117386)],
6344                [Some(37), Some(16117387)],
6345                [Some(38), Some(16117388)],
6346                [Some(39), Some(16117389)],
6347                [Some(40), Some(16117390)],
6348                [Some(41), Some(16117391)],
6349                [Some(42), Some(16117392)],
6350                [Some(43), Some(16117393)],
6351                [Some(44), Some(16117394)],
6352                [Some(45), Some(16117395)],
6353                [Some(46), Some(16117396)],
6354                [Some(47), Some(16117397)],
6355                [Some(48), Some(16117398)],
6356                [Some(49), Some(16117399)],
6357                [Some(50), Some(16117400)]
6358            ]
6359        );
6360        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6361        assert_eq!(
6362            pairs,
6363            vec![
6364                [Some(0), Some(16118483)],
6365                [Some(1), Some(16118484)],
6366                [Some(2), Some(16118485)],
6367                [Some(3), Some(16118486)],
6368                [Some(4), Some(16118487)],
6369                [Some(5), Some(16118488)],
6370                [Some(6), Some(16118489)],
6371                [Some(7), Some(16118490)],
6372                [Some(8), Some(16118491)],
6373                [Some(9), Some(16118492)],
6374                [Some(10), Some(16118493)],
6375                [Some(11), Some(16118494)],
6376                [Some(12), Some(16118495)],
6377                [Some(13), Some(16118496)],
6378                [Some(14), Some(16118497)],
6379                [Some(15), Some(16118498)],
6380                [Some(16), Some(16118499)],
6381                [Some(17), Some(16118500)],
6382                [Some(18), Some(16118501)],
6383                [Some(19), Some(16118502)],
6384                [Some(20), Some(16118503)],
6385                [Some(21), Some(16118504)],
6386                [Some(22), Some(16118505)],
6387                [Some(23), Some(16118506)],
6388                [Some(24), Some(16118507)],
6389                [Some(25), Some(16118508)],
6390                [Some(26), Some(16118509)],
6391                [Some(27), Some(16118510)],
6392                [Some(28), Some(16118511)],
6393                [Some(29), Some(16118512)],
6394                [Some(30), Some(16118513)],
6395                [Some(31), Some(16118514)],
6396                [Some(32), Some(16118515)],
6397                [Some(33), Some(16118516)],
6398                [Some(34), Some(16118517)],
6399                [Some(35), Some(16118518)],
6400                [Some(36), Some(16118519)],
6401                [Some(37), Some(16118520)],
6402                [Some(38), Some(16118521)],
6403                [Some(39), Some(16118522)],
6404                [Some(40), Some(16118523)],
6405                [Some(41), Some(16118524)],
6406                [Some(42), Some(16118525)],
6407                [Some(43), Some(16118526)],
6408                [Some(44), Some(16118527)],
6409                [Some(45), Some(16118528)],
6410                [Some(46), Some(16118529)],
6411                [Some(47), Some(16118530)],
6412                [Some(48), Some(16118531)],
6413                [Some(49), Some(16118532)],
6414                [Some(50), Some(16118533)]
6415            ]
6416        );
6417
6418        //
6419        //for the rest, we just verify that they have the expected amount of None in each position
6420        fn some_count(pairs: &[[Option<i64>; 2]], pos: usize) -> i64 {
6421            pairs.iter().filter(|x| x[pos].is_some()).count() as i64
6422        }
6423        fn none_count(pairs: &[[Option<i64>; 2]], pos: usize) -> i64 {
6424            pairs.iter().filter(|x| x[pos].is_none()).count() as i64
6425        }
6426
6427        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6428        assert_eq!(some_count(&pairs, 0), 51);
6429        assert_eq!(none_count(&pairs, 0), 0);
6430        assert_eq!(some_count(&pairs, 1), 51);
6431        assert_eq!(none_count(&pairs, 1), 0);
6432        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6433        assert_eq!(some_count(&pairs, 0), 51);
6434        assert_eq!(none_count(&pairs, 0), 0);
6435        assert_eq!(some_count(&pairs, 1), 51);
6436        assert_eq!(none_count(&pairs, 1), 0);
6437        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6438        assert_eq!(some_count(&pairs, 0), 51);
6439        assert_eq!(none_count(&pairs, 0), 0);
6440        assert_eq!(some_count(&pairs, 1), 51);
6441        assert_eq!(none_count(&pairs, 1), 0);
6442        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6443        assert_eq!(some_count(&pairs, 0), 51);
6444        assert_eq!(none_count(&pairs, 0), 0);
6445        assert_eq!(some_count(&pairs, 1), 51);
6446        assert_eq!(none_count(&pairs, 1), 0);
6447        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6448        assert_eq!(some_count(&pairs, 0), 51);
6449        assert_eq!(none_count(&pairs, 0), 0);
6450        assert_eq!(some_count(&pairs, 1), 45);
6451        assert_eq!(none_count(&pairs, 1), 6);
6452        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6453        assert_eq!(some_count(&pairs, 0), 51);
6454        assert_eq!(none_count(&pairs, 0), 0);
6455        assert_eq!(some_count(&pairs, 1), 41);
6456        assert_eq!(none_count(&pairs, 1), 10);
6457        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6458        assert_eq!(some_count(&pairs, 0), 51);
6459        assert_eq!(none_count(&pairs, 0), 0);
6460        assert_eq!(some_count(&pairs, 1), 51);
6461        assert_eq!(none_count(&pairs, 1), 0);
6462        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6463        assert_eq!(some_count(&pairs, 0), 51);
6464        assert_eq!(none_count(&pairs, 0), 0);
6465        assert_eq!(some_count(&pairs, 1), 51);
6466        assert_eq!(none_count(&pairs, 1), 0);
6467        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6468        assert_eq!(some_count(&pairs, 0), 51);
6469        assert_eq!(none_count(&pairs, 0), 0);
6470        assert_eq!(some_count(&pairs, 1), 51);
6471        assert_eq!(none_count(&pairs, 1), 0);
6472        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6473        assert_eq!(some_count(&pairs, 0), 51);
6474        assert_eq!(none_count(&pairs, 0), 0);
6475        assert_eq!(some_count(&pairs, 1), 51);
6476        assert_eq!(none_count(&pairs, 1), 0);
6477        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6478        assert_eq!(some_count(&pairs, 0), 51);
6479        assert_eq!(none_count(&pairs, 0), 0);
6480        assert_eq!(some_count(&pairs, 1), 42);
6481        assert_eq!(none_count(&pairs, 1), 9);
6482        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6483        assert_eq!(some_count(&pairs, 0), 51);
6484        assert_eq!(none_count(&pairs, 0), 0);
6485        assert_eq!(some_count(&pairs, 1), 51);
6486        assert_eq!(none_count(&pairs, 1), 0);
6487        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6488        assert_eq!(some_count(&pairs, 0), 51);
6489        assert_eq!(none_count(&pairs, 0), 0);
6490        assert_eq!(some_count(&pairs, 1), 50);
6491        assert_eq!(none_count(&pairs, 1), 1);
6492        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6493        assert_eq!(some_count(&pairs, 0), 51);
6494        assert_eq!(none_count(&pairs, 0), 0);
6495        assert_eq!(some_count(&pairs, 1), 45);
6496        assert_eq!(none_count(&pairs, 1), 6);
6497        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6498        assert_eq!(some_count(&pairs, 0), 51);
6499        assert_eq!(none_count(&pairs, 0), 0);
6500        assert_eq!(some_count(&pairs, 1), 48);
6501        assert_eq!(none_count(&pairs, 1), 3);
6502        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6503        assert_eq!(some_count(&pairs, 0), 51);
6504        assert_eq!(none_count(&pairs, 0), 0);
6505        assert_eq!(some_count(&pairs, 1), 42);
6506        assert_eq!(none_count(&pairs, 1), 9);
6507        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6508        assert_eq!(some_count(&pairs, 0), 51);
6509        assert_eq!(none_count(&pairs, 0), 0);
6510        assert_eq!(some_count(&pairs, 1), 38);
6511        assert_eq!(none_count(&pairs, 1), 13);
6512        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6513        assert_eq!(some_count(&pairs, 0), 51);
6514        assert_eq!(none_count(&pairs, 0), 0);
6515        assert_eq!(some_count(&pairs, 1), 44);
6516        assert_eq!(none_count(&pairs, 1), 7);
6517        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6518        assert_eq!(some_count(&pairs, 0), 51);
6519        assert_eq!(none_count(&pairs, 0), 0);
6520        assert_eq!(some_count(&pairs, 1), 46);
6521        assert_eq!(none_count(&pairs, 1), 5);
6522        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6523        assert_eq!(some_count(&pairs, 0), 51);
6524        assert_eq!(none_count(&pairs, 0), 0);
6525        assert_eq!(some_count(&pairs, 1), 47);
6526        assert_eq!(none_count(&pairs, 1), 4);
6527        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6528        assert_eq!(some_count(&pairs, 0), 51);
6529        assert_eq!(none_count(&pairs, 0), 0);
6530        assert_eq!(some_count(&pairs, 1), 50);
6531        assert_eq!(none_count(&pairs, 1), 1);
6532        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6533        assert_eq!(some_count(&pairs, 0), 51);
6534        assert_eq!(none_count(&pairs, 0), 2183);
6535        assert_eq!(some_count(&pairs, 1), 2234);
6536        assert_eq!(none_count(&pairs, 1), 0);
6537        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6538        assert_eq!(some_count(&pairs, 0), 51);
6539        assert_eq!(none_count(&pairs, 0), 2183);
6540        assert_eq!(some_count(&pairs, 1), 2234);
6541        assert_eq!(none_count(&pairs, 1), 0);
6542        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6543        assert_eq!(some_count(&pairs, 0), 51);
6544        assert_eq!(none_count(&pairs, 0), 2183);
6545        assert_eq!(some_count(&pairs, 1), 2234);
6546        assert_eq!(none_count(&pairs, 1), 0);
6547        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6548        assert_eq!(some_count(&pairs, 0), 51);
6549        assert_eq!(none_count(&pairs, 0), 0);
6550        assert_eq!(some_count(&pairs, 1), 33);
6551        assert_eq!(none_count(&pairs, 1), 18);
6552        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6553        assert_eq!(some_count(&pairs, 0), 51);
6554        assert_eq!(none_count(&pairs, 0), 0);
6555        assert_eq!(some_count(&pairs, 1), 48);
6556        assert_eq!(none_count(&pairs, 1), 3);
6557        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6558        assert_eq!(some_count(&pairs, 0), 51);
6559        assert_eq!(none_count(&pairs, 0), 0);
6560        assert_eq!(some_count(&pairs, 1), 45);
6561        assert_eq!(none_count(&pairs, 1), 6);
6562        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6563        assert_eq!(some_count(&pairs, 0), 51);
6564        assert_eq!(none_count(&pairs, 0), 11832);
6565        assert_eq!(some_count(&pairs, 1), 11883);
6566        assert_eq!(none_count(&pairs, 1), 0);
6567        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6568        assert_eq!(some_count(&pairs, 0), 51);
6569        assert_eq!(none_count(&pairs, 0), 12542);
6570        assert_eq!(some_count(&pairs, 1), 12593);
6571        assert_eq!(none_count(&pairs, 1), 0);
6572        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6573        assert_eq!(some_count(&pairs, 0), 51);
6574        assert_eq!(none_count(&pairs, 0), 12542);
6575        assert_eq!(some_count(&pairs, 1), 12593);
6576        assert_eq!(none_count(&pairs, 1), 0);
6577        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6578        assert_eq!(some_count(&pairs, 0), 51);
6579        assert_eq!(none_count(&pairs, 0), 12542);
6580        assert_eq!(some_count(&pairs, 1), 12593);
6581        assert_eq!(none_count(&pairs, 1), 0);
6582        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6583        assert_eq!(some_count(&pairs, 0), 51);
6584        assert_eq!(none_count(&pairs, 0), 12542);
6585        assert_eq!(some_count(&pairs, 1), 12593);
6586        assert_eq!(none_count(&pairs, 1), 0);
6587        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6588        assert_eq!(some_count(&pairs, 0), 51);
6589        assert_eq!(none_count(&pairs, 0), 12542);
6590        assert_eq!(some_count(&pairs, 1), 12593);
6591        assert_eq!(none_count(&pairs, 1), 0);
6592        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6593        assert_eq!(some_count(&pairs, 0), 51);
6594        assert_eq!(none_count(&pairs, 0), 12542);
6595        assert_eq!(some_count(&pairs, 1), 12593);
6596        assert_eq!(none_count(&pairs, 1), 0);
6597        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6598        assert_eq!(some_count(&pairs, 0), 51);
6599        assert_eq!(none_count(&pairs, 0), 12542);
6600        assert_eq!(some_count(&pairs, 1), 12593);
6601        assert_eq!(none_count(&pairs, 1), 0);
6602        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6603        assert_eq!(some_count(&pairs, 0), 51);
6604        assert_eq!(none_count(&pairs, 0), 12542);
6605        assert_eq!(some_count(&pairs, 1), 12593);
6606        assert_eq!(none_count(&pairs, 1), 0);
6607        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6608        assert_eq!(some_count(&pairs, 0), 51);
6609        assert_eq!(none_count(&pairs, 0), 1467);
6610        assert_eq!(some_count(&pairs, 1), 1517);
6611        assert_eq!(none_count(&pairs, 1), 1);
6612        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6613        assert_eq!(some_count(&pairs, 0), 51);
6614        assert_eq!(none_count(&pairs, 0), 1609);
6615        assert_eq!(some_count(&pairs, 1), 1660);
6616        assert_eq!(none_count(&pairs, 1), 0);
6617        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6618        assert_eq!(some_count(&pairs, 0), 51);
6619        assert_eq!(none_count(&pairs, 0), 1609);
6620        assert_eq!(some_count(&pairs, 1), 1660);
6621        assert_eq!(none_count(&pairs, 1), 0);
6622        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6623        assert_eq!(some_count(&pairs, 0), 51);
6624        assert_eq!(none_count(&pairs, 0), 1609);
6625        assert_eq!(some_count(&pairs, 1), 1660);
6626        assert_eq!(none_count(&pairs, 1), 0);
6627        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6628        assert_eq!(some_count(&pairs, 0), 51);
6629        assert_eq!(none_count(&pairs, 0), 95);
6630        assert_eq!(some_count(&pairs, 1), 145);
6631        assert_eq!(none_count(&pairs, 1), 1);
6632        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6633        assert_eq!(some_count(&pairs, 0), 51);
6634        assert_eq!(none_count(&pairs, 0), 538);
6635        assert_eq!(some_count(&pairs, 1), 588);
6636        assert_eq!(none_count(&pairs, 1), 1);
6637        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6638        assert_eq!(some_count(&pairs, 0), 51);
6639        assert_eq!(none_count(&pairs, 0), 538);
6640        assert_eq!(some_count(&pairs, 1), 588);
6641        assert_eq!(none_count(&pairs, 1), 1);
6642        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6643        assert_eq!(some_count(&pairs, 0), 51);
6644        assert_eq!(none_count(&pairs, 0), 538);
6645        assert_eq!(some_count(&pairs, 1), 588);
6646        assert_eq!(none_count(&pairs, 1), 1);
6647        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6648        assert_eq!(some_count(&pairs, 0), 51);
6649        assert_eq!(none_count(&pairs, 0), 1);
6650        assert_eq!(some_count(&pairs, 1), 51);
6651        assert_eq!(none_count(&pairs, 1), 1);
6652        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6653        assert_eq!(some_count(&pairs, 0), 51);
6654        assert_eq!(none_count(&pairs, 0), 1);
6655        assert_eq!(some_count(&pairs, 1), 49);
6656        assert_eq!(none_count(&pairs, 1), 3);
6657        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6658        assert_eq!(some_count(&pairs, 0), 51);
6659        assert_eq!(none_count(&pairs, 0), 1);
6660        assert_eq!(some_count(&pairs, 1), 45);
6661        assert_eq!(none_count(&pairs, 1), 7);
6662        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6663        assert_eq!(some_count(&pairs, 0), 51);
6664        assert_eq!(none_count(&pairs, 0), 0);
6665        assert_eq!(some_count(&pairs, 1), 39);
6666        assert_eq!(none_count(&pairs, 1), 12);
6667        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6668        assert_eq!(some_count(&pairs, 0), 51);
6669        assert_eq!(none_count(&pairs, 0), 1892);
6670        assert_eq!(some_count(&pairs, 1), 1938);
6671        assert_eq!(none_count(&pairs, 1), 5);
6672        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6673        assert_eq!(some_count(&pairs, 0), 51);
6674        assert_eq!(none_count(&pairs, 0), 1892);
6675        assert_eq!(some_count(&pairs, 1), 1941);
6676        assert_eq!(none_count(&pairs, 1), 2);
6677        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6678        assert_eq!(some_count(&pairs, 0), 51);
6679        assert_eq!(none_count(&pairs, 0), 2288);
6680        assert_eq!(some_count(&pairs, 1), 2338);
6681        assert_eq!(none_count(&pairs, 1), 1);
6682        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6683        assert_eq!(some_count(&pairs, 0), 51);
6684        assert_eq!(none_count(&pairs, 0), 14680);
6685        assert_eq!(some_count(&pairs, 1), 14729);
6686        assert_eq!(none_count(&pairs, 1), 2);
6687        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
6688        assert_eq!(some_count(&pairs, 0), 51);
6689        assert_eq!(none_count(&pairs, 0), 4027);
6690        assert_eq!(some_count(&pairs, 1), 4074);
6691        assert_eq!(none_count(&pairs, 1), 4);
6692    }
6693
6694    #[test]
6695    fn test_aligned_block_pairs() {
6696        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
6697        let mut it = bam.records();
6698
6699        let read = it.next().unwrap().unwrap();
6700        let pairs: Vec<_> = read.aligned_pairs().collect();
6701        let block_pairs: Vec<_> = read.aligned_block_pairs().collect();
6702
6703        //first coordinates identical
6704        assert_eq!(pairs[0][0], block_pairs[0].0[0]); //read
6705        assert_eq!(pairs[0][1], block_pairs[0].1[0]); // genomic
6706
6707        //end coordinates are + 1, so the ranges are the same...
6708        assert_eq!(
6709            pairs[pairs.len() - 1][0],
6710            block_pairs[block_pairs.len() - 1].0[1] - 1
6711        );
6712        assert_eq!(
6713            pairs[pairs.len() - 1][1],
6714            block_pairs[block_pairs.len() - 1].1[1] - 1
6715        );
6716
6717        //let's see if they're really identical
6718        for read in it {
6719            let read = read.unwrap();
6720            let pairs: Vec<_> = read.aligned_pairs().collect();
6721            let block_pairs: Vec<_> = read.aligned_block_pairs().collect();
6722            let mut ii = 0;
6723            for ([read_start, read_stop], [genome_start, genome_stop]) in block_pairs {
6724                assert_eq!(read_stop - read_start, genome_stop - genome_start);
6725                for (read_pos, genome_pos) in (read_start..read_stop).zip(genome_start..genome_stop)
6726                {
6727                    assert_eq!(pairs[ii][0], read_pos);
6728                    assert_eq!(pairs[ii][1], genome_pos);
6729                    ii += 1;
6730                }
6731            }
6732        }
6733    }
6734
6735    #[test]
6736    fn test_get_cigar_stats() {
6737        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
6738        let mut it = bam.records();
6739
6740        fn to_arr(hm: HashMap<Cigar, i32>) -> [i32; 9] {
6741            [
6742                *hm.get(&Cigar::Match(0)).unwrap(),
6743                *hm.get(&Cigar::Ins(0)).unwrap(),
6744                *hm.get(&Cigar::Del(0)).unwrap(),
6745                *hm.get(&Cigar::RefSkip(0)).unwrap(),
6746                *hm.get(&Cigar::SoftClip(0)).unwrap(),
6747                *hm.get(&Cigar::HardClip(0)).unwrap(),
6748                *hm.get(&Cigar::Pad(0)).unwrap(),
6749                *hm.get(&Cigar::Equal(0)).unwrap(),
6750                *hm.get(&Cigar::Diff(0)).unwrap(),
6751            ]
6752        }
6753
6754        let read = it.next().unwrap().unwrap();
6755        let cigar_nucleotides = read.cigar_stats_nucleotides();
6756        assert_eq!(to_arr(cigar_nucleotides), [45, 0, 0, 0, 6, 0, 0, 0, 0]);
6757        let cigar_blocks = read.cigar_stats_blocks();
6758        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
6759        let read = it.next().unwrap().unwrap();
6760        let cigar_nucleotides = read.cigar_stats_nucleotides();
6761        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 2, 0, 0, 0, 0, 0, 0]);
6762        let cigar_blocks = read.cigar_stats_blocks();
6763        assert_eq!(to_arr(cigar_blocks), [2, 0, 1, 0, 0, 0, 0, 0, 0]);
6764        let read = it.next().unwrap().unwrap();
6765        let cigar_nucleotides = read.cigar_stats_nucleotides();
6766        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 2, 0, 0, 0, 0, 0, 0]);
6767        let cigar_blocks = read.cigar_stats_blocks();
6768        assert_eq!(to_arr(cigar_blocks), [2, 0, 1, 0, 0, 0, 0, 0, 0]);
6769        let read = it.next().unwrap().unwrap();
6770        let cigar_nucleotides = read.cigar_stats_nucleotides();
6771        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
6772        let cigar_blocks = read.cigar_stats_blocks();
6773        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
6774        let read = it.next().unwrap().unwrap();
6775        let cigar_nucleotides = read.cigar_stats_nucleotides();
6776        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
6777        let cigar_blocks = read.cigar_stats_blocks();
6778        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
6779        let read = it.next().unwrap().unwrap();
6780        let cigar_nucleotides = read.cigar_stats_nucleotides();
6781        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
6782        let cigar_blocks = read.cigar_stats_blocks();
6783        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
6784        let read = it.next().unwrap().unwrap();
6785        let cigar_nucleotides = read.cigar_stats_nucleotides();
6786        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
6787        let cigar_blocks = read.cigar_stats_blocks();
6788        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
6789        let read = it.next().unwrap().unwrap();
6790        let cigar_nucleotides = read.cigar_stats_nucleotides();
6791        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
6792        let cigar_blocks = read.cigar_stats_blocks();
6793        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
6794        let read = it.next().unwrap().unwrap();
6795        let cigar_nucleotides = read.cigar_stats_nucleotides();
6796        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
6797        let cigar_blocks = read.cigar_stats_blocks();
6798        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
6799        let read = it.next().unwrap().unwrap();
6800        let cigar_nucleotides = read.cigar_stats_nucleotides();
6801        assert_eq!(to_arr(cigar_nucleotides), [45, 0, 0, 0, 6, 0, 0, 0, 0]);
6802        let cigar_blocks = read.cigar_stats_blocks();
6803        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
6804        let read = it.next().unwrap().unwrap();
6805        let cigar_nucleotides = read.cigar_stats_nucleotides();
6806        assert_eq!(to_arr(cigar_nucleotides), [41, 0, 0, 0, 10, 0, 0, 0, 0]);
6807        let cigar_blocks = read.cigar_stats_blocks();
6808        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
6809        let read = it.next().unwrap().unwrap();
6810        let cigar_nucleotides = read.cigar_stats_nucleotides();
6811        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
6812        let cigar_blocks = read.cigar_stats_blocks();
6813        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
6814        let read = it.next().unwrap().unwrap();
6815        let cigar_nucleotides = read.cigar_stats_nucleotides();
6816        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
6817        let cigar_blocks = read.cigar_stats_blocks();
6818        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
6819        let read = it.next().unwrap().unwrap();
6820        let cigar_nucleotides = read.cigar_stats_nucleotides();
6821        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
6822        let cigar_blocks = read.cigar_stats_blocks();
6823        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
6824        let read = it.next().unwrap().unwrap();
6825        let cigar_nucleotides = read.cigar_stats_nucleotides();
6826        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
6827        let cigar_blocks = read.cigar_stats_blocks();
6828        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
6829        let read = it.next().unwrap().unwrap();
6830        let cigar_nucleotides = read.cigar_stats_nucleotides();
6831        assert_eq!(to_arr(cigar_nucleotides), [42, 0, 0, 0, 9, 0, 0, 0, 0]);
6832        let cigar_blocks = read.cigar_stats_blocks();
6833        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
6834        let read = it.next().unwrap().unwrap();
6835        let cigar_nucleotides = read.cigar_stats_nucleotides();
6836        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
6837        let cigar_blocks = read.cigar_stats_blocks();
6838        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
6839        let read = it.next().unwrap().unwrap();
6840        let cigar_nucleotides = read.cigar_stats_nucleotides();
6841        assert_eq!(to_arr(cigar_nucleotides), [50, 0, 0, 0, 1, 0, 0, 0, 0]);
6842        let cigar_blocks = read.cigar_stats_blocks();
6843        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
6844        let read = it.next().unwrap().unwrap();
6845        let cigar_nucleotides = read.cigar_stats_nucleotides();
6846        assert_eq!(to_arr(cigar_nucleotides), [45, 0, 0, 0, 6, 0, 0, 0, 0]);
6847        let cigar_blocks = read.cigar_stats_blocks();
6848        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
6849        let read = it.next().unwrap().unwrap();
6850        let cigar_nucleotides = read.cigar_stats_nucleotides();
6851        assert_eq!(to_arr(cigar_nucleotides), [48, 0, 0, 0, 3, 0, 0, 0, 0]);
6852        let cigar_blocks = read.cigar_stats_blocks();
6853        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
6854        let read = it.next().unwrap().unwrap();
6855        let cigar_nucleotides = read.cigar_stats_nucleotides();
6856        assert_eq!(to_arr(cigar_nucleotides), [42, 0, 0, 0, 9, 0, 0, 0, 0]);
6857        let cigar_blocks = read.cigar_stats_blocks();
6858        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
6859        let read = it.next().unwrap().unwrap();
6860        let cigar_nucleotides = read.cigar_stats_nucleotides();
6861        assert_eq!(to_arr(cigar_nucleotides), [38, 0, 0, 0, 13, 0, 0, 0, 0]);
6862        let cigar_blocks = read.cigar_stats_blocks();
6863        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
6864        let read = it.next().unwrap().unwrap();
6865        let cigar_nucleotides = read.cigar_stats_nucleotides();
6866        assert_eq!(to_arr(cigar_nucleotides), [44, 0, 0, 0, 7, 0, 0, 0, 0]);
6867        let cigar_blocks = read.cigar_stats_blocks();
6868        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
6869        let read = it.next().unwrap().unwrap();
6870        let cigar_nucleotides = read.cigar_stats_nucleotides();
6871        assert_eq!(to_arr(cigar_nucleotides), [46, 0, 0, 0, 5, 0, 0, 0, 0]);
6872        let cigar_blocks = read.cigar_stats_blocks();
6873        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
6874        let read = it.next().unwrap().unwrap();
6875        let cigar_nucleotides = read.cigar_stats_nucleotides();
6876        assert_eq!(to_arr(cigar_nucleotides), [47, 4, 0, 0, 0, 0, 0, 0, 0]);
6877        let cigar_blocks = read.cigar_stats_blocks();
6878        assert_eq!(to_arr(cigar_blocks), [2, 1, 0, 0, 0, 0, 0, 0, 0]);
6879        let read = it.next().unwrap().unwrap();
6880        let cigar_nucleotides = read.cigar_stats_nucleotides();
6881        assert_eq!(to_arr(cigar_nucleotides), [50, 1, 0, 0, 0, 0, 0, 0, 0]);
6882        let cigar_blocks = read.cigar_stats_blocks();
6883        assert_eq!(to_arr(cigar_blocks), [2, 1, 0, 0, 0, 0, 0, 0, 0]);
6884        let read = it.next().unwrap().unwrap();
6885        let cigar_nucleotides = read.cigar_stats_nucleotides();
6886        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 2183, 0, 0, 0, 0, 0]);
6887        let cigar_blocks = read.cigar_stats_blocks();
6888        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 0, 0, 0, 0, 0]);
6889        let read = it.next().unwrap().unwrap();
6890        let cigar_nucleotides = read.cigar_stats_nucleotides();
6891        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 2183, 0, 0, 0, 0, 0]);
6892        let cigar_blocks = read.cigar_stats_blocks();
6893        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 0, 0, 0, 0, 0]);
6894        let read = it.next().unwrap().unwrap();
6895        let cigar_nucleotides = read.cigar_stats_nucleotides();
6896        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 2183, 0, 0, 0, 0, 0]);
6897        let cigar_blocks = read.cigar_stats_blocks();
6898        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 0, 0, 0, 0, 0]);
6899        let read = it.next().unwrap().unwrap();
6900        let cigar_nucleotides = read.cigar_stats_nucleotides();
6901        assert_eq!(to_arr(cigar_nucleotides), [33, 0, 0, 0, 18, 0, 0, 0, 0]);
6902        let cigar_blocks = read.cigar_stats_blocks();
6903        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 2, 0, 0, 0, 0]);
6904        let read = it.next().unwrap().unwrap();
6905        let cigar_nucleotides = read.cigar_stats_nucleotides();
6906        assert_eq!(to_arr(cigar_nucleotides), [48, 0, 0, 0, 3, 0, 0, 0, 0]);
6907        let cigar_blocks = read.cigar_stats_blocks();
6908        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 2, 0, 0, 0, 0]);
6909        let read = it.next().unwrap().unwrap();
6910        let cigar_nucleotides = read.cigar_stats_nucleotides();
6911        assert_eq!(to_arr(cigar_nucleotides), [45, 0, 0, 0, 6, 0, 0, 0, 0]);
6912        let cigar_blocks = read.cigar_stats_blocks();
6913        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 2, 0, 0, 0, 0]);
6914        let read = it.next().unwrap().unwrap();
6915        let cigar_nucleotides = read.cigar_stats_nucleotides();
6916        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 11832, 0, 0, 0, 0, 0]);
6917        let cigar_blocks = read.cigar_stats_blocks();
6918        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 0, 0, 0, 0, 0]);
6919        let read = it.next().unwrap().unwrap();
6920        let cigar_nucleotides = read.cigar_stats_nucleotides();
6921        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 12542, 0, 0, 0, 0, 0],);
6922        let cigar_blocks = read.cigar_stats_blocks();
6923        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
6924        let read = it.next().unwrap().unwrap();
6925        let cigar_nucleotides = read.cigar_stats_nucleotides();
6926        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 12542, 0, 0, 0, 0, 0],);
6927        let cigar_blocks = read.cigar_stats_blocks();
6928        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
6929        let read = it.next().unwrap().unwrap();
6930        let cigar_nucleotides = read.cigar_stats_nucleotides();
6931        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 12542, 0, 0, 0, 0, 0],);
6932        let cigar_blocks = read.cigar_stats_blocks();
6933        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
6934        let read = it.next().unwrap().unwrap();
6935        let cigar_nucleotides = read.cigar_stats_nucleotides();
6936        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 12542, 0, 0, 0, 0, 0],);
6937        let cigar_blocks = read.cigar_stats_blocks();
6938        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
6939        let read = it.next().unwrap().unwrap();
6940        let cigar_nucleotides = read.cigar_stats_nucleotides();
6941        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 12542, 0, 0, 0, 0, 0],);
6942        let cigar_blocks = read.cigar_stats_blocks();
6943        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
6944        let read = it.next().unwrap().unwrap();
6945        let cigar_nucleotides = read.cigar_stats_nucleotides();
6946        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 12542, 0, 0, 0, 0, 0],);
6947        let cigar_blocks = read.cigar_stats_blocks();
6948        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
6949        let read = it.next().unwrap().unwrap();
6950        let cigar_nucleotides = read.cigar_stats_nucleotides();
6951        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 12542, 0, 0, 0, 0, 0],);
6952        let cigar_blocks = read.cigar_stats_blocks();
6953        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
6954        let read = it.next().unwrap().unwrap();
6955        let cigar_nucleotides = read.cigar_stats_nucleotides();
6956        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 12542, 0, 0, 0, 0, 0],);
6957        let cigar_blocks = read.cigar_stats_blocks();
6958        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
6959        let read = it.next().unwrap().unwrap();
6960        let cigar_nucleotides = read.cigar_stats_nucleotides();
6961        assert_eq!(to_arr(cigar_nucleotides), [50, 0, 0, 1467, 1, 0, 0, 0, 0]);
6962        let cigar_blocks = read.cigar_stats_blocks();
6963        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 1, 0, 0, 0, 0]);
6964        let read = it.next().unwrap().unwrap();
6965        let cigar_nucleotides = read.cigar_stats_nucleotides();
6966        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 1609, 0, 0, 0, 0, 0]);
6967        let cigar_blocks = read.cigar_stats_blocks();
6968        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
6969        let read = it.next().unwrap().unwrap();
6970        let cigar_nucleotides = read.cigar_stats_nucleotides();
6971        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 1609, 0, 0, 0, 0, 0]);
6972        let cigar_blocks = read.cigar_stats_blocks();
6973        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
6974        let read = it.next().unwrap().unwrap();
6975        let cigar_nucleotides = read.cigar_stats_nucleotides();
6976        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 1609, 0, 0, 0, 0, 0]);
6977        let cigar_blocks = read.cigar_stats_blocks();
6978        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
6979        let read = it.next().unwrap().unwrap();
6980        let cigar_nucleotides = read.cigar_stats_nucleotides();
6981        assert_eq!(to_arr(cigar_nucleotides), [50, 0, 0, 95, 1, 0, 0, 0, 0]);
6982        let cigar_blocks = read.cigar_stats_blocks();
6983        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 1, 0, 0, 0, 0]);
6984        let read = it.next().unwrap().unwrap();
6985        let cigar_nucleotides = read.cigar_stats_nucleotides();
6986        assert_eq!(to_arr(cigar_nucleotides), [50, 0, 0, 538, 1, 0, 0, 0, 0]);
6987        let cigar_blocks = read.cigar_stats_blocks();
6988        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 1, 0, 0, 0, 0]);
6989        let read = it.next().unwrap().unwrap();
6990        let cigar_nucleotides = read.cigar_stats_nucleotides();
6991        assert_eq!(to_arr(cigar_nucleotides), [50, 0, 0, 538, 1, 0, 0, 0, 0]);
6992        let cigar_blocks = read.cigar_stats_blocks();
6993        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 1, 0, 0, 0, 0]);
6994        let read = it.next().unwrap().unwrap();
6995        let cigar_nucleotides = read.cigar_stats_nucleotides();
6996        assert_eq!(to_arr(cigar_nucleotides), [50, 0, 0, 538, 1, 0, 0, 0, 0]);
6997        let cigar_blocks = read.cigar_stats_blocks();
6998        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 1, 0, 0, 0, 0]);
6999        let read = it.next().unwrap().unwrap();
7000        let cigar_nucleotides = read.cigar_stats_nucleotides();
7001        assert_eq!(to_arr(cigar_nucleotides), [50, 0, 1, 0, 1, 0, 0, 0, 0]);
7002        let cigar_blocks = read.cigar_stats_blocks();
7003        assert_eq!(to_arr(cigar_blocks), [2, 0, 1, 0, 1, 0, 0, 0, 0]);
7004        let read = it.next().unwrap().unwrap();
7005        let cigar_nucleotides = read.cigar_stats_nucleotides();
7006        assert_eq!(to_arr(cigar_nucleotides), [48, 0, 1, 0, 3, 0, 0, 0, 0]);
7007        let cigar_blocks = read.cigar_stats_blocks();
7008        assert_eq!(to_arr(cigar_blocks), [2, 0, 1, 0, 1, 0, 0, 0, 0]);
7009        let read = it.next().unwrap().unwrap();
7010        let cigar_nucleotides = read.cigar_stats_nucleotides();
7011        assert_eq!(to_arr(cigar_nucleotides), [44, 0, 1, 0, 7, 0, 0, 0, 0]);
7012        let cigar_blocks = read.cigar_stats_blocks();
7013        assert_eq!(to_arr(cigar_blocks), [2, 0, 1, 0, 1, 0, 0, 0, 0]);
7014        let read = it.next().unwrap().unwrap();
7015        let cigar_nucleotides = read.cigar_stats_nucleotides();
7016        assert_eq!(to_arr(cigar_nucleotides), [39, 1, 0, 0, 11, 0, 0, 0, 0]);
7017        let cigar_blocks = read.cigar_stats_blocks();
7018        assert_eq!(to_arr(cigar_blocks), [2, 1, 0, 0, 1, 0, 0, 0, 0]);
7019        let read = it.next().unwrap().unwrap();
7020        let cigar_nucleotides = read.cigar_stats_nucleotides();
7021        assert_eq!(to_arr(cigar_nucleotides), [46, 0, 0, 1892, 5, 0, 0, 0, 0]);
7022        let cigar_blocks = read.cigar_stats_blocks();
7023        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 1, 0, 0, 0, 0]);
7024        let read = it.next().unwrap().unwrap();
7025        let cigar_nucleotides = read.cigar_stats_nucleotides();
7026        assert_eq!(to_arr(cigar_nucleotides), [49, 0, 0, 1892, 2, 0, 0, 0, 0]);
7027        let cigar_blocks = read.cigar_stats_blocks();
7028        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 1, 0, 0, 0, 0]);
7029        let read = it.next().unwrap().unwrap();
7030        let cigar_nucleotides = read.cigar_stats_nucleotides();
7031        assert_eq!(to_arr(cigar_nucleotides), [50, 0, 3, 2285, 1, 0, 0, 0, 0]);
7032        let cigar_blocks = read.cigar_stats_blocks();
7033        assert_eq!(to_arr(cigar_blocks), [3, 0, 1, 1, 1, 0, 0, 0, 0]);
7034        let read = it.next().unwrap().unwrap();
7035        let cigar_nucleotides = read.cigar_stats_nucleotides();
7036        assert_eq!(to_arr(cigar_nucleotides), [49, 0, 0, 14680, 2, 0, 0, 0, 0],);
7037        let cigar_blocks = read.cigar_stats_blocks();
7038        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 1, 0, 0, 0, 0]);
7039        let read = it.next().unwrap().unwrap();
7040        let cigar_nucleotides = read.cigar_stats_nucleotides();
7041        assert_eq!(to_arr(cigar_nucleotides), [47, 0, 0, 4027, 4, 0, 0, 0, 0]);
7042        let cigar_blocks = read.cigar_stats_blocks();
7043        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 1, 0, 0, 0, 0]);
7044    }
7045
7046    #[test]
7047    fn test_reference_positions() {
7048        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
7049        let mut it = bam.records();
7050
7051        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7052        assert_eq!(
7053            rp,
7054            vec![
7055                16050676, 16050677, 16050678, 16050679, 16050680, 16050681, 16050682, 16050683,
7056                16050684, 16050685, 16050686, 16050687, 16050688, 16050689, 16050690, 16050691,
7057                16050692, 16050693, 16050694, 16050695, 16050696, 16050697, 16050698, 16050699,
7058                16050700, 16050701, 16050702, 16050703, 16050704, 16050705, 16050706, 16050707,
7059                16050708, 16050709, 16050710, 16050711, 16050712, 16050713, 16050714, 16050715,
7060                16050716, 16050717, 16050718, 16050719, 16050720
7061            ]
7062        );
7063        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7064        assert_eq!(
7065            rp,
7066            vec![
7067                16096878, 16096879, 16096880, 16096881, 16096882, 16096883, 16096884, 16096887,
7068                16096888, 16096889, 16096890, 16096891, 16096892, 16096893, 16096894, 16096895,
7069                16096896, 16096897, 16096898, 16096899, 16096900, 16096901, 16096902, 16096903,
7070                16096904, 16096905, 16096906, 16096907, 16096908, 16096909, 16096910, 16096911,
7071                16096912, 16096913, 16096914, 16096915, 16096916, 16096917, 16096918, 16096919,
7072                16096920, 16096921, 16096922, 16096923, 16096924, 16096925, 16096926, 16096927,
7073                16096928, 16096929, 16096930
7074            ]
7075        );
7076        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7077        assert_eq!(
7078            rp,
7079            vec![
7080                16097145, 16097146, 16097147, 16097148, 16097149, 16097150, 16097151, 16097152,
7081                16097153, 16097154, 16097155, 16097156, 16097157, 16097158, 16097159, 16097160,
7082                16097161, 16097162, 16097163, 16097164, 16097165, 16097166, 16097167, 16097168,
7083                16097169, 16097170, 16097171, 16097172, 16097173, 16097176, 16097177, 16097178,
7084                16097179, 16097180, 16097181, 16097182, 16097183, 16097184, 16097185, 16097186,
7085                16097187, 16097188, 16097189, 16097190, 16097191, 16097192, 16097193, 16097194,
7086                16097195, 16097196, 16097197
7087            ]
7088        );
7089        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7090        assert_eq!(
7091            rp,
7092            vec![
7093                16117350, 16117351, 16117352, 16117353, 16117354, 16117355, 16117356, 16117357,
7094                16117358, 16117359, 16117360, 16117361, 16117362, 16117363, 16117364, 16117365,
7095                16117366, 16117367, 16117368, 16117369, 16117370, 16117371, 16117372, 16117373,
7096                16117374, 16117375, 16117376, 16117377, 16117378, 16117379, 16117380, 16117381,
7097                16117382, 16117383, 16117384, 16117385, 16117386, 16117387, 16117388, 16117389,
7098                16117390, 16117391, 16117392, 16117393, 16117394, 16117395, 16117396, 16117397,
7099                16117398, 16117399, 16117400
7100            ]
7101        );
7102        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7103        assert_eq!(
7104            rp,
7105            vec![
7106                16118483, 16118484, 16118485, 16118486, 16118487, 16118488, 16118489, 16118490,
7107                16118491, 16118492, 16118493, 16118494, 16118495, 16118496, 16118497, 16118498,
7108                16118499, 16118500, 16118501, 16118502, 16118503, 16118504, 16118505, 16118506,
7109                16118507, 16118508, 16118509, 16118510, 16118511, 16118512, 16118513, 16118514,
7110                16118515, 16118516, 16118517, 16118518, 16118519, 16118520, 16118521, 16118522,
7111                16118523, 16118524, 16118525, 16118526, 16118527, 16118528, 16118529, 16118530,
7112                16118531, 16118532, 16118533
7113            ]
7114        );
7115        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7116        assert_eq!(
7117            rp,
7118            vec![
7119                16118499, 16118500, 16118501, 16118502, 16118503, 16118504, 16118505, 16118506,
7120                16118507, 16118508, 16118509, 16118510, 16118511, 16118512, 16118513, 16118514,
7121                16118515, 16118516, 16118517, 16118518, 16118519, 16118520, 16118521, 16118522,
7122                16118523, 16118524, 16118525, 16118526, 16118527, 16118528, 16118529, 16118530,
7123                16118531, 16118532, 16118533, 16118534, 16118535, 16118536, 16118537, 16118538,
7124                16118539, 16118540, 16118541, 16118542, 16118543, 16118544, 16118545, 16118546,
7125                16118547, 16118548, 16118549
7126            ]
7127        );
7128        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7129        assert_eq!(
7130            rp,
7131            vec![
7132                16118499, 16118500, 16118501, 16118502, 16118503, 16118504, 16118505, 16118506,
7133                16118507, 16118508, 16118509, 16118510, 16118511, 16118512, 16118513, 16118514,
7134                16118515, 16118516, 16118517, 16118518, 16118519, 16118520, 16118521, 16118522,
7135                16118523, 16118524, 16118525, 16118526, 16118527, 16118528, 16118529, 16118530,
7136                16118531, 16118532, 16118533, 16118534, 16118535, 16118536, 16118537, 16118538,
7137                16118539, 16118540, 16118541, 16118542, 16118543, 16118544, 16118545, 16118546,
7138                16118547, 16118548, 16118549
7139            ]
7140        );
7141        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7142        assert_eq!(
7143            rp,
7144            vec![
7145                16118499, 16118500, 16118501, 16118502, 16118503, 16118504, 16118505, 16118506,
7146                16118507, 16118508, 16118509, 16118510, 16118511, 16118512, 16118513, 16118514,
7147                16118515, 16118516, 16118517, 16118518, 16118519, 16118520, 16118521, 16118522,
7148                16118523, 16118524, 16118525, 16118526, 16118527, 16118528, 16118529, 16118530,
7149                16118531, 16118532, 16118533, 16118534, 16118535, 16118536, 16118537, 16118538,
7150                16118539, 16118540, 16118541, 16118542, 16118543, 16118544, 16118545, 16118546,
7151                16118547, 16118548, 16118549
7152            ]
7153        );
7154        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7155        assert_eq!(
7156            rp,
7157            vec![
7158                16123411, 16123412, 16123413, 16123414, 16123415, 16123416, 16123417, 16123418,
7159                16123419, 16123420, 16123421, 16123422, 16123423, 16123424, 16123425, 16123426,
7160                16123427, 16123428, 16123429, 16123430, 16123431, 16123432, 16123433, 16123434,
7161                16123435, 16123436, 16123437, 16123438, 16123439, 16123440, 16123441, 16123442,
7162                16123443, 16123444, 16123445, 16123446, 16123447, 16123448, 16123449, 16123450,
7163                16123451, 16123452, 16123453, 16123454, 16123455, 16123456, 16123457, 16123458,
7164                16123459, 16123460, 16123461
7165            ]
7166        );
7167        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7168        assert_eq!(
7169            rp,
7170            vec![
7171                16123417, 16123418, 16123419, 16123420, 16123421, 16123422, 16123423, 16123424,
7172                16123425, 16123426, 16123427, 16123428, 16123429, 16123430, 16123431, 16123432,
7173                16123433, 16123434, 16123435, 16123436, 16123437, 16123438, 16123439, 16123440,
7174                16123441, 16123442, 16123443, 16123444, 16123445, 16123446, 16123447, 16123448,
7175                16123449, 16123450, 16123451, 16123452, 16123453, 16123454, 16123455, 16123456,
7176                16123457, 16123458, 16123459, 16123460, 16123461
7177            ]
7178        );
7179        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7180        assert_eq!(
7181            rp,
7182            vec![
7183                16165860, 16165861, 16165862, 16165863, 16165864, 16165865, 16165866, 16165867,
7184                16165868, 16165869, 16165870, 16165871, 16165872, 16165873, 16165874, 16165875,
7185                16165876, 16165877, 16165878, 16165879, 16165880, 16165881, 16165882, 16165883,
7186                16165884, 16165885, 16165886, 16165887, 16165888, 16165889, 16165890, 16165891,
7187                16165892, 16165893, 16165894, 16165895, 16165896, 16165897, 16165898, 16165899,
7188                16165900
7189            ]
7190        );
7191        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7192        assert_eq!(
7193            rp,
7194            vec![
7195                16180871, 16180872, 16180873, 16180874, 16180875, 16180876, 16180877, 16180878,
7196                16180879, 16180880, 16180881, 16180882, 16180883, 16180884, 16180885, 16180886,
7197                16180887, 16180888, 16180889, 16180890, 16180891, 16180892, 16180893, 16180894,
7198                16180895, 16180896, 16180897, 16180898, 16180899, 16180900, 16180901, 16180902,
7199                16180903, 16180904, 16180905, 16180906, 16180907, 16180908, 16180909, 16180910,
7200                16180911, 16180912, 16180913, 16180914, 16180915, 16180916, 16180917, 16180918,
7201                16180919, 16180920, 16180921
7202            ]
7203        );
7204        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7205        assert_eq!(
7206            rp,
7207            vec![
7208                16189705, 16189706, 16189707, 16189708, 16189709, 16189710, 16189711, 16189712,
7209                16189713, 16189714, 16189715, 16189716, 16189717, 16189718, 16189719, 16189720,
7210                16189721, 16189722, 16189723, 16189724, 16189725, 16189726, 16189727, 16189728,
7211                16189729, 16189730, 16189731, 16189732, 16189733, 16189734, 16189735, 16189736,
7212                16189737, 16189738, 16189739, 16189740, 16189741, 16189742, 16189743, 16189744,
7213                16189745, 16189746, 16189747, 16189748, 16189749, 16189750, 16189751, 16189752,
7214                16189753, 16189754, 16189755
7215            ]
7216        );
7217        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7218        assert_eq!(
7219            rp,
7220            vec![
7221                16231271, 16231272, 16231273, 16231274, 16231275, 16231276, 16231277, 16231278,
7222                16231279, 16231280, 16231281, 16231282, 16231283, 16231284, 16231285, 16231286,
7223                16231287, 16231288, 16231289, 16231290, 16231291, 16231292, 16231293, 16231294,
7224                16231295, 16231296, 16231297, 16231298, 16231299, 16231300, 16231301, 16231302,
7225                16231303, 16231304, 16231305, 16231306, 16231307, 16231308, 16231309, 16231310,
7226                16231311, 16231312, 16231313, 16231314, 16231315, 16231316, 16231317, 16231318,
7227                16231319, 16231320, 16231321
7228            ]
7229        );
7230        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7231        assert_eq!(
7232            rp,
7233            vec![
7234                16237657, 16237658, 16237659, 16237660, 16237661, 16237662, 16237663, 16237664,
7235                16237665, 16237666, 16237667, 16237668, 16237669, 16237670, 16237671, 16237672,
7236                16237673, 16237674, 16237675, 16237676, 16237677, 16237678, 16237679, 16237680,
7237                16237681, 16237682, 16237683, 16237684, 16237685, 16237686, 16237687, 16237688,
7238                16237689, 16237690, 16237691, 16237692, 16237693, 16237694, 16237695, 16237696,
7239                16237697, 16237698, 16237699, 16237700, 16237701, 16237702, 16237703, 16237704,
7240                16237705, 16237706, 16237707
7241            ]
7242        );
7243        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7244        assert_eq!(
7245            rp,
7246            vec![
7247                16255012, 16255013, 16255014, 16255015, 16255016, 16255017, 16255018, 16255019,
7248                16255020, 16255021, 16255022, 16255023, 16255024, 16255025, 16255026, 16255027,
7249                16255028, 16255029, 16255030, 16255031, 16255032, 16255033, 16255034, 16255035,
7250                16255036, 16255037, 16255038, 16255039, 16255040, 16255041, 16255042, 16255043,
7251                16255044, 16255045, 16255046, 16255047, 16255048, 16255049, 16255050, 16255051,
7252                16255052, 16255053
7253            ]
7254        );
7255        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7256        assert_eq!(
7257            rp,
7258            vec![
7259                16255391, 16255392, 16255393, 16255394, 16255395, 16255396, 16255397, 16255398,
7260                16255399, 16255400, 16255401, 16255402, 16255403, 16255404, 16255405, 16255406,
7261                16255407, 16255408, 16255409, 16255410, 16255411, 16255412, 16255413, 16255414,
7262                16255415, 16255416, 16255417, 16255418, 16255419, 16255420, 16255421, 16255422,
7263                16255423, 16255424, 16255425, 16255426, 16255427, 16255428, 16255429, 16255430,
7264                16255431, 16255432, 16255433, 16255434, 16255435, 16255436, 16255437, 16255438,
7265                16255439, 16255440, 16255441
7266            ]
7267        );
7268        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7269        assert_eq!(
7270            rp,
7271            vec![
7272                16255392, 16255393, 16255394, 16255395, 16255396, 16255397, 16255398, 16255399,
7273                16255400, 16255401, 16255402, 16255403, 16255404, 16255405, 16255406, 16255407,
7274                16255408, 16255409, 16255410, 16255411, 16255412, 16255413, 16255414, 16255415,
7275                16255416, 16255417, 16255418, 16255419, 16255420, 16255421, 16255422, 16255423,
7276                16255424, 16255425, 16255426, 16255427, 16255428, 16255429, 16255430, 16255431,
7277                16255432, 16255433, 16255434, 16255435, 16255436, 16255437, 16255438, 16255439,
7278                16255440, 16255441
7279            ]
7280        );
7281        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7282        assert_eq!(
7283            rp,
7284            vec![
7285                16256084, 16256085, 16256086, 16256087, 16256088, 16256089, 16256090, 16256091,
7286                16256092, 16256093, 16256094, 16256095, 16256096, 16256097, 16256098, 16256099,
7287                16256100, 16256101, 16256102, 16256103, 16256104, 16256105, 16256106, 16256107,
7288                16256108, 16256109, 16256110, 16256111, 16256112, 16256113, 16256114, 16256115,
7289                16256116, 16256117, 16256118, 16256119, 16256120, 16256121, 16256122, 16256123,
7290                16256124, 16256125, 16256126, 16256127, 16256128
7291            ]
7292        );
7293        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7294        assert_eq!(
7295            rp,
7296            vec![
7297                16256224, 16256225, 16256226, 16256227, 16256228, 16256229, 16256230, 16256231,
7298                16256232, 16256233, 16256234, 16256235, 16256236, 16256237, 16256238, 16256239,
7299                16256240, 16256241, 16256242, 16256243, 16256244, 16256245, 16256246, 16256247,
7300                16256248, 16256249, 16256250, 16256251, 16256252, 16256253, 16256254, 16256255,
7301                16256256, 16256257, 16256258, 16256259, 16256260, 16256261, 16256262, 16256263,
7302                16256264, 16256265, 16256266, 16256267, 16256268, 16256269, 16256270, 16256271
7303            ]
7304        );
7305        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7306        assert_eq!(
7307            rp,
7308            vec![
7309                16325199, 16325200, 16325201, 16325202, 16325203, 16325204, 16325205, 16325206,
7310                16325207, 16325208, 16325209, 16325210, 16325211, 16325212, 16325213, 16325214,
7311                16325215, 16325216, 16325217, 16325218, 16325219, 16325220, 16325221, 16325222,
7312                16325223, 16325224, 16325225, 16325226, 16325227, 16325228, 16325229, 16325230,
7313                16325231, 16325232, 16325233, 16325234, 16325235, 16325236, 16325237, 16325238,
7314                16325239, 16325240
7315            ]
7316        );
7317        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7318        assert_eq!(
7319            rp,
7320            vec![
7321                16352865, 16352866, 16352867, 16352868, 16352869, 16352870, 16352871, 16352872,
7322                16352873, 16352874, 16352875, 16352876, 16352877, 16352878, 16352879, 16352880,
7323                16352881, 16352882, 16352883, 16352884, 16352885, 16352886, 16352887, 16352888,
7324                16352889, 16352890, 16352891, 16352892, 16352893, 16352894, 16352895, 16352896,
7325                16352897, 16352898, 16352899, 16352900, 16352901, 16352902
7326            ]
7327        );
7328        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7329        assert_eq!(
7330            rp,
7331            vec![
7332                16352968, 16352969, 16352970, 16352971, 16352972, 16352973, 16352974, 16352975,
7333                16352976, 16352977, 16352978, 16352979, 16352980, 16352981, 16352982, 16352983,
7334                16352984, 16352985, 16352986, 16352987, 16352988, 16352989, 16352990, 16352991,
7335                16352992, 16352993, 16352994, 16352995, 16352996, 16352997, 16352998, 16352999,
7336                16353000, 16353001, 16353002, 16353003, 16353004, 16353005, 16353006, 16353007,
7337                16353008, 16353009, 16353010, 16353011
7338            ]
7339        );
7340        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7341        assert_eq!(
7342            rp,
7343            vec![
7344                16414998, 16414999, 16415000, 16415001, 16415002, 16415003, 16415004, 16415005,
7345                16415006, 16415007, 16415008, 16415009, 16415010, 16415011, 16415012, 16415013,
7346                16415014, 16415015, 16415016, 16415017, 16415018, 16415019, 16415020, 16415021,
7347                16415022, 16415023, 16415024, 16415025, 16415026, 16415027, 16415028, 16415029,
7348                16415030, 16415031, 16415032, 16415033, 16415034, 16415035, 16415036, 16415037,
7349                16415038, 16415039, 16415040, 16415041, 16415042, 16415043
7350            ]
7351        );
7352        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7353        assert_eq!(
7354            rp,
7355            vec![
7356                17031591, 17031592, 17031593, 17031594, 17031595, 17031596, 17031597, 17031598,
7357                17031599, 17031600, 17031601, 17031602, 17031603, 17031604, 17031605, 17031606,
7358                17031607, 17031608, 17031609, 17031610, 17031611, 17031612, 17031613, 17031614,
7359                17031615, 17031616, 17031617, 17031618, 17031619, 17031620, 17031621, 17031622,
7360                17031623, 17031624, 17031625, 17031626, 17031627, 17031628, 17031629, 17031630,
7361                17031631, 17031632, 17031633, 17031634, 17031635, 17031636, 17031637
7362            ]
7363        );
7364        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7365        assert_eq!(
7366            rp,
7367            vec![
7368                17057382, 17057383, 17057384, 17057385, 17057386, 17057387, 17057388, 17057389,
7369                17057390, 17057391, 17057392, 17057393, 17057394, 17057395, 17057396, 17057397,
7370                17057398, 17057399, 17057400, 17057401, 17057402, 17057403, 17057404, 17057405,
7371                17057406, 17057407, 17057408, 17057409, 17057410, 17057411, 17057412, 17057413,
7372                17057414, 17057415, 17057416, 17057417, 17057418, 17057419, 17057420, 17057421,
7373                17057422, 17057423, 17057424, 17057425, 17057426, 17057427, 17057428, 17057429,
7374                17057430, 17057431
7375            ]
7376        );
7377        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7378        assert_eq!(
7379            rp,
7380            vec![
7381                17092766, 17092767, 17092768, 17092769, 17092770, 17092771, 17092772, 17092773,
7382                17092774, 17092775, 17092776, 17092777, 17092778, 17092779, 17092780, 17092781,
7383                17092782, 17094966, 17094967, 17094968, 17094969, 17094970, 17094971, 17094972,
7384                17094973, 17094974, 17094975, 17094976, 17094977, 17094978, 17094979, 17094980,
7385                17094981, 17094982, 17094983, 17094984, 17094985, 17094986, 17094987, 17094988,
7386                17094989, 17094990, 17094991, 17094992, 17094993, 17094994, 17094995, 17094996,
7387                17094997, 17094998, 17094999
7388            ]
7389        );
7390        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7391        assert_eq!(
7392            rp,
7393            vec![
7394                17092782, 17094966, 17094967, 17094968, 17094969, 17094970, 17094971, 17094972,
7395                17094973, 17094974, 17094975, 17094976, 17094977, 17094978, 17094979, 17094980,
7396                17094981, 17094982, 17094983, 17094984, 17094985, 17094986, 17094987, 17094988,
7397                17094989, 17094990, 17094991, 17094992, 17094993, 17094994, 17094995, 17094996,
7398                17094997, 17094998, 17094999, 17095000, 17095001, 17095002, 17095003, 17095004,
7399                17095005, 17095006, 17095007, 17095008, 17095009, 17095010, 17095011, 17095012,
7400                17095013, 17095014, 17095015
7401            ]
7402        );
7403        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7404        assert_eq!(
7405            rp,
7406            vec![
7407                17092782, 17094966, 17094967, 17094968, 17094969, 17094970, 17094971, 17094972,
7408                17094973, 17094974, 17094975, 17094976, 17094977, 17094978, 17094979, 17094980,
7409                17094981, 17094982, 17094983, 17094984, 17094985, 17094986, 17094987, 17094988,
7410                17094989, 17094990, 17094991, 17094992, 17094993, 17094994, 17094995, 17094996,
7411                17094997, 17094998, 17094999, 17095000, 17095001, 17095002, 17095003, 17095004,
7412                17095005, 17095006, 17095007, 17095008, 17095009, 17095010, 17095011, 17095012,
7413                17095013, 17095014, 17095015
7414            ]
7415        );
7416        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7417        assert_eq!(
7418            rp,
7419            vec![
7420                17137287, 17137288, 17137289, 17137290, 17137291, 17137292, 17137293, 17137294,
7421                17137295, 17137296, 17137297, 17137298, 17137299, 17137300, 17137301, 17137302,
7422                17137303, 17137304, 17137305, 17137306, 17137307, 17137308, 17137309, 17137310,
7423                17137311, 17137312, 17137313, 17137314, 17137315, 17137316, 17137317, 17137318,
7424                17137319
7425            ]
7426        );
7427        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7428        assert_eq!(
7429            rp,
7430            vec![
7431                17306238, 17306239, 17306240, 17306241, 17306242, 17306243, 17306244, 17306245,
7432                17306246, 17306247, 17306248, 17306249, 17306250, 17306251, 17306252, 17306253,
7433                17306254, 17306255, 17306256, 17306257, 17306258, 17306259, 17306260, 17306261,
7434                17306262, 17306263, 17306264, 17306265, 17306266, 17306267, 17306268, 17306269,
7435                17306270, 17306271, 17306272, 17306273, 17306274, 17306275, 17306276, 17306277,
7436                17306278, 17306279, 17306280, 17306281, 17306282, 17306283, 17306284, 17306285
7437            ]
7438        );
7439        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7440        assert_eq!(
7441            rp,
7442            vec![
7443                17561868, 17561869, 17561870, 17561871, 17561872, 17561873, 17561874, 17561875,
7444                17561876, 17561877, 17561878, 17561879, 17561880, 17561881, 17561882, 17561883,
7445                17561884, 17561885, 17561886, 17561887, 17561888, 17561889, 17561890, 17561891,
7446                17561892, 17561893, 17561894, 17561895, 17561896, 17561897, 17561898, 17561899,
7447                17561900, 17561901, 17561902, 17561903, 17561904, 17561905, 17561906, 17561907,
7448                17561908, 17561909, 17561910, 17561911, 17561912
7449            ]
7450        );
7451        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7452        assert_eq!(
7453            rp,
7454            vec![
7455                17566078, 17566079, 17566080, 17566081, 17566082, 17566083, 17566084, 17566085,
7456                17566086, 17566087, 17566088, 17566089, 17566090, 17566091, 17566092, 17566093,
7457                17566094, 17566095, 17566096, 17566097, 17566098, 17566099, 17566100, 17566101,
7458                17566102, 17566103, 17566104, 17566105, 17566106, 17566107, 17566108, 17566109,
7459                17566110, 17566111, 17566112, 17566113, 17566114, 17566115, 17566116, 17566117,
7460                17566118, 17577951, 17577952, 17577953, 17577954, 17577955, 17577956, 17577957,
7461                17577958, 17577959, 17577960
7462            ]
7463        );
7464        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7465        assert_eq!(
7466            rp,
7467            vec![
7468                17566108, 17566109, 17566110, 17566111, 17566112, 17566113, 17566114, 17566115,
7469                17566116, 17566117, 17566118, 17577951, 17577952, 17577953, 17577954, 17577955,
7470                17577956, 17577957, 17577958, 17577959, 17577960, 17577961, 17577962, 17577963,
7471                17577964, 17577965, 17577966, 17577967, 17577968, 17577969, 17577970, 17577971,
7472                17577972, 17577973, 17577974, 17577975, 17578686, 17578687, 17578688, 17578689,
7473                17578690, 17578691, 17578692, 17578693, 17578694, 17578695, 17578696, 17578697,
7474                17578698, 17578699, 17578700
7475            ]
7476        );
7477        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7478        assert_eq!(
7479            rp,
7480            vec![
7481                17566111, 17566112, 17566113, 17566114, 17566115, 17566116, 17566117, 17566118,
7482                17577951, 17577952, 17577953, 17577954, 17577955, 17577956, 17577957, 17577958,
7483                17577959, 17577960, 17577961, 17577962, 17577963, 17577964, 17577965, 17577966,
7484                17577967, 17577968, 17577969, 17577970, 17577971, 17577972, 17577973, 17577974,
7485                17577975, 17578686, 17578687, 17578688, 17578689, 17578690, 17578691, 17578692,
7486                17578693, 17578694, 17578695, 17578696, 17578697, 17578698, 17578699, 17578700,
7487                17578701, 17578702, 17578703
7488            ]
7489        );
7490        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7491        assert_eq!(
7492            rp,
7493            vec![
7494                17566111, 17566112, 17566113, 17566114, 17566115, 17566116, 17566117, 17566118,
7495                17577951, 17577952, 17577953, 17577954, 17577955, 17577956, 17577957, 17577958,
7496                17577959, 17577960, 17577961, 17577962, 17577963, 17577964, 17577965, 17577966,
7497                17577967, 17577968, 17577969, 17577970, 17577971, 17577972, 17577973, 17577974,
7498                17577975, 17578686, 17578687, 17578688, 17578689, 17578690, 17578691, 17578692,
7499                17578693, 17578694, 17578695, 17578696, 17578697, 17578698, 17578699, 17578700,
7500                17578701, 17578702, 17578703
7501            ]
7502        );
7503        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7504        assert_eq!(
7505            rp,
7506            vec![
7507                17566111, 17566112, 17566113, 17566114, 17566115, 17566116, 17566117, 17566118,
7508                17577951, 17577952, 17577953, 17577954, 17577955, 17577956, 17577957, 17577958,
7509                17577959, 17577960, 17577961, 17577962, 17577963, 17577964, 17577965, 17577966,
7510                17577967, 17577968, 17577969, 17577970, 17577971, 17577972, 17577973, 17577974,
7511                17577975, 17578686, 17578687, 17578688, 17578689, 17578690, 17578691, 17578692,
7512                17578693, 17578694, 17578695, 17578696, 17578697, 17578698, 17578699, 17578700,
7513                17578701, 17578702, 17578703
7514            ]
7515        );
7516        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7517        assert_eq!(
7518            rp,
7519            vec![
7520                17566111, 17566112, 17566113, 17566114, 17566115, 17566116, 17566117, 17566118,
7521                17577951, 17577952, 17577953, 17577954, 17577955, 17577956, 17577957, 17577958,
7522                17577959, 17577960, 17577961, 17577962, 17577963, 17577964, 17577965, 17577966,
7523                17577967, 17577968, 17577969, 17577970, 17577971, 17577972, 17577973, 17577974,
7524                17577975, 17578686, 17578687, 17578688, 17578689, 17578690, 17578691, 17578692,
7525                17578693, 17578694, 17578695, 17578696, 17578697, 17578698, 17578699, 17578700,
7526                17578701, 17578702, 17578703
7527            ]
7528        );
7529        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7530        assert_eq!(
7531            rp,
7532            vec![
7533                17566112, 17566113, 17566114, 17566115, 17566116, 17566117, 17566118, 17577951,
7534                17577952, 17577953, 17577954, 17577955, 17577956, 17577957, 17577958, 17577959,
7535                17577960, 17577961, 17577962, 17577963, 17577964, 17577965, 17577966, 17577967,
7536                17577968, 17577969, 17577970, 17577971, 17577972, 17577973, 17577974, 17577975,
7537                17578686, 17578687, 17578688, 17578689, 17578690, 17578691, 17578692, 17578693,
7538                17578694, 17578695, 17578696, 17578697, 17578698, 17578699, 17578700, 17578701,
7539                17578702, 17578703, 17578704
7540            ]
7541        );
7542        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7543        assert_eq!(
7544            rp,
7545            vec![
7546                17566113, 17566114, 17566115, 17566116, 17566117, 17566118, 17577951, 17577952,
7547                17577953, 17577954, 17577955, 17577956, 17577957, 17577958, 17577959, 17577960,
7548                17577961, 17577962, 17577963, 17577964, 17577965, 17577966, 17577967, 17577968,
7549                17577969, 17577970, 17577971, 17577972, 17577973, 17577974, 17577975, 17578686,
7550                17578687, 17578688, 17578689, 17578690, 17578691, 17578692, 17578693, 17578694,
7551                17578695, 17578696, 17578697, 17578698, 17578699, 17578700, 17578701, 17578702,
7552                17578703, 17578704, 17578705
7553            ]
7554        );
7555        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7556        assert_eq!(
7557            rp,
7558            vec![
7559                17566113, 17566114, 17566115, 17566116, 17566117, 17566118, 17577951, 17577952,
7560                17577953, 17577954, 17577955, 17577956, 17577957, 17577958, 17577959, 17577960,
7561                17577961, 17577962, 17577963, 17577964, 17577965, 17577966, 17577967, 17577968,
7562                17577969, 17577970, 17577971, 17577972, 17577973, 17577974, 17577975, 17578686,
7563                17578687, 17578688, 17578689, 17578690, 17578691, 17578692, 17578693, 17578694,
7564                17578695, 17578696, 17578697, 17578698, 17578699, 17578700, 17578701, 17578702,
7565                17578703, 17578704, 17578705
7566            ]
7567        );
7568        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7569        assert_eq!(
7570            rp,
7571            vec![
7572                17579733, 17579734, 17579735, 17579736, 17579737, 17579738, 17579739, 17579740,
7573                17579741, 17579742, 17579743, 17579744, 17579745, 17579746, 17579747, 17579748,
7574                17579749, 17579750, 17579751, 17579752, 17579753, 17579754, 17579755, 17579756,
7575                17579757, 17579758, 17579759, 17579760, 17579761, 17579762, 17579763, 17579764,
7576                17579765, 17579766, 17579767, 17579768, 17579769, 17579770, 17579771, 17579772,
7577                17579773, 17579774, 17579775, 17579776, 17581244, 17581245, 17581246, 17581247,
7578                17581248, 17581249
7579            ]
7580        );
7581        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7582        assert_eq!(
7583            rp,
7584            vec![
7585                17581369, 17581370, 17582885, 17582886, 17582887, 17582888, 17582889, 17582890,
7586                17582891, 17582892, 17582893, 17582894, 17582895, 17582896, 17582897, 17582898,
7587                17582899, 17582900, 17582901, 17582902, 17582903, 17582904, 17582905, 17582906,
7588                17582907, 17582908, 17582909, 17582910, 17582911, 17582912, 17582913, 17582914,
7589                17582915, 17582916, 17582917, 17582918, 17582919, 17582920, 17582921, 17582922,
7590                17582923, 17582924, 17582925, 17582926, 17582927, 17582928, 17582929, 17582930,
7591                17582931, 17582932, 17583028
7592            ]
7593        );
7594        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7595        assert_eq!(
7596            rp,
7597            vec![
7598                17581370, 17582885, 17582886, 17582887, 17582888, 17582889, 17582890, 17582891,
7599                17582892, 17582893, 17582894, 17582895, 17582896, 17582897, 17582898, 17582899,
7600                17582900, 17582901, 17582902, 17582903, 17582904, 17582905, 17582906, 17582907,
7601                17582908, 17582909, 17582910, 17582911, 17582912, 17582913, 17582914, 17582915,
7602                17582916, 17582917, 17582918, 17582919, 17582920, 17582921, 17582922, 17582923,
7603                17582924, 17582925, 17582926, 17582927, 17582928, 17582929, 17582930, 17582931,
7604                17582932, 17583028, 17583029
7605            ]
7606        );
7607        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7608        assert_eq!(
7609            rp,
7610            vec![
7611                17581370, 17582885, 17582886, 17582887, 17582888, 17582889, 17582890, 17582891,
7612                17582892, 17582893, 17582894, 17582895, 17582896, 17582897, 17582898, 17582899,
7613                17582900, 17582901, 17582902, 17582903, 17582904, 17582905, 17582906, 17582907,
7614                17582908, 17582909, 17582910, 17582911, 17582912, 17582913, 17582914, 17582915,
7615                17582916, 17582917, 17582918, 17582919, 17582920, 17582921, 17582922, 17582923,
7616                17582924, 17582925, 17582926, 17582927, 17582928, 17582929, 17582930, 17582931,
7617                17582932, 17583028, 17583029
7618            ]
7619        );
7620        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7621        assert_eq!(
7622            rp,
7623            vec![
7624                17582911, 17582912, 17582913, 17582914, 17582915, 17582916, 17582917, 17582918,
7625                17582919, 17582920, 17582921, 17582922, 17582923, 17582924, 17582925, 17582926,
7626                17582927, 17582928, 17582929, 17582930, 17582931, 17582932, 17583028, 17583029,
7627                17583030, 17583031, 17583032, 17583033, 17583034, 17583035, 17583036, 17583037,
7628                17583038, 17583039, 17583040, 17583041, 17583042, 17583043, 17583044, 17583045,
7629                17583046, 17583047, 17583048, 17583049, 17583050, 17583051, 17583052, 17583053,
7630                17583054, 17583055
7631            ]
7632        );
7633        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7634        assert_eq!(
7635            rp,
7636            vec![
7637                17588621, 17588622, 17588623, 17588624, 17588625, 17588626, 17588627, 17588628,
7638                17588629, 17588630, 17588631, 17588632, 17588633, 17588634, 17588635, 17588636,
7639                17588637, 17588638, 17588639, 17588640, 17588641, 17588642, 17588643, 17588644,
7640                17588645, 17588646, 17588647, 17588648, 17588649, 17588650, 17588651, 17588652,
7641                17588653, 17588654, 17588655, 17588656, 17588657, 17589196, 17589197, 17589198,
7642                17589199, 17589200, 17589201, 17589202, 17589203, 17589204, 17589205, 17589206,
7643                17589207, 17589208
7644            ]
7645        );
7646        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7647        assert_eq!(
7648            rp,
7649            vec![
7650                17588621, 17588622, 17588623, 17588624, 17588625, 17588626, 17588627, 17588628,
7651                17588629, 17588630, 17588631, 17588632, 17588633, 17588634, 17588635, 17588636,
7652                17588637, 17588638, 17588639, 17588640, 17588641, 17588642, 17588643, 17588644,
7653                17588645, 17588646, 17588647, 17588648, 17588649, 17588650, 17588651, 17588652,
7654                17588653, 17588654, 17588655, 17588656, 17588657, 17589196, 17589197, 17589198,
7655                17589199, 17589200, 17589201, 17589202, 17589203, 17589204, 17589205, 17589206,
7656                17589207, 17589208
7657            ]
7658        );
7659        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7660        assert_eq!(
7661            rp,
7662            vec![
7663                17588621, 17588622, 17588623, 17588624, 17588625, 17588626, 17588627, 17588628,
7664                17588629, 17588630, 17588631, 17588632, 17588633, 17588634, 17588635, 17588636,
7665                17588637, 17588638, 17588639, 17588640, 17588641, 17588642, 17588643, 17588644,
7666                17588645, 17588646, 17588647, 17588648, 17588649, 17588650, 17588651, 17588652,
7667                17588653, 17588654, 17588655, 17588656, 17588657, 17589196, 17589197, 17589198,
7668                17589199, 17589200, 17589201, 17589202, 17589203, 17589204, 17589205, 17589206,
7669                17589207, 17589208
7670            ]
7671        );
7672        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7673        assert_eq!(
7674            rp,
7675            vec![
7676                17591770, 17591771, 17591772, 17591773, 17591774, 17591775, 17591776, 17591777,
7677                17591778, 17591779, 17591780, 17591781, 17591782, 17591783, 17591784, 17591785,
7678                17591786, 17591787, 17591788, 17591789, 17591790, 17591791, 17591792, 17591793,
7679                17591794, 17591796, 17591797, 17591798, 17591799, 17591800, 17591801, 17591802,
7680                17591803, 17591804, 17591805, 17591806, 17591807, 17591808, 17591809, 17591810,
7681                17591811, 17591812, 17591813, 17591814, 17591815, 17591816, 17591817, 17591818,
7682                17591819, 17591820
7683            ]
7684        );
7685        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7686        assert_eq!(
7687            rp,
7688            vec![
7689                17593855, 17593856, 17593857, 17593858, 17593859, 17593860, 17593861, 17593862,
7690                17593863, 17593864, 17593865, 17593866, 17593867, 17593868, 17593869, 17593870,
7691                17593871, 17593872, 17593873, 17593874, 17593875, 17593876, 17593877, 17593878,
7692                17593880, 17593881, 17593882, 17593883, 17593884, 17593885, 17593886, 17593887,
7693                17593888, 17593889, 17593890, 17593891, 17593892, 17593893, 17593894, 17593895,
7694                17593896, 17593897, 17593898, 17593899, 17593900, 17593901, 17593902, 17593903
7695            ]
7696        );
7697        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7698        assert_eq!(
7699            rp,
7700            vec![
7701                17593863, 17593864, 17593865, 17593866, 17593867, 17593868, 17593869, 17593870,
7702                17593871, 17593872, 17593873, 17593874, 17593875, 17593876, 17593877, 17593878,
7703                17593880, 17593881, 17593882, 17593883, 17593884, 17593885, 17593886, 17593887,
7704                17593888, 17593889, 17593890, 17593891, 17593892, 17593893, 17593894, 17593895,
7705                17593896, 17593897, 17593898, 17593899, 17593900, 17593901, 17593902, 17593903,
7706                17593904, 17593905, 17593906, 17593907
7707            ]
7708        );
7709        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7710        assert_eq!(
7711            rp,
7712            vec![
7713                17596476, 17596477, 17596478, 17596479, 17596480, 17596481, 17596482, 17596483,
7714                17596484, 17596485, 17596486, 17596487, 17596488, 17596489, 17596490, 17596491,
7715                17596492, 17596493, 17596494, 17596495, 17596496, 17596497, 17596498, 17596499,
7716                17596500, 17596501, 17596502, 17596503, 17596504, 17596505, 17596506, 17596507,
7717                17596508, 17596509, 17596510, 17596511, 17596512, 17596513, 17596514
7718            ]
7719        );
7720        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7721        assert_eq!(
7722            rp,
7723            vec![
7724                17624012, 17624013, 17624014, 17624015, 17624016, 17624017, 17624018, 17624019,
7725                17624020, 17625913, 17625914, 17625915, 17625916, 17625917, 17625918, 17625919,
7726                17625920, 17625921, 17625922, 17625923, 17625924, 17625925, 17625926, 17625927,
7727                17625928, 17625929, 17625930, 17625931, 17625932, 17625933, 17625934, 17625935,
7728                17625936, 17625937, 17625938, 17625939, 17625940, 17625941, 17625942, 17625943,
7729                17625944, 17625945, 17625946, 17625947, 17625948, 17625949
7730            ]
7731        );
7732        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7733        assert_eq!(
7734            rp,
7735            vec![
7736                17624012, 17624013, 17624014, 17624015, 17624016, 17624017, 17624018, 17624019,
7737                17624020, 17625913, 17625914, 17625915, 17625916, 17625917, 17625918, 17625919,
7738                17625920, 17625921, 17625922, 17625923, 17625924, 17625925, 17625926, 17625927,
7739                17625928, 17625929, 17625930, 17625931, 17625932, 17625933, 17625934, 17625935,
7740                17625936, 17625937, 17625938, 17625939, 17625940, 17625941, 17625942, 17625943,
7741                17625944, 17625945, 17625946, 17625947, 17625948, 17625949, 17625950, 17625951,
7742                17625952
7743            ]
7744        );
7745        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7746        assert_eq!(
7747            rp,
7748            vec![
7749                31796700, 31796701, 31796702, 31796703, 31796704, 31796705, 31796706, 31796710,
7750                31796711, 31796712, 31796713, 31796714, 31796715, 31796716, 31796717, 31796718,
7751                31796719, 31796720, 31796721, 31796722, 31796723, 31796724, 31796725, 31796726,
7752                31796727, 31796728, 31799014, 31799015, 31799016, 31799017, 31799018, 31799019,
7753                31799020, 31799021, 31799022, 31799023, 31799024, 31799025, 31799026, 31799027,
7754                31799028, 31799029, 31799030, 31799031, 31799032, 31799033, 31799034, 31799035,
7755                31799036, 31799037
7756            ]
7757        );
7758        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7759        assert_eq!(
7760            rp,
7761            vec![
7762                36722692, 36722693, 36722694, 36722695, 36722696, 36722697, 36722698, 36722699,
7763                36722700, 36722701, 36722702, 36722703, 36722704, 36722705, 36723505, 36723506,
7764                36723507, 36723508, 36723509, 36723510, 36723511, 36723512, 36723513, 36723514,
7765                36723515, 36723516, 36723517, 36723518, 36723519, 36723520, 36723521, 36723522,
7766                36723523, 36723524, 36723525, 36723526, 36723527, 36723528, 36723529, 36723530,
7767                36723531, 36723532, 36737414, 36737415, 36737416, 36737417, 36737418, 36737419,
7768                36737420
7769            ]
7770        );
7771        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
7772        assert_eq!(
7773            rp,
7774            vec![
7775                44587963, 44587964, 44587965, 44587966, 44587967, 44587968, 44587969, 44587970,
7776                44587971, 44587972, 44587973, 44587974, 44587975, 44587976, 44587977, 44587978,
7777                44587979, 44587980, 44587981, 44587982, 44587983, 44589680, 44589681, 44589682,
7778                44589683, 44589684, 44589685, 44589686, 44589687, 44589688, 44589689, 44589690,
7779                44589691, 44589692, 44589693, 44589694, 44589695, 44589696, 44589697, 44589698,
7780                44589699, 44589700, 44589701, 44589702, 44592034, 44592035, 44592036
7781            ]
7782        );
7783    }
7784
7785    #[test]
7786    fn test_reference_positions_full() {
7787        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
7788        let mut it = bam.records();
7789
7790        let rp: Vec<_> = it
7791            .next()
7792            .unwrap()
7793            .unwrap()
7794            .reference_positions_full()
7795            .collect();
7796        assert_eq!(
7797            rp,
7798            vec![
7799                None,
7800                None,
7801                None,
7802                None,
7803                None,
7804                None,
7805                Some(16050676),
7806                Some(16050677),
7807                Some(16050678),
7808                Some(16050679),
7809                Some(16050680),
7810                Some(16050681),
7811                Some(16050682),
7812                Some(16050683),
7813                Some(16050684),
7814                Some(16050685),
7815                Some(16050686),
7816                Some(16050687),
7817                Some(16050688),
7818                Some(16050689),
7819                Some(16050690),
7820                Some(16050691),
7821                Some(16050692),
7822                Some(16050693),
7823                Some(16050694),
7824                Some(16050695),
7825                Some(16050696),
7826                Some(16050697),
7827                Some(16050698),
7828                Some(16050699),
7829                Some(16050700),
7830                Some(16050701),
7831                Some(16050702),
7832                Some(16050703),
7833                Some(16050704),
7834                Some(16050705),
7835                Some(16050706),
7836                Some(16050707),
7837                Some(16050708),
7838                Some(16050709),
7839                Some(16050710),
7840                Some(16050711),
7841                Some(16050712),
7842                Some(16050713),
7843                Some(16050714),
7844                Some(16050715),
7845                Some(16050716),
7846                Some(16050717),
7847                Some(16050718),
7848                Some(16050719),
7849                Some(16050720)
7850            ]
7851        );
7852        let rp: Vec<_> = it
7853            .next()
7854            .unwrap()
7855            .unwrap()
7856            .reference_positions_full()
7857            .collect();
7858        assert_eq!(
7859            rp,
7860            vec![
7861                Some(16096878),
7862                Some(16096879),
7863                Some(16096880),
7864                Some(16096881),
7865                Some(16096882),
7866                Some(16096883),
7867                Some(16096884),
7868                Some(16096887),
7869                Some(16096888),
7870                Some(16096889),
7871                Some(16096890),
7872                Some(16096891),
7873                Some(16096892),
7874                Some(16096893),
7875                Some(16096894),
7876                Some(16096895),
7877                Some(16096896),
7878                Some(16096897),
7879                Some(16096898),
7880                Some(16096899),
7881                Some(16096900),
7882                Some(16096901),
7883                Some(16096902),
7884                Some(16096903),
7885                Some(16096904),
7886                Some(16096905),
7887                Some(16096906),
7888                Some(16096907),
7889                Some(16096908),
7890                Some(16096909),
7891                Some(16096910),
7892                Some(16096911),
7893                Some(16096912),
7894                Some(16096913),
7895                Some(16096914),
7896                Some(16096915),
7897                Some(16096916),
7898                Some(16096917),
7899                Some(16096918),
7900                Some(16096919),
7901                Some(16096920),
7902                Some(16096921),
7903                Some(16096922),
7904                Some(16096923),
7905                Some(16096924),
7906                Some(16096925),
7907                Some(16096926),
7908                Some(16096927),
7909                Some(16096928),
7910                Some(16096929),
7911                Some(16096930)
7912            ]
7913        );
7914        let rp: Vec<_> = it
7915            .next()
7916            .unwrap()
7917            .unwrap()
7918            .reference_positions_full()
7919            .collect();
7920        assert_eq!(
7921            rp,
7922            vec![
7923                Some(16097145),
7924                Some(16097146),
7925                Some(16097147),
7926                Some(16097148),
7927                Some(16097149),
7928                Some(16097150),
7929                Some(16097151),
7930                Some(16097152),
7931                Some(16097153),
7932                Some(16097154),
7933                Some(16097155),
7934                Some(16097156),
7935                Some(16097157),
7936                Some(16097158),
7937                Some(16097159),
7938                Some(16097160),
7939                Some(16097161),
7940                Some(16097162),
7941                Some(16097163),
7942                Some(16097164),
7943                Some(16097165),
7944                Some(16097166),
7945                Some(16097167),
7946                Some(16097168),
7947                Some(16097169),
7948                Some(16097170),
7949                Some(16097171),
7950                Some(16097172),
7951                Some(16097173),
7952                Some(16097176),
7953                Some(16097177),
7954                Some(16097178),
7955                Some(16097179),
7956                Some(16097180),
7957                Some(16097181),
7958                Some(16097182),
7959                Some(16097183),
7960                Some(16097184),
7961                Some(16097185),
7962                Some(16097186),
7963                Some(16097187),
7964                Some(16097188),
7965                Some(16097189),
7966                Some(16097190),
7967                Some(16097191),
7968                Some(16097192),
7969                Some(16097193),
7970                Some(16097194),
7971                Some(16097195),
7972                Some(16097196),
7973                Some(16097197)
7974            ]
7975        );
7976        let rp: Vec<_> = it
7977            .next()
7978            .unwrap()
7979            .unwrap()
7980            .reference_positions_full()
7981            .collect();
7982        assert_eq!(
7983            rp,
7984            vec![
7985                Some(16117350),
7986                Some(16117351),
7987                Some(16117352),
7988                Some(16117353),
7989                Some(16117354),
7990                Some(16117355),
7991                Some(16117356),
7992                Some(16117357),
7993                Some(16117358),
7994                Some(16117359),
7995                Some(16117360),
7996                Some(16117361),
7997                Some(16117362),
7998                Some(16117363),
7999                Some(16117364),
8000                Some(16117365),
8001                Some(16117366),
8002                Some(16117367),
8003                Some(16117368),
8004                Some(16117369),
8005                Some(16117370),
8006                Some(16117371),
8007                Some(16117372),
8008                Some(16117373),
8009                Some(16117374),
8010                Some(16117375),
8011                Some(16117376),
8012                Some(16117377),
8013                Some(16117378),
8014                Some(16117379),
8015                Some(16117380),
8016                Some(16117381),
8017                Some(16117382),
8018                Some(16117383),
8019                Some(16117384),
8020                Some(16117385),
8021                Some(16117386),
8022                Some(16117387),
8023                Some(16117388),
8024                Some(16117389),
8025                Some(16117390),
8026                Some(16117391),
8027                Some(16117392),
8028                Some(16117393),
8029                Some(16117394),
8030                Some(16117395),
8031                Some(16117396),
8032                Some(16117397),
8033                Some(16117398),
8034                Some(16117399),
8035                Some(16117400)
8036            ]
8037        );
8038        let rp: Vec<_> = it
8039            .next()
8040            .unwrap()
8041            .unwrap()
8042            .reference_positions_full()
8043            .collect();
8044        assert_eq!(
8045            rp,
8046            vec![
8047                Some(16118483),
8048                Some(16118484),
8049                Some(16118485),
8050                Some(16118486),
8051                Some(16118487),
8052                Some(16118488),
8053                Some(16118489),
8054                Some(16118490),
8055                Some(16118491),
8056                Some(16118492),
8057                Some(16118493),
8058                Some(16118494),
8059                Some(16118495),
8060                Some(16118496),
8061                Some(16118497),
8062                Some(16118498),
8063                Some(16118499),
8064                Some(16118500),
8065                Some(16118501),
8066                Some(16118502),
8067                Some(16118503),
8068                Some(16118504),
8069                Some(16118505),
8070                Some(16118506),
8071                Some(16118507),
8072                Some(16118508),
8073                Some(16118509),
8074                Some(16118510),
8075                Some(16118511),
8076                Some(16118512),
8077                Some(16118513),
8078                Some(16118514),
8079                Some(16118515),
8080                Some(16118516),
8081                Some(16118517),
8082                Some(16118518),
8083                Some(16118519),
8084                Some(16118520),
8085                Some(16118521),
8086                Some(16118522),
8087                Some(16118523),
8088                Some(16118524),
8089                Some(16118525),
8090                Some(16118526),
8091                Some(16118527),
8092                Some(16118528),
8093                Some(16118529),
8094                Some(16118530),
8095                Some(16118531),
8096                Some(16118532),
8097                Some(16118533)
8098            ]
8099        );
8100        let rp: Vec<_> = it
8101            .next()
8102            .unwrap()
8103            .unwrap()
8104            .reference_positions_full()
8105            .collect();
8106        assert_eq!(
8107            rp,
8108            vec![
8109                Some(16118499),
8110                Some(16118500),
8111                Some(16118501),
8112                Some(16118502),
8113                Some(16118503),
8114                Some(16118504),
8115                Some(16118505),
8116                Some(16118506),
8117                Some(16118507),
8118                Some(16118508),
8119                Some(16118509),
8120                Some(16118510),
8121                Some(16118511),
8122                Some(16118512),
8123                Some(16118513),
8124                Some(16118514),
8125                Some(16118515),
8126                Some(16118516),
8127                Some(16118517),
8128                Some(16118518),
8129                Some(16118519),
8130                Some(16118520),
8131                Some(16118521),
8132                Some(16118522),
8133                Some(16118523),
8134                Some(16118524),
8135                Some(16118525),
8136                Some(16118526),
8137                Some(16118527),
8138                Some(16118528),
8139                Some(16118529),
8140                Some(16118530),
8141                Some(16118531),
8142                Some(16118532),
8143                Some(16118533),
8144                Some(16118534),
8145                Some(16118535),
8146                Some(16118536),
8147                Some(16118537),
8148                Some(16118538),
8149                Some(16118539),
8150                Some(16118540),
8151                Some(16118541),
8152                Some(16118542),
8153                Some(16118543),
8154                Some(16118544),
8155                Some(16118545),
8156                Some(16118546),
8157                Some(16118547),
8158                Some(16118548),
8159                Some(16118549)
8160            ]
8161        );
8162        let rp: Vec<_> = it
8163            .next()
8164            .unwrap()
8165            .unwrap()
8166            .reference_positions_full()
8167            .collect();
8168        assert_eq!(
8169            rp,
8170            vec![
8171                Some(16118499),
8172                Some(16118500),
8173                Some(16118501),
8174                Some(16118502),
8175                Some(16118503),
8176                Some(16118504),
8177                Some(16118505),
8178                Some(16118506),
8179                Some(16118507),
8180                Some(16118508),
8181                Some(16118509),
8182                Some(16118510),
8183                Some(16118511),
8184                Some(16118512),
8185                Some(16118513),
8186                Some(16118514),
8187                Some(16118515),
8188                Some(16118516),
8189                Some(16118517),
8190                Some(16118518),
8191                Some(16118519),
8192                Some(16118520),
8193                Some(16118521),
8194                Some(16118522),
8195                Some(16118523),
8196                Some(16118524),
8197                Some(16118525),
8198                Some(16118526),
8199                Some(16118527),
8200                Some(16118528),
8201                Some(16118529),
8202                Some(16118530),
8203                Some(16118531),
8204                Some(16118532),
8205                Some(16118533),
8206                Some(16118534),
8207                Some(16118535),
8208                Some(16118536),
8209                Some(16118537),
8210                Some(16118538),
8211                Some(16118539),
8212                Some(16118540),
8213                Some(16118541),
8214                Some(16118542),
8215                Some(16118543),
8216                Some(16118544),
8217                Some(16118545),
8218                Some(16118546),
8219                Some(16118547),
8220                Some(16118548),
8221                Some(16118549)
8222            ]
8223        );
8224        let rp: Vec<_> = it
8225            .next()
8226            .unwrap()
8227            .unwrap()
8228            .reference_positions_full()
8229            .collect();
8230        assert_eq!(
8231            rp,
8232            vec![
8233                Some(16118499),
8234                Some(16118500),
8235                Some(16118501),
8236                Some(16118502),
8237                Some(16118503),
8238                Some(16118504),
8239                Some(16118505),
8240                Some(16118506),
8241                Some(16118507),
8242                Some(16118508),
8243                Some(16118509),
8244                Some(16118510),
8245                Some(16118511),
8246                Some(16118512),
8247                Some(16118513),
8248                Some(16118514),
8249                Some(16118515),
8250                Some(16118516),
8251                Some(16118517),
8252                Some(16118518),
8253                Some(16118519),
8254                Some(16118520),
8255                Some(16118521),
8256                Some(16118522),
8257                Some(16118523),
8258                Some(16118524),
8259                Some(16118525),
8260                Some(16118526),
8261                Some(16118527),
8262                Some(16118528),
8263                Some(16118529),
8264                Some(16118530),
8265                Some(16118531),
8266                Some(16118532),
8267                Some(16118533),
8268                Some(16118534),
8269                Some(16118535),
8270                Some(16118536),
8271                Some(16118537),
8272                Some(16118538),
8273                Some(16118539),
8274                Some(16118540),
8275                Some(16118541),
8276                Some(16118542),
8277                Some(16118543),
8278                Some(16118544),
8279                Some(16118545),
8280                Some(16118546),
8281                Some(16118547),
8282                Some(16118548),
8283                Some(16118549)
8284            ]
8285        );
8286        let rp: Vec<_> = it
8287            .next()
8288            .unwrap()
8289            .unwrap()
8290            .reference_positions_full()
8291            .collect();
8292        assert_eq!(
8293            rp,
8294            vec![
8295                Some(16123411),
8296                Some(16123412),
8297                Some(16123413),
8298                Some(16123414),
8299                Some(16123415),
8300                Some(16123416),
8301                Some(16123417),
8302                Some(16123418),
8303                Some(16123419),
8304                Some(16123420),
8305                Some(16123421),
8306                Some(16123422),
8307                Some(16123423),
8308                Some(16123424),
8309                Some(16123425),
8310                Some(16123426),
8311                Some(16123427),
8312                Some(16123428),
8313                Some(16123429),
8314                Some(16123430),
8315                Some(16123431),
8316                Some(16123432),
8317                Some(16123433),
8318                Some(16123434),
8319                Some(16123435),
8320                Some(16123436),
8321                Some(16123437),
8322                Some(16123438),
8323                Some(16123439),
8324                Some(16123440),
8325                Some(16123441),
8326                Some(16123442),
8327                Some(16123443),
8328                Some(16123444),
8329                Some(16123445),
8330                Some(16123446),
8331                Some(16123447),
8332                Some(16123448),
8333                Some(16123449),
8334                Some(16123450),
8335                Some(16123451),
8336                Some(16123452),
8337                Some(16123453),
8338                Some(16123454),
8339                Some(16123455),
8340                Some(16123456),
8341                Some(16123457),
8342                Some(16123458),
8343                Some(16123459),
8344                Some(16123460),
8345                Some(16123461)
8346            ]
8347        );
8348        let rp: Vec<_> = it
8349            .next()
8350            .unwrap()
8351            .unwrap()
8352            .reference_positions_full()
8353            .collect();
8354        assert_eq!(
8355            rp,
8356            vec![
8357                None,
8358                None,
8359                None,
8360                None,
8361                None,
8362                None,
8363                Some(16123417),
8364                Some(16123418),
8365                Some(16123419),
8366                Some(16123420),
8367                Some(16123421),
8368                Some(16123422),
8369                Some(16123423),
8370                Some(16123424),
8371                Some(16123425),
8372                Some(16123426),
8373                Some(16123427),
8374                Some(16123428),
8375                Some(16123429),
8376                Some(16123430),
8377                Some(16123431),
8378                Some(16123432),
8379                Some(16123433),
8380                Some(16123434),
8381                Some(16123435),
8382                Some(16123436),
8383                Some(16123437),
8384                Some(16123438),
8385                Some(16123439),
8386                Some(16123440),
8387                Some(16123441),
8388                Some(16123442),
8389                Some(16123443),
8390                Some(16123444),
8391                Some(16123445),
8392                Some(16123446),
8393                Some(16123447),
8394                Some(16123448),
8395                Some(16123449),
8396                Some(16123450),
8397                Some(16123451),
8398                Some(16123452),
8399                Some(16123453),
8400                Some(16123454),
8401                Some(16123455),
8402                Some(16123456),
8403                Some(16123457),
8404                Some(16123458),
8405                Some(16123459),
8406                Some(16123460),
8407                Some(16123461)
8408            ]
8409        );
8410        let rp: Vec<_> = it
8411            .next()
8412            .unwrap()
8413            .unwrap()
8414            .reference_positions_full()
8415            .collect();
8416        assert_eq!(
8417            rp,
8418            vec![
8419                Some(16165860),
8420                Some(16165861),
8421                Some(16165862),
8422                Some(16165863),
8423                Some(16165864),
8424                Some(16165865),
8425                Some(16165866),
8426                Some(16165867),
8427                Some(16165868),
8428                Some(16165869),
8429                Some(16165870),
8430                Some(16165871),
8431                Some(16165872),
8432                Some(16165873),
8433                Some(16165874),
8434                Some(16165875),
8435                Some(16165876),
8436                Some(16165877),
8437                Some(16165878),
8438                Some(16165879),
8439                Some(16165880),
8440                Some(16165881),
8441                Some(16165882),
8442                Some(16165883),
8443                Some(16165884),
8444                Some(16165885),
8445                Some(16165886),
8446                Some(16165887),
8447                Some(16165888),
8448                Some(16165889),
8449                Some(16165890),
8450                Some(16165891),
8451                Some(16165892),
8452                Some(16165893),
8453                Some(16165894),
8454                Some(16165895),
8455                Some(16165896),
8456                Some(16165897),
8457                Some(16165898),
8458                Some(16165899),
8459                Some(16165900),
8460                None,
8461                None,
8462                None,
8463                None,
8464                None,
8465                None,
8466                None,
8467                None,
8468                None,
8469                None
8470            ]
8471        );
8472        let rp: Vec<_> = it
8473            .next()
8474            .unwrap()
8475            .unwrap()
8476            .reference_positions_full()
8477            .collect();
8478        assert_eq!(
8479            rp,
8480            vec![
8481                Some(16180871),
8482                Some(16180872),
8483                Some(16180873),
8484                Some(16180874),
8485                Some(16180875),
8486                Some(16180876),
8487                Some(16180877),
8488                Some(16180878),
8489                Some(16180879),
8490                Some(16180880),
8491                Some(16180881),
8492                Some(16180882),
8493                Some(16180883),
8494                Some(16180884),
8495                Some(16180885),
8496                Some(16180886),
8497                Some(16180887),
8498                Some(16180888),
8499                Some(16180889),
8500                Some(16180890),
8501                Some(16180891),
8502                Some(16180892),
8503                Some(16180893),
8504                Some(16180894),
8505                Some(16180895),
8506                Some(16180896),
8507                Some(16180897),
8508                Some(16180898),
8509                Some(16180899),
8510                Some(16180900),
8511                Some(16180901),
8512                Some(16180902),
8513                Some(16180903),
8514                Some(16180904),
8515                Some(16180905),
8516                Some(16180906),
8517                Some(16180907),
8518                Some(16180908),
8519                Some(16180909),
8520                Some(16180910),
8521                Some(16180911),
8522                Some(16180912),
8523                Some(16180913),
8524                Some(16180914),
8525                Some(16180915),
8526                Some(16180916),
8527                Some(16180917),
8528                Some(16180918),
8529                Some(16180919),
8530                Some(16180920),
8531                Some(16180921)
8532            ]
8533        );
8534        let rp: Vec<_> = it
8535            .next()
8536            .unwrap()
8537            .unwrap()
8538            .reference_positions_full()
8539            .collect();
8540        assert_eq!(
8541            rp,
8542            vec![
8543                Some(16189705),
8544                Some(16189706),
8545                Some(16189707),
8546                Some(16189708),
8547                Some(16189709),
8548                Some(16189710),
8549                Some(16189711),
8550                Some(16189712),
8551                Some(16189713),
8552                Some(16189714),
8553                Some(16189715),
8554                Some(16189716),
8555                Some(16189717),
8556                Some(16189718),
8557                Some(16189719),
8558                Some(16189720),
8559                Some(16189721),
8560                Some(16189722),
8561                Some(16189723),
8562                Some(16189724),
8563                Some(16189725),
8564                Some(16189726),
8565                Some(16189727),
8566                Some(16189728),
8567                Some(16189729),
8568                Some(16189730),
8569                Some(16189731),
8570                Some(16189732),
8571                Some(16189733),
8572                Some(16189734),
8573                Some(16189735),
8574                Some(16189736),
8575                Some(16189737),
8576                Some(16189738),
8577                Some(16189739),
8578                Some(16189740),
8579                Some(16189741),
8580                Some(16189742),
8581                Some(16189743),
8582                Some(16189744),
8583                Some(16189745),
8584                Some(16189746),
8585                Some(16189747),
8586                Some(16189748),
8587                Some(16189749),
8588                Some(16189750),
8589                Some(16189751),
8590                Some(16189752),
8591                Some(16189753),
8592                Some(16189754),
8593                Some(16189755)
8594            ]
8595        );
8596        let rp: Vec<_> = it
8597            .next()
8598            .unwrap()
8599            .unwrap()
8600            .reference_positions_full()
8601            .collect();
8602        assert_eq!(
8603            rp,
8604            vec![
8605                Some(16231271),
8606                Some(16231272),
8607                Some(16231273),
8608                Some(16231274),
8609                Some(16231275),
8610                Some(16231276),
8611                Some(16231277),
8612                Some(16231278),
8613                Some(16231279),
8614                Some(16231280),
8615                Some(16231281),
8616                Some(16231282),
8617                Some(16231283),
8618                Some(16231284),
8619                Some(16231285),
8620                Some(16231286),
8621                Some(16231287),
8622                Some(16231288),
8623                Some(16231289),
8624                Some(16231290),
8625                Some(16231291),
8626                Some(16231292),
8627                Some(16231293),
8628                Some(16231294),
8629                Some(16231295),
8630                Some(16231296),
8631                Some(16231297),
8632                Some(16231298),
8633                Some(16231299),
8634                Some(16231300),
8635                Some(16231301),
8636                Some(16231302),
8637                Some(16231303),
8638                Some(16231304),
8639                Some(16231305),
8640                Some(16231306),
8641                Some(16231307),
8642                Some(16231308),
8643                Some(16231309),
8644                Some(16231310),
8645                Some(16231311),
8646                Some(16231312),
8647                Some(16231313),
8648                Some(16231314),
8649                Some(16231315),
8650                Some(16231316),
8651                Some(16231317),
8652                Some(16231318),
8653                Some(16231319),
8654                Some(16231320),
8655                Some(16231321)
8656            ]
8657        );
8658        let rp: Vec<_> = it
8659            .next()
8660            .unwrap()
8661            .unwrap()
8662            .reference_positions_full()
8663            .collect();
8664        assert_eq!(
8665            rp,
8666            vec![
8667                Some(16237657),
8668                Some(16237658),
8669                Some(16237659),
8670                Some(16237660),
8671                Some(16237661),
8672                Some(16237662),
8673                Some(16237663),
8674                Some(16237664),
8675                Some(16237665),
8676                Some(16237666),
8677                Some(16237667),
8678                Some(16237668),
8679                Some(16237669),
8680                Some(16237670),
8681                Some(16237671),
8682                Some(16237672),
8683                Some(16237673),
8684                Some(16237674),
8685                Some(16237675),
8686                Some(16237676),
8687                Some(16237677),
8688                Some(16237678),
8689                Some(16237679),
8690                Some(16237680),
8691                Some(16237681),
8692                Some(16237682),
8693                Some(16237683),
8694                Some(16237684),
8695                Some(16237685),
8696                Some(16237686),
8697                Some(16237687),
8698                Some(16237688),
8699                Some(16237689),
8700                Some(16237690),
8701                Some(16237691),
8702                Some(16237692),
8703                Some(16237693),
8704                Some(16237694),
8705                Some(16237695),
8706                Some(16237696),
8707                Some(16237697),
8708                Some(16237698),
8709                Some(16237699),
8710                Some(16237700),
8711                Some(16237701),
8712                Some(16237702),
8713                Some(16237703),
8714                Some(16237704),
8715                Some(16237705),
8716                Some(16237706),
8717                Some(16237707)
8718            ]
8719        );
8720        let rp: Vec<_> = it
8721            .next()
8722            .unwrap()
8723            .unwrap()
8724            .reference_positions_full()
8725            .collect();
8726        assert_eq!(
8727            rp,
8728            vec![
8729                None,
8730                None,
8731                None,
8732                None,
8733                None,
8734                None,
8735                None,
8736                None,
8737                None,
8738                Some(16255012),
8739                Some(16255013),
8740                Some(16255014),
8741                Some(16255015),
8742                Some(16255016),
8743                Some(16255017),
8744                Some(16255018),
8745                Some(16255019),
8746                Some(16255020),
8747                Some(16255021),
8748                Some(16255022),
8749                Some(16255023),
8750                Some(16255024),
8751                Some(16255025),
8752                Some(16255026),
8753                Some(16255027),
8754                Some(16255028),
8755                Some(16255029),
8756                Some(16255030),
8757                Some(16255031),
8758                Some(16255032),
8759                Some(16255033),
8760                Some(16255034),
8761                Some(16255035),
8762                Some(16255036),
8763                Some(16255037),
8764                Some(16255038),
8765                Some(16255039),
8766                Some(16255040),
8767                Some(16255041),
8768                Some(16255042),
8769                Some(16255043),
8770                Some(16255044),
8771                Some(16255045),
8772                Some(16255046),
8773                Some(16255047),
8774                Some(16255048),
8775                Some(16255049),
8776                Some(16255050),
8777                Some(16255051),
8778                Some(16255052),
8779                Some(16255053)
8780            ]
8781        );
8782        let rp: Vec<_> = it
8783            .next()
8784            .unwrap()
8785            .unwrap()
8786            .reference_positions_full()
8787            .collect();
8788        assert_eq!(
8789            rp,
8790            vec![
8791                Some(16255391),
8792                Some(16255392),
8793                Some(16255393),
8794                Some(16255394),
8795                Some(16255395),
8796                Some(16255396),
8797                Some(16255397),
8798                Some(16255398),
8799                Some(16255399),
8800                Some(16255400),
8801                Some(16255401),
8802                Some(16255402),
8803                Some(16255403),
8804                Some(16255404),
8805                Some(16255405),
8806                Some(16255406),
8807                Some(16255407),
8808                Some(16255408),
8809                Some(16255409),
8810                Some(16255410),
8811                Some(16255411),
8812                Some(16255412),
8813                Some(16255413),
8814                Some(16255414),
8815                Some(16255415),
8816                Some(16255416),
8817                Some(16255417),
8818                Some(16255418),
8819                Some(16255419),
8820                Some(16255420),
8821                Some(16255421),
8822                Some(16255422),
8823                Some(16255423),
8824                Some(16255424),
8825                Some(16255425),
8826                Some(16255426),
8827                Some(16255427),
8828                Some(16255428),
8829                Some(16255429),
8830                Some(16255430),
8831                Some(16255431),
8832                Some(16255432),
8833                Some(16255433),
8834                Some(16255434),
8835                Some(16255435),
8836                Some(16255436),
8837                Some(16255437),
8838                Some(16255438),
8839                Some(16255439),
8840                Some(16255440),
8841                Some(16255441)
8842            ]
8843        );
8844        let rp: Vec<_> = it
8845            .next()
8846            .unwrap()
8847            .unwrap()
8848            .reference_positions_full()
8849            .collect();
8850        assert_eq!(
8851            rp,
8852            vec![
8853                Some(16255392),
8854                Some(16255393),
8855                Some(16255394),
8856                Some(16255395),
8857                Some(16255396),
8858                Some(16255397),
8859                Some(16255398),
8860                Some(16255399),
8861                Some(16255400),
8862                Some(16255401),
8863                Some(16255402),
8864                Some(16255403),
8865                Some(16255404),
8866                Some(16255405),
8867                Some(16255406),
8868                Some(16255407),
8869                Some(16255408),
8870                Some(16255409),
8871                Some(16255410),
8872                Some(16255411),
8873                Some(16255412),
8874                Some(16255413),
8875                Some(16255414),
8876                Some(16255415),
8877                Some(16255416),
8878                Some(16255417),
8879                Some(16255418),
8880                Some(16255419),
8881                Some(16255420),
8882                Some(16255421),
8883                Some(16255422),
8884                Some(16255423),
8885                Some(16255424),
8886                Some(16255425),
8887                Some(16255426),
8888                Some(16255427),
8889                Some(16255428),
8890                Some(16255429),
8891                Some(16255430),
8892                Some(16255431),
8893                Some(16255432),
8894                Some(16255433),
8895                Some(16255434),
8896                Some(16255435),
8897                Some(16255436),
8898                Some(16255437),
8899                Some(16255438),
8900                Some(16255439),
8901                Some(16255440),
8902                Some(16255441),
8903                None
8904            ]
8905        );
8906        let rp: Vec<_> = it
8907            .next()
8908            .unwrap()
8909            .unwrap()
8910            .reference_positions_full()
8911            .collect();
8912        assert_eq!(
8913            rp,
8914            vec![
8915                Some(16256084),
8916                Some(16256085),
8917                Some(16256086),
8918                Some(16256087),
8919                Some(16256088),
8920                Some(16256089),
8921                Some(16256090),
8922                Some(16256091),
8923                Some(16256092),
8924                Some(16256093),
8925                Some(16256094),
8926                Some(16256095),
8927                Some(16256096),
8928                Some(16256097),
8929                Some(16256098),
8930                Some(16256099),
8931                Some(16256100),
8932                Some(16256101),
8933                Some(16256102),
8934                Some(16256103),
8935                Some(16256104),
8936                Some(16256105),
8937                Some(16256106),
8938                Some(16256107),
8939                Some(16256108),
8940                Some(16256109),
8941                Some(16256110),
8942                Some(16256111),
8943                Some(16256112),
8944                Some(16256113),
8945                Some(16256114),
8946                Some(16256115),
8947                Some(16256116),
8948                Some(16256117),
8949                Some(16256118),
8950                Some(16256119),
8951                Some(16256120),
8952                Some(16256121),
8953                Some(16256122),
8954                Some(16256123),
8955                Some(16256124),
8956                Some(16256125),
8957                Some(16256126),
8958                Some(16256127),
8959                Some(16256128),
8960                None,
8961                None,
8962                None,
8963                None,
8964                None,
8965                None
8966            ]
8967        );
8968        let rp: Vec<_> = it
8969            .next()
8970            .unwrap()
8971            .unwrap()
8972            .reference_positions_full()
8973            .collect();
8974        assert_eq!(
8975            rp,
8976            vec![
8977                None,
8978                None,
8979                None,
8980                Some(16256224),
8981                Some(16256225),
8982                Some(16256226),
8983                Some(16256227),
8984                Some(16256228),
8985                Some(16256229),
8986                Some(16256230),
8987                Some(16256231),
8988                Some(16256232),
8989                Some(16256233),
8990                Some(16256234),
8991                Some(16256235),
8992                Some(16256236),
8993                Some(16256237),
8994                Some(16256238),
8995                Some(16256239),
8996                Some(16256240),
8997                Some(16256241),
8998                Some(16256242),
8999                Some(16256243),
9000                Some(16256244),
9001                Some(16256245),
9002                Some(16256246),
9003                Some(16256247),
9004                Some(16256248),
9005                Some(16256249),
9006                Some(16256250),
9007                Some(16256251),
9008                Some(16256252),
9009                Some(16256253),
9010                Some(16256254),
9011                Some(16256255),
9012                Some(16256256),
9013                Some(16256257),
9014                Some(16256258),
9015                Some(16256259),
9016                Some(16256260),
9017                Some(16256261),
9018                Some(16256262),
9019                Some(16256263),
9020                Some(16256264),
9021                Some(16256265),
9022                Some(16256266),
9023                Some(16256267),
9024                Some(16256268),
9025                Some(16256269),
9026                Some(16256270),
9027                Some(16256271)
9028            ]
9029        );
9030        let rp: Vec<_> = it
9031            .next()
9032            .unwrap()
9033            .unwrap()
9034            .reference_positions_full()
9035            .collect();
9036        assert_eq!(
9037            rp,
9038            vec![
9039                Some(16325199),
9040                Some(16325200),
9041                Some(16325201),
9042                Some(16325202),
9043                Some(16325203),
9044                Some(16325204),
9045                Some(16325205),
9046                Some(16325206),
9047                Some(16325207),
9048                Some(16325208),
9049                Some(16325209),
9050                Some(16325210),
9051                Some(16325211),
9052                Some(16325212),
9053                Some(16325213),
9054                Some(16325214),
9055                Some(16325215),
9056                Some(16325216),
9057                Some(16325217),
9058                Some(16325218),
9059                Some(16325219),
9060                Some(16325220),
9061                Some(16325221),
9062                Some(16325222),
9063                Some(16325223),
9064                Some(16325224),
9065                Some(16325225),
9066                Some(16325226),
9067                Some(16325227),
9068                Some(16325228),
9069                Some(16325229),
9070                Some(16325230),
9071                Some(16325231),
9072                Some(16325232),
9073                Some(16325233),
9074                Some(16325234),
9075                Some(16325235),
9076                Some(16325236),
9077                Some(16325237),
9078                Some(16325238),
9079                Some(16325239),
9080                Some(16325240),
9081                None,
9082                None,
9083                None,
9084                None,
9085                None,
9086                None,
9087                None,
9088                None,
9089                None
9090            ]
9091        );
9092        let rp: Vec<_> = it
9093            .next()
9094            .unwrap()
9095            .unwrap()
9096            .reference_positions_full()
9097            .collect();
9098        assert_eq!(
9099            rp,
9100            vec![
9101                None,
9102                None,
9103                None,
9104                None,
9105                None,
9106                None,
9107                None,
9108                None,
9109                None,
9110                None,
9111                None,
9112                None,
9113                None,
9114                Some(16352865),
9115                Some(16352866),
9116                Some(16352867),
9117                Some(16352868),
9118                Some(16352869),
9119                Some(16352870),
9120                Some(16352871),
9121                Some(16352872),
9122                Some(16352873),
9123                Some(16352874),
9124                Some(16352875),
9125                Some(16352876),
9126                Some(16352877),
9127                Some(16352878),
9128                Some(16352879),
9129                Some(16352880),
9130                Some(16352881),
9131                Some(16352882),
9132                Some(16352883),
9133                Some(16352884),
9134                Some(16352885),
9135                Some(16352886),
9136                Some(16352887),
9137                Some(16352888),
9138                Some(16352889),
9139                Some(16352890),
9140                Some(16352891),
9141                Some(16352892),
9142                Some(16352893),
9143                Some(16352894),
9144                Some(16352895),
9145                Some(16352896),
9146                Some(16352897),
9147                Some(16352898),
9148                Some(16352899),
9149                Some(16352900),
9150                Some(16352901),
9151                Some(16352902)
9152            ]
9153        );
9154        let rp: Vec<_> = it
9155            .next()
9156            .unwrap()
9157            .unwrap()
9158            .reference_positions_full()
9159            .collect();
9160        assert_eq!(
9161            rp,
9162            vec![
9163                Some(16352968),
9164                Some(16352969),
9165                Some(16352970),
9166                Some(16352971),
9167                Some(16352972),
9168                Some(16352973),
9169                Some(16352974),
9170                Some(16352975),
9171                Some(16352976),
9172                Some(16352977),
9173                Some(16352978),
9174                Some(16352979),
9175                Some(16352980),
9176                Some(16352981),
9177                Some(16352982),
9178                Some(16352983),
9179                Some(16352984),
9180                Some(16352985),
9181                Some(16352986),
9182                Some(16352987),
9183                Some(16352988),
9184                Some(16352989),
9185                Some(16352990),
9186                Some(16352991),
9187                Some(16352992),
9188                Some(16352993),
9189                Some(16352994),
9190                Some(16352995),
9191                Some(16352996),
9192                Some(16352997),
9193                Some(16352998),
9194                Some(16352999),
9195                Some(16353000),
9196                Some(16353001),
9197                Some(16353002),
9198                Some(16353003),
9199                Some(16353004),
9200                Some(16353005),
9201                Some(16353006),
9202                Some(16353007),
9203                Some(16353008),
9204                Some(16353009),
9205                Some(16353010),
9206                Some(16353011),
9207                None,
9208                None,
9209                None,
9210                None,
9211                None,
9212                None,
9213                None
9214            ]
9215        );
9216        let rp: Vec<_> = it
9217            .next()
9218            .unwrap()
9219            .unwrap()
9220            .reference_positions_full()
9221            .collect();
9222        assert_eq!(
9223            rp,
9224            vec![
9225                None,
9226                None,
9227                None,
9228                None,
9229                None,
9230                Some(16414998),
9231                Some(16414999),
9232                Some(16415000),
9233                Some(16415001),
9234                Some(16415002),
9235                Some(16415003),
9236                Some(16415004),
9237                Some(16415005),
9238                Some(16415006),
9239                Some(16415007),
9240                Some(16415008),
9241                Some(16415009),
9242                Some(16415010),
9243                Some(16415011),
9244                Some(16415012),
9245                Some(16415013),
9246                Some(16415014),
9247                Some(16415015),
9248                Some(16415016),
9249                Some(16415017),
9250                Some(16415018),
9251                Some(16415019),
9252                Some(16415020),
9253                Some(16415021),
9254                Some(16415022),
9255                Some(16415023),
9256                Some(16415024),
9257                Some(16415025),
9258                Some(16415026),
9259                Some(16415027),
9260                Some(16415028),
9261                Some(16415029),
9262                Some(16415030),
9263                Some(16415031),
9264                Some(16415032),
9265                Some(16415033),
9266                Some(16415034),
9267                Some(16415035),
9268                Some(16415036),
9269                Some(16415037),
9270                Some(16415038),
9271                Some(16415039),
9272                Some(16415040),
9273                Some(16415041),
9274                Some(16415042),
9275                Some(16415043)
9276            ]
9277        );
9278        let rp: Vec<_> = it
9279            .next()
9280            .unwrap()
9281            .unwrap()
9282            .reference_positions_full()
9283            .collect();
9284        assert_eq!(
9285            rp,
9286            vec![
9287                Some(17031591),
9288                Some(17031592),
9289                Some(17031593),
9290                Some(17031594),
9291                Some(17031595),
9292                Some(17031596),
9293                Some(17031597),
9294                Some(17031598),
9295                Some(17031599),
9296                Some(17031600),
9297                Some(17031601),
9298                Some(17031602),
9299                Some(17031603),
9300                Some(17031604),
9301                Some(17031605),
9302                Some(17031606),
9303                Some(17031607),
9304                Some(17031608),
9305                Some(17031609),
9306                Some(17031610),
9307                Some(17031611),
9308                Some(17031612),
9309                Some(17031613),
9310                None,
9311                None,
9312                None,
9313                None,
9314                Some(17031614),
9315                Some(17031615),
9316                Some(17031616),
9317                Some(17031617),
9318                Some(17031618),
9319                Some(17031619),
9320                Some(17031620),
9321                Some(17031621),
9322                Some(17031622),
9323                Some(17031623),
9324                Some(17031624),
9325                Some(17031625),
9326                Some(17031626),
9327                Some(17031627),
9328                Some(17031628),
9329                Some(17031629),
9330                Some(17031630),
9331                Some(17031631),
9332                Some(17031632),
9333                Some(17031633),
9334                Some(17031634),
9335                Some(17031635),
9336                Some(17031636),
9337                Some(17031637)
9338            ]
9339        );
9340        let rp: Vec<_> = it
9341            .next()
9342            .unwrap()
9343            .unwrap()
9344            .reference_positions_full()
9345            .collect();
9346        assert_eq!(
9347            rp,
9348            vec![
9349                Some(17057382),
9350                Some(17057383),
9351                Some(17057384),
9352                Some(17057385),
9353                Some(17057386),
9354                Some(17057387),
9355                Some(17057388),
9356                Some(17057389),
9357                Some(17057390),
9358                Some(17057391),
9359                Some(17057392),
9360                Some(17057393),
9361                Some(17057394),
9362                Some(17057395),
9363                Some(17057396),
9364                Some(17057397),
9365                Some(17057398),
9366                Some(17057399),
9367                None,
9368                Some(17057400),
9369                Some(17057401),
9370                Some(17057402),
9371                Some(17057403),
9372                Some(17057404),
9373                Some(17057405),
9374                Some(17057406),
9375                Some(17057407),
9376                Some(17057408),
9377                Some(17057409),
9378                Some(17057410),
9379                Some(17057411),
9380                Some(17057412),
9381                Some(17057413),
9382                Some(17057414),
9383                Some(17057415),
9384                Some(17057416),
9385                Some(17057417),
9386                Some(17057418),
9387                Some(17057419),
9388                Some(17057420),
9389                Some(17057421),
9390                Some(17057422),
9391                Some(17057423),
9392                Some(17057424),
9393                Some(17057425),
9394                Some(17057426),
9395                Some(17057427),
9396                Some(17057428),
9397                Some(17057429),
9398                Some(17057430),
9399                Some(17057431)
9400            ]
9401        );
9402        let rp: Vec<_> = it
9403            .next()
9404            .unwrap()
9405            .unwrap()
9406            .reference_positions_full()
9407            .collect();
9408        assert_eq!(
9409            rp,
9410            vec![
9411                Some(17092766),
9412                Some(17092767),
9413                Some(17092768),
9414                Some(17092769),
9415                Some(17092770),
9416                Some(17092771),
9417                Some(17092772),
9418                Some(17092773),
9419                Some(17092774),
9420                Some(17092775),
9421                Some(17092776),
9422                Some(17092777),
9423                Some(17092778),
9424                Some(17092779),
9425                Some(17092780),
9426                Some(17092781),
9427                Some(17092782),
9428                Some(17094966),
9429                Some(17094967),
9430                Some(17094968),
9431                Some(17094969),
9432                Some(17094970),
9433                Some(17094971),
9434                Some(17094972),
9435                Some(17094973),
9436                Some(17094974),
9437                Some(17094975),
9438                Some(17094976),
9439                Some(17094977),
9440                Some(17094978),
9441                Some(17094979),
9442                Some(17094980),
9443                Some(17094981),
9444                Some(17094982),
9445                Some(17094983),
9446                Some(17094984),
9447                Some(17094985),
9448                Some(17094986),
9449                Some(17094987),
9450                Some(17094988),
9451                Some(17094989),
9452                Some(17094990),
9453                Some(17094991),
9454                Some(17094992),
9455                Some(17094993),
9456                Some(17094994),
9457                Some(17094995),
9458                Some(17094996),
9459                Some(17094997),
9460                Some(17094998),
9461                Some(17094999)
9462            ]
9463        );
9464        let rp: Vec<_> = it
9465            .next()
9466            .unwrap()
9467            .unwrap()
9468            .reference_positions_full()
9469            .collect();
9470        assert_eq!(
9471            rp,
9472            vec![
9473                Some(17092782),
9474                Some(17094966),
9475                Some(17094967),
9476                Some(17094968),
9477                Some(17094969),
9478                Some(17094970),
9479                Some(17094971),
9480                Some(17094972),
9481                Some(17094973),
9482                Some(17094974),
9483                Some(17094975),
9484                Some(17094976),
9485                Some(17094977),
9486                Some(17094978),
9487                Some(17094979),
9488                Some(17094980),
9489                Some(17094981),
9490                Some(17094982),
9491                Some(17094983),
9492                Some(17094984),
9493                Some(17094985),
9494                Some(17094986),
9495                Some(17094987),
9496                Some(17094988),
9497                Some(17094989),
9498                Some(17094990),
9499                Some(17094991),
9500                Some(17094992),
9501                Some(17094993),
9502                Some(17094994),
9503                Some(17094995),
9504                Some(17094996),
9505                Some(17094997),
9506                Some(17094998),
9507                Some(17094999),
9508                Some(17095000),
9509                Some(17095001),
9510                Some(17095002),
9511                Some(17095003),
9512                Some(17095004),
9513                Some(17095005),
9514                Some(17095006),
9515                Some(17095007),
9516                Some(17095008),
9517                Some(17095009),
9518                Some(17095010),
9519                Some(17095011),
9520                Some(17095012),
9521                Some(17095013),
9522                Some(17095014),
9523                Some(17095015)
9524            ]
9525        );
9526        let rp: Vec<_> = it
9527            .next()
9528            .unwrap()
9529            .unwrap()
9530            .reference_positions_full()
9531            .collect();
9532        assert_eq!(
9533            rp,
9534            vec![
9535                Some(17092782),
9536                Some(17094966),
9537                Some(17094967),
9538                Some(17094968),
9539                Some(17094969),
9540                Some(17094970),
9541                Some(17094971),
9542                Some(17094972),
9543                Some(17094973),
9544                Some(17094974),
9545                Some(17094975),
9546                Some(17094976),
9547                Some(17094977),
9548                Some(17094978),
9549                Some(17094979),
9550                Some(17094980),
9551                Some(17094981),
9552                Some(17094982),
9553                Some(17094983),
9554                Some(17094984),
9555                Some(17094985),
9556                Some(17094986),
9557                Some(17094987),
9558                Some(17094988),
9559                Some(17094989),
9560                Some(17094990),
9561                Some(17094991),
9562                Some(17094992),
9563                Some(17094993),
9564                Some(17094994),
9565                Some(17094995),
9566                Some(17094996),
9567                Some(17094997),
9568                Some(17094998),
9569                Some(17094999),
9570                Some(17095000),
9571                Some(17095001),
9572                Some(17095002),
9573                Some(17095003),
9574                Some(17095004),
9575                Some(17095005),
9576                Some(17095006),
9577                Some(17095007),
9578                Some(17095008),
9579                Some(17095009),
9580                Some(17095010),
9581                Some(17095011),
9582                Some(17095012),
9583                Some(17095013),
9584                Some(17095014),
9585                Some(17095015)
9586            ]
9587        );
9588        let rp: Vec<_> = it
9589            .next()
9590            .unwrap()
9591            .unwrap()
9592            .reference_positions_full()
9593            .collect();
9594        assert_eq!(
9595            rp,
9596            vec![
9597                None,
9598                None,
9599                None,
9600                None,
9601                None,
9602                None,
9603                None,
9604                None,
9605                None,
9606                Some(17137287),
9607                Some(17137288),
9608                Some(17137289),
9609                Some(17137290),
9610                Some(17137291),
9611                Some(17137292),
9612                Some(17137293),
9613                Some(17137294),
9614                Some(17137295),
9615                Some(17137296),
9616                Some(17137297),
9617                Some(17137298),
9618                Some(17137299),
9619                Some(17137300),
9620                Some(17137301),
9621                Some(17137302),
9622                Some(17137303),
9623                Some(17137304),
9624                Some(17137305),
9625                Some(17137306),
9626                Some(17137307),
9627                Some(17137308),
9628                Some(17137309),
9629                Some(17137310),
9630                Some(17137311),
9631                Some(17137312),
9632                Some(17137313),
9633                Some(17137314),
9634                Some(17137315),
9635                Some(17137316),
9636                Some(17137317),
9637                Some(17137318),
9638                Some(17137319),
9639                None,
9640                None,
9641                None,
9642                None,
9643                None,
9644                None,
9645                None,
9646                None,
9647                None
9648            ]
9649        );
9650        let rp: Vec<_> = it
9651            .next()
9652            .unwrap()
9653            .unwrap()
9654            .reference_positions_full()
9655            .collect();
9656        assert_eq!(
9657            rp,
9658            vec![
9659                None,
9660                None,
9661                Some(17306238),
9662                Some(17306239),
9663                Some(17306240),
9664                Some(17306241),
9665                Some(17306242),
9666                Some(17306243),
9667                Some(17306244),
9668                Some(17306245),
9669                Some(17306246),
9670                Some(17306247),
9671                Some(17306248),
9672                Some(17306249),
9673                Some(17306250),
9674                Some(17306251),
9675                Some(17306252),
9676                Some(17306253),
9677                Some(17306254),
9678                Some(17306255),
9679                Some(17306256),
9680                Some(17306257),
9681                Some(17306258),
9682                Some(17306259),
9683                Some(17306260),
9684                Some(17306261),
9685                Some(17306262),
9686                Some(17306263),
9687                Some(17306264),
9688                Some(17306265),
9689                Some(17306266),
9690                Some(17306267),
9691                Some(17306268),
9692                Some(17306269),
9693                Some(17306270),
9694                Some(17306271),
9695                Some(17306272),
9696                Some(17306273),
9697                Some(17306274),
9698                Some(17306275),
9699                Some(17306276),
9700                Some(17306277),
9701                Some(17306278),
9702                Some(17306279),
9703                Some(17306280),
9704                Some(17306281),
9705                Some(17306282),
9706                Some(17306283),
9707                Some(17306284),
9708                Some(17306285),
9709                None
9710            ]
9711        );
9712        let rp: Vec<_> = it
9713            .next()
9714            .unwrap()
9715            .unwrap()
9716            .reference_positions_full()
9717            .collect();
9718        assert_eq!(
9719            rp,
9720            vec![
9721                None,
9722                None,
9723                None,
9724                None,
9725                Some(17561868),
9726                Some(17561869),
9727                Some(17561870),
9728                Some(17561871),
9729                Some(17561872),
9730                Some(17561873),
9731                Some(17561874),
9732                Some(17561875),
9733                Some(17561876),
9734                Some(17561877),
9735                Some(17561878),
9736                Some(17561879),
9737                Some(17561880),
9738                Some(17561881),
9739                Some(17561882),
9740                Some(17561883),
9741                Some(17561884),
9742                Some(17561885),
9743                Some(17561886),
9744                Some(17561887),
9745                Some(17561888),
9746                Some(17561889),
9747                Some(17561890),
9748                Some(17561891),
9749                Some(17561892),
9750                Some(17561893),
9751                Some(17561894),
9752                Some(17561895),
9753                Some(17561896),
9754                Some(17561897),
9755                Some(17561898),
9756                Some(17561899),
9757                Some(17561900),
9758                Some(17561901),
9759                Some(17561902),
9760                Some(17561903),
9761                Some(17561904),
9762                Some(17561905),
9763                Some(17561906),
9764                Some(17561907),
9765                Some(17561908),
9766                Some(17561909),
9767                Some(17561910),
9768                Some(17561911),
9769                Some(17561912),
9770                None,
9771                None
9772            ]
9773        );
9774        let rp: Vec<_> = it
9775            .next()
9776            .unwrap()
9777            .unwrap()
9778            .reference_positions_full()
9779            .collect();
9780        assert_eq!(
9781            rp,
9782            vec![
9783                Some(17566078),
9784                Some(17566079),
9785                Some(17566080),
9786                Some(17566081),
9787                Some(17566082),
9788                Some(17566083),
9789                Some(17566084),
9790                Some(17566085),
9791                Some(17566086),
9792                Some(17566087),
9793                Some(17566088),
9794                Some(17566089),
9795                Some(17566090),
9796                Some(17566091),
9797                Some(17566092),
9798                Some(17566093),
9799                Some(17566094),
9800                Some(17566095),
9801                Some(17566096),
9802                Some(17566097),
9803                Some(17566098),
9804                Some(17566099),
9805                Some(17566100),
9806                Some(17566101),
9807                Some(17566102),
9808                Some(17566103),
9809                Some(17566104),
9810                Some(17566105),
9811                Some(17566106),
9812                Some(17566107),
9813                Some(17566108),
9814                Some(17566109),
9815                Some(17566110),
9816                Some(17566111),
9817                Some(17566112),
9818                Some(17566113),
9819                Some(17566114),
9820                Some(17566115),
9821                Some(17566116),
9822                Some(17566117),
9823                Some(17566118),
9824                Some(17577951),
9825                Some(17577952),
9826                Some(17577953),
9827                Some(17577954),
9828                Some(17577955),
9829                Some(17577956),
9830                Some(17577957),
9831                Some(17577958),
9832                Some(17577959),
9833                Some(17577960)
9834            ]
9835        );
9836        let rp: Vec<_> = it
9837            .next()
9838            .unwrap()
9839            .unwrap()
9840            .reference_positions_full()
9841            .collect();
9842        assert_eq!(
9843            rp,
9844            vec![
9845                Some(17566108),
9846                Some(17566109),
9847                Some(17566110),
9848                Some(17566111),
9849                Some(17566112),
9850                Some(17566113),
9851                Some(17566114),
9852                Some(17566115),
9853                Some(17566116),
9854                Some(17566117),
9855                Some(17566118),
9856                Some(17577951),
9857                Some(17577952),
9858                Some(17577953),
9859                Some(17577954),
9860                Some(17577955),
9861                Some(17577956),
9862                Some(17577957),
9863                Some(17577958),
9864                Some(17577959),
9865                Some(17577960),
9866                Some(17577961),
9867                Some(17577962),
9868                Some(17577963),
9869                Some(17577964),
9870                Some(17577965),
9871                Some(17577966),
9872                Some(17577967),
9873                Some(17577968),
9874                Some(17577969),
9875                Some(17577970),
9876                Some(17577971),
9877                Some(17577972),
9878                Some(17577973),
9879                Some(17577974),
9880                Some(17577975),
9881                Some(17578686),
9882                Some(17578687),
9883                Some(17578688),
9884                Some(17578689),
9885                Some(17578690),
9886                Some(17578691),
9887                Some(17578692),
9888                Some(17578693),
9889                Some(17578694),
9890                Some(17578695),
9891                Some(17578696),
9892                Some(17578697),
9893                Some(17578698),
9894                Some(17578699),
9895                Some(17578700)
9896            ]
9897        );
9898        let rp: Vec<_> = it
9899            .next()
9900            .unwrap()
9901            .unwrap()
9902            .reference_positions_full()
9903            .collect();
9904        assert_eq!(
9905            rp,
9906            vec![
9907                Some(17566111),
9908                Some(17566112),
9909                Some(17566113),
9910                Some(17566114),
9911                Some(17566115),
9912                Some(17566116),
9913                Some(17566117),
9914                Some(17566118),
9915                Some(17577951),
9916                Some(17577952),
9917                Some(17577953),
9918                Some(17577954),
9919                Some(17577955),
9920                Some(17577956),
9921                Some(17577957),
9922                Some(17577958),
9923                Some(17577959),
9924                Some(17577960),
9925                Some(17577961),
9926                Some(17577962),
9927                Some(17577963),
9928                Some(17577964),
9929                Some(17577965),
9930                Some(17577966),
9931                Some(17577967),
9932                Some(17577968),
9933                Some(17577969),
9934                Some(17577970),
9935                Some(17577971),
9936                Some(17577972),
9937                Some(17577973),
9938                Some(17577974),
9939                Some(17577975),
9940                Some(17578686),
9941                Some(17578687),
9942                Some(17578688),
9943                Some(17578689),
9944                Some(17578690),
9945                Some(17578691),
9946                Some(17578692),
9947                Some(17578693),
9948                Some(17578694),
9949                Some(17578695),
9950                Some(17578696),
9951                Some(17578697),
9952                Some(17578698),
9953                Some(17578699),
9954                Some(17578700),
9955                Some(17578701),
9956                Some(17578702),
9957                Some(17578703)
9958            ]
9959        );
9960        let rp: Vec<_> = it
9961            .next()
9962            .unwrap()
9963            .unwrap()
9964            .reference_positions_full()
9965            .collect();
9966        assert_eq!(
9967            rp,
9968            vec![
9969                Some(17566111),
9970                Some(17566112),
9971                Some(17566113),
9972                Some(17566114),
9973                Some(17566115),
9974                Some(17566116),
9975                Some(17566117),
9976                Some(17566118),
9977                Some(17577951),
9978                Some(17577952),
9979                Some(17577953),
9980                Some(17577954),
9981                Some(17577955),
9982                Some(17577956),
9983                Some(17577957),
9984                Some(17577958),
9985                Some(17577959),
9986                Some(17577960),
9987                Some(17577961),
9988                Some(17577962),
9989                Some(17577963),
9990                Some(17577964),
9991                Some(17577965),
9992                Some(17577966),
9993                Some(17577967),
9994                Some(17577968),
9995                Some(17577969),
9996                Some(17577970),
9997                Some(17577971),
9998                Some(17577972),
9999                Some(17577973),
10000                Some(17577974),
10001                Some(17577975),
10002                Some(17578686),
10003                Some(17578687),
10004                Some(17578688),
10005                Some(17578689),
10006                Some(17578690),
10007                Some(17578691),
10008                Some(17578692),
10009                Some(17578693),
10010                Some(17578694),
10011                Some(17578695),
10012                Some(17578696),
10013                Some(17578697),
10014                Some(17578698),
10015                Some(17578699),
10016                Some(17578700),
10017                Some(17578701),
10018                Some(17578702),
10019                Some(17578703)
10020            ]
10021        );
10022        let rp: Vec<_> = it
10023            .next()
10024            .unwrap()
10025            .unwrap()
10026            .reference_positions_full()
10027            .collect();
10028        assert_eq!(
10029            rp,
10030            vec![
10031                Some(17566111),
10032                Some(17566112),
10033                Some(17566113),
10034                Some(17566114),
10035                Some(17566115),
10036                Some(17566116),
10037                Some(17566117),
10038                Some(17566118),
10039                Some(17577951),
10040                Some(17577952),
10041                Some(17577953),
10042                Some(17577954),
10043                Some(17577955),
10044                Some(17577956),
10045                Some(17577957),
10046                Some(17577958),
10047                Some(17577959),
10048                Some(17577960),
10049                Some(17577961),
10050                Some(17577962),
10051                Some(17577963),
10052                Some(17577964),
10053                Some(17577965),
10054                Some(17577966),
10055                Some(17577967),
10056                Some(17577968),
10057                Some(17577969),
10058                Some(17577970),
10059                Some(17577971),
10060                Some(17577972),
10061                Some(17577973),
10062                Some(17577974),
10063                Some(17577975),
10064                Some(17578686),
10065                Some(17578687),
10066                Some(17578688),
10067                Some(17578689),
10068                Some(17578690),
10069                Some(17578691),
10070                Some(17578692),
10071                Some(17578693),
10072                Some(17578694),
10073                Some(17578695),
10074                Some(17578696),
10075                Some(17578697),
10076                Some(17578698),
10077                Some(17578699),
10078                Some(17578700),
10079                Some(17578701),
10080                Some(17578702),
10081                Some(17578703)
10082            ]
10083        );
10084        let rp: Vec<_> = it
10085            .next()
10086            .unwrap()
10087            .unwrap()
10088            .reference_positions_full()
10089            .collect();
10090        assert_eq!(
10091            rp,
10092            vec![
10093                Some(17566111),
10094                Some(17566112),
10095                Some(17566113),
10096                Some(17566114),
10097                Some(17566115),
10098                Some(17566116),
10099                Some(17566117),
10100                Some(17566118),
10101                Some(17577951),
10102                Some(17577952),
10103                Some(17577953),
10104                Some(17577954),
10105                Some(17577955),
10106                Some(17577956),
10107                Some(17577957),
10108                Some(17577958),
10109                Some(17577959),
10110                Some(17577960),
10111                Some(17577961),
10112                Some(17577962),
10113                Some(17577963),
10114                Some(17577964),
10115                Some(17577965),
10116                Some(17577966),
10117                Some(17577967),
10118                Some(17577968),
10119                Some(17577969),
10120                Some(17577970),
10121                Some(17577971),
10122                Some(17577972),
10123                Some(17577973),
10124                Some(17577974),
10125                Some(17577975),
10126                Some(17578686),
10127                Some(17578687),
10128                Some(17578688),
10129                Some(17578689),
10130                Some(17578690),
10131                Some(17578691),
10132                Some(17578692),
10133                Some(17578693),
10134                Some(17578694),
10135                Some(17578695),
10136                Some(17578696),
10137                Some(17578697),
10138                Some(17578698),
10139                Some(17578699),
10140                Some(17578700),
10141                Some(17578701),
10142                Some(17578702),
10143                Some(17578703)
10144            ]
10145        );
10146        let rp: Vec<_> = it
10147            .next()
10148            .unwrap()
10149            .unwrap()
10150            .reference_positions_full()
10151            .collect();
10152        assert_eq!(
10153            rp,
10154            vec![
10155                Some(17566112),
10156                Some(17566113),
10157                Some(17566114),
10158                Some(17566115),
10159                Some(17566116),
10160                Some(17566117),
10161                Some(17566118),
10162                Some(17577951),
10163                Some(17577952),
10164                Some(17577953),
10165                Some(17577954),
10166                Some(17577955),
10167                Some(17577956),
10168                Some(17577957),
10169                Some(17577958),
10170                Some(17577959),
10171                Some(17577960),
10172                Some(17577961),
10173                Some(17577962),
10174                Some(17577963),
10175                Some(17577964),
10176                Some(17577965),
10177                Some(17577966),
10178                Some(17577967),
10179                Some(17577968),
10180                Some(17577969),
10181                Some(17577970),
10182                Some(17577971),
10183                Some(17577972),
10184                Some(17577973),
10185                Some(17577974),
10186                Some(17577975),
10187                Some(17578686),
10188                Some(17578687),
10189                Some(17578688),
10190                Some(17578689),
10191                Some(17578690),
10192                Some(17578691),
10193                Some(17578692),
10194                Some(17578693),
10195                Some(17578694),
10196                Some(17578695),
10197                Some(17578696),
10198                Some(17578697),
10199                Some(17578698),
10200                Some(17578699),
10201                Some(17578700),
10202                Some(17578701),
10203                Some(17578702),
10204                Some(17578703),
10205                Some(17578704)
10206            ]
10207        );
10208        let rp: Vec<_> = it
10209            .next()
10210            .unwrap()
10211            .unwrap()
10212            .reference_positions_full()
10213            .collect();
10214        assert_eq!(
10215            rp,
10216            vec![
10217                Some(17566113),
10218                Some(17566114),
10219                Some(17566115),
10220                Some(17566116),
10221                Some(17566117),
10222                Some(17566118),
10223                Some(17577951),
10224                Some(17577952),
10225                Some(17577953),
10226                Some(17577954),
10227                Some(17577955),
10228                Some(17577956),
10229                Some(17577957),
10230                Some(17577958),
10231                Some(17577959),
10232                Some(17577960),
10233                Some(17577961),
10234                Some(17577962),
10235                Some(17577963),
10236                Some(17577964),
10237                Some(17577965),
10238                Some(17577966),
10239                Some(17577967),
10240                Some(17577968),
10241                Some(17577969),
10242                Some(17577970),
10243                Some(17577971),
10244                Some(17577972),
10245                Some(17577973),
10246                Some(17577974),
10247                Some(17577975),
10248                Some(17578686),
10249                Some(17578687),
10250                Some(17578688),
10251                Some(17578689),
10252                Some(17578690),
10253                Some(17578691),
10254                Some(17578692),
10255                Some(17578693),
10256                Some(17578694),
10257                Some(17578695),
10258                Some(17578696),
10259                Some(17578697),
10260                Some(17578698),
10261                Some(17578699),
10262                Some(17578700),
10263                Some(17578701),
10264                Some(17578702),
10265                Some(17578703),
10266                Some(17578704),
10267                Some(17578705)
10268            ]
10269        );
10270        let rp: Vec<_> = it
10271            .next()
10272            .unwrap()
10273            .unwrap()
10274            .reference_positions_full()
10275            .collect();
10276        assert_eq!(
10277            rp,
10278            vec![
10279                Some(17566113),
10280                Some(17566114),
10281                Some(17566115),
10282                Some(17566116),
10283                Some(17566117),
10284                Some(17566118),
10285                Some(17577951),
10286                Some(17577952),
10287                Some(17577953),
10288                Some(17577954),
10289                Some(17577955),
10290                Some(17577956),
10291                Some(17577957),
10292                Some(17577958),
10293                Some(17577959),
10294                Some(17577960),
10295                Some(17577961),
10296                Some(17577962),
10297                Some(17577963),
10298                Some(17577964),
10299                Some(17577965),
10300                Some(17577966),
10301                Some(17577967),
10302                Some(17577968),
10303                Some(17577969),
10304                Some(17577970),
10305                Some(17577971),
10306                Some(17577972),
10307                Some(17577973),
10308                Some(17577974),
10309                Some(17577975),
10310                Some(17578686),
10311                Some(17578687),
10312                Some(17578688),
10313                Some(17578689),
10314                Some(17578690),
10315                Some(17578691),
10316                Some(17578692),
10317                Some(17578693),
10318                Some(17578694),
10319                Some(17578695),
10320                Some(17578696),
10321                Some(17578697),
10322                Some(17578698),
10323                Some(17578699),
10324                Some(17578700),
10325                Some(17578701),
10326                Some(17578702),
10327                Some(17578703),
10328                Some(17578704),
10329                Some(17578705)
10330            ]
10331        );
10332        let rp: Vec<_> = it
10333            .next()
10334            .unwrap()
10335            .unwrap()
10336            .reference_positions_full()
10337            .collect();
10338        assert_eq!(
10339            rp,
10340            vec![
10341                None,
10342                Some(17579733),
10343                Some(17579734),
10344                Some(17579735),
10345                Some(17579736),
10346                Some(17579737),
10347                Some(17579738),
10348                Some(17579739),
10349                Some(17579740),
10350                Some(17579741),
10351                Some(17579742),
10352                Some(17579743),
10353                Some(17579744),
10354                Some(17579745),
10355                Some(17579746),
10356                Some(17579747),
10357                Some(17579748),
10358                Some(17579749),
10359                Some(17579750),
10360                Some(17579751),
10361                Some(17579752),
10362                Some(17579753),
10363                Some(17579754),
10364                Some(17579755),
10365                Some(17579756),
10366                Some(17579757),
10367                Some(17579758),
10368                Some(17579759),
10369                Some(17579760),
10370                Some(17579761),
10371                Some(17579762),
10372                Some(17579763),
10373                Some(17579764),
10374                Some(17579765),
10375                Some(17579766),
10376                Some(17579767),
10377                Some(17579768),
10378                Some(17579769),
10379                Some(17579770),
10380                Some(17579771),
10381                Some(17579772),
10382                Some(17579773),
10383                Some(17579774),
10384                Some(17579775),
10385                Some(17579776),
10386                Some(17581244),
10387                Some(17581245),
10388                Some(17581246),
10389                Some(17581247),
10390                Some(17581248),
10391                Some(17581249)
10392            ]
10393        );
10394        let rp: Vec<_> = it
10395            .next()
10396            .unwrap()
10397            .unwrap()
10398            .reference_positions_full()
10399            .collect();
10400        assert_eq!(
10401            rp,
10402            vec![
10403                Some(17581369),
10404                Some(17581370),
10405                Some(17582885),
10406                Some(17582886),
10407                Some(17582887),
10408                Some(17582888),
10409                Some(17582889),
10410                Some(17582890),
10411                Some(17582891),
10412                Some(17582892),
10413                Some(17582893),
10414                Some(17582894),
10415                Some(17582895),
10416                Some(17582896),
10417                Some(17582897),
10418                Some(17582898),
10419                Some(17582899),
10420                Some(17582900),
10421                Some(17582901),
10422                Some(17582902),
10423                Some(17582903),
10424                Some(17582904),
10425                Some(17582905),
10426                Some(17582906),
10427                Some(17582907),
10428                Some(17582908),
10429                Some(17582909),
10430                Some(17582910),
10431                Some(17582911),
10432                Some(17582912),
10433                Some(17582913),
10434                Some(17582914),
10435                Some(17582915),
10436                Some(17582916),
10437                Some(17582917),
10438                Some(17582918),
10439                Some(17582919),
10440                Some(17582920),
10441                Some(17582921),
10442                Some(17582922),
10443                Some(17582923),
10444                Some(17582924),
10445                Some(17582925),
10446                Some(17582926),
10447                Some(17582927),
10448                Some(17582928),
10449                Some(17582929),
10450                Some(17582930),
10451                Some(17582931),
10452                Some(17582932),
10453                Some(17583028)
10454            ]
10455        );
10456        let rp: Vec<_> = it
10457            .next()
10458            .unwrap()
10459            .unwrap()
10460            .reference_positions_full()
10461            .collect();
10462        assert_eq!(
10463            rp,
10464            vec![
10465                Some(17581370),
10466                Some(17582885),
10467                Some(17582886),
10468                Some(17582887),
10469                Some(17582888),
10470                Some(17582889),
10471                Some(17582890),
10472                Some(17582891),
10473                Some(17582892),
10474                Some(17582893),
10475                Some(17582894),
10476                Some(17582895),
10477                Some(17582896),
10478                Some(17582897),
10479                Some(17582898),
10480                Some(17582899),
10481                Some(17582900),
10482                Some(17582901),
10483                Some(17582902),
10484                Some(17582903),
10485                Some(17582904),
10486                Some(17582905),
10487                Some(17582906),
10488                Some(17582907),
10489                Some(17582908),
10490                Some(17582909),
10491                Some(17582910),
10492                Some(17582911),
10493                Some(17582912),
10494                Some(17582913),
10495                Some(17582914),
10496                Some(17582915),
10497                Some(17582916),
10498                Some(17582917),
10499                Some(17582918),
10500                Some(17582919),
10501                Some(17582920),
10502                Some(17582921),
10503                Some(17582922),
10504                Some(17582923),
10505                Some(17582924),
10506                Some(17582925),
10507                Some(17582926),
10508                Some(17582927),
10509                Some(17582928),
10510                Some(17582929),
10511                Some(17582930),
10512                Some(17582931),
10513                Some(17582932),
10514                Some(17583028),
10515                Some(17583029)
10516            ]
10517        );
10518        let rp: Vec<_> = it
10519            .next()
10520            .unwrap()
10521            .unwrap()
10522            .reference_positions_full()
10523            .collect();
10524        assert_eq!(
10525            rp,
10526            vec![
10527                Some(17581370),
10528                Some(17582885),
10529                Some(17582886),
10530                Some(17582887),
10531                Some(17582888),
10532                Some(17582889),
10533                Some(17582890),
10534                Some(17582891),
10535                Some(17582892),
10536                Some(17582893),
10537                Some(17582894),
10538                Some(17582895),
10539                Some(17582896),
10540                Some(17582897),
10541                Some(17582898),
10542                Some(17582899),
10543                Some(17582900),
10544                Some(17582901),
10545                Some(17582902),
10546                Some(17582903),
10547                Some(17582904),
10548                Some(17582905),
10549                Some(17582906),
10550                Some(17582907),
10551                Some(17582908),
10552                Some(17582909),
10553                Some(17582910),
10554                Some(17582911),
10555                Some(17582912),
10556                Some(17582913),
10557                Some(17582914),
10558                Some(17582915),
10559                Some(17582916),
10560                Some(17582917),
10561                Some(17582918),
10562                Some(17582919),
10563                Some(17582920),
10564                Some(17582921),
10565                Some(17582922),
10566                Some(17582923),
10567                Some(17582924),
10568                Some(17582925),
10569                Some(17582926),
10570                Some(17582927),
10571                Some(17582928),
10572                Some(17582929),
10573                Some(17582930),
10574                Some(17582931),
10575                Some(17582932),
10576                Some(17583028),
10577                Some(17583029)
10578            ]
10579        );
10580        let rp: Vec<_> = it
10581            .next()
10582            .unwrap()
10583            .unwrap()
10584            .reference_positions_full()
10585            .collect();
10586        assert_eq!(
10587            rp,
10588            vec![
10589                None,
10590                Some(17582911),
10591                Some(17582912),
10592                Some(17582913),
10593                Some(17582914),
10594                Some(17582915),
10595                Some(17582916),
10596                Some(17582917),
10597                Some(17582918),
10598                Some(17582919),
10599                Some(17582920),
10600                Some(17582921),
10601                Some(17582922),
10602                Some(17582923),
10603                Some(17582924),
10604                Some(17582925),
10605                Some(17582926),
10606                Some(17582927),
10607                Some(17582928),
10608                Some(17582929),
10609                Some(17582930),
10610                Some(17582931),
10611                Some(17582932),
10612                Some(17583028),
10613                Some(17583029),
10614                Some(17583030),
10615                Some(17583031),
10616                Some(17583032),
10617                Some(17583033),
10618                Some(17583034),
10619                Some(17583035),
10620                Some(17583036),
10621                Some(17583037),
10622                Some(17583038),
10623                Some(17583039),
10624                Some(17583040),
10625                Some(17583041),
10626                Some(17583042),
10627                Some(17583043),
10628                Some(17583044),
10629                Some(17583045),
10630                Some(17583046),
10631                Some(17583047),
10632                Some(17583048),
10633                Some(17583049),
10634                Some(17583050),
10635                Some(17583051),
10636                Some(17583052),
10637                Some(17583053),
10638                Some(17583054),
10639                Some(17583055)
10640            ]
10641        );
10642        let rp: Vec<_> = it
10643            .next()
10644            .unwrap()
10645            .unwrap()
10646            .reference_positions_full()
10647            .collect();
10648        assert_eq!(
10649            rp,
10650            vec![
10651                Some(17588621),
10652                Some(17588622),
10653                Some(17588623),
10654                Some(17588624),
10655                Some(17588625),
10656                Some(17588626),
10657                Some(17588627),
10658                Some(17588628),
10659                Some(17588629),
10660                Some(17588630),
10661                Some(17588631),
10662                Some(17588632),
10663                Some(17588633),
10664                Some(17588634),
10665                Some(17588635),
10666                Some(17588636),
10667                Some(17588637),
10668                Some(17588638),
10669                Some(17588639),
10670                Some(17588640),
10671                Some(17588641),
10672                Some(17588642),
10673                Some(17588643),
10674                Some(17588644),
10675                Some(17588645),
10676                Some(17588646),
10677                Some(17588647),
10678                Some(17588648),
10679                Some(17588649),
10680                Some(17588650),
10681                Some(17588651),
10682                Some(17588652),
10683                Some(17588653),
10684                Some(17588654),
10685                Some(17588655),
10686                Some(17588656),
10687                Some(17588657),
10688                Some(17589196),
10689                Some(17589197),
10690                Some(17589198),
10691                Some(17589199),
10692                Some(17589200),
10693                Some(17589201),
10694                Some(17589202),
10695                Some(17589203),
10696                Some(17589204),
10697                Some(17589205),
10698                Some(17589206),
10699                Some(17589207),
10700                Some(17589208),
10701                None
10702            ]
10703        );
10704        let rp: Vec<_> = it
10705            .next()
10706            .unwrap()
10707            .unwrap()
10708            .reference_positions_full()
10709            .collect();
10710        assert_eq!(
10711            rp,
10712            vec![
10713                Some(17588621),
10714                Some(17588622),
10715                Some(17588623),
10716                Some(17588624),
10717                Some(17588625),
10718                Some(17588626),
10719                Some(17588627),
10720                Some(17588628),
10721                Some(17588629),
10722                Some(17588630),
10723                Some(17588631),
10724                Some(17588632),
10725                Some(17588633),
10726                Some(17588634),
10727                Some(17588635),
10728                Some(17588636),
10729                Some(17588637),
10730                Some(17588638),
10731                Some(17588639),
10732                Some(17588640),
10733                Some(17588641),
10734                Some(17588642),
10735                Some(17588643),
10736                Some(17588644),
10737                Some(17588645),
10738                Some(17588646),
10739                Some(17588647),
10740                Some(17588648),
10741                Some(17588649),
10742                Some(17588650),
10743                Some(17588651),
10744                Some(17588652),
10745                Some(17588653),
10746                Some(17588654),
10747                Some(17588655),
10748                Some(17588656),
10749                Some(17588657),
10750                Some(17589196),
10751                Some(17589197),
10752                Some(17589198),
10753                Some(17589199),
10754                Some(17589200),
10755                Some(17589201),
10756                Some(17589202),
10757                Some(17589203),
10758                Some(17589204),
10759                Some(17589205),
10760                Some(17589206),
10761                Some(17589207),
10762                Some(17589208),
10763                None
10764            ]
10765        );
10766        let rp: Vec<_> = it
10767            .next()
10768            .unwrap()
10769            .unwrap()
10770            .reference_positions_full()
10771            .collect();
10772        assert_eq!(
10773            rp,
10774            vec![
10775                Some(17588621),
10776                Some(17588622),
10777                Some(17588623),
10778                Some(17588624),
10779                Some(17588625),
10780                Some(17588626),
10781                Some(17588627),
10782                Some(17588628),
10783                Some(17588629),
10784                Some(17588630),
10785                Some(17588631),
10786                Some(17588632),
10787                Some(17588633),
10788                Some(17588634),
10789                Some(17588635),
10790                Some(17588636),
10791                Some(17588637),
10792                Some(17588638),
10793                Some(17588639),
10794                Some(17588640),
10795                Some(17588641),
10796                Some(17588642),
10797                Some(17588643),
10798                Some(17588644),
10799                Some(17588645),
10800                Some(17588646),
10801                Some(17588647),
10802                Some(17588648),
10803                Some(17588649),
10804                Some(17588650),
10805                Some(17588651),
10806                Some(17588652),
10807                Some(17588653),
10808                Some(17588654),
10809                Some(17588655),
10810                Some(17588656),
10811                Some(17588657),
10812                Some(17589196),
10813                Some(17589197),
10814                Some(17589198),
10815                Some(17589199),
10816                Some(17589200),
10817                Some(17589201),
10818                Some(17589202),
10819                Some(17589203),
10820                Some(17589204),
10821                Some(17589205),
10822                Some(17589206),
10823                Some(17589207),
10824                Some(17589208),
10825                None
10826            ]
10827        );
10828        let rp: Vec<_> = it
10829            .next()
10830            .unwrap()
10831            .unwrap()
10832            .reference_positions_full()
10833            .collect();
10834        assert_eq!(
10835            rp,
10836            vec![
10837                None,
10838                Some(17591770),
10839                Some(17591771),
10840                Some(17591772),
10841                Some(17591773),
10842                Some(17591774),
10843                Some(17591775),
10844                Some(17591776),
10845                Some(17591777),
10846                Some(17591778),
10847                Some(17591779),
10848                Some(17591780),
10849                Some(17591781),
10850                Some(17591782),
10851                Some(17591783),
10852                Some(17591784),
10853                Some(17591785),
10854                Some(17591786),
10855                Some(17591787),
10856                Some(17591788),
10857                Some(17591789),
10858                Some(17591790),
10859                Some(17591791),
10860                Some(17591792),
10861                Some(17591793),
10862                Some(17591794),
10863                Some(17591796),
10864                Some(17591797),
10865                Some(17591798),
10866                Some(17591799),
10867                Some(17591800),
10868                Some(17591801),
10869                Some(17591802),
10870                Some(17591803),
10871                Some(17591804),
10872                Some(17591805),
10873                Some(17591806),
10874                Some(17591807),
10875                Some(17591808),
10876                Some(17591809),
10877                Some(17591810),
10878                Some(17591811),
10879                Some(17591812),
10880                Some(17591813),
10881                Some(17591814),
10882                Some(17591815),
10883                Some(17591816),
10884                Some(17591817),
10885                Some(17591818),
10886                Some(17591819),
10887                Some(17591820)
10888            ]
10889        );
10890        let rp: Vec<_> = it
10891            .next()
10892            .unwrap()
10893            .unwrap()
10894            .reference_positions_full()
10895            .collect();
10896        assert_eq!(
10897            rp,
10898            vec![
10899                Some(17593855),
10900                Some(17593856),
10901                Some(17593857),
10902                Some(17593858),
10903                Some(17593859),
10904                Some(17593860),
10905                Some(17593861),
10906                Some(17593862),
10907                Some(17593863),
10908                Some(17593864),
10909                Some(17593865),
10910                Some(17593866),
10911                Some(17593867),
10912                Some(17593868),
10913                Some(17593869),
10914                Some(17593870),
10915                Some(17593871),
10916                Some(17593872),
10917                Some(17593873),
10918                Some(17593874),
10919                Some(17593875),
10920                Some(17593876),
10921                Some(17593877),
10922                Some(17593878),
10923                Some(17593880),
10924                Some(17593881),
10925                Some(17593882),
10926                Some(17593883),
10927                Some(17593884),
10928                Some(17593885),
10929                Some(17593886),
10930                Some(17593887),
10931                Some(17593888),
10932                Some(17593889),
10933                Some(17593890),
10934                Some(17593891),
10935                Some(17593892),
10936                Some(17593893),
10937                Some(17593894),
10938                Some(17593895),
10939                Some(17593896),
10940                Some(17593897),
10941                Some(17593898),
10942                Some(17593899),
10943                Some(17593900),
10944                Some(17593901),
10945                Some(17593902),
10946                Some(17593903),
10947                None,
10948                None,
10949                None
10950            ]
10951        );
10952        let rp: Vec<_> = it
10953            .next()
10954            .unwrap()
10955            .unwrap()
10956            .reference_positions_full()
10957            .collect();
10958        assert_eq!(
10959            rp,
10960            vec![
10961                Some(17593863),
10962                Some(17593864),
10963                Some(17593865),
10964                Some(17593866),
10965                Some(17593867),
10966                Some(17593868),
10967                Some(17593869),
10968                Some(17593870),
10969                Some(17593871),
10970                Some(17593872),
10971                Some(17593873),
10972                Some(17593874),
10973                Some(17593875),
10974                Some(17593876),
10975                Some(17593877),
10976                Some(17593878),
10977                Some(17593880),
10978                Some(17593881),
10979                Some(17593882),
10980                Some(17593883),
10981                Some(17593884),
10982                Some(17593885),
10983                Some(17593886),
10984                Some(17593887),
10985                Some(17593888),
10986                Some(17593889),
10987                Some(17593890),
10988                Some(17593891),
10989                Some(17593892),
10990                Some(17593893),
10991                Some(17593894),
10992                Some(17593895),
10993                Some(17593896),
10994                Some(17593897),
10995                Some(17593898),
10996                Some(17593899),
10997                Some(17593900),
10998                Some(17593901),
10999                Some(17593902),
11000                Some(17593903),
11001                Some(17593904),
11002                Some(17593905),
11003                Some(17593906),
11004                Some(17593907),
11005                None,
11006                None,
11007                None,
11008                None,
11009                None,
11010                None,
11011                None
11012            ]
11013        );
11014        let rp: Vec<_> = it
11015            .next()
11016            .unwrap()
11017            .unwrap()
11018            .reference_positions_full()
11019            .collect();
11020        assert_eq!(
11021            rp,
11022            vec![
11023                None,
11024                None,
11025                None,
11026                None,
11027                None,
11028                None,
11029                None,
11030                None,
11031                None,
11032                None,
11033                None,
11034                Some(17596476),
11035                Some(17596477),
11036                Some(17596478),
11037                Some(17596479),
11038                Some(17596480),
11039                Some(17596481),
11040                Some(17596482),
11041                None,
11042                Some(17596483),
11043                Some(17596484),
11044                Some(17596485),
11045                Some(17596486),
11046                Some(17596487),
11047                Some(17596488),
11048                Some(17596489),
11049                Some(17596490),
11050                Some(17596491),
11051                Some(17596492),
11052                Some(17596493),
11053                Some(17596494),
11054                Some(17596495),
11055                Some(17596496),
11056                Some(17596497),
11057                Some(17596498),
11058                Some(17596499),
11059                Some(17596500),
11060                Some(17596501),
11061                Some(17596502),
11062                Some(17596503),
11063                Some(17596504),
11064                Some(17596505),
11065                Some(17596506),
11066                Some(17596507),
11067                Some(17596508),
11068                Some(17596509),
11069                Some(17596510),
11070                Some(17596511),
11071                Some(17596512),
11072                Some(17596513),
11073                Some(17596514)
11074            ]
11075        );
11076        let rp: Vec<_> = it
11077            .next()
11078            .unwrap()
11079            .unwrap()
11080            .reference_positions_full()
11081            .collect();
11082        assert_eq!(
11083            rp,
11084            vec![
11085                None,
11086                None,
11087                None,
11088                None,
11089                None,
11090                Some(17624012),
11091                Some(17624013),
11092                Some(17624014),
11093                Some(17624015),
11094                Some(17624016),
11095                Some(17624017),
11096                Some(17624018),
11097                Some(17624019),
11098                Some(17624020),
11099                Some(17625913),
11100                Some(17625914),
11101                Some(17625915),
11102                Some(17625916),
11103                Some(17625917),
11104                Some(17625918),
11105                Some(17625919),
11106                Some(17625920),
11107                Some(17625921),
11108                Some(17625922),
11109                Some(17625923),
11110                Some(17625924),
11111                Some(17625925),
11112                Some(17625926),
11113                Some(17625927),
11114                Some(17625928),
11115                Some(17625929),
11116                Some(17625930),
11117                Some(17625931),
11118                Some(17625932),
11119                Some(17625933),
11120                Some(17625934),
11121                Some(17625935),
11122                Some(17625936),
11123                Some(17625937),
11124                Some(17625938),
11125                Some(17625939),
11126                Some(17625940),
11127                Some(17625941),
11128                Some(17625942),
11129                Some(17625943),
11130                Some(17625944),
11131                Some(17625945),
11132                Some(17625946),
11133                Some(17625947),
11134                Some(17625948),
11135                Some(17625949)
11136            ]
11137        );
11138        let rp: Vec<_> = it
11139            .next()
11140            .unwrap()
11141            .unwrap()
11142            .reference_positions_full()
11143            .collect();
11144        assert_eq!(
11145            rp,
11146            vec![
11147                None,
11148                None,
11149                Some(17624012),
11150                Some(17624013),
11151                Some(17624014),
11152                Some(17624015),
11153                Some(17624016),
11154                Some(17624017),
11155                Some(17624018),
11156                Some(17624019),
11157                Some(17624020),
11158                Some(17625913),
11159                Some(17625914),
11160                Some(17625915),
11161                Some(17625916),
11162                Some(17625917),
11163                Some(17625918),
11164                Some(17625919),
11165                Some(17625920),
11166                Some(17625921),
11167                Some(17625922),
11168                Some(17625923),
11169                Some(17625924),
11170                Some(17625925),
11171                Some(17625926),
11172                Some(17625927),
11173                Some(17625928),
11174                Some(17625929),
11175                Some(17625930),
11176                Some(17625931),
11177                Some(17625932),
11178                Some(17625933),
11179                Some(17625934),
11180                Some(17625935),
11181                Some(17625936),
11182                Some(17625937),
11183                Some(17625938),
11184                Some(17625939),
11185                Some(17625940),
11186                Some(17625941),
11187                Some(17625942),
11188                Some(17625943),
11189                Some(17625944),
11190                Some(17625945),
11191                Some(17625946),
11192                Some(17625947),
11193                Some(17625948),
11194                Some(17625949),
11195                Some(17625950),
11196                Some(17625951),
11197                Some(17625952)
11198            ]
11199        );
11200        let rp: Vec<_> = it
11201            .next()
11202            .unwrap()
11203            .unwrap()
11204            .reference_positions_full()
11205            .collect();
11206        assert_eq!(
11207            rp,
11208            vec![
11209                None,
11210                Some(31796700),
11211                Some(31796701),
11212                Some(31796702),
11213                Some(31796703),
11214                Some(31796704),
11215                Some(31796705),
11216                Some(31796706),
11217                Some(31796710),
11218                Some(31796711),
11219                Some(31796712),
11220                Some(31796713),
11221                Some(31796714),
11222                Some(31796715),
11223                Some(31796716),
11224                Some(31796717),
11225                Some(31796718),
11226                Some(31796719),
11227                Some(31796720),
11228                Some(31796721),
11229                Some(31796722),
11230                Some(31796723),
11231                Some(31796724),
11232                Some(31796725),
11233                Some(31796726),
11234                Some(31796727),
11235                Some(31796728),
11236                Some(31799014),
11237                Some(31799015),
11238                Some(31799016),
11239                Some(31799017),
11240                Some(31799018),
11241                Some(31799019),
11242                Some(31799020),
11243                Some(31799021),
11244                Some(31799022),
11245                Some(31799023),
11246                Some(31799024),
11247                Some(31799025),
11248                Some(31799026),
11249                Some(31799027),
11250                Some(31799028),
11251                Some(31799029),
11252                Some(31799030),
11253                Some(31799031),
11254                Some(31799032),
11255                Some(31799033),
11256                Some(31799034),
11257                Some(31799035),
11258                Some(31799036),
11259                Some(31799037)
11260            ]
11261        );
11262        let rp: Vec<_> = it
11263            .next()
11264            .unwrap()
11265            .unwrap()
11266            .reference_positions_full()
11267            .collect();
11268        assert_eq!(
11269            rp,
11270            vec![
11271                Some(36722692),
11272                Some(36722693),
11273                Some(36722694),
11274                Some(36722695),
11275                Some(36722696),
11276                Some(36722697),
11277                Some(36722698),
11278                Some(36722699),
11279                Some(36722700),
11280                Some(36722701),
11281                Some(36722702),
11282                Some(36722703),
11283                Some(36722704),
11284                Some(36722705),
11285                Some(36723505),
11286                Some(36723506),
11287                Some(36723507),
11288                Some(36723508),
11289                Some(36723509),
11290                Some(36723510),
11291                Some(36723511),
11292                Some(36723512),
11293                Some(36723513),
11294                Some(36723514),
11295                Some(36723515),
11296                Some(36723516),
11297                Some(36723517),
11298                Some(36723518),
11299                Some(36723519),
11300                Some(36723520),
11301                Some(36723521),
11302                Some(36723522),
11303                Some(36723523),
11304                Some(36723524),
11305                Some(36723525),
11306                Some(36723526),
11307                Some(36723527),
11308                Some(36723528),
11309                Some(36723529),
11310                Some(36723530),
11311                Some(36723531),
11312                Some(36723532),
11313                Some(36737414),
11314                Some(36737415),
11315                Some(36737416),
11316                Some(36737417),
11317                Some(36737418),
11318                Some(36737419),
11319                Some(36737420),
11320                None,
11321                None
11322            ]
11323        );
11324        let rp: Vec<_> = it
11325            .next()
11326            .unwrap()
11327            .unwrap()
11328            .reference_positions_full()
11329            .collect();
11330        assert_eq!(
11331            rp,
11332            vec![
11333                None,
11334                None,
11335                None,
11336                None,
11337                Some(44587963),
11338                Some(44587964),
11339                Some(44587965),
11340                Some(44587966),
11341                Some(44587967),
11342                Some(44587968),
11343                Some(44587969),
11344                Some(44587970),
11345                Some(44587971),
11346                Some(44587972),
11347                Some(44587973),
11348                Some(44587974),
11349                Some(44587975),
11350                Some(44587976),
11351                Some(44587977),
11352                Some(44587978),
11353                Some(44587979),
11354                Some(44587980),
11355                Some(44587981),
11356                Some(44587982),
11357                Some(44587983),
11358                Some(44589680),
11359                Some(44589681),
11360                Some(44589682),
11361                Some(44589683),
11362                Some(44589684),
11363                Some(44589685),
11364                Some(44589686),
11365                Some(44589687),
11366                Some(44589688),
11367                Some(44589689),
11368                Some(44589690),
11369                Some(44589691),
11370                Some(44589692),
11371                Some(44589693),
11372                Some(44589694),
11373                Some(44589695),
11374                Some(44589696),
11375                Some(44589697),
11376                Some(44589698),
11377                Some(44589699),
11378                Some(44589700),
11379                Some(44589701),
11380                Some(44589702),
11381                Some(44592034),
11382                Some(44592035),
11383                Some(44592036)
11384            ]
11385        );
11386    }
11387
11388    #[test]
11389    fn test_reference_start_end() {
11390        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
11391        let mut it = bam.records();
11392        let read = it.next().unwrap().unwrap();
11393        assert_eq!(read.reference_start(), 16050676);
11394        assert_eq!(read.reference_end(), 16050721);
11395        let read = it.next().unwrap().unwrap();
11396        assert_eq!(read.reference_start(), 16096878);
11397        assert_eq!(read.reference_end(), 16096931);
11398        let read = it.next().unwrap().unwrap();
11399        assert_eq!(read.reference_start(), 16097145);
11400        assert_eq!(read.reference_end(), 16097198);
11401        let read = it.next().unwrap().unwrap();
11402        assert_eq!(read.reference_start(), 16117350);
11403        assert_eq!(read.reference_end(), 16117401);
11404        let read = it.next().unwrap().unwrap();
11405        assert_eq!(read.reference_start(), 16118483);
11406        assert_eq!(read.reference_end(), 16118534);
11407        let read = it.next().unwrap().unwrap();
11408        assert_eq!(read.reference_start(), 16118499);
11409        assert_eq!(read.reference_end(), 16118550);
11410        let read = it.next().unwrap().unwrap();
11411        assert_eq!(read.reference_start(), 16118499);
11412        assert_eq!(read.reference_end(), 16118550);
11413        let read = it.next().unwrap().unwrap();
11414        assert_eq!(read.reference_start(), 16118499);
11415        assert_eq!(read.reference_end(), 16118550);
11416        let read = it.next().unwrap().unwrap();
11417        assert_eq!(read.reference_start(), 16123411);
11418        assert_eq!(read.reference_end(), 16123462);
11419        let read = it.next().unwrap().unwrap();
11420        assert_eq!(read.reference_start(), 16123417);
11421        assert_eq!(read.reference_end(), 16123462);
11422        let read = it.next().unwrap().unwrap();
11423        assert_eq!(read.reference_start(), 16165860);
11424        assert_eq!(read.reference_end(), 16165901);
11425        let read = it.next().unwrap().unwrap();
11426        assert_eq!(read.reference_start(), 16180871);
11427        assert_eq!(read.reference_end(), 16180922);
11428        let read = it.next().unwrap().unwrap();
11429        assert_eq!(read.reference_start(), 16189705);
11430        assert_eq!(read.reference_end(), 16189756);
11431        let read = it.next().unwrap().unwrap();
11432        assert_eq!(read.reference_start(), 16231271);
11433        assert_eq!(read.reference_end(), 16231322);
11434        let read = it.next().unwrap().unwrap();
11435        assert_eq!(read.reference_start(), 16237657);
11436        assert_eq!(read.reference_end(), 16237708);
11437        let read = it.next().unwrap().unwrap();
11438        assert_eq!(read.reference_start(), 16255012);
11439        assert_eq!(read.reference_end(), 16255054);
11440        let read = it.next().unwrap().unwrap();
11441        assert_eq!(read.reference_start(), 16255391);
11442        assert_eq!(read.reference_end(), 16255442);
11443        let read = it.next().unwrap().unwrap();
11444        assert_eq!(read.reference_start(), 16255392);
11445        assert_eq!(read.reference_end(), 16255442);
11446        let read = it.next().unwrap().unwrap();
11447        assert_eq!(read.reference_start(), 16256084);
11448        assert_eq!(read.reference_end(), 16256129);
11449        let read = it.next().unwrap().unwrap();
11450        assert_eq!(read.reference_start(), 16256224);
11451        assert_eq!(read.reference_end(), 16256272);
11452        let read = it.next().unwrap().unwrap();
11453        assert_eq!(read.reference_start(), 16325199);
11454        assert_eq!(read.reference_end(), 16325241);
11455        let read = it.next().unwrap().unwrap();
11456        assert_eq!(read.reference_start(), 16352865);
11457        assert_eq!(read.reference_end(), 16352903);
11458        let read = it.next().unwrap().unwrap();
11459        assert_eq!(read.reference_start(), 16352968);
11460        assert_eq!(read.reference_end(), 16353012);
11461        let read = it.next().unwrap().unwrap();
11462        assert_eq!(read.reference_start(), 16414998);
11463        assert_eq!(read.reference_end(), 16415044);
11464        let read = it.next().unwrap().unwrap();
11465        assert_eq!(read.reference_start(), 17031591);
11466        assert_eq!(read.reference_end(), 17031638);
11467        let read = it.next().unwrap().unwrap();
11468        assert_eq!(read.reference_start(), 17057382);
11469        assert_eq!(read.reference_end(), 17057432);
11470        let read = it.next().unwrap().unwrap();
11471        assert_eq!(read.reference_start(), 17092766);
11472        assert_eq!(read.reference_end(), 17095000);
11473        let read = it.next().unwrap().unwrap();
11474        assert_eq!(read.reference_start(), 17092782);
11475        assert_eq!(read.reference_end(), 17095016);
11476        let read = it.next().unwrap().unwrap();
11477        assert_eq!(read.reference_start(), 17092782);
11478        assert_eq!(read.reference_end(), 17095016);
11479        let read = it.next().unwrap().unwrap();
11480        assert_eq!(read.reference_start(), 17137287);
11481        assert_eq!(read.reference_end(), 17137320);
11482        let read = it.next().unwrap().unwrap();
11483        assert_eq!(read.reference_start(), 17306238);
11484        assert_eq!(read.reference_end(), 17306286);
11485        let read = it.next().unwrap().unwrap();
11486        assert_eq!(read.reference_start(), 17561868);
11487        assert_eq!(read.reference_end(), 17561913);
11488        let read = it.next().unwrap().unwrap();
11489        assert_eq!(read.reference_start(), 17566078);
11490        assert_eq!(read.reference_end(), 17577961);
11491        let read = it.next().unwrap().unwrap();
11492        assert_eq!(read.reference_start(), 17566108);
11493        assert_eq!(read.reference_end(), 17578701);
11494        let read = it.next().unwrap().unwrap();
11495        assert_eq!(read.reference_start(), 17566111);
11496        assert_eq!(read.reference_end(), 17578704);
11497        let read = it.next().unwrap().unwrap();
11498        assert_eq!(read.reference_start(), 17566111);
11499        assert_eq!(read.reference_end(), 17578704);
11500        let read = it.next().unwrap().unwrap();
11501        assert_eq!(read.reference_start(), 17566111);
11502        assert_eq!(read.reference_end(), 17578704);
11503        let read = it.next().unwrap().unwrap();
11504        assert_eq!(read.reference_start(), 17566111);
11505        assert_eq!(read.reference_end(), 17578704);
11506        let read = it.next().unwrap().unwrap();
11507        assert_eq!(read.reference_start(), 17566112);
11508        assert_eq!(read.reference_end(), 17578705);
11509        let read = it.next().unwrap().unwrap();
11510        assert_eq!(read.reference_start(), 17566113);
11511        assert_eq!(read.reference_end(), 17578706);
11512        let read = it.next().unwrap().unwrap();
11513        assert_eq!(read.reference_start(), 17566113);
11514        assert_eq!(read.reference_end(), 17578706);
11515        let read = it.next().unwrap().unwrap();
11516        assert_eq!(read.reference_start(), 17579733);
11517        assert_eq!(read.reference_end(), 17581250);
11518        let read = it.next().unwrap().unwrap();
11519        assert_eq!(read.reference_start(), 17581369);
11520        assert_eq!(read.reference_end(), 17583029);
11521        let read = it.next().unwrap().unwrap();
11522        assert_eq!(read.reference_start(), 17581370);
11523        assert_eq!(read.reference_end(), 17583030);
11524        let read = it.next().unwrap().unwrap();
11525        assert_eq!(read.reference_start(), 17581370);
11526        assert_eq!(read.reference_end(), 17583030);
11527        let read = it.next().unwrap().unwrap();
11528        assert_eq!(read.reference_start(), 17582911);
11529        assert_eq!(read.reference_end(), 17583056);
11530        let read = it.next().unwrap().unwrap();
11531        assert_eq!(read.reference_start(), 17588621);
11532        assert_eq!(read.reference_end(), 17589209);
11533        let read = it.next().unwrap().unwrap();
11534        assert_eq!(read.reference_start(), 17588621);
11535        assert_eq!(read.reference_end(), 17589209);
11536        let read = it.next().unwrap().unwrap();
11537        assert_eq!(read.reference_start(), 17588621);
11538        assert_eq!(read.reference_end(), 17589209);
11539        let read = it.next().unwrap().unwrap();
11540        assert_eq!(read.reference_start(), 17591770);
11541        assert_eq!(read.reference_end(), 17591821);
11542        let read = it.next().unwrap().unwrap();
11543        assert_eq!(read.reference_start(), 17593855);
11544        assert_eq!(read.reference_end(), 17593904);
11545        let read = it.next().unwrap().unwrap();
11546        assert_eq!(read.reference_start(), 17593863);
11547        assert_eq!(read.reference_end(), 17593908);
11548        let read = it.next().unwrap().unwrap();
11549        assert_eq!(read.reference_start(), 17596476);
11550        assert_eq!(read.reference_end(), 17596515);
11551        let read = it.next().unwrap().unwrap();
11552        assert_eq!(read.reference_start(), 17624012);
11553        assert_eq!(read.reference_end(), 17625950);
11554        let read = it.next().unwrap().unwrap();
11555        assert_eq!(read.reference_start(), 17624012);
11556        assert_eq!(read.reference_end(), 17625953);
11557        let read = it.next().unwrap().unwrap();
11558        assert_eq!(read.reference_start(), 31796700);
11559        assert_eq!(read.reference_end(), 31799038);
11560        let read = it.next().unwrap().unwrap();
11561        assert_eq!(read.reference_start(), 36722692);
11562        assert_eq!(read.reference_end(), 36737421);
11563        let read = it.next().unwrap().unwrap();
11564        assert_eq!(read.reference_start(), 44587963);
11565        assert_eq!(read.reference_end(), 44592037);
11566    }
11567
11568    #[test]
11569    fn test_infer_seq_len() {
11570        use std::convert::TryFrom;
11571        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
11572        for read in bam.records() {
11573            let read = read.unwrap();
11574            assert_eq!(read.seq_len_from_cigar(false), 51);
11575            assert_eq!(read.seq_len_from_cigar(true), 51);
11576        }
11577
11578        let mut read = bam::Record::new();
11579        for (input_cigar, supposed_length_wo_hard_clip, supposed_length_with_hard_clip) in &[
11580            ("40M", 40, 40),
11581            ("40=", 40, 40),
11582            ("40X", 40, 40),
11583            ("20M5I20M", 45, 45),
11584            ("20M5D20M", 40, 40),
11585            ("5H35M", 35, 40),
11586            ("5S35M", 40, 40),
11587            ("35M5H", 35, 40),
11588            ("35M5S", 40, 40),
11589            ("", 0, 0),
11590        ] {
11591            read.set(
11592                b"test",
11593                Some(&CigarString::try_from(*input_cigar).unwrap()),
11594                b"agtc",
11595                b"BBBB",
11596            );
11597            assert_eq!(
11598                &read.seq_len_from_cigar(false),
11599                supposed_length_wo_hard_clip
11600            );
11601            assert_eq!(
11602                &read.seq_len_from_cigar(true),
11603                supposed_length_with_hard_clip
11604            );
11605        }
11606    }
11607}
extended_htslib/bam/ext.rs

extended_htslib/bam/
ext.rs
