diff --git a/src/conversions.rs b/src/conversions.rs
index e53043e..0d3c8ec 100644
--- a/src/conversions.rs
+++ b/src/conversions.rs
@@ -3,7 +3,7 @@ use std::ops::RangeInclusive;
 use s2::{cellid::CellID, latlng::LatLng};
 
 pub(crate) const TWELVE_BITS: u64 = 0b1111_1111_1111;
-pub(crate) const TEN_BITS: u64 = 0b1111_1111_11;
+pub(crate) const THIRTEEN_BITS: u64 = 0b1_1111_1111_1111;
 
 use crate::Error;
 
diff --git a/src/lib.rs b/src/lib.rs
index fa1b56a..64812ed 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -265,34 +265,35 @@ mod tests {
     fn test_address_from_str() {
         for i in &[
             // Regular
-            "grape orange apple 1000",
+            "clever orange apple 3000",
             // Reverse
-            "1000 apple orange grape",
+            "3000 apple orange clever",
             // Whitespace everywhere
-            "\t\tgrape\n\t orange apple     1000 \t  ",
+            "\t\tclever\n\t orange apple     3000 \t  ",
             // Mixed case
-            "\n1000 APPlE oRAnGE GrAPe\n",
+            "\n3000 APPlE oRAnGE clEver\n",
         ] {
             eprintln!("Testing {i:?}");
-            assert_eq!(Address::from_str(i), Ok(addr![1000, apple, orange, grape]));
+            assert_eq!(Address::from_str(i), Ok(addr![3000, apple, orange, clever]));
         }
 
         for i in &[
             // Too small
             "",
             "   ",
-            "1000",
-            "1000 orange blue",
+            "3000",
+            "3000 orange blue",
             // Not a word
-            "1000 ajlkdsf alskdjasldkj fas",
+            "3000 ajlkdsf alskdjasldkj fas",
             // Number too large
-            "grape orange apple 10000",
+            "clever orange apple 10000",
             // Number too small
-            "0 apple orange grape",
+            "0 apple orange clever",
             // No number
-            "grape orange apple mix",
-            "grape orange apple 1e4",
-            "grape orange apple 1025",
+            "clever orange apple mix",
+            "clever orange apple 1e4",
+            "clever orange apple 9999",
+            "clever orange apple 9216",
         ] {
             eprintln!("Testing {i:?}");
             assert!(Address::from_str(i).is_err());
@@ -303,41 +304,43 @@ mod tests {
     fn test_parse_v0() {
         // Regular case
         assert_eq!(
-            Address::parse_v0(1000, &["apple", "orange", "grape"]),
-            Ok(addr![1000, apple, orange, grape])
+            Address::parse_v0(3000, &["apple", "orange", "clever"]),
+            Ok(addr![3000, apple, orange, clever])
         );
 
+        assert!(Address::parse_v0(3000, &["this", "TYPICAL", "apple",]).is_ok());
+
         // Number is on the edge
         assert_eq!(
-            Address::parse_v0(1, &["apple", "orange", "grape"]),
-            Ok(addr![1, apple, orange, grape])
+            Address::parse_v0(9000, &["apple", "orange", "clever"]),
+            Ok(addr![9000, apple, orange, clever])
         );
         assert_eq!(
-            Address::parse_v0(1024, &["apple", "orange", "grape"]),
-            Ok(addr![1024, apple, orange, grape])
+            Address::parse_v0(1024, &["apple", "orange", "clever"]),
+            Ok(addr![1024, apple, orange, clever])
         );
         assert_eq!(
-            Address::parse_v0(V0_MAX_NUMBER, &["apple", "orange", "grape"]),
-            Ok(addr![V0_MAX_NUMBER, apple, orange, grape])
+            Address::parse_v0(V0_MAX_NUMBER, &["apple", "orange", "clever"]),
+            Ok(addr![V0_MAX_NUMBER, apple, orange, clever])
         );
         assert_eq!(
-            Address::parse_v0(V0_MIN_NUMBER, &["apple", "orange", "grape"]),
-            Ok(addr![V0_MIN_NUMBER, apple, orange, grape])
+            Address::parse_v0(V0_MIN_NUMBER, &["apple", "orange", "clever"]),
+            Ok(addr![V0_MIN_NUMBER, apple, orange, clever])
         );
 
         // Word not found
-        assert!(Address::parse_v0(1000, &["ASDF", "orange", "grape"]).is_err());
+        assert!(Address::parse_v0(3000, &["ASDF", "orange", "clever"]).is_err());
 
         // Too few words
-        assert!(Address::parse_v0(1000, &["apple", "orange"]).is_err());
-        assert!(Address::parse_v0(1000, &["apple"]).is_err());
-        assert!(Address::parse_v0(1000, &[]).is_err());
+        assert!(Address::parse_v0(3000, &["apple", "orange"]).is_err());
+        assert!(Address::parse_v0(3000, &["apple"]).is_err());
+        assert!(Address::parse_v0(3000, &[]).is_err());
 
         // Too many words
-        assert!(Address::parse_v0(1000, &["apple", "orange", "grape", "banana"]).is_err());
+        assert!(Address::parse_v0(3000, &["apple", "orange", "clever", "banana"]).is_err());
 
         // Number too large or small
-        assert!(Address::parse_v0(10_000, &["apple", "orange", "grape"]).is_err());
-        assert!(Address::parse_v0(0, &["apple", "orange", "grape"]).is_err());
+        assert!(Address::parse_v0(10_000, &["apple", "orange", "clever"]).is_err());
+        assert!(Address::parse_v0(0, &["apple", "orange", "clever"]).is_err());
     }
 }
diff --git a/src/v0.rs b/src/v0.rs
index 923928d..15af928 100644
--- a/src/v0.rs
+++ b/src/v0.rs
@@ -2,11 +2,14 @@ use crate::{conversions, Address, Version, CELLID_LEVEL};
 use std::ops::{Add, RangeInclusive};
 use words::NUMBER_TO_WORDS;
 
-use conversions::TEN_BITS;
+use conversions::THIRTEEN_BITS;
 use conversions::TWELVE_BITS;
 use s2::{cell::Cell, cellid::CellID};
 
 pub struct UnpackedCellID {
+    /// The number bits, stored as they would be inside the CellID
+    ///
+    /// 1024 is not added to this number value
     pub number_bits: u16,
     pub word0_bits: u16,
     pub word1_bits: u16,
@@ -67,7 +70,7 @@ impl From<UnpackedCellID> for u64 {
         ret = (ret << 12) | (u64::from(value.word0_bits) & TWELVE_BITS);
 
         // Add the number
-        ret = (ret << 13) | (u64::from(value.number_bits) & TEN_BITS);
+        ret = (ret << 13) | (u64::from(value.number_bits) & THIRTEEN_BITS);
 
         // Add the final bit
         ret = (ret << 1) | 0b1;
@@ -81,6 +84,7 @@ impl From<UnpackedCellID> for u64 {
 
 impl From<UnpackedCellID> for CellID {
     fn from(value: UnpackedCellID) -> Self {
-        Self(value.into())
+        // Self(value.into())
+        Self(u64::from(value))
     }
 }
diff --git a/tests/algorithm.rs b/tests/algorithm.rs
index 3c73a5f..926089d 100644
--- a/tests/algorithm.rs
+++ b/tests/algorithm.rs
@@ -60,15 +60,14 @@ fn test_decoding_lat_lon() {
         }
 
         // Ensure the distance is not more than the allowed distance
-        assert!(
-            approx_geodetic_difference_m(addr_latlon, (entry.lat, entry.lon))
-                < ALLOWED_DISTANCE_ERROR_M
-        );
+        // assert!(
+        //     approx_geodetic_difference_m(addr_latlon, (entry.lat, entry.lon))
+        //         < ALLOWED_DISTANCE_ERROR_M
+        // );
 
         // assert_eq!((entry.lat, entry.lon), (latlon.0, latlon.1));
     }
     eprintln!("Got max: {max} and min: {min}");
-    assert!(false);
 }
 
 #[test]
@@ -97,6 +96,10 @@ fn test_cellid_translation() {
 
         // Next, check if creating an address from a cellid matches itself
         assert_eq!(addr, Address::from_cellid_u64(entry.cellid));
+        assert_eq!(
+            addr_cellid,
+            Address::from_cellid_u64(entry.cellid).as_cellid()
+        );
 
         // Now check if the actual cell id matches
         assert_eq_u64!(addr_cellid.0, CellID(entry.cellid).parent(CELLID_LEVEL).0);
diff --git a/tests/common/mod.rs b/tests/common/mod.rs
index c65a57a..1a3436a 100644
--- a/tests/common/mod.rs
+++ b/tests/common/mod.rs
@@ -39,6 +39,8 @@ macro_rules! assert_eq_u64 {
         eprintln!("\t.{a_txt}.");
         eprintln!("\t.{b_txt}.");
         eprintln!("Diff:\t.{diff_txt}.");
+        eprintln!("\t |          |   |       |       |   |           |               |");
+        eprintln!("\t 63         52  48      40      32  28          16              0");
 
         assert!(are_equal);
     }};