diff --git a/src/meta/size.rs b/src/meta/size.rs
index a8db5b3..1cc0861 100644
--- a/src/meta/size.rs
+++ b/src/meta/size.rs
@@ -2,9 +2,13 @@ use crate::color::{ColoredString, Colors, Elem};
 use crate::flags::{Flags, SizeFlag};
 use std::fs::Metadata;
 
+const KB: u64 = 1024;
+const MB: u64 = 1024_u64.pow(2);
+const GB: u64 = 1024_u64.pow(3);
+const TB: u64 = 1024_u64.pow(4);
+
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum Unit {
-    None,
     Byte,
     Kilo,
     Mega,
@@ -19,8 +23,7 @@ pub struct Size {
 
 impl From<&Metadata> for Size {
     fn from(meta: &Metadata) -> Self {
-        let len = meta.len();
-        Self { bytes: len }
+        Self { bytes: meta.len() }
     }
 }
 
@@ -38,16 +41,16 @@ impl Size {
     }
 
     pub fn get_unit(&self, flags: &Flags) -> Unit {
-        if self.bytes < 1024 || flags.size == SizeFlag::Bytes {
-            Unit::Byte
-        } else if self.bytes < 1024 * 1024 {
-            Unit::Kilo
-        } else if self.bytes < 1024 * 1024 * 1024 {
-            Unit::Mega
-        } else if self.bytes < 1024 * 1024 * 1024 * 1024 {
-            Unit::Giga
-        } else {
-            Unit::Tera
+        if flags.size == SizeFlag::Bytes {
+            return Unit::Byte;
+        }
+
+        match self.bytes {
+            b if b < KB => Unit::Byte,
+            b if b < MB => Unit::Kilo,
+            b if b < GB => Unit::Mega,
+            b if b < TB => Unit::Giga,
+            _ => Unit::Tera,
         }
     }
 
@@ -85,16 +88,13 @@ impl Size {
 
     fn paint(&self, colors: &Colors, flags: &Flags, content: String) -> ColoredString {
         let unit = self.get_unit(flags);
+        let elem = match unit {
+            Unit::Byte | Unit::Kilo => &Elem::FileSmall,
+            Unit::Mega => &Elem::FileMedium,
+            _ => &Elem::FileLarge,
+        };
 
-        if unit == Unit::None {
-            colors.colorize(content, &Elem::NonFile)
-        } else if unit == Unit::Byte || unit == Unit::Kilo {
-            colors.colorize(content, &Elem::FileSmall)
-        } else if unit == Unit::Mega {
-            colors.colorize(content, &Elem::FileMedium)
-        } else {
-            colors.colorize(content, &Elem::FileLarge)
-        }
+        colors.colorize(content, elem)
     }
 
     pub fn render_value(&self, colors: &Colors, flags: &Flags) -> ColoredString {
@@ -107,18 +107,11 @@ impl Size {
         let unit = self.get_unit(flags);
 
         match unit {
-            Unit::None => "".to_string(),
             Unit::Byte => self.bytes.to_string(),
-            Unit::Kilo => self.format_size(((self.bytes as f64) / 1024.0 * 10.0).round() / 10.0),
-            Unit::Mega => {
-                self.format_size(((self.bytes as f64) / (1024.0 * 1024.0) * 10.0).round() / 10.0)
-            }
-            Unit::Giga => self.format_size(
-                ((self.bytes as f64) / (1024.0 * 1024.0 * 1024.0) * 10.0).round() / 10.0,
-            ),
-            Unit::Tera => self.format_size(
-                ((self.bytes as f64) / (1024.0 * 1024.0 * 1024.0 * 1024.0) * 10.0).round() / 10.0,
-            ),
+            Unit::Kilo => self.format_size(((self.bytes as f64 / KB as f64) * 10.0).round() / 10.0),
+            Unit::Mega => self.format_size(((self.bytes as f64 / MB as f64) * 10.0).round() / 10.0),
+            Unit::Giga => self.format_size(((self.bytes as f64 / GB as f64) * 10.0).round() / 10.0),
+            Unit::Tera => self.format_size(((self.bytes as f64 / TB as f64) * 10.0).round() / 10.0),
         }
     }
 
@@ -133,20 +126,18 @@ impl Size {
 
         match flags.size {
             SizeFlag::Default => match unit {
-                Unit::None => String::from("-"),
-                Unit::Byte => String::from("B"),
+                Unit::Byte => String::from('B'),
                 Unit::Kilo => String::from("KB"),
                 Unit::Mega => String::from("MB"),
                 Unit::Giga => String::from("GB"),
                 Unit::Tera => String::from("TB"),
             },
             SizeFlag::Short => match unit {
-                Unit::None => String::from("-"),
-                Unit::Byte => String::from("B"),
-                Unit::Kilo => String::from("K"),
-                Unit::Mega => String::from("M"),
-                Unit::Giga => String::from("G"),
-                Unit::Tera => String::from("T"),
+                Unit::Byte => String::from('B'),
+                Unit::Kilo => String::from('K'),
+                Unit::Mega => String::from('M'),
+                Unit::Giga => String::from('G'),
+                Unit::Tera => String::from('T'),
             },
             SizeFlag::Bytes => String::from(""),
         }
@@ -155,7 +146,7 @@ impl Size {
 
 #[cfg(test)]
 mod test {
-    use super::Size;
+    use super::{Size, GB, KB, MB, TB};
     use crate::color::{Colors, ThemeOption};
     use crate::flags::{Flags, SizeFlag};
 
@@ -175,7 +166,7 @@ mod test {
 
     #[test]
     fn render_10_minus_kilobyte() {
-        let size = Size::new(4 * 1024); // 4 kilobytes
+        let size = Size::new(4 * KB); // 4 kilobytes
         let mut flags = Flags::default();
 
         assert_eq!(size.value_string(&flags).as_str(), "4.0");
@@ -186,7 +177,7 @@ mod test {
 
     #[test]
     fn render_kilobyte() {
-        let size = Size::new(42 * 1024); // 42 kilobytes
+        let size = Size::new(42 * KB); // 42 kilobytes
         let mut flags = Flags::default();
 
         assert_eq!(size.value_string(&flags).as_str(), "42");
@@ -197,7 +188,7 @@ mod test {
 
     #[test]
     fn render_100_plus_kilobyte() {
-        let size = Size::new(420 * 1024 + 420); // 420.4 kilobytes
+        let size = Size::new(420 * KB + 420); // 420.4 kilobytes
         let mut flags = Flags::default();
 
         assert_eq!(size.value_string(&flags).as_str(), "420");
@@ -208,7 +199,7 @@ mod test {
 
     #[test]
     fn render_10_minus_megabyte() {
-        let size = Size::new(4 * 1024 * 1024); // 4 megabytes
+        let size = Size::new(4 * MB); // 4 megabytes
         let mut flags = Flags::default();
 
         assert_eq!(size.value_string(&flags).as_str(), "4.0");
@@ -219,7 +210,7 @@ mod test {
 
     #[test]
     fn render_megabyte() {
-        let size = Size::new(42 * 1024 * 1024); // 42 megabytes
+        let size = Size::new(42 * MB); // 42 megabytes
         let mut flags = Flags::default();
 
         assert_eq!(size.value_string(&flags).as_str(), "42");
@@ -230,7 +221,7 @@ mod test {
 
     #[test]
     fn render_100_plus_megabyte() {
-        let size = Size::new(420 * 1024 * 1024 + 420 * 1024); // 420.4 megabytes
+        let size = Size::new(420 * MB + 420 * KB); // 420.4 megabytes
         let mut flags = Flags::default();
 
         assert_eq!(size.value_string(&flags).as_str(), "420");
@@ -241,7 +232,7 @@ mod test {
 
     #[test]
     fn render_10_minus_gigabyte() {
-        let size = Size::new(4 * 1024 * 1024 * 1024); // 4 gigabytes
+        let size = Size::new(4 * GB); // 4 gigabytes
         let mut flags = Flags::default();
 
         assert_eq!(size.value_string(&flags).as_str(), "4.0");
@@ -252,7 +243,7 @@ mod test {
 
     #[test]
     fn render_gigabyte() {
-        let size = Size::new(42 * 1024 * 1024 * 1024); // 42 gigabytes
+        let size = Size::new(42 * GB); // 42 gigabytes
         let mut flags = Flags::default();
 
         assert_eq!(size.value_string(&flags).as_str(), "42");
@@ -263,7 +254,7 @@ mod test {
 
     #[test]
     fn render_100_plus_gigabyte() {
-        let size = Size::new(420 * 1024 * 1024 * 1024 + 420 * 1024 * 1024); // 420.4 gigabytes
+        let size = Size::new(420 * GB + 420 * MB); // 420.4 gigabytes
         let mut flags = Flags::default();
 
         assert_eq!(size.value_string(&flags).as_str(), "420");
@@ -274,7 +265,7 @@ mod test {
 
     #[test]
     fn render_10_minus_terabyte() {
-        let size = Size::new(4 * 1024 * 1024 * 1024 * 1024); // 4 terabytes
+        let size = Size::new(4 * TB); // 4 terabytes
         let mut flags = Flags::default();
 
         assert_eq!(size.value_string(&flags).as_str(), "4.0");
@@ -285,7 +276,7 @@ mod test {
 
     #[test]
     fn render_terabyte() {
-        let size = Size::new(42 * 1024 * 1024 * 1024 * 1024); // 42 terabytes
+        let size = Size::new(42 * TB); // 42 terabytes
         let mut flags = Flags::default();
 
         assert_eq!(size.value_string(&flags).as_str(), "42");
@@ -296,7 +287,7 @@ mod test {
 
     #[test]
     fn render_100_plus_terabyte() {
-        let size = Size::new(420 * 1024 * 1024 * 1024 * 1024 + 420 * 1024 * 1024 * 1024); // 420.4 terabytes
+        let size = Size::new(420 * TB + 420 * GB); // 420.4 terabytes
         let mut flags = Flags::default();
 
         assert_eq!(size.value_string(&flags).as_str(), "420");
@@ -307,7 +298,7 @@ mod test {
 
     #[test]
     fn render_with_a_fraction() {
-        let size = Size::new(42 * 1024 + 103); // 42.1 kilobytes
+        let size = Size::new(42 * KB + 103); // 42.1 kilobytes
         let flags = Flags::default();
 
         assert_eq!(size.value_string(&flags).as_str(), "42");
@@ -316,7 +307,7 @@ mod test {
 
     #[test]
     fn render_with_a_truncated_fraction() {
-        let size = Size::new(42 * 1024 + 1); // 42.001 kilobytes == 42 kilobytes
+        let size = Size::new(42 * KB + 1); // 42.001 kilobytes == 42 kilobytes
         let flags = Flags::default();
 
         assert_eq!(size.value_string(&flags).as_str(), "42");
@@ -325,7 +316,7 @@ mod test {
 
     #[test]
     fn render_short_nospaces() {
-        let size = Size::new(42 * 1024); // 42 kilobytes
+        let size = Size::new(42 * KB); // 42 kilobytes
         let mut flags = Flags::default();
         flags.size = SizeFlag::Short;
         let colors = Colors::new(ThemeOption::NoColor);