diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -35,3 +35,7 @@
 ## 0.1.0.8 -- 2022-11-11
 
 * Optimized BWT and RLE implementations by switching out sequences with vectors.
+
+## 0.1.0.9 -- 2022-11-12
+
+* Switching back to sequences for maintainability (for now).
diff --git a/src/Data/BWT.hs b/src/Data/BWT.hs
--- a/src/Data/BWT.hs
+++ b/src/Data/BWT.hs
@@ -30,29 +30,28 @@
 import Control.Monad.State.Strict()
 import Data.ByteString as BS (ByteString,concat,pack,unpack)
 import Data.Foldable as DFold (toList)
+import Data.Sequence as DS (Seq(..),fromList,iterateN,length,unstableSortBy,zip)
 import Data.STRef()
 import Data.Text (Text)
 import Data.Text.Encoding as DTE (decodeUtf8,encodeUtf8)
-import Data.Vector as DVB (empty,iterateN,length,zip)
-import Data.Vector.Unboxed as DVU (Unbox,fromList)
 import Data.Word (Word8)
-import GHC.Generics (Generic)
+import GHC.Generics(Generic)
 
 
 {-toBWT Function(s)-}
 
 -- | Takes a String and returns the Burrows-Wheeler Transform (BWT).
 -- Implemented via a 'SuffixArray'.
-toBWT :: (Unbox a,Ord a)
-      => [a]
-      -> BWT a
-toBWT [] = BWT DVB.empty
+toBWT :: Ord a =>
+         [a]   ->
+         BWT a
+toBWT [] = BWT DS.Empty
 toBWT xs = do
   let saxs = createSuffixArray xss
-  saToBWT saxs
-          xss
+  BWT (saToBWT saxs
+               xss)
     where
-      xss = DVU.fromList xs
+      xss = DS.fromList xs
 
 -- | Helper function for converting a 'ByteString'
 -- to a 'BWT' 'Word8'.
@@ -81,16 +80,17 @@
 -- This function utilizes the state monad (strict) in order
 -- to implement the [Magic](https://www.youtube.com/watch?v=QwSsppKrCj4) Inverse BWT algorithm by backtracking
 -- indices starting with the (__Nothing__,_) entry.
-fromBWT :: Ord a
-        => BWT a
-        -> [a]
+fromBWT :: Ord a =>
+           BWT a ->
+           [a]
 fromBWT bwt = do
   let originall = CMST.runST $ magicInverseBWT magicsz
   DFold.toList originall
     where
-      magicsz = sortVecBWT zipped
-      zipped  = DVB.zip bwtt
-                        (DVB.iterateN (DVB.length bwtt) (+1) 0)
+      magicsz = DS.unstableSortBy (\(a,b) (c,d) -> sortTB (a,b) (c,d))
+                zipped
+      zipped  = DS.zip bwtt
+                       (DS.iterateN (DS.length bwtt) (+1) 0)
       bwtt    = (\(BWT t) -> t) bwt
 
 -- | Helper function for converting a 'BWT' of 'Word8's
diff --git a/src/Data/BWT/Internal.hs b/src/Data/BWT/Internal.hs
--- a/src/Data/BWT/Internal.hs
+++ b/src/Data/BWT/Internal.hs
@@ -33,28 +33,25 @@
 -- Various data structures and custom data types to describe the Burrows-Wheeler Transform (BWT)
 -- and the Inverse BWT.
 --
--- The implementation of the BWT relies upon Boxed vectors, 'DVB.Vector', and Unboxed vectors, 'DVU.Vector',
--- provided by the [vector](https://hackage.haskell.org/package/vector).
+-- The implementation of the BWT relies upon sequence provided
+-- by the [containers](https://hackage.haskell.org/package/containers).
 --
 -- The internal 'BWTMatrix' data type relies upon the [massiv](https://hackage.haskell.org/package/massiv) package.
 
 
 module Data.BWT.Internal where
 
-import Control.Monad as CM (when)
-import Control.Monad.ST as CMST (ST,runST)
+import Control.Monad as CM
+import Control.Monad.ST as CMST
 import Control.Monad.State.Strict()
 import Data.Foldable as DFold
-import Data.List as DL (length,map)
+import Data.List as DL
 import Data.Maybe as DMaybe (fromJust,isNothing)
-import Data.Sequence as DS (fromList,(><),null,singleton,zip,sortBy,tails,inits)
+import Data.Sequence as DS (Seq(..),empty,findIndexL,fromList,length,index,inits,null,singleton,tails,unstableSortBy,unstableSortOn,zip,(><),(|>),(<|))
 import Data.Massiv.Array as DMA
 import Data.Massiv.Core()
-import Data.STRef as DSTR (STRef,newSTRef,readSTRef,writeSTRef)
-import Data.Vector as DVB (Vector,empty,findIndex,fromList,iterateN,map,snoc,thaw,unsafeFreeze,zip,uncons,(!))
-import Data.Vector.Algorithms.Tim as DVAT (sortBy)
-import Data.Vector.Unboxed as DVU (Vector,empty,null,tail,uncons,(!))
-import GHC.Generics (Generic)
+import Data.STRef as DSTR
+import GHC.Generics
 import Prelude as P
 
 
@@ -64,19 +61,20 @@
 -- the core data inside of the 'SuffixArray' data type.
 data Suffix a = Suffix { suffixindex    :: Int
                        , suffixstartpos :: Int
-                       , suffix         :: Maybe (DVU.Vector a)
+                       , suffix         :: Maybe (Seq a)
                        }
   deriving (Show,Read,Eq,Ord,Generic)
 
 -- | The SuffixArray data type.
--- Uses 'DVB.Vector' internally.
-type SuffixArray a = DVB.Vector (Suffix a)
+-- Uses sequence internally.
+type SuffixArray a = Seq (Suffix a)
 
 -- | The BWT data type.
--- Uses 'DVU.Vector' internally.
-newtype BWT a = BWT (DVB.Vector (Maybe a))
+-- Uses sequence internally.
+newtype BWT a = BWT (Seq (Maybe a))
   deriving (Eq,Ord,Show,Read,Generic)
 
+
 -- | The BWTMatrix data type.
 -- Uses a massiv array internally.
 type BWTMatrix = DMA.Array BN Ix1 String
@@ -87,80 +85,46 @@
 {-toBWT functions.-}
 
 -- | Computes the Burrows-Wheeler Transform (BWT) using the suffix array
--- and the original string (represented as a 'DVB.Vector' for performance).
-saToBWT :: Unbox a
-        => SuffixArray a
-        -> DVU.Vector a
-        -> BWT a
-saToBWT (DVB.uncons -> Nothing) _ = BWT DVB.empty
-saToBWT vs                      t =
-  BWT
-    (DVB.map (\v -> if | suffixstartpos v /= 1
-                       -> Just $
-                          (DVU.!) t (suffixstartpos v - 1 - 1)
-                       | otherwise
-                       -> Nothing
-             )
-     vs)
-
--- | 'DVU.Vector' based implementation of the
--- well-known tails function in the List library.
-tailsV :: Unbox a
-       => DVU.Vector a
-       -> [DVU.Vector a]
-tailsV (DVU.uncons -> Nothing) = [DVU.empty]
-tailsV vs                      =
-  vs : (tailsV (DVU.tail vs))
-
--- | Custom sort function for 'DVB.Vector's
--- used in the 'createSuffixArray' function.
-sortVecSA :: Ord a
-          => DVB.Vector (Int,a)
-          -> DVB.Vector (Int,a)
-sortVecSA vs =
-  CMST.runST
-    (do mv <- DVB.thaw vs
-        DVAT.sortBy (\(_,b) (_,d) -> compare b d) mv
-        DVB.unsafeFreeze mv)
-
--- | Custom sort function for 'DVB.Vector's
--- used in the fromBWT function.
-sortVecBWT :: Ord a
-           => DVB.Vector (a,Int)
-           -> DVB.Vector (a,Int)
-sortVecBWT vs =
-  CMST.runST
-    (do mv <- DVB.thaw vs
-        DVAT.sortBy (\(a,b) (c,d) -> sortTB (a,b) (c,d)) mv
-        DVB.unsafeFreeze mv) 
+-- and the original string (represented as a sequence for performance).
+saToBWT :: SuffixArray a ->
+           Seq a         ->
+           Seq (Maybe a)
+saToBWT DS.Empty      _ = DS.Empty
+saToBWT (y DS.:<| ys) t =
+  if | suffixstartpos y /= 1
+     -> (Just $ DS.index t (suffixstartpos y - 1 - 1))
+        DS.<| (saToBWT ys t)
+     | otherwise
+     -> Nothing
+        DS.<| (saToBWT ys t)
 
 -- | Computes the corresponding 'SuffixArray' of a given string. Please see [suffix array](https://en.wikipedia.org/wiki/Suffix_array)
--- for more information.
-createSuffixArray :: (Unbox a,Ord a)
-                    => DVU.Vector a 
-                    -> SuffixArray a
-createSuffixArray vs =
-  DVB.map (\(a,b,c) -> if | not $ DVU.null c
-                          -> Suffix { suffixindex    = a
-                                    , suffixstartpos = b
-                                    , suffix         = Just c
-                                    }
-                          | otherwise
-                          -> Suffix { suffixindex    = a
-                                    , suffixstartpos = b
-                                    , suffix         = Nothing
-                                    }
-          )
-  vssuffixesfff
+-- for more information. 
+createSuffixArray :: Ord a =>
+                     Seq a ->
+                     SuffixArray a
+createSuffixArray xs =
+  fmap (\(a,b,c) -> if | not $ DS.null c
+                       -> Suffix { suffixindex    = a
+                                 , suffixstartpos = b
+                                 , suffix         = Just c
+                                 }
+                       | otherwise
+                       -> Suffix { suffixindex    = a
+                                 , suffixstartpos = b
+                                 , suffix         = Nothing
+                                 }
+       )
+  xsssuffixesfff
     where
-      vssuffixes         = tailsV vs
-      vssuffixesf        = DVB.zip (DVB.iterateN (DL.length vssuffixes) (+1) 1 :: DVB.Vector Int)
-                                   (DVB.fromList vssuffixes)
-      vssuffixesffsorted = sortVecSA vssuffixesf
-      vssuffixesfff      = (\(a,(b,c)) -> (a,b,c))
-                           <$>
-                           DVB.zip (DVB.iterateN (DL.length vssuffixesffsorted) (+1) 1 :: DVB.Vector Int)
-                                   vssuffixesffsorted 
+      xsssuffixes         = DS.tails xs
+      xsssuffixesf        = DS.zip (DS.fromList [1..(DS.length xsssuffixes)])
+                                   xsssuffixes
+      xsssuffixesffsorted = DS.unstableSortOn snd xsssuffixesf
+      xsssuffixesfff      = (\(a,(b,c)) -> (a,b,c))
+                            <$>
+                            DS.zip (DS.fromList [1..(DS.length xsssuffixesffsorted)])
+                                   xsssuffixesffsorted
 
 {------------------}
 
@@ -178,20 +142,20 @@
                          compare i1 i2
 
 -- | Abstract BWTSeq type utilizing a sequence.
-type BWTVec a = DVB.Vector a
+type BWTSeq a = Seq a
 
--- | Abstract data type representing a 'BWTVec' in the (strict) ST monad.
-type STBWTVec s a = STRef s (BWTVec a)
+-- | Abstract data type representing a BWTSeq in the (strict) ST monad.
+type STBWTSeq s a = STRef s (BWTSeq a)
 
--- | State function to push 'BWTVec' data into stack.
-pushSTBWTVec :: STBWTVec s a -> a -> ST s ()
-pushSTBWTVec s e = do
+-- | State function to push BWTString data into stack.
+pushSTBWTSeq :: STBWTSeq s a -> a -> ST s ()
+pushSTBWTSeq s e = do
   s2 <- readSTRef s
-  writeSTRef s (DVB.snoc s2 e)
+  writeSTRef s (s2 DS.|> e)
 
--- | State function to create empty 'STBWTVec' type.
-emptySTBWTVec :: ST s (STBWTVec s a)
-emptySTBWTVec = newSTRef DVB.empty
+-- | State function to create empty STBWTString type.
+emptySTBWTSeq :: ST s (STBWTSeq s a)
+emptySTBWTSeq = newSTRef DS.empty
 
 -- | Abstract BWTCounter and associated state type.
 type STBWTCounter s a = STRef s Int
@@ -205,43 +169,43 @@
 emptySTBWTCounter = newSTRef (-1)
 
 -- | "Magic" Inverse BWT function.
-magicInverseBWT :: DVB.Vector (Maybe a,Int) ->
-                   ST s (BWTVec a)
-magicInverseBWT (DVB.uncons -> Nothing) = do
-  bwtvecstackempty  <- emptySTBWTVec
-  bwtvecstackemptyr <- readSTRef bwtvecstackempty
-  return bwtvecstackemptyr
-magicInverseBWT xs                      = do
-  bwtvecstack      <- emptySTBWTVec
+magicInverseBWT :: Seq (Maybe a,Int) ->
+                   ST s (BWTSeq a)
+magicInverseBWT DS.Empty = do
+  bwtseqstackempty  <- emptySTBWTSeq
+  bwtseqstackemptyr <- readSTRef bwtseqstackempty
+  return bwtseqstackemptyr
+magicInverseBWT xs       = do
+  bwtseqstack      <- emptySTBWTSeq
   bwtcounterstackf <- emptySTBWTCounter
   bwtcounterstacke <- emptySTBWTCounter
-  case (DVB.findIndex (\x -> isNothing $ fst x) xs) of
-    Nothing           -> do bwtvecstackr <- readSTRef bwtvecstack
-                            return bwtvecstackr
-    Just nothingindex -> do let nothingfirst = (DVB.!) xs
+  case (DS.findIndexL (\x -> isNothing $ fst x) xs) of
+    Nothing           -> do bwtseqstackr <- readSTRef bwtseqstack
+                            return bwtseqstackr
+    Just nothingindex -> do let nothingfirst = DS.index xs
                                                         nothingindex
                             updateSTBWTCounter bwtcounterstacke
                                                nothingindex
                             updateSTBWTCounter bwtcounterstackf
                                                (snd nothingfirst)
                             iBWT xs
-                                 bwtvecstack
+                                 bwtseqstack
                                  bwtcounterstackf
                                  bwtcounterstacke
-                            bwtvecstackr <- readSTRef bwtvecstack
-                            return bwtvecstackr
+                            bwtseqstackr <- readSTRef bwtseqstack
+                            return bwtseqstackr
       where
-        iBWT ys bwtvs bwtcsf bwtcse = do
+        iBWT ys bwtss bwtcsf bwtcse = do
           cbwtcsf <- readSTRef bwtcsf
           cbwtcse <- readSTRef bwtcse
           CM.when (cbwtcsf /= cbwtcse) $ do 
-            let next = (DVB.!) ys cbwtcsf
-            pushSTBWTVec bwtvs
+            let next = DS.index ys cbwtcsf
+            pushSTBWTSeq bwtss
                          (DMaybe.fromJust $ fst next)
             updateSTBWTCounter bwtcsf
                                (snd next)
             iBWT ys
-                 bwtvs
+                 bwtss
                  bwtcsf
                  bwtcse
 
@@ -250,7 +214,7 @@
 createBWTMatrix :: String ->
                    BWTMatrix
 createBWTMatrix t =
-  DMA.fromList (ParN 0) zippedffff :: DMA.Array BN Ix1 String
+  DMA.fromList (ParN 0) zippedffff :: Array BN Ix1 String
     where
       zippedffff = DL.map DFold.toList $
                    DL.map (\(a,b) -> if | isNothing a
@@ -266,7 +230,7 @@
                           )
                    zippedfff
       zippedfff  = DFold.toList zippedff
-      zippedff   = DS.sortBy (\(a,_) (c,_) -> compare a c)
+      zippedff   = DS.unstableSortBy (\(a,_) (c,_) -> compare a c)
                    zippedp
       zippedp    = DS.zip suffixesf prefixesf
       suffixesf  = fmap (\x -> if | DS.null x
diff --git a/src/Data/RLE.hs b/src/Data/RLE.hs
--- a/src/Data/RLE.hs
+++ b/src/Data/RLE.hs
@@ -28,11 +28,10 @@
 import Data.Char()
 import Data.Foldable()
 import Data.Maybe as DMaybe (isNothing,fromJust)
+import Data.Sequence as DS (Seq(..))
 import Data.STRef()
 import Data.Text as DText 
 import Data.Text.Encoding as DTE (decodeUtf8,encodeUtf8)
-import Data.Vector as DVB (Vector,empty,map,uncons)
-import Data.Vector.Unboxed()
 import Data.Word (Word8)
 import Prelude as P
 
@@ -68,7 +67,7 @@
 textBWTToRLEB :: TextBWT
               -> RLEB
 textBWTToRLEB xs =
-  RLEB (CMST.runST $ vecToRLEB xss)
+  RLEB (CMST.runST $ seqToRLEB xss)
     where
       xss = fmap (\x -> if | isNothing x
                            -> Nothing
@@ -84,9 +83,9 @@
 -- Run-length encoding ('RLEB').
 bytestringBWTToRLEB :: BWT Word8
                     -> RLEB
-bytestringBWTToRLEB (BWT (DVB.uncons -> Nothing)) = RLEB DVB.empty
-bytestringBWTToRLEB xs                            =
-  RLEB (CMST.runST $ vecToRLEB xss)
+bytestringBWTToRLEB (BWT DS.Empty) = RLEB DS.Empty
+bytestringBWTToRLEB xs             =
+  RLEB (CMST.runST $ seqToRLEB xss)
     where
       xss = fmap (\x -> if | isNothing x
                            -> Nothing
@@ -102,7 +101,7 @@
 textBWTToRLET :: TextBWT
               -> RLET
 textBWTToRLET xs =
-  RLET (CMST.runST $ vecToRLET xss)
+  RLET (CMST.runST $ seqToRLET xss)
     where
       xss = fmap (\x -> if | isNothing x
                            -> Nothing
@@ -119,9 +118,9 @@
 -- Run-length encoding ('RLET').
 bytestringBWTToRLET :: BWT Word8
                     -> RLET
-bytestringBWTToRLET (BWT (DVB.uncons -> Nothing)) = RLET DVB.empty
-bytestringBWTToRLET xs                            =
-  RLET (CMST.runST $ vecToRLET xss)
+bytestringBWTToRLET (BWT DS.Empty) = RLET DS.Empty
+bytestringBWTToRLET xs             =
+  RLET (CMST.runST $ seqToRLET xss)
     where
       xss = fmap (\x -> if | isNothing x
                            -> Nothing
@@ -134,11 +133,11 @@
             ((\(BWT t) -> t) xs)
 
 -- | Takes a 'Text' and returns the Run-length encoding ('RLEB').
-textToRLEB :: DVB.Vector (Maybe Text)
+textToRLEB :: Seq (Maybe Text)
            -> RLEB
-textToRLEB (DVB.uncons -> Nothing) = RLEB DVB.empty
-textToRLEB xs                      = 
-  RLEB (CMST.runST $ vecToRLEB xss)
+textToRLEB DS.Empty = RLEB DS.Empty
+textToRLEB xs       = 
+  RLEB (CMST.runST $ seqToRLEB xss)
     where
       xss = fmap (\x -> if | isNothing x
                            -> Nothing
@@ -149,26 +148,26 @@
                  )
             xs
 
--- | Takes a 'DVB.Vector' of 'ByteString's and returns the Run-length encoding ('RLEB').
-bytestringToRLEB :: DVB.Vector (Maybe ByteString)
+-- | Takes a 'Seq' of 'ByteString's and returns the Run-length encoding ('RLEB').
+bytestringToRLEB :: Seq (Maybe ByteString)
                  -> RLEB
-bytestringToRLEB (DVB.uncons -> Nothing) = RLEB DVB.empty
-bytestringToRLEB xs                      =
- RLEB (CMST.runST $ vecToRLEB xs)
+bytestringToRLEB DS.Empty = RLEB DS.Empty
+bytestringToRLEB xs       =
+ RLEB (CMST.runST $ seqToRLEB xs)
 
 -- | Takes a 'Text' and returns the Run-length encoding (RLE).
-textToRLET :: DVB.Vector (Maybe Text)
+textToRLET :: Seq (Maybe Text)
            -> RLET
-textToRLET (DVB.uncons -> Nothing) = RLET DVB.empty
-textToRLET xs                      =
-  RLET (CMST.runST $ vecToRLET xs)
+textToRLET DS.Empty = RLET DS.Empty
+textToRLET xs       =
+  RLET (CMST.runST $ seqToRLET xs)
 
 -- | Takes a 'ByteString' and returns the Run-length encoding (RLE).
-bytestringToRLET :: DVB.Vector (Maybe ByteString)
+bytestringToRLET :: Seq (Maybe ByteString)
                  -> RLET
-bytestringToRLET (DVB.uncons -> Nothing) = RLET DVB.empty
-bytestringToRLET xs                      =
-  RLET (CMST.runST $ vecToRLET xss)
+bytestringToRLET DS.Empty = RLET DS.Empty
+bytestringToRLET xs       =
+  RLET (CMST.runST $ seqToRLET xss)
     where
       xss = fmap (\x -> if | isNothing x
                            -> Nothing
@@ -194,17 +193,17 @@
 -- back to the original 'ByteString'.
 bytestringFromBWTFromRLET :: RLET
                           -> ByteString
-bytestringFromBWTFromRLET vs = bytestringFromByteStringBWT $
+bytestringFromBWTFromRLET xs = bytestringFromByteStringBWT $
                                BWT                         $
-                               DVB.map (\x -> if | isNothing x
-                                                 -> Nothing
-                                                 | otherwise
-                                                 -> Just           $
-                                                    DTE.encodeUtf8 $
-                                                    fromJust x
-                                       )
-                                                           $ 
-                               ((\(BWT t) -> t) (textBWTFromRLET vs))
+                               fmap (\x -> if | isNothing x
+                                              -> Nothing
+                                              | otherwise
+                                              -> Just           $
+                                                 DTE.encodeUtf8 $
+                                                 fromJust x
+                                    )
+                                                           $
+                            ((\(BWT t) -> t) (textBWTFromRLET xs))
 
 -- | Helper function for converting a 'BWT'ed 'RLEB'
 -- back to the original 'Text'.
@@ -222,92 +221,92 @@
 -- the 'BWT' of 'Text's.
 textBWTFromRLET :: RLET
                 -> BWT Text
-textBWTFromRLET (RLET (DVB.uncons -> Nothing)) = BWT DVB.empty
-textBWTFromRLET vs              = 
-  BWT (CMST.runST $ vecFromRLET vs)
+textBWTFromRLET (RLET DS.Empty) = BWT DS.Empty
+textBWTFromRLET xs              = 
+  BWT (CMST.runST $ seqFromRLET xs)
 
 -- | Takes a 'RLET' and returns
 -- the 'BWT' of 'ByteString's.
 bytestringBWTFromRLET :: RLET
                       -> BWT ByteString
-bytestringBWTFromRLET (RLET (DVB.uncons -> Nothing)) = BWT DVB.empty
-bytestringBWTFromRLET vs                             = do
-  let originalbwtb = CMST.runST $ vecFromRLET vs
-  BWT (DVB.map (\x -> if | isNothing x
-                         -> Nothing
-                         | otherwise
-                         -> Just           $
-                            DTE.encodeUtf8 $
-                            fromJust x 
-               ) originalbwtb)
+bytestringBWTFromRLET (RLET DS.Empty) = BWT DS.Empty
+bytestringBWTFromRLET xs              = do
+  let originalbwtb = CMST.runST $ seqFromRLET xs
+  BWT (fmap (\x -> if | isNothing x
+                      -> Nothing
+                      | otherwise
+                      -> Just           $
+                         DTE.encodeUtf8 $
+                        fromJust x 
+            ) originalbwtb)
 
 -- | Takes a 'RLEB' and returns
 -- the 'BWT' of 'Text's.
 textBWTFromRLEB :: RLEB
                 -> BWT Text
-textBWTFromRLEB (RLEB (DVB.uncons -> Nothing)) = BWT DVB.empty
-textBWTFromRLEB vs                             = do
-  let originalbwtt = CMST.runST $ vecFromRLEB vs
-  BWT (DVB.map (\x -> if | isNothing x
-                         -> Nothing
-                         | otherwise
-                         -> Just           $
-                            DTE.decodeUtf8 $
-                            fromJust x
-               ) originalbwtt)
+textBWTFromRLEB (RLEB DS.Empty) = BWT DS.Empty
+textBWTFromRLEB xs              = do
+  let originalbwtt = CMST.runST $ seqFromRLEB xs
+  BWT (fmap (\x -> if | isNothing x
+                      -> Nothing
+                      | otherwise
+                      -> Just           $
+                         DTE.decodeUtf8 $
+                        fromJust x
+            ) originalbwtt)
 
 -- | Take a 'RLEB' and returns
 -- the 'BWT' of 'ByteString's.
 bytestringBWTFromRLEB :: RLEB 
                       -> BWT ByteString
-bytestringBWTFromRLEB (RLEB (DVB.uncons -> Nothing)) = BWT DVB.empty
-bytestringBWTFromRLEB vs                             =
-  BWT (CMST.runST $ vecFromRLEB vs)
+bytestringBWTFromRLEB (RLEB DS.Empty) = BWT DS.Empty
+bytestringBWTFromRLEB xs              =
+  BWT (CMST.runST $ seqFromRLEB xs)
 
 -- | Takes a 'RLEB' and returns
--- the original 'DVB.Vector' of 'Text's.
+-- the original 'Seq' of 'Text's.
 textFromRLEB :: RLEB
-             -> DVB.Vector (Maybe Text)
-textFromRLEB (RLEB (DVB.uncons -> Nothing)) = DVB.empty
-textFromRLEB vs                             = do
-  let originalt = CMST.runST $ vecFromRLEB vs
-  DVB.map (\x -> if | isNothing x
-                    -> Nothing
-                    | otherwise
-                    -> Just           $
-                       DTE.decodeUtf8 $
-                       fromJust x
-          ) originalt
+             -> Seq (Maybe Text)
+textFromRLEB (RLEB DS.Empty) = DS.Empty
+textFromRLEB xs              = do
+  let originalt = CMST.runST $ seqFromRLEB xs
+  fmap (\x -> if | isNothing x
+                 -> Nothing
+                 | otherwise
+                 -> Just           $
+                    DTE.decodeUtf8 $
+                    fromJust x
+       ) originalt
 
 -- | Takes a 'RLEB' and returns
--- the original 'DVB.Vector' of 'ByteString's.
+-- the original 'Seq' of 'ByteString's.
 bytestringFromRLEB :: RLEB
-                   -> DVB.Vector (Maybe ByteString)
-bytestringFromRLEB (RLEB (DVB.uncons -> Nothing)) = DVB.empty
-bytestringFromRLEB vs                             =
-  CMST.runST $ vecFromRLEB vs
+                   -> Seq (Maybe ByteString)
+bytestringFromRLEB (RLEB DS.Empty) = DS.Empty
+bytestringFromRLEB xs              = do
+  CMST.runST $ seqFromRLEB xs
 
 -- | Takes a 'RLET' and returns
--- the original 'DVB.Vector' of 'Text's.
+-- the original 'Seq' of 'Text's.
 textFromRLET :: RLET
-             -> DVB.Vector (Maybe Text)
-textFromRLET (RLET (DVB.uncons -> Nothing)) = DVB.empty
-textFromRLET vs                             =
-  CMST.runST $ vecFromRLET vs
+             -> Seq (Maybe Text)
+textFromRLET (RLET DS.Empty) = DS.Empty
+textFromRLET xs              = do
+  CMST.runST $ seqFromRLET xs
 
 -- | Takes a 'RLET' and returns
--- the original 'DVB.Vector' of 'ByteString's.
+-- the original 'Seq' of 'ByteString's.
 bytestringFromRLET :: RLET
-                   -> DVB.Vector (Maybe ByteString)
-bytestringFromRLET (RLET (DVB.uncons -> Nothing)) = DVB.empty
-bytestringFromRLET vs                             = do
-  let originalb = CMST.runST $ vecFromRLET vs
-  DVB.map (\x -> if | isNothing x
-                    -> Nothing
-                    | otherwise
-                    -> Just           $
-                       DTE.encodeUtf8 $
-                       fromJust x
-          ) originalb
+                   -> Seq (Maybe ByteString)
+bytestringFromRLET (RLET DS.Empty) = DS.Empty
+bytestringFromRLET xs              = do
+  let originalb = CMST.runST $ seqFromRLET xs
+  fmap (\x -> if | isNothing x
+                 -> Nothing
+                 | otherwise
+                 -> Just           $ 
+                    DTE.encodeUtf8 $
+                    fromJust x
+       ) originalb
 
 {---------------------}
diff --git a/src/Data/RLE/Internal.hs b/src/Data/RLE/Internal.hs
--- a/src/Data/RLE/Internal.hs
+++ b/src/Data/RLE/Internal.hs
@@ -31,9 +31,9 @@
 -- = Description
 --
 -- Various data structures and custom data types to describe the Run-length encoding (RLE)
--- and the Inverse RLE implementations, namely 'vecToRLEB', 'vecToRLET', 'vecFromRLEB', and 'vecFromRLET'.
+-- and the Inverse RLE implementations, namely 'seqToRLEB', 'seqToRLET', 'seqFromRLEB', and 'seqFromRLET'.
 --
--- The RLE implementations rely heavily upon 'DVB.Vector' provided by the [vector](https://hackage.haskell.org/package/vector) library,
+-- The RLE implementations rely heavily upon 'Seq' provided by the [containers](https://hackage.haskell.org/package/containers),
 -- 'STRef' and associated functions in the [stref](https://hackage.haskell.org/package/base-4.17.0.0/docs/Data-STRef.html) library,
 -- and 'runST' in the [Control.Monad.ST](https://hackage.haskell.org/package/base-4.17.0.0/docs/Control-Monad-ST.html) library.
 
@@ -48,10 +48,10 @@
 import Data.ByteString.Internal()
 import Data.List()
 import Data.Maybe as DMaybe (fromJust,isJust,isNothing)
+import Data.Sequence as DS (Seq(..),empty,(|>))
+import Data.Sequence.Internal as DSI
 import Data.STRef as DSTR
 import Data.Text as DText
-import Data.Vector as DVB
-import Data.Vector.Unboxed()
 import GHC.Generics (Generic)
 import Prelude as P
 
@@ -59,11 +59,11 @@
 {-Base level types.-}
 
 -- | Basic RLE ('ByteString') data type.
-newtype RLEB = RLEB (DVB.Vector (Maybe ByteString))
+newtype RLEB = RLEB (Seq (Maybe ByteString))
   deriving (Eq,Ord,Show,Read,Generic)
 
 -- | Basic RLE ('Text') data type.
-newtype RLET = RLET (DVB.Vector (Maybe Text))
+newtype RLET = RLET (Seq (Maybe Text))
   deriving (Eq,Ord,Show,Read,Generic)
 
 {-------------------}
@@ -71,24 +71,24 @@
 
 {-toRLE (ByteString) functions.-}
 
--- | Abstract 'RLEVecB' type utilizing a sequence.
-type RLEVecB = DVB.Vector (Maybe ByteString)
+-- | Abstract 'RLESeqB' type utilizing a sequence.
+type RLESeqB = Seq (Maybe ByteString)
 
--- | Abstract data type representing a 'RLEVecB' in the (strict) ST monad.
-type STRLEVecB s a = STRef s RLEVecB
+-- | Abstract data type representing a 'RLESeqB' in the (strict) ST monad.
+type STRLESeqB s a = STRef s RLESeqB
 
--- | State function to push 'RLEVecB' data into stack.
-pushSTRLEVecB :: STRLEVecB s (Maybe ByteString) -> Maybe ByteString -> ST s ()
-pushSTRLEVecB s Nothing  = do
+-- | State function to push 'RLESeqB' data into stack.
+pushSTRLESeqB :: STRLESeqB s (Maybe ByteString) -> Maybe ByteString -> ST s ()
+pushSTRLESeqB s Nothing  = do
   s2 <- readSTRef s
-  writeSTRef s (DVB.snoc s2 Nothing)
-pushSTRLEVecB s (Just e) = do
+  writeSTRef s (s2 DS.|> Nothing)
+pushSTRLESeqB s (Just e) = do
   s2 <- readSTRef s
-  writeSTRef s (DVB.snoc s2 (Just e))
+  writeSTRef s (s2 DS.|> Just e)
 
--- | State function to create empty 'STRLEVecB' type.
-emptySTRLEVecB :: ST s (STRLEVecB s a)
-emptySTRLEVecB = newSTRef DVB.empty
+-- | State function to create empty 'STRLESeqB' type.
+emptySTRLESeqB :: ST s (STRLESeqB s a)
+emptySTRLESeqB = newSTRef DS.empty
 
 -- | Abstract 'STRLETempB' and associated state type.
 type STRLETempB s a = STRef s (Maybe ByteString)
@@ -114,52 +114,52 @@
 emptySTRLECounterB = newSTRef (-1)
 
 -- | Strict state monad function.
-vecToRLEB :: RLEVecB
-          -> ST s RLEVecB
-vecToRLEB (DVB.uncons -> Nothing)     = do
-  brlevecstackempty  <- emptySTRLEVecB
-  brlevecstackemptyr <- readSTRef brlevecstackempty
-  return brlevecstackemptyr
-vecToRLEB (DVB.uncons -> Just (v,vs)) = do
-  brlevecstack     <- emptySTRLEVecB
+seqToRLEB :: RLESeqB
+          -> ST s RLESeqB
+seqToRLEB DS.Empty      = do
+  brleseqstackempty  <- emptySTRLESeqB
+  brleseqstackemptyr <- readSTRef brleseqstackempty
+  return brleseqstackemptyr
+seqToRLEB (x DS.:<| xs) = do
+  brleseqstack     <- emptySTRLESeqB
   brlecounterstack <- emptySTRLECounterB
   brletempstack    <- emptySTRLETempB
   updateSTRLECounterB brlecounterstack
                       1 
   updateSTRLETempB brletempstack
-                   v
-  iRLEB vs
-        brlevecstack
+                   x
+  iRLEB xs
+        brleseqstack
         brlecounterstack
         brletempstack
-  brlevecstackr <- readSTRef brlevecstack
-  return brlevecstackr
+  brleseqstackr <- readSTRef brleseqstack
+  return brleseqstackr
     where
-      iRLEB (DVB.uncons -> Nothing)     brless brlecs brlets = do
+      iRLEB DS.Empty      brless brlecs brlets = do
         cbrlecs <- readSTRef brlecs
         cbrlets <- readSTRef brlets
-        pushSTRLEVecB brless
+        pushSTRLESeqB brless
                       (Just      $
                        BSC8.pack $
                        show cbrlecs)
-        pushSTRLEVecB brless
+        pushSTRLESeqB brless
                       cbrlets
         pure ()
-      iRLEB (DVB.uncons -> Just (y,ys)) brless brlecs brlets = do
+      iRLEB (y DS.:<| ys) brless brlecs brlets = do
         cbrlecs <- readSTRef brlecs
         cbrlets <- readSTRef brlets
         if | isNothing y
-           -> do pushSTRLEVecB brless
+           -> do pushSTRLESeqB brless
                                (Just      $
                                 BSC8.pack $
                                 show cbrlecs)
-                 pushSTRLEVecB brless
+                 pushSTRLESeqB brless
                                cbrlets 
-                 pushSTRLEVecB brless
+                 pushSTRLESeqB brless
                                (Just      $
                                 BSC8.pack $
                                 show (1 :: Int))
-                 pushSTRLEVecB brless
+                 pushSTRLESeqB brless
                                Nothing
                  updateSTRLETempB brlets
                                   Nothing             
@@ -184,11 +184,11 @@
                        brlecs
                        brlets
            | otherwise
-           -> do pushSTRLEVecB brless
+           -> do pushSTRLESeqB brless
                                (Just      $
                                 BSC8.pack $
                                 show cbrlecs)
-                 pushSTRLEVecB brless
+                 pushSTRLESeqB brless
                                cbrlets
                  updateSTRLECounterB brlecs
                                      1
@@ -204,24 +204,24 @@
 
 {-toRLE (Text) functions.-}
 
--- | Abstract 'RLEVecT' type utilizing a sequence.
-type RLEVecT = DVB.Vector (Maybe Text)
+-- | Abstract 'RLESeqT' type utilizing a sequence.
+type RLESeqT = Seq (Maybe Text)
 
--- | Abstract data type representing a 'RLEVecT' in the (strict) ST monad.
-type STRLEVecT s a = STRef s RLEVecT
+-- | Abstract data type representing a 'RLESeqT' in the (strict) ST monad.
+type STRLESeqT s a = STRef s RLESeqT
 
--- | State function to push 'RLEVecT' data into stack.
-pushSTRLEVecT :: STRLEVecT s (Maybe Text) -> (Maybe Text) -> ST s ()
-pushSTRLEVecT s Nothing  = do
+-- | State function to push 'RLESeqT' data into stack.
+pushSTRLESeqT :: STRLESeqT s (Maybe Text) -> (Maybe Text) -> ST s ()
+pushSTRLESeqT s Nothing  = do
   s2 <- readSTRef s
-  writeSTRef s (DVB.snoc s2 Nothing)
-pushSTRLEVecT s (Just e) = do
+  writeSTRef s (s2 DS.|> Nothing)
+pushSTRLESeqT s (Just e) = do
   s2 <- readSTRef s
-  writeSTRef s (DVB.snoc s2 (Just e))
+  writeSTRef s (s2 DS.|> Just e)
 
--- | State function to create empty 'STRLEVecT' type.
-emptySTRLEVecT :: ST s (STRLEVecT s a)
-emptySTRLEVecT = newSTRef DVB.empty
+-- | State function to create empty 'STRLESeqT' type.
+emptySTRLESeqT :: ST s (STRLESeqT s a)
+emptySTRLESeqT = newSTRef DS.empty
 
 -- | Abstract 'STRLETempT' state type.
 type STRLETempT s a = STRef s (Maybe Text)
@@ -247,52 +247,52 @@
 emptySTRLECounterT = newSTRef (-1)
 
 -- | Strict state monad function.
-vecToRLET :: RLEVecT ->
-             ST s RLEVecT
-vecToRLET (DVB.uncons -> Nothing)     = do
-  trlevecstackempty  <- emptySTRLEVecT
-  trlevecstackemptyr <- readSTRef trlevecstackempty
-  return trlevecstackemptyr
-vecToRLET (DVB.uncons -> Just (v,vs)) = do
-  trlevecstack     <- emptySTRLEVecT
+seqToRLET :: RLESeqT ->
+             ST s RLESeqT
+seqToRLET DS.Empty      = do
+  trleseqstackempty  <- emptySTRLESeqT
+  trleseqstackemptyr <- readSTRef trleseqstackempty
+  return trleseqstackemptyr
+seqToRLET (x DS.:<| xs) = do
+  trleseqstack     <- emptySTRLESeqT
   trlecounterstack <- emptySTRLECounterT
   trletempstack    <- emptySTRLETempT
   updateSTRLECounterT trlecounterstack
                       1
   updateSTRLETempT trletempstack
-                   v
-  iRLET vs
-        trlevecstack
+                   x
+  iRLET xs
+        trleseqstack
         trlecounterstack
         trletempstack
-  trlevecstackr <- readSTRef trlevecstack
-  return trlevecstackr
+  trleseqstackr <- readSTRef trleseqstack
+  return trleseqstackr
     where
-      iRLET (DVB.uncons -> Nothing)     trless trlecs trlets = do
+      iRLET DS.Empty      trless trlecs trlets = do
         ctrlecs <- readSTRef trlecs
         ctrlets <- readSTRef trlets
-        pushSTRLEVecT trless
+        pushSTRLESeqT trless
                       (Just       $
                        DText.pack $
                        show ctrlecs)
-        pushSTRLEVecT trless
+        pushSTRLESeqT trless
                       ctrlets 
         pure ()
-      iRLET (DVB.uncons -> Just (y,ys)) trless trlecs trlets = do
+      iRLET (y DS.:<| ys) trless trlecs trlets = do
         ctrlecs <- readSTRef trlecs
         ctrlets <- readSTRef trlets
         if | isNothing y
-           -> do pushSTRLEVecT trless
+           -> do pushSTRLESeqT trless
                                (Just       $
                                 DText.pack $
                                 show ctrlecs)
-                 pushSTRLEVecT trless
+                 pushSTRLESeqT trless
                                ctrlets
-                 pushSTRLEVecT trless
+                 pushSTRLESeqT trless
                                (Just       $
                                 DText.pack $
                                 show (1 :: Int))
-                 pushSTRLEVecT trless
+                 pushSTRLESeqT trless
                                Nothing
                  updateSTRLETempT trlets
                                   Nothing
@@ -317,11 +317,11 @@
                        trlecs
                        trlets
            | otherwise
-           -> do pushSTRLEVecT trless
+           -> do pushSTRLESeqT trless
                                (Just       $
                                 DText.pack $
                                 show ctrlecs)
-                 pushSTRLEVecT trless
+                 pushSTRLESeqT trless
                                ctrlets
                  updateSTRLECounterT trlecs
                                      1
@@ -337,69 +337,59 @@
 
 {-fromRLE (ByteString) functions.-}
 
--- | 'DVB.Vector' auxilary function
--- to pattern match on first two elements
--- of a vector.
-unconsb2 :: DVB.Vector a -> Maybe (a,DVB.Vector a,Maybe (DVB.Vector a))
-unconsb2 v = if | DVB.length v < 3
-                -> Just (DVB.unsafeHead v,DVB.drop 1 v,Nothing)
-                | otherwise
-                -> Just (DVB.unsafeHead v,DVB.drop 1 v,Just $ DVB.drop 2 v)
-
--- | Abstract 'FRLEVecB' type utilizing a sequence.
-type FRLEVecB = DVB.Vector (Maybe ByteString)
+-- | Abstract 'FRLESeqB' type utilizing a sequence.
+type FRLESeqB = Seq (Maybe ByteString)
 
--- | Abstract data type representing a 'FRLEVecB' in the (strict) ST monad.
-type FSTRLEVecB s a = STRef s FRLEVecB
+-- | Abstract data type representing a 'FRLESeqB' in the (strict) ST monad.
+type FSTRLESeqB s a = STRef s FRLESeqB
 
--- | State function to push 'FRLEVecB' data into stack.
-pushFSTRLEVecB :: FSTRLEVecB s (Maybe ByteString) -> (Maybe ByteString) -> ST s ()
-pushFSTRLEVecB s Nothing  = do
+-- | State function to push 'FRLESeqB' data into stack.
+pushFSTRLESeqB :: FSTRLESeqB s (Maybe ByteString) -> (Maybe ByteString) -> ST s ()
+pushFSTRLESeqB s Nothing  = do
   s2 <- readSTRef s
-  writeSTRef s (DVB.snoc s2 Nothing)
-pushFSTRLEVecB s (Just e) = do
+  writeSTRef s (s2 DS.|> Nothing)
+pushFSTRLESeqB s (Just e) = do
   s2 <- readSTRef s
-  writeSTRef s (DVB.snoc s2 (Just e))
+  writeSTRef s (s2 DS.|> Just e)
 
--- | State function to create empty 'FSTRLEVecB' type.
-emptyFSTRLEVecB :: ST s (FSTRLEVecB s a)
-emptyFSTRLEVecB = newSTRef DVB.empty
+-- | State function to create empty 'FSTRLESeqB' type.
+emptyFSTRLESeqB :: ST s (FSTRLESeqB s a)
+emptyFSTRLESeqB = newSTRef DS.empty
 
 -- | Strict state monad function.
-vecFromRLEB :: RLEB
-            -> ST s FRLEVecB
-vecFromRLEB (RLEB (DVB.uncons -> Nothing)) = do
-  fbrlevecstackempty  <- emptyFSTRLEVecB
-  fbrlevecstackemptyr <- readSTRef fbrlevecstackempty
-  return fbrlevecstackemptyr
-vecFromRLEB vs                             = do
-  fbrlevecstack <- emptySTRLEVecB
-  let rlebvec = (\(RLEB b) -> b) vs
-  iFRLEB rlebvec
-         fbrlevecstack
-  fbrlevecstackr <- readSTRef fbrlevecstack
-  return fbrlevecstackr
+seqFromRLEB :: RLEB
+            -> ST s FRLESeqB
+seqFromRLEB (RLEB DS.Empty) = do
+  fbrleseqstackempty  <- emptyFSTRLESeqB
+  fbrleseqstackemptyr <- readSTRef fbrleseqstackempty
+  return fbrleseqstackemptyr
+seqFromRLEB xs              = do
+  fbrleseqstack <- emptySTRLESeqB
+  let rlebseq = (\(RLEB b) -> b) xs
+  iFRLEB rlebseq
+         fbrleseqstack
+  fbrleseqstackr <- readSTRef fbrleseqstack
+  return fbrleseqstackr
     where
-      iFRLEB (unconsb2 -> Just (y1,y2,Nothing)) fbrless =
+      iFRLEB (y1 DS.:<| y2 DS.:<| DS.Empty) fbrless =
         if | isJust y1    &&
-             isNothing (DVB.head y2)
-           -> do pushFSTRLEVecB fbrless
+             isNothing y2
+           -> do pushFSTRLESeqB fbrless
                                 Nothing
                  pure () 
            | otherwise
            -> do let y1' = read        $
                            BSC8.unpack $
                            fromJust y1 :: Int
-                 let y2' = fromJust $
-                           DVB.head y2
+                 let y2' = fromJust y2
                  CM.replicateM_ y1'
-                                (pushFSTRLEVecB fbrless
+                                (pushFSTRLESeqB fbrless
                                                 (Just y2'))
                  pure () 
-      iFRLEB (unconsb2 -> Just (y1,y2,Just ys)) fbrless =
+      iFRLEB (y1 DS.:<| y2 DS.:<| ys)       fbrless =
         if | isJust y1     &&
-             isNothing (DVB.head y2)
-           -> do pushFSTRLEVecB fbrless
+             isNothing y2
+           -> do pushFSTRLESeqB fbrless
                                 Nothing
                  iFRLEB ys
                         fbrless
@@ -407,82 +397,74 @@
            -> do let y1' = read        $
                            BSC8.unpack $
                            fromJust y1 :: Int
-                 let y2' = fromJust $
-                           DVB.head y2
+                 let y2' = fromJust y2
                  CM.replicateM_ y1'
-                                (pushFSTRLEVecB fbrless
+                                (pushFSTRLESeqB fbrless
                                                 (Just y2'))
                  iFRLEB ys
-                        fbrless
+                        fbrless 
+      iFRLEB (DSI.Seq EmptyT)               _       = pure ()
+      iFRLEB (DSI.Seq (Single _))           _       = pure ()
+      iFRLEB (DSI.Seq (Deep _ _ _ _))       _       = pure ()
 
 {---------------------------------}
 
 
 {-fromRLE (Text) functions.-}
 
--- | 'DVB.Vector' auxilary function
--- to pattern match on first two elements
--- of a vector.
-unconst2 :: DVB.Vector a -> Maybe (a,DVB.Vector a, Maybe (DVB.Vector a))
-unconst2 v = if | DVB.length v < 3
-                -> Just (DVB.unsafeHead v,DVB.drop 1 v,Nothing)
-                | otherwise
-                -> Just (DVB.unsafeHead v, DVB.drop 1 v,Just $ DVB.drop 2 v)
-
--- | Abstract 'FRLEVecT' type utilizing a sequence.
-type FRLEVecT = DVB.Vector (Maybe Text)
+-- | Abstract 'FRLESeqT' type utilizing a sequence.
+type FRLESeqT = Seq (Maybe Text)
 
--- | Abstract data type representing a 'FRLEVecT' in the (strict) ST monad.
-type FSTRLEVecT s a = STRef s FRLEVecT
+-- | Abstract data type representing a 'FRLESeqT' in the (strict) ST monad.
+type FSTRLESeqT s a = STRef s FRLESeqT
 
--- | State function to push 'FSTRLEVecT' data into stack.
-pushFSTRLEVecT :: FSTRLEVecT s (Maybe Text) -> (Maybe Text) -> ST s ()
-pushFSTRLEVecT s Nothing  = do
+-- | State function to push 'FSTRLESeqT' data into stack.
+pushFSTRLESeqT :: FSTRLESeqT s (Maybe Text) -> (Maybe Text) -> ST s ()
+pushFSTRLESeqT s Nothing  = do
   s2 <- readSTRef s
-  writeSTRef s (DVB.snoc s2 Nothing)
-pushFSTRLEVecT s (Just e) = do
+  writeSTRef s (s2 DS.|> Nothing)
+pushFSTRLESeqT s (Just e) = do
   s2 <- readSTRef s
-  writeSTRef s (DVB.snoc s2 (Just e))
+  writeSTRef s (s2 DS.|> Just e)
 
--- | State function to create empty 'FSTRLEVecT' type.
-emptyFSTRLEVecT :: ST s (FSTRLEVecT s a)
-emptyFSTRLEVecT = newSTRef DVB.empty
+-- | State function to create empty 'FSTRLESeqT' type.
+emptyFSTRLESeqT :: ST s (FSTRLESeqT s a)
+emptyFSTRLESeqT = newSTRef DS.empty
 
 -- | Strict state monad function.
-vecFromRLET :: RLET ->
-               ST s FRLEVecT
-vecFromRLET (RLET (DVB.uncons -> Nothing)) = do
-  ftrlevecstackempty  <- emptyFSTRLEVecT
-  ftrlevecstackemptyr <- readSTRef ftrlevecstackempty
-  return ftrlevecstackemptyr
-vecFromRLET vs                             = do
-  ftrlevecstack <- emptySTRLEVecT
-  let rletvec = (\(RLET t) -> t) vs
-  iFRLET rletvec
-         ftrlevecstack
-  ftrlevecstackr <- readSTRef ftrlevecstack
-  return ftrlevecstackr
-    where 
-      iFRLET (unconst2 -> Just (y1,y2,Nothing)) ftrless =
+seqFromRLET :: RLET ->
+               ST s FRLESeqT
+seqFromRLET (RLET DS.Empty) = do
+  ftrleseqstackempty  <- emptyFSTRLESeqT
+  ftrleseqstackemptyr <- readSTRef ftrleseqstackempty
+  return ftrleseqstackemptyr
+seqFromRLET xs              = do
+  ftrleseqstack <- emptySTRLESeqT
+  let rletseq = (\(RLET t) -> t) xs
+  iFRLET rletseq
+         ftrleseqstack
+  ftrleseqstackr <- readSTRef ftrleseqstack
+  return ftrleseqstackr
+    where
+      iFRLET (y1 DS.:<| y2 DS.:<| DS.Empty) ftrless =
         if | isJust y1    &&
-             isNothing (DVB.head y2)
-           -> do pushFSTRLEVecT ftrless
+             isNothing y2
+           -> do pushFSTRLESeqT ftrless
                                 Nothing
                  pure ()
            | otherwise
            -> do let y1' = read         $
                            DText.unpack $
                            fromJust y1 :: Int
-                 let y2' = fromJust $
-                           DVB.head y2
+                 let y2' = fromJust y2
                  CM.replicateM_ y1'
-                                (pushFSTRLEVecT ftrless
+                                (pushFSTRLESeqT ftrless
                                                 (Just y2'))
                  pure ()
-      iFRLET (unconst2 -> Just (y1,y2,Just ys)) ftrless =
+      iFRLET (y1 DS.:<| y2 DS.:<| ys)       ftrless =
         if | isJust y1     &&
-             isNothing (DVB.head y2)
-           -> do pushFSTRLEVecT ftrless
+             isNothing y2
+           -> do pushFSTRLESeqT ftrless
                                 Nothing
                  iFRLET ys
                         ftrless
@@ -490,12 +472,14 @@
            -> do let y1' = read         $
                            DText.unpack $
                            fromJust y1 :: Int
-                 let y2' = fromJust $
-                           DVB.head y2
+                 let y2' = fromJust y2
                  CM.replicateM_ y1'
-                                (pushFSTRLEVecT ftrless
+                                (pushFSTRLESeqT ftrless
                                                 (Just y2'))
                  iFRLET ys
                         ftrless
+      iFRLET (DSI.Seq EmptyT)               _       = pure ()
+      iFRLET (DSI.Seq (Single _))           _       = pure ()
+      iFRLET (DSI.Seq (Deep _ _ _ _))       _       = pure ()
 
 {---------------------------}
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.8
+version:            0.1.0.9
 
 -- A short (one-line) description of the package.
 synopsis:           A text compression library.
@@ -76,14 +76,12 @@
     -- other-extensions:
 
     -- Other library packages from which modules are imported.
-    build-depends:    base              ^>=4.16.3.0, 
-                      bytestring        >= 0.11.3 && < 0.12,
-                      containers        >= 0.6.5 && < 0.7,
-                      massiv            >= 1.0.2 && < 1.1,
-                      mtl               >= 2.2.2 && < 2.3,
-                      text              >= 1.2.5 && < 1.3,
-                      vector            >= 0.13.0 && < 0.14,
-                      vector-algorithms >= 0.9.0 && < 0.10
+    build-depends:    base       ^>=4.16.3.0,
+                      bytestring >= 0.11.3 && < 0.12,
+                      containers >= 0.6.5 && < 0.7,
+                      massiv     >= 1.0.2 && < 1.1,
+                      mtl        >= 2.2.2 && < 2.3,
+                      text       >= 1.2.5 && < 1.3
 
     -- Directories containing source files.
     hs-source-dirs:   src