diff --git a/src/readable_impl.rs b/src/readable_impl.rs
index 30a89bd..e48b99f 100644
--- a/src/readable_impl.rs
+++ b/src/readable_impl.rs
@@ -13,148 +13,145 @@ use crate::utils::SwapBytes;
 
 impl<'a, C, K, V> Readable<'a, C> for BTreeMap<K, V>
 where
-    C: Context,
-    K: Readable<'a, C> + Ord,
-    V: Readable<'a, C>,
+  C: Context,
+  K: Readable<'a, C> + Ord,
+  V: Readable<'a, C>,
 {
-    #[inline]
-    fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
-        let length = crate::private::read_length(reader)?;
-        reader.read_collection(length)
-    }
+  #[inline]
+  fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
+    let length = crate::private::read_length(reader)?;
+    reader.read_collection(length)
+  }
 
-    #[inline]
-    fn minimum_bytes_needed() -> usize {
-        4
-    }
+  #[inline]
+  fn minimum_bytes_needed() -> usize {
+    4
+  }
 }
 
 impl<'a, C, T> Readable<'a, C> for BTreeSet<T>
 where
-    C: Context,
-    T: Readable<'a, C> + Ord,
+  C: Context,
+  T: Readable<'a, C> + Ord,
 {
-    #[inline]
-    fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
-        let length = crate::private::read_length(reader)?;
-        reader.read_collection(length)
-    }
+  #[inline]
+  fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
+    let length = crate::private::read_length(reader)?;
+    reader.read_collection(length)
+  }
 
-    #[inline]
-    fn minimum_bytes_needed() -> usize {
-        4
-    }
+  #[inline]
+  fn minimum_bytes_needed() -> usize {
+    4
+  }
 }
 
 impl<'a, C, K, V, S> Readable<'a, C> for HashMap<K, V, S>
 where
-    C: Context,
-    K: Readable<'a, C> + Eq + Hash,
-    V: Readable<'a, C>,
-    S: BuildHasher + Default,
+  C: Context,
+  K: Readable<'a, C> + Eq + Hash,
+  V: Readable<'a, C>,
+  S: BuildHasher + Default,
 {
-    #[inline]
-    fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
-        let length = crate::private::read_length(reader)?;
-        reader.read_collection(length)
-    }
+  #[inline]
+  fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
+    let length = crate::private::read_length(reader)?;
+    reader.read_collection(length)
+  }
 
-    #[inline]
-    fn minimum_bytes_needed() -> usize {
-        4
-    }
+  #[inline]
+  fn minimum_bytes_needed() -> usize {
+    4
+  }
 }
 
 impl<'a, C, T, S> Readable<'a, C> for HashSet<T, S>
 where
-    C: Context,
-    T: Readable<'a, C> + Eq + Hash,
-    S: BuildHasher + Default,
+  C: Context,
+  T: Readable<'a, C> + Eq + Hash,
+  S: BuildHasher + Default,
 {
-    #[inline]
-    fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
-        let length = crate::private::read_length(reader)?;
-        reader.read_collection(length)
-    }
+  #[inline]
+  fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
+    let length = crate::private::read_length(reader)?;
+    reader.read_collection(length)
+  }
 
-    #[inline]
-    fn minimum_bytes_needed() -> usize {
-        4
-    }
+  #[inline]
+  fn minimum_bytes_needed() -> usize {
+    4
+  }
 }
 
 impl<'a, C: Context> Readable<'a, C> for bool {
-    #[inline]
-    fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
-        let value = reader.read_u8()?;
-        if value == 0 {
-            Ok(false)
-        } else {
-            Ok(true)
-        }
+  #[inline]
+  fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
+    let value = reader.read_u8()?;
+    if value == 0 {
+      Ok(false)
+    } else {
+      Ok(true)
     }
+  }
 
-    #[inline]
-    fn minimum_bytes_needed() -> usize {
-        1
-    }
+  #[inline]
+  fn minimum_bytes_needed() -> usize {
+    1
+  }
 }
 
 impl<'a, C: Context> Readable<'a, C> for char {
-    #[inline]
-    fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
-        let value = reader.read_u32()?;
-        std::char::from_u32(value).ok_or_else(crate::error::error_out_of_range_char)
-    }
+  #[inline]
+  fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
+    let value = reader.read_u32()?;
+    std::char::from_u32(value).ok_or_else(crate::error::error_out_of_range_char)
+  }
 
-    #[inline]
-    fn minimum_bytes_needed() -> usize {
-        4
-    }
+  #[inline]
+  fn minimum_bytes_needed() -> usize {
+    4
+  }
 }
 
 macro_rules! impl_for_primitive {
-    ($type:ty, $getter:ident, $endianness_swap:ident) => {
-        impl<'a, C: Context> Readable<'a, C> for $type {
-            #[inline(always)]
-            fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
-                reader.$getter()
-            }
-
-            #[inline]
-            fn minimum_bytes_needed() -> usize {
-                mem::size_of::<Self>()
-            }
-
-            #[inline(always)]
-            fn speedy_is_primitive() -> bool {
-                true
-            }
-
-            #[inline]
-            unsafe fn speedy_slice_from_bytes(slice: &[u8]) -> &[Self] {
-                std::slice::from_raw_parts(
-                    slice.as_ptr() as *const $type,
-                    slice.len() / mem::size_of::<Self>(),
-                )
-            }
-
-            #[inline(always)]
-            fn speedy_flip_endianness(itself: *mut Self) {
-                unsafe {
-                    std::ptr::write_unaligned(
-                        itself,
-                        std::ptr::read_unaligned(itself).swap_bytes(),
-                    );
-                }
-            }
-
-            #[inline(always)]
-            fn speedy_convert_slice_endianness(endianness: Endianness, slice: &mut [$type]) {
-                endianness.$endianness_swap(slice);
-            }
+  ($type:ty, $getter:ident, $endianness_swap:ident) => {
+    impl<'a, C: Context> Readable<'a, C> for $type {
+      #[inline(always)]
+      fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
+        reader.$getter()
+      }
+
+      #[inline]
+      fn minimum_bytes_needed() -> usize {
+        mem::size_of::<Self>()
+      }
+
+      #[inline(always)]
+      fn speedy_is_primitive() -> bool {
+        true
+      }
+
+      #[inline]
+      unsafe fn speedy_slice_from_bytes(slice: &[u8]) -> &[Self] {
+        std::slice::from_raw_parts(
+          slice.as_ptr() as *const $type,
+          slice.len() / mem::size_of::<Self>(),
+        )
+      }
+
+      #[inline(always)]
+      fn speedy_flip_endianness(itself: *mut Self) {
+        unsafe {
+          std::ptr::write_unaligned(itself, std::ptr::read_unaligned(itself).swap_bytes());
         }
-    };
+      }
+
+      #[inline(always)]
+      fn speedy_convert_slice_endianness(endianness: Endianness, slice: &mut [$type]) {
+        endianness.$endianness_swap(slice);
+      }
+    }
+  };
 }
 
 impl_for_primitive!(i8, read_i8, swap_slice_i8);
@@ -171,122 +168,122 @@ impl_for_primitive!(f32, read_f32, swap_slice_f32);
 impl_for_primitive!(f64, read_f64, swap_slice_f64);
 
 impl<'a, C: Context> Readable<'a, C> for usize {
-    #[inline]
-    fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
-        let value = u64::read_from(reader)?;
-        if value > std::usize::MAX as u64 {
-            return Err(crate::error::error_too_big_usize_for_this_architecture());
-        }
-        Ok(value as usize)
+  #[inline]
+  fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
+    let value = u64::read_from(reader)?;
+    if value > std::usize::MAX as u64 {
+      return Err(crate::error::error_too_big_usize_for_this_architecture());
     }
+    Ok(value as usize)
+  }
 
-    #[inline]
-    fn minimum_bytes_needed() -> usize {
-        <u64 as Readable<'a, C>>::minimum_bytes_needed()
-    }
+  #[inline]
+  fn minimum_bytes_needed() -> usize {
+    <u64 as Readable<'a, C>>::minimum_bytes_needed()
+  }
 }
 
 impl<'a, C: Context> Readable<'a, C> for String {
-    #[inline]
-    fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
-        let bytes: Vec<u8> = reader.read_value()?;
-        let value = crate::private::vec_to_string(bytes)?;
-        Ok(value)
-    }
+  #[inline]
+  fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
+    let bytes: Vec<u8> = reader.read_value()?;
+    let value = crate::private::vec_to_string(bytes)?;
+    Ok(value)
+  }
 
-    #[inline]
-    fn minimum_bytes_needed() -> usize {
-        <Vec<u8> as Readable<'a, C>>::minimum_bytes_needed()
-    }
+  #[inline]
+  fn minimum_bytes_needed() -> usize {
+    <Vec<u8> as Readable<'a, C>>::minimum_bytes_needed()
+  }
 }
 
 impl<'a, C: Context> Readable<'a, C> for Cow<'a, str> {
-    #[inline]
-    fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
-        let length = crate::private::read_length(reader)?;
-        let bytes: Cow<'a, [u8]> = reader.read_cow(length)?;
-        let value = crate::private::cow_bytes_to_cow_str(bytes)?;
-        Ok(value)
-    }
+  #[inline]
+  fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
+    let length = crate::private::read_length(reader)?;
+    let bytes: Cow<'a, [u8]> = reader.read_cow(length)?;
+    let value = crate::private::cow_bytes_to_cow_str(bytes)?;
+    Ok(value)
+  }
 
-    #[inline]
-    fn minimum_bytes_needed() -> usize {
-        <String as Readable<'a, C>>::minimum_bytes_needed()
-    }
+  #[inline]
+  fn minimum_bytes_needed() -> usize {
+    <String as Readable<'a, C>>::minimum_bytes_needed()
+  }
 }
 
 impl<'a, C: Context, T: Readable<'a, C>> Readable<'a, C> for Vec<T> {
-    #[inline]
-    fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
-        let length = crate::private::read_length(reader)?;
-        reader.read_vec(length)
-    }
+  #[inline]
+  fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
+    let length = crate::private::read_length(reader)?;
+    reader.read_vec(length)
+  }
 
-    #[inline]
-    fn minimum_bytes_needed() -> usize {
-        4
-    }
+  #[inline]
+  fn minimum_bytes_needed() -> usize {
+    4
+  }
 }
 
 impl<'a, C: Context, T: Readable<'a, C>> Readable<'a, C> for Cow<'a, [T]>
 where
-    [T]: ToOwned<Owned = Vec<T>>,
+  [T]: ToOwned<Owned = Vec<T>>,
 {
-    #[inline]
-    fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
-        let length = crate::private::read_length(reader)?;
-        reader.read_cow(length)
-    }
+  #[inline]
+  fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
+    let length = crate::private::read_length(reader)?;
+    reader.read_cow(length)
+  }
 
-    #[inline]
-    fn minimum_bytes_needed() -> usize {
-        <Vec<T> as Readable<'a, C>>::minimum_bytes_needed()
-    }
+  #[inline]
+  fn minimum_bytes_needed() -> usize {
+    <Vec<T> as Readable<'a, C>>::minimum_bytes_needed()
+  }
 }
 
 impl<'a, C: Context, T: Readable<'a, C>> Readable<'a, C> for Range<T> {
-    #[inline]
-    fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
-        let start = reader.read_value()?;
-        let end = reader.read_value()?;
-        Ok(start..end)
-    }
+  #[inline]
+  fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
+    let start = reader.read_value()?;
+    let end = reader.read_value()?;
+    Ok(start..end)
+  }
 
-    #[inline]
-    fn minimum_bytes_needed() -> usize {
-        <T as Readable<'a, C>>::minimum_bytes_needed() * 2
-    }
+  #[inline]
+  fn minimum_bytes_needed() -> usize {
+    <T as Readable<'a, C>>::minimum_bytes_needed() * 2
+  }
 }
 
 impl<'a, C: Context, T: Readable<'a, C>> Readable<'a, C> for Option<T> {
-    #[inline]
-    fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
-        let flag = reader.read_value()?;
-        let value = if flag {
-            Some(reader.read_value()?)
-        } else {
-            None
-        };
-
-        Ok(value)
-    }
+  #[inline]
+  fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
+    let flag = reader.read_value()?;
+    let value = if flag {
+      Some(reader.read_value()?)
+    } else {
+      None
+    };
 
-    #[inline]
-    fn minimum_bytes_needed() -> usize {
-        1
-    }
+    Ok(value)
+  }
+
+  #[inline]
+  fn minimum_bytes_needed() -> usize {
+    1
+  }
 }
 
 impl<'a, C: Context> Readable<'a, C> for () {
-    #[inline]
-    fn read_from<R: Reader<'a, C>>(_: &mut R) -> Result<Self, C::Error> {
-        Ok(())
-    }
+  #[inline]
+  fn read_from<R: Reader<'a, C>>(_: &mut R) -> Result<Self, C::Error> {
+    Ok(())
+  }
 
-    #[inline]
-    fn minimum_bytes_needed() -> usize {
-        0
-    }
+  #[inline]
+  fn minimum_bytes_needed() -> usize {
+    0
+  }
 }
 
 macro_rules! impl_for_tuple {
@@ -327,37 +324,37 @@ impl_for_tuple!(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9);
 impl_for_tuple!(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
 
 impl<'a, C: Context> Readable<'a, C> for Endianness {
-    #[inline]
-    fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
-        let value = reader.read_u8()?;
-        match value {
-            0 => Ok(Endianness::LittleEndian),
-            1 => Ok(Endianness::BigEndian),
-            _ => Err(crate::error::error_invalid_enum_variant()),
-        }
+  #[inline]
+  fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
+    let value = reader.read_u8()?;
+    match value {
+      0 => Ok(Endianness::LittleEndian),
+      1 => Ok(Endianness::BigEndian),
+      _ => Err(crate::error::error_invalid_enum_variant()),
     }
+  }
 
-    #[inline]
-    fn minimum_bytes_needed() -> usize {
-        1
-    }
+  #[inline]
+  fn minimum_bytes_needed() -> usize {
+    1
+  }
 }
 
 macro_rules! impl_for_non_zero {
-    ($type:ident, $base_type:ty) => {
-        impl<'a, C: Context> Readable<'a, C> for std::num::$type {
-            #[inline]
-            fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
-                let value: $base_type = reader.read_value()?;
-                std::num::$type::new(value).ok_or_else(crate::error::error_zero_non_zero)
-            }
-
-            #[inline]
-            fn minimum_bytes_needed() -> usize {
-                mem::size_of::<$base_type>()
-            }
-        }
-    };
+  ($type:ident, $base_type:ty) => {
+    impl<'a, C: Context> Readable<'a, C> for std::num::$type {
+      #[inline]
+      fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
+        let value: $base_type = reader.read_value()?;
+        std::num::$type::new(value).ok_or_else(crate::error::error_zero_non_zero)
+      }
+
+      #[inline]
+      fn minimum_bytes_needed() -> usize {
+        mem::size_of::<$base_type>()
+      }
+    }
+  };
 }
 
 impl_for_non_zero!(NonZeroU8, u8);
@@ -370,20 +367,20 @@ impl_for_non_zero!(NonZeroI32, i32);
 impl_for_non_zero!(NonZeroI64, i64);
 
 macro_rules! impl_for_atomic {
-    ($type:ident, $base_type:ty) => {
-        impl<'a, C: Context> Readable<'a, C> for std::sync::atomic::$type {
-            #[inline(always)]
-            fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
-                let value: $base_type = reader.read_value()?;
-                Ok(value.into())
-            }
-
-            #[inline]
-            fn minimum_bytes_needed() -> usize {
-                mem::size_of::<$base_type>()
-            }
-        }
-    };
+  ($type:ident, $base_type:ty) => {
+    impl<'a, C: Context> Readable<'a, C> for std::sync::atomic::$type {
+      #[inline(always)]
+      fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
+        let value: $base_type = reader.read_value()?;
+        Ok(value.into())
+      }
+
+      #[inline]
+      fn minimum_bytes_needed() -> usize {
+        mem::size_of::<$base_type>()
+      }
+    }
+  };
 }
 
 impl_for_atomic!(AtomicI8, i8);
@@ -398,101 +395,101 @@ impl_for_atomic!(AtomicU64, u64);
 
 impl<'a, C> Readable<'a, C> for std::net::Ipv4Addr
 where
-    C: Context,
+  C: Context,
 {
-    #[inline]
-    fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
-        let value = reader.read_u32()?;
-        Ok(value.into())
-    }
+  #[inline]
+  fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
+    let value = reader.read_u32()?;
+    Ok(value.into())
+  }
 
-    #[inline]
-    fn minimum_bytes_needed() -> usize {
-        4
-    }
+  #[inline]
+  fn minimum_bytes_needed() -> usize {
+    4
+  }
 }
 
 impl<'a, C> Readable<'a, C> for std::net::Ipv6Addr
 where
-    C: Context,
+  C: Context,
 {
-    #[inline]
-    fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
-        let mut octets = [0; 16];
-        reader.read_bytes(&mut octets)?;
-        if !reader.endianness().conversion_necessary() {
-            octets.reverse();
-        }
-
-        Ok(octets.into())
+  #[inline]
+  fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
+    let mut octets = [0; 16];
+    reader.read_bytes(&mut octets)?;
+    if !reader.endianness().conversion_necessary() {
+      octets.reverse();
     }
 
-    #[inline]
-    fn minimum_bytes_needed() -> usize {
-        16
-    }
+    Ok(octets.into())
+  }
+
+  #[inline]
+  fn minimum_bytes_needed() -> usize {
+    16
+  }
 }
 
 impl<'a, C> Readable<'a, C> for std::net::SocketAddrV4
 where
-    C: Context,
+  C: Context,
 {
-    #[inline]
-    fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
-        Ok(Self::new(
-            std::net::Ipv4Addr::read_from(reader)?,
-            reader.read_u16()?,
-        ))
-    }
+  #[inline]
+  fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
+    Ok(Self::new(
+      std::net::Ipv4Addr::read_from(reader)?,
+      reader.read_u16()?,
+    ))
+  }
 
-    #[inline]
-    fn minimum_bytes_needed() -> usize {
-        6
-    }
+  #[inline]
+  fn minimum_bytes_needed() -> usize {
+    6
+  }
 }
 
 impl<'a, C> Readable<'a, C> for std::net::SocketAddrV6
 where
-    C: Context,
+  C: Context,
 {
-    #[inline]
-    fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
-        Ok(Self::new(
-            std::net::Ipv6Addr::read_from(reader)?,
-            reader.read_u16()?,
-            0,
-            0,
-        ))
-    }
+  #[inline]
+  fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
+    Ok(Self::new(
+      std::net::Ipv6Addr::read_from(reader)?,
+      reader.read_u16()?,
+      0,
+      0,
+    ))
+  }
 
-    #[inline]
-    fn minimum_bytes_needed() -> usize {
-        18
-    }
+  #[inline]
+  fn minimum_bytes_needed() -> usize {
+    18
+  }
 }
 
 macro_rules! impl_for_addr {
-    ($type:ident, $min_bytes:expr) => {
-        impl<'a, C> Readable<'a, C> for std::net::$type
-        where
-            C: Context,
-        {
-            #[inline]
-            fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
-                let kind = reader.read_u8()?;
-                match kind {
-                    0 => Ok(std::net::$type::V4(reader.read_value()?)),
-                    1 => Ok(std::net::$type::V6(reader.read_value()?)),
-                    _ => Err(crate::error::error_invalid_enum_variant()),
-                }
-            }
-
-            #[inline]
-            fn minimum_bytes_needed() -> usize {
-                $min_bytes
-            }
+  ($type:ident, $min_bytes:expr) => {
+    impl<'a, C> Readable<'a, C> for std::net::$type
+    where
+      C: Context,
+    {
+      #[inline]
+      fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
+        let kind = reader.read_u8()?;
+        match kind {
+          0 => Ok(std::net::$type::V4(reader.read_value()?)),
+          1 => Ok(std::net::$type::V6(reader.read_value()?)),
+          _ => Err(crate::error::error_invalid_enum_variant()),
         }
-    };
+      }
+
+      #[inline]
+      fn minimum_bytes_needed() -> usize {
+        $min_bytes
+      }
+    }
+  };
 }
 
 impl_for_addr!(IpAddr, 5);
@@ -500,117 +497,118 @@ impl_for_addr!(SocketAddr, 7);
 
 impl<'a, C> Readable<'a, C> for std::time::Duration
 where
-    C: Context,
+  C: Context,
 {
-    #[inline]
-    fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
-        let secs = reader.read_u64()?;
-        let nanos = reader.read_u32()?;
-        Ok(std::time::Duration::new(secs, nanos))
-    }
+  #[inline]
+  fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
+    let secs = reader.read_u64()?;
+    let nanos = reader.read_u32()?;
+    Ok(std::time::Duration::new(secs, nanos))
+  }
 
-    #[inline]
-    fn minimum_bytes_needed() -> usize {
-        12
-    }
+  #[inline]
+  fn minimum_bytes_needed() -> usize {
+    12
+  }
 }
 
 impl<'a, C> Readable<'a, C> for std::time::SystemTime
 where
-    C: Context,
+  C: Context,
 {
-    #[inline]
-    fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
-        let duration = std::time::Duration::read_from(reader)?;
-        std::time::SystemTime::UNIX_EPOCH
-            .checked_add(duration)
-            .ok_or_else(crate::error::error_invalid_system_time)
-    }
+  #[inline]
+  fn read_from<R: Reader<'a, C>>(reader: &mut R) -> Result<Self, C::Error> {
+    let duration = std::time::Duration::read_from(reader)?;
+    std::time::SystemTime::UNIX_EPOCH
+      .checked_add(duration)
+      .ok_or_else(crate::error::error_invalid_system_time)
+  }
 
-    #[inline]
-    fn minimum_bytes_needed() -> usize {
-        12
-    }
+  #[inline]
+  fn minimum_bytes_needed() -> usize {
+    12
+  }
 }
 
 impl<'a, C, T, const N: usize> Readable<'a, C> for [T; N]
 where
-    C: Context,
-    T: Readable<'a, C>,
+  C: Context,
+  T: Readable<'a, C>,
 {
-    #[inline(always)]
-    fn read_from<R>(reader: &mut R) -> Result<Self, C::Error>
-    where
-        R: Reader<'a, C>,
-    {
-        let mut array: [T; N] = unsafe { MaybeUninit::uninit().assume_init() };
-        for i in 0..N {
-            array[i] = reader.read_value()?;
-        }
-
-        Ok(array)
-    }
+  #[inline(always)]
+  fn read_from<R>(reader: &mut R) -> Result<Self, C::Error>
+  where
+    R: Reader<'a, C>,
+  {
+    let mut array: [T; N] = unsafe { MaybeUninit::uninit().assume_init() };
+
+    for i in 0..N {
+      array[i] = reader.read_value()?;
+    }
+    //[seq_macro::seq!(n in 0..N, {reader.read_value()?,})];
+    Ok(array)
+  }
 
-    #[inline]
-    fn minimum_bytes_needed() -> usize {
-        T::minimum_bytes_needed() * N
-    }
+  #[inline]
+  fn minimum_bytes_needed() -> usize {
+    T::minimum_bytes_needed() * N
+  }
 }
 
 impl<'a, C, T> Readable<'a, C> for Box<T>
 where
-    C: Context,
-    T: Readable<'a, C>,
+  C: Context,
+  T: Readable<'a, C>,
 {
-    #[inline]
-    fn read_from<R>(reader: &mut R) -> Result<Self, C::Error>
-    where
-        R: Reader<'a, C>,
-    {
-        Ok(Box::new(T::read_from(reader)?))
-    }
+  #[inline]
+  fn read_from<R>(reader: &mut R) -> Result<Self, C::Error>
+  where
+    R: Reader<'a, C>,
+  {
+    Ok(Box::new(T::read_from(reader)?))
+  }
 
-    #[inline]
-    fn minimum_bytes_needed() -> usize {
-        T::minimum_bytes_needed()
-    }
+  #[inline]
+  fn minimum_bytes_needed() -> usize {
+    T::minimum_bytes_needed()
+  }
 }
 
 impl<'a, C, T> Readable<'a, C> for Box<[T]>
 where
-    C: Context,
-    T: Readable<'a, C>,
+  C: Context,
+  T: Readable<'a, C>,
 {
-    #[inline]
-    fn read_from<R>(reader: &mut R) -> Result<Self, C::Error>
-    where
-        R: Reader<'a, C>,
-    {
-        let data = Vec::<T>::read_from(reader)?;
-        Ok(data.into())
-    }
+  #[inline]
+  fn read_from<R>(reader: &mut R) -> Result<Self, C::Error>
+  where
+    R: Reader<'a, C>,
+  {
+    let data = Vec::<T>::read_from(reader)?;
+    Ok(data.into())
+  }
 
-    #[inline]
-    fn minimum_bytes_needed() -> usize {
-        Vec::<T>::minimum_bytes_needed()
-    }
+  #[inline]
+  fn minimum_bytes_needed() -> usize {
+    Vec::<T>::minimum_bytes_needed()
+  }
 }
 
 impl<'a, C> Readable<'a, C> for Box<str>
 where
-    C: Context,
+  C: Context,
 {
-    #[inline]
-    fn read_from<R>(reader: &mut R) -> Result<Self, C::Error>
-    where
-        R: Reader<'a, C>,
-    {
-        let data = String::read_from(reader)?;
-        Ok(data.into())
-    }
+  #[inline]
+  fn read_from<R>(reader: &mut R) -> Result<Self, C::Error>
+  where
+    R: Reader<'a, C>,
+  {
+    let data = String::read_from(reader)?;
+    Ok(data.into())
+  }
 
-    #[inline]
-    fn minimum_bytes_needed() -> usize {
-        <String as Readable<'a, C>>::minimum_bytes_needed()
-    }
+  #[inline]
+  fn minimum_bytes_needed() -> usize {
+    <String as Readable<'a, C>>::minimum_bytes_needed()
+  }
 }