diff --git a/hw-excess.cabal b/hw-excess.cabal
--- a/hw-excess.cabal
+++ b/hw-excess.cabal
@@ -1,7 +1,7 @@
 cabal-version:        2.2
 
 name:                 hw-excess
-version:              0.2.1.0
+version:              0.2.2.0
 synopsis:             Excess
 description:          Please see README.md
 category:             Data, Succinct Data Structures, Data Structures
@@ -53,8 +53,13 @@
     HaskellWorks.Data.Excess.Internal.Partial.Table
     HaskellWorks.Data.Excess.Internal.Table
     HaskellWorks.Data.Excess.Internal.Triplet8
+    HaskellWorks.Data.Excess.MinExcess
+    HaskellWorks.Data.Excess.MinExcess0
+    HaskellWorks.Data.Excess.MinExcess1
     HaskellWorks.Data.Excess.MinMaxExcess0
     HaskellWorks.Data.Excess.MinMaxExcess1
+    HaskellWorks.Data.Excess.PartialMinExcess0
+    HaskellWorks.Data.Excess.PartialMinExcess1
     HaskellWorks.Data.Excess.PartialMinMaxExcess0
     HaskellWorks.Data.Excess.PartialMinMaxExcess1
     HaskellWorks.Data.Excess.Triplet
@@ -81,8 +86,14 @@
   autogen-modules:      Paths_hw_excess
   other-modules:
     HaskellWorks.Data.Excess.Internal.BranchlessSpec
+    HaskellWorks.Data.Excess.MinExcess0Spec
+    HaskellWorks.Data.Excess.MinExcess1Spec
     HaskellWorks.Data.Excess.MinMaxExcess0Spec
     HaskellWorks.Data.Excess.MinMaxExcess1Spec
+    HaskellWorks.Data.Excess.PartialMinExcess0Spec
+    HaskellWorks.Data.Excess.PartialMinExcess1Spec
+    HaskellWorks.Data.Excess.PartialMinMaxExcess0Spec
+    HaskellWorks.Data.Excess.PartialMinMaxExcess1Spec
     Paths_hw_excess
 
 benchmark bench
diff --git a/src/HaskellWorks/Data/Excess/MinExcess.hs b/src/HaskellWorks/Data/Excess/MinExcess.hs
new file mode 100644
--- /dev/null
+++ b/src/HaskellWorks/Data/Excess/MinExcess.hs
@@ -0,0 +1,25 @@
+{-# OPTIONS_GHC-funbox-strict-fields #-}
+
+module HaskellWorks.Data.Excess.MinExcess
+  ( MinExcess(..)
+  ) where
+
+import Control.Applicative (pure)
+import Foreign.Ptr         (castPtr)
+import Foreign.Storable    (Storable (..))
+
+data MinExcess = MinExcess
+  { minExcessMin :: !Int
+  , minExcessAll :: !Int
+  } deriving (Eq, Show)
+
+instance Storable MinExcess where
+  sizeOf _    = sizeOf (0 :: Int) * 3
+  alignment _ = alignment (0 :: Int)
+  peek p      = do let q = castPtr p
+                   a <- peek q
+                   b <- peekElemOff q 1
+                   pure (MinExcess a b)
+  poke p t    = do let q = castPtr p
+                   poke q (minExcessMin t)
+                   pokeElemOff q 1 (minExcessAll t)
diff --git a/src/HaskellWorks/Data/Excess/MinExcess0.hs b/src/HaskellWorks/Data/Excess/MinExcess0.hs
new file mode 100644
--- /dev/null
+++ b/src/HaskellWorks/Data/Excess/MinExcess0.hs
@@ -0,0 +1,111 @@
+{-# LANGUAGE FlexibleInstances #-}
+
+module HaskellWorks.Data.Excess.MinExcess0
+  ( MinExcess0(..)
+  ) where
+
+import Data.Word
+import HaskellWorks.Data.Bits.BitWise
+import HaskellWorks.Data.Bits.FixedBitSize
+import HaskellWorks.Data.Excess.Internal.Table
+import HaskellWorks.Data.Excess.MinExcess
+import HaskellWorks.Data.Naive
+
+import qualified Data.Vector.Storable                         as DVS
+import qualified HaskellWorks.Data.Excess.Internal.Branchless as BL
+
+class MinExcess0 a where
+  minExcess0 :: a -> MinExcess
+
+instance MinExcess0 [Bool] where
+  minExcess0 = go 0 0
+    where go minE allE (x:xs)                    = let ne = if x then allE - 1 else allE + 1 in
+                                                        go (BL.minInt minE ne) ne xs
+          go minE allE _                         = MinExcess minE allE
+  {-# INLINE minExcess0 #-}
+
+instance MinExcess0 (Naive Word8) where
+  minExcess0 = go 0 0 0 . naive
+    where go minE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE - 1 else allE + 1 in
+                                                        go (BL.minInt minE ne) ne (n + 1) w
+          go minE allE _ _                       = MinExcess minE allE
+  {-# INLINE minExcess0 #-}
+
+instance MinExcess0 (Naive Word16) where
+  minExcess0 = go 0 0 0 . naive
+    where go minE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE - 1 else allE + 1 in
+                                                        go (BL.minInt minE ne) ne (n + 1) w
+          go minE allE _ _                       = MinExcess minE allE
+  {-# INLINE minExcess0 #-}
+
+instance MinExcess0 (Naive Word32) where
+  minExcess0 = go 0 0 0 . naive
+    where go minE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE - 1 else allE + 1 in
+                                                        go (BL.minInt minE ne) ne (n + 1) w
+          go minE allE _ _                       = MinExcess minE allE
+  {-# INLINE minExcess0 #-}
+
+instance MinExcess0 (Naive Word64) where
+  minExcess0 = go 0 0 0 . naive
+    where go minE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE - 1 else allE + 1 in
+                                                        go (BL.minInt minE ne) ne (n + 1) w
+          go minE allE _ _                       = MinExcess minE allE
+  {-# INLINE minExcess0 #-}
+
+instance MinExcess0 Word8 where
+  minExcess0 w = MinExcess (DVS.unsafeIndex word8Excess0Min (fromIntegral w))
+                            (DVS.unsafeIndex word8Excess0    (fromIntegral w))
+  {-# INLINE minExcess0 #-}
+
+instance MinExcess0 Word16 where
+  minExcess0 w = MinExcess (BL.minInt minExcessA (minExcessB + allExcessA))
+                            (allExcessA + allExcessB)
+    where MinExcess minExcessA allExcessA = minExcess0 (fromIntegral  w        :: Word8)
+          MinExcess minExcessB allExcessB = minExcess0 (fromIntegral (w .>. 8) :: Word8)
+  {-# INLINE minExcess0 #-}
+
+instance MinExcess0 Word32 where
+  minExcess0 w = MinExcess (BL.minInt minExcessA (minExcessB + allExcessA))
+                            (allExcessA + allExcessB)
+    where MinExcess minExcessA allExcessA = minExcess0 (fromIntegral  w         :: Word16)
+          MinExcess minExcessB allExcessB = minExcess0 (fromIntegral (w .>. 16) :: Word16)
+  {-# INLINE minExcess0 #-}
+
+instance MinExcess0 Word64 where
+  minExcess0 w = MinExcess (BL.minInt minExcessA (minExcessB + allExcessA))
+                            (allExcessA + allExcessB)
+    where MinExcess minExcessA allExcessA = minExcess0 (fromIntegral  w         :: Word32)
+          MinExcess minExcessB allExcessB = minExcess0 (fromIntegral (w .>. 32) :: Word32)
+  {-# INLINE minExcess0 #-}
+
+instance MinExcess0 (DVS.Vector Word8) where
+  minExcess0 = DVS.foldl' gen (MinExcess 0 0)
+    where gen :: MinExcess -> Word8 -> MinExcess
+          gen (MinExcess minE allE) w  = let MinExcess wMinE wAllE = minExcess0 w  in
+                                            MinExcess (BL.minInt minE (wMinE + allE))
+                                                    (                wAllE + allE )
+  {-# INLINE minExcess0 #-}
+
+instance MinExcess0 (DVS.Vector Word16) where
+  minExcess0 = DVS.foldl' gen (MinExcess 0 0)
+    where gen :: MinExcess -> Word16 -> MinExcess
+          gen (MinExcess minE allE) w  = let MinExcess wMinE wAllE = minExcess0 w  in
+                                            MinExcess (BL.minInt minE (wMinE + allE))
+                                                    (                wAllE + allE )
+  {-# INLINE minExcess0 #-}
+
+instance MinExcess0 (DVS.Vector Word32) where
+  minExcess0 = DVS.foldl' gen (MinExcess 0 0)
+    where gen :: MinExcess -> Word32 -> MinExcess
+          gen (MinExcess minE allE) w  = let MinExcess wMinE wAllE = minExcess0 w  in
+                                            MinExcess (BL.minInt minE (wMinE + allE))
+                                                    (                wAllE + allE )
+  {-# INLINE minExcess0 #-}
+
+instance MinExcess0 (DVS.Vector Word64) where
+  minExcess0 = DVS.foldl' gen (MinExcess 0 0)
+    where gen :: MinExcess -> Word64 -> MinExcess
+          gen (MinExcess minE allE) w  = let MinExcess wMinE wAllE = minExcess0 w  in
+                                            MinExcess (BL.minInt minE (wMinE + allE))
+                                                    (                wAllE + allE )
+  {-# INLINE minExcess0 #-}
diff --git a/src/HaskellWorks/Data/Excess/MinExcess1.hs b/src/HaskellWorks/Data/Excess/MinExcess1.hs
new file mode 100644
--- /dev/null
+++ b/src/HaskellWorks/Data/Excess/MinExcess1.hs
@@ -0,0 +1,111 @@
+{-# LANGUAGE FlexibleInstances #-}
+
+module HaskellWorks.Data.Excess.MinExcess1
+  ( MinExcess1(..)
+  ) where
+
+import Data.Word
+import HaskellWorks.Data.Bits.BitWise
+import HaskellWorks.Data.Bits.FixedBitSize
+import HaskellWorks.Data.Excess.Internal.Table
+import HaskellWorks.Data.Excess.MinExcess
+import HaskellWorks.Data.Naive
+
+import qualified Data.Vector.Storable                         as DVS
+import qualified HaskellWorks.Data.Excess.Internal.Branchless as BL
+
+class MinExcess1 a where
+  minExcess1 :: a -> MinExcess
+
+instance MinExcess1 [Bool] where
+  minExcess1 = go 0 0
+    where go minE allE (x:xs)                    = let ne = if x then allE + 1 else allE - 1 in
+                                                        go (BL.minInt minE ne) ne xs
+          go minE allE _                         = MinExcess minE allE
+  {-# INLINE minExcess1 #-}
+
+instance MinExcess1 (Naive Word8) where
+  minExcess1 = go 0 0 0 . naive
+    where go minE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE + 1 else allE - 1 in
+                                                        go (BL.minInt minE ne) ne (n + 1) w
+          go minE allE _ _                       = MinExcess minE allE
+  {-# INLINE minExcess1 #-}
+
+instance MinExcess1 (Naive Word16) where
+  minExcess1 = go 0 0 0 . naive
+    where go minE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE + 1 else allE - 1 in
+                                                        go (BL.minInt minE ne) ne (n + 1) w
+          go minE allE _ _                       = MinExcess minE allE
+  {-# INLINE minExcess1 #-}
+
+instance MinExcess1 (Naive Word32) where
+  minExcess1 = go 0 0 0 . naive
+    where go minE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE + 1 else allE - 1 in
+                                                        go (BL.minInt minE ne) ne (n + 1) w
+          go minE allE _ _                       = MinExcess minE allE
+  {-# INLINE minExcess1 #-}
+
+instance MinExcess1 (Naive Word64) where
+  minExcess1 = go 0 0 0 . naive
+    where go minE allE n w | n < fixedBitSize w  = let ne = if w .?. fromIntegral n then allE + 1 else allE - 1 in
+                                                        go (BL.minInt minE ne) ne (n + 1) w
+          go minE allE _ _                       = MinExcess minE allE
+  {-# INLINE minExcess1 #-}
+
+instance MinExcess1 Word8 where
+  minExcess1 w = MinExcess (DVS.unsafeIndex word8Excess1Min  (fromIntegral w))
+                            (DVS.unsafeIndex word8Excess1     (fromIntegral w))
+  {-# INLINE minExcess1 #-}
+
+instance MinExcess1 Word16 where
+  minExcess1 w = MinExcess (BL.minInt minExcessA (minExcessB + allExcessA))
+                            (allExcessA + allExcessB)
+    where MinExcess minExcessA allExcessA = minExcess1 (fromIntegral  w        :: Word8)
+          MinExcess minExcessB allExcessB = minExcess1 (fromIntegral (w .>. 8) :: Word8)
+  {-# INLINE minExcess1 #-}
+
+instance MinExcess1 Word32 where
+  minExcess1 w = MinExcess (BL.minInt minExcessA (minExcessB + allExcessA))
+                            (allExcessA + allExcessB)
+    where MinExcess minExcessA allExcessA = minExcess1 (fromIntegral  w         :: Word16)
+          MinExcess minExcessB allExcessB = minExcess1 (fromIntegral (w .>. 16) :: Word16)
+  {-# INLINE minExcess1 #-}
+
+instance MinExcess1 Word64 where
+  minExcess1 w = MinExcess (BL.minInt minExcessA (minExcessB + allExcessA))
+                            (allExcessA + allExcessB)
+    where MinExcess minExcessA allExcessA = minExcess1 (fromIntegral  w         :: Word32)
+          MinExcess minExcessB allExcessB = minExcess1 (fromIntegral (w .>. 32) :: Word32)
+  {-# INLINE minExcess1 #-}
+
+instance MinExcess1 (DVS.Vector Word8) where
+  minExcess1 = DVS.foldl' gen (MinExcess 0 0)
+    where gen :: MinExcess -> Word8 -> MinExcess
+          gen (MinExcess minE allE) w  = let MinExcess wMinE wAllE = minExcess1 w  in
+                                            MinExcess (BL.minInt minE (wMinE + allE))
+                                                    (                wAllE + allE )
+  {-# INLINE minExcess1 #-}
+
+instance MinExcess1 (DVS.Vector Word16) where
+  minExcess1 = DVS.foldl' gen (MinExcess 0 0)
+    where gen :: MinExcess -> Word16 -> MinExcess
+          gen (MinExcess minE allE) w  = let MinExcess wMinE wAllE = minExcess1 w  in
+                                            MinExcess (BL.minInt minE (wMinE + allE))
+                                                    (                wAllE + allE )
+  {-# INLINE minExcess1 #-}
+
+instance MinExcess1 (DVS.Vector Word32) where
+  minExcess1 = DVS.foldl' gen (MinExcess 0 0)
+    where gen :: MinExcess -> Word32 -> MinExcess
+          gen (MinExcess minE allE) w  = let MinExcess wMinE wAllE = minExcess1 w  in
+                                            MinExcess (BL.minInt minE (wMinE + allE))
+                                                    (                wAllE + allE )
+  {-# INLINE minExcess1 #-}
+
+instance MinExcess1 (DVS.Vector Word64) where
+  minExcess1 = DVS.foldl' gen (MinExcess 0 0)
+    where gen :: MinExcess -> Word64 -> MinExcess
+          gen (MinExcess minE allE) w  = let MinExcess wMinE wAllE = minExcess1 w  in
+                                            MinExcess (BL.minInt minE (wMinE + allE))
+                                                    (                wAllE + allE )
+  {-# INLINE minExcess1 #-}
diff --git a/src/HaskellWorks/Data/Excess/PartialMinExcess0.hs b/src/HaskellWorks/Data/Excess/PartialMinExcess0.hs
new file mode 100644
--- /dev/null
+++ b/src/HaskellWorks/Data/Excess/PartialMinExcess0.hs
@@ -0,0 +1,44 @@
+module HaskellWorks.Data.Excess.PartialMinExcess0
+  ( PartialMinExcess0(..)
+  ) where
+
+import Data.Word
+import HaskellWorks.Data.Bits.BitWise
+import HaskellWorks.Data.Excess.MinExcess
+
+import qualified Data.Vector.Storable                            as DVS
+import qualified HaskellWorks.Data.Excess.Internal.Branchless    as BL
+import qualified HaskellWorks.Data.Excess.Internal.Partial.Table as T
+
+class PartialMinExcess0 a where
+  partialMinExcess0 :: Int -> a -> MinExcess
+
+instance PartialMinExcess0 Word8 where
+  partialMinExcess0 n w = MinExcess partialMinExcessMin partialMinExcessAll
+    where partialMinExcessMin = fromIntegral $ DVS.unsafeIndex T.tableWord8Excess0Lo (n * 256 + fromIntegral w)
+          partialMinExcessAll = fromIntegral $ DVS.unsafeIndex T.tableWord8Excess0Ex (n * 256 + fromIntegral w)
+  {-# INLINE partialMinExcess0 #-}
+
+instance PartialMinExcess0 Word16 where
+  partialMinExcess0 n w = MinExcess partialMinExcessMin partialMinExcessAll
+    where MinExcess aMin aAll = partialMinExcess0 8       (fromIntegral  w        :: Word8)
+          MinExcess bMin bAll = partialMinExcess0 (n - 8) (fromIntegral (w .>. 8) :: Word8)
+          partialMinExcessMin = if n <= 8 then aMin else BL.minInt aMin (aAll + bMin)
+          partialMinExcessAll = if n <= 8 then aAll else aAll + bAll
+  {-# INLINE partialMinExcess0 #-}
+
+instance PartialMinExcess0 Word32 where
+  partialMinExcess0 n w = MinExcess partialMinExcessMin partialMinExcessAll
+    where MinExcess aMin aAll = partialMinExcess0 16       (fromIntegral  w         :: Word16)
+          MinExcess bMin bAll = partialMinExcess0 (n - 16) (fromIntegral (w .>. 16) :: Word16)
+          partialMinExcessMin = if n <= 8 then aMin else BL.minInt aMin (aAll + bMin)
+          partialMinExcessAll = if n <= 8 then aAll else aAll + bAll
+  {-# INLINE partialMinExcess0 #-}
+
+instance PartialMinExcess0 Word64 where
+  partialMinExcess0 n w = MinExcess partialMinExcessMin partialMinExcessAll
+    where MinExcess aMin aAll = partialMinExcess0 32       (fromIntegral  w         :: Word32)
+          MinExcess bMin bAll = partialMinExcess0 (n - 32) (fromIntegral (w .>. 32) :: Word32)
+          partialMinExcessMin = if n <= 8 then aMin else BL.minInt aMin (aAll + bMin)
+          partialMinExcessAll = if n <= 8 then aAll else aAll + bAll
+  {-# INLINE partialMinExcess0 #-}
diff --git a/src/HaskellWorks/Data/Excess/PartialMinExcess1.hs b/src/HaskellWorks/Data/Excess/PartialMinExcess1.hs
new file mode 100644
--- /dev/null
+++ b/src/HaskellWorks/Data/Excess/PartialMinExcess1.hs
@@ -0,0 +1,44 @@
+module HaskellWorks.Data.Excess.PartialMinExcess1
+  ( PartialMinExcess1(..)
+  ) where
+
+import Data.Word
+import HaskellWorks.Data.Bits.BitWise
+import HaskellWorks.Data.Excess.MinExcess
+
+import qualified Data.Vector.Storable                            as DVS
+import qualified HaskellWorks.Data.Excess.Internal.Branchless    as BL
+import qualified HaskellWorks.Data.Excess.Internal.Partial.Table as T
+
+class PartialMinExcess1 a where
+  partialMinExcess1 :: Int -> a -> MinExcess
+
+instance PartialMinExcess1 Word8 where
+  partialMinExcess1 n w = MinExcess partialMinExcessMin partialMinExcessAll
+    where partialMinExcessMin = fromIntegral $ DVS.unsafeIndex T.tableWord8Excess1Lo (n * 256 + fromIntegral w)
+          partialMinExcessAll = fromIntegral $ DVS.unsafeIndex T.tableWord8Excess1Ex (n * 256 + fromIntegral w)
+  {-# INLINE partialMinExcess1 #-}
+
+instance PartialMinExcess1 Word16 where
+  partialMinExcess1 n w = MinExcess partialMinExcessMin partialMinExcessAll
+    where MinExcess aMin aAll = partialMinExcess1 8       (fromIntegral  w        :: Word8)
+          MinExcess bMin bAll = partialMinExcess1 (n - 8) (fromIntegral (w .>. 8) :: Word8)
+          partialMinExcessMin = if n <= 8 then aMin else BL.minInt aMin (aAll + bMin)
+          partialMinExcessAll = if n <= 8 then aAll else aAll + bAll
+  {-# INLINE partialMinExcess1 #-}
+
+instance PartialMinExcess1 Word32 where
+  partialMinExcess1 n w = MinExcess partialMinExcessMin partialMinExcessAll
+    where MinExcess aMin aAll = partialMinExcess1 16       (fromIntegral  w         :: Word16)
+          MinExcess bMin bAll = partialMinExcess1 (n - 16) (fromIntegral (w .>. 16) :: Word16)
+          partialMinExcessMin = if n <= 8 then aMin else BL.minInt aMin (aAll + bMin)
+          partialMinExcessAll = if n <= 8 then aAll else aAll + bAll
+  {-# INLINE partialMinExcess1 #-}
+
+instance PartialMinExcess1 Word64 where
+  partialMinExcess1 n w = MinExcess partialMinExcessMin partialMinExcessAll
+    where MinExcess aMin aAll = partialMinExcess1 32       (fromIntegral  w         :: Word32)
+          MinExcess bMin bAll = partialMinExcess1 (n - 32) (fromIntegral (w .>. 32) :: Word32)
+          partialMinExcessMin = if n <= 8 then aMin else BL.minInt aMin (aAll + bMin)
+          partialMinExcessAll = if n <= 8 then aAll else aAll + bAll
+  {-# INLINE partialMinExcess1 #-}
diff --git a/test/HaskellWorks/Data/Excess/MinExcess0Spec.hs b/test/HaskellWorks/Data/Excess/MinExcess0Spec.hs
new file mode 100644
--- /dev/null
+++ b/test/HaskellWorks/Data/Excess/MinExcess0Spec.hs
@@ -0,0 +1,122 @@
+{-# OPTIONS_GHC -fno-warn-incomplete-patterns #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+
+module HaskellWorks.Data.Excess.MinExcess0Spec (spec) where
+
+import HaskellWorks.Data.Bits.Word
+import HaskellWorks.Data.Excess.Internal.Triplet8 (Triplet8 (Triplet8))
+import HaskellWorks.Data.Excess.MinExcess
+import HaskellWorks.Data.Excess.MinExcess0
+import HaskellWorks.Data.Naive
+import HaskellWorks.Hspec.Hedgehog
+import Hedgehog
+import Test.Hspec
+
+import qualified Data.Vector.Storable                            as DVS
+import qualified HaskellWorks.Data.Excess.Internal.Partial.Table as T
+import qualified Hedgehog.Gen                                    as G
+import qualified Hedgehog.Range                                  as R
+
+{-# ANN module ("HLint: Ignore Redundant do" :: String) #-}
+{-# ANN module ("HLint: Ignore Reduce duplication"  :: String) #-}
+
+spec :: Spec
+spec = describe "HaskellWorks.Data.Excess.MinExcess0Spec" $ do
+  describe "For Word8" $ do
+    it "Excess should be between min excess and max excess" $ requireProperty $ do
+      w <- forAll $ G.word8 R.constantBounded
+      let MinExcess minE e = minExcess0 w
+      assert $ minE <= e
+    it "minE2 == minE0 `min` (minE1 + e0)" $ requireProperty $ do
+      w0 <- forAll $ G.word8 R.constantBounded
+      w1 <- forAll $ G.word8 R.constantBounded
+      let w2 = leConcat w0 w1
+      let MinExcess minE0 e0 = minExcess0 w0
+      let MinExcess minE1 _  = minExcess0 w1
+      let MinExcess minE2 _  = minExcess0 w2
+      minE2 === minE0 `min` (minE1 + e0)
+    it "minE2 == minE0 `min` (minE1 + e0) via vector" $ requireProperty $ do
+      w0 <- forAll $ G.word8 R.constantBounded
+      w1 <- forAll $ G.word8 R.constantBounded
+      let w2 = DVS.fromList [w0, w1]
+      let MinExcess minE0 e0 = minExcess0 w0
+      let MinExcess minE1 _  = minExcess0 w1
+      let MinExcess minE2 _  = minExcess0 w2
+      minE2 === minE0 `min` (minE1 + e0)
+  describe "For Word16" $ do
+    it "Excess should be between min excess and max excess" $ requireProperty $ do
+      w <- forAll $ G.word16 R.constantBounded
+      let MinExcess minE e = minExcess0 w
+      assert $ minE <= e
+    it "minE2 == minE0 `min` (minE1 + e0)" $ requireProperty $ do
+      w0 <- forAll $ G.word16 R.constantBounded
+      w1 <- forAll $ G.word16 R.constantBounded
+      let w2 = leConcat w0 w1
+      let MinExcess minE0 e0 = minExcess0 w0
+      let MinExcess minE1 _  = minExcess0 w1
+      let MinExcess minE2 _  = minExcess0 w2
+      minE2 === minE0 `min` (minE1 + e0)
+    it "minE2 == minE0 `min` (minE1 + e0) via vector" $ requireProperty $ do
+      w0 <- forAll $ G.word16 R.constantBounded
+      w1 <- forAll $ G.word16 R.constantBounded
+      let w2 = DVS.fromList [w0, w1]
+      let MinExcess minE0 e0 = minExcess0 w0
+      let MinExcess minE1 _  = minExcess0 w1
+      let MinExcess minE2 _  = minExcess0 w2
+      minE2 === minE0 `min` (minE1 + e0)
+    describe "For Word32" $ do
+      it "Excess should be between min excess and max excess" $ requireProperty $ do
+        w <- forAll $ G.word32 R.constantBounded
+        let MinExcess minE e = minExcess0 w
+        assert $ minE <= e
+      it "minE2 == minE0 `min` (minE1 + e0)" $ requireProperty $ do
+        w0 <- forAll $ G.word32 R.constantBounded
+        w1 <- forAll $ G.word32 R.constantBounded
+
+        let w2 = leConcat w0 w1
+        let MinExcess minE0 e0 = minExcess0 w0
+        let MinExcess minE1 _  = minExcess0 w1
+        let MinExcess minE2 _  = minExcess0 w2
+        minE2 === minE0 `min` (minE1 + e0)
+      it "minE2 == minE0 `min` (minE1 + e0) via vector" $ requireProperty $ do
+        w0 <- forAll $ G.word32 R.constantBounded
+        w1 <- forAll $ G.word32 R.constantBounded
+
+        let w2 = DVS.fromList [w0, w1]
+        let MinExcess minE0 e0 = minExcess0 w0
+        let MinExcess minE1 _  = minExcess0 w1
+        let MinExcess minE2 _  = minExcess0 w2
+        minE2 === minE0 `min` (minE1 + e0)
+  describe "For Word64" $ do
+    it "Excess should be between min excess and max excess" $ requireProperty $ do
+      w <- forAll $ G.word64 R.constantBounded
+      let MinExcess minE e = minExcess0 w
+      assert $ minE <= e
+    it "minE2 == minE0 `min` (minE1 + e0) via vector" $ requireProperty $ do
+      w0 <- forAll $ G.word64 R.constantBounded
+      w1 <- forAll $ G.word64 R.constantBounded
+      let w2 = DVS.fromList [w0, w1]
+      let MinExcess minE0 e0 = minExcess0 w0
+      let MinExcess minE1 _  = minExcess0 w1
+      let MinExcess minE2 _  = minExcess0 w2
+      minE2 === minE0 `min` (minE1 + e0)
+  describe "Equivalent to native implementation" $ do
+    it "For Word8" $ requireProperty $ do
+      w <- forAll $ G.word8 R.constantBounded
+      minExcess0 w === minExcess0 (Naive w)
+    it "For Word16" $ requireProperty $ do
+      w <- forAll $ G.word16 R.constantBounded
+      minExcess0 w === minExcess0 (Naive w)
+    it "For Word32" $ requireProperty $ do
+      w <- forAll $ G.word32 R.constantBounded
+      minExcess0 w === minExcess0 (Naive w)
+    it "For Word64" $ requireProperty $ do
+      w <- forAll $ G.word64 R.constantBounded
+      minExcess0 w === minExcess0 (Naive w)
+  describe "Equivalent to word8Excess0' implementation" $ do
+    it "For word8" $ requireProperty $ do
+      w <- forAll $ G.word8 R.constantBounded
+      let MinExcess lo0 ex0   = minExcess0          w
+      let Triplet8  lo1 ex1 _ = T.genWord8Excess0 8 w
+      lo0 === fromIntegral lo1
+      ex0 === fromIntegral ex1
diff --git a/test/HaskellWorks/Data/Excess/MinExcess1Spec.hs b/test/HaskellWorks/Data/Excess/MinExcess1Spec.hs
new file mode 100644
--- /dev/null
+++ b/test/HaskellWorks/Data/Excess/MinExcess1Spec.hs
@@ -0,0 +1,122 @@
+{-# OPTIONS_GHC -fno-warn-incomplete-patterns #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+
+module HaskellWorks.Data.Excess.MinExcess1Spec (spec) where
+
+import HaskellWorks.Data.Bits.Word
+import HaskellWorks.Data.Excess.Internal.Triplet8 (Triplet8 (Triplet8))
+import HaskellWorks.Data.Excess.MinExcess
+import HaskellWorks.Data.Excess.MinExcess1
+import HaskellWorks.Data.Naive
+import HaskellWorks.Hspec.Hedgehog
+import Hedgehog
+import Test.Hspec
+
+import qualified Data.Vector.Storable                            as DVS
+import qualified HaskellWorks.Data.Excess.Internal.Partial.Table as T
+import qualified Hedgehog.Gen                                    as G
+import qualified Hedgehog.Range                                  as R
+
+{-# ANN module ("HLint: Ignore Redundant do" :: String) #-}
+{-# ANN module ("HLint: Ignore Reduce duplication"  :: String) #-}
+
+spec :: Spec
+spec = describe "HaskellWorks.Data.Excess.MinExcess1Spec" $ do
+  describe "For Word8" $ do
+    it "Excess should be between min excess and max excess" $ requireProperty $ do
+      w <- forAll $ G.word8 R.constantBounded
+      let MinExcess minE e = minExcess1 w
+      assert $ minE <= e
+    it "minE2 == minE0 `min` (minE1 + e0)" $ requireProperty $ do
+      w0 <- forAll $ G.word8 R.constantBounded
+      w1 <- forAll $ G.word8 R.constantBounded
+
+      let w2 = leConcat w0 w1
+      let MinExcess minE0 e0 = minExcess1 w0
+      let MinExcess minE1 _  = minExcess1 w1
+      let MinExcess minE2 _  = minExcess1 w2
+      minE2 === minE0 `min` (minE1 + e0)
+    it "minE2 == minE0 `min` (minE1 + e0) via vector" $ requireProperty $ do
+      w0 <- forAll $ G.word8 R.constantBounded
+      w1 <- forAll $ G.word8 R.constantBounded
+
+      let w2 = DVS.fromList [w0, w1]
+      let MinExcess minE0 e0 = minExcess1 w0
+      let MinExcess minE1 _  = minExcess1 w1
+      let MinExcess minE2 _  = minExcess1 w2
+      minE2 === minE0 `min` (minE1 + e0)
+  describe "For Word16" $ do
+    it "Excess should be between min excess and max excess" $ requireProperty $ do
+      w <- forAll $ G.word16 R.constantBounded
+      let MinExcess minE e = minExcess1 w
+      assert $ minE <= e
+    it "minE2 == minE0 `min` (minE1 + e0)" $ requireProperty $ do
+      w0 <- forAll $ G.word16 R.constantBounded
+      w1 <- forAll $ G.word16 R.constantBounded
+      let w2 = leConcat w0 w1
+      let MinExcess minE0 e0 = minExcess1 w0
+      let MinExcess minE1 _  = minExcess1 w1
+      let MinExcess minE2 _  = minExcess1 w2
+      minE2 === minE0 `min` (minE1 + e0)
+    it "minE2 == minE0 `min` (minE1 + e0) via vector" $ requireProperty $ do
+      w0 <- forAll $ G.word16 R.constantBounded
+      w1 <- forAll $ G.word16 R.constantBounded
+      let w2 = DVS.fromList [w0, w1]
+      let MinExcess minE0 e0 = minExcess1 w0
+      let MinExcess minE1 _  = minExcess1 w1
+      let MinExcess minE2 _  = minExcess1 w2
+      minE2 === minE0 `min` (minE1 + e0)
+    describe "For Word32" $ do
+      it "Excess should be between min excess and max excess" $ requireProperty $ do
+        w <- forAll $ G.word32 R.constantBounded
+        let MinExcess minE e = minExcess1 w
+        assert $ minE <= e
+      it "minE2 == minE0 `min` (minE1 + e0)" $ requireProperty $ do
+        w0 <- forAll $ G.word32 R.constantBounded
+        w1 <- forAll $ G.word32 R.constantBounded
+        let w2 = leConcat w0 w1
+        let MinExcess minE0 e0 = minExcess1 w0
+        let MinExcess minE1 _  = minExcess1 w1
+        let MinExcess minE2 _  = minExcess1 w2
+        minE2 === minE0 `min` (minE1 + e0)
+      it "minE2 == minE0 `min` (minE1 + e0) via vector" $ requireProperty $ do
+        w0 <- forAll $ G.word32 R.constantBounded
+        w1 <- forAll $ G.word32 R.constantBounded
+        let w2 = DVS.fromList [w0, w1]
+        let MinExcess minE0 e0 = minExcess1 w0
+        let MinExcess minE1 _  = minExcess1 w1
+        let MinExcess minE2 _  = minExcess1 w2
+        minE2 === minE0 `min` (minE1 + e0)
+  describe "For Word64" $ do
+    it "Excess should be between min excess and max excess" $ requireProperty $ do
+      w <- forAll $ G.word64 R.constantBounded
+      let MinExcess minE e = minExcess1 w
+      assert $ minE <= e
+    it "minE2 == minE0 `min` (minE1 + e0) via vector" $ requireProperty $ do
+      w0 <- forAll $ G.word64 R.constantBounded
+      w1 <- forAll $ G.word64 R.constantBounded
+      let w2 = DVS.fromList [w0, w1]
+      let MinExcess minE0 e0 = minExcess1 w0
+      let MinExcess minE1 _  = minExcess1 w1
+      let MinExcess minE2 _  = minExcess1 w2
+      minE2 === minE0 `min` (minE1 + e0)
+  describe "Equivalent to native implementation" $ do
+    it "For Word8" $ requireProperty $ do
+      w <- forAll $ G.word8 R.constantBounded
+      minExcess1 w === minExcess1 (Naive w)
+    it "For Word16" $ requireProperty $ do
+      w <- forAll $ G.word16 R.constantBounded
+      minExcess1 w === minExcess1 (Naive w)
+    it "For Word32" $ requireProperty $ do
+      w <- forAll $ G.word32 R.constantBounded
+      minExcess1 w === minExcess1 (Naive w)
+    it "For Word64" $ requireProperty $ do
+      w <- forAll $ G.word64 R.constantBounded
+      minExcess1 w === minExcess1 (Naive w)
+  describe "Equivalent to word8Excess1' implementation" $ do
+    it "For word8" $ requireProperty $ do
+      w <- forAll $ G.word8 R.constantBounded
+      let MinExcess lo0 ex0   = minExcess1          w
+      let Triplet8  lo1 ex1 _ = T.genWord8Excess1 8 w
+      lo0 === fromIntegral lo1
+      ex0 === fromIntegral ex1
diff --git a/test/HaskellWorks/Data/Excess/MinMaxExcess0Spec.hs b/test/HaskellWorks/Data/Excess/MinMaxExcess0Spec.hs
--- a/test/HaskellWorks/Data/Excess/MinMaxExcess0Spec.hs
+++ b/test/HaskellWorks/Data/Excess/MinMaxExcess0Spec.hs
@@ -6,7 +6,6 @@
 import HaskellWorks.Data.Bits.Word
 import HaskellWorks.Data.Excess.Internal.Triplet8 (Triplet8 (Triplet8))
 import HaskellWorks.Data.Excess.MinMaxExcess0
-import HaskellWorks.Data.Excess.PartialMinMaxExcess0
 import HaskellWorks.Data.Excess.Triplet
 import HaskellWorks.Data.Naive
 import HaskellWorks.Hspec.Hedgehog
@@ -180,16 +179,3 @@
       lo0 === fromIntegral lo1
       ex0 === fromIntegral ex1
       hi0 === fromIntegral hi1
-  describe "Equivalent to partialMinMaxExcess1 implementation" $ do
-    it "For word8" $ requireProperty $ do
-      w <- forAll $ G.word8 R.constantBounded
-      minMaxExcess0 w === partialMinMaxExcess0 8 w
-    it "For word16" $ requireProperty $ do
-      w <- forAll $ G.word16 R.constantBounded
-      minMaxExcess0 w === partialMinMaxExcess0 16 w
-    it "For word32" $ requireProperty $ do
-      w <- forAll $ G.word32 R.constantBounded
-      minMaxExcess0 w === partialMinMaxExcess0 32 w
-    it "For word64" $ requireProperty $ do
-      w <- forAll $ G.word64 R.constantBounded
-      minMaxExcess0 w === partialMinMaxExcess0 64 w
diff --git a/test/HaskellWorks/Data/Excess/MinMaxExcess1Spec.hs b/test/HaskellWorks/Data/Excess/MinMaxExcess1Spec.hs
--- a/test/HaskellWorks/Data/Excess/MinMaxExcess1Spec.hs
+++ b/test/HaskellWorks/Data/Excess/MinMaxExcess1Spec.hs
@@ -6,7 +6,6 @@
 import HaskellWorks.Data.Bits.Word
 import HaskellWorks.Data.Excess.Internal.Triplet8 (Triplet8 (Triplet8))
 import HaskellWorks.Data.Excess.MinMaxExcess1
-import HaskellWorks.Data.Excess.PartialMinMaxExcess1
 import HaskellWorks.Data.Excess.Triplet
 import HaskellWorks.Data.Naive
 import HaskellWorks.Hspec.Hedgehog
@@ -180,16 +179,3 @@
       lo0 === fromIntegral lo1
       ex0 === fromIntegral ex1
       hi0 === fromIntegral hi1
-  describe "Equivalent to partialMinMaxExcess1 implementation" $ do
-    it "For word8" $ requireProperty $ do
-      w <- forAll $ G.word8 R.constantBounded
-      minMaxExcess1 w === partialMinMaxExcess1 8 w
-    it "For word16" $ requireProperty $ do
-      w <- forAll $ G.word16 R.constantBounded
-      minMaxExcess1 w === partialMinMaxExcess1 16 w
-    it "For word32" $ requireProperty $ do
-      w <- forAll $ G.word32 R.constantBounded
-      minMaxExcess1 w === partialMinMaxExcess1 32 w
-    it "For word64" $ requireProperty $ do
-      w <- forAll $ G.word64 R.constantBounded
-      minMaxExcess1 w === partialMinMaxExcess1 64 w
diff --git a/test/HaskellWorks/Data/Excess/PartialMinExcess0Spec.hs b/test/HaskellWorks/Data/Excess/PartialMinExcess0Spec.hs
new file mode 100644
--- /dev/null
+++ b/test/HaskellWorks/Data/Excess/PartialMinExcess0Spec.hs
@@ -0,0 +1,32 @@
+{-# OPTIONS_GHC -fno-warn-incomplete-patterns #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+
+module HaskellWorks.Data.Excess.PartialMinExcess0Spec (spec) where
+
+import HaskellWorks.Data.Excess.MinExcess0
+import HaskellWorks.Data.Excess.PartialMinExcess0
+import HaskellWorks.Hspec.Hedgehog
+import Hedgehog
+import Test.Hspec
+
+import qualified Hedgehog.Gen   as G
+import qualified Hedgehog.Range as R
+
+{-# ANN module ("HLint: Ignore Redundant do" :: String) #-}
+{-# ANN module ("HLint: Ignore Reduce duplication"  :: String) #-}
+
+spec :: Spec
+spec = describe "HaskellWorks.Data.Excess.PartialMinExcess0Spec" $ do
+  describe "Equivalent to partialMinExcess1 implementation" $ do
+    it "For word8" $ requireProperty $ do
+      w <- forAll $ G.word8 R.constantBounded
+      minExcess0 w === partialMinExcess0 8 w
+    it "For word16" $ requireProperty $ do
+      w <- forAll $ G.word16 R.constantBounded
+      minExcess0 w === partialMinExcess0 16 w
+    it "For word32" $ requireProperty $ do
+      w <- forAll $ G.word32 R.constantBounded
+      minExcess0 w === partialMinExcess0 32 w
+    it "For word64" $ requireProperty $ do
+      w <- forAll $ G.word64 R.constantBounded
+      minExcess0 w === partialMinExcess0 64 w
diff --git a/test/HaskellWorks/Data/Excess/PartialMinExcess1Spec.hs b/test/HaskellWorks/Data/Excess/PartialMinExcess1Spec.hs
new file mode 100644
--- /dev/null
+++ b/test/HaskellWorks/Data/Excess/PartialMinExcess1Spec.hs
@@ -0,0 +1,32 @@
+{-# OPTIONS_GHC -fno-warn-incomplete-patterns #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+
+module HaskellWorks.Data.Excess.PartialMinExcess1Spec (spec) where
+
+import HaskellWorks.Data.Excess.MinExcess1
+import HaskellWorks.Data.Excess.PartialMinExcess1
+import HaskellWorks.Hspec.Hedgehog
+import Hedgehog
+import Test.Hspec
+
+import qualified Hedgehog.Gen   as G
+import qualified Hedgehog.Range as R
+
+{-# ANN module ("HLint: Ignore Redundant do" :: String) #-}
+{-# ANN module ("HLint: Ignore Reduce duplication"  :: String) #-}
+
+spec :: Spec
+spec = describe "HaskellWorks.Data.Excess.PartialMinExcess1Spec" $ do
+  describe "Equivalent to partialMinExcess1 implementation" $ do
+    it "For word8" $ requireProperty $ do
+      w <- forAll $ G.word8 R.constantBounded
+      minExcess1 w === partialMinExcess1 8 w
+    it "For word16" $ requireProperty $ do
+      w <- forAll $ G.word16 R.constantBounded
+      minExcess1 w === partialMinExcess1 16 w
+    it "For word32" $ requireProperty $ do
+      w <- forAll $ G.word32 R.constantBounded
+      minExcess1 w === partialMinExcess1 32 w
+    it "For word64" $ requireProperty $ do
+      w <- forAll $ G.word64 R.constantBounded
+      minExcess1 w === partialMinExcess1 64 w
diff --git a/test/HaskellWorks/Data/Excess/PartialMinMaxExcess0Spec.hs b/test/HaskellWorks/Data/Excess/PartialMinMaxExcess0Spec.hs
new file mode 100644
--- /dev/null
+++ b/test/HaskellWorks/Data/Excess/PartialMinMaxExcess0Spec.hs
@@ -0,0 +1,32 @@
+{-# OPTIONS_GHC -fno-warn-incomplete-patterns #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+
+module HaskellWorks.Data.Excess.PartialMinMaxExcess0Spec (spec) where
+
+import HaskellWorks.Data.Excess.MinMaxExcess0
+import HaskellWorks.Data.Excess.PartialMinMaxExcess0
+import HaskellWorks.Hspec.Hedgehog
+import Hedgehog
+import Test.Hspec
+
+import qualified Hedgehog.Gen   as G
+import qualified Hedgehog.Range as R
+
+{-# ANN module ("HLint: Ignore Redundant do" :: String) #-}
+{-# ANN module ("HLint: Ignore Reduce duplication"  :: String) #-}
+
+spec :: Spec
+spec = describe "HaskellWorks.Data.Excess.PartialMinMaxExcess0Spec" $ do
+  describe "Equivalent to partialMinMaxExcess1 implementation" $ do
+    it "For word8" $ requireProperty $ do
+      w <- forAll $ G.word8 R.constantBounded
+      minMaxExcess0 w === partialMinMaxExcess0 8 w
+    it "For word16" $ requireProperty $ do
+      w <- forAll $ G.word16 R.constantBounded
+      minMaxExcess0 w === partialMinMaxExcess0 16 w
+    it "For word32" $ requireProperty $ do
+      w <- forAll $ G.word32 R.constantBounded
+      minMaxExcess0 w === partialMinMaxExcess0 32 w
+    it "For word64" $ requireProperty $ do
+      w <- forAll $ G.word64 R.constantBounded
+      minMaxExcess0 w === partialMinMaxExcess0 64 w
diff --git a/test/HaskellWorks/Data/Excess/PartialMinMaxExcess1Spec.hs b/test/HaskellWorks/Data/Excess/PartialMinMaxExcess1Spec.hs
new file mode 100644
--- /dev/null
+++ b/test/HaskellWorks/Data/Excess/PartialMinMaxExcess1Spec.hs
@@ -0,0 +1,32 @@
+{-# OPTIONS_GHC -fno-warn-incomplete-patterns #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+
+module HaskellWorks.Data.Excess.PartialMinMaxExcess1Spec (spec) where
+
+import HaskellWorks.Data.Excess.MinMaxExcess1
+import HaskellWorks.Data.Excess.PartialMinMaxExcess1
+import HaskellWorks.Hspec.Hedgehog
+import Hedgehog
+import Test.Hspec
+
+import qualified Hedgehog.Gen   as G
+import qualified Hedgehog.Range as R
+
+{-# ANN module ("HLint: Ignore Redundant do" :: String) #-}
+{-# ANN module ("HLint: Ignore Reduce duplication"  :: String) #-}
+
+spec :: Spec
+spec = describe "HaskellWorks.Data.Excess.PartialMinMaxExcess1Spec" $ do
+  describe "Equivalent to partialMinMaxExcess1 implementation" $ do
+    it "For word8" $ requireProperty $ do
+      w <- forAll $ G.word8 R.constantBounded
+      minMaxExcess1 w === partialMinMaxExcess1 8 w
+    it "For word16" $ requireProperty $ do
+      w <- forAll $ G.word16 R.constantBounded
+      minMaxExcess1 w === partialMinMaxExcess1 16 w
+    it "For word32" $ requireProperty $ do
+      w <- forAll $ G.word32 R.constantBounded
+      minMaxExcess1 w === partialMinMaxExcess1 32 w
+    it "For word64" $ requireProperty $ do
+      w <- forAll $ G.word64 R.constantBounded
+      minMaxExcess1 w === partialMinMaxExcess1 64 w