diff --git a/src/main.rs b/src/main.rs
index 54ac1a0..f42bbcf 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,8 +1,8 @@
-use std::{env, io, process};
-use std::fs::File;
-use std::io::{BufRead, BufReader, BufWriter, Lines};
 use arrayvec::{ArrayString, ArrayVec};
 use png::{BitDepth, ColorType, EncodingError};
+use std::fs::File;
+use std::io::{BufRead, BufReader, BufWriter, Lines};
+use std::{env, io, process};
 use thiserror::Error;
 
 mod nummap;
@@ -32,7 +32,7 @@ enum CifError {
     #[error("CIF image doesn't contain any pixels")]
     NoDataError,
     #[error("PNG error: {0}")]
-    PngError(EncodingError)
+    PngError(EncodingError),
 }
 
 #[allow(clippy::enum_glob_use)]
@@ -75,7 +75,7 @@ fn join_to_arraystring<const C: usize>(elems: &[&str], str: &mut ArrayString<C>)
 fn lines_read_noempty<T: BufRead>(lines: &mut Lines<T>) -> Result<Option<String>> {
     while let Some(s) = lines.next().transpose()? {
         if !s.is_empty() {
-            return Ok(Some(s))
+            return Ok(Some(s));
         }
     }
     Ok(None)
@@ -84,7 +84,8 @@ fn lines_read_noempty<T: BufRead>(lines: &mut Lines<T>) -> Result<Option<String>
 fn unfuck_cif_number(number: &str) -> Result<u32> {
     let mut buf = ArrayString::<2048>::new();
     // the split later will discard leading/trailing whitespace information, so we first check if it's there
-    if number.is_empty() || number.as_bytes()[0] == 32 || number.as_bytes()[number.len()-1] == 32 {
+    if number.is_empty() || number.as_bytes()[0] == 32 || number.as_bytes()[number.len() - 1] == 32
+    {
         return Err(GrammarError(number.to_string()));
     }
     let split = number.split_ascii_whitespace().collect::<ArrayVec<_, 64>>();
@@ -104,39 +105,48 @@ fn unfuck_cif_number(number: &str) -> Result<u32> {
             "tysięcy" | "tysiące" => {
                 if i > 0 {
                     join_to_arraystring(&split[..i], &mut buf)?;
-                    nummap::NUMMAP.get(&buf).ok_or_else(|| GrammarError(number.to_string()))?
+                    nummap::U16_NUMMAP
+                        .get(&buf)
+                        .ok_or_else(|| GrammarError(number.to_string()))?
                 } else {
                     return Err(GrammarError(number.to_string()));
                 }
             }
-            _ => return Err(GrammarError(number.to_string()))
+            _ => return Err(GrammarError(number.to_string())),
         };
         let remainder = if i + 1 < splitlen {
             buf.clear();
             join_to_arraystring(&split[i + 1..], &mut buf)?;
-            nummap::NUMMAP.get(&buf).ok_or_else(|| GrammarError(number.to_string()))?
+            nummap::U16_NUMMAP
+                .get(&buf)
+                .ok_or_else(|| GrammarError(number.to_string()))?
         } else {
             &0_u16
         };
         return Ok(u32::from(*thousands) * 1000 + u32::from(*remainder));
     }
-    Ok(u32::from(*nummap::NUMMAP.get(number).ok_or_else(|| GrammarError(number.to_string()))?))
+    Ok(u32::from(
+        *nummap::U16_NUMMAP
+            .get(number)
+            .ok_or_else(|| GrammarError(number.to_string()))?,
+    ))
 }
 
 fn unfuck_cif_number_fast(number: &str) -> Result<u8> {
-    if number.is_empty() || number.as_bytes()[0] == 32 || number.as_bytes()[number.len()-1] == 32 {
+    if number.is_empty() || number.as_bytes()[0] == 32 || number.as_bytes()[number.len() - 1] == 32
+    {
         return Err(GrammarError(number.to_string()));
     }
     let mut buf = ArrayString::<2048>::new();
-    let split = number.split_ascii_whitespace().take(8).collect::<ArrayVec<_, 8>>();
+    let split = number
+        .split_ascii_whitespace()
+        .take(8)
+        .collect::<ArrayVec<_, 8>>();
     join_to_arraystring(&split, &mut buf)?;
-    let number = *(nummap::NUMMAP.get(&buf).ok_or_else(|| GrammarError(number.to_string()))?);
-    if number < 256 {
-        #[allow(clippy::cast_possible_truncation)]
-        Ok(number as u8)
-    } else {
-        Err(OutOfRangeError(number.to_string(), number))
-    }
+    let number = *(nummap::U8_NUMMAP
+        .get(&buf)
+        .ok_or_else(|| GrammarError(number.to_string()))?);
+    Ok(number)
 }
 
 fn decoder(inputfile: &str, outputfile: &str) -> Result<()> {
@@ -145,41 +155,65 @@ fn decoder(inputfile: &str, outputfile: &str) -> Result<()> {
     let mut lines = BufReader::new(infile).lines();
     let rawriter = BufWriter::new(outfile);
 
-    if !lines.next().transpose()?.ok_or(InvalidHeaderError)?.starts_with("CIF:") {
-        return Err(InvalidHeaderError)
+    if !lines
+        .next()
+        .transpose()?
+        .ok_or(InvalidHeaderError)?
+        .starts_with("CIF:")
+    {
+        return Err(InvalidHeaderError);
     }
 
     let version_str = lines_read_noempty(&mut lines)?.ok_or(InvalidHeaderError)?;
-    let version_split = version_str.split_ascii_whitespace().take(2).collect::<ArrayVec<_, 2>>();
+    let version_split = version_str
+        .split_ascii_whitespace()
+        .take(2)
+        .collect::<ArrayVec<_, 2>>();
     if version_split.len() != 2 || version_split[0] != "WERSJA" || version_split[1] != "jeden" {
-        return Err(InvalidHeaderError)
+        return Err(InvalidHeaderError);
     }
 
     let size_string = lines_read_noempty(&mut lines)?.ok_or(InvalidHeaderError)?;
     if size_string.len() < 8 || !size_string.starts_with("ROZMIAR") {
-        return Err(InvalidSizeError(size_string))
+        return Err(InvalidSizeError(size_string));
     }
-    let size_split = (&size_string[7..]).split(',').take(3).collect::<ArrayVec<_, 3>>();
+    let size_split = (&size_string[7..])
+        .split(',')
+        .take(3)
+        .collect::<ArrayVec<_, 3>>();
     if size_split.len() != 3 {
-        return Err(InvalidSizeError(size_string.to_string()))
+        return Err(InvalidSizeError(size_string.to_string()));
     }
 
-    let width = unfuck_cif_number(size_split[0].trim_start().strip_prefix("szerokość:")
-        .ok_or_else(|| InvalidSizeError(size_string.to_string()))?.trim_start())?;
-    let height = unfuck_cif_number(size_split[1].trim_start().strip_prefix("wysokość:")
-        .ok_or_else(|| InvalidSizeError(size_string.to_string()))?.trim_start())?;
+    let width = unfuck_cif_number(
+        size_split[0]
+            .trim_start()
+            .strip_prefix("szerokość:")
+            .ok_or_else(|| InvalidSizeError(size_string.to_string()))?
+            .trim_start(),
+    )?;
+    let height = unfuck_cif_number(
+        size_split[1]
+            .trim_start()
+            .strip_prefix("wysokość:")
+            .ok_or_else(|| InvalidSizeError(size_string.to_string()))?
+            .trim_start(),
+    )?;
 
     let format = match unfuck_cif_number_fast(
-        size_split[2].trim_start().strip_prefix("bitów_na_piksel:")
-        .ok_or_else(|| InvalidSizeError(size_string.to_string()))?.trim_start()
+        size_split[2]
+            .trim_start()
+            .strip_prefix("bitów_na_piksel:")
+            .ok_or_else(|| InvalidSizeError(size_string.to_string()))?
+            .trim_start(),
     )? {
         24 => ColorType::Rgb,
         32 => ColorType::Rgba,
-        _ => return Err(InvalidSizeError(size_string.to_string()))
+        _ => return Err(InvalidSizeError(size_string.to_string())),
     };
 
     if width == 0 || height == 0 {
-        return Err(NoDataError)
+        return Err(NoDataError);
     }
 
     let mut outpng = png::Encoder::new(rawriter, width, height);
@@ -194,26 +228,26 @@ fn decoder(inputfile: &str, outputfile: &str) -> Result<()> {
                 let split = line.split_ascii_whitespace().collect::<ArrayVec<_, 256>>();
                 join_to_arraystring(&split, &mut buf)?;
                 let md_split = buf.splitn(3, ' ').collect::<ArrayVec<_, 3>>();
-                if md_split.len() != 3  {
-                    return Err(InvalidMetadataError(line.to_string()))
+                if md_split.len() != 3 {
+                    return Err(InvalidMetadataError(line.to_string()));
                 }
                 outpng.add_itxt_chunk(md_split[1].to_string(), md_split[2].to_string())?;
-                continue
+                continue;
             }
-            break line
+            break line;
         }
-        return Err(NoDataError)
+        return Err(NoDataError);
     };
 
     let mut outpng = outpng.write_header()?;
-    let bytes_per_pixel = if format == ColorType::Rgb {3} else {4};
+    let bytes_per_pixel = if format == ColorType::Rgb { 3 } else { 4 };
 
     let mut pixmap = Vec::with_capacity((bytes_per_pixel * width * height) as usize);
 
     if !first.is_empty() {
         let px_split = first.split(';').collect::<ArrayVec<_, 4>>();
         if px_split.len() != bytes_per_pixel as usize {
-            return Err(InvalidPixelError(first.to_string()))
+            return Err(InvalidPixelError(first.to_string()));
         }
         for px in px_split {
             pixmap.push(unfuck_cif_number_fast(px.trim_start())?);
@@ -223,7 +257,7 @@ fn decoder(inputfile: &str, outputfile: &str) -> Result<()> {
     while let Some(line) = lines_read_noempty(&mut lines)? {
         let px_split = line.split(';').collect::<ArrayVec<_, 4>>();
         if px_split.len() != bytes_per_pixel as usize {
-            return Err(InvalidPixelError(line.to_string()))
+            return Err(InvalidPixelError(line.to_string()));
         }
         for px in px_split {
             pixmap.push(unfuck_cif_number_fast(px.trim())?);
@@ -238,7 +272,9 @@ fn decoder(inputfile: &str, outputfile: &str) -> Result<()> {
 fn main() {
     let argv = env::args().skip(1).take(2).collect::<ArrayVec<_, 2>>();
     if argv.len() != 2 {
-        eprintln!("Invalid usage;\nUsage: zardzewialy-dekoder-cif <input cif file> <output bmp file>");
+        eprintln!(
+            "Invalid usage;\nUsage: zardzewialy-dekoder-cif <input cif file> <output bmp file>"
+        );
         process::exit(1);
     }
     if let Err(e) = decoder(&argv[0], &argv[1]) {
diff --git a/src/nummap.rs b/src/nummap.rs
index df006c1..fc14f80 100644
--- a/src/nummap.rs
+++ b/src/nummap.rs
@@ -1,6 +1,6 @@
 use phf::{phf_map, Map};
 
-pub static NUMMAP: Map<&'static str, u16> = phf_map! {
+pub static U16_NUMMAP: Map<&'static str, u16> = phf_map! {
     "zero" => 0,
     "jeden" => 1,
     "dwa" => 2,
@@ -1002,3 +1002,263 @@ pub static NUMMAP: Map<&'static str, u16> = phf_map! {
     "dziewięćset dziewięćdziesiąt osiem" => 998,
     "dziewięćset dziewięćdziesiąt dziewięć" => 999,
 };
+
+pub static U8_NUMMAP: Map<&'static str, u8> = phf_map! {
+    "zero" => 0,
+    "jeden" => 1,
+    "dwa" => 2,
+    "trzy" => 3,
+    "cztery" => 4,
+    "pięć" => 5,
+    "sześć" => 6,
+    "siedem" => 7,
+    "osiem" => 8,
+    "dziewięć" => 9,
+    "dziesięć" => 10,
+    "jedenaście" => 11,
+    "dwanaście" => 12,
+    "trzynaście" => 13,
+    "czternaście" => 14,
+    "piętnaście" => 15,
+    "szesnaście" => 16,
+    "siedemnaście" => 17,
+    "osiemnaście" => 18,
+    "dziewiętnaście" => 19,
+    "dwadzieścia" => 20,
+    "dwadzieścia jeden" => 21,
+    "dwadzieścia dwa" => 22,
+    "dwadzieścia trzy" => 23,
+    "dwadzieścia cztery" => 24,
+    "dwadzieścia pięć" => 25,
+    "dwadzieścia sześć" => 26,
+    "dwadzieścia siedem" => 27,
+    "dwadzieścia osiem" => 28,
+    "dwadzieścia dziewięć" => 29,
+    "trzydzieści" => 30,
+    "trzydzieści jeden" => 31,
+    "trzydzieści dwa" => 32,
+    "trzydzieści trzy" => 33,
+    "trzydzieści cztery" => 34,
+    "trzydzieści pięć" => 35,
+    "trzydzieści sześć" => 36,
+    "trzydzieści siedem" => 37,
+    "trzydzieści osiem" => 38,
+    "trzydzieści dziewięć" => 39,
+    "czterdzieści" => 40,
+    "czterdzieści jeden" => 41,
+    "czterdzieści dwa" => 42,
+    "czterdzieści trzy" => 43,
+    "czterdzieści cztery" => 44,
+    "czterdzieści pięć" => 45,
+    "czterdzieści sześć" => 46,
+    "czterdzieści siedem" => 47,
+    "czterdzieści osiem" => 48,
+    "czterdzieści dziewięć" => 49,
+    "pięćdziesiąt" => 50,
+    "pięćdziesiąt jeden" => 51,
+    "pięćdziesiąt dwa" => 52,
+    "pięćdziesiąt trzy" => 53,
+    "pięćdziesiąt cztery" => 54,
+    "pięćdziesiąt pięć" => 55,
+    "pięćdziesiąt sześć" => 56,
+    "pięćdziesiąt siedem" => 57,
+    "pięćdziesiąt osiem" => 58,
+    "pięćdziesiąt dziewięć" => 59,
+    "sześćdziesiąt" => 60,
+    "sześćdziesiąt jeden" => 61,
+    "sześćdziesiąt dwa" => 62,
+    "sześćdziesiąt trzy" => 63,
+    "sześćdziesiąt cztery" => 64,
+    "sześćdziesiąt pięć" => 65,
+    "sześćdziesiąt sześć" => 66,
+    "sześćdziesiąt siedem" => 67,
+    "sześćdziesiąt osiem" => 68,
+    "sześćdziesiąt dziewięć" => 69,
+    "siedemdziesiąt" => 70,
+    "siedemdziesiąt jeden" => 71,
+    "siedemdziesiąt dwa" => 72,
+    "siedemdziesiąt trzy" => 73,
+    "siedemdziesiąt cztery" => 74,
+    "siedemdziesiąt pięć" => 75,
+    "siedemdziesiąt sześć" => 76,
+    "siedemdziesiąt siedem" => 77,
+    "siedemdziesiąt osiem" => 78,
+    "siedemdziesiąt dziewięć" => 79,
+    "osiemdziesiąt" => 80,
+    "osiemdziesiąt jeden" => 81,
+    "osiemdziesiąt dwa" => 82,
+    "osiemdziesiąt trzy" => 83,
+    "osiemdziesiąt cztery" => 84,
+    "osiemdziesiąt pięć" => 85,
+    "osiemdziesiąt sześć" => 86,
+    "osiemdziesiąt siedem" => 87,
+    "osiemdziesiąt osiem" => 88,
+    "osiemdziesiąt dziewięć" => 89,
+    "dziewięćdziesiąt" => 90,
+    "dziewięćdziesiąt jeden" => 91,
+    "dziewięćdziesiąt dwa" => 92,
+    "dziewięćdziesiąt trzy" => 93,
+    "dziewięćdziesiąt cztery" => 94,
+    "dziewięćdziesiąt pięć" => 95,
+    "dziewięćdziesiąt sześć" => 96,
+    "dziewięćdziesiąt siedem" => 97,
+    "dziewięćdziesiąt osiem" => 98,
+    "dziewięćdziesiąt dziewięć" => 99,
+    "sto" => 100,
+    "sto jeden" => 101,
+    "sto dwa" => 102,
+    "sto trzy" => 103,
+    "sto cztery" => 104,
+    "sto pięć" => 105,
+    "sto sześć" => 106,
+    "sto siedem" => 107,
+    "sto osiem" => 108,
+    "sto dziewięć" => 109,
+    "sto dziesięć" => 110,
+    "sto jedenaście" => 111,
+    "sto dwanaście" => 112,
+    "sto trzynaście" => 113,
+    "sto czternaście" => 114,
+    "sto piętnaście" => 115,
+    "sto szesnaście" => 116,
+    "sto siedemnaście" => 117,
+    "sto osiemnaście" => 118,
+    "sto dziewiętnaście" => 119,
+    "sto dwadzieścia" => 120,
+    "sto dwadzieścia jeden" => 121,
+    "sto dwadzieścia dwa" => 122,
+    "sto dwadzieścia trzy" => 123,
+    "sto dwadzieścia cztery" => 124,
+    "sto dwadzieścia pięć" => 125,
+    "sto dwadzieścia sześć" => 126,
+    "sto dwadzieścia siedem" => 127,
+    "sto dwadzieścia osiem" => 128,
+    "sto dwadzieścia dziewięć" => 129,
+    "sto trzydzieści" => 130,
+    "sto trzydzieści jeden" => 131,
+    "sto trzydzieści dwa" => 132,
+    "sto trzydzieści trzy" => 133,
+    "sto trzydzieści cztery" => 134,
+    "sto trzydzieści pięć" => 135,
+    "sto trzydzieści sześć" => 136,
+    "sto trzydzieści siedem" => 137,
+    "sto trzydzieści osiem" => 138,
+    "sto trzydzieści dziewięć" => 139,
+    "sto czterdzieści" => 140,
+    "sto czterdzieści jeden" => 141,
+    "sto czterdzieści dwa" => 142,
+    "sto czterdzieści trzy" => 143,
+    "sto czterdzieści cztery" => 144,
+    "sto czterdzieści pięć" => 145,
+    "sto czterdzieści sześć" => 146,
+    "sto czterdzieści siedem" => 147,
+    "sto czterdzieści osiem" => 148,
+    "sto czterdzieści dziewięć" => 149,
+    "sto pięćdziesiąt" => 150,
+    "sto pięćdziesiąt jeden" => 151,
+    "sto pięćdziesiąt dwa" => 152,
+    "sto pięćdziesiąt trzy" => 153,
+    "sto pięćdziesiąt cztery" => 154,
+    "sto pięćdziesiąt pięć" => 155,
+    "sto pięćdziesiąt sześć" => 156,
+    "sto pięćdziesiąt siedem" => 157,
+    "sto pięćdziesiąt osiem" => 158,
+    "sto pięćdziesiąt dziewięć" => 159,
+    "sto sześćdziesiąt" => 160,
+    "sto sześćdziesiąt jeden" => 161,
+    "sto sześćdziesiąt dwa" => 162,
+    "sto sześćdziesiąt trzy" => 163,
+    "sto sześćdziesiąt cztery" => 164,
+    "sto sześćdziesiąt pięć" => 165,
+    "sto sześćdziesiąt sześć" => 166,
+    "sto sześćdziesiąt siedem" => 167,
+    "sto sześćdziesiąt osiem" => 168,
+    "sto sześćdziesiąt dziewięć" => 169,
+    "sto siedemdziesiąt" => 170,
+    "sto siedemdziesiąt jeden" => 171,
+    "sto siedemdziesiąt dwa" => 172,
+    "sto siedemdziesiąt trzy" => 173,
+    "sto siedemdziesiąt cztery" => 174,
+    "sto siedemdziesiąt pięć" => 175,
+    "sto siedemdziesiąt sześć" => 176,
+    "sto siedemdziesiąt siedem" => 177,
+    "sto siedemdziesiąt osiem" => 178,
+    "sto siedemdziesiąt dziewięć" => 179,
+    "sto osiemdziesiąt" => 180,
+    "sto osiemdziesiąt jeden" => 181,
+    "sto osiemdziesiąt dwa" => 182,
+    "sto osiemdziesiąt trzy" => 183,
+    "sto osiemdziesiąt cztery" => 184,
+    "sto osiemdziesiąt pięć" => 185,
+    "sto osiemdziesiąt sześć" => 186,
+    "sto osiemdziesiąt siedem" => 187,
+    "sto osiemdziesiąt osiem" => 188,
+    "sto osiemdziesiąt dziewięć" => 189,
+    "sto dziewięćdziesiąt" => 190,
+    "sto dziewięćdziesiąt jeden" => 191,
+    "sto dziewięćdziesiąt dwa" => 192,
+    "sto dziewięćdziesiąt trzy" => 193,
+    "sto dziewięćdziesiąt cztery" => 194,
+    "sto dziewięćdziesiąt pięć" => 195,
+    "sto dziewięćdziesiąt sześć" => 196,
+    "sto dziewięćdziesiąt siedem" => 197,
+    "sto dziewięćdziesiąt osiem" => 198,
+    "sto dziewięćdziesiąt dziewięć" => 199,
+    "dwieście" => 200,
+    "dwieście jeden" => 201,
+    "dwieście dwa" => 202,
+    "dwieście trzy" => 203,
+    "dwieście cztery" => 204,
+    "dwieście pięć" => 205,
+    "dwieście sześć" => 206,
+    "dwieście siedem" => 207,
+    "dwieście osiem" => 208,
+    "dwieście dziewięć" => 209,
+    "dwieście dziesięć" => 210,
+    "dwieście jedenaście" => 211,
+    "dwieście dwanaście" => 212,
+    "dwieście trzynaście" => 213,
+    "dwieście czternaście" => 214,
+    "dwieście piętnaście" => 215,
+    "dwieście szesnaście" => 216,
+    "dwieście siedemnaście" => 217,
+    "dwieście osiemnaście" => 218,
+    "dwieście dziewiętnaście" => 219,
+    "dwieście dwadzieścia" => 220,
+    "dwieście dwadzieścia jeden" => 221,
+    "dwieście dwadzieścia dwa" => 222,
+    "dwieście dwadzieścia trzy" => 223,
+    "dwieście dwadzieścia cztery" => 224,
+    "dwieście dwadzieścia pięć" => 225,
+    "dwieście dwadzieścia sześć" => 226,
+    "dwieście dwadzieścia siedem" => 227,
+    "dwieście dwadzieścia osiem" => 228,
+    "dwieście dwadzieścia dziewięć" => 229,
+    "dwieście trzydzieści" => 230,
+    "dwieście trzydzieści jeden" => 231,
+    "dwieście trzydzieści dwa" => 232,
+    "dwieście trzydzieści trzy" => 233,
+    "dwieście trzydzieści cztery" => 234,
+    "dwieście trzydzieści pięć" => 235,
+    "dwieście trzydzieści sześć" => 236,
+    "dwieście trzydzieści siedem" => 237,
+    "dwieście trzydzieści osiem" => 238,
+    "dwieście trzydzieści dziewięć" => 239,
+    "dwieście czterdzieści" => 240,
+    "dwieście czterdzieści jeden" => 241,
+    "dwieście czterdzieści dwa" => 242,
+    "dwieście czterdzieści trzy" => 243,
+    "dwieście czterdzieści cztery" => 244,
+    "dwieście czterdzieści pięć" => 245,
+    "dwieście czterdzieści sześć" => 246,
+    "dwieście czterdzieści siedem" => 247,
+    "dwieście czterdzieści osiem" => 248,
+    "dwieście czterdzieści dziewięć" => 249,
+    "dwieście pięćdziesiąt" => 250,
+    "dwieście pięćdziesiąt jeden" => 251,
+    "dwieście pięćdziesiąt dwa" => 252,
+    "dwieście pięćdziesiąt trzy" => 253,
+    "dwieście pięćdziesiąt cztery" => 254,
+    "dwieście pięćdziesiąt pięć" => 255,
+
+};