diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -100,3 +100,7 @@
 ## 0.1.0.24 -- 2022-12-08
 
 * Optimized parallel implementation for locate and count FM-index functions.
+
+## 0.1.0.25 -- 2022-12-09
+
+* Optimized FMIndexB and FMIndexT data types to include the SuffixArray of the respective input.
diff --git a/src/Data/FMIndex.hs b/src/Data/FMIndex.hs
--- a/src/Data/FMIndex.hs
+++ b/src/Data/FMIndex.hs
@@ -21,14 +21,6 @@
 -- To do this, users can use the 'bytestringToBWTToFMIndexB' and 'bytestringToBWTToFMIndexT' functions,
 -- as well as the 'textToBWTToFMIndexB' and 'textToBWTToFMIndexT' functions.
 --
--- The base functions for 'ByteString', 'bytestringToFMIndexB' and 'bytestringToFMIndexT' can be used to
--- convert a 'Seq' ('Maybe' 'ByteString') to a 'FMIndexB' and 'FMIndexT', respectively.
---
--- Likewise, the base functions for 'Text', 'textToFMIndexB' and 'textToFMIndexT' can be used to
--- convert a 'Seq' ('Maybe' 'Text') to a 'FMIndexB' and 'FMIndexT' respectively.
---
--- There are various other lower-level functions for interacting with the FMIndex implementation on 'ByteString' and 'Text' as well.
---
 -- = Operation: Count
 --
 -- The count operation is supported by both sequential, 'bytestringFMIndexCountS' and 'textFMIndexCountS'
@@ -60,11 +52,7 @@
                       textBWTToFMIndexB,
                       bytestringBWTToFMIndexB,
                       textBWTToFMIndexT,
-                      bytestringBWTToFMIndexT,
-                      textToFMIndexB,
-                      bytestringToFMIndexB,
-                      textToFMIndexT,
-                      bytestringToFMIndexT,
+                      bytestringBWTToFMIndexT,    
                       -- * From FMIndex functions
                       bytestringFromBWTFromFMIndexB,
                       bytestringFromBWTFromFMIndexT,
@@ -147,11 +135,16 @@
 textBWTToFMIndexB :: BWTMatrix Word8
                   -> TextBWT
                   -> FMIndexB
-textBWTToFMIndexB (BWTMatrix DS.Empty) _  = FMIndexB (CcB DS.Empty,OccCKB DS.Empty)
+textBWTToFMIndexB (BWTMatrix DS.Empty) _  = FMIndexB (CcB DS.Empty,OccCKB DS.Empty,SAB DS.Empty)
 textBWTToFMIndexB bwm                  xs = do
   let occckb = CMST.runST $ seqToOccCKB xss
   let ccb    = CMST.runST $ seqToCcB bwmff
-  FMIndexB (CcB ccb,OccCKB occckb)
+  let sab    = createSuffixArray     $
+               fmap (BSC8.singleton) $
+               DS.fromList           $
+               DText.unpack          $
+               textFromBWT xs
+  FMIndexB (CcB ccb,OccCKB occckb,SAB sab)
     where
       bwmf  = fmap (\x -> case viewl x of
                             EmptyL       -> Nothing
@@ -180,11 +173,16 @@
 bytestringBWTToFMIndexB :: BWTMatrix Word8
                         -> BWT Word8
                         -> FMIndexB
-bytestringBWTToFMIndexB (BWTMatrix DS.Empty) _  = FMIndexB (CcB DS.Empty,OccCKB DS.Empty) 
+bytestringBWTToFMIndexB (BWTMatrix DS.Empty) _  = FMIndexB (CcB DS.Empty,OccCKB DS.Empty,SAB DS.Empty) 
 bytestringBWTToFMIndexB bwm                  xs = do
   let occckb = CMST.runST $ seqToOccCKB xss
-  let ccb    = CMST.runST $ seqToCcB bwmff 
-  FMIndexB (CcB ccb,OccCKB occckb)
+  let ccb    = CMST.runST $ seqToCcB bwmff
+  let sab    = createSuffixArray   $
+               fmap (BS.singleton) $
+               DS.fromList         $
+               BS.unpack           $
+               bytestringFromWord8BWT xs
+  FMIndexB (CcB ccb,OccCKB occckb,SAB sab)
     where
       bwmf  = fmap (\x -> case viewl x of
                             EmptyL       -> Nothing
@@ -212,11 +210,16 @@
 textBWTToFMIndexT :: BWTMatrix Word8
                   -> TextBWT
                   -> FMIndexT
-textBWTToFMIndexT (BWTMatrix DS.Empty) _  = FMIndexT (CcT DS.Empty,OccCKT DS.Empty)
+textBWTToFMIndexT (BWTMatrix DS.Empty) _  = FMIndexT (CcT DS.Empty,OccCKT DS.Empty,SAT DS.Empty)
 textBWTToFMIndexT bwm                  xs = do
   let occckt = CMST.runST $ seqToOccCKT xss
   let cct    = CMST.runST $ seqToCcT bwmff
-  FMIndexT (CcT cct,OccCKT occckt)
+  let sat    = createSuffixArray      $
+               fmap (DText.singleton) $
+               DS.fromList            $
+               DText.unpack           $
+               textFromBWT xs 
+  FMIndexT (CcT cct,OccCKT occckt,SAT sat)
     where
       bwmf  = fmap (\x -> case viewl x of
                             EmptyL       -> Nothing
@@ -247,11 +250,17 @@
 bytestringBWTToFMIndexT :: BWTMatrix Word8
                         -> BWT Word8
                         -> FMIndexT
-bytestringBWTToFMIndexT (BWTMatrix DS.Empty) _  = FMIndexT (CcT DS.Empty,OccCKT DS.Empty)
+bytestringBWTToFMIndexT (BWTMatrix DS.Empty) _  = FMIndexT (CcT DS.Empty,OccCKT DS.Empty,SAT DS.Empty)
 bytestringBWTToFMIndexT bwm                  xs = do
   let occckt = CMST.runST $ seqToOccCKT xss
   let cct    = CMST.runST $ seqToCcT bwmff
-  FMIndexT (CcT cct,OccCKT occckt)
+  let sat    = createSuffixArray $
+               fmap (DText.singleton) $
+               DS.fromList            $
+               DText.unpack           $
+               DTE.decodeUtf8         $
+               bytestringFromWord8BWT xs
+  FMIndexT (CcT cct,OccCKT occckt,SAT sat)
     where
       bwmf  = fmap (\x -> case viewl x of
                             EmptyL       -> Nothing
@@ -276,104 +285,6 @@
                  )
             ((\(BWT t) -> t) xs)
 
--- | Takes a 'Text' and returns the FM-index ('FMIndexB').
-textToFMIndexB :: BWTMatrix Text
-               -> Seq (Maybe Text)
-               -> FMIndexB
-textToFMIndexB (BWTMatrix DS.Empty) _        = FMIndexB (CcB DS.Empty,OccCKB DS.Empty) 
-textToFMIndexB _                    DS.Empty = FMIndexB (CcB DS.Empty,OccCKB DS.Empty)
-textToFMIndexB bwm                  xs       = do
-  let occckb = CMST.runST $ seqToOccCKB xss
-  let ccb    = CMST.runST $ seqToCcB bwmff
-  FMIndexB (CcB ccb,OccCKB occckb)
-    where
-      bwmf  = fmap (\x -> case viewl x of
-                            EmptyL       -> Nothing
-                            (xh DS.:< _) -> xh
-                   ) $
-              (\(BWTMatrix m) -> m) bwm
-      bwmff = fmap (\x -> if | isNothing x
-                             -> Nothing
-                             | otherwise
-                             -> Just           $
-                                DTE.encodeUtf8 $
-                                fromJust x
-                   ) bwmf
-      xss   = fmap (\x -> if | isNothing x
-                             -> Nothing
-                             | otherwise
-                             -> Just           $
-                                DTE.encodeUtf8 $
-                                fromJust x
-                   )
-              xs
-
--- | Takes a 'Seq' of 'ByteString's and returns the FM-index ('FMIndexB').
-bytestringToFMIndexB :: BWTMatrix ByteString
-                     -> Seq (Maybe ByteString)
-                     -> FMIndexB
-bytestringToFMIndexB (BWTMatrix DS.Empty) _        = FMIndexB (CcB DS.Empty,OccCKB DS.Empty)
-bytestringToFMIndexB _                    DS.Empty = FMIndexB (CcB DS.Empty,OccCKB DS.Empty)
-bytestringToFMIndexB bwm                  xs       = do
-  let occckb = CMST.runST $ seqToOccCKB xs
-  let ccb    = CMST.runST $ seqToCcB bwmf
-  FMIndexB (CcB ccb,OccCKB occckb)
-    where
-      bwmf  = fmap (\x -> case viewl x of
-                            EmptyL       -> Nothing
-                            (xh DS.:< _) -> xh
-                   ) $
-              (\(BWTMatrix m) -> m) bwm
-
--- | Takes a 'Text' and returns the FM-index ('FMIndexT').
-textToFMIndexT :: BWTMatrix Text
-               -> Seq (Maybe Text)
-               -> FMIndexT
-textToFMIndexT (BWTMatrix DS.Empty) _        = FMIndexT (CcT DS.Empty,OccCKT DS.Empty)
-textToFMIndexT _                    DS.Empty = FMIndexT (CcT DS.Empty,OccCKT DS.Empty) 
-textToFMIndexT bwm                  xs       = do
-  let occckt = CMST.runST $ seqToOccCKT xs
-  let cct    = CMST.runST $ seqToCcT bwmf
-  FMIndexT (CcT cct,OccCKT occckt)
-    where
-      bwmf  = fmap (\x -> case viewl x of
-                            EmptyL       -> Nothing
-                            (xh DS.:< _) -> xh
-                   ) $
-              (\(BWTMatrix m) -> m) bwm
-
--- | Takes a 'ByteString' and returns the FM-index ('FMIndexT').
-bytestringToFMIndexT :: BWTMatrix ByteString
-                     -> Seq (Maybe ByteString)
-                     -> FMIndexT
-bytestringToFMIndexT (BWTMatrix DS.Empty) _        = FMIndexT (CcT DS.Empty,OccCKT DS.Empty) 
-bytestringToFMIndexT _                    DS.Empty = FMIndexT (CcT DS.Empty,OccCKT DS.Empty) 
-bytestringToFMIndexT bwm                  xs       = do
-  let occckt = CMST.runST $ seqToOccCKT xss
-  let cct    = CMST.runST $ seqToCcT bwmff
-  FMIndexT (CcT cct,OccCKT occckt)
-    where
-      bwmf  = fmap (\x -> case viewl x of
-                            EmptyL       -> Nothing
-                            (xh DS.:< _) -> xh
-                   ) $
-              (\(BWTMatrix m) -> m) bwm
-      bwmff = fmap (\x -> if | isNothing x
-                             -> Nothing
-                             | otherwise
-                             -> Just           $
-                                DTE.decodeUtf8 $ 
-                                fromJust x
-                   ) bwmf
-      xss = fmap (\x -> if | isNothing x
-                           -> Nothing
-                           | otherwise
-                           -> Just           $
-                              DTE.decodeUtf8 $
-                              fromJust x
-                 )
-            xs
-
 {-----------------------}
 
 
@@ -390,16 +301,16 @@
 bytestringFromBWTFromFMIndexT :: FMIndexT
                               -> ByteString
 bytestringFromBWTFromFMIndexT xs = bytestringFromByteStringBWT $
-                               BWT                         $
-                               fmap (\x -> if | isNothing x
-                                              -> Nothing
-                                              | otherwise
-                                              -> Just           $
-                                                 DTE.encodeUtf8 $
-                                                 fromJust x
-                                    )
+                                   BWT                             $
+                                   fmap (\x -> if | isNothing x
+                                                  -> Nothing
+                                                  | otherwise
+                                                  -> Just           $
+                                                     DTE.encodeUtf8 $
+                                                     fromJust x
+                                        )
                                                            $
-                            ((\(BWT t) -> t) (textBWTFromFMIndexT xs))
+                                   ((\(BWT t) -> t) (textBWTFromFMIndexT xs))
 
 -- | Helper function for converting a 'BWT'ed 'FMIndexB'
 -- back to the original 'Text'.
@@ -417,18 +328,20 @@
 -- the 'BWT' of 'Text's.
 textBWTFromFMIndexT :: FMIndexT
                     -> BWT Text
-textBWTFromFMIndexT (FMIndexT (CcT DS.Empty,_))    = BWT DS.Empty
-textBWTFromFMIndexT (FMIndexT (_,OccCKT DS.Empty)) = BWT DS.Empty
-textBWTFromFMIndexT xs                             =
+textBWTFromFMIndexT (FMIndexT (CcT DS.Empty,_,_))    = BWT DS.Empty
+textBWTFromFMIndexT (FMIndexT (_,OccCKT DS.Empty,_)) = BWT DS.Empty
+textBWTFromFMIndexT (FMIndexT (_,_,SAT DS.Empty))    = BWT DS.Empty
+textBWTFromFMIndexT xs                               =
   BWT (seqFromFMIndexT xs)
 
 -- | Takes a 'FMIndexT' and returns
 -- the 'BWT' of 'ByteString's.
 bytestringBWTFromFMIndexT :: FMIndexT
                           -> BWT ByteString
-bytestringBWTFromFMIndexT (FMIndexT (CcT DS.Empty,_))    = BWT DS.Empty
-bytestringBWTFromFMIndexT (FMIndexT (_,OccCKT DS.Empty)) = BWT DS.Empty 
-bytestringBWTFromFMIndexT xs                             = do
+bytestringBWTFromFMIndexT (FMIndexT (CcT DS.Empty,_,_))    = BWT DS.Empty
+bytestringBWTFromFMIndexT (FMIndexT (_,OccCKT DS.Empty,_)) = BWT DS.Empty
+bytestringBWTFromFMIndexT (FMIndexT (_,_,SAT DS.Empty))    = BWT DS.Empty
+bytestringBWTFromFMIndexT xs                               = do
   let originalbwtb = seqFromFMIndexT xs
   BWT (fmap (\x -> if | isNothing x
                       -> Nothing
@@ -442,9 +355,10 @@
 -- the 'BWT' of 'Text's.
 textBWTFromFMIndexB :: FMIndexB
                     -> BWT Text
-textBWTFromFMIndexB (FMIndexB (CcB DS.Empty,_))    = BWT DS.Empty
-textBWTFromFMIndexB (FMIndexB (_,OccCKB DS.Empty)) = BWT DS.Empty
-textBWTFromFMIndexB xs                             = do
+textBWTFromFMIndexB (FMIndexB (CcB DS.Empty,_,_))    = BWT DS.Empty
+textBWTFromFMIndexB (FMIndexB (_,OccCKB DS.Empty,_)) = BWT DS.Empty
+textBWTFromFMIndexB (FMIndexB (_,_,SAB DS.Empty))    = BWT DS.Empty
+textBWTFromFMIndexB xs                               = do
   let originalbwtt = seqFromFMIndexB xs
   BWT (fmap (\x -> if | isNothing x
                       -> Nothing
@@ -458,18 +372,20 @@
 -- the 'BWT' of 'ByteString's.
 bytestringBWTFromFMIndexB :: FMIndexB
                           -> BWT ByteString
-bytestringBWTFromFMIndexB (FMIndexB (CcB DS.Empty,_))    = BWT DS.Empty
-bytestringBWTFromFMIndexB (FMIndexB (_,OccCKB DS.Empty)) = BWT DS.Empty 
-bytestringBWTFromFMIndexB xs                             =
+bytestringBWTFromFMIndexB (FMIndexB (CcB DS.Empty,_,_))    = BWT DS.Empty
+bytestringBWTFromFMIndexB (FMIndexB (_,OccCKB DS.Empty,_)) = BWT DS.Empty
+bytestringBWTFromFMIndexB (FMIndexB (_,_,SAB DS.Empty))    = BWT DS.Empty
+bytestringBWTFromFMIndexB xs                               =
   BWT (seqFromFMIndexB xs)
 
 -- | Takes a 'FMIndexB' and returns
 -- the original 'Seq' of 'Text's.
 textFromFMIndexB :: FMIndexB
                  -> Seq (Maybe Text)
-textFromFMIndexB (FMIndexB (CcB DS.Empty,_))    = DS.Empty
-textFromFMIndexB (FMIndexB (_,OccCKB DS.Empty)) = DS.Empty
-textFromFMIndexB xs                             = do
+textFromFMIndexB (FMIndexB (CcB DS.Empty,_,_))    = DS.Empty
+textFromFMIndexB (FMIndexB (_,OccCKB DS.Empty,_)) = DS.Empty
+textFromFMIndexB (FMIndexB (_,_,SAB DS.Empty))    = DS.Empty
+textFromFMIndexB xs                               = do
   let originalt = seqFromFMIndexB xs
   fmap (\x -> if | isNothing x
                  -> Nothing
@@ -483,27 +399,30 @@
 -- the original 'Seq' of 'ByteString's.
 bytestringFromFMIndexB :: FMIndexB
                        -> Seq (Maybe ByteString)
-bytestringFromFMIndexB (FMIndexB (CcB DS.Empty,_))    = DS.Empty
-bytestringFromFMIndexB (FMIndexB (_,OccCKB DS.Empty)) = DS.Empty 
-bytestringFromFMIndexB xs                             =
+bytestringFromFMIndexB (FMIndexB (CcB DS.Empty,_,_))    = DS.Empty
+bytestringFromFMIndexB (FMIndexB (_,OccCKB DS.Empty,_)) = DS.Empty
+bytestringFromFMIndexB (FMIndexB (_,_,SAB DS.Empty))    = DS.Empty
+bytestringFromFMIndexB xs                               =
   seqFromFMIndexB xs
 
 -- | Takes a 'FMIndexT' and returns
 -- the original 'Seq' of 'Text's.
 textFromFMIndexT :: FMIndexT
                  -> Seq (Maybe Text)
-textFromFMIndexT (FMIndexT (CcT DS.Empty,_))    = DS.Empty
-textFromFMIndexT (FMIndexT (_,OccCKT DS.Empty)) = DS.Empty
-textFromFMIndexT xs                             =
+textFromFMIndexT (FMIndexT (CcT DS.Empty,_,_))    = DS.Empty
+textFromFMIndexT (FMIndexT (_,OccCKT DS.Empty,_)) = DS.Empty
+textFromFMIndexT (FMIndexT (_,_,SAT DS.Empty))    = DS.Empty
+textFromFMIndexT xs                               =
   seqFromFMIndexT xs
 
 -- | Takes a 'FMIndexT' and returns
 -- the original 'Seq' of 'ByteString's.
 bytestringFromFMIndexT :: FMIndexT
                        -> Seq (Maybe ByteString)
-bytestringFromFMIndexT (FMIndexT (CcT DS.Empty,_))    = DS.Empty
-bytestringFromFMIndexT (FMIndexT (_,OccCKT DS.Empty)) = DS.Empty
-bytestringFromFMIndexT xs                             = do
+bytestringFromFMIndexT (FMIndexT (CcT DS.Empty,_,_))    = DS.Empty
+bytestringFromFMIndexT (FMIndexT (_,OccCKT DS.Empty,_)) = DS.Empty
+bytestringFromFMIndexT (FMIndexT (_,_,SAT DS.Empty))    = DS.Empty
+bytestringFromFMIndexT xs                               = do
   let originalb = seqFromFMIndexT xs
   fmap (\x -> if | isNothing x
                  -> Nothing
@@ -580,7 +499,9 @@
   numcores <- CC.getNumCapabilities
   let chunksize = (P.length allpats) `div` numcores
   let bfmindex  = bytestringToBWTToFMIndexB input
-  let bcount    = (iBFMC allpats bfmindex) `CPS.using` (CPS.parListChunk chunksize CPS.rseq)
+  let bcount    = (iBFMC allpats bfmindex)
+                  `CPS.using`
+                  (CPS.parListChunk chunksize CPS.rseq)
   return $ DS.fromList bcount
     where
       iBFMC []                      _    = []
@@ -608,7 +529,9 @@
   numcores <- CC.getNumCapabilities 
   let chunksize = (P.length allpats) `div` numcores
   let tfmindex  = textToBWTToFMIndexT input
-  let tcount    = (iTFMC allpats tfmindex) `CPS.using` (CPS.parListChunk chunksize CPS.rseq)
+  let tcount    = (iTFMC allpats tfmindex)
+                  `CPS.using`
+                  (CPS.parListChunk chunksize CPS.rseq)
   return $ DS.fromList tcount
     where
       iTFMC []                      _    = []
@@ -637,11 +560,10 @@
 bytestringFMIndexLocateS []      _                        = DS.Empty
 bytestringFMIndexLocateS _       (BSC8.uncons -> Nothing) = DS.Empty
 bytestringFMIndexLocateS allpats input                    = do
-  let bytestringsa = createSuffixArray   $
-                     fmap (BS.singleton) $
-                     DS.fromList         $ 
-                     BS.unpack input
   let bfmindex     = bytestringToBWTToFMIndexB input
+  let bytestringsa = (\(SAB t) -> t) $
+                     (\(_,_,c) -> c) $
+                     (\(FMIndexB t) -> t) bfmindex
   iBFML allpats
         bytestringsa
         bfmindex
@@ -674,11 +596,10 @@
 textFMIndexLocateS []      _     = DS.Empty
 textFMIndexLocateS _       ""    = DS.Empty
 textFMIndexLocateS allpats input = do
-  let textsa      = createSuffixArray      $
-                    fmap (DText.singleton) $
-                    DS.fromList            $
-                    DText.unpack input
   let tfmindex    = textToBWTToFMIndexT input
+  let textsa      = (\(SAT t) -> t) $
+                    (\(_,_,c) -> c) $
+                    (\(FMIndexT t) -> t) tfmindex
   iTFML allpats
         textsa
         tfmindex
@@ -716,12 +637,13 @@
 bytestringFMIndexLocateP allpats input                    = do
   numcores <- CC.getNumCapabilities
   let chunksize    = (P.length allpats) `div` numcores
-  let bytestringsa = createSuffixArray   $
-                     fmap (BS.singleton) $
-                     DS.fromList         $ 
-                     BS.unpack input
   let bfmindex     = bytestringToBWTToFMIndexB input
-  let blocate      = (iBFML allpats bytestringsa bfmindex) `CPS.using` (CPS.parListChunk chunksize CPS.rseq)
+  let bytestringsa = (\(SAB t) -> t) $
+                     (\(_,_,c) -> c) $
+                     (\(FMIndexB t) -> t) bfmindex
+  let blocate      = (iBFML allpats bytestringsa bfmindex)
+                     `CPS.using`
+                     (CPS.parListChunk chunksize CPS.rseq)
   return $ DS.fromList blocate
     where
       iBFML []                      _   _    = []
@@ -757,12 +679,13 @@
 textFMIndexLocateP allpats input = do
   numcores <- CC.getNumCapabilities
   let chunksize = (P.length allpats) `div` numcores
-  let textsa    = createSuffixArray      $
-                  fmap (DText.singleton) $
-                  DS.fromList            $
-                  DText.unpack input
   let tfmindex  = textToBWTToFMIndexT input
-  let tlocate   = (iTFML allpats textsa tfmindex) `CPS.using` (CPS.parListChunk chunksize CPS.rseq)
+  let textsa    = (\(SAT t) -> t) $
+                  (\(_,_,c) -> c) $
+                  (\(FMIndexT t) -> t) tfmindex
+  let tlocate   = (iTFML allpats textsa tfmindex)
+                  `CPS.using`
+                  (CPS.parListChunk chunksize CPS.rseq)
   return $ DS.fromList tlocate
     where
       iTFML []                      _   _    = []
diff --git a/src/Data/FMIndex/Internal.hs b/src/Data/FMIndex/Internal.hs
--- a/src/Data/FMIndex/Internal.hs
+++ b/src/Data/FMIndex/Internal.hs
@@ -125,6 +125,8 @@
                                CcT(..),
                                CB(..),
                                CT(..),
+                               SAB(..),
+                               SAT(..),
                                -- * To OccCK (ByteString) functions
                                PBOccCKSeqB,
                                OccCKSeqB,
@@ -251,7 +253,7 @@
                                locateFMIndexT
                              ) where
 
-import Data.BWT.Internal()
+import Data.BWT.Internal (SuffixArray)
 import Data.MTF.Internal
 
 import Control.Monad as CM
@@ -274,11 +276,11 @@
 {-Base level types.-}
 
 -- | Basic FMIndex ('ByteString') data type.
-newtype FMIndexB = FMIndexB (CcB,OccCKB)
+newtype FMIndexB = FMIndexB (CcB,OccCKB,SAB)
   deriving (Eq,Ord,Show,Read,Generic)
 
 -- | Basic FMIndex ('Text') data type.
-newtype FMIndexT = FMIndexT (CcT,OccCKT)
+newtype FMIndexT = FMIndexT (CcT,OccCKT,SAT)
   deriving (Eq,Ord,Show,Read,Generic)
 
 -- | Basic OccCKB ('ByteString') data type.
@@ -305,6 +307,14 @@
 newtype CT = CT (Maybe Int)
   deriving (Eq,Ord,Show,Read,Generic)
 
+-- | Basic 'SuffixArray' ('ByteString') data type.
+newtype SAB = SAB (SuffixArray ByteString)
+  deriving (Eq,Ord,Show,Read,Generic)
+
+-- | Basic 'SuffixArray' ('Text') data type.
+newtype SAT = SAT (SuffixArray Text)
+  deriving (Eq,Ord,Show,Read,Generic)
+
 {-------------------}
 
 
@@ -786,15 +796,16 @@
 -- | Simple Inverse FMIndex function. 
 seqFromFMIndexB :: FMIndexB
                 -> FFMIndexSeqB
-seqFromFMIndexB (FMIndexB (CcB DS.Empty,_))    = DS.Empty
-seqFromFMIndexB (FMIndexB (_,OccCKB DS.Empty)) = DS.Empty
-seqFromFMIndexB xs                             = do
+seqFromFMIndexB (FMIndexB (CcB DS.Empty,_,_))    = DS.Empty
+seqFromFMIndexB (FMIndexB (_,OccCKB DS.Empty,_)) = DS.Empty
+seqFromFMIndexB (FMIndexB (_,_,SAB DS.Empty))    = DS.Empty
+seqFromFMIndexB xs                               = do
   let xss = (\(OccCKB b) -> b) $
-            (\(_,b) -> b)      $
+            (\(_,b,_) -> b)    $
             (\(FMIndexB b) -> b) xs
   iFFMIndexB xss
     where
-      iFFMIndexB DS.Empty         = DS.Empty 
+      iFFMIndexB DS.Empty         = DS.Empty
       iFFMIndexB ((_,b) DS.:<| _) =
         fmap (\(_,_,e) -> e) b
 
@@ -809,11 +820,12 @@
 -- | Simple Inverse FMIndex function.
 seqFromFMIndexT :: FMIndexT
                 -> FFMIndexSeqT
-seqFromFMIndexT (FMIndexT (CcT DS.Empty,_))    = DS.Empty
-seqFromFMIndexT (FMIndexT (_,OccCKT DS.Empty)) = DS.Empty
-seqFromFMIndexT xs                             = do
+seqFromFMIndexT (FMIndexT (CcT DS.Empty,_,_))    = DS.Empty
+seqFromFMIndexT (FMIndexT (_,OccCKT DS.Empty,_)) = DS.Empty
+seqFromFMIndexT (FMIndexT (_,_,SAT DS.Empty))    = DS.Empty
+seqFromFMIndexT xs                               = do
   let xss = (\(OccCKT t) -> t) $
-            (\(_,b) -> b)      $
+            (\(_,b,_) -> b)    $
             (\(FMIndexT t) -> t) xs
   iFFMIndexT xss
     where
@@ -891,10 +903,11 @@
 countFMIndexB :: PBCPat
               -> FMIndexB
               -> ST s CIntB 
-countFMIndexB DS.Empty _                              = return Nothing
-countFMIndexB _        (FMIndexB (CcB DS.Empty,_))    = return Nothing
-countFMIndexB _        (FMIndexB (_,OccCKB DS.Empty)) = return Nothing
-countFMIndexB xs       ys                             = do
+countFMIndexB DS.Empty _                                = return Nothing
+countFMIndexB _        (FMIndexB (CcB DS.Empty,_,_))    = return Nothing
+countFMIndexB _        (FMIndexB (_,OccCKB DS.Empty,_)) = return Nothing
+countFMIndexB _        (FMIndexB (_,_,SAB DS.Empty))    = return Nothing
+countFMIndexB xs       ys                               = do
   bccounter      <- emptySTCCounterB
   bcbool         <- emptySTCBoolB
   bccurrentstart <- emptySTCCurrentStartB
@@ -919,10 +932,10 @@
       iCB DS.Empty      _  _   _   _    _    = pure ()
       iCB (as DS.:|> a) bs bcc bcb bccs bcce = do
         let ccbbs = (\(CcB b) -> b) $
-                    (\(a,_) -> a)   $
+                    (\(a,_,_) -> a) $
                     (\(FMIndexB b) -> b) bs
         let coccckbs = (\(OccCKB b) -> b) $
-                       (\(_,b) -> b)      $
+                       (\(_,b,_) -> b)    $
                        (\(FMIndexB b) -> b) bs
         cbcc <- readSTRef bcc
         cbccs <- readSTRef bccs
@@ -1061,10 +1074,11 @@
 countFMIndexT :: PTCPat
               -> FMIndexT
               -> ST s CIntT
-countFMIndexT DS.Empty _                              = return Nothing
-countFMIndexT _        (FMIndexT (CcT DS.Empty,_))    = return Nothing
-countFMIndexT _        (FMIndexT (_,OccCKT DS.Empty)) = return Nothing
-countFMIndexT xs       ys                             = do
+countFMIndexT DS.Empty _                                = return Nothing
+countFMIndexT _        (FMIndexT (CcT DS.Empty,_,_))    = return Nothing
+countFMIndexT _        (FMIndexT (_,OccCKT DS.Empty,_)) = return Nothing
+countFMIndexT _        (FMIndexT (_,_,SAT DS.Empty))    = return Nothing
+countFMIndexT xs       ys                               = do
   tccounter      <- emptySTCCounterT
   tcbool         <- emptySTCBoolT
   tccurrentstart <- emptySTCCurrentStartT
@@ -1089,10 +1103,10 @@
       iCT DS.Empty      _  _   _   _    _    = pure ()
       iCT (as DS.:|> a) bs tcc tcb tccs tcce = do
         let cctbs = (\(CcT t) -> t) $
-                    (\(a,_) -> a)   $
+                    (\(a,_,_) -> a) $
                     (\(FMIndexT t) -> t) bs
         let coccckts = (\(OccCKT t) -> t) $
-                       (\(_,b) -> b)      $
+                       (\(_,b,_) -> b)    $
                        (\(FMIndexT t) -> t) bs
         ctcc <- readSTRef tcc
         ctccs <- readSTRef tccs
@@ -1231,10 +1245,11 @@
 locateFMIndexB :: PBLPat
                -> FMIndexB
                -> ST s LIntB
-locateFMIndexB DS.Empty _                              = return DS.Empty
-locateFMIndexB _        (FMIndexB (CcB DS.Empty,_))    = return DS.Empty
-locateFMIndexB _        (FMIndexB (_,OccCKB DS.Empty)) = return DS.Empty 
-locateFMIndexB xs       ys                             = do
+locateFMIndexB DS.Empty _                                = return DS.Empty
+locateFMIndexB _        (FMIndexB (CcB DS.Empty,_,_))    = return DS.Empty
+locateFMIndexB _        (FMIndexB (_,OccCKB DS.Empty,_)) = return DS.Empty
+locateFMIndexB _        (FMIndexB (_,_,SAB DS.Empty))    = return DS.Empty 
+locateFMIndexB xs       ys                               = do
   blcounter      <- emptySTLCounterB
   blbool         <- emptySTLBoolB
   blcurrentstart <- emptySTLCurrentStartB
@@ -1261,10 +1276,10 @@
       iLB DS.Empty      _  _   _   _    _    = pure ()
       iLB (as DS.:|> a) bs blc blb blcs blce = do
         let ccbbs = (\(CcB b) -> b) $
-                    (\(a,_) -> a)   $
+                    (\(a,_,_) -> a) $
                     (\(FMIndexB b) -> b) bs
         let coccckbs = (\(OccCKB b) -> b) $
-                       (\(_,b) -> b)      $
+                       (\(_,b,_) -> b)    $
                        (\(FMIndexB b) -> b) bs
         cblc <- readSTRef blc
         cblcs <- readSTRef blcs
@@ -1403,10 +1418,11 @@
 locateFMIndexT :: PTLPat
                -> FMIndexT
                -> ST s LIntT
-locateFMIndexT DS.Empty _                              = return DS.Empty
-locateFMIndexT _        (FMIndexT (CcT DS.Empty,_))    = return DS.Empty
-locateFMIndexT _        (FMIndexT (_,OccCKT DS.Empty)) = return DS.Empty
-locateFMIndexT xs       ys                             = do
+locateFMIndexT DS.Empty _                                = return DS.Empty
+locateFMIndexT _        (FMIndexT (CcT DS.Empty,_,_))    = return DS.Empty
+locateFMIndexT _        (FMIndexT (_,OccCKT DS.Empty,_)) = return DS.Empty
+locateFMIndexT _        (FMIndexT (_,_,SAT DS.Empty))    = return DS.Empty
+locateFMIndexT xs       ys                               = do
   tlcounter      <- emptySTLCounterT
   tlbool         <- emptySTLBoolT
   tlcurrentstart <- emptySTLCurrentStartT
@@ -1433,10 +1449,10 @@
       iLT DS.Empty      _  _   _   _    _    = pure ()
       iLT (as DS.:|> a) bs tlc tlb tlcs tlce = do
         let cctbs = (\(CcT t) -> t) $
-                    (\(a,_) -> a)   $
+                    (\(a,_,_) -> a) $
                     (\(FMIndexT t) -> t) bs
         let coccckts = (\(OccCKT t) -> t) $
-                       (\(_,b) -> b)      $
+                       (\(_,b,_) -> b)    $
                        (\(FMIndexT t) -> t) bs
         ctlc <- readSTRef tlc
         ctlcs <- readSTRef tlcs
diff --git a/text-compression.cabal b/text-compression.cabal
--- a/text-compression.cabal
+++ b/text-compression.cabal
@@ -20,7 +20,7 @@
 -- PVP summary:     +-+------- breaking API changes
 --                  | | +----- non-breaking API additions
 --                  | | | +--- code changes with no API change
-version:            0.1.0.24
+version:            0.1.0.25
 
 -- A short (one-line) description of the package.
 synopsis:           A text compression library.