diff --git a/src/reader.rs b/src/reader.rs
index 2e5124f..0ce60a1 100644
--- a/src/reader.rs
+++ b/src/reader.rs
@@ -143,15 +143,15 @@ pub trait Reader< 'a, C: Context >: Sized {
         }
 
         let mut value: MaybeUninit< u16 > = MaybeUninit::uninit();
-        unsafe {
-            self.read_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 2 )?;
-            let value = value.assume_init();
+        
+            unsafe { self.read_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 2 )? };
+            let value = unsafe { value.assume_init() };
             if self.context().endianness().conversion_necessary() {
                 Ok( value.swap_bytes() )
             } else {
                 Ok( value )
             }
-        }
+        
     }
 
     #[inline(always)]
@@ -161,15 +161,15 @@ pub trait Reader< 'a, C: Context >: Sized {
         }
 
         let mut value: MaybeUninit< u16 > = MaybeUninit::uninit();
-        unsafe {
-            self.peek_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 2 )?;
-            let value = value.assume_init();
+        
+            unsafe { self.peek_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 2 )? };
+            let value = unsafe { value.assume_init() };
             if self.context().endianness().conversion_necessary() {
                 Ok( value.swap_bytes() )
             } else {
                 Ok( value )
             }
-        }
+        
     }
 
     #[inline(always)]
@@ -179,15 +179,15 @@ pub trait Reader< 'a, C: Context >: Sized {
         }
 
         let mut value: MaybeUninit< i16 > = MaybeUninit::uninit();
-        unsafe {
-            self.read_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 2 )?;
-            let value = value.assume_init();
+        
+            unsafe { self.read_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 2 )? };
+            let value = unsafe { value.assume_init() };
             if self.context().endianness().conversion_necessary() {
                 Ok( value.swap_bytes() )
             } else {
                 Ok( value )
             }
-        }
+        
     }
 
     #[inline(always)]
@@ -197,15 +197,15 @@ pub trait Reader< 'a, C: Context >: Sized {
         }
 
         let mut value: MaybeUninit< i16 > = MaybeUninit::uninit();
-        unsafe {
-            self.peek_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 2 )?;
-            let value = value.assume_init();
+        
+            unsafe { self.peek_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 2 )? };
+            let value = unsafe { value.assume_init() };
             if self.context().endianness().conversion_necessary() {
                 Ok( value.swap_bytes() )
             } else {
                 Ok( value )
             }
-        }
+        
     }
 
     #[inline(always)]
@@ -215,15 +215,15 @@ pub trait Reader< 'a, C: Context >: Sized {
         }
 
         let mut value: MaybeUninit< u32 > = MaybeUninit::uninit();
-        unsafe {
-            self.read_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 4 )?;
-            let value = value.assume_init();
+        
+            unsafe { self.read_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 4 )? };
+            let value = unsafe { value.assume_init() };
             if self.context().endianness().conversion_necessary() {
                 Ok( value.swap_bytes() )
             } else {
                 Ok( value )
             }
-        }
+        
     }
 
     #[inline(always)]
@@ -233,15 +233,15 @@ pub trait Reader< 'a, C: Context >: Sized {
         }
 
         let mut value: MaybeUninit< u32 > = MaybeUninit::uninit();
-        unsafe {
-            self.peek_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 4 )?;
-            let value = value.assume_init();
+        
+            unsafe { self.peek_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 4 )? };
+            let value = unsafe { value.assume_init() };
             if self.context().endianness().conversion_necessary() {
                 Ok( value.swap_bytes() )
             } else {
                 Ok( value )
             }
-        }
+        
     }
 
     #[inline(always)]
@@ -251,15 +251,15 @@ pub trait Reader< 'a, C: Context >: Sized {
         }
 
         let mut value: MaybeUninit< i32 > = MaybeUninit::uninit();
-        unsafe {
-            self.read_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 4 )?;
-            let value = value.assume_init();
+        
+            unsafe { self.read_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 4 )? };
+            let value = unsafe { value.assume_init() };
             if self.context().endianness().conversion_necessary() {
                 Ok( value.swap_bytes() )
             } else {
                 Ok( value )
             }
-        }
+        
     }
 
     #[inline(always)]
@@ -269,15 +269,15 @@ pub trait Reader< 'a, C: Context >: Sized {
         }
 
         let mut value: MaybeUninit< i32 > = MaybeUninit::uninit();
-        unsafe {
-            self.peek_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 4 )?;
-            let value = value.assume_init();
+        
+            unsafe { self.peek_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 4 )? };
+            let value = unsafe { value.assume_init() };
             if self.context().endianness().conversion_necessary() {
                 Ok( value.swap_bytes() )
             } else {
                 Ok( value )
             }
-        }
+        
     }
 
     #[inline(always)]
@@ -287,15 +287,15 @@ pub trait Reader< 'a, C: Context >: Sized {
         }
 
         let mut value: MaybeUninit< u64 > = MaybeUninit::uninit();
-        unsafe {
-            self.read_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 8 )?;
-            let value = value.assume_init();
+        
+            unsafe { self.read_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 8 )? };
+            let value = unsafe { value.assume_init() };
             if self.context().endianness().conversion_necessary() {
                 Ok( value.swap_bytes() )
             } else {
                 Ok( value )
             }
-        }
+        
     }
 
     #[inline(always)]
@@ -305,15 +305,15 @@ pub trait Reader< 'a, C: Context >: Sized {
         }
 
         let mut value: MaybeUninit< u64 > = MaybeUninit::uninit();
-        unsafe {
-            self.peek_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 8 )?;
-            let value = value.assume_init();
+        
+            unsafe { self.peek_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 8 )? };
+            let value = unsafe { value.assume_init() };
             if self.context().endianness().conversion_necessary() {
                 Ok( value.swap_bytes() )
             } else {
                 Ok( value )
             }
-        }
+        
     }
 
     #[inline(always)]
@@ -323,15 +323,15 @@ pub trait Reader< 'a, C: Context >: Sized {
         }
 
         let mut value: MaybeUninit< i64 > = MaybeUninit::uninit();
-        unsafe {
-            self.read_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 8 )?;
-            let value = value.assume_init();
+        
+            unsafe { self.read_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 8 )? };
+            let value = unsafe { value.assume_init() };
             if self.context().endianness().conversion_necessary() {
                 Ok( value.swap_bytes() )
             } else {
                 Ok( value )
             }
-        }
+        
     }
 
     #[inline(always)]
@@ -341,15 +341,15 @@ pub trait Reader< 'a, C: Context >: Sized {
         }
 
         let mut value: MaybeUninit< i64 > = MaybeUninit::uninit();
-        unsafe {
-            self.peek_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 8 )?;
-            let value = value.assume_init();
+        
+            unsafe { self.peek_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 8 )? };
+            let value = unsafe { value.assume_init() };
             if self.context().endianness().conversion_necessary() {
                 Ok( value.swap_bytes() )
             } else {
                 Ok( value )
             }
-        }
+        
     }
 
     #[inline(always)]
@@ -359,15 +359,15 @@ pub trait Reader< 'a, C: Context >: Sized {
         }
 
         let mut value: MaybeUninit< u128 > = MaybeUninit::uninit();
-        unsafe {
-            self.read_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 16 )?;
-            let value = value.assume_init();
+        
+            unsafe { self.read_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 16 )? };
+            let value = unsafe { value.assume_init() };
             if self.context().endianness().conversion_necessary() {
                 Ok( value.swap_bytes() )
             } else {
                 Ok( value )
             }
-        }
+        
     }
 
     #[inline(always)]
@@ -377,15 +377,15 @@ pub trait Reader< 'a, C: Context >: Sized {
         }
 
         let mut value: MaybeUninit< u128 > = MaybeUninit::uninit();
-        unsafe {
-            self.peek_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 16 )?;
-            let value = value.assume_init();
+        
+            unsafe { self.peek_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 16 )? };
+            let value = unsafe { value.assume_init() };
             if self.context().endianness().conversion_necessary() {
                 Ok( value.swap_bytes() )
             } else {
                 Ok( value )
             }
-        }
+        
     }
 
     #[inline(always)]
@@ -395,15 +395,15 @@ pub trait Reader< 'a, C: Context >: Sized {
         }
 
         let mut value: MaybeUninit< i128 > = MaybeUninit::uninit();
-        unsafe {
-            self.read_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 16 )?;
-            let value = value.assume_init();
+        
+            unsafe { self.read_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 16 )? };
+            let value = unsafe { value.assume_init() };
             if self.context().endianness().conversion_necessary() {
                 Ok( value.swap_bytes() )
             } else {
                 Ok( value )
             }
-        }
+        
     }
 
     #[inline(always)]
@@ -413,15 +413,15 @@ pub trait Reader< 'a, C: Context >: Sized {
         }
 
         let mut value: MaybeUninit< i128 > = MaybeUninit::uninit();
-        unsafe {
-            self.peek_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 16 )?;
-            let value = value.assume_init();
+        
+            unsafe { self.peek_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 16 )? };
+            let value = unsafe { value.assume_init() };
             if self.context().endianness().conversion_necessary() {
                 Ok( value.swap_bytes() )
             } else {
                 Ok( value )
             }
-        }
+        
     }
 
     #[inline(always)]
@@ -431,15 +431,15 @@ pub trait Reader< 'a, C: Context >: Sized {
         }
 
         let mut value: MaybeUninit< f32 > = MaybeUninit::uninit();
-        unsafe {
-            self.read_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 4 )?;
-            let value = value.assume_init();
+        
+            unsafe { self.read_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 4 )? };
+            let value = unsafe { value.assume_init() };
             if self.context().endianness().conversion_necessary() {
                 Ok( value.swap_bytes() )
             } else {
                 Ok( value )
             }
-        }
+        
     }
 
     #[inline(always)]
@@ -449,15 +449,15 @@ pub trait Reader< 'a, C: Context >: Sized {
         }
 
         let mut value: MaybeUninit< f32 > = MaybeUninit::uninit();
-        unsafe {
-            self.peek_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 4 )?;
-            let value = value.assume_init();
+        
+            unsafe { self.peek_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 4 )? };
+            let value = unsafe { value.assume_init() };
             if self.context().endianness().conversion_necessary() {
                 Ok( value.swap_bytes() )
             } else {
                 Ok( value )
             }
-        }
+        
     }
 
     #[inline(always)]
@@ -467,15 +467,15 @@ pub trait Reader< 'a, C: Context >: Sized {
         }
 
         let mut value: MaybeUninit< f64 > = MaybeUninit::uninit();
-        unsafe {
-            self.read_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 8 )?;
-            let value = value.assume_init();
+        
+            unsafe { self.read_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 8 )? };
+            let value = unsafe { value.assume_init() };
             if self.context().endianness().conversion_necessary() {
                 Ok( value.swap_bytes() )
             } else {
                 Ok( value )
             }
-        }
+        
     }
 
     #[inline(always)]
@@ -485,15 +485,15 @@ pub trait Reader< 'a, C: Context >: Sized {
         }
 
         let mut value: MaybeUninit< f64 > = MaybeUninit::uninit();
-        unsafe {
-            self.peek_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 8 )?;
-            let value = value.assume_init();
+        
+            unsafe { self.peek_bytes_into_ptr( value.as_mut_ptr() as *mut u8, 8 )? };
+            let value = unsafe { value.assume_init() };
             if self.context().endianness().conversion_necessary() {
                 Ok( value.swap_bytes() )
             } else {
                 Ok( value )
             }
-        }
+        
     }
 
     #[inline(always)]
@@ -551,8 +551,8 @@ pub trait Reader< 'a, C: Context >: Sized {
                 unsafe {
                     std::ptr::write( p, value );
                     p = p.add( 1 );
-                    count += 1;
                 }
+                count += 1;
             }
             unsafe {
                 vec.set_len( length );
diff --git a/src/utils.rs b/src/utils.rs
index cc2f178..b67644c 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -34,8 +34,8 @@ impl SwapBytes for f32 {
             int: u32
         }
 
+        let mut u = Union { float: self };
         unsafe {
-            let mut u = Union { float: self };
             u.int = u.int.swap_bytes();
             u.float
         }
@@ -50,8 +50,8 @@ impl SwapBytes for f64 {
             int: u64
         }
 
+        let mut u = Union { float: self };
         unsafe {
-            let mut u = Union { float: self };
             u.int = u.int.swap_bytes();
             u.float
         }