diff --git a/Cargo.toml b/Cargo.toml
index b4a11a5..a0b6fb8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "orx-linked-list"
-version = "3.9.0"
+version = "3.9.1"
 edition = "2024"
 authors = ["orxfun <orx.ugur.arikan@gmail.com>"]
 description = "A linked list implementation with unique features and an extended list of constant time methods providing high performance traversals and mutations."
diff --git a/examples/bench_parallelization.rs b/examples/bench_parallelization.rs
index 018b25d..fbfcdba 100644
--- a/examples/bench_parallelization.rs
+++ b/examples/bench_parallelization.rs
@@ -74,7 +74,7 @@ fn main() {
             Box::new(move || {
                 let list: DoublyList<_> = (0..args.len as usize).collect();
 
-                list.par_x() // replace iter_ (into_iter_x) with par_x (into_par_x) to parallelize !
+                list.par_x() // replace iter_x (into_iter_x) with par_x (into_par_x) to parallelize !
                     .filter(|x| *x % 3 != 0)
                     .map(|x| x + fibonacci(x % 1000))
                     .filter(|x| x % 2 == 0)
diff --git a/src/list/consuming.rs b/src/list/consuming.rs
index e33b65e..95ced70 100644
--- a/src/list/consuming.rs
+++ b/src/list/consuming.rs
@@ -50,7 +50,7 @@ where
     /// In brief, computation is defined as chain of iterator transformations and parallelization
     /// is handled by the underlying parallel executor.
     ///
-    /// Required **orx-parallel** feature.
+    /// Requires **orx-parallel** feature.
     ///
     /// [`ParIter`]: orx_parallel::ParIter
     /// [`into_iter_x`]: crate::List::into_iter_x
@@ -75,7 +75,6 @@ where
     ///
     /// let expected: usize = new_list().into_iter_x().filter(|x| x % 2 == 0).sum();
     /// let sum_evens = new_list().into_par_x().filter(|x| x % 2 == 0).sum();
-    /// std::dbg!(sum_evens, expected);
     /// ```
     #[cfg(feature = "orx-parallel")]
     pub fn into_par_x(self) -> impl orx_parallel::ParIter<Item = V::Item>
diff --git a/src/list/ends_traits/doubly_ends_mut.rs b/src/list/ends_traits/doubly_ends_mut.rs
index 8fdfbd1..ada8fca 100644
--- a/src/list/ends_traits/doubly_ends_mut.rs
+++ b/src/list/ends_traits/doubly_ends_mut.rs
@@ -393,7 +393,6 @@ where
     /// let e = list.push_back('e');
     ///
     /// assert!(list.eq_to_iter_vals(['a', 'b', 'c', 'd', 'e']));
-    /// dbg!(list.front());
     ///
     /// list.reverse();
     /// assert!(list.eq_to_iter_vals(['e', 'd', 'c', 'b', 'a']));
diff --git a/src/list/get.rs b/src/list/get.rs
index bef27e7..305d04a 100644
--- a/src/list/get.rs
+++ b/src/list/get.rs
@@ -113,7 +113,7 @@ where
     /// In brief, computation is defined as chain of iterator transformations and parallelization
     /// is handled by the underlying parallel executor.
     ///
-    /// Required **orx-parallel** feature.
+    /// Requires **orx-parallel** feature.
     ///
     /// [`ParIter`]: orx_parallel::ParIter
     /// [`iter_x`]: crate::List::iter_x
@@ -138,7 +138,6 @@ where
     ///
     /// let expected: usize = list.iter_x().filter(|x| *x % 2 == 0).sum();
     /// let sum_evens = list.par_x().filter(|x| *x % 2 == 0).sum();
-    /// std::dbg!(sum_evens, expected);
     /// ```
     #[cfg(feature = "orx-parallel")]
     pub fn par_x(&self) -> impl orx_parallel::ParIter<Item = &V::Item>
diff --git a/tests/list_move_next_to.rs b/tests/list_move_next_to.rs
index 144d870..fac255d 100644
--- a/tests/list_move_next_to.rs
+++ b/tests/list_move_next_to.rs
@@ -32,8 +32,6 @@ fn list_move_next_to_back() {
         let mut vec: Vec<_> = (0..n).into_iter().filter(|x| x != &i).collect();
         vec.insert(n - 1, i);
 
-        dbg!(i, &vec, list.iter().collect::<Vec<_>>());
-
         #[cfg(feature = "validation")]
         list.validate();
         assert!(list.eq_to_iter_refs(&vec));
diff --git a/tests/reverse.rs b/tests/reverse.rs
index d098cb3..8b24aba 100644
--- a/tests/reverse.rs
+++ b/tests/reverse.rs
@@ -84,7 +84,6 @@ fn slice_reverse_until_back() {
 #[test]
 fn slice_reverse_middle() {
     for i in 0..20 {
-        dbg!(i);
         let mut list = doubly::new_doubly(&mut &mut doubly::rng_with_seed(100 * i as u64), 20, 50);
         let mut expected: Vec<_> = list.iter().cloned().collect();
         let idx: Vec<_> = list.indices().collect();
diff --git a/tests/ring_iter_mut.rs b/tests/ring_iter_mut.rs
index 16dbdaa..91d4f39 100644
--- a/tests/ring_iter_mut.rs
+++ b/tests/ring_iter_mut.rs
@@ -11,7 +11,6 @@ fn ring_iter_mut_on_list() {
     let values: Vec<_> = list.iter().cloned().collect();
 
     for i in 0..n {
-        dbg!(i, n);
         let cyclic: Vec<_> = list.ring_iter_mut(&idx[i]).map(|x| x.clone()).collect();
         assert_eq!(cyclic.len(), n);
 
diff --git a/tests/slice_move_prev_to.rs b/tests/slice_move_prev_to.rs
index 7c4b4b5..49ff763 100644
--- a/tests/slice_move_prev_to.rs
+++ b/tests/slice_move_prev_to.rs
@@ -12,7 +12,6 @@ fn slice_move_prev_to_front() {
     let a = 1;
     let b = 5;
     for i in a..=b {
-        dbg!(i);
         let (mut list, idx) = list_and_indices(n);
         let mut slice = list.slice_mut(&idx[a]..=&idx[b]);
         let idx: Vec<_> = slice.indices().collect();