uuuuhhhhhh all for nothing!!!!!!

src/common_subsequence/db.rs

@@ -79,18 +79,17 @@ impl DB {
 
     /// Removes the last value from the sequence.
     pub fn pop(&mut self) -> Option<u32> {
-        let return_value = self.last();
+        let return_value = self.last()?;
-        if return_value.is_some() {
+        // if return_value.is_some() {
-            if let Some(&last_inner) = self.inner.last() {
+        if let Some(&last_inner) = self.inner.last() {
-                if self.len - last_inner == 1 {
+            if self.len - last_inner == 1 {
-                    self.inner.pop();
+                self.inner.pop();
-                } else if self.len < last_inner {
+            } else if self.len < last_inner {
-                    panic!("run DB::validate(&self)");
+                panic!("run DB::validate(&self)");
-                }
             }
-            self.len -= 1;
         }
-        return_value
+        self.len -= 1; // }
+        Some(return_value)
     }
     /// Retrieves the value at a given index.
     /**

src/common_subsequence/mod.rs

@@ -1,11 +1,12 @@
 use db::DB;
+use monotonic_sequence::{MonotonicSequence, SequenceError};
 //  use db2::{DBError, DB as DB2};
 
 pub mod db;
-#[allow(dead_code)]
+// #[allow(dead_code)]
-mod db2;
+// mod db2;
-#[allow(dead_code)]
+// #[allow(dead_code)]
- mod db3;
+//  mod db3;
 pub mod monotonic_sequence;
 
 pub fn lcs_gen(str1: &str, str2: &str) -> Vec<Vec<u32>> {
@@ -68,6 +69,45 @@ pub fn lcs_gen_db(str1: &str, str2: &str) -> Vec<DB> {
     db
 }
 
+#[allow(non_camel_case_types)]
+#[derive(Debug)]
+pub enum belper {
+    MSE(SequenceError),
+    None,
+}
+
+pub fn lcs_gen_ms(str1: &str, str2: &str) -> Result<Vec<MonotonicSequence>, belper> {
+    let c1: Vec<char> = str1.chars().collect();
+    let c1len = c1.len();
+    let c2: Vec<char> = str2.chars().collect();
+    let c2len = c2.len();
+    let mut db: Vec<MonotonicSequence> = vec![MonotonicSequence::zeros(c2len + 1); c1len + 1];
+    if c1len * c2len == 0 {
+        // for i in &db {
+        //     println!("{i:?}")
+        // }
+        return Ok(db);
+    }
+    for i in 1..=c1len {
+        for j in 1..=c2len {
+            if c1[i - 1] == c2[j - 1] {
+                let val = db[i - 1].get(j - 1).ok_or(belper::None)? + 1;
+                db[i].propagate_to_end(j, val).map_err(belper::MSE)?;
+            } else {
+                let val = db[i]
+                    .get(j - 1)
+                    .ok_or(belper::None)?
+                    .max(db[i - 1].get(j).ok_or(belper::None)?);
+                db[i].propagate_to_end(j, val).map_err(belper::MSE)?;
+            }
+        }
+    }
+    // for i in &db {
+    //     println!("{i:?}")
+    // }
+    Ok(db)
+}
+
 // #[allow(non_camel_case_types)]
 // #[derive(Debug)]
 // pub enum belper {
@@ -112,6 +152,8 @@ mod test {
 
     // use crate::common_subsequence::{db2::DB as DB2, lcs_gen_dbai};
 
+    use super::{lcs_gen_ms, monotonic_sequence::MonotonicSequence};
+
     use super::{lcs_gen, lcs_gen_db, DB};
     #[test]
     fn test_normal_case() {
@@ -129,7 +171,7 @@ mod test {
 
             println!("for test_wiki is: {:?}", duration);
         }
-        // 30/45 micro
+        // 30/45 micro how dropped to 8/15 im cooked
 
         {
             let start = Instant::now();
@@ -138,7 +180,15 @@ mod test {
 
             println!("for test_db is: {:?}", duration);
         }
-        // 22 micro
+        // 22/30 micro
+        {
+            let start = Instant::now();
+            test_dbai();
+            let duration = start.elapsed();
+
+            println!("for test_dbai is: {:?}", duration);
+        }
+        // 13/28 micro
 
         // success to me
     }
@@ -186,26 +236,26 @@ mod test {
             .collect();
         assert_eq!(c, s)
     }
-    // #[test]
+    #[test]
-    // fn test_dbai() {
+    fn test_dbai() {
-    //     // CURRENTLY BREAKING IDFK idk IDKF
+        // CURRENTLY BREAKING IDFK idk IDKF
-    //     let s: Vec<Vec<u32>> = vec![
+        let s: Vec<Vec<u32>> = vec![
-    //         vec![0, 0, 0, 0, 0, 0, 0, 0],
+            vec![0, 0, 0, 0, 0, 0, 0, 0],
-    //         vec![0, 0, 0, 0, 0, 0, 1, 1],
+            vec![0, 0, 0, 0, 0, 0, 1, 1],
-    //         vec![0, 1, 1, 1, 1, 1, 1, 1],
+            vec![0, 1, 1, 1, 1, 1, 1, 1],
-    //         vec![0, 1, 1, 2, 2, 2, 2, 2],
+            vec![0, 1, 1, 2, 2, 2, 2, 2],
-    //         vec![0, 1, 1, 2, 2, 2, 2, 2],
+            vec![0, 1, 1, 2, 2, 2, 2, 2],
-    //         vec![0, 1, 1, 2, 3, 3, 3, 3],
+            vec![0, 1, 1, 2, 3, 3, 3, 3],
-    //         vec![0, 1, 1, 2, 3, 3, 3, 4],
+            vec![0, 1, 1, 2, 3, 3, 3, 4],
-    //         vec![0, 1, 2, 2, 3, 3, 3, 4],
+            vec![0, 1, 2, 2, 3, 3, 3, 4],
-    //     ];
+        ];
-    //     let c: Vec<Vec<u32>> = lcs_gen_dbai("XMJYAUZ", "MZJAWXU")
+        let c: Vec<Vec<u32>> = lcs_gen_ms("XMJYAUZ", "MZJAWXU")
-    //         .expect("oops")
+            .expect("oops")
-    //         .iter()
+            .iter()
-    //         .map(DB2::to_vec)
+            .map(MonotonicSequence::to_vec)
-    //         .collect();
+            .collect();
-    //     assert_eq!(c, s)
+        assert_eq!(c, s)
-    // }
+    }
     #[test]
     fn test_empty() {
         lcs_gen("", "");

src/common_subsequence/monotonic_sequence.rs

@@ -43,7 +43,16 @@ impl MonotonicSequence {
         }
     }
 
-    pub fn new() -> Self{Default::default()}
+    pub fn zeros(count: usize) -> Self {
+        match count {
+            0 => Self::new(),
+            _ => Self::with(0, count),
+        }
+    }
+
+    pub fn new() -> Self {
+        Default::default()
+    }
     // jumps function
     /// `self.jumps[result of this function]` to get info
     fn get_jump_index(&self, pos: usize) -> usize {
@@ -64,7 +73,7 @@ impl MonotonicSequence {
     }
     /// Get value at position
     ///
-    /// this would return none if pos == self.len()
+    /// this would return none if pos >= self.len()
     pub fn get(&self, pos: usize) -> Option<u32> {
         // check for bounds
         if pos >= self.length {
@@ -73,9 +82,14 @@ impl MonotonicSequence {
         // find the place to put
         Some(self.jumps[self.get_jump_index(pos)].1)
     }
+
     /// a superset of can_set, giving no fucks about self.length.
     // code in can_set moved to here
     fn can_be(&self, pos: usize) -> (u32, u32) {
+        // if pos > self.len() {
+        //     return None
+        // } what couldve been if i cared
+
         // let _current_value = self.get(pos).unwrap(); // in bound,
 
         // this new value must be:
@@ -142,25 +156,35 @@ impl MonotonicSequence {
         Ok(min <= new_value && new_value <= max)
         // if 2, 4 which NEVER happens btw then can you not be 4? well but it never happens
     }
-
+    // if bigger to big if smaller too small
-    /// Change value at position
+    pub fn can_set_mini(
-    pub fn set(&mut self, pos: usize, value: u32) -> Result<(), SequenceError> {
+        pos: usize,
-        let (min, max) = dbg!(self.can_set(pos, value)?); // already checked for bounds here
+        new_value: u32,
-        if value < min {
+        (current_min, current_max): (u32, u32),
+    ) -> Result<(), SequenceError> {
+        debug_assert!(current_max >= current_min && current_max - current_min <= 1);
+        if new_value < current_min {
             return Err(SequenceError::ValueTooLow {
                 pos,
-                attempted: value,
+                attempted: new_value,
-                min_allowed: min,
+                min_allowed: current_min,
             });
-        } else if value > max {
+        } else if new_value > current_max {
             return Err(SequenceError::ValueTooHigh {
                 pos,
-                attempted: value,
+                attempted: new_value,
-                max_allowed: max,
+                max_allowed: current_max,
             });
-        } else if min == value && max == value {
+        };
+        Ok(())
+    }
+    /// Change value at position
+    pub fn set(&mut self, pos: usize, value: u32) -> Result<(), SequenceError> {
+        let (min, max) = /*dbg!*/self.can_set(pos, value)?; // already checked for bounds here
+        if min == value && max == value {
             return Ok(());
         }
+        Self::can_set_mini(pos, value, (min, max))?;
         // every single singular instance of in between is solved
         // [2, (3), 4] min == max == 3
 
@@ -172,17 +196,20 @@ impl MonotonicSequence {
         // now current_value needs to change to value.
         // case 1.
         // value == min, so current value MUST be max. like how else
+        // THE jump index from get_jump_index
         if value == min {
+            assert_eq!(current_value, max); // solid logic
             let at = self.get_jump_index(pos);
-            debug_assert_eq!(current_value, max);
             debug_assert_eq!(self.jumps[at].0, pos);
-            let (ind, val) = self.jumps.get_mut(pos).unwrap(); // pos here is valid. already checked bounds
+            // TODO: pos misuse?
+            let (ind, _ /*val*/) = self.jumps.get_mut(at).unwrap(); // pos here is valid. already checked bounds
 
-            debug_assert_eq!(current_value, *val);
+            // debug_assert_eq!(current_value, *val); // current value is upper
             *ind += 1;
             // if ind is self.length now then we need to pop
             if *ind >= self.length {
                 let re_moved = self.jumps.pop(); // its just moved (+ 1) also its removed
+                                                 // get it
                 #[cfg(debug_assertions)]
                 {
                     if let Some(ind_and_val) = re_moved {
@@ -192,18 +219,26 @@ impl MonotonicSequence {
             }
         }
         // case 2: value == max, current must be min
+        // very last number before a jump
         else if value == max {
-            debug_assert_eq!(current_value, min);
+            assert_eq!(current_value, min);
-            // let at = self.get_jump_index(pos + 1);
+            if pos + 1 >= self.len() {
-            let Some((index, _val)) = dbg!(self.jumps.get_mut(pos + 1)) else {
                 // pos + 1 is len
                 // pos is the end. Not a jump point, as current_value == min
                 debug_assert_eq!(self.length, pos + 1);
+
                 self.jumps.push((pos, value));
                 return Ok(());
             };
 
+            // TODO: pos misuse?
+            let at = self.get_jump_index(pos + 1); // should land at
+            debug_assert_eq!(self.jumps[at].0, pos + 1);
+            let (index, _val) = /*dbg!*/self.jumps.get_mut(at).unwrap();
+
+            // how does this work?
             assert_ne!(*index, 0);
+
             // we want to decrease my guy
             // but what if index == 1?
             // at that place current value == min, value == max ([(0),1,1,1])
@@ -221,12 +256,12 @@ impl MonotonicSequence {
 
         Ok(())
     }
-
+    /// readonly of self.length
     pub fn len(&self) -> usize {
         self.length
     }
     pub fn is_empty(&self) -> bool {
-        self.length == 0
+        self.len() == 0
     }
 
     /// Convert to regular vector
@@ -246,8 +281,167 @@ impl MonotonicSequence {
 
         result
     }
+
+    pub fn validate(&self) -> bool {
+        self.jumps.windows(2).all(|c| {
+            let [(lind, lv), (tind, tv)] = *c else {
+                unreachable!("windows is 2")
+            };
+            lind < tind && lv < tv
+        }) && self.jumps.iter().all(|&(ind, _)| ind < self.length)
+    }
+
+    pub fn push(&mut self, value: u32) -> Result<(), SequenceError> {
+        // let len = self.jumps.len();
+        let Some(&(_curind, current_value)) = self.jumps.last() else {
+            debug_assert_eq!(self.length, 0);
+            self.jumps.push((self.length, value));
+            self.length += 1;
+            return Ok(());
+        };
+        Self::can_set_mini(self.length, value, (current_value, current_value + 1))?;
+        // if current_value == value { } else
+        if current_value + 1 == value {
+            self.jumps.push((self.length, value));
+        }
+        self.length += 1;
+
+        Ok(())
+    }
+
+    pub fn last(&self) -> Option<u32> {
+        if self.is_empty() {
+            None // huh
+        } else {
+            self.jumps.last().map(|&(_, val)| val)
+        }
+    }
+    pub fn first(&self) -> Option<u32> {
+        if self.is_empty() {
+            None // huh
+        } else {
+            self.jumps.first().map(|&(_, val)| val)
+        }
+    }
+
+    pub fn pop(&mut self) -> Option<u32> {
+        let return_value = self.last()?;
+
+        if let Some(&(index_last, _)) = self.jumps.last() {
+            if self.length - index_last == 1 {
+                let _rem = self.jumps.pop();
+                #[cfg(debug_assertions)]
+                {
+                    if let Some(ind_and_val) = _rem {
+                        debug_assert_eq!(ind_and_val, (self.length - 1, return_value))
+                    }
+                }
+            } else if self.length < index_last {
+                // things that never run:
+                panic!("run self.validate()");
+            }
+        }
+        self.length -= 1; // not zero already
+        Some(return_value)
+    }
+
+    pub fn try_from_vec(vec: &[u32]) -> Result<Self, SequenceError> {
+        let Some(mut lagging_value) = vec.first().cloned() else {
+            return Ok(Default::default());
+        }; // always 1 behind => lagging
+        let mut jumps = vec![(0, lagging_value)];
+        vec.iter().enumerate().skip(1).try_for_each(|(ind, &val)| {
+            // if val > lagging_value + 1 {
+            //     return Err(SequenceError::ValueTooHigh {
+            //         pos: ind,
+            //         attempted: val,
+            //         max_allowed: lagging_value + 1,
+            //     });
+            // } else if val < lagging_value {
+            //     return Err(SequenceError::ValueTooLow {
+            //         pos: ind,
+            //         attempted: val,
+            //         min_allowed: lagging_value,
+            //     });
+            // } else
+
+            Self::can_set_mini(ind, val, (lagging_value, lagging_value + 1))?;
+            if val == lagging_value + 1 {
+                jumps.push((ind, val));
+            }
+            lagging_value = val;
+            Ok(())
+        })?;
+        Ok(Self {
+            jumps,
+            length: vec.len(),
+        })
+    }
+
+    // working my ass out to make this struct look like a vec D:
+
+    pub fn flatten_after(&mut self, pos: usize) {
+        let len = self.get_jump_index(pos) + 1;
+        self.jumps.truncate(len);
+    }
+    pub fn flatten_before(&mut self, pos: usize) {
+        let len = self.get_jump_index(pos);
+        // let r = self.jumps[len..].to_vec();
+
+        self.jumps.rotate_left(len); // damn they figured it
+                                     // self.jumps.copy_within(len.., 0);
+
+        self.jumps.truncate(self.jumps.len() - len);
+        // assert_eq!(r, self.jumps, "rotate tricks failed");
+        if let Some((ind, _)) = self.jumps.first_mut() {
+            *ind = 0;
+        }
+    }
+    /// truncate does not need work when big
+    pub fn truncate(&mut self, new_len: usize) {
+        if new_len >= self.len() {
+            return;
+        };
+        self.flatten_after(new_len);
+        self.length = new_len;
+    }
+    // does not extend if number smaller than len
+    pub fn extend(&mut self, large_len: usize) {
+        if large_len < self.length {
+            // eprintln!(
+            //     "{large_len} smaller than length {l} could cause data loss",
+            //     l = self.length
+            // );
+            return;
+        }
+        self.length = large_len;
+    }
+    pub fn resize(&mut self, new_size: usize) {
+        if new_size >= self.len() {
+            self.extend(new_size);
+        } else {
+            self.truncate(new_size);
+        }
+    }
+    pub fn jumps(&self) -> Vec<(usize, u32)> {
+        self.jumps.to_vec()
+    }
+    pub fn propagate_to_end(&mut self, pos: usize, val: u32) -> Result<(), SequenceError> {
+        let len = self.len();
+        let Some(cur) = self.get(pos) else {
+            return Ok(());
+        };
+        Self::can_set_mini(pos, val, (cur, cur + 1))?;
+        self.flatten_after(pos);
+        if val == cur + 1 {
+            self.jumps.push((pos, val));
+        }
+        self.length = len;
+        Ok(())
+    }
 }
 
+// ai gen testcases: not quite sure because short + not updated with new methods
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -256,8 +450,11 @@ mod tests {
     fn test_basic_operations() {
         // Create [0,0,1,1,2,2]
         let mut seq = MonotonicSequence::with(0, 6);
+        seq.length = 3; // temp
         seq.set(2, 1).unwrap();
+        seq.length = 5; // temp
         seq.set(4, 2).unwrap();
+        seq.length = 6; // temp
 
         assert_eq!(seq.get(0), Some(0));
         assert_eq!(seq.get(1), Some(0));
@@ -274,7 +471,7 @@ mod tests {
     fn test_invalid_changes() {
         let mut seq = MonotonicSequence::with(0, 6);
         seq.length = 3; // temp
-        dbg!(&seq);
+                        // dbg!(&seq, /*seq.to_vec()*/);
         seq.set(2, 1).unwrap();
         seq.length = 5; // temp
         seq.set(4, 2).unwrap();
@@ -298,438 +495,89 @@ mod tests {
         seq.length = 5; // temp
         seq.set(4, 2).unwrap();
         seq.length = 6; // temp
-
+        let mut sec = seq.clone();
-        seq.set(2, 0).unwrap();
+        sec.set(2, 0).unwrap();
-        assert_eq!(seq.to_vec(), vec![0, 0, 0, 1, 2, 2]);
+        assert_eq!(sec.to_vec(), vec![0, 0, 0, 1, 2, 2]);
 
         seq.set(1, 1).unwrap();
         assert_eq!(seq.to_vec(), vec![0, 1, 1, 1, 2, 2]);
     }
+    #[test]
+    fn test_basic_sequence() {
+        let mut seq = MonotonicSequence::with(0, 6);
+        assert_eq!(seq.to_vec(), vec![0, 0, 0, 0, 0, 0]);
+
+        seq.truncate(3);
+        seq.set(2, 1).unwrap();
+        seq.extend(6);
+        assert_eq!(seq.to_vec(), vec![0, 0, 1, 1, 1, 1]);
+        seq.truncate(5);
+
+        seq.set(4, 2).unwrap();
+        seq.extend(6);
+        assert_eq!(seq.to_vec(), vec![0, 0, 1, 1, 2, 2]);
+    }
+    #[test]
+    fn test_edge_cases() {
+        let mut seq = MonotonicSequence::with(3, 3);
+
+        // Can't decrease
+        assert!(seq.set(1, 3).is_ok()); // same value ok
+        assert!(matches!(
+            seq.set(2, 2),
+            Err(SequenceError::ValueTooLow { .. })
+        ));
+
+        // Can't jump by 2
+        assert!(matches!(
+            seq.set(1, 5),
+            Err(SequenceError::ValueTooHigh { .. })
+        ));
+    }
+    #[test]
+    fn test_push_pop() {
+        let mut seq = MonotonicSequence::with(0, 1);
+        seq.push(1).unwrap();
+        seq.push(1).unwrap();
+        assert_eq!(seq.to_vec(), vec![0, 1, 1]);
+
+        assert_eq!(seq.pop(), Some(1));
+        assert_eq!(seq.pop(), Some(1));
+        assert_eq!(seq.to_vec(), vec![0]);
+    }
+    #[test]
+    fn test_flatten_after() {
+        let mut seq = MonotonicSequence::with(0, 6);
+        seq.propagate_to_end(2, 1).unwrap();
+        seq.propagate_to_end(4, 2).unwrap();
+        assert_eq!(seq.to_vec(), vec![0, 0, 1, 1, 2, 2]);
+
+        seq.flatten_after(3);
+        assert_eq!(seq.to_vec(), vec![0, 0, 1, 1, 1, 1]);
+    }
+    #[test]
+    fn test_flatten_before() {
+        let mut seq = MonotonicSequence::with(0, 6);
+        seq.propagate_to_end(2, 1).unwrap();
+        seq.propagate_to_end(4, 2).unwrap();
+        assert_eq!(seq.to_vec(), vec![0, 0, 1, 1, 2, 2]);
+
+        seq.flatten_before(3);
+        assert_eq!(seq.to_vec(), vec![1, 1, 1, 1, 2, 2]);
+    }
+
+    #[test]
+    fn test_try_from_vec() {
+        // Valid sequence
+        let v = vec![0, 0, 1, 1, 2, 2];
+        let seq = MonotonicSequence::try_from_vec(&v).unwrap();
+        assert_eq!(seq.to_vec(), v);
+
+        // Invalid jumps
+        let v = vec![0, 0, 2, 1, 1, 1];
+        assert!(matches!(
+            MonotonicSequence::try_from_vec(&v),
+            Err(SequenceError::ValueTooHigh { .. })
+        ));
+    }
 }
-
-// /// working as intended: i am happy
-// #[cfg(test)]
-// mod lda_test {
-//     use super::MonotonicSequence;
-//     #[test]
-//     fn db_to_vec() {
-//         let c = vec![0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4];
-//         let ctodb = vec![(0, 0), (4, 1), (8, 2), (12, 3), (14, 4)];
-//         let clen = 16;
-//         assert_eq!(clen as usize, c.len());
-//         let ctodb = MonotonicSequence {
-//             jumps: ctodb,
-//             length: clen,
-//         };
-//         assert!(ctodb.validate().is_ok());
-//         assert_eq!(ctodb.to_vec(), c);
-//     }
-//     #[test]
-//     fn pop_and_get() {
-//         let ctodb = vec![(0, 0), (4, 1), (8, 2), (12, 3), (14, 4)];
-//         let clen = 17;
-//         let mut db = MonotonicSequence {
-//             jumps: ctodb,
-//             length: clen,
-//         };
-//         assert_eq!(db.get(4), Some(1));
-//         assert_eq!(db.get(12), Some(3));
-//         assert_eq!(db.get(18), None);
-//         assert_eq!(db.get(0), Some(0));
-//         assert_eq!(db.get(17), None);
-//         assert_eq!(db.get(16), Some(4));
-//         // assert_eq!(db.pop(), Some(4));
-
-//         // println!("length:{} jumps: {:?} vec: {:?}",db.len(), db.jumps, db.vec());
-//         // while let Some(_) = db.pop() {
-//         //     println!("length:{} jumps: {:?} vec: {:?}",db.len(), db.jumps, db.vec());
-
-//         // };
-//         let mut vec = db.to_vec();
-//         while db.len() > 0 {
-//             assert_eq!(db.pop(), vec.pop())
-//         }
-//         assert_eq!(db.pop(), vec.pop());
-//         assert_eq!(db.len(), 0);
-//     }
-//     #[test]
-//     fn last() {
-//         let db = MonotonicSequence::new();
-//         assert_eq!(db.len(), 0);
-//         assert!(db.last_item().is_none());
-
-//         let db = MonotonicSequence::with(0, 1);
-//         assert!(matches!(db.last_item(), Some(0)));
-
-//         // assert!(db.pop() == 0);
-//         // assert_eq!(db.len(), 0);
-//     }
-
-//     #[test]
-//     fn range_of() {
-//         let ctodb = vec![4, 7, 9, 12, 15, 23, 27, 31, 38, 41];
-//         let clen = 49;
-//         let mut db = MonotonicSequence {
-//             jumps: ctodb,
-//             length: clen,
-//         };
-//         assert_eq!(db.range_of(0), Some(0..4));
-//         assert_eq!(db.range_of(1), Some(4..7));
-//         assert_eq!(db.range_of(11), None);
-//         assert_eq!(db.range_of(10), Some(41..clen));
-//         assert_eq!(db.pop(), Some(10));
-//         assert_eq!(db.range_of(10), Some(41..clen - 1));
-//     }
-
-//     #[test]
-//     fn push() {
-//         let mut db = MonotonicSequence::new();
-//         let mut c = vec![];
-//         let mut push = |i| {
-//             db.push(i).unwrap();
-//             c.push(i);
-//         };
-//         for _ in 0..6 {
-//             push(0);
-//         }
-//         for _ in 0..3 {
-//             push(1);
-//         }
-//         for _ in 0..5 {
-//             push(2);
-//         }
-//         for _ in 0..2 {
-//             push(3);
-//         }
-//         for _ in 0..1 {
-//             push(4);
-//         }
-//         assert_eq!(db.to_vec(), c)
-//     }
-//     #[test]
-//     // #[should_panic]
-//     fn invalid_push() {
-//         let mut db = MonotonicSequence::new();
-//         // dbg!(&db.jumps);
-//         db.push(1).unwrap();
-//         // dbg!(&db.jumps);
-//         for _ in 3..=11 {
-//             db.push(1).unwrap();
-//         }
-
-//         // dbg!(&db.jumps);
-//         // dbg!(db.vec());
-//         db.push(2).unwrap();
-//         dbg!(db.len() != 0);
-//         assert!(db.push(4).is_err());
-//     }
-//     #[test]
-//     // #[should_panic]
-//     fn invalid_push_2() {
-//         let mut db = MonotonicSequence::new();
-//         // dbg!(&db.jumps);
-
-//         db.push(0).unwrap();
-//         db.push(1).unwrap();
-//         // dbg!(&db.jumps);
-//         // dbg!(db.to_vec());
-//         db.push(2).unwrap();
-//         dbg!(db.len() != 0);
-//         assert!(db.push(1).is_err());
-//     }
-
-//     #[test]
-//     fn change() {
-//         let mut c = vec![0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4];
-//         let ctodb = vec![4, 8, 12, 14];
-
-//         let mut ctodb = MonotonicSequence {
-//             jumps: ctodb,
-//             length: c.len() as _,
-//         };
-//         let mut change = |i, v| {
-//             ctodb.change(i, v);
-//             c[i as usize] = v;
-//         };
-//         change(13, 3);
-//         change(3, 1);
-//         change(7, 2);
-
-//         assert_eq!(
-//             ctodb.jumps,
-//             MonotonicSequence::try_from_vec(c).unwrap().jumps
-//         )
-//     }
-//     #[test]
-//     fn from_vec() {
-//         let c = vec![0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4];
-//         let ctodb = vec![4, 8, 12, 14];
-
-//         let ctodb = MonotonicSequence {
-//             jumps: ctodb,
-//             length: c.len() as _,
-//         };
-//         let c2 = MonotonicSequence::try_from_vec(c).unwrap();
-//         assert_eq!(ctodb.jumps, c2.jumps);
-//         assert_eq!(ctodb.len, c2.len);
-//     }
-//     #[test]
-//     fn avail() {
-//         let c = [0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4];
-//         let ctodb = vec![4, 8, 12, 14];
-
-//         let ctodb = MonotonicSequence {
-//             jumps: ctodb,
-//             length: c.len() as _,
-//         };
-//         assert_eq!(ctodb.available_values(3), (Some([0, 1]), Some(false)));
-//         assert_eq!(ctodb.available_values(7), (Some([1, 2]), Some(false)));
-//         assert_eq!(ctodb.available_values(13), (Some([3, 4]), Some(false)));
-
-//         assert_eq!(ctodb.available_values(0), (Some([0, 0]), None));
-//         assert_eq!(ctodb.available_values(4), (Some([0, 1]), Some(true)));
-//         assert_eq!(ctodb.available_values(11), (Some([2, 3]), Some(false)));
-//         assert_eq!(ctodb.available_values(12), (Some([2, 3]), Some(true)));
-//         assert_eq!(ctodb.available_values(15), (Some([4, 5]), Some(false)));
-//         assert_eq!(ctodb.available_values(16), (Some([4, 5]), Some(true)));
-//         assert_eq!(ctodb.available_values(17), (None, None));
-//     }
-//     #[test]
-//     fn avail_hard() {
-//         let c = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 13, 13, 13, 13];
-//         let db = MonotonicSequence::try_from_vec(c).unwrap();
-//         assert_eq!(db.available_values(0), (Some([0, 1]), None));
-//         assert_eq!(db.available_values(1), (Some([1, 2]), None));
-//         assert_eq!(db.available_values(11), (Some([11, 12]), None));
-//         assert_eq!(db.available_values(12), (Some([12, 13]), Some(true)));
-//         assert_eq!(db.available_values(13), (Some([13, 13]), None));
-//         assert_eq!(db.available_values(15), (Some([13, 13]), None));
-//         assert_eq!(db.available_values(16), (Some([13, 14]), Some(false)));
-//         assert_eq!(db.available_values(17), (Some([13, 14]), Some(true)));
-//     }
-//     #[test]
-//     fn change_hard() {
-//         let mut c = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 13, 13, 13, 13];
-//         let mut db = MonotonicSequence::try_from_vec(c.clone()).unwrap();
-//         let change = |d: &mut MonotonicSequence, c: &mut Vec<u32>, i, v| {
-//             d.change(i, v);
-//             c[i as usize] = v;
-//         };
-
-//         change(&mut db, &mut c, 12, 12);
-//         change(&mut db, &mut c, 16, 14);
-//         {
-//             println!("f: {c:?}");
-//             assert_eq!(db, MonotonicSequence::try_from_vec(c.clone()).unwrap());
-//         }
-
-//         change(&mut db, &mut c, 13, 12);
-//         change(&mut db, &mut c, 14, 12);
-//         change(&mut db, &mut c, 11, 11);
-//         change(&mut db, &mut c, 12, 11);
-//         change(&mut db, &mut c, 13, 11);
-//         change(&mut db, &mut c, 10, 10);
-//         change(&mut db, &mut c, 11, 10);
-//         change(&mut db, &mut c, 12, 10);
-//         change(&mut db, &mut c, 9, 9);
-//         change(&mut db, &mut c, 10, 9);
-//         {
-//             println!("m: {:?}", db);
-//             print!("{c:?}");
-//             println!(
-//                 ", {:?}",
-//                 MonotonicSequence::try_from_vec(c.clone()).unwrap().to_vec()
-//             );
-//         }
-//         change(&mut db, &mut c, 11, 9);
-//         change(&mut db, &mut c, 8, 8);
-//         change(&mut db, &mut c, 9, 8);
-//         change(&mut db, &mut c, 10, 8);
-//         change(&mut db, &mut c, 7, 7);
-//         change(&mut db, &mut c, 8, 7);
-//         // change(&mut db, &mut c, 9, 7);
-//         {
-//             println!("m: {:?}", db);
-//             print!("{c:?}");
-//             println!(
-//                 ", {:?}",
-//                 MonotonicSequence::try_from_vec(c.clone()).unwrap().to_vec()
-//             );
-//         }
-//         change(&mut db, &mut c, 6, 6);
-//         change(&mut db, &mut c, 7, 6);
-//         // change(&mut db, &mut c, 8, 6);
-//         change(&mut db, &mut c, 5, 5);
-//         change(&mut db, &mut c, 6, 5);
-//         // change(&mut db, &mut c, 7, 5);
-//         change(&mut db, &mut c, 4, 4);
-//         change(&mut db, &mut c, 5, 4);
-//         // change(&mut db, &mut c, 6, 4);
-//         change(&mut db, &mut c, 3, 3);
-//         change(&mut db, &mut c, 4, 3);
-//         // change(&mut db, &mut c, 5, 3);
-//         change(&mut db, &mut c, 2, 2);
-//         change(&mut db, &mut c, 3, 2);
-//         // change(&mut db, &mut c, 4, 2);
-//         change(&mut db, &mut c, 1, 1);
-//         // change(&mut db, &mut c, 2, 1);
-//         // change(&mut db, &mut c, 3, 1);
-//         change(&mut db, &mut c, 0, 0);
-//         // change(&mut db, &mut c, 1, 0);
-//         // change(&mut db, &mut c, 2, 0);
-//         {
-//             let db2 = MonotonicSequence::try_from_vec(c.clone()).unwrap();
-//             println!("e: {c:?}, {:?}", db2.to_vec());
-//             println!("{:?}", db);
-//             assert_eq!(db, db2);
-//         }
-//     }
-
-//     #[test]
-//     fn change_harder() {
-//         let mut c = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 13, 13, 13];
-//         let mut db = MonotonicSequence::try_from_vec(c.clone()).unwrap();
-//         let change = |d: &mut MonotonicSequence, c: &mut Vec<u32>, i, v| {
-//             d.change(i, v);
-//             c[i as usize] = v;
-//         };
-//         {
-//             println!("f: {c:?}");
-//             assert_eq!(db, MonotonicSequence::try_from_vec(c.clone()).unwrap());
-//         }
-
-//         change(&mut db, &mut c, 12, 12);
-//         println!("m: {:?}", db);
-//         change(&mut db, &mut c, 16, 14);
-//         {
-//             println!("f: {c:?}");
-//             assert_eq!(db, MonotonicSequence::try_from_vec(c.clone()).unwrap());
-//         }
-
-//         change(&mut db, &mut c, 13, 12);
-//         change(&mut db, &mut c, 14, 12);
-//         change(&mut db, &mut c, 11, 11);
-//         change(&mut db, &mut c, 12, 11);
-//         change(&mut db, &mut c, 13, 11);
-//         change(&mut db, &mut c, 10, 10);
-//         change(&mut db, &mut c, 11, 10);
-//         change(&mut db, &mut c, 12, 10);
-//         change(&mut db, &mut c, 9, 9);
-//         change(&mut db, &mut c, 10, 9);
-//         {
-//             println!("m: {:?}", db);
-//             print!("{c:?}");
-//             println!(
-//                 ", {:?}",
-//                 MonotonicSequence::try_from_vec(c.clone()).unwrap().to_vec()
-//             );
-//         }
-//         change(&mut db, &mut c, 11, 9);
-//         change(&mut db, &mut c, 8, 8);
-//         change(&mut db, &mut c, 9, 8);
-//         change(&mut db, &mut c, 10, 8);
-//         change(&mut db, &mut c, 7, 7);
-//         change(&mut db, &mut c, 8, 7);
-//         // change(&mut db, &mut c, 9, 7);
-//         {
-//             println!("m: {:?}", db);
-//             print!("{c:?}");
-//             println!(
-//                 ", {:?}",
-//                 MonotonicSequence::try_from_vec(c.clone()).unwrap().to_vec()
-//             );
-//         }
-//         change(&mut db, &mut c, 6, 6);
-//         change(&mut db, &mut c, 7, 6);
-//         // change(&mut db, &mut c, 8, 6);
-//         change(&mut db, &mut c, 5, 5);
-//         change(&mut db, &mut c, 6, 5);
-//         // change(&mut db, &mut c, 7, 5);
-//         change(&mut db, &mut c, 4, 4);
-//         change(&mut db, &mut c, 5, 4);
-//         // change(&mut db, &mut c, 6, 4);
-//         change(&mut db, &mut c, 3, 3);
-//         change(&mut db, &mut c, 4, 3);
-//         // change(&mut db, &mut c, 5, 3);
-//         change(&mut db, &mut c, 2, 2);
-//         change(&mut db, &mut c, 3, 2);
-//         // change(&mut db, &mut c, 4, 2);
-//         change(&mut db, &mut c, 1, 1);
-//         // change(&mut db, &mut c, 2, 1);
-//         // change(&mut db, &mut c, 3, 1);
-//         change(&mut db, &mut c, 0, 0);
-//         // change(&mut db, &mut c, 1, 0);
-//         // change(&mut db, &mut c, 2, 0);
-//         {
-//             let db2 = MonotonicSequence::try_from_vec(c.clone()).unwrap();
-//             println!("e: {c:?}, {:?}", db2.to_vec());
-//             println!("{:?}", db);
-//             assert_eq!(db, db2);
-//         }
-//     }
-
-//     #[test]
-//     fn prop_idk() {
-//         let c = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 13, 13, 13, 13];
-//         let mut db = MonotonicSequence::try_from_vec(c.clone()).unwrap();
-//         dbg!(&mut db).propagate_to_end(2, 2);
-//         dbg!(&db);
-//         println!("{:?}", db.to_vec());
-//         assert_eq!(db.jumps, vec![0, 1]);
-//         let mut db = MonotonicSequence::try_from_vec(c.clone()).unwrap();
-//         db.propagate_to_end(2, 3);
-//         println!("{:?}", db.to_vec());
-//         assert_eq!(db.jumps, vec![0, 1, 2]);
-//     }
-//     #[test]
-//     fn prop() {
-//         let base = [
-//             0, 1, 1, 2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 7, 7, 8, 8, 9, 10, 10, 10, 11, 12, 12, 12, 13,
-//             14, 15, 16, 17, 17, 18, 18, 18, 18, 18, 19, 20, 21, 21, 21, 21, 22, 23, 23, 24, 25, 26,
-//             26, 26,
-//         ];
-
-//         let prop = |bd: &mut MonotonicSequence, cc: &mut Vec<u32>, i, v: u32| {
-//             cc.get_mut(i as usize..).unwrap().fill(v);
-//             bd.propagate_to_end(i, v);
-//         };
-//         {
-//             let mut c = base.to_vec();
-//             let mut db = MonotonicSequence::try_from_vec(c.to_vec()).unwrap();
-
-//             prop(&mut db, &mut c, 15, 7);
-//             prop(&mut db, &mut c, 28, 8);
-
-//             println!("{db:?}, {c:?}");
-
-//             assert_eq!(db, MonotonicSequence::try_from_vec(c.clone()).unwrap());
-//             assert_eq!(db.to_vec(), c);
-//         }
-//     }
-//     #[test]
-//     #[should_panic]
-//     fn prop_failcase() {
-//         let base = [
-//             0, 1, 1, 2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 7, 7, 8, 8, 9, 10, 10, 10, 11, 12, 12, 12, 13,
-//             14, 15, 16, 17, 17, 18, 18, 18, 18, 18, 19, 20, 21, 21, 21, 21, 22, 23, 23, 24, 25, 26,
-//             26, 26,
-//         ];
-
-//         let prop = |bd: &mut MonotonicSequence, cc: &mut Vec<u32>, i, v: u32| {
-//             cc.get_mut(i as usize..).unwrap().fill(v);
-//             bd.propagate_to_end(i, v);
-//         };
-//         {
-//             let mut c = base.to_vec();
-//             let mut db = MonotonicSequence::try_from_vec(c.to_vec()).unwrap();
-
-//             // prop(&mut db, &mut c, 12, 6);
-//             prop(&mut db, &mut c, 28, 14);
-
-//             println!("{db:?}, {c:?}");
-
-//             assert_eq!(db.to_vec(), c);
-//             assert_eq!(db, MonotonicSequence::try_from_vec(c.clone()).unwrap());
-//         }
-//     }
-// }