extended_htslib/bam/

ext.rs

//* Copyright 2019 Johannes Köster and Florian Finkernagel,
// Copyright 2025 Guilhem Zeitoun.
// Licensed under the MIT license (http://opensource.org/licenses/MIT)
// This file may not be copied, modified, or distributed
// except according to those terms.

// Extensions for BAM records beyond htslib */
use bio_types::genome::AbstractInterval;

use crate::bam;
use crate::bam::record::{Aux, CsString};
use crate::bam::record::{
    Cigar, CigarString,
    CsValue::{self, *},
};
use crate::htslib;
use std::collections::{BTreeMap, HashMap};

use std::convert::TryInto;
use std::ops::{Range, RangeBounds, RangeInclusive};
use std::str::FromStr;
#[derive(Debug, Clone, Copy)]
pub struct MovingPos {
    fakepos: i64,
    isvalid: bool,
}
impl MovingPos {
    fn new(pos: i64, isvalid: bool) -> Self {
        MovingPos {
            fakepos: pos,
            isvalid,
        }
    }
}
#[derive(Debug, Clone)]
pub struct CsData {
    ///Get the genome align position
    pub genome_pos: MovingPos,
    //Get the read align position
    pub read_pos: MovingPos,
    //Get CS value
    pub state: CsValue,
    //Get sequence if existing else None
    pub sequence: SeqPos,
}
impl CsData {
    //Get genome pos or none if not existing
    pub fn getgenomepos(&self) -> Option<i64> {
        match self.genome_pos.isvalid {
            true => Some(self.genome_pos.fakepos),
            false => None,
        }
    }
    //Get genome pos or the genomic position nefore
    pub fn getgenomepos_zero(&self) -> i64 {
        self.genome_pos.fakepos
    }
    //Get read pos or none if not existing
    pub fn getreadpos(&self) -> Option<i64> {
        match self.read_pos.isvalid {
            true => Some(self.read_pos.fakepos),
            false => None,
        }
    }
    //Get read pos or or the read position nefore
    pub fn getreadpos_zero(&self) -> i64 {
        self.read_pos.fakepos
    }
    fn new(
        genome_pos: (i64, bool),
        read_pos: (i64, bool),
        state: CsValue,
        sequence: SeqPos,
    ) -> Self {
        CsData {
            genome_pos: MovingPos::new(genome_pos.0, genome_pos.1),
            read_pos: MovingPos::new(read_pos.0, read_pos.1),
            state,
            sequence,
        }
    }
}
#[derive(Debug, Clone)]
pub struct SeqPos {
    ///Get genomic sequence, None if not available
    genome_seq: Option<String>,
    ///Get read sequence, None if not available
    read_seq: Option<String>,
}
impl SeqPos {
    //Check genome seq is equal to given seq (None == None)
    pub fn genomematch<T>(&self, genome_match: Option<T>) -> bool
    where
        T: AsRef<str>,
    {
        match (&self.genome_seq, genome_match) {
            (Some(d), Some(q)) if d.to_lowercase() == q.as_ref().to_lowercase() => true,
            (None, None) => true,
            _ => false,
        }
    }
    //Check read seq is equal to given seq (None == None)
    pub fn readmatch<T>(&self, read_match: Option<T>) -> bool
    where
        T: AsRef<str>,
    {
        match (&self.read_seq, read_match) {
            (Some(d), Some(q)) if d.to_lowercase() == q.as_ref().to_lowercase() => true,
            (None, None) => true,
            _ => false,
        }
    }
}
/// Block of aligned pairs
pub struct CgAlignedBlockPairs {
    /// Contig name, use getcontig()
    pub contig: Vec<u8>,
    /// Starting position in the genome, 0-based
    pub genome_pos: i64,
    /// Length of the alignment
    pub genomelen: usize,
    cs_index: usize,
    csdata: Vec<CsData>,
    /// Cs String
    pub cs: CsString,
}
impl CgAlignedBlockPairs {
    ///Get contig name
    pub fn getcontig(&self) -> &[u8] {
        &self.contig
    }
    /// Is a long cs
    pub fn islongcs(&self) -> bool {
        self.cs.islongcs()
    }
    /// Get CS tag
    pub fn getcs(&self) -> &CsString {
        &self.cs
    }
    ///Restrict Cgblocks to a specific region
    pub fn restrict<T>(&mut self, contig: &[u8], range: T)
    where
        T: RangeBounds<usize>,
    {
        let genomepos = match self.genome_pos.try_into() {
            Ok(a) => a,
            Err(_a) => {
                return;
            }
        };
        if self.contig != contig || !range.contains(&genomepos) {
            self.csdata.clear();
            return;
        }
        let new = self
            .filter(|p| {
                if let Ok(a) = p.getgenomepos_zero().try_into() {
                    range.contains(&a)
                } else {
                    false
                }
            })
            .collect();
        self.csdata = new;
    }
}
impl Iterator for CgAlignedBlockPairs {
    type Item = CsData;

    fn next(&mut self) -> Option<Self::Item> {
        match self.csdata.get(self.cs_index) {
            Some(value) => {
                self.cs_index += 1;
                Some(value.clone())
            }
            None => None,
        }
    }
}
impl Into<CsString> for CgAlignedBlockPairs {
    fn into(self) -> CsString {
        self.cs
    }
}
impl CgAlignedBlockPairs {
    fn increasecounting(mut genome_pos: i64, mut query_pos: i64, state: &CsValue) -> (i64, i64) {
        match state {
            CsValue::Same(_) | CsValue::Intron(_) => {
                genome_pos += state.getlength() as i64;
                query_pos += state.getlength() as i64;
                (genome_pos, query_pos)
            }
            CsValue::Deletion(_) => {
                genome_pos += state.getlength() as i64;
                (genome_pos, query_pos)
            }
            CsValue::Insertion(_) => {
                query_pos += state.getlength() as i64;
                (genome_pos, query_pos)
            }
            CsValue::Substitution(_) => {
                genome_pos += 1;
                query_pos += 1;
                (genome_pos, query_pos)
            }
        }
    }
    /// Transform a CSstring into a CgAlignedBlockPairs
    fn createfromcs<T, F>(
        csstring: F,
        seq: Option<T>,
        contig: Vec<u8>,
        old_genome_pos: i64,
    ) -> Result<Self, crate::bam::Error>
    where
        T: Into<String>,
        F: Into<CsString>,
    {
        let (mut genome_pos, mut query_pos): (i64, i64) = (old_genome_pos, 0);
        let csstring = csstring.into();
        let seq = seq.map(|p| p.into()).and_then(|f| {
            if f.trim().is_empty() {
                None
            } else {
                Some(f.trim().to_string())
            }
        });
        let mut list = Vec::new();
        for block in csstring.into_iter() {
            let (seq, state) = match (seq.as_ref(), block) {
                //Cs tag does not provide sequence (short form) but we have a cigar tag that can help us
                (Some(s), a) if a.issame() => {
                    let val: String = s
                        .char_indices()
                        .skip(query_pos.try_into().unwrap_or_default())
                        .take(a.getlength())
                        .into_iter()
                        .map(|(_a, b)| b)
                        .collect();
                    if val.trim().is_empty() {
                        return Err(crate::errors::Error::BamParseCS {
                            rec: format!("Invalid format for CS tag at value {}", a),
                        });
                    }
                    (Some(val), a)
                }
                (None, a) if a.issame() => {
                    return Err(crate::errors::Error::BamParseCS {
                        rec: format!("No seq provided to match for CS tag at value {}", a),
                    });
                }
                (_, s) if s.isintron() => (None, s),
                //Cs tag provides the sequence
                (_, s) if let Some(a) = s.getseq() => (Some(a), s),
                (_, b) => {
                    return Err(crate::errors::Error::BamParseCS {
                        rec: format!("Invalid format for CS tag at value {}", b),
                    });
                }
            };
            let (seq1, seq2) = match state {
                CsValue::Substitution((a, b)) => (Some(a.to_string()), Some(b.to_string())),
                CsValue::Same(_) => match seq {
                    None => (None, None),
                    Some(d) => (Some(d.clone()), Some(d.clone())),
                },
                CsValue::Deletion(_) => {
                    let seq = seq
                        .as_ref()
                        .ok_or_else(|| crate::errors::Error::BamParseCS {
                            rec: "Invalid string CS".to_string(),
                        })?;
                    (None, Some(seq.clone()))
                }
                CsValue::Insertion(_) | CsValue::Intron(_) => {
                    let seq = seq
                        .as_ref()
                        .ok_or_else(|| crate::errors::Error::BamParseCS {
                            rec: "Invalid string CS".to_string(),
                        })?;
                    (Some(seq.clone()), None)
                }
            };
            let seq = SeqPos {
                genome_seq: seq1,
                read_seq: seq2,
            };
            let genome_bool = !matches!(state, CsValue::Insertion(_));
            let read_bool = !matches!(state, CsValue::Deletion(_));
            let elem = CsData::new(
                (genome_pos, genome_bool),
                (query_pos, read_bool),
                state.clone(),
                seq,
            );
            (genome_pos, query_pos) = Self::increasecounting(genome_pos, query_pos, &state);
            list.push(elem);
        }
        Ok(CgAlignedBlockPairs {
            contig,
            genome_pos: old_genome_pos,
            genomelen: std::convert::TryInto::<usize>::try_into(genome_pos - old_genome_pos + 1)
                .unwrap(),
            cs_index: 0,
            csdata: list,
            cs: csstring,
        })
    }
    /// Parses an MD tag (from SAM format) and a CIGAR string to generate a consensus sequence (CS).
    ///
    /// # Arguments
    /// * `md` - The MD tag string (e.g., "147^C4418^C731^G").
    /// * `seq` - The read sequence (e.g., "ACGTACGT...").
    /// * `cigar` - The CIGAR string as a slice of `Cigar` operations.
    /// * `line` - A identifier for the current line (used for error reporting).
    /// * `long_cs` - If true, generates a detailed consensus sequence with explicit matches/mismatches.
    /// * `contig` - The contig (chromosome) name.
    /// * `genome_pos` - The starting genome position of the alignment.
    ///
    /// # Returns
    /// A `Result` containing the parsed consensus sequence or an error if parsing fails.
    ///
    /// # Errors
    /// Returns `bam::Error::BamParseMD` if:
    /// - The MD tag, sequence, or CIGAR string is empty.
    /// - The MD tag starts or ends with a deletion (`^`).
    /// - The MD tag or CIGAR string is malformed.
    /// - The MD tag and CIGAR string are inconsistent (e.g., lengths do not match).
    ///
    /// # SAM Format Notes
    /// - The MD tag describes mismatches and deletions in the reference.
    ///   - Matches: `\d+` (e.g., "10" for 10 matches).
    ///   - Mismatches: `[A-Za-z]` (e.g., "A" for a mismatch with base `A`).
    ///   - Deletions: `\^[A-Za-z]+` (e.g., "^ATG" for a deletion of "ATG" in the reference).
    /// - The CIGAR string describes the alignment:
    ///   - `M`/`=`/`X`: Match/mismatch (consumes both read and reference).
    ///   - `I`: Insertion (consumes read only).
    ///   - `D`: Deletion (consumes reference only).
    ///   - `N`: Reference skip (consumes reference only).
    ///   - `S`/`H`: Soft/hard clip (ignored for MD tag parsing).
    fn createfrommdtag<T>(
        md: T,
        seq: T,
        cigar: &[Cigar],
        line: T,
        long_cs: bool,
        contig: Vec<u8>,
        genome_pos: i64,
    ) -> Result<Self, bam::Error>
    where
        T: AsRef<str>,
    {
        // Trim and validate inputs
        let md = md.as_ref().trim();
        let seq = seq.as_ref().trim();
        let line = line.as_ref().trim();

        if md.is_empty() || seq.is_empty() || cigar.is_empty() {
            return Err(bam::Error::BamParseMD {
                rec: format!("at line {}: MD, SEQ, or CIGAR tag is empty", line),
            });
        }

        if md.starts_with('^') || md.ends_with('^') {
            return Err(bam::Error::BamParseMD {
                rec: format!("at line {}: MD tag cannot start or end with '^'", line),
            });
        }

        // Regex to parse the MD tag:
        // - Group 1: Matches (digits, e.g., "10").
        // - Group 2: Deletion marker (`^`).
        // - Group 3: Deletion bases (e.g., "ATG" in "^ATG").
        // - Group 4: Mismatch base(s) (e.g., "A" or "A0T").
        let re_md = regex::RegexBuilder::new(r"(\d+)|(\^)([a-z]+)|((?:[a-z]0?)+)")
            .case_insensitive(true)
            .build()
            .map_err(|e| bam::Error::BamParseMD {
                rec: format!("at line {}: Invalid MD tag regex: {}", line, e),
            })?;

        // Initialize positions:
        // - `cx`: Current reference position (from CIGAR).
        // - `cy`: Current read position (from CIGAR).
        // - `mx`: Current reference position (from MD tag).
        // - `my`: Current read position (from MD tag).
        let mut cx = 0;
        let mut cy = 0;
        let mut mx = 0;
        let mut my: usize = 0;
        let mut k = 0; // CIGAR index
        let mut rem_cl: usize = 0; // Cigar last bases (M/=/X)
        let mut cs = String::new(); // Consensus sequence

        for cap in re_md.captures_iter(md) {
            // --- Handle deletions in the MD tag (e.g., "^ATG") ---
            if let Some(deletion) = cap.get(3) {
                let deletion_len = deletion.as_str().len();
                // Deletions in the MD tag represent bases in the reference that are not in the read.
                // They only advance the reference position (`mx`).
                cs.push('-');
                cs.push_str(deletion.as_str());
                mx += deletion_len;
                cx += deletion_len;
                if cigar.get(k) == Some(&Cigar::Del(deletion_len.try_into().unwrap_or_default())) {
                    k += 1;
                }
                rem_cl = 0;
                continue;
            }

            // --- Handle matches (digits) or mismatches (multiples base) ---
            let mut ml = if let Some(match_len) = cap.get(1) {
                // Parse match length (e.g., "10" -> 10)
                match_len
                    .as_str()
                    .parse::<usize>()
                    .map_err(|e| bam::Error::BamParseMD {
                        rec: format!("at line {}: Invalid match length in MD tag: {}", line, e),
                    })?
            } else if let Some(b) = cap.get(4) {
                // Mismatch: remove 0 match and count bases
                b.as_str().replace("0", "").len()
            } else {
                return Err(bam::Error::BamParseMD {
                    rec: format!("at line {}: Invalid MD tag component: {}", line, md),
                });
            };

            if ml == 0 {
                continue; // Skip zero-length matches
            }

            // --- Process CIGAR operations to align with the MD tag ---
            while let Some(elem) = cigar.get(k) {
                match elem {
                    // --- Deletions in CIGAR (D) ---
                    // Deletions in CIGAR represent bases in the reference that are not in the read.
                    // They only advance the reference position (`cx`).
                    Cigar::Del(cl) => {
                        let cl: usize = (*cl).try_into().map_err(|_| bam::Error::BamParseMD {
                            rec: format!("at line {}: Invalid CIGAR deletion length", line),
                        })?;
                        cx += cl;
                        mx += cl;
                        k += 1;
                        rem_cl = 0;
                    }

                    // --- Matches, mismatches, or equal operations (M/=/X) ---
                    // These consume both the read and reference.
                    Cigar::Equal(cl) | Cigar::Diff(cl) | Cigar::Match(cl) => {
                        let cl: usize = (*cl).try_into().map_err(|_| bam::Error::BamParseMD {
                            rec: format!("at line {}: Invalid CIGAR match length", line),
                        })?;
                        if rem_cl == 0 {
                            rem_cl = cl;
                        }
                        let take = ml.min(rem_cl);

                        if let Some(mismatch_base) = cap.get(4) {
                            // (inchangé pour le cas courant à 1 base — voir note plus bas
                            //  si un mismatch multi-bases peut chevaucher une insertion)
                            let mut raw = String::new();
                            for (index, charm) in
                                mismatch_base.as_str().replace("0", "").chars().enumerate()
                            {
                                raw.push('*');
                                raw.push_str(&charm.to_string());
                                let string: Vec<char> =
                                    seq.chars().skip(my.saturating_add(index)).take(1).collect();
                                let string: String = string.into_iter().collect();
                                if string.trim().is_empty() {
                                    return Err(bam::Error::BamParseMD {
                                        rec: format!(
                                            "at line {}: Read sequence too short for MD tag",
                                            line
                                        ),
                                    });
                                }
                                raw.push_str(&string);
                            }
                            cs.push_str(&raw);
                        } else if long_cs {
                            cs.push('=');
                            let string: Vec<char> = seq.chars().skip(my).take(take).collect();
                            let string: String = string.into_iter().collect();
                            if string.trim().is_empty() {
                                return Err(bam::Error::BamParseMD {
                                    rec: format!(
                                        "at line {}: Read sequence too short for MD tag",
                                        line
                                    ),
                                });
                            }
                            cs.push_str(&string);
                        } else {
                            cs.push(':');
                            cs.push_str(&take.to_string()); // était `cl.to_string()`
                        }

                        mx += take;
                        my += take;
                        cx += take;
                        cy += take;
                        ml -= take;
                        rem_cl -= take;

                        if rem_cl == 0 {
                            k += 1; // opération CIGAR épuisée seulement maintenant
                        }
                        if ml == 0 {
                            break;
                        }
                    }

                    // --- Insertions in CIGAR (I) ---
                    // Insertions consume the read but not the reference.
                    Cigar::Ins(cl) => {
                        let cl: usize = (*cl).try_into().map_err(|_| bam::Error::BamParseMD {
                            rec: format!("at line {}: Invalid CIGAR insertion length", line),
                        })?;
                        cs.push('+');
                        let string: Vec<char> = seq.chars().skip(cy).take(cl).collect();
                        let string: String = string.into_iter().collect();
                        if string.trim().is_empty() {
                            return Err(bam::Error::BamParseMD {
                                rec: format!(
                                    "at line {}: Read sequence too short for MD tag insertion. Cy is {} and CL is {}",
                                    line, cy, cl
                                ),
                            });
                        }
                        cs.push_str(&string);
                        cy += cl;
                        my += cl;
                        k += 1;
                        rem_cl = 0;
                    }

                    // --- Soft clips (S) ---
                    // Soft clips consume the read but not the reference.
                    Cigar::SoftClip(cl) => {
                        let cl: usize = (*cl).try_into().map_err(|_| bam::Error::BamParseMD {
                            rec: format!("at line {}: Invalid CIGAR soft clip length", line),
                        })?;
                        cy += cl;
                        my += cl;
                        k += 1;
                        rem_cl = 0;
                    }

                    // --- Reference skips (N) ---
                    // Reference skips consume the reference but not the read.
                    Cigar::RefSkip(cl) => {
                        let cl: usize = (*cl).try_into().map_err(|_| bam::Error::BamParseMD {
                            rec: format!("at line {}: Invalid CIGAR reference skip length", line),
                        })?;
                        cx += cl;
                        mx += cl;
                        k += 1;
                        rem_cl = 0;
                    }

                    // --- Hard clips (H) and padding (P) ---
                    // These are ignored for MD tag parsing.
                    Cigar::HardClip(_) | Cigar::Pad(_) => {
                        k += 1;
                        rem_cl = 0;
                    }
                }
            }

            // If there's remaining `ml`, the CIGAR string is incomplete
            if ml != 0 {
                return Err(bam::Error::BamParseMD {
                    rec: format!(
                        "at line {}: Inconsistent MD tag (ml={} remaining, cx={}, mx={}, cy={}, my={}, cigarpos={}, elem={:?}, md={:?})",
                        line,
                        ml,
                        cx,
                        mx,
                        cy,
                        my,
                        k,
                        cigar.get(k.saturating_sub(1)),
                        cap
                    ),
                });
            }
        }

        // Final check: All positions must align
        if cx != mx || cy != my {
            return Err(bam::Error::BamParseMD {
                rec: format!(
                    "at line {}: Inconsistent alignment (cx={}, mx={}, cy={}, my={})",
                    line, cx, mx, cy, my
                ),
            });
        }

        // Success: Create the consensus sequence
        Ok(Self::createfromcs(
            CsString::from_str(&cs)?,
            Some(seq.to_string()),
            contig,
            genome_pos,
        )?)
    }
}
pub trait MatchIter {
    ///Only print matched bases?
    fn ismatchonly(&self) -> bool;
    ///Set match state
    fn setmatchstate(&mut self, matchs: bool);
}
pub struct IterAlignedBlockCigarMatchPairs {
    genome_pos: i64,
    read_pos: i64,
    cigar_index: usize,
    cigar: Vec<Cigar>,
}
impl Iterator for IterAlignedBlockCigarMatchPairs {
    type Item = (Option<(Range<i64>, Range<i64>)>, Cigar);
    fn next(&mut self) -> Option<Self::Item> {
        while self.cigar_index < self.cigar.len() {
            let entry = self.cigar[self.cigar_index];
            self.cigar_index += 1;
            match entry {
                Cigar::Match(len) | Cigar::Equal(len) | Cigar::Diff(len) => {
                    let qstart = self.read_pos;
                    let qend = qstart + len as i64;
                    let rstart = self.genome_pos;
                    let rend = self.genome_pos + len as i64;
                    self.read_pos += len as i64;
                    self.genome_pos += len as i64;
                    if matches!(entry, Cigar::Equal(_)) {
                        return Some((Some((qstart..qend, rstart..rend)), entry));
                    }
                }
                Cigar::Ins(len) | Cigar::SoftClip(len) => {
                    self.read_pos += len as i64;
                }
                Cigar::Del(len) | Cigar::RefSkip(len) => {
                    self.genome_pos += len as i64;
                }
                Cigar::HardClip(_) => {} // no advance
                Cigar::Pad(_) => panic!("Padding (Cigar::Pad) is not supported."), //padding is only used for multiple sequence alignment
            }
            return Some((None, entry));
        }
        None
    }
}
pub struct IterAlignedBlockCigarPairs {
    genome_pos: i64,
    read_pos: i64,
    cigar_index: usize,
    cigar: Vec<Cigar>,
}
impl Iterator for IterAlignedBlockCigarPairs {
    type Item = (Range<i64>, Range<i64>, Cigar);
    fn next(&mut self) -> Option<Self::Item> {
        while self.cigar_index < self.cigar.len() {
            let entry = self.cigar[self.cigar_index];
            self.cigar_index += 1;
            match entry {
                Cigar::Match(len) | Cigar::Equal(len) | Cigar::Diff(len) => {
                    let qstart = self.read_pos;
                    let qend = qstart + len as i64;
                    let rstart = self.genome_pos;
                    let rend = self.genome_pos + len as i64;
                    self.read_pos += len as i64;
                    self.genome_pos += len as i64;
                    return Some((qstart..qend, rstart..rend, entry));
                }
                Cigar::Ins(len) | Cigar::SoftClip(len) => {
                    let qstart = self.read_pos;
                    let qend = qstart + len as i64;
                    let rstart = self.genome_pos;
                    self.read_pos += len as i64;
                    return Some((qstart..qend, rstart..rstart, entry));
                }
                Cigar::Del(len) | Cigar::RefSkip(len) => {
                    let qstart = self.read_pos;
                    let rstart = self.genome_pos;
                    let rend = self.genome_pos + len as i64;
                    self.genome_pos += len as i64;
                    return Some((qstart..qstart, rstart..rend, entry));
                }
                Cigar::HardClip(_) => {
                    return Some((
                        self.read_pos..self.read_pos,
                        self.genome_pos..self.genome_pos,
                        entry,
                    ));
                } // no advance
                Cigar::Pad(_) => panic!("Padding (Cigar::Pad) is not supported."), //padding is only used for multiple sequence alignment
            }
        }
        None
    }
}
pub struct IterAlignedBlockPairs {
    genome_pos: i64,
    read_pos: i64,
    cigar_index: usize,
    cigar: Vec<Cigar>,
    r#match: bool,
}
impl MatchIter for IterAlignedBlockPairs {
    fn ismatchonly(&self) -> bool {
        self.r#match
    }

    fn setmatchstate(&mut self, matchs: bool) {
        self.r#match = matchs;
    }
}
impl Iterator for IterAlignedBlockPairs {
    type Item = ([i64; 2], [i64; 2]);
    fn next(&mut self) -> Option<Self::Item> {
        while self.cigar_index < self.cigar.len() {
            let entry = self.cigar[self.cigar_index];
            match entry {
                Cigar::Match(len) | Cigar::Equal(len) | Cigar::Diff(len) => {
                    let qstart = self.read_pos;
                    let qend = qstart + len as i64;
                    let rstart = self.genome_pos;
                    let rend = self.genome_pos + len as i64;
                    self.read_pos += len as i64;
                    self.genome_pos += len as i64;
                    #[allow(clippy::nonminimal_bool)]
                    if (self.r#match && matches!(entry, Cigar::Equal(_))) || !self.r#match {
                        self.cigar_index += 1;
                        return Some(([qstart, qend], [rstart, rend]));
                    }
                }
                Cigar::Ins(len) | Cigar::SoftClip(len) => {
                    self.read_pos += len as i64;
                }
                Cigar::Del(len) | Cigar::RefSkip(len) => {
                    self.genome_pos += len as i64;
                }
                Cigar::HardClip(_) => {} // no advance
                Cigar::Pad(_) => panic!("Padding (Cigar::Pad) is not supported."), //padding is only used for multiple sequence alignment
            }
            self.cigar_index += 1;
        }
        None
    }
}
#[derive(Ord, PartialOrd, Eq, PartialEq, Debug, Copy, Clone)]
pub struct RangePos {
    pub start: i64,
    pub end: i64,
}
impl RangePos {
    pub fn getrange(&self) -> Range<i64> {
        self.start..self.end
    }
    pub fn start(&self) -> i64 {
        self.start
    }
    pub fn end(&self) -> i64 {
        self.end
    }
    #[allow(unused)]
    fn new(start: i64, end: i64) -> Self {
        let (start, end) = match start.cmp(&end) {
            std::cmp::Ordering::Greater => (end, start),
            _ => (start, end),
        };
        RangePos { start, end }
    }
}
/// Matching sequence, return a genomic range and associated sequence
/// ```
/// use extended_htslib::bam::ext::MatchSequence;
/// let test = MatchSequence::default();
/// for (range, sequence) in test.gethash() {
///     println!("SEQ: {} for {}-{}",sequence,range.start,range.end);
/// }
/// ```
pub struct MatchSequence {
    pub hash: BTreeMap<RangePos, String>,
}
impl MatchSequence {
    pub fn new(range: RangePos, text: String) -> Self {
        let mut map = BTreeMap::new();
        map.insert(range, text);
        MatchSequence { hash: map }
    }
    /// return a hash of rangepos and genomic sequence
    pub fn gethash(&self) -> &BTreeMap<RangePos, String> {
        &self.hash
    }
    ///Check if a range of genomic position is completely aligned with the read. Return the sequence if yes else return None
    pub fn isfullymatched(&self, range: RangeInclusive<i64>) -> Option<String> {
        let mut vec = self.hash.iter();
        vec.find_map(|(a, b)| {
            if a.getrange().contains(range.start()) && a.getrange().contains(range.end()) {
                Some(b.clone())
            } else {
                None
            }
        })
    }
}
impl Default for MatchSequence {
    fn default() -> Self {
        let default = String::new();
        let range = RangePos { start: 1, end: 1 };
        Self::new(range, default)
    }
}
pub struct IterAlignedBlocks {
    pos: i64,
    cigar_index: usize,
    cigar: Vec<Cigar>,
    r#match: bool,
}
impl MatchIter for IterAlignedBlocks {
    fn ismatchonly(&self) -> bool {
        self.r#match
    }

    fn setmatchstate(&mut self, matchs: bool) {
        self.r#match = matchs;
    }
}
impl Iterator for IterAlignedBlocks {
    type Item = [i64; 2];
    fn next(&mut self) -> Option<Self::Item> {
        while self.cigar_index < self.cigar.len() {
            let entry = self.cigar[self.cigar_index];
            match entry {
                Cigar::Match(len) | Cigar::Equal(len) | Cigar::Diff(len) => {
                    let out_pos = self.pos;
                    //result.push([pos, pos + *len as i64]);
                    self.pos += len as i64;
                    #[allow(clippy::nonminimal_bool)]
                    if (self.r#match && matches!(entry, Cigar::Equal(_))) || !self.r#match {
                        self.cigar_index += 1;
                        return Some([out_pos, out_pos + len as i64]);
                    }
                }
                Cigar::Del(len) => self.pos += len as i64,
                Cigar::RefSkip(len) => self.pos += len as i64,
                _ => (),
            }
            self.cigar_index += 1;
        }
        None
    }
}

pub struct IterIntrons {
    pos: i64,
    cigar_index: usize,
    cigar: Vec<Cigar>,
}

impl Iterator for IterIntrons {
    type Item = [i64; 2];
    fn next(&mut self) -> Option<Self::Item> {
        while self.cigar_index < self.cigar.len() {
            let entry = self.cigar[self.cigar_index];
            match entry {
                Cigar::Match(len) | Cigar::Equal(len) | Cigar::Diff(len) | Cigar::Del(len) => {
                    self.pos += len as i64
                }
                Cigar::RefSkip(len) => {
                    let junc_start = self.pos;
                    self.pos += len as i64;
                    self.cigar_index += 1;
                    return Some([junc_start, self.pos]); //self.pos is  junc_start + len
                }
                _ => {}
            }
            self.cigar_index += 1;
        }
        None
    }
}

pub struct IterAlignedPairs {
    genome_pos: i64,
    read_pos: i64,
    cigar: Vec<Cigar>,
    remaining_match_bp: u32,
    cigar_index: usize,
    r#match: bool,
}
impl MatchIter for IterAlignedPairs {
    fn ismatchonly(&self) -> bool {
        self.r#match
    }

    fn setmatchstate(&mut self, matchs: bool) {
        self.r#match = matchs;
    }
}
impl Iterator for IterAlignedPairs {
    type Item = [i64; 2];
    fn next(&mut self) -> Option<Self::Item> {
        if self.remaining_match_bp > 0 {
            self.remaining_match_bp -= 1;
            self.genome_pos += 1;
            self.read_pos += 1;
            return Some([self.read_pos - 1, self.genome_pos - 1]);
        }

        while self.cigar_index < self.cigar.len() {
            let entry = self.cigar[self.cigar_index];
            match entry {
                Cigar::Match(len) | Cigar::Equal(len) | Cigar::Diff(len) => {
                    self.genome_pos += 1;
                    self.read_pos += 1;
                    self.remaining_match_bp = len - 1;
                    #[allow(clippy::nonminimal_bool)]
                    if (self.r#match && matches!(entry, Cigar::Equal(_))) || !self.r#match {
                        self.cigar_index += 1;
                        return Some([self.read_pos - 1, self.genome_pos - 1]);
                    }
                }
                Cigar::Ins(len) | Cigar::SoftClip(len) => {
                    self.read_pos += len as i64;
                }
                Cigar::Del(len) | Cigar::RefSkip(len) => {
                    self.genome_pos += len as i64;
                }
                Cigar::HardClip(_) => {} // no advance
                Cigar::Pad(_) => panic!("Padding (Cigar::Pad) is not supported."), //padding is only used for multiple sequence alignment
            }
            self.cigar_index += 1;
        }
        None
    }
}

pub struct IterAlignedPairsFull {
    genome_pos: i64,
    read_pos: i64,
    cigar: Vec<Cigar>,
    remaining_match_bp: u32,
    remaining_ins_bp: u32,
    remaining_del_bp: u32,
    cigar_index: usize,
}
pub(super) struct IterAlignedPairsFullCigar {
    genome_pos: i64,
    read_pos: i64,
    cigar: Vec<Cigar>,
    qual: Vec<u8>,
    remaining_match_bp: u32,
    remaining_ins_bp: u32,
    remaining_del_bp: u32,
    cigar_index: usize,
}
impl IterAlignedPairsFullCigar {
    pub fn new(start: IterAlignedPairsFull, record: &bam::Record) -> Self {
        Self {
            genome_pos: start.genome_pos,
            read_pos: start.read_pos,
            cigar: start.cigar,
            qual: record.qual().to_vec(),
            remaining_match_bp: start.remaining_match_bp,
            remaining_ins_bp: start.remaining_ins_bp,
            remaining_del_bp: start.remaining_del_bp,
            cigar_index: start.cigar_index,
        }
    }
}
/// Iterate over read pos, genome pos, cigar and quality of read
impl Iterator for IterAlignedPairsFullCigar {
    type Item = ([Option<i64>; 2], Cigar, u8);
    fn next(&mut self) -> Option<Self::Item> {
        if self.remaining_match_bp > 0 {
            self.remaining_match_bp -= 1;
            self.genome_pos += 1;
            self.read_pos += 1;
            return Some((
                [Some(self.read_pos - 1), Some(self.genome_pos - 1)],
                self.cigar[self.cigar_index.saturating_sub(1)],
                self.qual
                    .get(
                        usize::try_from(self.read_pos)
                            .unwrap_or_default()
                            .saturating_sub(1),
                    )
                    .copied()
                    .unwrap_or(u8::MAX),
            ));
        }
        if self.remaining_ins_bp > 0 {
            self.remaining_ins_bp -= 1;
            self.read_pos += 1;
            return Some((
                [Some(self.read_pos - 1), None],
                self.cigar[self.cigar_index.saturating_sub(1)],
                self.qual
                    .get(
                        usize::try_from(self.read_pos)
                            .unwrap_or_default()
                            .saturating_sub(1),
                    )
                    .copied()
                    .unwrap_or(u8::MAX),
            ));
        }
        if self.remaining_del_bp > 0 {
            self.remaining_del_bp -= 1;
            self.genome_pos += 1;
            return Some((
                [None, Some(self.genome_pos - 1)],
                self.cigar[self.cigar_index.saturating_sub(1)],
                self.qual
                    .get(usize::try_from(self.read_pos).unwrap_or_default())
                    .copied()
                    .unwrap_or(u8::MAX),
            ));
        }

        while self.cigar_index < self.cigar.len() {
            let entry = self.cigar[self.cigar_index];
            match entry {
                Cigar::Match(len) | Cigar::Equal(len) | Cigar::Diff(len) => {
                    self.genome_pos += 1;
                    self.read_pos += 1;
                    self.remaining_match_bp = len - 1;
                    self.cigar_index += 1;
                    return Some((
                        [Some(self.read_pos - 1), Some(self.genome_pos - 1)],
                        entry,
                        self.qual
                            .get(
                                usize::try_from(self.read_pos)
                                    .unwrap_or_default()
                                    .saturating_sub(1),
                            )
                            .copied()
                            .unwrap_or(u8::MAX),
                    ));
                }
                Cigar::Ins(len) | Cigar::SoftClip(len) => {
                    self.read_pos += 1;
                    self.remaining_ins_bp = len - 1;
                    self.cigar_index += 1;
                    return Some((
                        [Some(self.read_pos - 1), None],
                        entry,
                        self.qual
                            .get(
                                usize::try_from(self.read_pos)
                                    .unwrap_or_default()
                                    .saturating_sub(1),
                            )
                            .copied()
                            .unwrap_or(u8::MAX),
                    ));
                }
                Cigar::Del(len) | Cigar::RefSkip(len) => {
                    self.genome_pos += 1;
                    self.remaining_del_bp = len - 1;
                    self.cigar_index += 1;
                    return Some((
                        [None, Some(self.genome_pos - 1)],
                        entry,
                        self.qual
                            .get(usize::try_from(self.read_pos).unwrap_or_default())
                            .copied()
                            .unwrap_or(u8::MAX),
                    ));
                }
                Cigar::HardClip(_) => {
                    // no advance
                }
                Cigar::Pad(_) => panic!("Padding (Cigar::Pad) is not supported."), //padding is only used for multiple sequence alignment
            }
            self.cigar_index += 1;
        }
        None
    }
}

impl Iterator for IterAlignedPairsFull {
    type Item = [Option<i64>; 2];
    fn next(&mut self) -> Option<Self::Item> {
        if self.remaining_match_bp > 0 {
            self.remaining_match_bp -= 1;
            self.genome_pos += 1;
            self.read_pos += 1;
            return Some([Some(self.read_pos - 1), Some(self.genome_pos - 1)]);
        }
        if self.remaining_ins_bp > 0 {
            self.remaining_ins_bp -= 1;
            self.read_pos += 1;
            return Some([Some(self.read_pos - 1), None]);
        }
        if self.remaining_del_bp > 0 {
            self.remaining_del_bp -= 1;
            self.genome_pos += 1;
            return Some([None, Some(self.genome_pos - 1)]);
        }

        while self.cigar_index < self.cigar.len() {
            let entry = self.cigar[self.cigar_index];
            match entry {
                Cigar::Match(len) | Cigar::Equal(len) | Cigar::Diff(len) => {
                    self.genome_pos += 1;
                    self.read_pos += 1;
                    self.remaining_match_bp = len - 1;
                    self.cigar_index += 1;
                    return Some([Some(self.read_pos - 1), Some(self.genome_pos - 1)]);
                }
                Cigar::Ins(len) | Cigar::SoftClip(len) => {
                    self.read_pos += 1;
                    self.remaining_ins_bp = len - 1;
                    self.cigar_index += 1;
                    return Some([Some(self.read_pos - 1), None]);
                }
                Cigar::Del(len) | Cigar::RefSkip(len) => {
                    self.genome_pos += 1;
                    self.remaining_del_bp = len - 1;
                    self.cigar_index += 1;
                    return Some([None, Some(self.genome_pos - 1)]);
                }
                Cigar::HardClip(_) => {
                    // no advance
                }
                Cigar::Pad(_) => panic!("Padding (Cigar::Pad) is not supported."), //padding is only used for multiple sequence alignment
            }
            self.cigar_index += 1;
        }
        None
    }
}

/// Extra functionality for BAM records
///
/// Inspired by pysam
pub trait BamRecordExtensions {
    /// iterator over start and end positions with the sequence of matched
    /// blocks.
    /// # Errors
    /// Return None if CIGAR does not contain any = or sequence is not present.
    fn matched_sequence(&self) -> Option<MatchSequence>;
    /// iterator over start and end positions of aligned gapless blocks
    ///
    /// The start and end positions are in genomic coordinates.
    /// There is not necessarily a gap between blocks on the genome,
    /// this happens on insertions.
    ///
    /// pysam: blocks
    /// See also: [aligned_block_pairs](#tymethod.aligned_block_pairs) if you need
    /// the read coordinates as well.
    fn aligned_blocks(&self) -> IterAlignedBlocks;
    /// iterator over start and end positions of aligned matched blocks.
    ///
    /// The start and end positions are in genomic coordinates.
    /// There is not necessarily a gap between blocks on the genome,
    /// this happens on insertions.
    /// # Errors
    /// Return None if CIGAR does not contain any = or sequence is not present.
    fn aligned_blocks_match(&self) -> Option<IterAlignedBlocks>;
    ///Iter over <([read_start, read_stop], [genome_start, genome_stop]) blocks
    ///of continously aligned reads.
    ///
    ///In contrast to [aligned_blocks](#tymethod.aligned_blocks), this returns
    ///read and genome coordinates.
    ///
    ///There is not necessarily a gap between blocks in either coordinate space
    ///(this happens in in-dels).
    fn aligned_block_pairs(&self) -> IterAlignedBlockPairs;
    ///Iter over <([read_start, read_stop], [genome_start, genome_stop]) blocks
    ///of continously matched reads.
    ///
    ///In contrast to [aligned_blocks](#tymethod.aligned_blocks), this returns
    ///read and genome coordinates.
    ///In contrast to aligned_pairs, this returns only match sequence.
    ///
    ///There is not necessarily a gap between blocks in either coordinate space
    ///(this happens in in-dels).
    /// # Errors
    /// Return None if CIGAR does not contain any = or sequence is not present.
    fn aligned_block_pairs_match(&self) -> Option<IterAlignedBlockPairs>;
    ///Iter over <(([read_start..read_stop], [genome_start..genome_stop], Cigar)> blocks
    ///of cigar blocks (it is a range).
    ///
    ///In contrast to [aligned_blocks](#tymethod.aligned_blocks), this returns
    ///read and genome coordinates and by blocks of cigar.
    ///In contrast to aligned_pairs, this returns the cigar format.
    ///
    ///There is not necessarily a gap between blocks in either coordinate space
    ///(this happens in in-dels).
    fn aligned_block_pairs_cigar(&self) -> IterAlignedBlockCigarPairs;
    ///Iter over <(Option<([read_start..read_stop], [genome_start..genome_stop]),Cigar)> blocks
    ///of cigar blocks that perfectly match the reference (it is a range).
    ///
    ///In contrast to [aligned_blocks_match](#tymethod.aligned_blocks_match), this returns
    ///read and genome coordinates.
    ///In contrast to aligned_pairs_match, this returns None for every element that has no matching element and the cigar.
    ///
    ///There is not necessarily a gap between blocks in either coordinate space
    ///(this happens in in-dels).
    ///
    /// # Errors
    /// Return None if CIGAR does not contain any = or sequence is not present.
    fn aligned_block_pairs_cigar_match(&self) -> Option<IterAlignedBlockCigarMatchPairs>;
    /// This scans the CIGAR for reference skips
    /// and reports their positions.
    /// It does not inspect the reported regions
    /// for actual splice sites.
    /// pysam: get_introns
    fn introns(&self) -> IterIntrons;
    /// iter aligned read and reference positions on a basepair level
    ///
    /// No entry for mismatches, insertions, deletions or skipped pairs
    ///
    /// pysam: get_aligned_pairs(matches_only = True) but only matched bases
    ///
    /// See also [aligned_block_pairs](#tymethod.aligned_block_pairs)
    /// if you just need start&end coordinates of each block.
    /// That way you can allocate less memory for the same
    /// informational content.
    /// # Errors
    /// Return None if CIGAR does not contain any =/X.
    fn aligned_pairs_match(&self) -> Option<IterAlignedPairs>;
    /// iter aligned read and reference positions on a basepair level
    ///
    /// No entry for insertions, deletions or skipped pairs
    ///
    /// pysam: get_aligned_pairs(matches_only = True)
    ///
    /// See also [aligned_block_pairs](#tymethod.aligned_block_pairs)
    /// if you just need start&end coordinates of each block.
    /// That way you can allocate less memory for the same
    /// informational content.
    fn aligned_pairs(&self) -> IterAlignedPairs;

    /// iter list of read and reference positions on a basepair level.
    ///
    /// Unlike `aligned_pairs` this returns None in
    /// either the read positions or the reference position
    /// for insertions, deletions or skipped pairs
    ///
    /// pysam: aligned_pairs(matches_only = False)
    fn aligned_pairs_full(&self) -> IterAlignedPairsFull;

    /// the number of nucleotides covered by each Cigar::* variant.
    ///
    /// Result is a Hashmap Cigar::*(0) => covered nucleotides
    ///
    /// pysam: first result from get_cigar_stats
    fn cigar_stats_nucleotides(&self) -> HashMap<Cigar, i32>;

    /// the number of occurrences of each each Cigar::* variant
    ///
    /// Result is a Hashmap Cigar::*(0) => number of times this Cigar::
    /// appeared
    ///
    /// pysam: second result from get_cigar_stats
    fn cigar_stats_blocks(&self) -> HashMap<Cigar, i32>;

    /// iter over  reference positions that this read aligns to
    ///
    /// only returns positions that are aligned, excluding any soft-clipped
    /// or unaligned positions within the read
    ///
    /// pysam: get_reference_positions(full_length=False)
    fn reference_positions(&self) -> Box<dyn Iterator<Item = i64>>;
    /// iter over reference positions that this read aligns to
    ///
    /// only returns positions that are matched, excluding any soft-clipped
    /// or mismatched positions, unaligned positions within the read. Return None if cigar has no =
    ///
    /// pysam: get_reference_positions(full_length=False)
    fn reference_positions_match(&self) -> Option<Box<dyn Iterator<Item = i64>>>;
    ///
    /// iter over reference positions that this read aligns to
    ///
    /// include soft-clipped or skipped positions as None
    ///
    /// pysam: get_reference_positions(full_length=True)
    fn reference_positions_full(&self) -> Box<dyn Iterator<Item = Option<i64>>>;

    /// left most aligned reference position of the read on the reference genome.
    fn reference_start(&self) -> i64;

    /// right most aligned reference position of the read on the reference genome.
    fn reference_end(&self) -> i64;

    /// infer the query length from the cigar string, optionally include hard clipped bases
    ///
    /// Contrast with record::seq_len which returns the length of the sequence stored
    /// in the BAM file, and as such is 0 if the BAM file omits sequences
    ///
    /// pysam: infer_query_length / infer_read_length
    fn seq_len_from_cigar(&self, include_hard_clip: bool) -> usize;
    /// Get CS tag and perfect match alignment from BAM, try to use MD if existing else None if extension does not exist
    #[deprecated(since = "0.3.0", note = "use getorgeneratecsblock")]
    fn getcsaligned(&self) -> Option<CgAlignedBlockPairs>;
    /// 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.
    /// # Errors
    /// No CS or MD tag.
    /// # Examples
    /// ```
    /// use extended_htslib::bam::{self,Read,ext::BamRecordExtensions};
    /// use extended_htslib::bam::record::{Aux,CsString};
    /// use std::str::FromStr;
    /// let mut t = bam::Reader::from_path("test/locusmd.bam").unwrap();
    /// let info = t
    ///     .rc_records()
    ///     .filter_map(Result::ok)
    ///     .filter(|p| p.is_primary())
    ///     .next()
    ///     .unwrap()
    ///     .getorgeneratecsblock(false)
    ///     .unwrap();
    /// 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();
    /// assert_eq!(info.cs,raw);
    /// ```
    ///
    /// # Panics
    /// ```should_panic
    /// use extended_htslib::bam::{self,ext::BamRecordExtensions,record::Aux};
    /// let mut test = bam::Record::new();
    /// let cigar = "20M1X3M1D2M1I30S";
    /// let seqread = "ctatgtcaatcaatcgcttggacaactcctgcatcacatcgagctcttgccgaaaat";
    /// let cigarresult = bam::record::CigarString::try_from(cigar).unwrap();
    /// let qual = vec![255 as u8; seqread.len()];
    /// test.set_tid(1);
    /// test.set(
    ///     "test".as_bytes(),
    ///     Some(&cigarresult),
    ///     seqread.as_bytes(),
    ///     &qual,
    /// );
    /// assert!(test.getorgeneratecsblock(false).is_err_and(|f| f.to_string().as_str() == "error parsing CS record: Absent MD tag."));
    /// test.update_aux(b"MD", Aux::String("20T3^C2")).unwrap();
    /// assert!(test.getorgeneratecsblock(false).is_ok());
    /// ```
    fn getorgeneratecsblock(&self, long_cs: bool) -> crate::bam::Result<CgAlignedBlockPairs>;
    /// Edit cigar to add =/X if does not contain, return None if cannot perform or =/X already present.
    /// Can give a CgAlignedBlockPairs or set None to extract it from the CS tag.
    /// # Examples
    /// ```
    /// use extended_htslib::bam::{self, Read, ext::BamRecordExtensions, record::Aux};
    /// let mut t = bam::Reader::from_path("test/setcigar.sam").unwrap();
    /// let mut info = t
    ///     .records()
    ///     .filter_map(Result::ok)
    ///     .filter(|p| p.is_primary())
    ///     .next()
    ///     .unwrap();
    /// info.setcigarfromcs(None).unwrap();
    /// assert_eq!(info.cigar().to_string(), "31=1X29=1I1X45=1X39=1D143=1I203=1I1404=");
    /// ```
    fn setcigarfromcs(&mut self, record: Option<&CgAlignedBlockPairs>) -> Option<()>;
    #[deprecated(since = "0.4.0", note = "Use setcigarfromcs")]
    fn setseqfromcs(&mut self, record: &CgAlignedBlockPairs) -> Option<()>;
    /// Edit or add cs tag to the record. Return Error is fails.
    /// # Examples
    /// ```
    /// use extended_htslib::bam::{self, Read, ext::BamRecordExtensions, record::Aux};
    /// let mut t = bam::Reader::from_path("test/locusmd.bam").unwrap();
    /// let mut info = t
    ///     .records()
    ///     .filter_map(Result::ok)
    ///     .filter(|p| p.is_primary())
    ///     .next()
    ///     .unwrap();
    /// assert!(info.aux(b"cs").is_err());
    /// if let Ok(a) = info.getorgeneratecsblock(false) {
    ///     info.updateorsetcstag(&a.getcs());
    /// }
    /// let string = match info.aux(b"cs").unwrap() {
    ///    Aux::String(a) => a,
    ///    _ => panic!("Invalid tag"),
    /// };
    /// 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");
    /// ```
    fn updateorsetcstag(&mut self, string: &CsString) -> bam::Result<()>;
}
impl BamRecordExtensions for bam::Record {
    fn matched_sequence(&self) -> Option<MatchSequence> {
        let aligned = self.aligned_block_pairs_match()?;
        let sequence = self.seq();
        if sequence.is_empty() {
            return None;
        }
        let mut hash = BTreeMap::new();
        for ([rstart, rend], [gstart, gend]) in aligned {
            let (rstart, rend) = (rstart.try_into().unwrap(), rend.try_into().unwrap());
            let sequence = sequence.rangeextract(rstart..rend).unwrap();
            hash.insert(
                RangePos {
                    start: gstart,
                    end: gend,
                },
                sequence.to_string(),
            );
        }
        Some(MatchSequence { hash })
    }
    fn aligned_blocks(&self) -> IterAlignedBlocks {
        IterAlignedBlocks {
            pos: self.pos(),
            cigar: self.cigar().take().0,
            cigar_index: 0,
            r#match: false,
        }
    }
    fn aligned_blocks_match(&self) -> Option<IterAlignedBlocks> {
        if !self.cigar().containsequal() {
            return None;
        };
        Some(IterAlignedBlocks {
            pos: self.pos(),
            cigar: self.cigar().take().0,
            cigar_index: 0,
            r#match: true,
        })
    }
    fn getcsaligned(&self) -> Option<CgAlignedBlockPairs> {
        self.getorgeneratecsblock(true).ok()
    }
    fn setseqfromcs(&mut self, record: &CgAlignedBlockPairs) -> Option<()> {
        let initialcigar = self.cigar();
        let mycigar = initialcigar.iter();
        let first: Vec<&Cigar> = mycigar
            .take_while(|p| matches!(p, &Cigar::SoftClip(_)) || matches!(p, &Cigar::HardClip(_)))
            .collect();
        let mycigar = initialcigar.iter().skip(first.len());
        let mut first = first.into_iter().map(|p| p.clone()).collect();
        let last: Vec<&Cigar> = mycigar
            .skip_while(|p| !matches!(p, &Cigar::SoftClip(_)) && !matches!(p, &Cigar::HardClip(_)))
            .take_while(|_| true)
            .collect();
        let mut last = last.into_iter().map(|p| p.clone()).collect();
        let mut length: Option<usize> = None;
        let mut vec: Vec<Cigar> = Vec::new();
        vec.append(&mut first);
        for elem in record.csdata.iter() {
            if elem.state.isubstitution() {
                if let Some(l) = length {
                    length = Some(l.saturating_add(1));
                } else {
                    length = Some(1);
                }
                continue;
            }
            let lengthraw = elem.state.getlength().try_into().ok()?;
            if let Some(a) = length {
                vec.push(Cigar::Diff(a.try_into().ok()?));
                length = None;
            }
            let val = match elem.state {
                Same(_) => Cigar::Equal(lengthraw),
                Insertion(_) => Cigar::Ins(lengthraw),
                Deletion(_) => Cigar::Del(lengthraw),
                Intron(_) => Cigar::RefSkip(lengthraw),
                Substitution(_) if let Some(a) = length => Cigar::Diff(a.try_into().ok()?),
                Substitution(_) => unreachable!("Length must be set"),
            };
            vec.push(val);
        }
        if let Some(a) = length {
            vec.push(Cigar::Diff(a.try_into().ok()?));
        }
        vec.append(&mut last);
        self.set_cigar(Some(&CigarString::from(vec)));
        Some(())
    }
    fn setcigarfromcs(&mut self, record: Option<&CgAlignedBlockPairs>) -> Option<()> {
        if self
            .cigar()
            .iter()
            .any(|p| matches!(p, Cigar::Equal(_)) || matches!(p, Cigar::Diff(_)))
        {
            return None; //Already X/= in cigar
        }
        let record = match record {
            Some(a) => a,
            None => &self.getorgeneratecsblock(true).ok()?,
        };
        let initialcigar = self.cigar();
        let mycigar = initialcigar.iter();
        let first: Vec<&Cigar> = mycigar
            .take_while(|p| matches!(p, &Cigar::SoftClip(_)) || matches!(p, &Cigar::HardClip(_)))
            .collect();
        let mycigar = initialcigar.iter().skip(first.len());
        let mut first = first.into_iter().map(|p| p.clone()).collect();
        let last: Vec<&Cigar> = mycigar
            .skip_while(|p| !matches!(p, &Cigar::SoftClip(_)) && !matches!(p, &Cigar::HardClip(_)))
            .take_while(|_| true)
            .collect();
        let mut last = last.into_iter().map(|p| p.clone()).collect();
        let mut length: Option<usize> = None;
        let mut vec: Vec<Cigar> = Vec::new();
        vec.append(&mut first);
        for elem in record.csdata.iter() {
            if elem.state.isubstitution() {
                if let Some(l) = length {
                    length = Some(l.saturating_add(1));
                } else {
                    length = Some(1);
                }
                continue;
            }
            let lengthraw = elem.state.getlength().try_into().ok()?;
            if let Some(a) = length {
                vec.push(Cigar::Diff(a.try_into().ok()?));
                length = None;
            }
            let val = match elem.state {
                Same(_) => Cigar::Equal(lengthraw),
                Insertion(_) => Cigar::Ins(lengthraw),
                Deletion(_) => Cigar::Del(lengthraw),
                Intron(_) => Cigar::RefSkip(lengthraw),
                Substitution(_) if let Some(a) = length => Cigar::Diff(a.try_into().ok()?),
                Substitution(_) => unreachable!("Length must be set"),
            };
            vec.push(val);
        }
        if let Some(a) = length {
            vec.push(Cigar::Diff(a.try_into().ok()?));
        }
        vec.append(&mut last);
        self.set_cigar(Some(&CigarString::from(vec)));
        Some(())
    }
    fn updateorsetcstag(&mut self, string: &CsString) -> bam::Result<()> {
        self.update_aux(b"cs", Aux::String(&string.to_string()))
    }
    fn getorgeneratecsblock(&self, long_cs: bool) -> crate::bam::Result<CgAlignedBlockPairs> {
        let csext = self.aux(b"cs");
        let mdext = self.aux(b"MD");
        match (
            csext
                .and_then(|ext| {
                    if let bam::record::Aux::String(d) = ext {
                        Ok(d)
                    } else {
                        Err(bam::Error::BamParseCS {
                            rec: "Invalid CS tag found".to_string(),
                        })
                    }
                })
                .map_err(|_| bam::Error::BamParseCS {
                    rec: "Absent CS tag.".to_string(),
                }),
            mdext
                .and_then(|ext| {
                    if let bam::record::Aux::String(d) = ext {
                        Ok(d)
                    } else {
                        Err(bam::Error::BamParseMD {
                            rec: "Invalid MD tag found".to_string(),
                        })
                    }
                })
                .map_err(|_| bam::Error::BamParseCS {
                    rec: "Absent MD tag.".to_string(),
                }),
        ) {
            (Ok(data), _) => CgAlignedBlockPairs::createfromcs(
                // We have a valid CS tag
                CsString::from_str(data)?,
                String::from_utf8(self.seq().as_bytes())
                    .map(|a| a.to_string())
                    .map_err(|_| crate::bam::Error::NoSequencesInReference)
                    .ok(),
                self.contig().as_bytes().to_vec(),
                self.reference_start(),
            ),
            (Err(_), Ok(ext)) => {
                //We have a valid MD tag
                let line = String::from_utf8_lossy(self.qname());
                let cigar = &self.cigar().0;
                let seq = String::from_utf8(self.seq().as_bytes())
                    .map_err(|_| crate::bam::Error::NoSequencesInReference)?;
                let a = CgAlignedBlockPairs::createfrommdtag(
                    ext,
                    &seq,
                    cigar,
                    &line,
                    long_cs,
                    self.contig().as_bytes().to_vec(),
                    self.reference_start(),
                );
                a
            }
            (_, Err(b)) => return Err(b),
        }
    }
    fn introns(&self) -> IterIntrons {
        IterIntrons {
            pos: self.pos(),
            cigar: self.cigar().take().0,
            cigar_index: 0,
        }
    }

    fn aligned_block_pairs(&self) -> IterAlignedBlockPairs {
        IterAlignedBlockPairs {
            genome_pos: self.pos(),
            read_pos: 0,
            cigar: self.cigar().take().0,
            cigar_index: 0,
            r#match: false,
        }
    }
    fn aligned_block_pairs_cigar_match(&self) -> Option<IterAlignedBlockCigarMatchPairs> {
        let cigar = self.cigar().take().0;
        if cigar.iter().any(|f| matches!(f, Cigar::Match(_))) {
            return None;
        }
        Some(IterAlignedBlockCigarMatchPairs {
            genome_pos: self.pos(),
            read_pos: 0,
            cigar: cigar,
            cigar_index: 0,
        })
    }
    fn aligned_block_pairs_cigar(&self) -> IterAlignedBlockCigarPairs {
        IterAlignedBlockCigarPairs {
            genome_pos: self.pos(),
            read_pos: 0,
            cigar: self.cigar().take().0,
            cigar_index: 0,
        }
    }
    fn aligned_block_pairs_match(&self) -> Option<IterAlignedBlockPairs> {
        if !self.cigar().containsequal() {
            return None;
        };
        Some(IterAlignedBlockPairs {
            genome_pos: self.pos(),
            read_pos: 0,
            cigar: self.cigar().take().0,
            cigar_index: 0,
            r#match: true,
        })
    }
    fn aligned_pairs_match(&self) -> Option<IterAlignedPairs> {
        if !self.cigar().containsequal() {
            return None;
        };
        Some(IterAlignedPairs {
            genome_pos: self.pos(),
            read_pos: 0,
            cigar: self.cigar().take().0,
            remaining_match_bp: 0,
            cigar_index: 0,
            r#match: true,
        })
    }
    fn aligned_pairs(&self) -> IterAlignedPairs {
        IterAlignedPairs {
            genome_pos: self.pos(),
            read_pos: 0,
            cigar: self.cigar().take().0,
            remaining_match_bp: 0,
            cigar_index: 0,
            r#match: false,
        }
    }

    fn aligned_pairs_full(&self) -> IterAlignedPairsFull {
        IterAlignedPairsFull {
            genome_pos: self.pos(),
            read_pos: 0,
            cigar: self.cigar().take().0,
            remaining_match_bp: 0,
            remaining_ins_bp: 0,
            remaining_del_bp: 0,
            cigar_index: 0,
        }
    }

    fn cigar_stats_nucleotides(&self) -> HashMap<Cigar, i32> {
        let mut result = HashMap::new();
        result.insert(Cigar::Match(0), 0); // M
        result.insert(Cigar::Ins(0), 0); // I
        result.insert(Cigar::Del(0), 0); // D
        result.insert(Cigar::RefSkip(0), 0); // N
        result.insert(Cigar::SoftClip(0), 0); // S
        result.insert(Cigar::HardClip(0), 0); // H
        result.insert(Cigar::Pad(0), 0); // P
        result.insert(Cigar::Equal(0), 0); // =
        result.insert(Cigar::Diff(0), 0); // X
        for entry in self.cigar().iter() {
            match entry {
                Cigar::Match(len) => *result.get_mut(&Cigar::Match(0)).unwrap() += *len as i32, // M
                Cigar::Ins(len) => *result.get_mut(&Cigar::Ins(0)).unwrap() += *len as i32,     // I
                Cigar::Del(len) => *result.get_mut(&Cigar::Del(0)).unwrap() += *len as i32,     // D
                Cigar::RefSkip(len) => *result.get_mut(&Cigar::RefSkip(0)).unwrap() += *len as i32, // N
                Cigar::SoftClip(len) => {
                    *result.get_mut(&Cigar::SoftClip(0)).unwrap() += *len as i32
                } // S
                Cigar::HardClip(len) => {
                    *result.get_mut(&Cigar::HardClip(0)).unwrap() += *len as i32
                } // H
                Cigar::Pad(len) => *result.get_mut(&Cigar::Pad(0)).unwrap() += *len as i32, // P
                Cigar::Equal(len) => *result.get_mut(&Cigar::Equal(0)).unwrap() += *len as i32, // =
                Cigar::Diff(len) => *result.get_mut(&Cigar::Diff(0)).unwrap() += *len as i32, // X
            }
        }
        result
    }

    fn cigar_stats_blocks(&self) -> HashMap<Cigar, i32> {
        let mut result = HashMap::new();
        result.insert(Cigar::Match(0), 0); // M
        result.insert(Cigar::Ins(0), 0); // I
        result.insert(Cigar::Del(0), 0); // D
        result.insert(Cigar::RefSkip(0), 0); // N
        result.insert(Cigar::SoftClip(0), 0); // S
        result.insert(Cigar::HardClip(0), 0); // H
        result.insert(Cigar::Pad(0), 0); // P
        result.insert(Cigar::Equal(0), 0); // =
        result.insert(Cigar::Diff(0), 0); // X
        for entry in self.cigar().iter() {
            match entry {
                Cigar::Match(_) => *result.get_mut(&Cigar::Match(0)).unwrap() += 1, // M
                Cigar::Ins(_) => *result.get_mut(&Cigar::Ins(0)).unwrap() += 1,     // I
                Cigar::Del(_) => *result.get_mut(&Cigar::Del(0)).unwrap() += 1,     // D
                Cigar::RefSkip(_) => *result.get_mut(&Cigar::RefSkip(0)).unwrap() += 1, // N
                Cigar::SoftClip(_) => *result.get_mut(&Cigar::SoftClip(0)).unwrap() += 1, // S
                Cigar::HardClip(_) => *result.get_mut(&Cigar::HardClip(0)).unwrap() += 1, // H
                Cigar::Pad(_) => *result.get_mut(&Cigar::Pad(0)).unwrap() += 1,     // P
                Cigar::Equal(_) => *result.get_mut(&Cigar::Equal(0)).unwrap() += 1, // =
                Cigar::Diff(_) => *result.get_mut(&Cigar::Diff(0)).unwrap() += 1,   // X
            }
        }
        result
    }

    fn reference_positions(&self) -> Box<dyn Iterator<Item = i64>> {
        Box::new(self.aligned_pairs().map(|x| x[1]))
    }
    fn reference_positions_match(&self) -> Option<Box<dyn Iterator<Item = i64>>> {
        match self.aligned_pairs_match() {
            Some(b) => Some(Box::new(b.map(|x| x[1]))),
            None => None,
        }
    }
    fn reference_positions_full(&self) -> Box<dyn Iterator<Item = Option<i64>>> {
        Box::new(
            self.aligned_pairs_full()
                .filter(|x| x.get(0).copied().flatten().is_some())
                .map(|x| x.get(1).copied().flatten()),
        )
    }

    fn reference_start(&self) -> i64 {
        self.pos()
    }

    /// Calculate the rightmost base position of an alignment on the reference genome.
    /// Returns the coordinate of the first base after the alignment (0-based).
    fn reference_end(&self) -> i64 {
        unsafe { htslib::bam_endpos(self.inner_ptr()) }
    }

    fn seq_len_from_cigar(&self, include_hard_clip: bool) -> usize {
        let mut result = 0;
        for entry in self.cigar().iter() {
            match entry {
                Cigar::Match(len)
                | Cigar::Ins(len)
                | Cigar::SoftClip(len)
                | Cigar::Equal(len)
                | Cigar::Diff(len) => {
                    result += len;
                }
                Cigar::HardClip(len) if include_hard_clip => {
                    result += len;
                }
                _ => {}
            }
        }
        result as usize
    }
}

#[cfg(test)]
mod tests {
    use crate::bam;
    use crate::bam::Read;
    use crate::bam::Record;
    use crate::bam::ext::BamRecordExtensions;
    use crate::bam::ext::CsValue;
    use crate::bam::ext::RangePos;
    use crate::bam::record::{Cigar, CigarString};
    use bio_types::genome::AbstractInterval;
    use std::collections::HashMap;
    fn mergemdandcstest(element: &Record) {
        assert_eq!(element.qname(), b"SRR11292120.509914");
        assert_eq!(element.contig(), "chr14");
        let mut cs = element.getorgeneratecsblock(true).unwrap();
        let val = cs.next().unwrap();
        assert_eq!(val.getreadpos(), Some(0));
        assert_eq!(val.getgenomepos(), Some(99813318));
        let val = cs.nth(2).unwrap();
        assert_eq!(val.getreadpos(), None);
        assert_eq!(val.getgenomepos(), Some(99813465));
        assert_eq!(val.state, CsValue::Deletion("c".to_string()));
        assert!(val.sequence.genomematch(None::<&str>));
        assert!(val.sequence.readmatch(Some("c")));
        let val = cs.nth(2).unwrap();
        assert_eq!(val.getreadpos(), Some(292));
        assert_eq!(val.getgenomepos(), Some(99813609));
        if let CsValue::Same(a) = val.state {
            assert_eq!(a.getsize(), 203)
        } else {
            assert!(false)
        };
    }
    /*
    #[test]
    fn changecigar() {
        let mut d = crate::bam::Reader::from_path("test/locusmd.bam").unwrap();
        let mut output = crate::bam::Writer::from_path(
            "test/locusmdcigar.bam",
            &bam::Header::from_template(d.header()),
            bam::Format::Bam,
        )
        .unwrap();
        let mut record = Record::new();
        let mut matches = 0;
        while let Some(_) = d.read(&mut record) {
            let cigar = record.cigar();
            let mut cigarvec = Vec::new();
            if !record.cigarhasequal() {
                continue;
            }
            for ci in cigar.into_iter() {
                match ci {
                    Cigar::Match(e) | Cigar::Equal(e) | Cigar::Diff(e) => matches += e,
                    e => {
                        if matches > 0 {
                            cigarvec.push(Cigar::Match(matches));
                            matches = 0;
                        }
                        cigarvec.push(e.clone())
                    }
                }
            }
            if matches > 0 {
                cigarvec.push(Cigar::Match(matches));
                matches = 0;
            }
            let cigarnew = CigarString(cigarvec);
            record.set_cigar(Some(&cigarnew));
            output.write(&record).unwrap();
        }
    }
    */
    #[test]
    fn testcs() {
        let mut read = crate::bam::Reader::from_path("test/locus.bam").unwrap();
        let mut element = read.records().filter_map(Result::ok).skip(1).take(1);
        let element = element.next().unwrap();
        mergemdandcstest(&element);
    }
    #[test]
    //#[ignore]
    fn testgeneratedcssame() {
        let mut csread = crate::bam::Reader::from_path("test/locus.bam").unwrap();
        let mut mdread = crate::bam::Reader::from_path("test/locusmd.bam").unwrap();
        let mdread = mdread
            .rc_records()
            .filter_map(Result::ok)
            .filter(|a| a.is_primary())
            .map(|a| a.getorgeneratecsblock(false).unwrap());
        let csread = csread
            .rc_records()
            .filter_map(Result::ok)
            .filter(|a| a.is_primary())
            .map(|a| a.getorgeneratecsblock(false).unwrap());
        for (mdread, csread) in mdread.zip(csread) {
            if mdread.islongcs() == csread.islongcs() {
                //Same form
                assert_eq!(mdread.cs, csread.cs)
            } else {
                panic!("Different format");
            }
        }
    }
    #[test]
    fn testgeneratedmdsame() {
        let mut csread = crate::bam::Reader::from_path("test/locus.bam").unwrap();
        let mut mdread = crate::bam::Reader::from_path("test/locusmdcigar.bam").unwrap();
        let mdread = mdread
            .rc_records()
            .filter_map(Result::ok)
            .filter(|a| a.is_primary())
            .map(|a| a.getorgeneratecsblock(false).unwrap());
        let csread = csread
            .rc_records()
            .filter_map(Result::ok)
            .filter(|a| a.is_primary())
            .map(|a| a.getorgeneratecsblock(false).unwrap());
        for (mdread, csread) in mdread.zip(csread) {
            if mdread.islongcs() == csread.islongcs() {
                //Same form
                assert_eq!(mdread.cs, csread.cs)
            } else {
                panic!("Different format");
            }
        }
    }
    #[test]
    fn testmd() {
        let mut read = crate::bam::Reader::from_path("test/locusmd.bam").unwrap();
        let mut element = read.rc_records().filter_map(Result::ok).skip(1).take(1);
        let element = element.next().unwrap();
        mergemdandcstest(&element);
    }
    /*
    #[test]
    fn testmd2() {
        let mut read = crate::bam::Reader::from_path("test/outlight.bam").unwrap();
        let mut rawelem = read.rc_records().filter_map(Result::ok).into_iter();
        let element = rawelem
            .find(|p| p.qname() == "m84072_250402_125013_s1/241502339/ccs".as_bytes())
            .unwrap();
        let v = element.getorgeneratecsblock(false).unwrap();
        assert_eq!(
            v.cs.to_string(),
            ":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",
            "Cigar is invalid"
        );
        let element = rawelem
            .find(|p| p.qname() == "m84070_250402_111906_s3/138216250/ccs".as_bytes())
            .unwrap();
        let v = element.getorgeneratecsblock(false).unwrap();
        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");
        for left in rawelem.take(1000) {
            let _ = left.getorgeneratecsblock(false).unwrap();
        }
    }  */
    #[test]
    fn testcigar() {
        let mut read = crate::bam::Reader::from_path("test/locus.bam").unwrap();
        let elem = read
            .rc_records()
            .filter_map(Result::ok)
            .take(1)
            .next()
            .unwrap();
        let mut cigar = elem.aligned_pairs_match().unwrap();
        let _ = cigar.next();
        let align = cigar.next();
        assert_eq!(align, Some([1, 99812480]));
        let align = cigar.nth(40);
        assert_eq!(align, Some([43, 99812521]));
    }
    #[test]
    fn testblock() {
        let mut read = crate::bam::Reader::from_path("test/locus.bam").unwrap();
        let elem = read.rc_records().filter_map(Result::ok).nth(3).unwrap();
        assert_eq!(elem.qname(), b"SRR11292123.1482913");
        assert_eq!(elem.contig(), "chr14");
        let mut element = elem.aligned_blocks_match().unwrap();
        assert_eq!(element.next(), Some([99814926, 99816399]));
        assert_eq!(element.next(), Some([99816400, 99817131]));
        assert_eq!(element.next(), Some([99817132, 99830222]));
        assert!(element.next().is_none());
    }
    #[test]
    fn testseq() {
        let mut read = crate::bam::Reader::from_path("test/locus.bam").unwrap();
        let elem = read.records().filter_map(Result::ok).nth(7).unwrap();
        let val = elem.matched_sequence().unwrap();
        assert!(val.isfullymatched(99820271..=99826916).is_some());
        assert!(val.isfullymatched(99820271..=99826917).is_none());
        let mut elem = val.gethash().iter();
        let test = elem.next();
        let rangepos = RangePos::new(99820271, 99826917);
        assert_eq!(
            test,
            Some((
                &rangepos,
                &String::from(
                    "AGAGGCAGGGATGACAGAGACAGACACAAAGCAGAGAGACGGAGGCAGAGGGAGACATGCAGAGTCGCGGAGACATCCGGGCTCAGGCCCCGACTCTCAGGGGCCACCCCCAGGGAGGACACGCAGTGCACCCCCACACCCACACCTCACACACACACTCACACCCACATACCCCCATCCACACACACCCAGAGACACACAGACACCCACAGCCACACACTCACACTCACGAACTTATCCAGTCACGTCCCACACACTCCCACCCAACCCATACACCACACACCTACACAACCCATACACCACACACACTCACAAACTATATACCACACACACACCAACCATACACCTATATACACTCACACACCCATATACCACACACTCACACACAACCCATACACCACACGCACACAACCCATACACCTATACACACTCACACCTACAAACTATATACTACACACTCACACACAACCCATACACCTATACACACACACCCATATACCACACACAACCCATACACCACACACACAAACCATATACCACACACTCACACAACCCATACACCTATACACACTCATACCCATATACCACATACAACCAATATACCACACACACACAACCCATACACCTATACACACACACCTATACACCACACACAGCCCATACACTACACAATCACACCACAAACTGTATACCACACACTCACACATAACCCATACACCTATACACACACACCCATATACCACACACACAACCTGTGCACCTACACACACACATACACCACACACACACAACTCCTACACCTACACACACCCACCACCCATACACACACAGCCTATACACCTACACACACTCATACACTCATATAGCACACACACAACCCATATACCACACACACAACCCACATACCTATACACACACGCCCATACACCACACACTCACACAACCCATGCACCACATACACCCACAAACTATATGCTACACGCTCACACACAACCCATACACCTATACACAATCCCACAACCCATACACACTTACACAACCTATACACCACACACACTCACAATCTGTATACCACACACACAACCCATACAGTTATACACACACACCCATATACCACACACACACAACCCATATACCACACACTCACACACAAACCATACATCTATACACATACCCATATGCCACACATACAACCCATACACCACACACTCACACACAACACATACACCACACACACAACCCATAGAACACAAACACAAGTCATAACCACACACACAGCCCATATACCTATACACATTCACACACACAACCCATACACTACACACACAACACATACACCTATACACACTCACACTCAATTCATACACCACACACACACAGCCCATACATCTATACACAAACTCACACACAATCCATATACCACAAACTCACACACAACGCATACACCTATACACACACACGCAACTCATACAGCACACACTCACACAACCCACAGACCATAAACACACACAAGCCATAACCACACACAAACCCATACACCTATACACACACTCATAAACAAGCCATACACCCCTACACAACCCATACACCACACACTCACAACCCATACACCTATATACACACACAACCATATACCACAAACTCACGCTCAACACATACACCTATACACACACACAACTCATACACCACACACTCATACACAACGCACAGACCACATACACAAGCCATAACCACACACACACAACCCGTACACATATATACACACTAATAAACAAGCCATACACCTACACATACAACCCATACACCACACATTCACACATAACCCATACACCTATACACACACACACACAACCCATATACCACAAACACACACAACCTATACACACATACAACCCATACACCACACACACAACACATACACACCACACACACACAGAATACTCATACACACACCCATACACCACCCCCACACAGAACCCATACACCACACACACACAACCTATACACCTATACACACACTCACACACACAACTCATATACCACAAACACACACAACACATACACCTATGCACACACACAACCCATACACCACACATTCACATACAACCCATACACCACACACACACAACACATACATGAAACATACATACAACCCACACACCACCCACTCATACACAACCTATACACCACACACACAACTCATACACCTATACACACACAACACATACACCTATCATACACTCACAACACATACACCTCCTATACACACACAACACACACACTTCCTATACACACAACCCACACGCCTATACACACATCCTCACTCACACTCACCCTCACATTCATATACTCACTAACACACTTCCACACTCACACCCTCACCCACACTTACACCCCCACCCACACTCAAACCCCGACGCTAAGTCACTGTCACATTTGTACCCATGCTCACACGCTCACACGCTCACACACTCACCCCCCACCAGCTCCAGGGCTCACTGGTGTGTGCCCACCAAACCCCCCTCGGGGGTCCCCTCGGTAAGCCGACAGTGCTCTGCTCATCGGTGGCCTGGGGAAACAGGGCCCACCCAAGGCCTGGCTCAGGAAAGGCTCCAAACACACATGGCCCAGGAGCAAATGGGCAGAGCTCAGCCTGCAGCTGGGAGCGGCCGAGCGGGTGCTGGGCCAGAGTCGGGGCCTGTCTGTGGGTGAGGGGCACGGCAGCACGGGCCCACCTGCACCTACAAGGCCTGGCCCCCGAGGTCACTGGGCCACCACCCAGCCCTCGCCCTGTTCCCCGTCTGTGCTGGCCGGGGCAGGACTCTGAGCCTCGGGGAAACCCACAGATACACACGGGACCCCGAACATCGGGCTGGGGAGGCTGGGGTGGGTAACAACATCCCAGAGGCAGGAGCAGGAGGTCCTGGGACCCTGCACACTGCGACCCCAGCCCTGGGGGCTGAAGCCCAGGACAGCCTCAGGTCTCCCAGGAGGGACTGGATAGTGGGGGATGGTCAGAGAACAGGACAGCCAGCAGGGTGCAGCCCGAGGACAGGGATGGATGCTGGGAGGTCAACAGGACAGGGGCAGGGGCAGGGGCTGTGGAGTGTGAGAAGGTCCTGGAGGGCCTGGAGAACCTGTGGGTCAGTGTCTGTGGGAAGGAGGCCAGGAGCAGCCCTGAGTGGCCAGGCTGGCAGGGGTGAGGAGGTGGGGGCAGTGAGGTGAGGGTGACCGAGACAGGCCTCTGGCCAGGGAGGGGACCTTGGCTGGGCTCTGACTGAACCCAGGGCTCCTGGAGAAGGGGCCCCAGGCGGGGATGAGGATGTGGGCATCTGACTCCATCAACAATGGGGCTTCCAACACGCACAGCCTGGGCCTCGGAGACCTGGGCCCTGACCCGCCTCCCCCTGGCACTGGGCCGGGTGCCGTGTGTGGTCCCCAGTCCCCGCAGCACCTCCCCCACACTGGTCACGTTCCAGGGCCCCTCTGAAGCACCTGCTGTGAGGGGATGTGAGGAGGGGACAGGGACTTGGGCCTGAGCTGCCGGGTCGGGGGGGAGTCGGGGACCCAGGCTCAGCGTGTGGCTGGGGACCAGACAGATGGGGATGGAGGAGGACACGCCCTGTACCCACTGCCTGCCAAGGGGCTGGACCCACGCCCAGTCTAGGCCATGTCCCCCGAGGCCTGTGAACCTTCACTCTGAGCCACTAAAACATTCAGGAGCTTTGAAAGCAGCCCCCGTCCTTGTCACTATGCGATGACTCTGAGCATCACGCTGTCCCTGCTGGATCCACCCTCCAGCCCCAGCGAGGGAGGCTGGGCCCCGGGCAGCAGGTGGTGAGGGCAGCGGGCACAGCCACCCTACAGCACACACAGGGTCTCAGGGACGCGTCCACCACAGCCCGTGCACAGGCTCCTCACGGCACTGAGTTCACCCGGGGCGCGGGCCGTTTGTCCTCAGGAGTCCCACTGTGCCCTCCGCCCCCAGCCCTGTCCTGCTGAGGCTGCAGCTGGGTCCCGGGGCACAGGGCGGCCCTGAGCACCTTGTCATGTTGGTCCCTGTCGGGTGGGCTGCTGGCTGTCTGTGGAGCTGGCAGAGCCGCGGTTCAGCCTTGGAGGCCGGTCCTGGGGCCCAGCAGCCGTGGGGAGCACTGCCCAGTCCCGTGCCCACAGGGAATCACCTGGGCTGAGGAAGGGCCCACACGCCGACGGGATCGGGGTCAGGCAGCGCACGCCTGGCACCGAGATCCCACGTCCCGAAGTGGGGACACGGCCCAGGGGCACTGTTCCGGGAGGGTCTCAAGATGGGGTCTCCTATTTCAATCTTCACTCCTTCTGCACCTGTTAGCTGGGAACCTTCTAGAAGGAGGGGTGTCCTCAATCATGGGGTGGTTGTGAGCTGAGCACAGATCATGCAGGAAGGTACATGGCTTCTCCTTCACCAGGAAAACAGTGCAGAGAGACAGAGACACAGAGACAGAGTAACAGAGAAAGACAGAGAGACAGAGACACAGAGACAGAGACAGAGTAACAGAGAAAGACAGAGAGACAGAGAGACACAGACAGAGACAGAGTAACAGAGAAAGGCAGAGAGACAGAGAGAGACAGAGACAGAGTAACAGAGAAAGACAGAGAGGCAGAGAGAGAGAGACAGAGACAGAGACAGAGTAACAGAGATAGACAGAGAGACACAGAGACAGAGACAGAGTAACAGAGATAGAGAGACAGAGAGAGACACAGAGACAGAGTAACAGACAGAGACAGAGACAGGCACAGAGATAAGAAAGATACACAGAAACAGAGAGAGACAGAGACAGAGATAGTCACTGTCACATTCATACCCACGCTCACCTGCTCACACACACACACCTCACACACACTCACACTCACACTCACCTCACACACACAGTCACACACACACTCACACACACTCACACACACACACTGAGCTTCCCTCAGGCCCTGTCACTTCCGATGGGGCCTACGGCCTGTCTAAGCCTCTGGGCCACCAGCCCCTGGCTCACCGGTGTGTGCCCACCACACCCCGCCTTGGGGGTCTCCTCTATGAGCTGGGCACATGCCCTCCGCTCTGTTCATGGCTGGCCTGGGGGAAACAGGGCCCACCCAAGGCCTGGCTCAGGGAAGGCCTCAAACACACATGGCCCAGGAGCAAAGGGGCAGAGCTCAGCCTGCAGCTGGGAGCGGGCAGGGGTAGTGGAGTGGGCGGAGGGCCTGGAGAACCTGCAGGGCTACGATGTCTCTGGGAAGGGGGCCCAGGAGCAGCTCAGCGTGGCTGGGCCGGCAGGGCCGAGGAGGTGGGGGCCGTGAGGGAGGGGTGACTCGGCTGTGTGGGGTGCCGGGGGACACGGGCTTTGCTCCGGCTGAGCCCAGGCAGTGGCGAATCCCTGAGCTGCCAGGAGGAGAGCAGGGCCGGGGTCAGGCAGAGGTGGGCCGCGGGGCCGAGGGCTGCGGCCGGTCGGGAGCAGTCGGTCGGTTGAGGGCACCATTACATGGAGGGCTGTGAGACGGGAGACCCCATTCCCTTCATTCCTTGTGCACGTGTTAGTGAGGAAGCTTCTAGAAGGAGGGCATTGCTCGTAGTGGGTGAGTGTGAGCACAGATCATGCAGGCTGGCGTGCTGCCGTGAAGTGCCTCTCTTTACTTTCCAGACCTCAGCATGGCAAGCCCGTCCTGCGCCCCAGGGTCTTTCTGGAGTACACGCCGCGCGGTCCTGGTGGGCACCATACCTGGCACCCACGCTTTGGCCGGGCCCGAACCTTGCGCCCTCCCAGCCCCCATGTGGCTCTCCCTTGGCCATACTGGCCTTTTGCCAGTCCTCCTACCTCACCCTAGGGTCTGCCTGGCCCTGCCCTCCCTTCCTAGCCCCCCAAGGAGGCTGGAGGGCACCCCTGCGTCCACCAGCAGCAGCTCCTCATGGGCGAGTCTCCTTGGGCCAGTGACACATAGTGTGCCCCGATGGTGCCACGGCAGCCTGGGCCCTCCGCCTTCCTGCTTGGCAGGCACCCCCGCTCCCTGCACCCTCACCGGGGCACCTGTGAGCCCTGAGGGCCAGTGGGGGTCTCACTGCTGCTCCCTCCCACAGCCTAGCCTCGGGCCTCAGGGCTCTGCATCCAAGCGGCCCAGGGCTCCCTGAGGTCTCAGCCCGAGTGGGCCTTTGAGCCTTCGCGTTCTCTGCAGGGTGGGACCTGCCCAAGGGCTGCTGAGGGCTTCCCAGGGGTCCTGTGGGTCCCACCTAGGGGCAAGCTGGTGAGGAAAGTGGGTCCTGCCATGGCGGCCGGGTGGGCTGAGTTTTCGGCATCTCTGGGCCCAACAGCAGGTCCCTGGAGCGGCGCCCACCCCTCCCCCAGGCAGGTGTGAGGGCTCTGATCTGTTTCTCCTTGAGTGACTCATTCTGGGCAGACTTGGCCCTCAGGGCACATGCAAATGGTTGTTTGTTCCACACCGAAAACATGTTTCTTGCCCTCTGAGGCTGTTTCCAGAAATAGCTTGCACGATTCTCCACCTGCAGCTGCAGCCGCCACCCACCCAGTGTGGCCAGGCTGGCCCAGGCCTCCAGATTCGGGGACACCCCCCGCCCCCTCCCCCAGCGTGGCCAGGCTGGCTCAGGCCTCCAGATTCGGGGACA"
                )
            ))
        );
        let test = elem.next();
        let rangepos = RangePos::new(99826917, 99827017);
        assert_eq!(
            test,
            Some((
                &rangepos,
                &String::from(
                    "CCCCCCCCCCCCAACAGCGTGGCCAGGCTGGCTCAGGCCTCCAGATTCGGGGACACCCCCCCACCACAGCGTGGCCAGGCTGGCTCAGGCCTCCAGATTC"
                )
            ))
        );
        let test = elem.next();
        let rangepos = RangePos::new(99827017, 99829102);
        assert_eq!(
            test,
            Some((
                &rangepos,
                &String::from(
                    "GGGGACACCCGCCCCCTCCCCCAGGACAGGCCCACTTGGGTTACTGACACTGGGACCACCCTGCAAACGTCAACTTTATTGAATTCAGTGGTTCTGAACTTGTTGCCATCTTTGGGACCAGGACCCAGGGGCAGCCCCCAGGTTGGCAGGAAGGGCAGGGGAGCCAACGCTGGCAGGGCCCCCAGCCAACCCCCACCCCAGAAGCCCCAAGGAGGCTGAGCGGAGGTGGCCCTGGTGGCCTGGGCACAGGCAGCCCGATTGGTACAGGGCCTGTCTGGTGCAGGCCCGCACCTCCCCCACCCTCATGGCCTGGTGGTCCCCACTGTACAGAGAGAACACTGAGGCTCAGCAGGGCCAGGGACATGGCCTGAGGTTACATGGTGATGGGGGCTGGGTCTCCGGGCCTGGGGGCCGTGGTGGGTGCAGCACCCGGACTGCGTGGGCTGTGGCCTCCCTGCTCCCAGCTCTGTCACACCCGTCTCCATCTGAGCCTCCAGCTCCATCTTTCCCGCTGTCCCTGTCTCTGGCCACCCTTCTGTCTCCCTGTCTCTCTGCCTCTCTGAAGGTATCTCCCTGCCCGAATCTCTGTCTCTGTCCCATTGTCGGTGTCTCTGACTCATCTCTGTCAAGCCCGTCTGCTGGGCTTTGTCCCGCCATCTTGCCTGTCTTGGCCTCTCTCTCTTTCTGTGTGTCTCCGTCGGTGCCTCCTTTCTCCATCCATCTCTCCCCCGTGTCTGTCTCTATCCCTCCGTCTCTCTTCCCGTCTATCCCTCCCTCTGTGCCTGTCCCTTTGCTGTGTCCCTTTCTTTGCCTCTGTCTCTCTGTCTGTCTCTTCGTGTCCCTGTGTGTGTCTCTCTCTTCTCTCTGCTTCTCTTTCTGTATCTCTGTCTATATCTCAGCCTCTTTGTGTCCCTGTGTGTGTGTCTCTCTCTTCTCTGTCTTTCCATGTCTCTGTCTATATCTCTGTCTCTCTGCCTCTGTATCTCTGTCTGTCTGTTCGTGTCCCTGTGTATGTCTCTCTCTGTCTCTTTCTGTATCTCTGTCTATATCTGTCTCTCTCATCTGTCTCTTCCTGTGTGTGTCTCTCTGTCTCTCTGCCTCTGTCTCTGTCTCTCTGTCTCTTCATCTCTGTCTGTCTCTGCCTGTCTGTGTCATTTGGTGTCTCTGTTTTTGTATGTCTCTCTGTTTGTCTGTGTCTCTTCCTCTCTGTAGCTCTGCCTCTCTCTATCTCTCCTTATATCTGTCTTTCTCTCTCCCTGTTTCTTTCTCTGTCTCTTTTTGTCTTTCTGAGTCTGTCTCTGTCTCTGTCTCTTCCTCTCTGTATATACCTCTCTGTCTTTCTGTTGCTGTCTGTCTCTGTTTCTCTTCTCCTCTCTCTATCTCTCTTTGTCTGTCTTTCTCTGCCTTTCTAACTCTGTCTTTCTCTGTCTCTCTGTCTCTATCTCAGTCTCTCTTCTTATCTCTCTCTCTGTCTCTCTCACTCTCTGTATCTCTTTGTCTCTGTCTTTCTCTTATCTCTATCGCTCTGTCTCTATCTCTCTTTCTGTCTCTCTGTATCTCTATCTCTGTCTCTCTCATGTCTATCTCTCTGTCTTTCTCTGTCTCTCTGTATCTCTGTCTTTCATCTCTATCTCTATCTCTGTCTTTCTGTCTCTATCTCTGTCTCTCTATCTCTTTCTCTGTCTGTATCTCTCTGTCTCTATCTCTCTCTGTCTTTCTCTGTGTCTCTGTATCTCTGTCTCTATCTCTGTCTCTCTATCTCTCTCTGTCTCTCCCTGTCTCTCTCTATCTCTGTCTCTCCATCCCATGTGGGTCTGTGGGTTTCCCCGAGGCTCAGAGCCCTGCCCCGGTCAGCACAGACAGGGAACAGGGCGAGGGCTGGGTGGTGGCCCAGTGACCTTGGGGGCCAGGCCTTGGGGGTGCAGGTGGGCCCGTGCTGCCGTGCCCCCCACCCACAGACAGGCCCCGGCTCTGGCCCAGCACCCGCTCCGCCGCTCCCAGCTGCAGGCTGAGCTCTGCCCGTTTGCTGCTGGGCCATGTGTGTTTGGGGCCTTTCCTGAGCCAGGCCTTGGGTGGGCCCTGTTT"
                )
            ))
        );
        let test = elem.next();
        let rangepos = RangePos::new(99829102, 99835825);
        assert_eq!(
            test,
            Some((
                &rangepos,
                &String::from(
                    "CCCCAGACCACCCATGAGCAGAGTGTAGGGCACGTGCCCAGCTCACAGAGGGGACCTCTGAGGCGGGGTGTGGTGGGCACACAGCAGTGAGCCATGAGGCTGGTGGCCCAGAGGCTTGGACATGCCGTGGGCCCCATAGGAAGTGACAGGGCTTGAGGGAAGCTCAGTGTGAGTGTGTGAGCGTGGGTATGAATGTGACAGTGACTCTCTATCTGTCTCTTTGTATCTCTGTCTCTCTGTGTGTATCTTTCTATCTCTGTCTCTCTATATGTCTCTCTATCTCTGTCTCTCTGTATCTCTATCTCTCTGTGTGTATCTTTCTATCTCTGTCTCTCTTTCTTGATCTCTCTCTATCTCTGTCTCTGTAACTCTCTTTATCTCTTACTGCTTCTGTTTCTCTCACTCTGTCTCTGTCTCTCTTTATCTCTGTCTTGCTCTCTCTCTCTGTAACTTTATCTCTGTCTCTCTGTTTCTATCTCTGTTTTTCTCTGTCTCTGTCTGTATCTCTGTCTCTCTTTATCTGTCTCTCTGTCTCTGTGTATCTCTGTCTCTCTGTAACTTTATCTCTGTCTTTTTCTGTCTCTGTGTGTGTCTGTCTCTGTGTCTTTGTTTTTCTCTCTGTCTCTGTCAATGTCTCTTTCTGTATCTGTTTCTTTCTCTCTGTCTCTGTCTCTCTATCTCTGTCTCTATCTCTCTGTCTCTCTGTAACTCCTCATCTCTGTCTCTGTGTCTGCATGTCTCTTTCTGTGTCTCTGTTTCTCTCTCTGTCTCTGTCTCTCTGTGACTCTGTCTCTGTCTCTGTCTCTGTCTTTCTCTGTTACTCTGTCTCTCTCTCTGTCTCTCTGTGACTCTATCTGTTACTCTGTCTCTGTCTCTGTCTCTCTCTGTCTCTCTTTCTCTGTTACTCTGTCTGTGTCTCTGTGTCTCTCTCTCGTCTGTCTTTCTCTGTTACTCTGTCTCTGTCTCTGTGTCTCTGTCTCTCTGCACTGTTTTCCTGGTGAAGGAGAAGCCATGTACCTTCCTGCATGATCTGTGCTCAGCTCACAACCACCCCATGATTGAGGACACCCCTCCTTCTAGAAGGTTCCCAGCTAACAGGTGCAGAAGGAGTGAAGATTGAAATAGGAGACCCCATCTTGAGACCCTCCCGGAACAGTGCCCCTGGGCCGTGTCCCCACTTCGGGACGTGGGATCTCGGTGCCAGGCGTGCGCTGCCTGACCCCGATCCCGTCGGCGTGTGGGCCCTTCCTCAGCCCAGGTGATTCCCTGTGGGCACGGGACTGGGCAGTGCTCCCCACGGCTGCTGGGCCCCAGGACCGGCCTCCAAGGCTGAACCGCGGCTCTGCCAGCTCCACAGACAGCCAGCAGCCCACCCGACAGGGACCAACATGACAAGGTGCTCAGGGCCGCCCTGTGCCCCGGGACCCAGCTGCAGCCTCAGCAGGACAGGGCTGGGGGTGGAGGGCACAGCCGGACTCCTGAGGACAAACGGCCCGCGCCCCGGGTGAACTCAGTGCCGTGGGGAGCCTGTGCACGGGCTGTGGTGGACGCGTCCCTGAGACCCTGTGTGTGCTGTAGGGTGGCTGTGCCCGCTGCCCTCACCACCTGCTGCCCGGGGCCCAGCCTCCCTCGCTGGGGCTGGAGGGTGGATCCAGCAGGGACAGCGTGATGCTCAGAGTCATCGCATAGTGACAAGGACGGGGGCTGCTTTCAAAGCTCCTGAATGTTTTAGTGGCTCAGAGTGAAGGTTCACAGGCCTCGGGGGACATGGCCTAGACTGGGCGTGGGTCCAGCCCCTTGGCAAGCAGTGGGTACATGGCGTGTCCTCCTCCATCCCCATCTGTCTGGTCCCCAGCCACACGCTGAGCCTGGGTCCCCGACTCCCCCCCGACCCGGCAGCTCAGGCCCAAGTCCCTGTCCCCTCCCCACATCCCCTCACAGCAGGTGCTTCAGAGGGGCCCTGGAACGTGACCAGTGTGGGGGAGGTGCTGCGGGGACTGGGGACCACACACGGCACCCGGCCCAGTGCCAGGGGGAGGCGGGTCAGGGCCCAGGTCTCCGAGGCCCAGGCTGTGCGTGTTGGAAGCCCCATTGTTGATGGAGTCAGATGCCCACATCCTCATCCCCGCCTGGGGCCCCTTCTTCAGGAGCCCTGGGTTCAGTCAGAGCCCAGCCAAGGTCCCCTCCCTGGCCAGAGGCCTCACTGTCTCGGTCACCCTCACCTCACTGCCCCCACCTCCTCACCCCTGCCAGCCTGGCCACTCTGGGCTGCTCCTGGCCTCCTTCCCACAAACACGGACCCACAGGTTCTCTAGGCCCTCCAGGACCTTCGCCCACTCCACGGCCCCTGCCCCTGTCCTGTTGACCTCCCAGCGTCCATCCCTGTCCTCGGGCTGCACCCTGCTGGCTATCCTGTTCTCTGACCATCCCCCACTGTCCAGTCCCTCCTGGGAGACCTGAGGCCGTCCTGGGCTTCAGCCCCCAGGGCTGGGGTCGCAGTGCGCAGGGTCCTGGGACCTCCTGCTCCCGCCTCTCCCATGTTGTTACCCACCCCAGCCCGATGTTCGGGGTCCTGTGTGGATCTGTAGGTTTCCCCGAGGCTCAGAGTCCTGCCCCGTCCAGCACAGACGGGGAACAGGGCGAGGGCTGGGTGGTGGCCCAGTGACCTCGGGGGCCAGGCCTTGTAGGTGCAGGTGGGCCCGTGCTGCCGTGCCCCCCACCCACAGACAGGCCCCGACTCTGGCCCAGCGCCCGCTCGGCCGCTCCCAGCTGCAGGCTGAGGTCTCCCCATTTGCTCCTGGGCCATGTGTGTTTGGGTGTGAGTGTGGGTATGGATGTGACAGTGACTTAGTGTGTGGCTGTGAGCGTGGGTATGTTTCTGTGTGTTTGTGTGTGAATGTTGTATAATAGTCGTGGTGTGTGTTTGTGAGAGTGACTGTGTGAGAGGGGCTTGCAGCTGAGTTCCTGGGCCCATCTTGCTGCCTCTTTCTCTCCCTGTGTGTTCTCTGCCTCTGTTGTGTTCTCTCTGCATGTCTGTCTCCATGTCTCTTTTTCCCTGTTCCCATCTCCTCCCTTTTTCTCCCATCTCTGTCTCTGTTTCTTATCTATCTCATCTCATCTCTCTCTTTCTGTCTCTTGTGTCTCTGTCCCTCCCCATCCCTGTCTCTTATCTCTCTCCATCCCCATCTCTCTCTCTGTGTCTGTCTTTGTCTCTGTCTCTATGTCTCTTGTCTCTCCCCATCCCTGTCTCTCTCTATGTCTCTGTGTCTCTTATCTCTCCCCATCCCTGTCTCTCTATGTCTCTGTGTCTCTTATCTCTCCTTGTCCTTGTCTTTCTCTGTCTACGTCTCTGTGTCTCTCTCCATCCCTGTCTCTCTCTATGTCTCTGTGTCTCTTATCTCTCCCTATCCCTGTCTCTCTATGTCTCTTGTCTCTCCCCATCCCTGTCTCTCTCTCTCTATGTCTCTGTGTCTCTTATCTCTCCCCATCCCTGTCTCTCTCTATGTCTCTTCATCTCTTATCTCTCTCCCCATCCCTGTCTCTATGTCTCTGTGTCTCTTATCTCTCCCCATCCTTGTCTCTGTCTATGTCTCTGTGTCTCTTGTCTCTCCCTGTCCCTGTCTCTCTCTATGTCTCTGTGTCTCTCTGGGCCCCTGGTCCAATGTCCCCTTCCCAGAACCCCTGTTTCCCTGGTGTGGGGTGCAGGTCCTTCTGTGGCCCTGTGGGCCGTGCTTGTGCTGGGCACAGCCTGCCAGGGCAGCCACTCAAGCCCCAGGGCTGGGCACTGCGTCCTGGCTCTGGCCAAGGGCCCTGGGGAGAGCTGAGGGAGGTGCATGCAGGGTGTGAGGCCCACCACAGTCACTGCCAGATGCTCAGTGCTGGTGCTTCCCTGGGTCTGCTGTGTGGTGGGCACAGCCCTCGTGAGGGCTGCCCATGGAGGAGGCCTGCCGCCTAGAGAGCCCGGACAGGGGGACAATGGCCTGTGCTGACCCTGGCGGAACCCTGGCTGGCCCCAGATGACCCCAGATGGCCCTGGCTGACCCTGGCGGAACCCAGATGACCCTGGCTGACCCTGGCTGGCCCTGGCTGACCCCAGATGACCCTGGCTGACCCTGGCTGATCCTGGCTGACCCTGGCTGACCTCTGCCTAACCCTGGACCTGGAAAGCCCTAGCTGACCCCGGGCTGGTTGGGGCTGGGCCTCCCTGTGGCTGCAGCCCCTCGCTCAGGCCCCAGGCACACCTGGCCAGGTCTCGGTTTTGGGGCATGTTTCTCAGAACAGCAGTTCTCTGGCTGGAACACCTGGCCTGGGCTGTGTTCACAATGACTCAGCCGCCCCACAGGGCTATTTTGGATATTTCTGCAGGTGATGGGGTACAAGAGGCTTCAGGAGAGAGAGAAAAGCAAGAGAATACAAACAGCATGGCCTCCCCCGACCTTCCTGTCCCCACTCCTGTACTGTACCCCCTCCCCAGTGCTAAGTCGAGACCTGGCGACCCCTTAGGGGCTGGGGCTGGGTGTAGCTCACAGGGCCTGGGCTGGTCCTCTCCCCACCAAGTCCTCCTGGGGCCTACACACCCCTCTGAGCCTGGAAAAATGGAGCAAGCCATTGGGGTCATTTCTTCATCTACCAGTGAGTACATGCACTGAGAGGGTCTCGGCTCCCCTGGAGGCCTCCCTCCACCACTGCAGGTCACTTACTCATGAGGGCCAAGGCTCAGAAATCAGACAGGACTCAGTGTCTAGTCAGACTGATACATGCTCAGAAAAGGAATCAGATTTCAAAATGAATATGTATAAGAAAAGAACCGGGGATCAGTGATCAGGAACAGGGATCCATGATCTGGTCCAGGGCTCAGCGGTCAGGAACAGGGCCCAGCGATCAGGACCAGGGCTCAGTAATCAGGACCAGGGCCCAGTGATCAGGACCAGGGCCCAGCGATTGGGTCCAGGGCTCAGTGATCAGGAACAGGGCTCAGTGATCAGGACCAGGGCCCAGTGATCAGGAACAGGGGCCAGTGACTGGGTCCAGGGCTCAGTAATCAGGACCAGGGCTCAGTGATCAGGACCAGGGCTCAGTGATCAGGAACAGGGGTTAGTGATCAGGAACAGGGCTCAGTGATCAGGACCAGCATTCAGTGATCAGGACCAGGGCTCAGTGATCAGGAACAGGGCTCAGTGATCAGGAACAGGGGTTAGTGATCAGGAACAGGGCTCAGTGATCAGGACCAGCACTCAGTGATCAGGACCAGGGCCCAGTGATCAGGAACAGGGGCCAGTGACTGGGTCCAGGGCTCAGTAATCAGGACCAGGGCTCAGTGATCAGGACCAGGGCTCAGTGATCAGGAATAGGGGTTAGTGATCAGGAACAGGGCTCAGTGATCAGGACCAGGGCTCAGTGATCAGGAACAGGGCTCAGTGATCAGGAACAGTGGTCAGTGATCAGGAACAGGGGTTAGTGATCAGGAACAGGGCTCAGTGATCGGGACCAGGGCTCAGTGATCAGGACCAGGGCCCAGTGATTGTGTCCAGGGCTCAGTGATCAGGACCAGGGCTCAGTGATCAGGAACAGGGCTCAGTGATCAGGAACAGGGGTTAGTGATCAGGAACAGGGCTCAGTGATCAGGACCAGCACTCAGTGATCAGGACCAGGGCCCAGTGATCAGGACCAGGGCCCAGCGATTGGGTCCAGGGCTCAGTAATCAGGACCAGGGCCCAGTGATCAGGAACAGGGCTCAGTGATCAGGAACAGGGGTTAGTGATCAGGAACAGGGGTTAGTGATCAGGAACAGGGCTCAGTGATCAGGAACAGGGCTCAGAGATCAGGACCAGGGCCCAGCGATTGGGTCCAGAGCTCAGTGATCAGGAACAGGGCCCAGCGATCAGGACCAGGGCTCAGTAATCAGGACCAGGGCTCAGTGATCAGGACCAGGGCCCAGTGATCAGGAACAGGGGCCAGTGACTGGGTCCAGGGCTCAGTAATCAGGACCAGGGCTCAGTGATCAGGAACAGCGGTTAGTGATCAGGAACAGGGCTCAGTGATCAGGACCAGCGCTCAGTGATCAGGAGCAGGGCTCAGTAATCAGGACCAGGGCCCAGTGATCAGGAACAGGGCTCAGTGATCAGGAACAGGGGTTAGTGATCAGGAACAGGGCTCAGTGATCAGGACCAGGGCCCAGCGATTGGGTCCAGAGCTCAGTGATCAGGAACAGGGCCCAGCGATCAGGACCAGGGCTCAGTAATCAGGACCAGGGCTCAGTGATCAGTACCAGGGCCCAGCGATTGGGTCCAGGGCTCAGTGATCAGGACCAGGGCCCAGCGATTGGGTCCAGGGCTCAGTGATCAGGAACAGGGCCCAGCGATCAGGACCAGGGCTCAGTAATCAGGACCAGGGCTCAGTGATCAGGACCAGGGCCCAGCGATTGGGTCCAGGGCTCAGTGATCAGGAACAGGGCCCAGCGATTGGGTCCAGGGCTCAGTGATCAGGAACAGGGCCCAGCGATCAGGACCAGGGCTCAGTAATCAGGACCAGGGCTCAGTGATCAGGACCAGGGCCCAGCGATTGGGTCCAGGGCTCAGTGATCAGGACCAGGGCCCAGCGATTGGGTCCAGGGCTCAGTGATCAGGAACAGGGGTTAGTGATCAGGAACAGGGCTCAGTGATCAGGAACAGGGGTTAGTGATCAGGAACAGGGCTCAGTGATCAGGACCAGGGCCCAGTGATT"
                )
            ))
        );
        assert!(elem.next().is_none());
    }
    #[test]
    fn testseqreverse() {
        let mut read = crate::bam::Reader::from_path("test/locus.bam").unwrap();
        let elem = read.records().filter_map(Result::ok).nth(8).unwrap();
        let val = elem.matched_sequence().unwrap();
        assert!(val.isfullymatched(99820441..=99821296).is_some());
        assert!(val.isfullymatched(99821296..=99821298).is_none());
        let mut elem = val.gethash().iter();
        let test = elem.next();
        let rangepos = RangePos::new(99820441, 99821297);
        assert_eq!(
            test,
            Some((
                &rangepos,
                &String::from(
                    "ACCCCCATCCACACACACCCAGAGACACACAGACACCCACAGCCACACACTCACACTCACGAACTTATCCAGTCACGTCCCACACACTCCCACCCAACCCATACACCACACACCTACACAACCCATACACCACACACACTCACAAACTATATACCACACACACACCAACCATACACCTATATACACTCACACACCCATATACCACACACTCACACACAACCCATACACCACACGCACACAACCCATACACCTATACACACTCACACCTACAAACTATATACTACACACTCACACACAACCCATACACCTATACACACACACCCATATACCACACACAACCCATACACCACACACACAAACCATATACCACACACTCACACAACCCATACACCTATACACACTCATACCCATATACCACATACAACCAATATACCACACACACACAACCCATACACCTATACACACACACCTATACACCACACACAGCCCATACACTACACAATCACACCACAAACTGTATACCACACACTCACACATAACCCATACACCTATACACACACACCCATATACCACACACACAACCTGTGCACCTACACACACACATACACCACACACACACAACTCCTACACCTACACACACCCACCACCCATACACACACAGCCTATACACCTACACACACTCATACACTCATATAGCACACACACAACCCATATACCACACACACAACCCACATACCTATACACACACGCCCATACACCACACACTCACACAACCCATGCACCACATACACCCACAAACTATATGCTACACGCTCACACACAACCCATACACCTATACACAATCCCACAACCCATA"
                )
            ))
        );
        let test = elem.next();
        let rangepos = RangePos::new(99821297, 99822851);
        assert_eq!(
            test,
            Some((
                &rangepos,
                &String::from(
                    "CACACTTACACAACCTATACACCACACACACTCACAATCTGTATACCACACACACAACCCATACAGTTATACACACACACCCATATACCACACACACACAACCCATATACCACACACTCACACACAAACCATACATCTATACACATACCCATATGCCACACATACAACCCATACACCACACACTCACACACAACACATACACCACACACACAACCCATAGAACACAAACACAAGTCATAACCACACACACAGCCCATATACCTATACACATTCACACACACAACCCATACACTACACACACAACACATACACCTATACACACTCACACTCAATTCATACACCACACACACACAGCCCATACATCTATACACAAACTCACACACAATCCATATACCACAAACTCACACACAACGCATACACCTATACACACACACGCAACTCATACAGCACACACTCACACAACCCACAGACCATAAACACACACAAGCCATAACCACACACAAACCCATACACCTATACACACACTCATAAACAAGCCATACACCCCTACACAACCCATACACCACACACTCACAACCCATACACCTATATACACACACAACCATATACCACAAACTCACGCTCAACACATACACCTATACACACACACAACTCATACACCACACACTCATACACAACGCACAGACCACATACACAAGCCATAACCACACACACACAACCCGTACACATATATACACACTAATAAACAAGCCATACACCTACACATACAACCCATACACCACACATTCACACATAACCCATACACCTATACACACACACACACAACCCATATACCACAAACACACACAACCTATACACACATACAACCCATACACCACACACACAACACATACACACCACACACACACAGAATACTCATACACACACCCATACACCACCCCCACACAGAACCCATACACCACACACACACAACCTATACACCTATACACACACTCACACACACAACTCATATACCACAAACACACACAACACATACACCTATGCACACACACAACCCATACACCACACATTCACATACAACCCATACACCACACACACACAACACATACATGAAACATACATACAACCCACACACCACCCACTCATACACAACCTATACACCACACACACAACTCATACACCTATACACACACAACACATACACCTATCATACACTCACAACACATACACCTCCTATACACACACAACACACACACTTCCTATACACACAACCCACACGCCTATACACACATCCTCACTCACACTCACCCTCACATTCATATACTCACTAACACACTTCCACACTCACACCCTCACCCACACTTACACCCCCACCCACACTCAAACCCCGACGCTAAGTCACTGTCACATTTGTACCCATGCTCACACGCTCACACGCTCACACACTCACCCCCCACCAGCTCCAGGGCTCACTGGTGTGTGCCCACCAAACCCCCCTCGGGGGTCCCCTCGGTAAGCCGACAGTGCTCTGCTCATCGGTGGCCTGGGGAAACA"
                )
            ))
        );
    }
    #[test]
    fn spliced_reads() {
        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
        let mut it = bam.records();
        let blocks: Vec<_> = it.next().expect("iter").unwrap().aligned_blocks().collect();
        //6S45M - 0
        assert!(blocks[0] == [16050676, 16050721]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //7M2D44M - 1
        assert!(blocks[0] == [16096878, 16096885]);
        //7M2D44M - 1
        assert!(blocks[1] == [16096887, 16096931]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //29M2D22M - 2
        assert!(blocks[0] == [16097145, 16097174]);
        //29M2D22M - 2
        assert!(blocks[1] == [16097176, 16097198]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //51M - 3
        assert!(blocks[0] == [16117350, 16117401]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //51M - 4
        assert!(blocks[0] == [16118483, 16118534]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //51M - 5
        assert!(blocks[0] == [16118499, 16118550]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //51M - 6
        assert!(blocks[0] == [16118499, 16118550]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //51M - 7
        assert!(blocks[0] == [16118499, 16118550]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //51M - 8
        assert!(blocks[0] == [16123411, 16123462]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //6S45M - 9
        assert!(blocks[0] == [16123417, 16123462]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //41M10S - 10
        assert!(blocks[0] == [16165860, 16165901]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //51M - 11
        assert!(blocks[0] == [16180871, 16180922]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //51M - 12
        assert!(blocks[0] == [16189705, 16189756]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //51M - 13
        assert!(blocks[0] == [16231271, 16231322]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //51M - 14
        assert!(blocks[0] == [16237657, 16237708]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //9S42M - 15
        assert!(blocks[0] == [16255012, 16255054]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //51M - 16
        assert!(blocks[0] == [16255391, 16255442]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //50M1S - 17
        assert!(blocks[0] == [16255392, 16255442]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //45M6S - 18
        assert!(blocks[0] == [16256084, 16256129]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //3S48M - 19
        assert!(blocks[0] == [16256224, 16256272]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //42M9S - 20
        assert!(blocks[0] == [16325199, 16325241]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //13S38M - 21
        assert!(blocks[0] == [16352865, 16352903]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //44M7S - 22
        assert!(blocks[0] == [16352968, 16353012]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //5S46M - 23
        assert!(blocks[0] == [16414998, 16415044]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //23M4I24M - 24
        assert!(blocks[0] == [17031591, 17031614]);
        //23M4I24M - 24
        assert!(blocks[1] == [17031614, 17031638]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //18M1I32M - 25
        assert!(blocks[0] == [17057382, 17057400]);
        //18M1I32M - 25
        assert!(blocks[1] == [17057400, 17057432]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //17M2183N34M - 26
        assert!(blocks[0] == [17092766, 17092783]);
        //17M2183N34M - 26
        assert!(blocks[1] == [17094966, 17095000]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //1M2183N50M - 27
        assert!(blocks[0] == [17092782, 17092783]);
        //1M2183N50M - 27
        assert!(blocks[1] == [17094966, 17095016]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //1M2183N50M - 28
        assert!(blocks[0] == [17092782, 17092783]);
        //1M2183N50M - 28
        assert!(blocks[1] == [17094966, 17095016]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //9S33M9S - 29
        assert!(blocks[0] == [17137287, 17137320]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //2S48M1S - 30
        assert!(blocks[0] == [17306238, 17306286]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //4S45M2S - 31
        assert!(blocks[0] == [17561868, 17561913]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //41M11832N10M - 32
        assert!(blocks[0] == [17566078, 17566119]);
        //41M11832N10M - 32
        assert!(blocks[1] == [17577951, 17577961]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //11M11832N25M710N15M - 33
        assert!(blocks[0] == [17566108, 17566119]);
        //11M11832N25M710N15M - 33
        assert!(blocks[1] == [17577951, 17577976]);
        //11M11832N25M710N15M - 33
        assert!(blocks[2] == [17578686, 17578701]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //8M11832N25M710N18M - 34
        assert!(blocks[0] == [17566111, 17566119]);
        //8M11832N25M710N18M - 34
        assert!(blocks[1] == [17577951, 17577976]);
        //8M11832N25M710N18M - 34
        assert!(blocks[2] == [17578686, 17578704]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //8M11832N25M710N18M - 35
        assert!(blocks[0] == [17566111, 17566119]);
        //8M11832N25M710N18M - 35
        assert!(blocks[1] == [17577951, 17577976]);
        //8M11832N25M710N18M - 35
        assert!(blocks[2] == [17578686, 17578704]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //8M11832N25M710N18M - 36
        assert!(blocks[0] == [17566111, 17566119]);
        //8M11832N25M710N18M - 36
        assert!(blocks[1] == [17577951, 17577976]);
        //8M11832N25M710N18M - 36
        assert!(blocks[2] == [17578686, 17578704]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //8M11832N25M710N18M - 37
        assert!(blocks[0] == [17566111, 17566119]);
        //8M11832N25M710N18M - 37
        assert!(blocks[1] == [17577951, 17577976]);
        //8M11832N25M710N18M - 37
        assert!(blocks[2] == [17578686, 17578704]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //7M11832N25M710N19M - 38
        assert!(blocks[0] == [17566112, 17566119]);
        //7M11832N25M710N19M - 38
        assert!(blocks[1] == [17577951, 17577976]);
        //7M11832N25M710N19M - 38
        assert!(blocks[2] == [17578686, 17578705]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //6M11832N25M710N20M - 39
        assert!(blocks[0] == [17566113, 17566119]);
        //6M11832N25M710N20M - 39
        assert!(blocks[1] == [17577951, 17577976]);
        //6M11832N25M710N20M - 39
        assert!(blocks[2] == [17578686, 17578706]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //6M11832N25M710N20M - 40
        assert!(blocks[0] == [17566113, 17566119]);
        //6M11832N25M710N20M - 40
        assert!(blocks[1] == [17577951, 17577976]);
        //6M11832N25M710N20M - 40
        assert!(blocks[2] == [17578686, 17578706]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //1S44M1467N6M - 41
        assert!(blocks[0] == [17579733, 17579777]);
        //1S44M1467N6M - 41
        assert!(blocks[1] == [17581244, 17581250]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //2M1514N48M95N1M - 42
        assert!(blocks[0] == [17581369, 17581371]);
        //2M1514N48M95N1M - 42
        assert!(blocks[1] == [17582885, 17582933]);
        //2M1514N48M95N1M - 42
        assert!(blocks[2] == [17583028, 17583029]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //1M1514N48M95N2M - 43
        assert!(blocks[0] == [17581370, 17581371]);
        //1M1514N48M95N2M - 43
        assert!(blocks[1] == [17582885, 17582933]);
        //1M1514N48M95N2M - 43
        assert!(blocks[2] == [17583028, 17583030]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //1M1514N48M95N2M - 44
        assert!(blocks[0] == [17581370, 17581371]);
        //1M1514N48M95N2M - 44
        assert!(blocks[1] == [17582885, 17582933]);
        //1M1514N48M95N2M - 44
        assert!(blocks[2] == [17583028, 17583030]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //1S22M95N28M - 45
        assert!(blocks[0] == [17582911, 17582933]);
        //1S22M95N28M - 45
        assert!(blocks[1] == [17583028, 17583056]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //37M538N13M1S - 46
        assert!(blocks[0] == [17588621, 17588658]);
        //37M538N13M1S - 46
        assert!(blocks[1] == [17589196, 17589209]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //37M538N13M1S - 47
        assert!(blocks[0] == [17588621, 17588658]);
        //37M538N13M1S - 47
        assert!(blocks[1] == [17589196, 17589209]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //37M538N13M1S - 48
        assert!(blocks[0] == [17588621, 17588658]);
        //37M538N13M1S - 48
        assert!(blocks[1] == [17589196, 17589209]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //1S25M1D25M - 49
        assert!(blocks[0] == [17591770, 17591795]);
        //1S25M1D25M - 49
        assert!(blocks[1] == [17591796, 17591821]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //24M1D24M3S - 50
        assert!(blocks[0] == [17593855, 17593879]);
        //24M1D24M3S - 50
        assert!(blocks[1] == [17593880, 17593904]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //16M1D28M7S - 51
        assert!(blocks[0] == [17593863, 17593879]);
        //16M1D28M7S - 51
        assert!(blocks[1] == [17593880, 17593908]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //11S7M1I32M - 52
        assert!(blocks[0] == [17596476, 17596483]);
        //11S7M1I32M - 52
        assert!(blocks[1] == [17596483, 17596515]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //5S9M1892N37M - 53
        assert!(blocks[0] == [17624012, 17624021]);
        //5S9M1892N37M - 53
        assert!(blocks[1] == [17625913, 17625950]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //2S9M1892N40M - 54
        assert!(blocks[0] == [17624012, 17624021]);
        //2S9M1892N40M - 54
        assert!(blocks[1] == [17625913, 17625953]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //1S7M3D19M2285N24M - 55
        assert!(blocks[0] == [31796700, 31796707]);
        //1S7M3D19M2285N24M - 55
        assert!(blocks[1] == [31796710, 31796729]);
        //1S7M3D19M2285N24M - 55
        assert!(blocks[2] == [31799014, 31799038]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //14M799N28M13881N7M2S - 56
        assert!(blocks[0] == [36722692, 36722706]);
        //14M799N28M13881N7M2S - 56
        assert!(blocks[1] == [36723505, 36723533]);
        //14M799N28M13881N7M2S - 56
        assert!(blocks[2] == [36737414, 36737421]);

        let blocks: Vec<_> = it.next().unwrap().unwrap().aligned_blocks().collect();
        //4S21M1696N23M2331N3M - 57
        assert!(blocks[0] == [44587963, 44587984]);
        //4S21M1696N23M2331N3M - 57
        assert!(blocks[1] == [44589680, 44589703]);
        //4S21M1696N23M2331N3M - 57
        assert!(blocks[2] == [44592034, 44592037]);
    }

    #[test]
    fn test_introns() {
        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
        let mut it = bam.records();

        //6S45M - 0
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //7M2D44M - 1
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //29M2D22M - 2
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //51M - 3
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //51M - 4
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //51M - 5
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //51M - 6
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //51M - 7
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //51M - 8
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //6S45M - 9
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //41M10S - 10
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //51M - 11
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //51M - 12
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //51M - 13
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //51M - 14
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //9S42M - 15
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //51M - 16
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //50M1S - 17
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //45M6S - 18
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //3S48M - 19
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //42M9S - 20
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //13S38M - 21
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //44M7S - 22
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //5S46M - 23
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //23M4I24M - 24
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //18M1I32M - 25
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //17M2183N34M - 26
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 1);
        assert_eq!(introns[0], [17092783, 17094966]);
        //1M2183N50M - 27
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 1);
        assert_eq!(introns[0], [17092783, 17094966]);
        //1M2183N50M - 28
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 1);
        assert_eq!(introns[0], [17092783, 17094966]);
        //9S33M9S - 29
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //2S48M1S - 30
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //4S45M2S - 31
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //41M11832N10M - 32
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 1);
        assert_eq!(introns[0], [17566119, 17577951]);
        //11M11832N25M710N15M - 33
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 2);
        assert_eq!(introns[0], [17566119, 17577951]);
        assert_eq!(introns[1], [17577976, 17578686]);
        //8M11832N25M710N18M - 34
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 2);
        assert_eq!(introns[0], [17566119, 17577951]);
        assert_eq!(introns[1], [17577976, 17578686]);
        //8M11832N25M710N18M - 35
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 2);
        assert_eq!(introns[0], [17566119, 17577951]);
        assert_eq!(introns[1], [17577976, 17578686]);
        //8M11832N25M710N18M - 36
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 2);
        assert_eq!(introns[0], [17566119, 17577951]);
        assert_eq!(introns[1], [17577976, 17578686]);
        //8M11832N25M710N18M - 37
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 2);
        assert_eq!(introns[0], [17566119, 17577951]);
        assert_eq!(introns[1], [17577976, 17578686]);
        //7M11832N25M710N19M - 38
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 2);
        assert_eq!(introns[0], [17566119, 17577951]);
        assert_eq!(introns[1], [17577976, 17578686]);
        //6M11832N25M710N20M - 39
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 2);
        assert_eq!(introns[0], [17566119, 17577951]);
        assert_eq!(introns[1], [17577976, 17578686]);
        //6M11832N25M710N20M - 40
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 2);
        assert_eq!(introns[0], [17566119, 17577951]);
        assert_eq!(introns[1], [17577976, 17578686]);
        //1S44M1467N6M - 41
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 1);
        assert_eq!(introns[0], [17579777, 17581244]);
        //2M1514N48M95N1M - 42
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 2);
        assert_eq!(introns[0], [17581371, 17582885]);
        assert_eq!(introns[1], [17582933, 17583028]);
        //1M1514N48M95N2M - 43
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 2);
        assert_eq!(introns[0], [17581371, 17582885]);
        assert_eq!(introns[1], [17582933, 17583028]);
        //1M1514N48M95N2M - 44
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 2);
        assert_eq!(introns[0], [17581371, 17582885]);
        assert_eq!(introns[1], [17582933, 17583028]);
        //1S22M95N28M - 45
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 1);
        assert_eq!(introns[0], [17582933, 17583028]);
        //37M538N13M1S - 46
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 1);
        assert_eq!(introns[0], [17588658, 17589196]);
        //37M538N13M1S - 47
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 1);
        assert_eq!(introns[0], [17588658, 17589196]);
        //37M538N13M1S - 48
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 1);
        assert_eq!(introns[0], [17588658, 17589196]);
        //1S25M1D25M - 49
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //24M1D24M3S - 50
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //16M1D28M7S - 51
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //11S7M1I32M - 52
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 0);
        //5S9M1892N37M - 53
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 1);
        assert_eq!(introns[0], [17624021, 17625913]);
        //2S9M1892N40M - 54
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 1);
        assert_eq!(introns[0], [17624021, 17625913]);
        //1S7M3D19M2285N24M - 55
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 1);
        assert_eq!(introns[0], [31796729, 31799014]);
        //14M799N28M13881N7M2S - 56
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 2);
        assert_eq!(introns[0], [36722706, 36723505]);
        assert_eq!(introns[1], [36723533, 36737414]);
        //4S21M1696N23M2331N3M - 57
        let introns: Vec<_> = it.next().unwrap().unwrap().introns().collect();
        assert_eq!(introns.len(), 2);
        assert_eq!(introns[0], [44587984, 44589680]);
        assert_eq!(introns[1], [44589703, 44592034]);
    }

    #[test]
    fn test_aligned_pairs() {
        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
        let mut it = bam.records();

        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [6, 16050676],
                [7, 16050677],
                [8, 16050678],
                [9, 16050679],
                [10, 16050680],
                [11, 16050681],
                [12, 16050682],
                [13, 16050683],
                [14, 16050684],
                [15, 16050685],
                [16, 16050686],
                [17, 16050687],
                [18, 16050688],
                [19, 16050689],
                [20, 16050690],
                [21, 16050691],
                [22, 16050692],
                [23, 16050693],
                [24, 16050694],
                [25, 16050695],
                [26, 16050696],
                [27, 16050697],
                [28, 16050698],
                [29, 16050699],
                [30, 16050700],
                [31, 16050701],
                [32, 16050702],
                [33, 16050703],
                [34, 16050704],
                [35, 16050705],
                [36, 16050706],
                [37, 16050707],
                [38, 16050708],
                [39, 16050709],
                [40, 16050710],
                [41, 16050711],
                [42, 16050712],
                [43, 16050713],
                [44, 16050714],
                [45, 16050715],
                [46, 16050716],
                [47, 16050717],
                [48, 16050718],
                [49, 16050719],
                [50, 16050720]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 16096878],
                [1, 16096879],
                [2, 16096880],
                [3, 16096881],
                [4, 16096882],
                [5, 16096883],
                [6, 16096884],
                [7, 16096887],
                [8, 16096888],
                [9, 16096889],
                [10, 16096890],
                [11, 16096891],
                [12, 16096892],
                [13, 16096893],
                [14, 16096894],
                [15, 16096895],
                [16, 16096896],
                [17, 16096897],
                [18, 16096898],
                [19, 16096899],
                [20, 16096900],
                [21, 16096901],
                [22, 16096902],
                [23, 16096903],
                [24, 16096904],
                [25, 16096905],
                [26, 16096906],
                [27, 16096907],
                [28, 16096908],
                [29, 16096909],
                [30, 16096910],
                [31, 16096911],
                [32, 16096912],
                [33, 16096913],
                [34, 16096914],
                [35, 16096915],
                [36, 16096916],
                [37, 16096917],
                [38, 16096918],
                [39, 16096919],
                [40, 16096920],
                [41, 16096921],
                [42, 16096922],
                [43, 16096923],
                [44, 16096924],
                [45, 16096925],
                [46, 16096926],
                [47, 16096927],
                [48, 16096928],
                [49, 16096929],
                [50, 16096930]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 16097145],
                [1, 16097146],
                [2, 16097147],
                [3, 16097148],
                [4, 16097149],
                [5, 16097150],
                [6, 16097151],
                [7, 16097152],
                [8, 16097153],
                [9, 16097154],
                [10, 16097155],
                [11, 16097156],
                [12, 16097157],
                [13, 16097158],
                [14, 16097159],
                [15, 16097160],
                [16, 16097161],
                [17, 16097162],
                [18, 16097163],
                [19, 16097164],
                [20, 16097165],
                [21, 16097166],
                [22, 16097167],
                [23, 16097168],
                [24, 16097169],
                [25, 16097170],
                [26, 16097171],
                [27, 16097172],
                [28, 16097173],
                [29, 16097176],
                [30, 16097177],
                [31, 16097178],
                [32, 16097179],
                [33, 16097180],
                [34, 16097181],
                [35, 16097182],
                [36, 16097183],
                [37, 16097184],
                [38, 16097185],
                [39, 16097186],
                [40, 16097187],
                [41, 16097188],
                [42, 16097189],
                [43, 16097190],
                [44, 16097191],
                [45, 16097192],
                [46, 16097193],
                [47, 16097194],
                [48, 16097195],
                [49, 16097196],
                [50, 16097197]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 16117350],
                [1, 16117351],
                [2, 16117352],
                [3, 16117353],
                [4, 16117354],
                [5, 16117355],
                [6, 16117356],
                [7, 16117357],
                [8, 16117358],
                [9, 16117359],
                [10, 16117360],
                [11, 16117361],
                [12, 16117362],
                [13, 16117363],
                [14, 16117364],
                [15, 16117365],
                [16, 16117366],
                [17, 16117367],
                [18, 16117368],
                [19, 16117369],
                [20, 16117370],
                [21, 16117371],
                [22, 16117372],
                [23, 16117373],
                [24, 16117374],
                [25, 16117375],
                [26, 16117376],
                [27, 16117377],
                [28, 16117378],
                [29, 16117379],
                [30, 16117380],
                [31, 16117381],
                [32, 16117382],
                [33, 16117383],
                [34, 16117384],
                [35, 16117385],
                [36, 16117386],
                [37, 16117387],
                [38, 16117388],
                [39, 16117389],
                [40, 16117390],
                [41, 16117391],
                [42, 16117392],
                [43, 16117393],
                [44, 16117394],
                [45, 16117395],
                [46, 16117396],
                [47, 16117397],
                [48, 16117398],
                [49, 16117399],
                [50, 16117400]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 16118483],
                [1, 16118484],
                [2, 16118485],
                [3, 16118486],
                [4, 16118487],
                [5, 16118488],
                [6, 16118489],
                [7, 16118490],
                [8, 16118491],
                [9, 16118492],
                [10, 16118493],
                [11, 16118494],
                [12, 16118495],
                [13, 16118496],
                [14, 16118497],
                [15, 16118498],
                [16, 16118499],
                [17, 16118500],
                [18, 16118501],
                [19, 16118502],
                [20, 16118503],
                [21, 16118504],
                [22, 16118505],
                [23, 16118506],
                [24, 16118507],
                [25, 16118508],
                [26, 16118509],
                [27, 16118510],
                [28, 16118511],
                [29, 16118512],
                [30, 16118513],
                [31, 16118514],
                [32, 16118515],
                [33, 16118516],
                [34, 16118517],
                [35, 16118518],
                [36, 16118519],
                [37, 16118520],
                [38, 16118521],
                [39, 16118522],
                [40, 16118523],
                [41, 16118524],
                [42, 16118525],
                [43, 16118526],
                [44, 16118527],
                [45, 16118528],
                [46, 16118529],
                [47, 16118530],
                [48, 16118531],
                [49, 16118532],
                [50, 16118533]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 16118499],
                [1, 16118500],
                [2, 16118501],
                [3, 16118502],
                [4, 16118503],
                [5, 16118504],
                [6, 16118505],
                [7, 16118506],
                [8, 16118507],
                [9, 16118508],
                [10, 16118509],
                [11, 16118510],
                [12, 16118511],
                [13, 16118512],
                [14, 16118513],
                [15, 16118514],
                [16, 16118515],
                [17, 16118516],
                [18, 16118517],
                [19, 16118518],
                [20, 16118519],
                [21, 16118520],
                [22, 16118521],
                [23, 16118522],
                [24, 16118523],
                [25, 16118524],
                [26, 16118525],
                [27, 16118526],
                [28, 16118527],
                [29, 16118528],
                [30, 16118529],
                [31, 16118530],
                [32, 16118531],
                [33, 16118532],
                [34, 16118533],
                [35, 16118534],
                [36, 16118535],
                [37, 16118536],
                [38, 16118537],
                [39, 16118538],
                [40, 16118539],
                [41, 16118540],
                [42, 16118541],
                [43, 16118542],
                [44, 16118543],
                [45, 16118544],
                [46, 16118545],
                [47, 16118546],
                [48, 16118547],
                [49, 16118548],
                [50, 16118549]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 16118499],
                [1, 16118500],
                [2, 16118501],
                [3, 16118502],
                [4, 16118503],
                [5, 16118504],
                [6, 16118505],
                [7, 16118506],
                [8, 16118507],
                [9, 16118508],
                [10, 16118509],
                [11, 16118510],
                [12, 16118511],
                [13, 16118512],
                [14, 16118513],
                [15, 16118514],
                [16, 16118515],
                [17, 16118516],
                [18, 16118517],
                [19, 16118518],
                [20, 16118519],
                [21, 16118520],
                [22, 16118521],
                [23, 16118522],
                [24, 16118523],
                [25, 16118524],
                [26, 16118525],
                [27, 16118526],
                [28, 16118527],
                [29, 16118528],
                [30, 16118529],
                [31, 16118530],
                [32, 16118531],
                [33, 16118532],
                [34, 16118533],
                [35, 16118534],
                [36, 16118535],
                [37, 16118536],
                [38, 16118537],
                [39, 16118538],
                [40, 16118539],
                [41, 16118540],
                [42, 16118541],
                [43, 16118542],
                [44, 16118543],
                [45, 16118544],
                [46, 16118545],
                [47, 16118546],
                [48, 16118547],
                [49, 16118548],
                [50, 16118549]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 16118499],
                [1, 16118500],
                [2, 16118501],
                [3, 16118502],
                [4, 16118503],
                [5, 16118504],
                [6, 16118505],
                [7, 16118506],
                [8, 16118507],
                [9, 16118508],
                [10, 16118509],
                [11, 16118510],
                [12, 16118511],
                [13, 16118512],
                [14, 16118513],
                [15, 16118514],
                [16, 16118515],
                [17, 16118516],
                [18, 16118517],
                [19, 16118518],
                [20, 16118519],
                [21, 16118520],
                [22, 16118521],
                [23, 16118522],
                [24, 16118523],
                [25, 16118524],
                [26, 16118525],
                [27, 16118526],
                [28, 16118527],
                [29, 16118528],
                [30, 16118529],
                [31, 16118530],
                [32, 16118531],
                [33, 16118532],
                [34, 16118533],
                [35, 16118534],
                [36, 16118535],
                [37, 16118536],
                [38, 16118537],
                [39, 16118538],
                [40, 16118539],
                [41, 16118540],
                [42, 16118541],
                [43, 16118542],
                [44, 16118543],
                [45, 16118544],
                [46, 16118545],
                [47, 16118546],
                [48, 16118547],
                [49, 16118548],
                [50, 16118549]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 16123411],
                [1, 16123412],
                [2, 16123413],
                [3, 16123414],
                [4, 16123415],
                [5, 16123416],
                [6, 16123417],
                [7, 16123418],
                [8, 16123419],
                [9, 16123420],
                [10, 16123421],
                [11, 16123422],
                [12, 16123423],
                [13, 16123424],
                [14, 16123425],
                [15, 16123426],
                [16, 16123427],
                [17, 16123428],
                [18, 16123429],
                [19, 16123430],
                [20, 16123431],
                [21, 16123432],
                [22, 16123433],
                [23, 16123434],
                [24, 16123435],
                [25, 16123436],
                [26, 16123437],
                [27, 16123438],
                [28, 16123439],
                [29, 16123440],
                [30, 16123441],
                [31, 16123442],
                [32, 16123443],
                [33, 16123444],
                [34, 16123445],
                [35, 16123446],
                [36, 16123447],
                [37, 16123448],
                [38, 16123449],
                [39, 16123450],
                [40, 16123451],
                [41, 16123452],
                [42, 16123453],
                [43, 16123454],
                [44, 16123455],
                [45, 16123456],
                [46, 16123457],
                [47, 16123458],
                [48, 16123459],
                [49, 16123460],
                [50, 16123461]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [6, 16123417],
                [7, 16123418],
                [8, 16123419],
                [9, 16123420],
                [10, 16123421],
                [11, 16123422],
                [12, 16123423],
                [13, 16123424],
                [14, 16123425],
                [15, 16123426],
                [16, 16123427],
                [17, 16123428],
                [18, 16123429],
                [19, 16123430],
                [20, 16123431],
                [21, 16123432],
                [22, 16123433],
                [23, 16123434],
                [24, 16123435],
                [25, 16123436],
                [26, 16123437],
                [27, 16123438],
                [28, 16123439],
                [29, 16123440],
                [30, 16123441],
                [31, 16123442],
                [32, 16123443],
                [33, 16123444],
                [34, 16123445],
                [35, 16123446],
                [36, 16123447],
                [37, 16123448],
                [38, 16123449],
                [39, 16123450],
                [40, 16123451],
                [41, 16123452],
                [42, 16123453],
                [43, 16123454],
                [44, 16123455],
                [45, 16123456],
                [46, 16123457],
                [47, 16123458],
                [48, 16123459],
                [49, 16123460],
                [50, 16123461]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 16165860],
                [1, 16165861],
                [2, 16165862],
                [3, 16165863],
                [4, 16165864],
                [5, 16165865],
                [6, 16165866],
                [7, 16165867],
                [8, 16165868],
                [9, 16165869],
                [10, 16165870],
                [11, 16165871],
                [12, 16165872],
                [13, 16165873],
                [14, 16165874],
                [15, 16165875],
                [16, 16165876],
                [17, 16165877],
                [18, 16165878],
                [19, 16165879],
                [20, 16165880],
                [21, 16165881],
                [22, 16165882],
                [23, 16165883],
                [24, 16165884],
                [25, 16165885],
                [26, 16165886],
                [27, 16165887],
                [28, 16165888],
                [29, 16165889],
                [30, 16165890],
                [31, 16165891],
                [32, 16165892],
                [33, 16165893],
                [34, 16165894],
                [35, 16165895],
                [36, 16165896],
                [37, 16165897],
                [38, 16165898],
                [39, 16165899],
                [40, 16165900]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 16180871],
                [1, 16180872],
                [2, 16180873],
                [3, 16180874],
                [4, 16180875],
                [5, 16180876],
                [6, 16180877],
                [7, 16180878],
                [8, 16180879],
                [9, 16180880],
                [10, 16180881],
                [11, 16180882],
                [12, 16180883],
                [13, 16180884],
                [14, 16180885],
                [15, 16180886],
                [16, 16180887],
                [17, 16180888],
                [18, 16180889],
                [19, 16180890],
                [20, 16180891],
                [21, 16180892],
                [22, 16180893],
                [23, 16180894],
                [24, 16180895],
                [25, 16180896],
                [26, 16180897],
                [27, 16180898],
                [28, 16180899],
                [29, 16180900],
                [30, 16180901],
                [31, 16180902],
                [32, 16180903],
                [33, 16180904],
                [34, 16180905],
                [35, 16180906],
                [36, 16180907],
                [37, 16180908],
                [38, 16180909],
                [39, 16180910],
                [40, 16180911],
                [41, 16180912],
                [42, 16180913],
                [43, 16180914],
                [44, 16180915],
                [45, 16180916],
                [46, 16180917],
                [47, 16180918],
                [48, 16180919],
                [49, 16180920],
                [50, 16180921]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 16189705],
                [1, 16189706],
                [2, 16189707],
                [3, 16189708],
                [4, 16189709],
                [5, 16189710],
                [6, 16189711],
                [7, 16189712],
                [8, 16189713],
                [9, 16189714],
                [10, 16189715],
                [11, 16189716],
                [12, 16189717],
                [13, 16189718],
                [14, 16189719],
                [15, 16189720],
                [16, 16189721],
                [17, 16189722],
                [18, 16189723],
                [19, 16189724],
                [20, 16189725],
                [21, 16189726],
                [22, 16189727],
                [23, 16189728],
                [24, 16189729],
                [25, 16189730],
                [26, 16189731],
                [27, 16189732],
                [28, 16189733],
                [29, 16189734],
                [30, 16189735],
                [31, 16189736],
                [32, 16189737],
                [33, 16189738],
                [34, 16189739],
                [35, 16189740],
                [36, 16189741],
                [37, 16189742],
                [38, 16189743],
                [39, 16189744],
                [40, 16189745],
                [41, 16189746],
                [42, 16189747],
                [43, 16189748],
                [44, 16189749],
                [45, 16189750],
                [46, 16189751],
                [47, 16189752],
                [48, 16189753],
                [49, 16189754],
                [50, 16189755]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 16231271],
                [1, 16231272],
                [2, 16231273],
                [3, 16231274],
                [4, 16231275],
                [5, 16231276],
                [6, 16231277],
                [7, 16231278],
                [8, 16231279],
                [9, 16231280],
                [10, 16231281],
                [11, 16231282],
                [12, 16231283],
                [13, 16231284],
                [14, 16231285],
                [15, 16231286],
                [16, 16231287],
                [17, 16231288],
                [18, 16231289],
                [19, 16231290],
                [20, 16231291],
                [21, 16231292],
                [22, 16231293],
                [23, 16231294],
                [24, 16231295],
                [25, 16231296],
                [26, 16231297],
                [27, 16231298],
                [28, 16231299],
                [29, 16231300],
                [30, 16231301],
                [31, 16231302],
                [32, 16231303],
                [33, 16231304],
                [34, 16231305],
                [35, 16231306],
                [36, 16231307],
                [37, 16231308],
                [38, 16231309],
                [39, 16231310],
                [40, 16231311],
                [41, 16231312],
                [42, 16231313],
                [43, 16231314],
                [44, 16231315],
                [45, 16231316],
                [46, 16231317],
                [47, 16231318],
                [48, 16231319],
                [49, 16231320],
                [50, 16231321]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 16237657],
                [1, 16237658],
                [2, 16237659],
                [3, 16237660],
                [4, 16237661],
                [5, 16237662],
                [6, 16237663],
                [7, 16237664],
                [8, 16237665],
                [9, 16237666],
                [10, 16237667],
                [11, 16237668],
                [12, 16237669],
                [13, 16237670],
                [14, 16237671],
                [15, 16237672],
                [16, 16237673],
                [17, 16237674],
                [18, 16237675],
                [19, 16237676],
                [20, 16237677],
                [21, 16237678],
                [22, 16237679],
                [23, 16237680],
                [24, 16237681],
                [25, 16237682],
                [26, 16237683],
                [27, 16237684],
                [28, 16237685],
                [29, 16237686],
                [30, 16237687],
                [31, 16237688],
                [32, 16237689],
                [33, 16237690],
                [34, 16237691],
                [35, 16237692],
                [36, 16237693],
                [37, 16237694],
                [38, 16237695],
                [39, 16237696],
                [40, 16237697],
                [41, 16237698],
                [42, 16237699],
                [43, 16237700],
                [44, 16237701],
                [45, 16237702],
                [46, 16237703],
                [47, 16237704],
                [48, 16237705],
                [49, 16237706],
                [50, 16237707]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [9, 16255012],
                [10, 16255013],
                [11, 16255014],
                [12, 16255015],
                [13, 16255016],
                [14, 16255017],
                [15, 16255018],
                [16, 16255019],
                [17, 16255020],
                [18, 16255021],
                [19, 16255022],
                [20, 16255023],
                [21, 16255024],
                [22, 16255025],
                [23, 16255026],
                [24, 16255027],
                [25, 16255028],
                [26, 16255029],
                [27, 16255030],
                [28, 16255031],
                [29, 16255032],
                [30, 16255033],
                [31, 16255034],
                [32, 16255035],
                [33, 16255036],
                [34, 16255037],
                [35, 16255038],
                [36, 16255039],
                [37, 16255040],
                [38, 16255041],
                [39, 16255042],
                [40, 16255043],
                [41, 16255044],
                [42, 16255045],
                [43, 16255046],
                [44, 16255047],
                [45, 16255048],
                [46, 16255049],
                [47, 16255050],
                [48, 16255051],
                [49, 16255052],
                [50, 16255053]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 16255391],
                [1, 16255392],
                [2, 16255393],
                [3, 16255394],
                [4, 16255395],
                [5, 16255396],
                [6, 16255397],
                [7, 16255398],
                [8, 16255399],
                [9, 16255400],
                [10, 16255401],
                [11, 16255402],
                [12, 16255403],
                [13, 16255404],
                [14, 16255405],
                [15, 16255406],
                [16, 16255407],
                [17, 16255408],
                [18, 16255409],
                [19, 16255410],
                [20, 16255411],
                [21, 16255412],
                [22, 16255413],
                [23, 16255414],
                [24, 16255415],
                [25, 16255416],
                [26, 16255417],
                [27, 16255418],
                [28, 16255419],
                [29, 16255420],
                [30, 16255421],
                [31, 16255422],
                [32, 16255423],
                [33, 16255424],
                [34, 16255425],
                [35, 16255426],
                [36, 16255427],
                [37, 16255428],
                [38, 16255429],
                [39, 16255430],
                [40, 16255431],
                [41, 16255432],
                [42, 16255433],
                [43, 16255434],
                [44, 16255435],
                [45, 16255436],
                [46, 16255437],
                [47, 16255438],
                [48, 16255439],
                [49, 16255440],
                [50, 16255441]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 16255392],
                [1, 16255393],
                [2, 16255394],
                [3, 16255395],
                [4, 16255396],
                [5, 16255397],
                [6, 16255398],
                [7, 16255399],
                [8, 16255400],
                [9, 16255401],
                [10, 16255402],
                [11, 16255403],
                [12, 16255404],
                [13, 16255405],
                [14, 16255406],
                [15, 16255407],
                [16, 16255408],
                [17, 16255409],
                [18, 16255410],
                [19, 16255411],
                [20, 16255412],
                [21, 16255413],
                [22, 16255414],
                [23, 16255415],
                [24, 16255416],
                [25, 16255417],
                [26, 16255418],
                [27, 16255419],
                [28, 16255420],
                [29, 16255421],
                [30, 16255422],
                [31, 16255423],
                [32, 16255424],
                [33, 16255425],
                [34, 16255426],
                [35, 16255427],
                [36, 16255428],
                [37, 16255429],
                [38, 16255430],
                [39, 16255431],
                [40, 16255432],
                [41, 16255433],
                [42, 16255434],
                [43, 16255435],
                [44, 16255436],
                [45, 16255437],
                [46, 16255438],
                [47, 16255439],
                [48, 16255440],
                [49, 16255441]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 16256084],
                [1, 16256085],
                [2, 16256086],
                [3, 16256087],
                [4, 16256088],
                [5, 16256089],
                [6, 16256090],
                [7, 16256091],
                [8, 16256092],
                [9, 16256093],
                [10, 16256094],
                [11, 16256095],
                [12, 16256096],
                [13, 16256097],
                [14, 16256098],
                [15, 16256099],
                [16, 16256100],
                [17, 16256101],
                [18, 16256102],
                [19, 16256103],
                [20, 16256104],
                [21, 16256105],
                [22, 16256106],
                [23, 16256107],
                [24, 16256108],
                [25, 16256109],
                [26, 16256110],
                [27, 16256111],
                [28, 16256112],
                [29, 16256113],
                [30, 16256114],
                [31, 16256115],
                [32, 16256116],
                [33, 16256117],
                [34, 16256118],
                [35, 16256119],
                [36, 16256120],
                [37, 16256121],
                [38, 16256122],
                [39, 16256123],
                [40, 16256124],
                [41, 16256125],
                [42, 16256126],
                [43, 16256127],
                [44, 16256128]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [3, 16256224],
                [4, 16256225],
                [5, 16256226],
                [6, 16256227],
                [7, 16256228],
                [8, 16256229],
                [9, 16256230],
                [10, 16256231],
                [11, 16256232],
                [12, 16256233],
                [13, 16256234],
                [14, 16256235],
                [15, 16256236],
                [16, 16256237],
                [17, 16256238],
                [18, 16256239],
                [19, 16256240],
                [20, 16256241],
                [21, 16256242],
                [22, 16256243],
                [23, 16256244],
                [24, 16256245],
                [25, 16256246],
                [26, 16256247],
                [27, 16256248],
                [28, 16256249],
                [29, 16256250],
                [30, 16256251],
                [31, 16256252],
                [32, 16256253],
                [33, 16256254],
                [34, 16256255],
                [35, 16256256],
                [36, 16256257],
                [37, 16256258],
                [38, 16256259],
                [39, 16256260],
                [40, 16256261],
                [41, 16256262],
                [42, 16256263],
                [43, 16256264],
                [44, 16256265],
                [45, 16256266],
                [46, 16256267],
                [47, 16256268],
                [48, 16256269],
                [49, 16256270],
                [50, 16256271]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 16325199],
                [1, 16325200],
                [2, 16325201],
                [3, 16325202],
                [4, 16325203],
                [5, 16325204],
                [6, 16325205],
                [7, 16325206],
                [8, 16325207],
                [9, 16325208],
                [10, 16325209],
                [11, 16325210],
                [12, 16325211],
                [13, 16325212],
                [14, 16325213],
                [15, 16325214],
                [16, 16325215],
                [17, 16325216],
                [18, 16325217],
                [19, 16325218],
                [20, 16325219],
                [21, 16325220],
                [22, 16325221],
                [23, 16325222],
                [24, 16325223],
                [25, 16325224],
                [26, 16325225],
                [27, 16325226],
                [28, 16325227],
                [29, 16325228],
                [30, 16325229],
                [31, 16325230],
                [32, 16325231],
                [33, 16325232],
                [34, 16325233],
                [35, 16325234],
                [36, 16325235],
                [37, 16325236],
                [38, 16325237],
                [39, 16325238],
                [40, 16325239],
                [41, 16325240]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [13, 16352865],
                [14, 16352866],
                [15, 16352867],
                [16, 16352868],
                [17, 16352869],
                [18, 16352870],
                [19, 16352871],
                [20, 16352872],
                [21, 16352873],
                [22, 16352874],
                [23, 16352875],
                [24, 16352876],
                [25, 16352877],
                [26, 16352878],
                [27, 16352879],
                [28, 16352880],
                [29, 16352881],
                [30, 16352882],
                [31, 16352883],
                [32, 16352884],
                [33, 16352885],
                [34, 16352886],
                [35, 16352887],
                [36, 16352888],
                [37, 16352889],
                [38, 16352890],
                [39, 16352891],
                [40, 16352892],
                [41, 16352893],
                [42, 16352894],
                [43, 16352895],
                [44, 16352896],
                [45, 16352897],
                [46, 16352898],
                [47, 16352899],
                [48, 16352900],
                [49, 16352901],
                [50, 16352902]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 16352968],
                [1, 16352969],
                [2, 16352970],
                [3, 16352971],
                [4, 16352972],
                [5, 16352973],
                [6, 16352974],
                [7, 16352975],
                [8, 16352976],
                [9, 16352977],
                [10, 16352978],
                [11, 16352979],
                [12, 16352980],
                [13, 16352981],
                [14, 16352982],
                [15, 16352983],
                [16, 16352984],
                [17, 16352985],
                [18, 16352986],
                [19, 16352987],
                [20, 16352988],
                [21, 16352989],
                [22, 16352990],
                [23, 16352991],
                [24, 16352992],
                [25, 16352993],
                [26, 16352994],
                [27, 16352995],
                [28, 16352996],
                [29, 16352997],
                [30, 16352998],
                [31, 16352999],
                [32, 16353000],
                [33, 16353001],
                [34, 16353002],
                [35, 16353003],
                [36, 16353004],
                [37, 16353005],
                [38, 16353006],
                [39, 16353007],
                [40, 16353008],
                [41, 16353009],
                [42, 16353010],
                [43, 16353011]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [5, 16414998],
                [6, 16414999],
                [7, 16415000],
                [8, 16415001],
                [9, 16415002],
                [10, 16415003],
                [11, 16415004],
                [12, 16415005],
                [13, 16415006],
                [14, 16415007],
                [15, 16415008],
                [16, 16415009],
                [17, 16415010],
                [18, 16415011],
                [19, 16415012],
                [20, 16415013],
                [21, 16415014],
                [22, 16415015],
                [23, 16415016],
                [24, 16415017],
                [25, 16415018],
                [26, 16415019],
                [27, 16415020],
                [28, 16415021],
                [29, 16415022],
                [30, 16415023],
                [31, 16415024],
                [32, 16415025],
                [33, 16415026],
                [34, 16415027],
                [35, 16415028],
                [36, 16415029],
                [37, 16415030],
                [38, 16415031],
                [39, 16415032],
                [40, 16415033],
                [41, 16415034],
                [42, 16415035],
                [43, 16415036],
                [44, 16415037],
                [45, 16415038],
                [46, 16415039],
                [47, 16415040],
                [48, 16415041],
                [49, 16415042],
                [50, 16415043]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 17031591],
                [1, 17031592],
                [2, 17031593],
                [3, 17031594],
                [4, 17031595],
                [5, 17031596],
                [6, 17031597],
                [7, 17031598],
                [8, 17031599],
                [9, 17031600],
                [10, 17031601],
                [11, 17031602],
                [12, 17031603],
                [13, 17031604],
                [14, 17031605],
                [15, 17031606],
                [16, 17031607],
                [17, 17031608],
                [18, 17031609],
                [19, 17031610],
                [20, 17031611],
                [21, 17031612],
                [22, 17031613],
                [27, 17031614],
                [28, 17031615],
                [29, 17031616],
                [30, 17031617],
                [31, 17031618],
                [32, 17031619],
                [33, 17031620],
                [34, 17031621],
                [35, 17031622],
                [36, 17031623],
                [37, 17031624],
                [38, 17031625],
                [39, 17031626],
                [40, 17031627],
                [41, 17031628],
                [42, 17031629],
                [43, 17031630],
                [44, 17031631],
                [45, 17031632],
                [46, 17031633],
                [47, 17031634],
                [48, 17031635],
                [49, 17031636],
                [50, 17031637]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 17057382],
                [1, 17057383],
                [2, 17057384],
                [3, 17057385],
                [4, 17057386],
                [5, 17057387],
                [6, 17057388],
                [7, 17057389],
                [8, 17057390],
                [9, 17057391],
                [10, 17057392],
                [11, 17057393],
                [12, 17057394],
                [13, 17057395],
                [14, 17057396],
                [15, 17057397],
                [16, 17057398],
                [17, 17057399],
                [19, 17057400],
                [20, 17057401],
                [21, 17057402],
                [22, 17057403],
                [23, 17057404],
                [24, 17057405],
                [25, 17057406],
                [26, 17057407],
                [27, 17057408],
                [28, 17057409],
                [29, 17057410],
                [30, 17057411],
                [31, 17057412],
                [32, 17057413],
                [33, 17057414],
                [34, 17057415],
                [35, 17057416],
                [36, 17057417],
                [37, 17057418],
                [38, 17057419],
                [39, 17057420],
                [40, 17057421],
                [41, 17057422],
                [42, 17057423],
                [43, 17057424],
                [44, 17057425],
                [45, 17057426],
                [46, 17057427],
                [47, 17057428],
                [48, 17057429],
                [49, 17057430],
                [50, 17057431]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 17092766],
                [1, 17092767],
                [2, 17092768],
                [3, 17092769],
                [4, 17092770],
                [5, 17092771],
                [6, 17092772],
                [7, 17092773],
                [8, 17092774],
                [9, 17092775],
                [10, 17092776],
                [11, 17092777],
                [12, 17092778],
                [13, 17092779],
                [14, 17092780],
                [15, 17092781],
                [16, 17092782],
                [17, 17094966],
                [18, 17094967],
                [19, 17094968],
                [20, 17094969],
                [21, 17094970],
                [22, 17094971],
                [23, 17094972],
                [24, 17094973],
                [25, 17094974],
                [26, 17094975],
                [27, 17094976],
                [28, 17094977],
                [29, 17094978],
                [30, 17094979],
                [31, 17094980],
                [32, 17094981],
                [33, 17094982],
                [34, 17094983],
                [35, 17094984],
                [36, 17094985],
                [37, 17094986],
                [38, 17094987],
                [39, 17094988],
                [40, 17094989],
                [41, 17094990],
                [42, 17094991],
                [43, 17094992],
                [44, 17094993],
                [45, 17094994],
                [46, 17094995],
                [47, 17094996],
                [48, 17094997],
                [49, 17094998],
                [50, 17094999]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 17092782],
                [1, 17094966],
                [2, 17094967],
                [3, 17094968],
                [4, 17094969],
                [5, 17094970],
                [6, 17094971],
                [7, 17094972],
                [8, 17094973],
                [9, 17094974],
                [10, 17094975],
                [11, 17094976],
                [12, 17094977],
                [13, 17094978],
                [14, 17094979],
                [15, 17094980],
                [16, 17094981],
                [17, 17094982],
                [18, 17094983],
                [19, 17094984],
                [20, 17094985],
                [21, 17094986],
                [22, 17094987],
                [23, 17094988],
                [24, 17094989],
                [25, 17094990],
                [26, 17094991],
                [27, 17094992],
                [28, 17094993],
                [29, 17094994],
                [30, 17094995],
                [31, 17094996],
                [32, 17094997],
                [33, 17094998],
                [34, 17094999],
                [35, 17095000],
                [36, 17095001],
                [37, 17095002],
                [38, 17095003],
                [39, 17095004],
                [40, 17095005],
                [41, 17095006],
                [42, 17095007],
                [43, 17095008],
                [44, 17095009],
                [45, 17095010],
                [46, 17095011],
                [47, 17095012],
                [48, 17095013],
                [49, 17095014],
                [50, 17095015]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 17092782],
                [1, 17094966],
                [2, 17094967],
                [3, 17094968],
                [4, 17094969],
                [5, 17094970],
                [6, 17094971],
                [7, 17094972],
                [8, 17094973],
                [9, 17094974],
                [10, 17094975],
                [11, 17094976],
                [12, 17094977],
                [13, 17094978],
                [14, 17094979],
                [15, 17094980],
                [16, 17094981],
                [17, 17094982],
                [18, 17094983],
                [19, 17094984],
                [20, 17094985],
                [21, 17094986],
                [22, 17094987],
                [23, 17094988],
                [24, 17094989],
                [25, 17094990],
                [26, 17094991],
                [27, 17094992],
                [28, 17094993],
                [29, 17094994],
                [30, 17094995],
                [31, 17094996],
                [32, 17094997],
                [33, 17094998],
                [34, 17094999],
                [35, 17095000],
                [36, 17095001],
                [37, 17095002],
                [38, 17095003],
                [39, 17095004],
                [40, 17095005],
                [41, 17095006],
                [42, 17095007],
                [43, 17095008],
                [44, 17095009],
                [45, 17095010],
                [46, 17095011],
                [47, 17095012],
                [48, 17095013],
                [49, 17095014],
                [50, 17095015]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [9, 17137287],
                [10, 17137288],
                [11, 17137289],
                [12, 17137290],
                [13, 17137291],
                [14, 17137292],
                [15, 17137293],
                [16, 17137294],
                [17, 17137295],
                [18, 17137296],
                [19, 17137297],
                [20, 17137298],
                [21, 17137299],
                [22, 17137300],
                [23, 17137301],
                [24, 17137302],
                [25, 17137303],
                [26, 17137304],
                [27, 17137305],
                [28, 17137306],
                [29, 17137307],
                [30, 17137308],
                [31, 17137309],
                [32, 17137310],
                [33, 17137311],
                [34, 17137312],
                [35, 17137313],
                [36, 17137314],
                [37, 17137315],
                [38, 17137316],
                [39, 17137317],
                [40, 17137318],
                [41, 17137319]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [2, 17306238],
                [3, 17306239],
                [4, 17306240],
                [5, 17306241],
                [6, 17306242],
                [7, 17306243],
                [8, 17306244],
                [9, 17306245],
                [10, 17306246],
                [11, 17306247],
                [12, 17306248],
                [13, 17306249],
                [14, 17306250],
                [15, 17306251],
                [16, 17306252],
                [17, 17306253],
                [18, 17306254],
                [19, 17306255],
                [20, 17306256],
                [21, 17306257],
                [22, 17306258],
                [23, 17306259],
                [24, 17306260],
                [25, 17306261],
                [26, 17306262],
                [27, 17306263],
                [28, 17306264],
                [29, 17306265],
                [30, 17306266],
                [31, 17306267],
                [32, 17306268],
                [33, 17306269],
                [34, 17306270],
                [35, 17306271],
                [36, 17306272],
                [37, 17306273],
                [38, 17306274],
                [39, 17306275],
                [40, 17306276],
                [41, 17306277],
                [42, 17306278],
                [43, 17306279],
                [44, 17306280],
                [45, 17306281],
                [46, 17306282],
                [47, 17306283],
                [48, 17306284],
                [49, 17306285]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [4, 17561868],
                [5, 17561869],
                [6, 17561870],
                [7, 17561871],
                [8, 17561872],
                [9, 17561873],
                [10, 17561874],
                [11, 17561875],
                [12, 17561876],
                [13, 17561877],
                [14, 17561878],
                [15, 17561879],
                [16, 17561880],
                [17, 17561881],
                [18, 17561882],
                [19, 17561883],
                [20, 17561884],
                [21, 17561885],
                [22, 17561886],
                [23, 17561887],
                [24, 17561888],
                [25, 17561889],
                [26, 17561890],
                [27, 17561891],
                [28, 17561892],
                [29, 17561893],
                [30, 17561894],
                [31, 17561895],
                [32, 17561896],
                [33, 17561897],
                [34, 17561898],
                [35, 17561899],
                [36, 17561900],
                [37, 17561901],
                [38, 17561902],
                [39, 17561903],
                [40, 17561904],
                [41, 17561905],
                [42, 17561906],
                [43, 17561907],
                [44, 17561908],
                [45, 17561909],
                [46, 17561910],
                [47, 17561911],
                [48, 17561912]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 17566078],
                [1, 17566079],
                [2, 17566080],
                [3, 17566081],
                [4, 17566082],
                [5, 17566083],
                [6, 17566084],
                [7, 17566085],
                [8, 17566086],
                [9, 17566087],
                [10, 17566088],
                [11, 17566089],
                [12, 17566090],
                [13, 17566091],
                [14, 17566092],
                [15, 17566093],
                [16, 17566094],
                [17, 17566095],
                [18, 17566096],
                [19, 17566097],
                [20, 17566098],
                [21, 17566099],
                [22, 17566100],
                [23, 17566101],
                [24, 17566102],
                [25, 17566103],
                [26, 17566104],
                [27, 17566105],
                [28, 17566106],
                [29, 17566107],
                [30, 17566108],
                [31, 17566109],
                [32, 17566110],
                [33, 17566111],
                [34, 17566112],
                [35, 17566113],
                [36, 17566114],
                [37, 17566115],
                [38, 17566116],
                [39, 17566117],
                [40, 17566118],
                [41, 17577951],
                [42, 17577952],
                [43, 17577953],
                [44, 17577954],
                [45, 17577955],
                [46, 17577956],
                [47, 17577957],
                [48, 17577958],
                [49, 17577959],
                [50, 17577960]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 17566108],
                [1, 17566109],
                [2, 17566110],
                [3, 17566111],
                [4, 17566112],
                [5, 17566113],
                [6, 17566114],
                [7, 17566115],
                [8, 17566116],
                [9, 17566117],
                [10, 17566118],
                [11, 17577951],
                [12, 17577952],
                [13, 17577953],
                [14, 17577954],
                [15, 17577955],
                [16, 17577956],
                [17, 17577957],
                [18, 17577958],
                [19, 17577959],
                [20, 17577960],
                [21, 17577961],
                [22, 17577962],
                [23, 17577963],
                [24, 17577964],
                [25, 17577965],
                [26, 17577966],
                [27, 17577967],
                [28, 17577968],
                [29, 17577969],
                [30, 17577970],
                [31, 17577971],
                [32, 17577972],
                [33, 17577973],
                [34, 17577974],
                [35, 17577975],
                [36, 17578686],
                [37, 17578687],
                [38, 17578688],
                [39, 17578689],
                [40, 17578690],
                [41, 17578691],
                [42, 17578692],
                [43, 17578693],
                [44, 17578694],
                [45, 17578695],
                [46, 17578696],
                [47, 17578697],
                [48, 17578698],
                [49, 17578699],
                [50, 17578700]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 17566111],
                [1, 17566112],
                [2, 17566113],
                [3, 17566114],
                [4, 17566115],
                [5, 17566116],
                [6, 17566117],
                [7, 17566118],
                [8, 17577951],
                [9, 17577952],
                [10, 17577953],
                [11, 17577954],
                [12, 17577955],
                [13, 17577956],
                [14, 17577957],
                [15, 17577958],
                [16, 17577959],
                [17, 17577960],
                [18, 17577961],
                [19, 17577962],
                [20, 17577963],
                [21, 17577964],
                [22, 17577965],
                [23, 17577966],
                [24, 17577967],
                [25, 17577968],
                [26, 17577969],
                [27, 17577970],
                [28, 17577971],
                [29, 17577972],
                [30, 17577973],
                [31, 17577974],
                [32, 17577975],
                [33, 17578686],
                [34, 17578687],
                [35, 17578688],
                [36, 17578689],
                [37, 17578690],
                [38, 17578691],
                [39, 17578692],
                [40, 17578693],
                [41, 17578694],
                [42, 17578695],
                [43, 17578696],
                [44, 17578697],
                [45, 17578698],
                [46, 17578699],
                [47, 17578700],
                [48, 17578701],
                [49, 17578702],
                [50, 17578703]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 17566111],
                [1, 17566112],
                [2, 17566113],
                [3, 17566114],
                [4, 17566115],
                [5, 17566116],
                [6, 17566117],
                [7, 17566118],
                [8, 17577951],
                [9, 17577952],
                [10, 17577953],
                [11, 17577954],
                [12, 17577955],
                [13, 17577956],
                [14, 17577957],
                [15, 17577958],
                [16, 17577959],
                [17, 17577960],
                [18, 17577961],
                [19, 17577962],
                [20, 17577963],
                [21, 17577964],
                [22, 17577965],
                [23, 17577966],
                [24, 17577967],
                [25, 17577968],
                [26, 17577969],
                [27, 17577970],
                [28, 17577971],
                [29, 17577972],
                [30, 17577973],
                [31, 17577974],
                [32, 17577975],
                [33, 17578686],
                [34, 17578687],
                [35, 17578688],
                [36, 17578689],
                [37, 17578690],
                [38, 17578691],
                [39, 17578692],
                [40, 17578693],
                [41, 17578694],
                [42, 17578695],
                [43, 17578696],
                [44, 17578697],
                [45, 17578698],
                [46, 17578699],
                [47, 17578700],
                [48, 17578701],
                [49, 17578702],
                [50, 17578703]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 17566111],
                [1, 17566112],
                [2, 17566113],
                [3, 17566114],
                [4, 17566115],
                [5, 17566116],
                [6, 17566117],
                [7, 17566118],
                [8, 17577951],
                [9, 17577952],
                [10, 17577953],
                [11, 17577954],
                [12, 17577955],
                [13, 17577956],
                [14, 17577957],
                [15, 17577958],
                [16, 17577959],
                [17, 17577960],
                [18, 17577961],
                [19, 17577962],
                [20, 17577963],
                [21, 17577964],
                [22, 17577965],
                [23, 17577966],
                [24, 17577967],
                [25, 17577968],
                [26, 17577969],
                [27, 17577970],
                [28, 17577971],
                [29, 17577972],
                [30, 17577973],
                [31, 17577974],
                [32, 17577975],
                [33, 17578686],
                [34, 17578687],
                [35, 17578688],
                [36, 17578689],
                [37, 17578690],
                [38, 17578691],
                [39, 17578692],
                [40, 17578693],
                [41, 17578694],
                [42, 17578695],
                [43, 17578696],
                [44, 17578697],
                [45, 17578698],
                [46, 17578699],
                [47, 17578700],
                [48, 17578701],
                [49, 17578702],
                [50, 17578703]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 17566111],
                [1, 17566112],
                [2, 17566113],
                [3, 17566114],
                [4, 17566115],
                [5, 17566116],
                [6, 17566117],
                [7, 17566118],
                [8, 17577951],
                [9, 17577952],
                [10, 17577953],
                [11, 17577954],
                [12, 17577955],
                [13, 17577956],
                [14, 17577957],
                [15, 17577958],
                [16, 17577959],
                [17, 17577960],
                [18, 17577961],
                [19, 17577962],
                [20, 17577963],
                [21, 17577964],
                [22, 17577965],
                [23, 17577966],
                [24, 17577967],
                [25, 17577968],
                [26, 17577969],
                [27, 17577970],
                [28, 17577971],
                [29, 17577972],
                [30, 17577973],
                [31, 17577974],
                [32, 17577975],
                [33, 17578686],
                [34, 17578687],
                [35, 17578688],
                [36, 17578689],
                [37, 17578690],
                [38, 17578691],
                [39, 17578692],
                [40, 17578693],
                [41, 17578694],
                [42, 17578695],
                [43, 17578696],
                [44, 17578697],
                [45, 17578698],
                [46, 17578699],
                [47, 17578700],
                [48, 17578701],
                [49, 17578702],
                [50, 17578703]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 17566112],
                [1, 17566113],
                [2, 17566114],
                [3, 17566115],
                [4, 17566116],
                [5, 17566117],
                [6, 17566118],
                [7, 17577951],
                [8, 17577952],
                [9, 17577953],
                [10, 17577954],
                [11, 17577955],
                [12, 17577956],
                [13, 17577957],
                [14, 17577958],
                [15, 17577959],
                [16, 17577960],
                [17, 17577961],
                [18, 17577962],
                [19, 17577963],
                [20, 17577964],
                [21, 17577965],
                [22, 17577966],
                [23, 17577967],
                [24, 17577968],
                [25, 17577969],
                [26, 17577970],
                [27, 17577971],
                [28, 17577972],
                [29, 17577973],
                [30, 17577974],
                [31, 17577975],
                [32, 17578686],
                [33, 17578687],
                [34, 17578688],
                [35, 17578689],
                [36, 17578690],
                [37, 17578691],
                [38, 17578692],
                [39, 17578693],
                [40, 17578694],
                [41, 17578695],
                [42, 17578696],
                [43, 17578697],
                [44, 17578698],
                [45, 17578699],
                [46, 17578700],
                [47, 17578701],
                [48, 17578702],
                [49, 17578703],
                [50, 17578704]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 17566113],
                [1, 17566114],
                [2, 17566115],
                [3, 17566116],
                [4, 17566117],
                [5, 17566118],
                [6, 17577951],
                [7, 17577952],
                [8, 17577953],
                [9, 17577954],
                [10, 17577955],
                [11, 17577956],
                [12, 17577957],
                [13, 17577958],
                [14, 17577959],
                [15, 17577960],
                [16, 17577961],
                [17, 17577962],
                [18, 17577963],
                [19, 17577964],
                [20, 17577965],
                [21, 17577966],
                [22, 17577967],
                [23, 17577968],
                [24, 17577969],
                [25, 17577970],
                [26, 17577971],
                [27, 17577972],
                [28, 17577973],
                [29, 17577974],
                [30, 17577975],
                [31, 17578686],
                [32, 17578687],
                [33, 17578688],
                [34, 17578689],
                [35, 17578690],
                [36, 17578691],
                [37, 17578692],
                [38, 17578693],
                [39, 17578694],
                [40, 17578695],
                [41, 17578696],
                [42, 17578697],
                [43, 17578698],
                [44, 17578699],
                [45, 17578700],
                [46, 17578701],
                [47, 17578702],
                [48, 17578703],
                [49, 17578704],
                [50, 17578705]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 17566113],
                [1, 17566114],
                [2, 17566115],
                [3, 17566116],
                [4, 17566117],
                [5, 17566118],
                [6, 17577951],
                [7, 17577952],
                [8, 17577953],
                [9, 17577954],
                [10, 17577955],
                [11, 17577956],
                [12, 17577957],
                [13, 17577958],
                [14, 17577959],
                [15, 17577960],
                [16, 17577961],
                [17, 17577962],
                [18, 17577963],
                [19, 17577964],
                [20, 17577965],
                [21, 17577966],
                [22, 17577967],
                [23, 17577968],
                [24, 17577969],
                [25, 17577970],
                [26, 17577971],
                [27, 17577972],
                [28, 17577973],
                [29, 17577974],
                [30, 17577975],
                [31, 17578686],
                [32, 17578687],
                [33, 17578688],
                [34, 17578689],
                [35, 17578690],
                [36, 17578691],
                [37, 17578692],
                [38, 17578693],
                [39, 17578694],
                [40, 17578695],
                [41, 17578696],
                [42, 17578697],
                [43, 17578698],
                [44, 17578699],
                [45, 17578700],
                [46, 17578701],
                [47, 17578702],
                [48, 17578703],
                [49, 17578704],
                [50, 17578705]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [1, 17579733],
                [2, 17579734],
                [3, 17579735],
                [4, 17579736],
                [5, 17579737],
                [6, 17579738],
                [7, 17579739],
                [8, 17579740],
                [9, 17579741],
                [10, 17579742],
                [11, 17579743],
                [12, 17579744],
                [13, 17579745],
                [14, 17579746],
                [15, 17579747],
                [16, 17579748],
                [17, 17579749],
                [18, 17579750],
                [19, 17579751],
                [20, 17579752],
                [21, 17579753],
                [22, 17579754],
                [23, 17579755],
                [24, 17579756],
                [25, 17579757],
                [26, 17579758],
                [27, 17579759],
                [28, 17579760],
                [29, 17579761],
                [30, 17579762],
                [31, 17579763],
                [32, 17579764],
                [33, 17579765],
                [34, 17579766],
                [35, 17579767],
                [36, 17579768],
                [37, 17579769],
                [38, 17579770],
                [39, 17579771],
                [40, 17579772],
                [41, 17579773],
                [42, 17579774],
                [43, 17579775],
                [44, 17579776],
                [45, 17581244],
                [46, 17581245],
                [47, 17581246],
                [48, 17581247],
                [49, 17581248],
                [50, 17581249]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 17581369],
                [1, 17581370],
                [2, 17582885],
                [3, 17582886],
                [4, 17582887],
                [5, 17582888],
                [6, 17582889],
                [7, 17582890],
                [8, 17582891],
                [9, 17582892],
                [10, 17582893],
                [11, 17582894],
                [12, 17582895],
                [13, 17582896],
                [14, 17582897],
                [15, 17582898],
                [16, 17582899],
                [17, 17582900],
                [18, 17582901],
                [19, 17582902],
                [20, 17582903],
                [21, 17582904],
                [22, 17582905],
                [23, 17582906],
                [24, 17582907],
                [25, 17582908],
                [26, 17582909],
                [27, 17582910],
                [28, 17582911],
                [29, 17582912],
                [30, 17582913],
                [31, 17582914],
                [32, 17582915],
                [33, 17582916],
                [34, 17582917],
                [35, 17582918],
                [36, 17582919],
                [37, 17582920],
                [38, 17582921],
                [39, 17582922],
                [40, 17582923],
                [41, 17582924],
                [42, 17582925],
                [43, 17582926],
                [44, 17582927],
                [45, 17582928],
                [46, 17582929],
                [47, 17582930],
                [48, 17582931],
                [49, 17582932],
                [50, 17583028]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 17581370],
                [1, 17582885],
                [2, 17582886],
                [3, 17582887],
                [4, 17582888],
                [5, 17582889],
                [6, 17582890],
                [7, 17582891],
                [8, 17582892],
                [9, 17582893],
                [10, 17582894],
                [11, 17582895],
                [12, 17582896],
                [13, 17582897],
                [14, 17582898],
                [15, 17582899],
                [16, 17582900],
                [17, 17582901],
                [18, 17582902],
                [19, 17582903],
                [20, 17582904],
                [21, 17582905],
                [22, 17582906],
                [23, 17582907],
                [24, 17582908],
                [25, 17582909],
                [26, 17582910],
                [27, 17582911],
                [28, 17582912],
                [29, 17582913],
                [30, 17582914],
                [31, 17582915],
                [32, 17582916],
                [33, 17582917],
                [34, 17582918],
                [35, 17582919],
                [36, 17582920],
                [37, 17582921],
                [38, 17582922],
                [39, 17582923],
                [40, 17582924],
                [41, 17582925],
                [42, 17582926],
                [43, 17582927],
                [44, 17582928],
                [45, 17582929],
                [46, 17582930],
                [47, 17582931],
                [48, 17582932],
                [49, 17583028],
                [50, 17583029]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 17581370],
                [1, 17582885],
                [2, 17582886],
                [3, 17582887],
                [4, 17582888],
                [5, 17582889],
                [6, 17582890],
                [7, 17582891],
                [8, 17582892],
                [9, 17582893],
                [10, 17582894],
                [11, 17582895],
                [12, 17582896],
                [13, 17582897],
                [14, 17582898],
                [15, 17582899],
                [16, 17582900],
                [17, 17582901],
                [18, 17582902],
                [19, 17582903],
                [20, 17582904],
                [21, 17582905],
                [22, 17582906],
                [23, 17582907],
                [24, 17582908],
                [25, 17582909],
                [26, 17582910],
                [27, 17582911],
                [28, 17582912],
                [29, 17582913],
                [30, 17582914],
                [31, 17582915],
                [32, 17582916],
                [33, 17582917],
                [34, 17582918],
                [35, 17582919],
                [36, 17582920],
                [37, 17582921],
                [38, 17582922],
                [39, 17582923],
                [40, 17582924],
                [41, 17582925],
                [42, 17582926],
                [43, 17582927],
                [44, 17582928],
                [45, 17582929],
                [46, 17582930],
                [47, 17582931],
                [48, 17582932],
                [49, 17583028],
                [50, 17583029]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [1, 17582911],
                [2, 17582912],
                [3, 17582913],
                [4, 17582914],
                [5, 17582915],
                [6, 17582916],
                [7, 17582917],
                [8, 17582918],
                [9, 17582919],
                [10, 17582920],
                [11, 17582921],
                [12, 17582922],
                [13, 17582923],
                [14, 17582924],
                [15, 17582925],
                [16, 17582926],
                [17, 17582927],
                [18, 17582928],
                [19, 17582929],
                [20, 17582930],
                [21, 17582931],
                [22, 17582932],
                [23, 17583028],
                [24, 17583029],
                [25, 17583030],
                [26, 17583031],
                [27, 17583032],
                [28, 17583033],
                [29, 17583034],
                [30, 17583035],
                [31, 17583036],
                [32, 17583037],
                [33, 17583038],
                [34, 17583039],
                [35, 17583040],
                [36, 17583041],
                [37, 17583042],
                [38, 17583043],
                [39, 17583044],
                [40, 17583045],
                [41, 17583046],
                [42, 17583047],
                [43, 17583048],
                [44, 17583049],
                [45, 17583050],
                [46, 17583051],
                [47, 17583052],
                [48, 17583053],
                [49, 17583054],
                [50, 17583055]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 17588621],
                [1, 17588622],
                [2, 17588623],
                [3, 17588624],
                [4, 17588625],
                [5, 17588626],
                [6, 17588627],
                [7, 17588628],
                [8, 17588629],
                [9, 17588630],
                [10, 17588631],
                [11, 17588632],
                [12, 17588633],
                [13, 17588634],
                [14, 17588635],
                [15, 17588636],
                [16, 17588637],
                [17, 17588638],
                [18, 17588639],
                [19, 17588640],
                [20, 17588641],
                [21, 17588642],
                [22, 17588643],
                [23, 17588644],
                [24, 17588645],
                [25, 17588646],
                [26, 17588647],
                [27, 17588648],
                [28, 17588649],
                [29, 17588650],
                [30, 17588651],
                [31, 17588652],
                [32, 17588653],
                [33, 17588654],
                [34, 17588655],
                [35, 17588656],
                [36, 17588657],
                [37, 17589196],
                [38, 17589197],
                [39, 17589198],
                [40, 17589199],
                [41, 17589200],
                [42, 17589201],
                [43, 17589202],
                [44, 17589203],
                [45, 17589204],
                [46, 17589205],
                [47, 17589206],
                [48, 17589207],
                [49, 17589208]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 17588621],
                [1, 17588622],
                [2, 17588623],
                [3, 17588624],
                [4, 17588625],
                [5, 17588626],
                [6, 17588627],
                [7, 17588628],
                [8, 17588629],
                [9, 17588630],
                [10, 17588631],
                [11, 17588632],
                [12, 17588633],
                [13, 17588634],
                [14, 17588635],
                [15, 17588636],
                [16, 17588637],
                [17, 17588638],
                [18, 17588639],
                [19, 17588640],
                [20, 17588641],
                [21, 17588642],
                [22, 17588643],
                [23, 17588644],
                [24, 17588645],
                [25, 17588646],
                [26, 17588647],
                [27, 17588648],
                [28, 17588649],
                [29, 17588650],
                [30, 17588651],
                [31, 17588652],
                [32, 17588653],
                [33, 17588654],
                [34, 17588655],
                [35, 17588656],
                [36, 17588657],
                [37, 17589196],
                [38, 17589197],
                [39, 17589198],
                [40, 17589199],
                [41, 17589200],
                [42, 17589201],
                [43, 17589202],
                [44, 17589203],
                [45, 17589204],
                [46, 17589205],
                [47, 17589206],
                [48, 17589207],
                [49, 17589208]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 17588621],
                [1, 17588622],
                [2, 17588623],
                [3, 17588624],
                [4, 17588625],
                [5, 17588626],
                [6, 17588627],
                [7, 17588628],
                [8, 17588629],
                [9, 17588630],
                [10, 17588631],
                [11, 17588632],
                [12, 17588633],
                [13, 17588634],
                [14, 17588635],
                [15, 17588636],
                [16, 17588637],
                [17, 17588638],
                [18, 17588639],
                [19, 17588640],
                [20, 17588641],
                [21, 17588642],
                [22, 17588643],
                [23, 17588644],
                [24, 17588645],
                [25, 17588646],
                [26, 17588647],
                [27, 17588648],
                [28, 17588649],
                [29, 17588650],
                [30, 17588651],
                [31, 17588652],
                [32, 17588653],
                [33, 17588654],
                [34, 17588655],
                [35, 17588656],
                [36, 17588657],
                [37, 17589196],
                [38, 17589197],
                [39, 17589198],
                [40, 17589199],
                [41, 17589200],
                [42, 17589201],
                [43, 17589202],
                [44, 17589203],
                [45, 17589204],
                [46, 17589205],
                [47, 17589206],
                [48, 17589207],
                [49, 17589208]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [1, 17591770],
                [2, 17591771],
                [3, 17591772],
                [4, 17591773],
                [5, 17591774],
                [6, 17591775],
                [7, 17591776],
                [8, 17591777],
                [9, 17591778],
                [10, 17591779],
                [11, 17591780],
                [12, 17591781],
                [13, 17591782],
                [14, 17591783],
                [15, 17591784],
                [16, 17591785],
                [17, 17591786],
                [18, 17591787],
                [19, 17591788],
                [20, 17591789],
                [21, 17591790],
                [22, 17591791],
                [23, 17591792],
                [24, 17591793],
                [25, 17591794],
                [26, 17591796],
                [27, 17591797],
                [28, 17591798],
                [29, 17591799],
                [30, 17591800],
                [31, 17591801],
                [32, 17591802],
                [33, 17591803],
                [34, 17591804],
                [35, 17591805],
                [36, 17591806],
                [37, 17591807],
                [38, 17591808],
                [39, 17591809],
                [40, 17591810],
                [41, 17591811],
                [42, 17591812],
                [43, 17591813],
                [44, 17591814],
                [45, 17591815],
                [46, 17591816],
                [47, 17591817],
                [48, 17591818],
                [49, 17591819],
                [50, 17591820]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 17593855],
                [1, 17593856],
                [2, 17593857],
                [3, 17593858],
                [4, 17593859],
                [5, 17593860],
                [6, 17593861],
                [7, 17593862],
                [8, 17593863],
                [9, 17593864],
                [10, 17593865],
                [11, 17593866],
                [12, 17593867],
                [13, 17593868],
                [14, 17593869],
                [15, 17593870],
                [16, 17593871],
                [17, 17593872],
                [18, 17593873],
                [19, 17593874],
                [20, 17593875],
                [21, 17593876],
                [22, 17593877],
                [23, 17593878],
                [24, 17593880],
                [25, 17593881],
                [26, 17593882],
                [27, 17593883],
                [28, 17593884],
                [29, 17593885],
                [30, 17593886],
                [31, 17593887],
                [32, 17593888],
                [33, 17593889],
                [34, 17593890],
                [35, 17593891],
                [36, 17593892],
                [37, 17593893],
                [38, 17593894],
                [39, 17593895],
                [40, 17593896],
                [41, 17593897],
                [42, 17593898],
                [43, 17593899],
                [44, 17593900],
                [45, 17593901],
                [46, 17593902],
                [47, 17593903]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 17593863],
                [1, 17593864],
                [2, 17593865],
                [3, 17593866],
                [4, 17593867],
                [5, 17593868],
                [6, 17593869],
                [7, 17593870],
                [8, 17593871],
                [9, 17593872],
                [10, 17593873],
                [11, 17593874],
                [12, 17593875],
                [13, 17593876],
                [14, 17593877],
                [15, 17593878],
                [16, 17593880],
                [17, 17593881],
                [18, 17593882],
                [19, 17593883],
                [20, 17593884],
                [21, 17593885],
                [22, 17593886],
                [23, 17593887],
                [24, 17593888],
                [25, 17593889],
                [26, 17593890],
                [27, 17593891],
                [28, 17593892],
                [29, 17593893],
                [30, 17593894],
                [31, 17593895],
                [32, 17593896],
                [33, 17593897],
                [34, 17593898],
                [35, 17593899],
                [36, 17593900],
                [37, 17593901],
                [38, 17593902],
                [39, 17593903],
                [40, 17593904],
                [41, 17593905],
                [42, 17593906],
                [43, 17593907]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [11, 17596476],
                [12, 17596477],
                [13, 17596478],
                [14, 17596479],
                [15, 17596480],
                [16, 17596481],
                [17, 17596482],
                [19, 17596483],
                [20, 17596484],
                [21, 17596485],
                [22, 17596486],
                [23, 17596487],
                [24, 17596488],
                [25, 17596489],
                [26, 17596490],
                [27, 17596491],
                [28, 17596492],
                [29, 17596493],
                [30, 17596494],
                [31, 17596495],
                [32, 17596496],
                [33, 17596497],
                [34, 17596498],
                [35, 17596499],
                [36, 17596500],
                [37, 17596501],
                [38, 17596502],
                [39, 17596503],
                [40, 17596504],
                [41, 17596505],
                [42, 17596506],
                [43, 17596507],
                [44, 17596508],
                [45, 17596509],
                [46, 17596510],
                [47, 17596511],
                [48, 17596512],
                [49, 17596513],
                [50, 17596514]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [5, 17624012],
                [6, 17624013],
                [7, 17624014],
                [8, 17624015],
                [9, 17624016],
                [10, 17624017],
                [11, 17624018],
                [12, 17624019],
                [13, 17624020],
                [14, 17625913],
                [15, 17625914],
                [16, 17625915],
                [17, 17625916],
                [18, 17625917],
                [19, 17625918],
                [20, 17625919],
                [21, 17625920],
                [22, 17625921],
                [23, 17625922],
                [24, 17625923],
                [25, 17625924],
                [26, 17625925],
                [27, 17625926],
                [28, 17625927],
                [29, 17625928],
                [30, 17625929],
                [31, 17625930],
                [32, 17625931],
                [33, 17625932],
                [34, 17625933],
                [35, 17625934],
                [36, 17625935],
                [37, 17625936],
                [38, 17625937],
                [39, 17625938],
                [40, 17625939],
                [41, 17625940],
                [42, 17625941],
                [43, 17625942],
                [44, 17625943],
                [45, 17625944],
                [46, 17625945],
                [47, 17625946],
                [48, 17625947],
                [49, 17625948],
                [50, 17625949]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [2, 17624012],
                [3, 17624013],
                [4, 17624014],
                [5, 17624015],
                [6, 17624016],
                [7, 17624017],
                [8, 17624018],
                [9, 17624019],
                [10, 17624020],
                [11, 17625913],
                [12, 17625914],
                [13, 17625915],
                [14, 17625916],
                [15, 17625917],
                [16, 17625918],
                [17, 17625919],
                [18, 17625920],
                [19, 17625921],
                [20, 17625922],
                [21, 17625923],
                [22, 17625924],
                [23, 17625925],
                [24, 17625926],
                [25, 17625927],
                [26, 17625928],
                [27, 17625929],
                [28, 17625930],
                [29, 17625931],
                [30, 17625932],
                [31, 17625933],
                [32, 17625934],
                [33, 17625935],
                [34, 17625936],
                [35, 17625937],
                [36, 17625938],
                [37, 17625939],
                [38, 17625940],
                [39, 17625941],
                [40, 17625942],
                [41, 17625943],
                [42, 17625944],
                [43, 17625945],
                [44, 17625946],
                [45, 17625947],
                [46, 17625948],
                [47, 17625949],
                [48, 17625950],
                [49, 17625951],
                [50, 17625952]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [1, 31796700],
                [2, 31796701],
                [3, 31796702],
                [4, 31796703],
                [5, 31796704],
                [6, 31796705],
                [7, 31796706],
                [8, 31796710],
                [9, 31796711],
                [10, 31796712],
                [11, 31796713],
                [12, 31796714],
                [13, 31796715],
                [14, 31796716],
                [15, 31796717],
                [16, 31796718],
                [17, 31796719],
                [18, 31796720],
                [19, 31796721],
                [20, 31796722],
                [21, 31796723],
                [22, 31796724],
                [23, 31796725],
                [24, 31796726],
                [25, 31796727],
                [26, 31796728],
                [27, 31799014],
                [28, 31799015],
                [29, 31799016],
                [30, 31799017],
                [31, 31799018],
                [32, 31799019],
                [33, 31799020],
                [34, 31799021],
                [35, 31799022],
                [36, 31799023],
                [37, 31799024],
                [38, 31799025],
                [39, 31799026],
                [40, 31799027],
                [41, 31799028],
                [42, 31799029],
                [43, 31799030],
                [44, 31799031],
                [45, 31799032],
                [46, 31799033],
                [47, 31799034],
                [48, 31799035],
                [49, 31799036],
                [50, 31799037]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [0, 36722692],
                [1, 36722693],
                [2, 36722694],
                [3, 36722695],
                [4, 36722696],
                [5, 36722697],
                [6, 36722698],
                [7, 36722699],
                [8, 36722700],
                [9, 36722701],
                [10, 36722702],
                [11, 36722703],
                [12, 36722704],
                [13, 36722705],
                [14, 36723505],
                [15, 36723506],
                [16, 36723507],
                [17, 36723508],
                [18, 36723509],
                [19, 36723510],
                [20, 36723511],
                [21, 36723512],
                [22, 36723513],
                [23, 36723514],
                [24, 36723515],
                [25, 36723516],
                [26, 36723517],
                [27, 36723518],
                [28, 36723519],
                [29, 36723520],
                [30, 36723521],
                [31, 36723522],
                [32, 36723523],
                [33, 36723524],
                [34, 36723525],
                [35, 36723526],
                [36, 36723527],
                [37, 36723528],
                [38, 36723529],
                [39, 36723530],
                [40, 36723531],
                [41, 36723532],
                [42, 36737414],
                [43, 36737415],
                [44, 36737416],
                [45, 36737417],
                [46, 36737418],
                [47, 36737419],
                [48, 36737420]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs().collect();
        assert_eq!(
            pairs,
            vec![
                [4, 44587963],
                [5, 44587964],
                [6, 44587965],
                [7, 44587966],
                [8, 44587967],
                [9, 44587968],
                [10, 44587969],
                [11, 44587970],
                [12, 44587971],
                [13, 44587972],
                [14, 44587973],
                [15, 44587974],
                [16, 44587975],
                [17, 44587976],
                [18, 44587977],
                [19, 44587978],
                [20, 44587979],
                [21, 44587980],
                [22, 44587981],
                [23, 44587982],
                [24, 44587983],
                [25, 44589680],
                [26, 44589681],
                [27, 44589682],
                [28, 44589683],
                [29, 44589684],
                [30, 44589685],
                [31, 44589686],
                [32, 44589687],
                [33, 44589688],
                [34, 44589689],
                [35, 44589690],
                [36, 44589691],
                [37, 44589692],
                [38, 44589693],
                [39, 44589694],
                [40, 44589695],
                [41, 44589696],
                [42, 44589697],
                [43, 44589698],
                [44, 44589699],
                [45, 44589700],
                [46, 44589701],
                [47, 44589702],
                [48, 44592034],
                [49, 44592035],
                [50, 44592036]
            ]
        );
    }
    #[test]
    fn test_cigar_full() {
        let mut bam = bam::Reader::from_path("./test/locusmd.bam").unwrap();
        let mut it = bam.records();
        let test = it.next().unwrap().unwrap();
        let pairs: Vec<_> = test.aligned_block_pairs_cigar().collect();
        assert_eq!(
            pairs,
            vec![
                (0..15, 99812479..99812494, Cigar::Equal(15)),
                (15..16, 99812494..99812494, Cigar::Ins(1)),
                (16..83, 99812494..99812561, Cigar::Equal(67)),
                (83..84, 99812561..99812561, Cigar::Ins(1)),
                (84..413, 99812561..99812890, Cigar::Equal(329)),
                (413..413, 99812890..99812891, Cigar::Del(1)),
                (413..538, 99812891..99813016, Cigar::Equal(125)),
                (538..539, 99813016..99813016, Cigar::Ins(1)),
                (539..597, 99813016..99813074, Cigar::Equal(58)),
                (597..597, 99813074..99813075, Cigar::Del(1)),
                (597..1498, 99813075..99813976, Cigar::Equal(901)),
                (1498..1499, 99813976..99813976, Cigar::Ins(1)),
                (1499..1779, 99813976..99814256, Cigar::Equal(280)),
                (1779..1779, 99814256..99814257, Cigar::Del(1)),
                (1779..1939, 99814257..99814417, Cigar::Equal(160)),
                (1939..1939, 99814417..99814418, Cigar::Del(1)),
                (1939..1962, 99814418..99814441, Cigar::Equal(23)),
                (1962..1962, 99814441..99814442, Cigar::Del(1)),
                (1962..1994, 99814442..99814474, Cigar::Equal(32)),
                (1994..1994, 99814474..99814475, Cigar::Del(1)),
                (1994..2067, 99814475..99814548, Cigar::Equal(73)),
                (2067..2068, 99814548..99814548, Cigar::Ins(1)),
                (2068..2368, 99814548..99814848, Cigar::Equal(300)),
                (2368..2368, 99814848..99814850, Cigar::Del(2)),
                (2368..2384, 99814850..99814866, Cigar::Equal(16)),
                (2384..2384, 99814866..99814867, Cigar::Del(1)),
                (2384..2785, 99814867..99815268, Cigar::Equal(401)),
                (2785..2785, 99815268..99815269, Cigar::Del(1)),
                (2785..2790, 99815269..99815274, Cigar::Equal(5)),
                (2790..2791, 99815274..99815275, Cigar::Diff(1)),
                (2791..2867, 99815275..99815351, Cigar::Equal(76)),
                (2867..2867, 99815351..99815352, Cigar::Del(1)),
                (2867..3126, 99815352..99815611, Cigar::Equal(259)),
                (3126..3127, 99815611..99815612, Cigar::Diff(1)),
                (3127..3314, 99815612..99815799, Cigar::Equal(187)),
                (3314..3314, 99815799..99815800, Cigar::Del(1)),
                (3314..3331, 99815800..99815817, Cigar::Equal(17)),
                (3331..3331, 99815817..99815818, Cigar::Del(1)),
                (3331..3367, 99815818..99815854, Cigar::Equal(36)),
                (3367..3367, 99815854..99815855, Cigar::Del(1)),
                (3367..3430, 99815855..99815918, Cigar::Equal(63)),
                (3430..3430, 99815918..99815919, Cigar::Del(1)),
                (3430..3469, 99815919..99815958, Cigar::Equal(39)),
                (3469..3469, 99815958..99815959, Cigar::Del(1)),
                (3469..3508, 99815959..99815998, Cigar::Equal(39)),
                (3508..3508, 99815998..99815999, Cigar::Del(1)),
                (3508..3701, 99815999..99816192, Cigar::Equal(193)),
                (3701..3701, 99816192..99816193, Cigar::Del(1)),
                (3701..3829, 99816193..99816321, Cigar::Equal(128)),
                (3829..3830, 99816321..99816321, Cigar::Ins(1)),
                (3830..4519, 99816321..99817010, Cigar::Equal(689)),
                (4519..4520, 99817010..99817010, Cigar::Ins(1)),
                (4520..4569, 99817010..99817059, Cigar::Equal(49)),
                (4569..4569, 99817059..99817060, Cigar::Del(1)),
                (4569..4702, 99817060..99817193, Cigar::Equal(133)),
                (4702..4702, 99817193..99817194, Cigar::Del(1)),
                (4702..4888, 99817194..99817380, Cigar::Equal(186)),
                (4888..4889, 99817380..99817380, Cigar::Ins(1)),
                (4889..4981, 99817380..99817472, Cigar::Equal(92)),
                (4981..4982, 99817472..99817472, Cigar::Ins(1)),
                (4982..5089, 99817472..99817579, Cigar::Equal(107)),
                (5089..5090, 99817579..99817579, Cigar::Ins(1)),
                (5090..5132, 99817579..99817621, Cigar::Equal(42)),
                (5132..5133, 99817621..99817621, Cigar::Ins(1)),
                (5133..5383, 99817621..99817871, Cigar::Equal(250)),
                (5383..5383, 99817871..99817872, Cigar::Del(1)),
                (5383..5451, 99817872..99817940, Cigar::Equal(68)),
                (5451..5451, 99817940..99817941, Cigar::Del(1)),
                (5451..5457, 99817941..99817947, Cigar::Equal(6)),
                (5457..5457, 99817947..99817948, Cigar::Del(1)),
                (5457..5593, 99817948..99818084, Cigar::Equal(136)),
                (5593..5594, 99818084..99818084, Cigar::Ins(1)),
                (5594..5900, 99818084..99818390, Cigar::Equal(306)),
                (5900..5901, 99818390..99818390, Cigar::Ins(1)),
                (5901..5932, 99818390..99818421, Cigar::Equal(31)),
                (5932..5933, 99818421..99818421, Cigar::Ins(1)),
                (5933..6100, 99818421..99818588, Cigar::Equal(167)),
                (6100..6100, 99818588..99818589, Cigar::Del(1)),
                (6100..6256, 99818589..99818745, Cigar::Equal(156)),
                (6256..6257, 99818745..99818746, Cigar::Diff(1)),
                (6257..7576, 99818746..99820065, Cigar::Equal(1319)),
                (7576..7576, 99820065..99820066, Cigar::Del(1)),
                (7576..7884, 99820066..99820374, Cigar::Equal(308)),
                (7884..7884, 99820374..99820375, Cigar::Del(1)),
                (7884..7951, 99820375..99820442, Cigar::Equal(67)),
                (7951..7951, 99820442..99820443, Cigar::Del(1)),
                (7951..8159, 99820443..99820651, Cigar::Equal(208)),
                (8159..8159, 99820651..99820653, Cigar::Del(2)),
                (8159..8225, 99820653..99820719, Cigar::Equal(66)),
                (8225..8226, 99820719..99820719, Cigar::Ins(1)),
                (8226..8229, 99820719..99820722, Cigar::Equal(3)),
                (8229..8229, 99820722..99820723, Cigar::Del(1)),
                (8229..8245, 99820723..99820739, Cigar::Equal(16)),
                (8245..8245, 99820739..99820740, Cigar::Del(1)),
                (8245..8283, 99820740..99820778, Cigar::Equal(38)),
                (8283..8283, 99820778..99820780, Cigar::Del(2)),
                (8283..8285, 99820780..99820782, Cigar::Equal(2)),
                (8285..8286, 99820782..99820783, Cigar::Diff(1)),
                (8286..8326, 99820783..99820823, Cigar::Equal(40)),
                (8326..8326, 99820823..99820824, Cigar::Del(1)),
                (8326..8454, 99820824..99820952, Cigar::Equal(128)),
                (8454..8454, 99820952..99820953, Cigar::Del(1)),
                (8454..8508, 99820953..99821007, Cigar::Equal(54)),
                (8508..8509, 99821007..99821007, Cigar::Ins(1)),
                (8509..8560, 99821007..99821058, Cigar::Equal(51)),
                (8560..8560, 99821058..99821059, Cigar::Del(1)),
                (8560..8833, 99821059..99821332, Cigar::Equal(273)),
                (8833..8833, 99821332..99821333, Cigar::Del(1)),
                (8833..8836, 99821333..99821336, Cigar::Equal(3)),
                (8836..8836, 99821336..99821337, Cigar::Del(1)),
                (8836..9061, 99821337..99821562, Cigar::Equal(225)),
                (9061..9061, 99821562..99821563, Cigar::Del(1)),
                (9061..9065, 99821563..99821567, Cigar::Equal(4)),
                (9065..9065, 99821567..99821568, Cigar::Del(1)),
                (9065..9110, 99821568..99821613, Cigar::Equal(45)),
                (9110..9110, 99821613..99821615, Cigar::Del(2)),
                (9110..9163, 99821615..99821668, Cigar::Equal(53)),
                (9163..9163, 99821668..99821669, Cigar::Del(1)),
                (9163..9390, 99821669..99821896, Cigar::Equal(227)),
                (9390..9390, 99821896..99821897, Cigar::Del(1)),
                (9390..9427, 99821897..99821934, Cigar::Equal(37)),
                (9427..9430, 99821934..99821937, Cigar::Diff(3)),
                (9430..9461, 99821937..99821968, Cigar::Equal(31)),
                (9461..9461, 99821968..99821970, Cigar::Del(2)),
                (9461..9493, 99821970..99822002, Cigar::Equal(32)),
                (9493..9493, 99822002..99822004, Cigar::Del(2)),
                (9493..9692, 99822004..99822203, Cigar::Equal(199)),
                (9692..9693, 99822203..99822204, Cigar::Diff(1)),
                (9693..9829, 99822204..99822340, Cigar::Equal(136)),
                (9829..9829, 99822340..99822342, Cigar::Del(2)),
                (9829..9870, 99822342..99822383, Cigar::Equal(41)),
                (9870..9870, 99822383..99822386, Cigar::Del(3)),
                (9870..9915, 99822386..99822431, Cigar::Equal(45)),
                (9915..9915, 99822431..99822432, Cigar::Del(1)),
                (9915..10285, 99822432..99822802, Cigar::Equal(370)),
                (10285..10285, 99822802..99822803, Cigar::Del(1)),
                (10285..10480, 99822803..99822998, Cigar::Equal(195)),
                (10480..10480, 99822998..99822999, Cigar::Del(1)),
                (10480..10721, 99822999..99823240, Cigar::Equal(241)),
                (10721..10722, 99823240..99823240, Cigar::Ins(1)),
                (10722..11122, 99823240..99823640, Cigar::Equal(400)),
                (11122..11122, 99823640..99823641, Cigar::Del(1)),
                (11122..11230, 99823641..99823749, Cigar::Equal(108)),
                (11230..11230, 99823749..99823750, Cigar::Del(1)),
                (11230..11911, 99823750..99824431, Cigar::Equal(681)),
                (11911..11912, 99824431..99824431, Cigar::Ins(1)),
                (11912..12102, 99824431..99824621, Cigar::Equal(190)),
                (12102..12102, 99824621..99824622, Cigar::Del(1)),
                (12102..12870, 99824622..99825390, Cigar::Equal(768)),
                (12870..12870, 99825390..99825391, Cigar::Del(1)),
                (12870..12978, 99825391..99825499, Cigar::Equal(108)),
                (12978..12978, 99825499..99825500, Cigar::Del(1)),
                (12978..13419, 99825500..99825941, Cigar::Equal(441)),
                (13419..13419, 99825941..99825942, Cigar::Del(1)),
                (13419..13617, 99825942..99826140, Cigar::Equal(198)),
                (13617..13617, 99826140..99826141, Cigar::Del(1)),
                (13617..13697, 99826141..99826221, Cigar::Equal(80)),
                (13697..13698, 99826221..99826221, Cigar::Ins(1)),
                (13698..13811, 99826221..99826334, Cigar::Equal(113)),
                (13811..13812, 99826334..99826334, Cigar::Ins(1)),
                (13812..14020, 99826334..99826542, Cigar::Equal(208)),
                (14020..14020, 99826542..99826543, Cigar::Del(1)),
                (14020..14524, 99826543..99827047, Cigar::Equal(504)),
                (14524..14524, 99827047..99827048, Cigar::Del(1)),
                (14524..14533, 99827048..99827057, Cigar::Equal(9)),
                (14533..14534, 99827057..99827057, Cigar::Ins(1)),
                (14534..14787, 99827057..99827310, Cigar::Equal(253)),
                (14787..14788, 99827310..99827310, Cigar::Ins(1)),
                (14788..14901, 99827310..99827423, Cigar::Equal(113)),
                (14901..14901, 99827423..99827424, Cigar::Del(1)),
                (14901..15001, 99827424..99827524, Cigar::Equal(100)),
                (15001..15002, 99827524..99827524, Cigar::Ins(1)),
                (15002..15166, 99827524..99827688, Cigar::Equal(164)),
                (15166..15166, 99827688..99827689, Cigar::Del(1)),
                (15166..15805, 99827689..99828328, Cigar::Equal(639)),
                (15805..15805, 99828328..99828329, Cigar::Del(1)),
                (15805..16195, 99828329..99828719, Cigar::Equal(390)),
                (16195..16195, 99828719..99828721, Cigar::Del(2)),
                (16195..16576, 99828721..99829102, Cigar::Equal(381)),
                (16576..16577, 99829102..99829102, Cigar::Ins(1)),
                (16577..16912, 99829102..99829437, Cigar::Equal(335)),
                (16912..16912, 99829437..99829438, Cigar::Del(1)),
                (16912..17896, 99829438..99830422, Cigar::Equal(984)),
                (17896..17897, 99830422..99830422, Cigar::Ins(1)),
                (17897..18370, 99830422..99830895, Cigar::Equal(473)),
                (18370..18370, 99830895..99830896, Cigar::Del(1)),
                (18370..18410, 99830896..99830936, Cigar::Equal(40)),
                (18410..18410, 99830936..99830937, Cigar::Del(1)),
                (18410..18449, 99830937..99830976, Cigar::Equal(39)),
                (18449..18450, 99830976..99830976, Cigar::Ins(1)),
                (18450..18675, 99830976..99831201, Cigar::Equal(225)),
                (18675..18675, 99831201..99831202, Cigar::Del(1)),
                (18675..18729, 99831202..99831256, Cigar::Equal(54)),
                (18729..18729, 99831256..99831257, Cigar::Del(1)),
                (18729..18812, 99831257..99831340, Cigar::Equal(83)),
                (18812..18813, 99831340..99831340, Cigar::Ins(1)),
                (18813..18895, 99831340..99831422, Cigar::Equal(82)),
                (18895..18895, 99831422..99831423, Cigar::Del(1)),
                (18895..19239, 99831423..99831767, Cigar::Equal(344)),
                (19239..19240, 99831767..99831767, Cigar::Ins(1)),
                (19240..19244, 99831767..99831771, Cigar::Equal(4)),
                (19244..19245, 99831771..99831771, Cigar::Ins(1)),
                (19245..19387, 99831771..99831913, Cigar::Equal(142)),
                (19387..19387, 99831913..99831914, Cigar::Del(1)),
                (19387..19883, 99831914..99832410, Cigar::Equal(496)),
            ]
        );
        assert_eq!(
            test.aligned_block_pairs_cigar_match()
                .unwrap()
                .into_iter()
                .filter_map(|a| match a {
                    (Some((a, b)), _) => Some(((a.start, a.end), (b.start, b.end))),
                    (None, _) => None,
                })
                .collect::<Vec<_>>(),
            //Block pairs and aligned blocks must match
            test.aligned_block_pairs_match()
                .unwrap()
                .into_iter()
                .map(|(a, b)| ((a[0], a[1]), (b[0], b[1])))
                .collect::<Vec<_>>(),
            "Invalid alignment of pairs and cigar"
        );
        let pairs: Vec<_> = test.aligned_block_pairs_cigar_match().unwrap().collect();
        assert_eq!(
            pairs,
            vec![
                (Some((0..15, 99812479..99812494)), Cigar::Equal(15)),
                (None, Cigar::Ins(1)),
                (Some((16..83, 99812494..99812561)), Cigar::Equal(67)),
                (None, Cigar::Ins(1)),
                (Some((84..413, 99812561..99812890)), Cigar::Equal(329)),
                (None, Cigar::Del(1)),
                (Some((413..538, 99812891..99813016)), Cigar::Equal(125)),
                (None, Cigar::Ins(1)),
                (Some((539..597, 99813016..99813074)), Cigar::Equal(58)),
                (None, Cigar::Del(1)),
                (Some((597..1498, 99813075..99813976)), Cigar::Equal(901)),
                (None, Cigar::Ins(1)),
                (Some((1499..1779, 99813976..99814256)), Cigar::Equal(280)),
                (None, Cigar::Del(1)),
                (Some((1779..1939, 99814257..99814417)), Cigar::Equal(160)),
                (None, Cigar::Del(1)),
                (Some((1939..1962, 99814418..99814441)), Cigar::Equal(23)),
                (None, Cigar::Del(1)),
                (Some((1962..1994, 99814442..99814474)), Cigar::Equal(32)),
                (None, Cigar::Del(1)),
                (Some((1994..2067, 99814475..99814548)), Cigar::Equal(73)),
                (None, Cigar::Ins(1)),
                (Some((2068..2368, 99814548..99814848)), Cigar::Equal(300)),
                (None, Cigar::Del(2)),
                (Some((2368..2384, 99814850..99814866)), Cigar::Equal(16)),
                (None, Cigar::Del(1)),
                (Some((2384..2785, 99814867..99815268)), Cigar::Equal(401)),
                (None, Cigar::Del(1)),
                (Some((2785..2790, 99815269..99815274)), Cigar::Equal(5)),
                (None, Cigar::Diff(1)),
                (Some((2791..2867, 99815275..99815351)), Cigar::Equal(76)),
                (None, Cigar::Del(1)),
                (Some((2867..3126, 99815352..99815611)), Cigar::Equal(259)),
                (None, Cigar::Diff(1)),
                (Some((3127..3314, 99815612..99815799)), Cigar::Equal(187)),
                (None, Cigar::Del(1)),
                (Some((3314..3331, 99815800..99815817)), Cigar::Equal(17)),
                (None, Cigar::Del(1)),
                (Some((3331..3367, 99815818..99815854)), Cigar::Equal(36)),
                (None, Cigar::Del(1)),
                (Some((3367..3430, 99815855..99815918)), Cigar::Equal(63)),
                (None, Cigar::Del(1)),
                (Some((3430..3469, 99815919..99815958)), Cigar::Equal(39)),
                (None, Cigar::Del(1)),
                (Some((3469..3508, 99815959..99815998)), Cigar::Equal(39)),
                (None, Cigar::Del(1)),
                (Some((3508..3701, 99815999..99816192)), Cigar::Equal(193)),
                (None, Cigar::Del(1)),
                (Some((3701..3829, 99816193..99816321)), Cigar::Equal(128)),
                (None, Cigar::Ins(1)),
                (Some((3830..4519, 99816321..99817010)), Cigar::Equal(689)),
                (None, Cigar::Ins(1)),
                (Some((4520..4569, 99817010..99817059)), Cigar::Equal(49)),
                (None, Cigar::Del(1)),
                (Some((4569..4702, 99817060..99817193)), Cigar::Equal(133)),
                (None, Cigar::Del(1)),
                (Some((4702..4888, 99817194..99817380)), Cigar::Equal(186)),
                (None, Cigar::Ins(1)),
                (Some((4889..4981, 99817380..99817472)), Cigar::Equal(92)),
                (None, Cigar::Ins(1)),
                (Some((4982..5089, 99817472..99817579)), Cigar::Equal(107)),
                (None, Cigar::Ins(1)),
                (Some((5090..5132, 99817579..99817621)), Cigar::Equal(42)),
                (None, Cigar::Ins(1)),
                (Some((5133..5383, 99817621..99817871)), Cigar::Equal(250)),
                (None, Cigar::Del(1)),
                (Some((5383..5451, 99817872..99817940)), Cigar::Equal(68)),
                (None, Cigar::Del(1)),
                (Some((5451..5457, 99817941..99817947)), Cigar::Equal(6)),
                (None, Cigar::Del(1)),
                (Some((5457..5593, 99817948..99818084)), Cigar::Equal(136)),
                (None, Cigar::Ins(1)),
                (Some((5594..5900, 99818084..99818390)), Cigar::Equal(306)),
                (None, Cigar::Ins(1)),
                (Some((5901..5932, 99818390..99818421)), Cigar::Equal(31)),
                (None, Cigar::Ins(1)),
                (Some((5933..6100, 99818421..99818588)), Cigar::Equal(167)),
                (None, Cigar::Del(1)),
                (Some((6100..6256, 99818589..99818745)), Cigar::Equal(156)),
                (None, Cigar::Diff(1)),
                (Some((6257..7576, 99818746..99820065)), Cigar::Equal(1319)),
                (None, Cigar::Del(1)),
                (Some((7576..7884, 99820066..99820374)), Cigar::Equal(308)),
                (None, Cigar::Del(1)),
                (Some((7884..7951, 99820375..99820442)), Cigar::Equal(67)),
                (None, Cigar::Del(1)),
                (Some((7951..8159, 99820443..99820651)), Cigar::Equal(208)),
                (None, Cigar::Del(2)),
                (Some((8159..8225, 99820653..99820719)), Cigar::Equal(66)),
                (None, Cigar::Ins(1)),
                (Some((8226..8229, 99820719..99820722)), Cigar::Equal(3)),
                (None, Cigar::Del(1)),
                (Some((8229..8245, 99820723..99820739)), Cigar::Equal(16)),
                (None, Cigar::Del(1)),
                (Some((8245..8283, 99820740..99820778)), Cigar::Equal(38)),
                (None, Cigar::Del(2)),
                (Some((8283..8285, 99820780..99820782)), Cigar::Equal(2)),
                (None, Cigar::Diff(1)),
                (Some((8286..8326, 99820783..99820823)), Cigar::Equal(40)),
                (None, Cigar::Del(1)),
                (Some((8326..8454, 99820824..99820952)), Cigar::Equal(128)),
                (None, Cigar::Del(1)),
                (Some((8454..8508, 99820953..99821007)), Cigar::Equal(54)),
                (None, Cigar::Ins(1)),
                (Some((8509..8560, 99821007..99821058)), Cigar::Equal(51)),
                (None, Cigar::Del(1)),
                (Some((8560..8833, 99821059..99821332)), Cigar::Equal(273)),
                (None, Cigar::Del(1)),
                (Some((8833..8836, 99821333..99821336)), Cigar::Equal(3)),
                (None, Cigar::Del(1)),
                (Some((8836..9061, 99821337..99821562)), Cigar::Equal(225)),
                (None, Cigar::Del(1)),
                (Some((9061..9065, 99821563..99821567)), Cigar::Equal(4)),
                (None, Cigar::Del(1)),
                (Some((9065..9110, 99821568..99821613)), Cigar::Equal(45)),
                (None, Cigar::Del(2)),
                (Some((9110..9163, 99821615..99821668)), Cigar::Equal(53)),
                (None, Cigar::Del(1)),
                (Some((9163..9390, 99821669..99821896)), Cigar::Equal(227)),
                (None, Cigar::Del(1)),
                (Some((9390..9427, 99821897..99821934)), Cigar::Equal(37)),
                (None, Cigar::Diff(3)),
                (Some((9430..9461, 99821937..99821968)), Cigar::Equal(31)),
                (None, Cigar::Del(2)),
                (Some((9461..9493, 99821970..99822002)), Cigar::Equal(32)),
                (None, Cigar::Del(2)),
                (Some((9493..9692, 99822004..99822203)), Cigar::Equal(199)),
                (None, Cigar::Diff(1)),
                (Some((9693..9829, 99822204..99822340)), Cigar::Equal(136)),
                (None, Cigar::Del(2)),
                (Some((9829..9870, 99822342..99822383)), Cigar::Equal(41)),
                (None, Cigar::Del(3)),
                (Some((9870..9915, 99822386..99822431)), Cigar::Equal(45)),
                (None, Cigar::Del(1)),
                (Some((9915..10285, 99822432..99822802)), Cigar::Equal(370)),
                (None, Cigar::Del(1)),
                (Some((10285..10480, 99822803..99822998)), Cigar::Equal(195)),
                (None, Cigar::Del(1)),
                (Some((10480..10721, 99822999..99823240)), Cigar::Equal(241)),
                (None, Cigar::Ins(1)),
                (Some((10722..11122, 99823240..99823640)), Cigar::Equal(400)),
                (None, Cigar::Del(1)),
                (Some((11122..11230, 99823641..99823749)), Cigar::Equal(108)),
                (None, Cigar::Del(1)),
                (Some((11230..11911, 99823750..99824431)), Cigar::Equal(681)),
                (None, Cigar::Ins(1)),
                (Some((11912..12102, 99824431..99824621)), Cigar::Equal(190)),
                (None, Cigar::Del(1)),
                (Some((12102..12870, 99824622..99825390)), Cigar::Equal(768)),
                (None, Cigar::Del(1)),
                (Some((12870..12978, 99825391..99825499)), Cigar::Equal(108)),
                (None, Cigar::Del(1)),
                (Some((12978..13419, 99825500..99825941)), Cigar::Equal(441)),
                (None, Cigar::Del(1)),
                (Some((13419..13617, 99825942..99826140)), Cigar::Equal(198)),
                (None, Cigar::Del(1)),
                (Some((13617..13697, 99826141..99826221)), Cigar::Equal(80)),
                (None, Cigar::Ins(1)),
                (Some((13698..13811, 99826221..99826334)), Cigar::Equal(113)),
                (None, Cigar::Ins(1)),
                (Some((13812..14020, 99826334..99826542)), Cigar::Equal(208)),
                (None, Cigar::Del(1)),
                (Some((14020..14524, 99826543..99827047)), Cigar::Equal(504)),
                (None, Cigar::Del(1)),
                (Some((14524..14533, 99827048..99827057)), Cigar::Equal(9)),
                (None, Cigar::Ins(1)),
                (Some((14534..14787, 99827057..99827310)), Cigar::Equal(253)),
                (None, Cigar::Ins(1)),
                (Some((14788..14901, 99827310..99827423)), Cigar::Equal(113)),
                (None, Cigar::Del(1)),
                (Some((14901..15001, 99827424..99827524)), Cigar::Equal(100)),
                (None, Cigar::Ins(1)),
                (Some((15002..15166, 99827524..99827688)), Cigar::Equal(164)),
                (None, Cigar::Del(1)),
                (Some((15166..15805, 99827689..99828328)), Cigar::Equal(639)),
                (None, Cigar::Del(1)),
                (Some((15805..16195, 99828329..99828719)), Cigar::Equal(390)),
                (None, Cigar::Del(2)),
                (Some((16195..16576, 99828721..99829102)), Cigar::Equal(381)),
                (None, Cigar::Ins(1)),
                (Some((16577..16912, 99829102..99829437)), Cigar::Equal(335)),
                (None, Cigar::Del(1)),
                (Some((16912..17896, 99829438..99830422)), Cigar::Equal(984)),
                (None, Cigar::Ins(1)),
                (Some((17897..18370, 99830422..99830895)), Cigar::Equal(473)),
                (None, Cigar::Del(1)),
                (Some((18370..18410, 99830896..99830936)), Cigar::Equal(40)),
                (None, Cigar::Del(1)),
                (Some((18410..18449, 99830937..99830976)), Cigar::Equal(39)),
                (None, Cigar::Ins(1)),
                (Some((18450..18675, 99830976..99831201)), Cigar::Equal(225)),
                (None, Cigar::Del(1)),
                (Some((18675..18729, 99831202..99831256)), Cigar::Equal(54)),
                (None, Cigar::Del(1)),
                (Some((18729..18812, 99831257..99831340)), Cigar::Equal(83)),
                (None, Cigar::Ins(1)),
                (Some((18813..18895, 99831340..99831422)), Cigar::Equal(82)),
                (None, Cigar::Del(1)),
                (Some((18895..19239, 99831423..99831767)), Cigar::Equal(344)),
                (None, Cigar::Ins(1)),
                (Some((19240..19244, 99831767..99831771)), Cigar::Equal(4)),
                (None, Cigar::Ins(1)),
                (Some((19245..19387, 99831771..99831913)), Cigar::Equal(142)),
                (None, Cigar::Del(1)),
                (Some((19387..19883, 99831914..99832410)), Cigar::Equal(496))
            ]
        );
        let mut bam = bam::Reader::from_path("./test/setcigar.sam").unwrap();
        let mut it = bam.rc_records();
        let hit = it
            .next()
            .unwrap()
            .unwrap()
            .aligned_block_pairs_cigar_match();
        assert!(hit.is_none())
    }
    #[test]
    fn test_aligned_pairs_full() {
        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
        let mut it = bam.records();
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(
            pairs.clone().into_iter().take(12).collect::<Vec<_>>(),
            vec![
                [Some(0), None],
                [Some(1), None],
                [Some(2), None],
                [Some(3), None],
                [Some(4), None],
                [Some(5), None],
                [Some(6), Some(16050676)],
                [Some(7), Some(16050677)],
                [Some(8), Some(16050678)],
                [Some(9), Some(16050679)],
                [Some(10), Some(16050680)],
                [Some(11), Some(16050681)],
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(
            pairs,
            vec![
                [Some(0), Some(16096878)],
                [Some(1), Some(16096879)],
                [Some(2), Some(16096880)],
                [Some(3), Some(16096881)],
                [Some(4), Some(16096882)],
                [Some(5), Some(16096883)],
                [Some(6), Some(16096884)],
                [None, Some(16096885)],
                [None, Some(16096886)],
                [Some(7), Some(16096887)],
                [Some(8), Some(16096888)],
                [Some(9), Some(16096889)],
                [Some(10), Some(16096890)],
                [Some(11), Some(16096891)],
                [Some(12), Some(16096892)],
                [Some(13), Some(16096893)],
                [Some(14), Some(16096894)],
                [Some(15), Some(16096895)],
                [Some(16), Some(16096896)],
                [Some(17), Some(16096897)],
                [Some(18), Some(16096898)],
                [Some(19), Some(16096899)],
                [Some(20), Some(16096900)],
                [Some(21), Some(16096901)],
                [Some(22), Some(16096902)],
                [Some(23), Some(16096903)],
                [Some(24), Some(16096904)],
                [Some(25), Some(16096905)],
                [Some(26), Some(16096906)],
                [Some(27), Some(16096907)],
                [Some(28), Some(16096908)],
                [Some(29), Some(16096909)],
                [Some(30), Some(16096910)],
                [Some(31), Some(16096911)],
                [Some(32), Some(16096912)],
                [Some(33), Some(16096913)],
                [Some(34), Some(16096914)],
                [Some(35), Some(16096915)],
                [Some(36), Some(16096916)],
                [Some(37), Some(16096917)],
                [Some(38), Some(16096918)],
                [Some(39), Some(16096919)],
                [Some(40), Some(16096920)],
                [Some(41), Some(16096921)],
                [Some(42), Some(16096922)],
                [Some(43), Some(16096923)],
                [Some(44), Some(16096924)],
                [Some(45), Some(16096925)],
                [Some(46), Some(16096926)],
                [Some(47), Some(16096927)],
                [Some(48), Some(16096928)],
                [Some(49), Some(16096929)],
                [Some(50), Some(16096930)]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(
            pairs,
            vec![
                [Some(0), Some(16097145)],
                [Some(1), Some(16097146)],
                [Some(2), Some(16097147)],
                [Some(3), Some(16097148)],
                [Some(4), Some(16097149)],
                [Some(5), Some(16097150)],
                [Some(6), Some(16097151)],
                [Some(7), Some(16097152)],
                [Some(8), Some(16097153)],
                [Some(9), Some(16097154)],
                [Some(10), Some(16097155)],
                [Some(11), Some(16097156)],
                [Some(12), Some(16097157)],
                [Some(13), Some(16097158)],
                [Some(14), Some(16097159)],
                [Some(15), Some(16097160)],
                [Some(16), Some(16097161)],
                [Some(17), Some(16097162)],
                [Some(18), Some(16097163)],
                [Some(19), Some(16097164)],
                [Some(20), Some(16097165)],
                [Some(21), Some(16097166)],
                [Some(22), Some(16097167)],
                [Some(23), Some(16097168)],
                [Some(24), Some(16097169)],
                [Some(25), Some(16097170)],
                [Some(26), Some(16097171)],
                [Some(27), Some(16097172)],
                [Some(28), Some(16097173)],
                [None, Some(16097174)],
                [None, Some(16097175)],
                [Some(29), Some(16097176)],
                [Some(30), Some(16097177)],
                [Some(31), Some(16097178)],
                [Some(32), Some(16097179)],
                [Some(33), Some(16097180)],
                [Some(34), Some(16097181)],
                [Some(35), Some(16097182)],
                [Some(36), Some(16097183)],
                [Some(37), Some(16097184)],
                [Some(38), Some(16097185)],
                [Some(39), Some(16097186)],
                [Some(40), Some(16097187)],
                [Some(41), Some(16097188)],
                [Some(42), Some(16097189)],
                [Some(43), Some(16097190)],
                [Some(44), Some(16097191)],
                [Some(45), Some(16097192)],
                [Some(46), Some(16097193)],
                [Some(47), Some(16097194)],
                [Some(48), Some(16097195)],
                [Some(49), Some(16097196)],
                [Some(50), Some(16097197)]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(
            pairs,
            vec![
                [Some(0), Some(16117350)],
                [Some(1), Some(16117351)],
                [Some(2), Some(16117352)],
                [Some(3), Some(16117353)],
                [Some(4), Some(16117354)],
                [Some(5), Some(16117355)],
                [Some(6), Some(16117356)],
                [Some(7), Some(16117357)],
                [Some(8), Some(16117358)],
                [Some(9), Some(16117359)],
                [Some(10), Some(16117360)],
                [Some(11), Some(16117361)],
                [Some(12), Some(16117362)],
                [Some(13), Some(16117363)],
                [Some(14), Some(16117364)],
                [Some(15), Some(16117365)],
                [Some(16), Some(16117366)],
                [Some(17), Some(16117367)],
                [Some(18), Some(16117368)],
                [Some(19), Some(16117369)],
                [Some(20), Some(16117370)],
                [Some(21), Some(16117371)],
                [Some(22), Some(16117372)],
                [Some(23), Some(16117373)],
                [Some(24), Some(16117374)],
                [Some(25), Some(16117375)],
                [Some(26), Some(16117376)],
                [Some(27), Some(16117377)],
                [Some(28), Some(16117378)],
                [Some(29), Some(16117379)],
                [Some(30), Some(16117380)],
                [Some(31), Some(16117381)],
                [Some(32), Some(16117382)],
                [Some(33), Some(16117383)],
                [Some(34), Some(16117384)],
                [Some(35), Some(16117385)],
                [Some(36), Some(16117386)],
                [Some(37), Some(16117387)],
                [Some(38), Some(16117388)],
                [Some(39), Some(16117389)],
                [Some(40), Some(16117390)],
                [Some(41), Some(16117391)],
                [Some(42), Some(16117392)],
                [Some(43), Some(16117393)],
                [Some(44), Some(16117394)],
                [Some(45), Some(16117395)],
                [Some(46), Some(16117396)],
                [Some(47), Some(16117397)],
                [Some(48), Some(16117398)],
                [Some(49), Some(16117399)],
                [Some(50), Some(16117400)]
            ]
        );
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(
            pairs,
            vec![
                [Some(0), Some(16118483)],
                [Some(1), Some(16118484)],
                [Some(2), Some(16118485)],
                [Some(3), Some(16118486)],
                [Some(4), Some(16118487)],
                [Some(5), Some(16118488)],
                [Some(6), Some(16118489)],
                [Some(7), Some(16118490)],
                [Some(8), Some(16118491)],
                [Some(9), Some(16118492)],
                [Some(10), Some(16118493)],
                [Some(11), Some(16118494)],
                [Some(12), Some(16118495)],
                [Some(13), Some(16118496)],
                [Some(14), Some(16118497)],
                [Some(15), Some(16118498)],
                [Some(16), Some(16118499)],
                [Some(17), Some(16118500)],
                [Some(18), Some(16118501)],
                [Some(19), Some(16118502)],
                [Some(20), Some(16118503)],
                [Some(21), Some(16118504)],
                [Some(22), Some(16118505)],
                [Some(23), Some(16118506)],
                [Some(24), Some(16118507)],
                [Some(25), Some(16118508)],
                [Some(26), Some(16118509)],
                [Some(27), Some(16118510)],
                [Some(28), Some(16118511)],
                [Some(29), Some(16118512)],
                [Some(30), Some(16118513)],
                [Some(31), Some(16118514)],
                [Some(32), Some(16118515)],
                [Some(33), Some(16118516)],
                [Some(34), Some(16118517)],
                [Some(35), Some(16118518)],
                [Some(36), Some(16118519)],
                [Some(37), Some(16118520)],
                [Some(38), Some(16118521)],
                [Some(39), Some(16118522)],
                [Some(40), Some(16118523)],
                [Some(41), Some(16118524)],
                [Some(42), Some(16118525)],
                [Some(43), Some(16118526)],
                [Some(44), Some(16118527)],
                [Some(45), Some(16118528)],
                [Some(46), Some(16118529)],
                [Some(47), Some(16118530)],
                [Some(48), Some(16118531)],
                [Some(49), Some(16118532)],
                [Some(50), Some(16118533)]
            ]
        );

        //
        //for the rest, we just verify that they have the expected amount of None in each position
        fn some_count(pairs: &[[Option<i64>; 2]], pos: usize) -> i64 {
            pairs.iter().filter(|x| x[pos].is_some()).count() as i64
        }
        fn none_count(pairs: &[[Option<i64>; 2]], pos: usize) -> i64 {
            pairs.iter().filter(|x| x[pos].is_none()).count() as i64
        }

        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 0);
        assert_eq!(some_count(&pairs, 1), 51);
        assert_eq!(none_count(&pairs, 1), 0);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 0);
        assert_eq!(some_count(&pairs, 1), 51);
        assert_eq!(none_count(&pairs, 1), 0);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 0);
        assert_eq!(some_count(&pairs, 1), 51);
        assert_eq!(none_count(&pairs, 1), 0);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 0);
        assert_eq!(some_count(&pairs, 1), 51);
        assert_eq!(none_count(&pairs, 1), 0);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 0);
        assert_eq!(some_count(&pairs, 1), 45);
        assert_eq!(none_count(&pairs, 1), 6);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 0);
        assert_eq!(some_count(&pairs, 1), 41);
        assert_eq!(none_count(&pairs, 1), 10);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 0);
        assert_eq!(some_count(&pairs, 1), 51);
        assert_eq!(none_count(&pairs, 1), 0);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 0);
        assert_eq!(some_count(&pairs, 1), 51);
        assert_eq!(none_count(&pairs, 1), 0);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 0);
        assert_eq!(some_count(&pairs, 1), 51);
        assert_eq!(none_count(&pairs, 1), 0);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 0);
        assert_eq!(some_count(&pairs, 1), 51);
        assert_eq!(none_count(&pairs, 1), 0);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 0);
        assert_eq!(some_count(&pairs, 1), 42);
        assert_eq!(none_count(&pairs, 1), 9);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 0);
        assert_eq!(some_count(&pairs, 1), 51);
        assert_eq!(none_count(&pairs, 1), 0);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 0);
        assert_eq!(some_count(&pairs, 1), 50);
        assert_eq!(none_count(&pairs, 1), 1);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 0);
        assert_eq!(some_count(&pairs, 1), 45);
        assert_eq!(none_count(&pairs, 1), 6);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 0);
        assert_eq!(some_count(&pairs, 1), 48);
        assert_eq!(none_count(&pairs, 1), 3);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 0);
        assert_eq!(some_count(&pairs, 1), 42);
        assert_eq!(none_count(&pairs, 1), 9);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 0);
        assert_eq!(some_count(&pairs, 1), 38);
        assert_eq!(none_count(&pairs, 1), 13);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 0);
        assert_eq!(some_count(&pairs, 1), 44);
        assert_eq!(none_count(&pairs, 1), 7);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 0);
        assert_eq!(some_count(&pairs, 1), 46);
        assert_eq!(none_count(&pairs, 1), 5);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 0);
        assert_eq!(some_count(&pairs, 1), 47);
        assert_eq!(none_count(&pairs, 1), 4);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 0);
        assert_eq!(some_count(&pairs, 1), 50);
        assert_eq!(none_count(&pairs, 1), 1);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 2183);
        assert_eq!(some_count(&pairs, 1), 2234);
        assert_eq!(none_count(&pairs, 1), 0);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 2183);
        assert_eq!(some_count(&pairs, 1), 2234);
        assert_eq!(none_count(&pairs, 1), 0);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 2183);
        assert_eq!(some_count(&pairs, 1), 2234);
        assert_eq!(none_count(&pairs, 1), 0);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 0);
        assert_eq!(some_count(&pairs, 1), 33);
        assert_eq!(none_count(&pairs, 1), 18);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 0);
        assert_eq!(some_count(&pairs, 1), 48);
        assert_eq!(none_count(&pairs, 1), 3);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 0);
        assert_eq!(some_count(&pairs, 1), 45);
        assert_eq!(none_count(&pairs, 1), 6);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 11832);
        assert_eq!(some_count(&pairs, 1), 11883);
        assert_eq!(none_count(&pairs, 1), 0);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 12542);
        assert_eq!(some_count(&pairs, 1), 12593);
        assert_eq!(none_count(&pairs, 1), 0);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 12542);
        assert_eq!(some_count(&pairs, 1), 12593);
        assert_eq!(none_count(&pairs, 1), 0);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 12542);
        assert_eq!(some_count(&pairs, 1), 12593);
        assert_eq!(none_count(&pairs, 1), 0);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 12542);
        assert_eq!(some_count(&pairs, 1), 12593);
        assert_eq!(none_count(&pairs, 1), 0);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 12542);
        assert_eq!(some_count(&pairs, 1), 12593);
        assert_eq!(none_count(&pairs, 1), 0);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 12542);
        assert_eq!(some_count(&pairs, 1), 12593);
        assert_eq!(none_count(&pairs, 1), 0);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 12542);
        assert_eq!(some_count(&pairs, 1), 12593);
        assert_eq!(none_count(&pairs, 1), 0);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 12542);
        assert_eq!(some_count(&pairs, 1), 12593);
        assert_eq!(none_count(&pairs, 1), 0);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 1467);
        assert_eq!(some_count(&pairs, 1), 1517);
        assert_eq!(none_count(&pairs, 1), 1);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 1609);
        assert_eq!(some_count(&pairs, 1), 1660);
        assert_eq!(none_count(&pairs, 1), 0);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 1609);
        assert_eq!(some_count(&pairs, 1), 1660);
        assert_eq!(none_count(&pairs, 1), 0);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 1609);
        assert_eq!(some_count(&pairs, 1), 1660);
        assert_eq!(none_count(&pairs, 1), 0);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 95);
        assert_eq!(some_count(&pairs, 1), 145);
        assert_eq!(none_count(&pairs, 1), 1);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 538);
        assert_eq!(some_count(&pairs, 1), 588);
        assert_eq!(none_count(&pairs, 1), 1);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 538);
        assert_eq!(some_count(&pairs, 1), 588);
        assert_eq!(none_count(&pairs, 1), 1);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 538);
        assert_eq!(some_count(&pairs, 1), 588);
        assert_eq!(none_count(&pairs, 1), 1);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 1);
        assert_eq!(some_count(&pairs, 1), 51);
        assert_eq!(none_count(&pairs, 1), 1);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 1);
        assert_eq!(some_count(&pairs, 1), 49);
        assert_eq!(none_count(&pairs, 1), 3);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 1);
        assert_eq!(some_count(&pairs, 1), 45);
        assert_eq!(none_count(&pairs, 1), 7);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 0);
        assert_eq!(some_count(&pairs, 1), 39);
        assert_eq!(none_count(&pairs, 1), 12);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 1892);
        assert_eq!(some_count(&pairs, 1), 1938);
        assert_eq!(none_count(&pairs, 1), 5);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 1892);
        assert_eq!(some_count(&pairs, 1), 1941);
        assert_eq!(none_count(&pairs, 1), 2);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 2288);
        assert_eq!(some_count(&pairs, 1), 2338);
        assert_eq!(none_count(&pairs, 1), 1);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 14680);
        assert_eq!(some_count(&pairs, 1), 14729);
        assert_eq!(none_count(&pairs, 1), 2);
        let pairs: Vec<_> = it.next().unwrap().unwrap().aligned_pairs_full().collect();
        assert_eq!(some_count(&pairs, 0), 51);
        assert_eq!(none_count(&pairs, 0), 4027);
        assert_eq!(some_count(&pairs, 1), 4074);
        assert_eq!(none_count(&pairs, 1), 4);
    }

    #[test]
    fn test_aligned_block_pairs() {
        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
        let mut it = bam.records();

        let read = it.next().unwrap().unwrap();
        let pairs: Vec<_> = read.aligned_pairs().collect();
        let block_pairs: Vec<_> = read.aligned_block_pairs().collect();

        //first coordinates identical
        assert_eq!(pairs[0][0], block_pairs[0].0[0]); //read
        assert_eq!(pairs[0][1], block_pairs[0].1[0]); // genomic

        //end coordinates are + 1, so the ranges are the same...
        assert_eq!(
            pairs[pairs.len() - 1][0],
            block_pairs[block_pairs.len() - 1].0[1] - 1
        );
        assert_eq!(
            pairs[pairs.len() - 1][1],
            block_pairs[block_pairs.len() - 1].1[1] - 1
        );

        //let's see if they're really identical
        for read in it {
            let read = read.unwrap();
            let pairs: Vec<_> = read.aligned_pairs().collect();
            let block_pairs: Vec<_> = read.aligned_block_pairs().collect();
            let mut ii = 0;
            for ([read_start, read_stop], [genome_start, genome_stop]) in block_pairs {
                assert_eq!(read_stop - read_start, genome_stop - genome_start);
                for (read_pos, genome_pos) in (read_start..read_stop).zip(genome_start..genome_stop)
                {
                    assert_eq!(pairs[ii][0], read_pos);
                    assert_eq!(pairs[ii][1], genome_pos);
                    ii += 1;
                }
            }
        }
    }

    #[test]
    fn test_get_cigar_stats() {
        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
        let mut it = bam.records();

        fn to_arr(hm: HashMap<Cigar, i32>) -> [i32; 9] {
            [
                *hm.get(&Cigar::Match(0)).unwrap(),
                *hm.get(&Cigar::Ins(0)).unwrap(),
                *hm.get(&Cigar::Del(0)).unwrap(),
                *hm.get(&Cigar::RefSkip(0)).unwrap(),
                *hm.get(&Cigar::SoftClip(0)).unwrap(),
                *hm.get(&Cigar::HardClip(0)).unwrap(),
                *hm.get(&Cigar::Pad(0)).unwrap(),
                *hm.get(&Cigar::Equal(0)).unwrap(),
                *hm.get(&Cigar::Diff(0)).unwrap(),
            ]
        }

        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [45, 0, 0, 0, 6, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 2, 0, 0, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [2, 0, 1, 0, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 2, 0, 0, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [2, 0, 1, 0, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [45, 0, 0, 0, 6, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [41, 0, 0, 0, 10, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [42, 0, 0, 0, 9, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 0, 0, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [50, 0, 0, 0, 1, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [45, 0, 0, 0, 6, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [48, 0, 0, 0, 3, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [42, 0, 0, 0, 9, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [38, 0, 0, 0, 13, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [44, 0, 0, 0, 7, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [46, 0, 0, 0, 5, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 1, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [47, 4, 0, 0, 0, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [2, 1, 0, 0, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [50, 1, 0, 0, 0, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [2, 1, 0, 0, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 2183, 0, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 2183, 0, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 2183, 0, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [33, 0, 0, 0, 18, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 2, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [48, 0, 0, 0, 3, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 2, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [45, 0, 0, 0, 6, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [1, 0, 0, 0, 2, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 11832, 0, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 12542, 0, 0, 0, 0, 0],);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 12542, 0, 0, 0, 0, 0],);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 12542, 0, 0, 0, 0, 0],);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 12542, 0, 0, 0, 0, 0],);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 12542, 0, 0, 0, 0, 0],);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 12542, 0, 0, 0, 0, 0],);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 12542, 0, 0, 0, 0, 0],);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 12542, 0, 0, 0, 0, 0],);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [50, 0, 0, 1467, 1, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 1, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 1609, 0, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 1609, 0, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [51, 0, 0, 1609, 0, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 0, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [50, 0, 0, 95, 1, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 1, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [50, 0, 0, 538, 1, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 1, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [50, 0, 0, 538, 1, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 1, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [50, 0, 0, 538, 1, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 1, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [50, 0, 1, 0, 1, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [2, 0, 1, 0, 1, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [48, 0, 1, 0, 3, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [2, 0, 1, 0, 1, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [44, 0, 1, 0, 7, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [2, 0, 1, 0, 1, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [39, 1, 0, 0, 11, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [2, 1, 0, 0, 1, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [46, 0, 0, 1892, 5, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 1, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [49, 0, 0, 1892, 2, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [2, 0, 0, 1, 1, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [50, 0, 3, 2285, 1, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [3, 0, 1, 1, 1, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [49, 0, 0, 14680, 2, 0, 0, 0, 0],);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 1, 0, 0, 0, 0]);
        let read = it.next().unwrap().unwrap();
        let cigar_nucleotides = read.cigar_stats_nucleotides();
        assert_eq!(to_arr(cigar_nucleotides), [47, 0, 0, 4027, 4, 0, 0, 0, 0]);
        let cigar_blocks = read.cigar_stats_blocks();
        assert_eq!(to_arr(cigar_blocks), [3, 0, 0, 2, 1, 0, 0, 0, 0]);
    }

    #[test]
    fn test_reference_positions() {
        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
        let mut it = bam.records();

        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                16050676, 16050677, 16050678, 16050679, 16050680, 16050681, 16050682, 16050683,
                16050684, 16050685, 16050686, 16050687, 16050688, 16050689, 16050690, 16050691,
                16050692, 16050693, 16050694, 16050695, 16050696, 16050697, 16050698, 16050699,
                16050700, 16050701, 16050702, 16050703, 16050704, 16050705, 16050706, 16050707,
                16050708, 16050709, 16050710, 16050711, 16050712, 16050713, 16050714, 16050715,
                16050716, 16050717, 16050718, 16050719, 16050720
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                16096878, 16096879, 16096880, 16096881, 16096882, 16096883, 16096884, 16096887,
                16096888, 16096889, 16096890, 16096891, 16096892, 16096893, 16096894, 16096895,
                16096896, 16096897, 16096898, 16096899, 16096900, 16096901, 16096902, 16096903,
                16096904, 16096905, 16096906, 16096907, 16096908, 16096909, 16096910, 16096911,
                16096912, 16096913, 16096914, 16096915, 16096916, 16096917, 16096918, 16096919,
                16096920, 16096921, 16096922, 16096923, 16096924, 16096925, 16096926, 16096927,
                16096928, 16096929, 16096930
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                16097145, 16097146, 16097147, 16097148, 16097149, 16097150, 16097151, 16097152,
                16097153, 16097154, 16097155, 16097156, 16097157, 16097158, 16097159, 16097160,
                16097161, 16097162, 16097163, 16097164, 16097165, 16097166, 16097167, 16097168,
                16097169, 16097170, 16097171, 16097172, 16097173, 16097176, 16097177, 16097178,
                16097179, 16097180, 16097181, 16097182, 16097183, 16097184, 16097185, 16097186,
                16097187, 16097188, 16097189, 16097190, 16097191, 16097192, 16097193, 16097194,
                16097195, 16097196, 16097197
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                16117350, 16117351, 16117352, 16117353, 16117354, 16117355, 16117356, 16117357,
                16117358, 16117359, 16117360, 16117361, 16117362, 16117363, 16117364, 16117365,
                16117366, 16117367, 16117368, 16117369, 16117370, 16117371, 16117372, 16117373,
                16117374, 16117375, 16117376, 16117377, 16117378, 16117379, 16117380, 16117381,
                16117382, 16117383, 16117384, 16117385, 16117386, 16117387, 16117388, 16117389,
                16117390, 16117391, 16117392, 16117393, 16117394, 16117395, 16117396, 16117397,
                16117398, 16117399, 16117400
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                16118483, 16118484, 16118485, 16118486, 16118487, 16118488, 16118489, 16118490,
                16118491, 16118492, 16118493, 16118494, 16118495, 16118496, 16118497, 16118498,
                16118499, 16118500, 16118501, 16118502, 16118503, 16118504, 16118505, 16118506,
                16118507, 16118508, 16118509, 16118510, 16118511, 16118512, 16118513, 16118514,
                16118515, 16118516, 16118517, 16118518, 16118519, 16118520, 16118521, 16118522,
                16118523, 16118524, 16118525, 16118526, 16118527, 16118528, 16118529, 16118530,
                16118531, 16118532, 16118533
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                16118499, 16118500, 16118501, 16118502, 16118503, 16118504, 16118505, 16118506,
                16118507, 16118508, 16118509, 16118510, 16118511, 16118512, 16118513, 16118514,
                16118515, 16118516, 16118517, 16118518, 16118519, 16118520, 16118521, 16118522,
                16118523, 16118524, 16118525, 16118526, 16118527, 16118528, 16118529, 16118530,
                16118531, 16118532, 16118533, 16118534, 16118535, 16118536, 16118537, 16118538,
                16118539, 16118540, 16118541, 16118542, 16118543, 16118544, 16118545, 16118546,
                16118547, 16118548, 16118549
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                16118499, 16118500, 16118501, 16118502, 16118503, 16118504, 16118505, 16118506,
                16118507, 16118508, 16118509, 16118510, 16118511, 16118512, 16118513, 16118514,
                16118515, 16118516, 16118517, 16118518, 16118519, 16118520, 16118521, 16118522,
                16118523, 16118524, 16118525, 16118526, 16118527, 16118528, 16118529, 16118530,
                16118531, 16118532, 16118533, 16118534, 16118535, 16118536, 16118537, 16118538,
                16118539, 16118540, 16118541, 16118542, 16118543, 16118544, 16118545, 16118546,
                16118547, 16118548, 16118549
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                16118499, 16118500, 16118501, 16118502, 16118503, 16118504, 16118505, 16118506,
                16118507, 16118508, 16118509, 16118510, 16118511, 16118512, 16118513, 16118514,
                16118515, 16118516, 16118517, 16118518, 16118519, 16118520, 16118521, 16118522,
                16118523, 16118524, 16118525, 16118526, 16118527, 16118528, 16118529, 16118530,
                16118531, 16118532, 16118533, 16118534, 16118535, 16118536, 16118537, 16118538,
                16118539, 16118540, 16118541, 16118542, 16118543, 16118544, 16118545, 16118546,
                16118547, 16118548, 16118549
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                16123411, 16123412, 16123413, 16123414, 16123415, 16123416, 16123417, 16123418,
                16123419, 16123420, 16123421, 16123422, 16123423, 16123424, 16123425, 16123426,
                16123427, 16123428, 16123429, 16123430, 16123431, 16123432, 16123433, 16123434,
                16123435, 16123436, 16123437, 16123438, 16123439, 16123440, 16123441, 16123442,
                16123443, 16123444, 16123445, 16123446, 16123447, 16123448, 16123449, 16123450,
                16123451, 16123452, 16123453, 16123454, 16123455, 16123456, 16123457, 16123458,
                16123459, 16123460, 16123461
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                16123417, 16123418, 16123419, 16123420, 16123421, 16123422, 16123423, 16123424,
                16123425, 16123426, 16123427, 16123428, 16123429, 16123430, 16123431, 16123432,
                16123433, 16123434, 16123435, 16123436, 16123437, 16123438, 16123439, 16123440,
                16123441, 16123442, 16123443, 16123444, 16123445, 16123446, 16123447, 16123448,
                16123449, 16123450, 16123451, 16123452, 16123453, 16123454, 16123455, 16123456,
                16123457, 16123458, 16123459, 16123460, 16123461
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                16165860, 16165861, 16165862, 16165863, 16165864, 16165865, 16165866, 16165867,
                16165868, 16165869, 16165870, 16165871, 16165872, 16165873, 16165874, 16165875,
                16165876, 16165877, 16165878, 16165879, 16165880, 16165881, 16165882, 16165883,
                16165884, 16165885, 16165886, 16165887, 16165888, 16165889, 16165890, 16165891,
                16165892, 16165893, 16165894, 16165895, 16165896, 16165897, 16165898, 16165899,
                16165900
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                16180871, 16180872, 16180873, 16180874, 16180875, 16180876, 16180877, 16180878,
                16180879, 16180880, 16180881, 16180882, 16180883, 16180884, 16180885, 16180886,
                16180887, 16180888, 16180889, 16180890, 16180891, 16180892, 16180893, 16180894,
                16180895, 16180896, 16180897, 16180898, 16180899, 16180900, 16180901, 16180902,
                16180903, 16180904, 16180905, 16180906, 16180907, 16180908, 16180909, 16180910,
                16180911, 16180912, 16180913, 16180914, 16180915, 16180916, 16180917, 16180918,
                16180919, 16180920, 16180921
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                16189705, 16189706, 16189707, 16189708, 16189709, 16189710, 16189711, 16189712,
                16189713, 16189714, 16189715, 16189716, 16189717, 16189718, 16189719, 16189720,
                16189721, 16189722, 16189723, 16189724, 16189725, 16189726, 16189727, 16189728,
                16189729, 16189730, 16189731, 16189732, 16189733, 16189734, 16189735, 16189736,
                16189737, 16189738, 16189739, 16189740, 16189741, 16189742, 16189743, 16189744,
                16189745, 16189746, 16189747, 16189748, 16189749, 16189750, 16189751, 16189752,
                16189753, 16189754, 16189755
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                16231271, 16231272, 16231273, 16231274, 16231275, 16231276, 16231277, 16231278,
                16231279, 16231280, 16231281, 16231282, 16231283, 16231284, 16231285, 16231286,
                16231287, 16231288, 16231289, 16231290, 16231291, 16231292, 16231293, 16231294,
                16231295, 16231296, 16231297, 16231298, 16231299, 16231300, 16231301, 16231302,
                16231303, 16231304, 16231305, 16231306, 16231307, 16231308, 16231309, 16231310,
                16231311, 16231312, 16231313, 16231314, 16231315, 16231316, 16231317, 16231318,
                16231319, 16231320, 16231321
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                16237657, 16237658, 16237659, 16237660, 16237661, 16237662, 16237663, 16237664,
                16237665, 16237666, 16237667, 16237668, 16237669, 16237670, 16237671, 16237672,
                16237673, 16237674, 16237675, 16237676, 16237677, 16237678, 16237679, 16237680,
                16237681, 16237682, 16237683, 16237684, 16237685, 16237686, 16237687, 16237688,
                16237689, 16237690, 16237691, 16237692, 16237693, 16237694, 16237695, 16237696,
                16237697, 16237698, 16237699, 16237700, 16237701, 16237702, 16237703, 16237704,
                16237705, 16237706, 16237707
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                16255012, 16255013, 16255014, 16255015, 16255016, 16255017, 16255018, 16255019,
                16255020, 16255021, 16255022, 16255023, 16255024, 16255025, 16255026, 16255027,
                16255028, 16255029, 16255030, 16255031, 16255032, 16255033, 16255034, 16255035,
                16255036, 16255037, 16255038, 16255039, 16255040, 16255041, 16255042, 16255043,
                16255044, 16255045, 16255046, 16255047, 16255048, 16255049, 16255050, 16255051,
                16255052, 16255053
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                16255391, 16255392, 16255393, 16255394, 16255395, 16255396, 16255397, 16255398,
                16255399, 16255400, 16255401, 16255402, 16255403, 16255404, 16255405, 16255406,
                16255407, 16255408, 16255409, 16255410, 16255411, 16255412, 16255413, 16255414,
                16255415, 16255416, 16255417, 16255418, 16255419, 16255420, 16255421, 16255422,
                16255423, 16255424, 16255425, 16255426, 16255427, 16255428, 16255429, 16255430,
                16255431, 16255432, 16255433, 16255434, 16255435, 16255436, 16255437, 16255438,
                16255439, 16255440, 16255441
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                16255392, 16255393, 16255394, 16255395, 16255396, 16255397, 16255398, 16255399,
                16255400, 16255401, 16255402, 16255403, 16255404, 16255405, 16255406, 16255407,
                16255408, 16255409, 16255410, 16255411, 16255412, 16255413, 16255414, 16255415,
                16255416, 16255417, 16255418, 16255419, 16255420, 16255421, 16255422, 16255423,
                16255424, 16255425, 16255426, 16255427, 16255428, 16255429, 16255430, 16255431,
                16255432, 16255433, 16255434, 16255435, 16255436, 16255437, 16255438, 16255439,
                16255440, 16255441
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                16256084, 16256085, 16256086, 16256087, 16256088, 16256089, 16256090, 16256091,
                16256092, 16256093, 16256094, 16256095, 16256096, 16256097, 16256098, 16256099,
                16256100, 16256101, 16256102, 16256103, 16256104, 16256105, 16256106, 16256107,
                16256108, 16256109, 16256110, 16256111, 16256112, 16256113, 16256114, 16256115,
                16256116, 16256117, 16256118, 16256119, 16256120, 16256121, 16256122, 16256123,
                16256124, 16256125, 16256126, 16256127, 16256128
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                16256224, 16256225, 16256226, 16256227, 16256228, 16256229, 16256230, 16256231,
                16256232, 16256233, 16256234, 16256235, 16256236, 16256237, 16256238, 16256239,
                16256240, 16256241, 16256242, 16256243, 16256244, 16256245, 16256246, 16256247,
                16256248, 16256249, 16256250, 16256251, 16256252, 16256253, 16256254, 16256255,
                16256256, 16256257, 16256258, 16256259, 16256260, 16256261, 16256262, 16256263,
                16256264, 16256265, 16256266, 16256267, 16256268, 16256269, 16256270, 16256271
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                16325199, 16325200, 16325201, 16325202, 16325203, 16325204, 16325205, 16325206,
                16325207, 16325208, 16325209, 16325210, 16325211, 16325212, 16325213, 16325214,
                16325215, 16325216, 16325217, 16325218, 16325219, 16325220, 16325221, 16325222,
                16325223, 16325224, 16325225, 16325226, 16325227, 16325228, 16325229, 16325230,
                16325231, 16325232, 16325233, 16325234, 16325235, 16325236, 16325237, 16325238,
                16325239, 16325240
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                16352865, 16352866, 16352867, 16352868, 16352869, 16352870, 16352871, 16352872,
                16352873, 16352874, 16352875, 16352876, 16352877, 16352878, 16352879, 16352880,
                16352881, 16352882, 16352883, 16352884, 16352885, 16352886, 16352887, 16352888,
                16352889, 16352890, 16352891, 16352892, 16352893, 16352894, 16352895, 16352896,
                16352897, 16352898, 16352899, 16352900, 16352901, 16352902
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                16352968, 16352969, 16352970, 16352971, 16352972, 16352973, 16352974, 16352975,
                16352976, 16352977, 16352978, 16352979, 16352980, 16352981, 16352982, 16352983,
                16352984, 16352985, 16352986, 16352987, 16352988, 16352989, 16352990, 16352991,
                16352992, 16352993, 16352994, 16352995, 16352996, 16352997, 16352998, 16352999,
                16353000, 16353001, 16353002, 16353003, 16353004, 16353005, 16353006, 16353007,
                16353008, 16353009, 16353010, 16353011
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                16414998, 16414999, 16415000, 16415001, 16415002, 16415003, 16415004, 16415005,
                16415006, 16415007, 16415008, 16415009, 16415010, 16415011, 16415012, 16415013,
                16415014, 16415015, 16415016, 16415017, 16415018, 16415019, 16415020, 16415021,
                16415022, 16415023, 16415024, 16415025, 16415026, 16415027, 16415028, 16415029,
                16415030, 16415031, 16415032, 16415033, 16415034, 16415035, 16415036, 16415037,
                16415038, 16415039, 16415040, 16415041, 16415042, 16415043
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17031591, 17031592, 17031593, 17031594, 17031595, 17031596, 17031597, 17031598,
                17031599, 17031600, 17031601, 17031602, 17031603, 17031604, 17031605, 17031606,
                17031607, 17031608, 17031609, 17031610, 17031611, 17031612, 17031613, 17031614,
                17031615, 17031616, 17031617, 17031618, 17031619, 17031620, 17031621, 17031622,
                17031623, 17031624, 17031625, 17031626, 17031627, 17031628, 17031629, 17031630,
                17031631, 17031632, 17031633, 17031634, 17031635, 17031636, 17031637
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17057382, 17057383, 17057384, 17057385, 17057386, 17057387, 17057388, 17057389,
                17057390, 17057391, 17057392, 17057393, 17057394, 17057395, 17057396, 17057397,
                17057398, 17057399, 17057400, 17057401, 17057402, 17057403, 17057404, 17057405,
                17057406, 17057407, 17057408, 17057409, 17057410, 17057411, 17057412, 17057413,
                17057414, 17057415, 17057416, 17057417, 17057418, 17057419, 17057420, 17057421,
                17057422, 17057423, 17057424, 17057425, 17057426, 17057427, 17057428, 17057429,
                17057430, 17057431
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17092766, 17092767, 17092768, 17092769, 17092770, 17092771, 17092772, 17092773,
                17092774, 17092775, 17092776, 17092777, 17092778, 17092779, 17092780, 17092781,
                17092782, 17094966, 17094967, 17094968, 17094969, 17094970, 17094971, 17094972,
                17094973, 17094974, 17094975, 17094976, 17094977, 17094978, 17094979, 17094980,
                17094981, 17094982, 17094983, 17094984, 17094985, 17094986, 17094987, 17094988,
                17094989, 17094990, 17094991, 17094992, 17094993, 17094994, 17094995, 17094996,
                17094997, 17094998, 17094999
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17092782, 17094966, 17094967, 17094968, 17094969, 17094970, 17094971, 17094972,
                17094973, 17094974, 17094975, 17094976, 17094977, 17094978, 17094979, 17094980,
                17094981, 17094982, 17094983, 17094984, 17094985, 17094986, 17094987, 17094988,
                17094989, 17094990, 17094991, 17094992, 17094993, 17094994, 17094995, 17094996,
                17094997, 17094998, 17094999, 17095000, 17095001, 17095002, 17095003, 17095004,
                17095005, 17095006, 17095007, 17095008, 17095009, 17095010, 17095011, 17095012,
                17095013, 17095014, 17095015
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17092782, 17094966, 17094967, 17094968, 17094969, 17094970, 17094971, 17094972,
                17094973, 17094974, 17094975, 17094976, 17094977, 17094978, 17094979, 17094980,
                17094981, 17094982, 17094983, 17094984, 17094985, 17094986, 17094987, 17094988,
                17094989, 17094990, 17094991, 17094992, 17094993, 17094994, 17094995, 17094996,
                17094997, 17094998, 17094999, 17095000, 17095001, 17095002, 17095003, 17095004,
                17095005, 17095006, 17095007, 17095008, 17095009, 17095010, 17095011, 17095012,
                17095013, 17095014, 17095015
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17137287, 17137288, 17137289, 17137290, 17137291, 17137292, 17137293, 17137294,
                17137295, 17137296, 17137297, 17137298, 17137299, 17137300, 17137301, 17137302,
                17137303, 17137304, 17137305, 17137306, 17137307, 17137308, 17137309, 17137310,
                17137311, 17137312, 17137313, 17137314, 17137315, 17137316, 17137317, 17137318,
                17137319
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17306238, 17306239, 17306240, 17306241, 17306242, 17306243, 17306244, 17306245,
                17306246, 17306247, 17306248, 17306249, 17306250, 17306251, 17306252, 17306253,
                17306254, 17306255, 17306256, 17306257, 17306258, 17306259, 17306260, 17306261,
                17306262, 17306263, 17306264, 17306265, 17306266, 17306267, 17306268, 17306269,
                17306270, 17306271, 17306272, 17306273, 17306274, 17306275, 17306276, 17306277,
                17306278, 17306279, 17306280, 17306281, 17306282, 17306283, 17306284, 17306285
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17561868, 17561869, 17561870, 17561871, 17561872, 17561873, 17561874, 17561875,
                17561876, 17561877, 17561878, 17561879, 17561880, 17561881, 17561882, 17561883,
                17561884, 17561885, 17561886, 17561887, 17561888, 17561889, 17561890, 17561891,
                17561892, 17561893, 17561894, 17561895, 17561896, 17561897, 17561898, 17561899,
                17561900, 17561901, 17561902, 17561903, 17561904, 17561905, 17561906, 17561907,
                17561908, 17561909, 17561910, 17561911, 17561912
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17566078, 17566079, 17566080, 17566081, 17566082, 17566083, 17566084, 17566085,
                17566086, 17566087, 17566088, 17566089, 17566090, 17566091, 17566092, 17566093,
                17566094, 17566095, 17566096, 17566097, 17566098, 17566099, 17566100, 17566101,
                17566102, 17566103, 17566104, 17566105, 17566106, 17566107, 17566108, 17566109,
                17566110, 17566111, 17566112, 17566113, 17566114, 17566115, 17566116, 17566117,
                17566118, 17577951, 17577952, 17577953, 17577954, 17577955, 17577956, 17577957,
                17577958, 17577959, 17577960
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17566108, 17566109, 17566110, 17566111, 17566112, 17566113, 17566114, 17566115,
                17566116, 17566117, 17566118, 17577951, 17577952, 17577953, 17577954, 17577955,
                17577956, 17577957, 17577958, 17577959, 17577960, 17577961, 17577962, 17577963,
                17577964, 17577965, 17577966, 17577967, 17577968, 17577969, 17577970, 17577971,
                17577972, 17577973, 17577974, 17577975, 17578686, 17578687, 17578688, 17578689,
                17578690, 17578691, 17578692, 17578693, 17578694, 17578695, 17578696, 17578697,
                17578698, 17578699, 17578700
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17566111, 17566112, 17566113, 17566114, 17566115, 17566116, 17566117, 17566118,
                17577951, 17577952, 17577953, 17577954, 17577955, 17577956, 17577957, 17577958,
                17577959, 17577960, 17577961, 17577962, 17577963, 17577964, 17577965, 17577966,
                17577967, 17577968, 17577969, 17577970, 17577971, 17577972, 17577973, 17577974,
                17577975, 17578686, 17578687, 17578688, 17578689, 17578690, 17578691, 17578692,
                17578693, 17578694, 17578695, 17578696, 17578697, 17578698, 17578699, 17578700,
                17578701, 17578702, 17578703
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17566111, 17566112, 17566113, 17566114, 17566115, 17566116, 17566117, 17566118,
                17577951, 17577952, 17577953, 17577954, 17577955, 17577956, 17577957, 17577958,
                17577959, 17577960, 17577961, 17577962, 17577963, 17577964, 17577965, 17577966,
                17577967, 17577968, 17577969, 17577970, 17577971, 17577972, 17577973, 17577974,
                17577975, 17578686, 17578687, 17578688, 17578689, 17578690, 17578691, 17578692,
                17578693, 17578694, 17578695, 17578696, 17578697, 17578698, 17578699, 17578700,
                17578701, 17578702, 17578703
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17566111, 17566112, 17566113, 17566114, 17566115, 17566116, 17566117, 17566118,
                17577951, 17577952, 17577953, 17577954, 17577955, 17577956, 17577957, 17577958,
                17577959, 17577960, 17577961, 17577962, 17577963, 17577964, 17577965, 17577966,
                17577967, 17577968, 17577969, 17577970, 17577971, 17577972, 17577973, 17577974,
                17577975, 17578686, 17578687, 17578688, 17578689, 17578690, 17578691, 17578692,
                17578693, 17578694, 17578695, 17578696, 17578697, 17578698, 17578699, 17578700,
                17578701, 17578702, 17578703
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17566111, 17566112, 17566113, 17566114, 17566115, 17566116, 17566117, 17566118,
                17577951, 17577952, 17577953, 17577954, 17577955, 17577956, 17577957, 17577958,
                17577959, 17577960, 17577961, 17577962, 17577963, 17577964, 17577965, 17577966,
                17577967, 17577968, 17577969, 17577970, 17577971, 17577972, 17577973, 17577974,
                17577975, 17578686, 17578687, 17578688, 17578689, 17578690, 17578691, 17578692,
                17578693, 17578694, 17578695, 17578696, 17578697, 17578698, 17578699, 17578700,
                17578701, 17578702, 17578703
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17566112, 17566113, 17566114, 17566115, 17566116, 17566117, 17566118, 17577951,
                17577952, 17577953, 17577954, 17577955, 17577956, 17577957, 17577958, 17577959,
                17577960, 17577961, 17577962, 17577963, 17577964, 17577965, 17577966, 17577967,
                17577968, 17577969, 17577970, 17577971, 17577972, 17577973, 17577974, 17577975,
                17578686, 17578687, 17578688, 17578689, 17578690, 17578691, 17578692, 17578693,
                17578694, 17578695, 17578696, 17578697, 17578698, 17578699, 17578700, 17578701,
                17578702, 17578703, 17578704
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17566113, 17566114, 17566115, 17566116, 17566117, 17566118, 17577951, 17577952,
                17577953, 17577954, 17577955, 17577956, 17577957, 17577958, 17577959, 17577960,
                17577961, 17577962, 17577963, 17577964, 17577965, 17577966, 17577967, 17577968,
                17577969, 17577970, 17577971, 17577972, 17577973, 17577974, 17577975, 17578686,
                17578687, 17578688, 17578689, 17578690, 17578691, 17578692, 17578693, 17578694,
                17578695, 17578696, 17578697, 17578698, 17578699, 17578700, 17578701, 17578702,
                17578703, 17578704, 17578705
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17566113, 17566114, 17566115, 17566116, 17566117, 17566118, 17577951, 17577952,
                17577953, 17577954, 17577955, 17577956, 17577957, 17577958, 17577959, 17577960,
                17577961, 17577962, 17577963, 17577964, 17577965, 17577966, 17577967, 17577968,
                17577969, 17577970, 17577971, 17577972, 17577973, 17577974, 17577975, 17578686,
                17578687, 17578688, 17578689, 17578690, 17578691, 17578692, 17578693, 17578694,
                17578695, 17578696, 17578697, 17578698, 17578699, 17578700, 17578701, 17578702,
                17578703, 17578704, 17578705
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17579733, 17579734, 17579735, 17579736, 17579737, 17579738, 17579739, 17579740,
                17579741, 17579742, 17579743, 17579744, 17579745, 17579746, 17579747, 17579748,
                17579749, 17579750, 17579751, 17579752, 17579753, 17579754, 17579755, 17579756,
                17579757, 17579758, 17579759, 17579760, 17579761, 17579762, 17579763, 17579764,
                17579765, 17579766, 17579767, 17579768, 17579769, 17579770, 17579771, 17579772,
                17579773, 17579774, 17579775, 17579776, 17581244, 17581245, 17581246, 17581247,
                17581248, 17581249
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17581369, 17581370, 17582885, 17582886, 17582887, 17582888, 17582889, 17582890,
                17582891, 17582892, 17582893, 17582894, 17582895, 17582896, 17582897, 17582898,
                17582899, 17582900, 17582901, 17582902, 17582903, 17582904, 17582905, 17582906,
                17582907, 17582908, 17582909, 17582910, 17582911, 17582912, 17582913, 17582914,
                17582915, 17582916, 17582917, 17582918, 17582919, 17582920, 17582921, 17582922,
                17582923, 17582924, 17582925, 17582926, 17582927, 17582928, 17582929, 17582930,
                17582931, 17582932, 17583028
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17581370, 17582885, 17582886, 17582887, 17582888, 17582889, 17582890, 17582891,
                17582892, 17582893, 17582894, 17582895, 17582896, 17582897, 17582898, 17582899,
                17582900, 17582901, 17582902, 17582903, 17582904, 17582905, 17582906, 17582907,
                17582908, 17582909, 17582910, 17582911, 17582912, 17582913, 17582914, 17582915,
                17582916, 17582917, 17582918, 17582919, 17582920, 17582921, 17582922, 17582923,
                17582924, 17582925, 17582926, 17582927, 17582928, 17582929, 17582930, 17582931,
                17582932, 17583028, 17583029
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17581370, 17582885, 17582886, 17582887, 17582888, 17582889, 17582890, 17582891,
                17582892, 17582893, 17582894, 17582895, 17582896, 17582897, 17582898, 17582899,
                17582900, 17582901, 17582902, 17582903, 17582904, 17582905, 17582906, 17582907,
                17582908, 17582909, 17582910, 17582911, 17582912, 17582913, 17582914, 17582915,
                17582916, 17582917, 17582918, 17582919, 17582920, 17582921, 17582922, 17582923,
                17582924, 17582925, 17582926, 17582927, 17582928, 17582929, 17582930, 17582931,
                17582932, 17583028, 17583029
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17582911, 17582912, 17582913, 17582914, 17582915, 17582916, 17582917, 17582918,
                17582919, 17582920, 17582921, 17582922, 17582923, 17582924, 17582925, 17582926,
                17582927, 17582928, 17582929, 17582930, 17582931, 17582932, 17583028, 17583029,
                17583030, 17583031, 17583032, 17583033, 17583034, 17583035, 17583036, 17583037,
                17583038, 17583039, 17583040, 17583041, 17583042, 17583043, 17583044, 17583045,
                17583046, 17583047, 17583048, 17583049, 17583050, 17583051, 17583052, 17583053,
                17583054, 17583055
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17588621, 17588622, 17588623, 17588624, 17588625, 17588626, 17588627, 17588628,
                17588629, 17588630, 17588631, 17588632, 17588633, 17588634, 17588635, 17588636,
                17588637, 17588638, 17588639, 17588640, 17588641, 17588642, 17588643, 17588644,
                17588645, 17588646, 17588647, 17588648, 17588649, 17588650, 17588651, 17588652,
                17588653, 17588654, 17588655, 17588656, 17588657, 17589196, 17589197, 17589198,
                17589199, 17589200, 17589201, 17589202, 17589203, 17589204, 17589205, 17589206,
                17589207, 17589208
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17588621, 17588622, 17588623, 17588624, 17588625, 17588626, 17588627, 17588628,
                17588629, 17588630, 17588631, 17588632, 17588633, 17588634, 17588635, 17588636,
                17588637, 17588638, 17588639, 17588640, 17588641, 17588642, 17588643, 17588644,
                17588645, 17588646, 17588647, 17588648, 17588649, 17588650, 17588651, 17588652,
                17588653, 17588654, 17588655, 17588656, 17588657, 17589196, 17589197, 17589198,
                17589199, 17589200, 17589201, 17589202, 17589203, 17589204, 17589205, 17589206,
                17589207, 17589208
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17588621, 17588622, 17588623, 17588624, 17588625, 17588626, 17588627, 17588628,
                17588629, 17588630, 17588631, 17588632, 17588633, 17588634, 17588635, 17588636,
                17588637, 17588638, 17588639, 17588640, 17588641, 17588642, 17588643, 17588644,
                17588645, 17588646, 17588647, 17588648, 17588649, 17588650, 17588651, 17588652,
                17588653, 17588654, 17588655, 17588656, 17588657, 17589196, 17589197, 17589198,
                17589199, 17589200, 17589201, 17589202, 17589203, 17589204, 17589205, 17589206,
                17589207, 17589208
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17591770, 17591771, 17591772, 17591773, 17591774, 17591775, 17591776, 17591777,
                17591778, 17591779, 17591780, 17591781, 17591782, 17591783, 17591784, 17591785,
                17591786, 17591787, 17591788, 17591789, 17591790, 17591791, 17591792, 17591793,
                17591794, 17591796, 17591797, 17591798, 17591799, 17591800, 17591801, 17591802,
                17591803, 17591804, 17591805, 17591806, 17591807, 17591808, 17591809, 17591810,
                17591811, 17591812, 17591813, 17591814, 17591815, 17591816, 17591817, 17591818,
                17591819, 17591820
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17593855, 17593856, 17593857, 17593858, 17593859, 17593860, 17593861, 17593862,
                17593863, 17593864, 17593865, 17593866, 17593867, 17593868, 17593869, 17593870,
                17593871, 17593872, 17593873, 17593874, 17593875, 17593876, 17593877, 17593878,
                17593880, 17593881, 17593882, 17593883, 17593884, 17593885, 17593886, 17593887,
                17593888, 17593889, 17593890, 17593891, 17593892, 17593893, 17593894, 17593895,
                17593896, 17593897, 17593898, 17593899, 17593900, 17593901, 17593902, 17593903
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17593863, 17593864, 17593865, 17593866, 17593867, 17593868, 17593869, 17593870,
                17593871, 17593872, 17593873, 17593874, 17593875, 17593876, 17593877, 17593878,
                17593880, 17593881, 17593882, 17593883, 17593884, 17593885, 17593886, 17593887,
                17593888, 17593889, 17593890, 17593891, 17593892, 17593893, 17593894, 17593895,
                17593896, 17593897, 17593898, 17593899, 17593900, 17593901, 17593902, 17593903,
                17593904, 17593905, 17593906, 17593907
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17596476, 17596477, 17596478, 17596479, 17596480, 17596481, 17596482, 17596483,
                17596484, 17596485, 17596486, 17596487, 17596488, 17596489, 17596490, 17596491,
                17596492, 17596493, 17596494, 17596495, 17596496, 17596497, 17596498, 17596499,
                17596500, 17596501, 17596502, 17596503, 17596504, 17596505, 17596506, 17596507,
                17596508, 17596509, 17596510, 17596511, 17596512, 17596513, 17596514
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17624012, 17624013, 17624014, 17624015, 17624016, 17624017, 17624018, 17624019,
                17624020, 17625913, 17625914, 17625915, 17625916, 17625917, 17625918, 17625919,
                17625920, 17625921, 17625922, 17625923, 17625924, 17625925, 17625926, 17625927,
                17625928, 17625929, 17625930, 17625931, 17625932, 17625933, 17625934, 17625935,
                17625936, 17625937, 17625938, 17625939, 17625940, 17625941, 17625942, 17625943,
                17625944, 17625945, 17625946, 17625947, 17625948, 17625949
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                17624012, 17624013, 17624014, 17624015, 17624016, 17624017, 17624018, 17624019,
                17624020, 17625913, 17625914, 17625915, 17625916, 17625917, 17625918, 17625919,
                17625920, 17625921, 17625922, 17625923, 17625924, 17625925, 17625926, 17625927,
                17625928, 17625929, 17625930, 17625931, 17625932, 17625933, 17625934, 17625935,
                17625936, 17625937, 17625938, 17625939, 17625940, 17625941, 17625942, 17625943,
                17625944, 17625945, 17625946, 17625947, 17625948, 17625949, 17625950, 17625951,
                17625952
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                31796700, 31796701, 31796702, 31796703, 31796704, 31796705, 31796706, 31796710,
                31796711, 31796712, 31796713, 31796714, 31796715, 31796716, 31796717, 31796718,
                31796719, 31796720, 31796721, 31796722, 31796723, 31796724, 31796725, 31796726,
                31796727, 31796728, 31799014, 31799015, 31799016, 31799017, 31799018, 31799019,
                31799020, 31799021, 31799022, 31799023, 31799024, 31799025, 31799026, 31799027,
                31799028, 31799029, 31799030, 31799031, 31799032, 31799033, 31799034, 31799035,
                31799036, 31799037
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                36722692, 36722693, 36722694, 36722695, 36722696, 36722697, 36722698, 36722699,
                36722700, 36722701, 36722702, 36722703, 36722704, 36722705, 36723505, 36723506,
                36723507, 36723508, 36723509, 36723510, 36723511, 36723512, 36723513, 36723514,
                36723515, 36723516, 36723517, 36723518, 36723519, 36723520, 36723521, 36723522,
                36723523, 36723524, 36723525, 36723526, 36723527, 36723528, 36723529, 36723530,
                36723531, 36723532, 36737414, 36737415, 36737416, 36737417, 36737418, 36737419,
                36737420
            ]
        );
        let rp: Vec<i64> = it.next().unwrap().unwrap().reference_positions().collect();
        assert_eq!(
            rp,
            vec![
                44587963, 44587964, 44587965, 44587966, 44587967, 44587968, 44587969, 44587970,
                44587971, 44587972, 44587973, 44587974, 44587975, 44587976, 44587977, 44587978,
                44587979, 44587980, 44587981, 44587982, 44587983, 44589680, 44589681, 44589682,
                44589683, 44589684, 44589685, 44589686, 44589687, 44589688, 44589689, 44589690,
                44589691, 44589692, 44589693, 44589694, 44589695, 44589696, 44589697, 44589698,
                44589699, 44589700, 44589701, 44589702, 44592034, 44592035, 44592036
            ]
        );
    }

    #[test]
    fn test_reference_positions_full() {
        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
        let mut it = bam.records();

        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                None,
                None,
                None,
                None,
                None,
                None,
                Some(16050676),
                Some(16050677),
                Some(16050678),
                Some(16050679),
                Some(16050680),
                Some(16050681),
                Some(16050682),
                Some(16050683),
                Some(16050684),
                Some(16050685),
                Some(16050686),
                Some(16050687),
                Some(16050688),
                Some(16050689),
                Some(16050690),
                Some(16050691),
                Some(16050692),
                Some(16050693),
                Some(16050694),
                Some(16050695),
                Some(16050696),
                Some(16050697),
                Some(16050698),
                Some(16050699),
                Some(16050700),
                Some(16050701),
                Some(16050702),
                Some(16050703),
                Some(16050704),
                Some(16050705),
                Some(16050706),
                Some(16050707),
                Some(16050708),
                Some(16050709),
                Some(16050710),
                Some(16050711),
                Some(16050712),
                Some(16050713),
                Some(16050714),
                Some(16050715),
                Some(16050716),
                Some(16050717),
                Some(16050718),
                Some(16050719),
                Some(16050720)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(16096878),
                Some(16096879),
                Some(16096880),
                Some(16096881),
                Some(16096882),
                Some(16096883),
                Some(16096884),
                Some(16096887),
                Some(16096888),
                Some(16096889),
                Some(16096890),
                Some(16096891),
                Some(16096892),
                Some(16096893),
                Some(16096894),
                Some(16096895),
                Some(16096896),
                Some(16096897),
                Some(16096898),
                Some(16096899),
                Some(16096900),
                Some(16096901),
                Some(16096902),
                Some(16096903),
                Some(16096904),
                Some(16096905),
                Some(16096906),
                Some(16096907),
                Some(16096908),
                Some(16096909),
                Some(16096910),
                Some(16096911),
                Some(16096912),
                Some(16096913),
                Some(16096914),
                Some(16096915),
                Some(16096916),
                Some(16096917),
                Some(16096918),
                Some(16096919),
                Some(16096920),
                Some(16096921),
                Some(16096922),
                Some(16096923),
                Some(16096924),
                Some(16096925),
                Some(16096926),
                Some(16096927),
                Some(16096928),
                Some(16096929),
                Some(16096930)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(16097145),
                Some(16097146),
                Some(16097147),
                Some(16097148),
                Some(16097149),
                Some(16097150),
                Some(16097151),
                Some(16097152),
                Some(16097153),
                Some(16097154),
                Some(16097155),
                Some(16097156),
                Some(16097157),
                Some(16097158),
                Some(16097159),
                Some(16097160),
                Some(16097161),
                Some(16097162),
                Some(16097163),
                Some(16097164),
                Some(16097165),
                Some(16097166),
                Some(16097167),
                Some(16097168),
                Some(16097169),
                Some(16097170),
                Some(16097171),
                Some(16097172),
                Some(16097173),
                Some(16097176),
                Some(16097177),
                Some(16097178),
                Some(16097179),
                Some(16097180),
                Some(16097181),
                Some(16097182),
                Some(16097183),
                Some(16097184),
                Some(16097185),
                Some(16097186),
                Some(16097187),
                Some(16097188),
                Some(16097189),
                Some(16097190),
                Some(16097191),
                Some(16097192),
                Some(16097193),
                Some(16097194),
                Some(16097195),
                Some(16097196),
                Some(16097197)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(16117350),
                Some(16117351),
                Some(16117352),
                Some(16117353),
                Some(16117354),
                Some(16117355),
                Some(16117356),
                Some(16117357),
                Some(16117358),
                Some(16117359),
                Some(16117360),
                Some(16117361),
                Some(16117362),
                Some(16117363),
                Some(16117364),
                Some(16117365),
                Some(16117366),
                Some(16117367),
                Some(16117368),
                Some(16117369),
                Some(16117370),
                Some(16117371),
                Some(16117372),
                Some(16117373),
                Some(16117374),
                Some(16117375),
                Some(16117376),
                Some(16117377),
                Some(16117378),
                Some(16117379),
                Some(16117380),
                Some(16117381),
                Some(16117382),
                Some(16117383),
                Some(16117384),
                Some(16117385),
                Some(16117386),
                Some(16117387),
                Some(16117388),
                Some(16117389),
                Some(16117390),
                Some(16117391),
                Some(16117392),
                Some(16117393),
                Some(16117394),
                Some(16117395),
                Some(16117396),
                Some(16117397),
                Some(16117398),
                Some(16117399),
                Some(16117400)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(16118483),
                Some(16118484),
                Some(16118485),
                Some(16118486),
                Some(16118487),
                Some(16118488),
                Some(16118489),
                Some(16118490),
                Some(16118491),
                Some(16118492),
                Some(16118493),
                Some(16118494),
                Some(16118495),
                Some(16118496),
                Some(16118497),
                Some(16118498),
                Some(16118499),
                Some(16118500),
                Some(16118501),
                Some(16118502),
                Some(16118503),
                Some(16118504),
                Some(16118505),
                Some(16118506),
                Some(16118507),
                Some(16118508),
                Some(16118509),
                Some(16118510),
                Some(16118511),
                Some(16118512),
                Some(16118513),
                Some(16118514),
                Some(16118515),
                Some(16118516),
                Some(16118517),
                Some(16118518),
                Some(16118519),
                Some(16118520),
                Some(16118521),
                Some(16118522),
                Some(16118523),
                Some(16118524),
                Some(16118525),
                Some(16118526),
                Some(16118527),
                Some(16118528),
                Some(16118529),
                Some(16118530),
                Some(16118531),
                Some(16118532),
                Some(16118533)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(16118499),
                Some(16118500),
                Some(16118501),
                Some(16118502),
                Some(16118503),
                Some(16118504),
                Some(16118505),
                Some(16118506),
                Some(16118507),
                Some(16118508),
                Some(16118509),
                Some(16118510),
                Some(16118511),
                Some(16118512),
                Some(16118513),
                Some(16118514),
                Some(16118515),
                Some(16118516),
                Some(16118517),
                Some(16118518),
                Some(16118519),
                Some(16118520),
                Some(16118521),
                Some(16118522),
                Some(16118523),
                Some(16118524),
                Some(16118525),
                Some(16118526),
                Some(16118527),
                Some(16118528),
                Some(16118529),
                Some(16118530),
                Some(16118531),
                Some(16118532),
                Some(16118533),
                Some(16118534),
                Some(16118535),
                Some(16118536),
                Some(16118537),
                Some(16118538),
                Some(16118539),
                Some(16118540),
                Some(16118541),
                Some(16118542),
                Some(16118543),
                Some(16118544),
                Some(16118545),
                Some(16118546),
                Some(16118547),
                Some(16118548),
                Some(16118549)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(16118499),
                Some(16118500),
                Some(16118501),
                Some(16118502),
                Some(16118503),
                Some(16118504),
                Some(16118505),
                Some(16118506),
                Some(16118507),
                Some(16118508),
                Some(16118509),
                Some(16118510),
                Some(16118511),
                Some(16118512),
                Some(16118513),
                Some(16118514),
                Some(16118515),
                Some(16118516),
                Some(16118517),
                Some(16118518),
                Some(16118519),
                Some(16118520),
                Some(16118521),
                Some(16118522),
                Some(16118523),
                Some(16118524),
                Some(16118525),
                Some(16118526),
                Some(16118527),
                Some(16118528),
                Some(16118529),
                Some(16118530),
                Some(16118531),
                Some(16118532),
                Some(16118533),
                Some(16118534),
                Some(16118535),
                Some(16118536),
                Some(16118537),
                Some(16118538),
                Some(16118539),
                Some(16118540),
                Some(16118541),
                Some(16118542),
                Some(16118543),
                Some(16118544),
                Some(16118545),
                Some(16118546),
                Some(16118547),
                Some(16118548),
                Some(16118549)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(16118499),
                Some(16118500),
                Some(16118501),
                Some(16118502),
                Some(16118503),
                Some(16118504),
                Some(16118505),
                Some(16118506),
                Some(16118507),
                Some(16118508),
                Some(16118509),
                Some(16118510),
                Some(16118511),
                Some(16118512),
                Some(16118513),
                Some(16118514),
                Some(16118515),
                Some(16118516),
                Some(16118517),
                Some(16118518),
                Some(16118519),
                Some(16118520),
                Some(16118521),
                Some(16118522),
                Some(16118523),
                Some(16118524),
                Some(16118525),
                Some(16118526),
                Some(16118527),
                Some(16118528),
                Some(16118529),
                Some(16118530),
                Some(16118531),
                Some(16118532),
                Some(16118533),
                Some(16118534),
                Some(16118535),
                Some(16118536),
                Some(16118537),
                Some(16118538),
                Some(16118539),
                Some(16118540),
                Some(16118541),
                Some(16118542),
                Some(16118543),
                Some(16118544),
                Some(16118545),
                Some(16118546),
                Some(16118547),
                Some(16118548),
                Some(16118549)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(16123411),
                Some(16123412),
                Some(16123413),
                Some(16123414),
                Some(16123415),
                Some(16123416),
                Some(16123417),
                Some(16123418),
                Some(16123419),
                Some(16123420),
                Some(16123421),
                Some(16123422),
                Some(16123423),
                Some(16123424),
                Some(16123425),
                Some(16123426),
                Some(16123427),
                Some(16123428),
                Some(16123429),
                Some(16123430),
                Some(16123431),
                Some(16123432),
                Some(16123433),
                Some(16123434),
                Some(16123435),
                Some(16123436),
                Some(16123437),
                Some(16123438),
                Some(16123439),
                Some(16123440),
                Some(16123441),
                Some(16123442),
                Some(16123443),
                Some(16123444),
                Some(16123445),
                Some(16123446),
                Some(16123447),
                Some(16123448),
                Some(16123449),
                Some(16123450),
                Some(16123451),
                Some(16123452),
                Some(16123453),
                Some(16123454),
                Some(16123455),
                Some(16123456),
                Some(16123457),
                Some(16123458),
                Some(16123459),
                Some(16123460),
                Some(16123461)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                None,
                None,
                None,
                None,
                None,
                None,
                Some(16123417),
                Some(16123418),
                Some(16123419),
                Some(16123420),
                Some(16123421),
                Some(16123422),
                Some(16123423),
                Some(16123424),
                Some(16123425),
                Some(16123426),
                Some(16123427),
                Some(16123428),
                Some(16123429),
                Some(16123430),
                Some(16123431),
                Some(16123432),
                Some(16123433),
                Some(16123434),
                Some(16123435),
                Some(16123436),
                Some(16123437),
                Some(16123438),
                Some(16123439),
                Some(16123440),
                Some(16123441),
                Some(16123442),
                Some(16123443),
                Some(16123444),
                Some(16123445),
                Some(16123446),
                Some(16123447),
                Some(16123448),
                Some(16123449),
                Some(16123450),
                Some(16123451),
                Some(16123452),
                Some(16123453),
                Some(16123454),
                Some(16123455),
                Some(16123456),
                Some(16123457),
                Some(16123458),
                Some(16123459),
                Some(16123460),
                Some(16123461)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(16165860),
                Some(16165861),
                Some(16165862),
                Some(16165863),
                Some(16165864),
                Some(16165865),
                Some(16165866),
                Some(16165867),
                Some(16165868),
                Some(16165869),
                Some(16165870),
                Some(16165871),
                Some(16165872),
                Some(16165873),
                Some(16165874),
                Some(16165875),
                Some(16165876),
                Some(16165877),
                Some(16165878),
                Some(16165879),
                Some(16165880),
                Some(16165881),
                Some(16165882),
                Some(16165883),
                Some(16165884),
                Some(16165885),
                Some(16165886),
                Some(16165887),
                Some(16165888),
                Some(16165889),
                Some(16165890),
                Some(16165891),
                Some(16165892),
                Some(16165893),
                Some(16165894),
                Some(16165895),
                Some(16165896),
                Some(16165897),
                Some(16165898),
                Some(16165899),
                Some(16165900),
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(16180871),
                Some(16180872),
                Some(16180873),
                Some(16180874),
                Some(16180875),
                Some(16180876),
                Some(16180877),
                Some(16180878),
                Some(16180879),
                Some(16180880),
                Some(16180881),
                Some(16180882),
                Some(16180883),
                Some(16180884),
                Some(16180885),
                Some(16180886),
                Some(16180887),
                Some(16180888),
                Some(16180889),
                Some(16180890),
                Some(16180891),
                Some(16180892),
                Some(16180893),
                Some(16180894),
                Some(16180895),
                Some(16180896),
                Some(16180897),
                Some(16180898),
                Some(16180899),
                Some(16180900),
                Some(16180901),
                Some(16180902),
                Some(16180903),
                Some(16180904),
                Some(16180905),
                Some(16180906),
                Some(16180907),
                Some(16180908),
                Some(16180909),
                Some(16180910),
                Some(16180911),
                Some(16180912),
                Some(16180913),
                Some(16180914),
                Some(16180915),
                Some(16180916),
                Some(16180917),
                Some(16180918),
                Some(16180919),
                Some(16180920),
                Some(16180921)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(16189705),
                Some(16189706),
                Some(16189707),
                Some(16189708),
                Some(16189709),
                Some(16189710),
                Some(16189711),
                Some(16189712),
                Some(16189713),
                Some(16189714),
                Some(16189715),
                Some(16189716),
                Some(16189717),
                Some(16189718),
                Some(16189719),
                Some(16189720),
                Some(16189721),
                Some(16189722),
                Some(16189723),
                Some(16189724),
                Some(16189725),
                Some(16189726),
                Some(16189727),
                Some(16189728),
                Some(16189729),
                Some(16189730),
                Some(16189731),
                Some(16189732),
                Some(16189733),
                Some(16189734),
                Some(16189735),
                Some(16189736),
                Some(16189737),
                Some(16189738),
                Some(16189739),
                Some(16189740),
                Some(16189741),
                Some(16189742),
                Some(16189743),
                Some(16189744),
                Some(16189745),
                Some(16189746),
                Some(16189747),
                Some(16189748),
                Some(16189749),
                Some(16189750),
                Some(16189751),
                Some(16189752),
                Some(16189753),
                Some(16189754),
                Some(16189755)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(16231271),
                Some(16231272),
                Some(16231273),
                Some(16231274),
                Some(16231275),
                Some(16231276),
                Some(16231277),
                Some(16231278),
                Some(16231279),
                Some(16231280),
                Some(16231281),
                Some(16231282),
                Some(16231283),
                Some(16231284),
                Some(16231285),
                Some(16231286),
                Some(16231287),
                Some(16231288),
                Some(16231289),
                Some(16231290),
                Some(16231291),
                Some(16231292),
                Some(16231293),
                Some(16231294),
                Some(16231295),
                Some(16231296),
                Some(16231297),
                Some(16231298),
                Some(16231299),
                Some(16231300),
                Some(16231301),
                Some(16231302),
                Some(16231303),
                Some(16231304),
                Some(16231305),
                Some(16231306),
                Some(16231307),
                Some(16231308),
                Some(16231309),
                Some(16231310),
                Some(16231311),
                Some(16231312),
                Some(16231313),
                Some(16231314),
                Some(16231315),
                Some(16231316),
                Some(16231317),
                Some(16231318),
                Some(16231319),
                Some(16231320),
                Some(16231321)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(16237657),
                Some(16237658),
                Some(16237659),
                Some(16237660),
                Some(16237661),
                Some(16237662),
                Some(16237663),
                Some(16237664),
                Some(16237665),
                Some(16237666),
                Some(16237667),
                Some(16237668),
                Some(16237669),
                Some(16237670),
                Some(16237671),
                Some(16237672),
                Some(16237673),
                Some(16237674),
                Some(16237675),
                Some(16237676),
                Some(16237677),
                Some(16237678),
                Some(16237679),
                Some(16237680),
                Some(16237681),
                Some(16237682),
                Some(16237683),
                Some(16237684),
                Some(16237685),
                Some(16237686),
                Some(16237687),
                Some(16237688),
                Some(16237689),
                Some(16237690),
                Some(16237691),
                Some(16237692),
                Some(16237693),
                Some(16237694),
                Some(16237695),
                Some(16237696),
                Some(16237697),
                Some(16237698),
                Some(16237699),
                Some(16237700),
                Some(16237701),
                Some(16237702),
                Some(16237703),
                Some(16237704),
                Some(16237705),
                Some(16237706),
                Some(16237707)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                Some(16255012),
                Some(16255013),
                Some(16255014),
                Some(16255015),
                Some(16255016),
                Some(16255017),
                Some(16255018),
                Some(16255019),
                Some(16255020),
                Some(16255021),
                Some(16255022),
                Some(16255023),
                Some(16255024),
                Some(16255025),
                Some(16255026),
                Some(16255027),
                Some(16255028),
                Some(16255029),
                Some(16255030),
                Some(16255031),
                Some(16255032),
                Some(16255033),
                Some(16255034),
                Some(16255035),
                Some(16255036),
                Some(16255037),
                Some(16255038),
                Some(16255039),
                Some(16255040),
                Some(16255041),
                Some(16255042),
                Some(16255043),
                Some(16255044),
                Some(16255045),
                Some(16255046),
                Some(16255047),
                Some(16255048),
                Some(16255049),
                Some(16255050),
                Some(16255051),
                Some(16255052),
                Some(16255053)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(16255391),
                Some(16255392),
                Some(16255393),
                Some(16255394),
                Some(16255395),
                Some(16255396),
                Some(16255397),
                Some(16255398),
                Some(16255399),
                Some(16255400),
                Some(16255401),
                Some(16255402),
                Some(16255403),
                Some(16255404),
                Some(16255405),
                Some(16255406),
                Some(16255407),
                Some(16255408),
                Some(16255409),
                Some(16255410),
                Some(16255411),
                Some(16255412),
                Some(16255413),
                Some(16255414),
                Some(16255415),
                Some(16255416),
                Some(16255417),
                Some(16255418),
                Some(16255419),
                Some(16255420),
                Some(16255421),
                Some(16255422),
                Some(16255423),
                Some(16255424),
                Some(16255425),
                Some(16255426),
                Some(16255427),
                Some(16255428),
                Some(16255429),
                Some(16255430),
                Some(16255431),
                Some(16255432),
                Some(16255433),
                Some(16255434),
                Some(16255435),
                Some(16255436),
                Some(16255437),
                Some(16255438),
                Some(16255439),
                Some(16255440),
                Some(16255441)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(16255392),
                Some(16255393),
                Some(16255394),
                Some(16255395),
                Some(16255396),
                Some(16255397),
                Some(16255398),
                Some(16255399),
                Some(16255400),
                Some(16255401),
                Some(16255402),
                Some(16255403),
                Some(16255404),
                Some(16255405),
                Some(16255406),
                Some(16255407),
                Some(16255408),
                Some(16255409),
                Some(16255410),
                Some(16255411),
                Some(16255412),
                Some(16255413),
                Some(16255414),
                Some(16255415),
                Some(16255416),
                Some(16255417),
                Some(16255418),
                Some(16255419),
                Some(16255420),
                Some(16255421),
                Some(16255422),
                Some(16255423),
                Some(16255424),
                Some(16255425),
                Some(16255426),
                Some(16255427),
                Some(16255428),
                Some(16255429),
                Some(16255430),
                Some(16255431),
                Some(16255432),
                Some(16255433),
                Some(16255434),
                Some(16255435),
                Some(16255436),
                Some(16255437),
                Some(16255438),
                Some(16255439),
                Some(16255440),
                Some(16255441),
                None
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(16256084),
                Some(16256085),
                Some(16256086),
                Some(16256087),
                Some(16256088),
                Some(16256089),
                Some(16256090),
                Some(16256091),
                Some(16256092),
                Some(16256093),
                Some(16256094),
                Some(16256095),
                Some(16256096),
                Some(16256097),
                Some(16256098),
                Some(16256099),
                Some(16256100),
                Some(16256101),
                Some(16256102),
                Some(16256103),
                Some(16256104),
                Some(16256105),
                Some(16256106),
                Some(16256107),
                Some(16256108),
                Some(16256109),
                Some(16256110),
                Some(16256111),
                Some(16256112),
                Some(16256113),
                Some(16256114),
                Some(16256115),
                Some(16256116),
                Some(16256117),
                Some(16256118),
                Some(16256119),
                Some(16256120),
                Some(16256121),
                Some(16256122),
                Some(16256123),
                Some(16256124),
                Some(16256125),
                Some(16256126),
                Some(16256127),
                Some(16256128),
                None,
                None,
                None,
                None,
                None,
                None
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                None,
                None,
                None,
                Some(16256224),
                Some(16256225),
                Some(16256226),
                Some(16256227),
                Some(16256228),
                Some(16256229),
                Some(16256230),
                Some(16256231),
                Some(16256232),
                Some(16256233),
                Some(16256234),
                Some(16256235),
                Some(16256236),
                Some(16256237),
                Some(16256238),
                Some(16256239),
                Some(16256240),
                Some(16256241),
                Some(16256242),
                Some(16256243),
                Some(16256244),
                Some(16256245),
                Some(16256246),
                Some(16256247),
                Some(16256248),
                Some(16256249),
                Some(16256250),
                Some(16256251),
                Some(16256252),
                Some(16256253),
                Some(16256254),
                Some(16256255),
                Some(16256256),
                Some(16256257),
                Some(16256258),
                Some(16256259),
                Some(16256260),
                Some(16256261),
                Some(16256262),
                Some(16256263),
                Some(16256264),
                Some(16256265),
                Some(16256266),
                Some(16256267),
                Some(16256268),
                Some(16256269),
                Some(16256270),
                Some(16256271)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(16325199),
                Some(16325200),
                Some(16325201),
                Some(16325202),
                Some(16325203),
                Some(16325204),
                Some(16325205),
                Some(16325206),
                Some(16325207),
                Some(16325208),
                Some(16325209),
                Some(16325210),
                Some(16325211),
                Some(16325212),
                Some(16325213),
                Some(16325214),
                Some(16325215),
                Some(16325216),
                Some(16325217),
                Some(16325218),
                Some(16325219),
                Some(16325220),
                Some(16325221),
                Some(16325222),
                Some(16325223),
                Some(16325224),
                Some(16325225),
                Some(16325226),
                Some(16325227),
                Some(16325228),
                Some(16325229),
                Some(16325230),
                Some(16325231),
                Some(16325232),
                Some(16325233),
                Some(16325234),
                Some(16325235),
                Some(16325236),
                Some(16325237),
                Some(16325238),
                Some(16325239),
                Some(16325240),
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                Some(16352865),
                Some(16352866),
                Some(16352867),
                Some(16352868),
                Some(16352869),
                Some(16352870),
                Some(16352871),
                Some(16352872),
                Some(16352873),
                Some(16352874),
                Some(16352875),
                Some(16352876),
                Some(16352877),
                Some(16352878),
                Some(16352879),
                Some(16352880),
                Some(16352881),
                Some(16352882),
                Some(16352883),
                Some(16352884),
                Some(16352885),
                Some(16352886),
                Some(16352887),
                Some(16352888),
                Some(16352889),
                Some(16352890),
                Some(16352891),
                Some(16352892),
                Some(16352893),
                Some(16352894),
                Some(16352895),
                Some(16352896),
                Some(16352897),
                Some(16352898),
                Some(16352899),
                Some(16352900),
                Some(16352901),
                Some(16352902)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(16352968),
                Some(16352969),
                Some(16352970),
                Some(16352971),
                Some(16352972),
                Some(16352973),
                Some(16352974),
                Some(16352975),
                Some(16352976),
                Some(16352977),
                Some(16352978),
                Some(16352979),
                Some(16352980),
                Some(16352981),
                Some(16352982),
                Some(16352983),
                Some(16352984),
                Some(16352985),
                Some(16352986),
                Some(16352987),
                Some(16352988),
                Some(16352989),
                Some(16352990),
                Some(16352991),
                Some(16352992),
                Some(16352993),
                Some(16352994),
                Some(16352995),
                Some(16352996),
                Some(16352997),
                Some(16352998),
                Some(16352999),
                Some(16353000),
                Some(16353001),
                Some(16353002),
                Some(16353003),
                Some(16353004),
                Some(16353005),
                Some(16353006),
                Some(16353007),
                Some(16353008),
                Some(16353009),
                Some(16353010),
                Some(16353011),
                None,
                None,
                None,
                None,
                None,
                None,
                None
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                None,
                None,
                None,
                None,
                None,
                Some(16414998),
                Some(16414999),
                Some(16415000),
                Some(16415001),
                Some(16415002),
                Some(16415003),
                Some(16415004),
                Some(16415005),
                Some(16415006),
                Some(16415007),
                Some(16415008),
                Some(16415009),
                Some(16415010),
                Some(16415011),
                Some(16415012),
                Some(16415013),
                Some(16415014),
                Some(16415015),
                Some(16415016),
                Some(16415017),
                Some(16415018),
                Some(16415019),
                Some(16415020),
                Some(16415021),
                Some(16415022),
                Some(16415023),
                Some(16415024),
                Some(16415025),
                Some(16415026),
                Some(16415027),
                Some(16415028),
                Some(16415029),
                Some(16415030),
                Some(16415031),
                Some(16415032),
                Some(16415033),
                Some(16415034),
                Some(16415035),
                Some(16415036),
                Some(16415037),
                Some(16415038),
                Some(16415039),
                Some(16415040),
                Some(16415041),
                Some(16415042),
                Some(16415043)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(17031591),
                Some(17031592),
                Some(17031593),
                Some(17031594),
                Some(17031595),
                Some(17031596),
                Some(17031597),
                Some(17031598),
                Some(17031599),
                Some(17031600),
                Some(17031601),
                Some(17031602),
                Some(17031603),
                Some(17031604),
                Some(17031605),
                Some(17031606),
                Some(17031607),
                Some(17031608),
                Some(17031609),
                Some(17031610),
                Some(17031611),
                Some(17031612),
                Some(17031613),
                None,
                None,
                None,
                None,
                Some(17031614),
                Some(17031615),
                Some(17031616),
                Some(17031617),
                Some(17031618),
                Some(17031619),
                Some(17031620),
                Some(17031621),
                Some(17031622),
                Some(17031623),
                Some(17031624),
                Some(17031625),
                Some(17031626),
                Some(17031627),
                Some(17031628),
                Some(17031629),
                Some(17031630),
                Some(17031631),
                Some(17031632),
                Some(17031633),
                Some(17031634),
                Some(17031635),
                Some(17031636),
                Some(17031637)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(17057382),
                Some(17057383),
                Some(17057384),
                Some(17057385),
                Some(17057386),
                Some(17057387),
                Some(17057388),
                Some(17057389),
                Some(17057390),
                Some(17057391),
                Some(17057392),
                Some(17057393),
                Some(17057394),
                Some(17057395),
                Some(17057396),
                Some(17057397),
                Some(17057398),
                Some(17057399),
                None,
                Some(17057400),
                Some(17057401),
                Some(17057402),
                Some(17057403),
                Some(17057404),
                Some(17057405),
                Some(17057406),
                Some(17057407),
                Some(17057408),
                Some(17057409),
                Some(17057410),
                Some(17057411),
                Some(17057412),
                Some(17057413),
                Some(17057414),
                Some(17057415),
                Some(17057416),
                Some(17057417),
                Some(17057418),
                Some(17057419),
                Some(17057420),
                Some(17057421),
                Some(17057422),
                Some(17057423),
                Some(17057424),
                Some(17057425),
                Some(17057426),
                Some(17057427),
                Some(17057428),
                Some(17057429),
                Some(17057430),
                Some(17057431)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(17092766),
                Some(17092767),
                Some(17092768),
                Some(17092769),
                Some(17092770),
                Some(17092771),
                Some(17092772),
                Some(17092773),
                Some(17092774),
                Some(17092775),
                Some(17092776),
                Some(17092777),
                Some(17092778),
                Some(17092779),
                Some(17092780),
                Some(17092781),
                Some(17092782),
                Some(17094966),
                Some(17094967),
                Some(17094968),
                Some(17094969),
                Some(17094970),
                Some(17094971),
                Some(17094972),
                Some(17094973),
                Some(17094974),
                Some(17094975),
                Some(17094976),
                Some(17094977),
                Some(17094978),
                Some(17094979),
                Some(17094980),
                Some(17094981),
                Some(17094982),
                Some(17094983),
                Some(17094984),
                Some(17094985),
                Some(17094986),
                Some(17094987),
                Some(17094988),
                Some(17094989),
                Some(17094990),
                Some(17094991),
                Some(17094992),
                Some(17094993),
                Some(17094994),
                Some(17094995),
                Some(17094996),
                Some(17094997),
                Some(17094998),
                Some(17094999)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(17092782),
                Some(17094966),
                Some(17094967),
                Some(17094968),
                Some(17094969),
                Some(17094970),
                Some(17094971),
                Some(17094972),
                Some(17094973),
                Some(17094974),
                Some(17094975),
                Some(17094976),
                Some(17094977),
                Some(17094978),
                Some(17094979),
                Some(17094980),
                Some(17094981),
                Some(17094982),
                Some(17094983),
                Some(17094984),
                Some(17094985),
                Some(17094986),
                Some(17094987),
                Some(17094988),
                Some(17094989),
                Some(17094990),
                Some(17094991),
                Some(17094992),
                Some(17094993),
                Some(17094994),
                Some(17094995),
                Some(17094996),
                Some(17094997),
                Some(17094998),
                Some(17094999),
                Some(17095000),
                Some(17095001),
                Some(17095002),
                Some(17095003),
                Some(17095004),
                Some(17095005),
                Some(17095006),
                Some(17095007),
                Some(17095008),
                Some(17095009),
                Some(17095010),
                Some(17095011),
                Some(17095012),
                Some(17095013),
                Some(17095014),
                Some(17095015)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(17092782),
                Some(17094966),
                Some(17094967),
                Some(17094968),
                Some(17094969),
                Some(17094970),
                Some(17094971),
                Some(17094972),
                Some(17094973),
                Some(17094974),
                Some(17094975),
                Some(17094976),
                Some(17094977),
                Some(17094978),
                Some(17094979),
                Some(17094980),
                Some(17094981),
                Some(17094982),
                Some(17094983),
                Some(17094984),
                Some(17094985),
                Some(17094986),
                Some(17094987),
                Some(17094988),
                Some(17094989),
                Some(17094990),
                Some(17094991),
                Some(17094992),
                Some(17094993),
                Some(17094994),
                Some(17094995),
                Some(17094996),
                Some(17094997),
                Some(17094998),
                Some(17094999),
                Some(17095000),
                Some(17095001),
                Some(17095002),
                Some(17095003),
                Some(17095004),
                Some(17095005),
                Some(17095006),
                Some(17095007),
                Some(17095008),
                Some(17095009),
                Some(17095010),
                Some(17095011),
                Some(17095012),
                Some(17095013),
                Some(17095014),
                Some(17095015)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                Some(17137287),
                Some(17137288),
                Some(17137289),
                Some(17137290),
                Some(17137291),
                Some(17137292),
                Some(17137293),
                Some(17137294),
                Some(17137295),
                Some(17137296),
                Some(17137297),
                Some(17137298),
                Some(17137299),
                Some(17137300),
                Some(17137301),
                Some(17137302),
                Some(17137303),
                Some(17137304),
                Some(17137305),
                Some(17137306),
                Some(17137307),
                Some(17137308),
                Some(17137309),
                Some(17137310),
                Some(17137311),
                Some(17137312),
                Some(17137313),
                Some(17137314),
                Some(17137315),
                Some(17137316),
                Some(17137317),
                Some(17137318),
                Some(17137319),
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                None,
                None,
                Some(17306238),
                Some(17306239),
                Some(17306240),
                Some(17306241),
                Some(17306242),
                Some(17306243),
                Some(17306244),
                Some(17306245),
                Some(17306246),
                Some(17306247),
                Some(17306248),
                Some(17306249),
                Some(17306250),
                Some(17306251),
                Some(17306252),
                Some(17306253),
                Some(17306254),
                Some(17306255),
                Some(17306256),
                Some(17306257),
                Some(17306258),
                Some(17306259),
                Some(17306260),
                Some(17306261),
                Some(17306262),
                Some(17306263),
                Some(17306264),
                Some(17306265),
                Some(17306266),
                Some(17306267),
                Some(17306268),
                Some(17306269),
                Some(17306270),
                Some(17306271),
                Some(17306272),
                Some(17306273),
                Some(17306274),
                Some(17306275),
                Some(17306276),
                Some(17306277),
                Some(17306278),
                Some(17306279),
                Some(17306280),
                Some(17306281),
                Some(17306282),
                Some(17306283),
                Some(17306284),
                Some(17306285),
                None
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                None,
                None,
                None,
                None,
                Some(17561868),
                Some(17561869),
                Some(17561870),
                Some(17561871),
                Some(17561872),
                Some(17561873),
                Some(17561874),
                Some(17561875),
                Some(17561876),
                Some(17561877),
                Some(17561878),
                Some(17561879),
                Some(17561880),
                Some(17561881),
                Some(17561882),
                Some(17561883),
                Some(17561884),
                Some(17561885),
                Some(17561886),
                Some(17561887),
                Some(17561888),
                Some(17561889),
                Some(17561890),
                Some(17561891),
                Some(17561892),
                Some(17561893),
                Some(17561894),
                Some(17561895),
                Some(17561896),
                Some(17561897),
                Some(17561898),
                Some(17561899),
                Some(17561900),
                Some(17561901),
                Some(17561902),
                Some(17561903),
                Some(17561904),
                Some(17561905),
                Some(17561906),
                Some(17561907),
                Some(17561908),
                Some(17561909),
                Some(17561910),
                Some(17561911),
                Some(17561912),
                None,
                None
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(17566078),
                Some(17566079),
                Some(17566080),
                Some(17566081),
                Some(17566082),
                Some(17566083),
                Some(17566084),
                Some(17566085),
                Some(17566086),
                Some(17566087),
                Some(17566088),
                Some(17566089),
                Some(17566090),
                Some(17566091),
                Some(17566092),
                Some(17566093),
                Some(17566094),
                Some(17566095),
                Some(17566096),
                Some(17566097),
                Some(17566098),
                Some(17566099),
                Some(17566100),
                Some(17566101),
                Some(17566102),
                Some(17566103),
                Some(17566104),
                Some(17566105),
                Some(17566106),
                Some(17566107),
                Some(17566108),
                Some(17566109),
                Some(17566110),
                Some(17566111),
                Some(17566112),
                Some(17566113),
                Some(17566114),
                Some(17566115),
                Some(17566116),
                Some(17566117),
                Some(17566118),
                Some(17577951),
                Some(17577952),
                Some(17577953),
                Some(17577954),
                Some(17577955),
                Some(17577956),
                Some(17577957),
                Some(17577958),
                Some(17577959),
                Some(17577960)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(17566108),
                Some(17566109),
                Some(17566110),
                Some(17566111),
                Some(17566112),
                Some(17566113),
                Some(17566114),
                Some(17566115),
                Some(17566116),
                Some(17566117),
                Some(17566118),
                Some(17577951),
                Some(17577952),
                Some(17577953),
                Some(17577954),
                Some(17577955),
                Some(17577956),
                Some(17577957),
                Some(17577958),
                Some(17577959),
                Some(17577960),
                Some(17577961),
                Some(17577962),
                Some(17577963),
                Some(17577964),
                Some(17577965),
                Some(17577966),
                Some(17577967),
                Some(17577968),
                Some(17577969),
                Some(17577970),
                Some(17577971),
                Some(17577972),
                Some(17577973),
                Some(17577974),
                Some(17577975),
                Some(17578686),
                Some(17578687),
                Some(17578688),
                Some(17578689),
                Some(17578690),
                Some(17578691),
                Some(17578692),
                Some(17578693),
                Some(17578694),
                Some(17578695),
                Some(17578696),
                Some(17578697),
                Some(17578698),
                Some(17578699),
                Some(17578700)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(17566111),
                Some(17566112),
                Some(17566113),
                Some(17566114),
                Some(17566115),
                Some(17566116),
                Some(17566117),
                Some(17566118),
                Some(17577951),
                Some(17577952),
                Some(17577953),
                Some(17577954),
                Some(17577955),
                Some(17577956),
                Some(17577957),
                Some(17577958),
                Some(17577959),
                Some(17577960),
                Some(17577961),
                Some(17577962),
                Some(17577963),
                Some(17577964),
                Some(17577965),
                Some(17577966),
                Some(17577967),
                Some(17577968),
                Some(17577969),
                Some(17577970),
                Some(17577971),
                Some(17577972),
                Some(17577973),
                Some(17577974),
                Some(17577975),
                Some(17578686),
                Some(17578687),
                Some(17578688),
                Some(17578689),
                Some(17578690),
                Some(17578691),
                Some(17578692),
                Some(17578693),
                Some(17578694),
                Some(17578695),
                Some(17578696),
                Some(17578697),
                Some(17578698),
                Some(17578699),
                Some(17578700),
                Some(17578701),
                Some(17578702),
                Some(17578703)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(17566111),
                Some(17566112),
                Some(17566113),
                Some(17566114),
                Some(17566115),
                Some(17566116),
                Some(17566117),
                Some(17566118),
                Some(17577951),
                Some(17577952),
                Some(17577953),
                Some(17577954),
                Some(17577955),
                Some(17577956),
                Some(17577957),
                Some(17577958),
                Some(17577959),
                Some(17577960),
                Some(17577961),
                Some(17577962),
                Some(17577963),
                Some(17577964),
                Some(17577965),
                Some(17577966),
                Some(17577967),
                Some(17577968),
                Some(17577969),
                Some(17577970),
                Some(17577971),
                Some(17577972),
                Some(17577973),
                Some(17577974),
                Some(17577975),
                Some(17578686),
                Some(17578687),
                Some(17578688),
                Some(17578689),
                Some(17578690),
                Some(17578691),
                Some(17578692),
                Some(17578693),
                Some(17578694),
                Some(17578695),
                Some(17578696),
                Some(17578697),
                Some(17578698),
                Some(17578699),
                Some(17578700),
                Some(17578701),
                Some(17578702),
                Some(17578703)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(17566111),
                Some(17566112),
                Some(17566113),
                Some(17566114),
                Some(17566115),
                Some(17566116),
                Some(17566117),
                Some(17566118),
                Some(17577951),
                Some(17577952),
                Some(17577953),
                Some(17577954),
                Some(17577955),
                Some(17577956),
                Some(17577957),
                Some(17577958),
                Some(17577959),
                Some(17577960),
                Some(17577961),
                Some(17577962),
                Some(17577963),
                Some(17577964),
                Some(17577965),
                Some(17577966),
                Some(17577967),
                Some(17577968),
                Some(17577969),
                Some(17577970),
                Some(17577971),
                Some(17577972),
                Some(17577973),
                Some(17577974),
                Some(17577975),
                Some(17578686),
                Some(17578687),
                Some(17578688),
                Some(17578689),
                Some(17578690),
                Some(17578691),
                Some(17578692),
                Some(17578693),
                Some(17578694),
                Some(17578695),
                Some(17578696),
                Some(17578697),
                Some(17578698),
                Some(17578699),
                Some(17578700),
                Some(17578701),
                Some(17578702),
                Some(17578703)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(17566111),
                Some(17566112),
                Some(17566113),
                Some(17566114),
                Some(17566115),
                Some(17566116),
                Some(17566117),
                Some(17566118),
                Some(17577951),
                Some(17577952),
                Some(17577953),
                Some(17577954),
                Some(17577955),
                Some(17577956),
                Some(17577957),
                Some(17577958),
                Some(17577959),
                Some(17577960),
                Some(17577961),
                Some(17577962),
                Some(17577963),
                Some(17577964),
                Some(17577965),
                Some(17577966),
                Some(17577967),
                Some(17577968),
                Some(17577969),
                Some(17577970),
                Some(17577971),
                Some(17577972),
                Some(17577973),
                Some(17577974),
                Some(17577975),
                Some(17578686),
                Some(17578687),
                Some(17578688),
                Some(17578689),
                Some(17578690),
                Some(17578691),
                Some(17578692),
                Some(17578693),
                Some(17578694),
                Some(17578695),
                Some(17578696),
                Some(17578697),
                Some(17578698),
                Some(17578699),
                Some(17578700),
                Some(17578701),
                Some(17578702),
                Some(17578703)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(17566112),
                Some(17566113),
                Some(17566114),
                Some(17566115),
                Some(17566116),
                Some(17566117),
                Some(17566118),
                Some(17577951),
                Some(17577952),
                Some(17577953),
                Some(17577954),
                Some(17577955),
                Some(17577956),
                Some(17577957),
                Some(17577958),
                Some(17577959),
                Some(17577960),
                Some(17577961),
                Some(17577962),
                Some(17577963),
                Some(17577964),
                Some(17577965),
                Some(17577966),
                Some(17577967),
                Some(17577968),
                Some(17577969),
                Some(17577970),
                Some(17577971),
                Some(17577972),
                Some(17577973),
                Some(17577974),
                Some(17577975),
                Some(17578686),
                Some(17578687),
                Some(17578688),
                Some(17578689),
                Some(17578690),
                Some(17578691),
                Some(17578692),
                Some(17578693),
                Some(17578694),
                Some(17578695),
                Some(17578696),
                Some(17578697),
                Some(17578698),
                Some(17578699),
                Some(17578700),
                Some(17578701),
                Some(17578702),
                Some(17578703),
                Some(17578704)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(17566113),
                Some(17566114),
                Some(17566115),
                Some(17566116),
                Some(17566117),
                Some(17566118),
                Some(17577951),
                Some(17577952),
                Some(17577953),
                Some(17577954),
                Some(17577955),
                Some(17577956),
                Some(17577957),
                Some(17577958),
                Some(17577959),
                Some(17577960),
                Some(17577961),
                Some(17577962),
                Some(17577963),
                Some(17577964),
                Some(17577965),
                Some(17577966),
                Some(17577967),
                Some(17577968),
                Some(17577969),
                Some(17577970),
                Some(17577971),
                Some(17577972),
                Some(17577973),
                Some(17577974),
                Some(17577975),
                Some(17578686),
                Some(17578687),
                Some(17578688),
                Some(17578689),
                Some(17578690),
                Some(17578691),
                Some(17578692),
                Some(17578693),
                Some(17578694),
                Some(17578695),
                Some(17578696),
                Some(17578697),
                Some(17578698),
                Some(17578699),
                Some(17578700),
                Some(17578701),
                Some(17578702),
                Some(17578703),
                Some(17578704),
                Some(17578705)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(17566113),
                Some(17566114),
                Some(17566115),
                Some(17566116),
                Some(17566117),
                Some(17566118),
                Some(17577951),
                Some(17577952),
                Some(17577953),
                Some(17577954),
                Some(17577955),
                Some(17577956),
                Some(17577957),
                Some(17577958),
                Some(17577959),
                Some(17577960),
                Some(17577961),
                Some(17577962),
                Some(17577963),
                Some(17577964),
                Some(17577965),
                Some(17577966),
                Some(17577967),
                Some(17577968),
                Some(17577969),
                Some(17577970),
                Some(17577971),
                Some(17577972),
                Some(17577973),
                Some(17577974),
                Some(17577975),
                Some(17578686),
                Some(17578687),
                Some(17578688),
                Some(17578689),
                Some(17578690),
                Some(17578691),
                Some(17578692),
                Some(17578693),
                Some(17578694),
                Some(17578695),
                Some(17578696),
                Some(17578697),
                Some(17578698),
                Some(17578699),
                Some(17578700),
                Some(17578701),
                Some(17578702),
                Some(17578703),
                Some(17578704),
                Some(17578705)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                None,
                Some(17579733),
                Some(17579734),
                Some(17579735),
                Some(17579736),
                Some(17579737),
                Some(17579738),
                Some(17579739),
                Some(17579740),
                Some(17579741),
                Some(17579742),
                Some(17579743),
                Some(17579744),
                Some(17579745),
                Some(17579746),
                Some(17579747),
                Some(17579748),
                Some(17579749),
                Some(17579750),
                Some(17579751),
                Some(17579752),
                Some(17579753),
                Some(17579754),
                Some(17579755),
                Some(17579756),
                Some(17579757),
                Some(17579758),
                Some(17579759),
                Some(17579760),
                Some(17579761),
                Some(17579762),
                Some(17579763),
                Some(17579764),
                Some(17579765),
                Some(17579766),
                Some(17579767),
                Some(17579768),
                Some(17579769),
                Some(17579770),
                Some(17579771),
                Some(17579772),
                Some(17579773),
                Some(17579774),
                Some(17579775),
                Some(17579776),
                Some(17581244),
                Some(17581245),
                Some(17581246),
                Some(17581247),
                Some(17581248),
                Some(17581249)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(17581369),
                Some(17581370),
                Some(17582885),
                Some(17582886),
                Some(17582887),
                Some(17582888),
                Some(17582889),
                Some(17582890),
                Some(17582891),
                Some(17582892),
                Some(17582893),
                Some(17582894),
                Some(17582895),
                Some(17582896),
                Some(17582897),
                Some(17582898),
                Some(17582899),
                Some(17582900),
                Some(17582901),
                Some(17582902),
                Some(17582903),
                Some(17582904),
                Some(17582905),
                Some(17582906),
                Some(17582907),
                Some(17582908),
                Some(17582909),
                Some(17582910),
                Some(17582911),
                Some(17582912),
                Some(17582913),
                Some(17582914),
                Some(17582915),
                Some(17582916),
                Some(17582917),
                Some(17582918),
                Some(17582919),
                Some(17582920),
                Some(17582921),
                Some(17582922),
                Some(17582923),
                Some(17582924),
                Some(17582925),
                Some(17582926),
                Some(17582927),
                Some(17582928),
                Some(17582929),
                Some(17582930),
                Some(17582931),
                Some(17582932),
                Some(17583028)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(17581370),
                Some(17582885),
                Some(17582886),
                Some(17582887),
                Some(17582888),
                Some(17582889),
                Some(17582890),
                Some(17582891),
                Some(17582892),
                Some(17582893),
                Some(17582894),
                Some(17582895),
                Some(17582896),
                Some(17582897),
                Some(17582898),
                Some(17582899),
                Some(17582900),
                Some(17582901),
                Some(17582902),
                Some(17582903),
                Some(17582904),
                Some(17582905),
                Some(17582906),
                Some(17582907),
                Some(17582908),
                Some(17582909),
                Some(17582910),
                Some(17582911),
                Some(17582912),
                Some(17582913),
                Some(17582914),
                Some(17582915),
                Some(17582916),
                Some(17582917),
                Some(17582918),
                Some(17582919),
                Some(17582920),
                Some(17582921),
                Some(17582922),
                Some(17582923),
                Some(17582924),
                Some(17582925),
                Some(17582926),
                Some(17582927),
                Some(17582928),
                Some(17582929),
                Some(17582930),
                Some(17582931),
                Some(17582932),
                Some(17583028),
                Some(17583029)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(17581370),
                Some(17582885),
                Some(17582886),
                Some(17582887),
                Some(17582888),
                Some(17582889),
                Some(17582890),
                Some(17582891),
                Some(17582892),
                Some(17582893),
                Some(17582894),
                Some(17582895),
                Some(17582896),
                Some(17582897),
                Some(17582898),
                Some(17582899),
                Some(17582900),
                Some(17582901),
                Some(17582902),
                Some(17582903),
                Some(17582904),
                Some(17582905),
                Some(17582906),
                Some(17582907),
                Some(17582908),
                Some(17582909),
                Some(17582910),
                Some(17582911),
                Some(17582912),
                Some(17582913),
                Some(17582914),
                Some(17582915),
                Some(17582916),
                Some(17582917),
                Some(17582918),
                Some(17582919),
                Some(17582920),
                Some(17582921),
                Some(17582922),
                Some(17582923),
                Some(17582924),
                Some(17582925),
                Some(17582926),
                Some(17582927),
                Some(17582928),
                Some(17582929),
                Some(17582930),
                Some(17582931),
                Some(17582932),
                Some(17583028),
                Some(17583029)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                None,
                Some(17582911),
                Some(17582912),
                Some(17582913),
                Some(17582914),
                Some(17582915),
                Some(17582916),
                Some(17582917),
                Some(17582918),
                Some(17582919),
                Some(17582920),
                Some(17582921),
                Some(17582922),
                Some(17582923),
                Some(17582924),
                Some(17582925),
                Some(17582926),
                Some(17582927),
                Some(17582928),
                Some(17582929),
                Some(17582930),
                Some(17582931),
                Some(17582932),
                Some(17583028),
                Some(17583029),
                Some(17583030),
                Some(17583031),
                Some(17583032),
                Some(17583033),
                Some(17583034),
                Some(17583035),
                Some(17583036),
                Some(17583037),
                Some(17583038),
                Some(17583039),
                Some(17583040),
                Some(17583041),
                Some(17583042),
                Some(17583043),
                Some(17583044),
                Some(17583045),
                Some(17583046),
                Some(17583047),
                Some(17583048),
                Some(17583049),
                Some(17583050),
                Some(17583051),
                Some(17583052),
                Some(17583053),
                Some(17583054),
                Some(17583055)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(17588621),
                Some(17588622),
                Some(17588623),
                Some(17588624),
                Some(17588625),
                Some(17588626),
                Some(17588627),
                Some(17588628),
                Some(17588629),
                Some(17588630),
                Some(17588631),
                Some(17588632),
                Some(17588633),
                Some(17588634),
                Some(17588635),
                Some(17588636),
                Some(17588637),
                Some(17588638),
                Some(17588639),
                Some(17588640),
                Some(17588641),
                Some(17588642),
                Some(17588643),
                Some(17588644),
                Some(17588645),
                Some(17588646),
                Some(17588647),
                Some(17588648),
                Some(17588649),
                Some(17588650),
                Some(17588651),
                Some(17588652),
                Some(17588653),
                Some(17588654),
                Some(17588655),
                Some(17588656),
                Some(17588657),
                Some(17589196),
                Some(17589197),
                Some(17589198),
                Some(17589199),
                Some(17589200),
                Some(17589201),
                Some(17589202),
                Some(17589203),
                Some(17589204),
                Some(17589205),
                Some(17589206),
                Some(17589207),
                Some(17589208),
                None
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(17588621),
                Some(17588622),
                Some(17588623),
                Some(17588624),
                Some(17588625),
                Some(17588626),
                Some(17588627),
                Some(17588628),
                Some(17588629),
                Some(17588630),
                Some(17588631),
                Some(17588632),
                Some(17588633),
                Some(17588634),
                Some(17588635),
                Some(17588636),
                Some(17588637),
                Some(17588638),
                Some(17588639),
                Some(17588640),
                Some(17588641),
                Some(17588642),
                Some(17588643),
                Some(17588644),
                Some(17588645),
                Some(17588646),
                Some(17588647),
                Some(17588648),
                Some(17588649),
                Some(17588650),
                Some(17588651),
                Some(17588652),
                Some(17588653),
                Some(17588654),
                Some(17588655),
                Some(17588656),
                Some(17588657),
                Some(17589196),
                Some(17589197),
                Some(17589198),
                Some(17589199),
                Some(17589200),
                Some(17589201),
                Some(17589202),
                Some(17589203),
                Some(17589204),
                Some(17589205),
                Some(17589206),
                Some(17589207),
                Some(17589208),
                None
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(17588621),
                Some(17588622),
                Some(17588623),
                Some(17588624),
                Some(17588625),
                Some(17588626),
                Some(17588627),
                Some(17588628),
                Some(17588629),
                Some(17588630),
                Some(17588631),
                Some(17588632),
                Some(17588633),
                Some(17588634),
                Some(17588635),
                Some(17588636),
                Some(17588637),
                Some(17588638),
                Some(17588639),
                Some(17588640),
                Some(17588641),
                Some(17588642),
                Some(17588643),
                Some(17588644),
                Some(17588645),
                Some(17588646),
                Some(17588647),
                Some(17588648),
                Some(17588649),
                Some(17588650),
                Some(17588651),
                Some(17588652),
                Some(17588653),
                Some(17588654),
                Some(17588655),
                Some(17588656),
                Some(17588657),
                Some(17589196),
                Some(17589197),
                Some(17589198),
                Some(17589199),
                Some(17589200),
                Some(17589201),
                Some(17589202),
                Some(17589203),
                Some(17589204),
                Some(17589205),
                Some(17589206),
                Some(17589207),
                Some(17589208),
                None
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                None,
                Some(17591770),
                Some(17591771),
                Some(17591772),
                Some(17591773),
                Some(17591774),
                Some(17591775),
                Some(17591776),
                Some(17591777),
                Some(17591778),
                Some(17591779),
                Some(17591780),
                Some(17591781),
                Some(17591782),
                Some(17591783),
                Some(17591784),
                Some(17591785),
                Some(17591786),
                Some(17591787),
                Some(17591788),
                Some(17591789),
                Some(17591790),
                Some(17591791),
                Some(17591792),
                Some(17591793),
                Some(17591794),
                Some(17591796),
                Some(17591797),
                Some(17591798),
                Some(17591799),
                Some(17591800),
                Some(17591801),
                Some(17591802),
                Some(17591803),
                Some(17591804),
                Some(17591805),
                Some(17591806),
                Some(17591807),
                Some(17591808),
                Some(17591809),
                Some(17591810),
                Some(17591811),
                Some(17591812),
                Some(17591813),
                Some(17591814),
                Some(17591815),
                Some(17591816),
                Some(17591817),
                Some(17591818),
                Some(17591819),
                Some(17591820)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(17593855),
                Some(17593856),
                Some(17593857),
                Some(17593858),
                Some(17593859),
                Some(17593860),
                Some(17593861),
                Some(17593862),
                Some(17593863),
                Some(17593864),
                Some(17593865),
                Some(17593866),
                Some(17593867),
                Some(17593868),
                Some(17593869),
                Some(17593870),
                Some(17593871),
                Some(17593872),
                Some(17593873),
                Some(17593874),
                Some(17593875),
                Some(17593876),
                Some(17593877),
                Some(17593878),
                Some(17593880),
                Some(17593881),
                Some(17593882),
                Some(17593883),
                Some(17593884),
                Some(17593885),
                Some(17593886),
                Some(17593887),
                Some(17593888),
                Some(17593889),
                Some(17593890),
                Some(17593891),
                Some(17593892),
                Some(17593893),
                Some(17593894),
                Some(17593895),
                Some(17593896),
                Some(17593897),
                Some(17593898),
                Some(17593899),
                Some(17593900),
                Some(17593901),
                Some(17593902),
                Some(17593903),
                None,
                None,
                None
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(17593863),
                Some(17593864),
                Some(17593865),
                Some(17593866),
                Some(17593867),
                Some(17593868),
                Some(17593869),
                Some(17593870),
                Some(17593871),
                Some(17593872),
                Some(17593873),
                Some(17593874),
                Some(17593875),
                Some(17593876),
                Some(17593877),
                Some(17593878),
                Some(17593880),
                Some(17593881),
                Some(17593882),
                Some(17593883),
                Some(17593884),
                Some(17593885),
                Some(17593886),
                Some(17593887),
                Some(17593888),
                Some(17593889),
                Some(17593890),
                Some(17593891),
                Some(17593892),
                Some(17593893),
                Some(17593894),
                Some(17593895),
                Some(17593896),
                Some(17593897),
                Some(17593898),
                Some(17593899),
                Some(17593900),
                Some(17593901),
                Some(17593902),
                Some(17593903),
                Some(17593904),
                Some(17593905),
                Some(17593906),
                Some(17593907),
                None,
                None,
                None,
                None,
                None,
                None,
                None
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                None,
                Some(17596476),
                Some(17596477),
                Some(17596478),
                Some(17596479),
                Some(17596480),
                Some(17596481),
                Some(17596482),
                None,
                Some(17596483),
                Some(17596484),
                Some(17596485),
                Some(17596486),
                Some(17596487),
                Some(17596488),
                Some(17596489),
                Some(17596490),
                Some(17596491),
                Some(17596492),
                Some(17596493),
                Some(17596494),
                Some(17596495),
                Some(17596496),
                Some(17596497),
                Some(17596498),
                Some(17596499),
                Some(17596500),
                Some(17596501),
                Some(17596502),
                Some(17596503),
                Some(17596504),
                Some(17596505),
                Some(17596506),
                Some(17596507),
                Some(17596508),
                Some(17596509),
                Some(17596510),
                Some(17596511),
                Some(17596512),
                Some(17596513),
                Some(17596514)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                None,
                None,
                None,
                None,
                None,
                Some(17624012),
                Some(17624013),
                Some(17624014),
                Some(17624015),
                Some(17624016),
                Some(17624017),
                Some(17624018),
                Some(17624019),
                Some(17624020),
                Some(17625913),
                Some(17625914),
                Some(17625915),
                Some(17625916),
                Some(17625917),
                Some(17625918),
                Some(17625919),
                Some(17625920),
                Some(17625921),
                Some(17625922),
                Some(17625923),
                Some(17625924),
                Some(17625925),
                Some(17625926),
                Some(17625927),
                Some(17625928),
                Some(17625929),
                Some(17625930),
                Some(17625931),
                Some(17625932),
                Some(17625933),
                Some(17625934),
                Some(17625935),
                Some(17625936),
                Some(17625937),
                Some(17625938),
                Some(17625939),
                Some(17625940),
                Some(17625941),
                Some(17625942),
                Some(17625943),
                Some(17625944),
                Some(17625945),
                Some(17625946),
                Some(17625947),
                Some(17625948),
                Some(17625949)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                None,
                None,
                Some(17624012),
                Some(17624013),
                Some(17624014),
                Some(17624015),
                Some(17624016),
                Some(17624017),
                Some(17624018),
                Some(17624019),
                Some(17624020),
                Some(17625913),
                Some(17625914),
                Some(17625915),
                Some(17625916),
                Some(17625917),
                Some(17625918),
                Some(17625919),
                Some(17625920),
                Some(17625921),
                Some(17625922),
                Some(17625923),
                Some(17625924),
                Some(17625925),
                Some(17625926),
                Some(17625927),
                Some(17625928),
                Some(17625929),
                Some(17625930),
                Some(17625931),
                Some(17625932),
                Some(17625933),
                Some(17625934),
                Some(17625935),
                Some(17625936),
                Some(17625937),
                Some(17625938),
                Some(17625939),
                Some(17625940),
                Some(17625941),
                Some(17625942),
                Some(17625943),
                Some(17625944),
                Some(17625945),
                Some(17625946),
                Some(17625947),
                Some(17625948),
                Some(17625949),
                Some(17625950),
                Some(17625951),
                Some(17625952)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                None,
                Some(31796700),
                Some(31796701),
                Some(31796702),
                Some(31796703),
                Some(31796704),
                Some(31796705),
                Some(31796706),
                Some(31796710),
                Some(31796711),
                Some(31796712),
                Some(31796713),
                Some(31796714),
                Some(31796715),
                Some(31796716),
                Some(31796717),
                Some(31796718),
                Some(31796719),
                Some(31796720),
                Some(31796721),
                Some(31796722),
                Some(31796723),
                Some(31796724),
                Some(31796725),
                Some(31796726),
                Some(31796727),
                Some(31796728),
                Some(31799014),
                Some(31799015),
                Some(31799016),
                Some(31799017),
                Some(31799018),
                Some(31799019),
                Some(31799020),
                Some(31799021),
                Some(31799022),
                Some(31799023),
                Some(31799024),
                Some(31799025),
                Some(31799026),
                Some(31799027),
                Some(31799028),
                Some(31799029),
                Some(31799030),
                Some(31799031),
                Some(31799032),
                Some(31799033),
                Some(31799034),
                Some(31799035),
                Some(31799036),
                Some(31799037)
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                Some(36722692),
                Some(36722693),
                Some(36722694),
                Some(36722695),
                Some(36722696),
                Some(36722697),
                Some(36722698),
                Some(36722699),
                Some(36722700),
                Some(36722701),
                Some(36722702),
                Some(36722703),
                Some(36722704),
                Some(36722705),
                Some(36723505),
                Some(36723506),
                Some(36723507),
                Some(36723508),
                Some(36723509),
                Some(36723510),
                Some(36723511),
                Some(36723512),
                Some(36723513),
                Some(36723514),
                Some(36723515),
                Some(36723516),
                Some(36723517),
                Some(36723518),
                Some(36723519),
                Some(36723520),
                Some(36723521),
                Some(36723522),
                Some(36723523),
                Some(36723524),
                Some(36723525),
                Some(36723526),
                Some(36723527),
                Some(36723528),
                Some(36723529),
                Some(36723530),
                Some(36723531),
                Some(36723532),
                Some(36737414),
                Some(36737415),
                Some(36737416),
                Some(36737417),
                Some(36737418),
                Some(36737419),
                Some(36737420),
                None,
                None
            ]
        );
        let rp: Vec<_> = it
            .next()
            .unwrap()
            .unwrap()
            .reference_positions_full()
            .collect();
        assert_eq!(
            rp,
            vec![
                None,
                None,
                None,
                None,
                Some(44587963),
                Some(44587964),
                Some(44587965),
                Some(44587966),
                Some(44587967),
                Some(44587968),
                Some(44587969),
                Some(44587970),
                Some(44587971),
                Some(44587972),
                Some(44587973),
                Some(44587974),
                Some(44587975),
                Some(44587976),
                Some(44587977),
                Some(44587978),
                Some(44587979),
                Some(44587980),
                Some(44587981),
                Some(44587982),
                Some(44587983),
                Some(44589680),
                Some(44589681),
                Some(44589682),
                Some(44589683),
                Some(44589684),
                Some(44589685),
                Some(44589686),
                Some(44589687),
                Some(44589688),
                Some(44589689),
                Some(44589690),
                Some(44589691),
                Some(44589692),
                Some(44589693),
                Some(44589694),
                Some(44589695),
                Some(44589696),
                Some(44589697),
                Some(44589698),
                Some(44589699),
                Some(44589700),
                Some(44589701),
                Some(44589702),
                Some(44592034),
                Some(44592035),
                Some(44592036)
            ]
        );
    }

    #[test]
    fn test_reference_start_end() {
        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
        let mut it = bam.records();
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 16050676);
        assert_eq!(read.reference_end(), 16050721);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 16096878);
        assert_eq!(read.reference_end(), 16096931);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 16097145);
        assert_eq!(read.reference_end(), 16097198);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 16117350);
        assert_eq!(read.reference_end(), 16117401);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 16118483);
        assert_eq!(read.reference_end(), 16118534);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 16118499);
        assert_eq!(read.reference_end(), 16118550);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 16118499);
        assert_eq!(read.reference_end(), 16118550);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 16118499);
        assert_eq!(read.reference_end(), 16118550);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 16123411);
        assert_eq!(read.reference_end(), 16123462);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 16123417);
        assert_eq!(read.reference_end(), 16123462);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 16165860);
        assert_eq!(read.reference_end(), 16165901);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 16180871);
        assert_eq!(read.reference_end(), 16180922);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 16189705);
        assert_eq!(read.reference_end(), 16189756);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 16231271);
        assert_eq!(read.reference_end(), 16231322);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 16237657);
        assert_eq!(read.reference_end(), 16237708);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 16255012);
        assert_eq!(read.reference_end(), 16255054);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 16255391);
        assert_eq!(read.reference_end(), 16255442);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 16255392);
        assert_eq!(read.reference_end(), 16255442);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 16256084);
        assert_eq!(read.reference_end(), 16256129);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 16256224);
        assert_eq!(read.reference_end(), 16256272);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 16325199);
        assert_eq!(read.reference_end(), 16325241);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 16352865);
        assert_eq!(read.reference_end(), 16352903);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 16352968);
        assert_eq!(read.reference_end(), 16353012);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 16414998);
        assert_eq!(read.reference_end(), 16415044);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17031591);
        assert_eq!(read.reference_end(), 17031638);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17057382);
        assert_eq!(read.reference_end(), 17057432);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17092766);
        assert_eq!(read.reference_end(), 17095000);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17092782);
        assert_eq!(read.reference_end(), 17095016);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17092782);
        assert_eq!(read.reference_end(), 17095016);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17137287);
        assert_eq!(read.reference_end(), 17137320);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17306238);
        assert_eq!(read.reference_end(), 17306286);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17561868);
        assert_eq!(read.reference_end(), 17561913);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17566078);
        assert_eq!(read.reference_end(), 17577961);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17566108);
        assert_eq!(read.reference_end(), 17578701);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17566111);
        assert_eq!(read.reference_end(), 17578704);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17566111);
        assert_eq!(read.reference_end(), 17578704);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17566111);
        assert_eq!(read.reference_end(), 17578704);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17566111);
        assert_eq!(read.reference_end(), 17578704);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17566112);
        assert_eq!(read.reference_end(), 17578705);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17566113);
        assert_eq!(read.reference_end(), 17578706);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17566113);
        assert_eq!(read.reference_end(), 17578706);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17579733);
        assert_eq!(read.reference_end(), 17581250);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17581369);
        assert_eq!(read.reference_end(), 17583029);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17581370);
        assert_eq!(read.reference_end(), 17583030);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17581370);
        assert_eq!(read.reference_end(), 17583030);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17582911);
        assert_eq!(read.reference_end(), 17583056);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17588621);
        assert_eq!(read.reference_end(), 17589209);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17588621);
        assert_eq!(read.reference_end(), 17589209);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17588621);
        assert_eq!(read.reference_end(), 17589209);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17591770);
        assert_eq!(read.reference_end(), 17591821);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17593855);
        assert_eq!(read.reference_end(), 17593904);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17593863);
        assert_eq!(read.reference_end(), 17593908);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17596476);
        assert_eq!(read.reference_end(), 17596515);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17624012);
        assert_eq!(read.reference_end(), 17625950);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 17624012);
        assert_eq!(read.reference_end(), 17625953);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 31796700);
        assert_eq!(read.reference_end(), 31799038);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 36722692);
        assert_eq!(read.reference_end(), 36737421);
        let read = it.next().unwrap().unwrap();
        assert_eq!(read.reference_start(), 44587963);
        assert_eq!(read.reference_end(), 44592037);
    }

    #[test]
    fn test_infer_seq_len() {
        use std::convert::TryFrom;
        let mut bam = bam::Reader::from_path("./test/test_spliced_reads.bam").unwrap();
        for read in bam.records() {
            let read = read.unwrap();
            assert_eq!(read.seq_len_from_cigar(false), 51);
            assert_eq!(read.seq_len_from_cigar(true), 51);
        }

        let mut read = bam::Record::new();
        for (input_cigar, supposed_length_wo_hard_clip, supposed_length_with_hard_clip) in &[
            ("40M", 40, 40),
            ("40=", 40, 40),
            ("40X", 40, 40),
            ("20M5I20M", 45, 45),
            ("20M5D20M", 40, 40),
            ("5H", 0, 5),
            ("5H35M", 35, 40),
            ("5S35M", 40, 40),
            ("35M5H", 35, 40),
            ("35M5S", 40, 40),
            ("", 0, 0),
        ] {
            read.set(
                b"test",
                Some(&CigarString::try_from(*input_cigar).unwrap()),
                b"agtc",
                b"BBBB",
            );
            assert_eq!(
                &read.seq_len_from_cigar(false),
                supposed_length_wo_hard_clip
            );
            assert_eq!(
                &read.seq_len_from_cigar(true),
                supposed_length_with_hard_clip
            );
        }
    }
}