diff --git a/cbits/simd.h b/cbits/simd.h
--- a/cbits/simd.h
+++ b/cbits/simd.h
@@ -11,13 +11,7 @@
 
 void avx2_cmpeq8(
     uint8_t byte,
-    uint64_t *target,
-    size_t target_length,
-    uint8_t *source);
-
-void avx2_cmpeq8(
-    uint8_t byte,
-    uint64_t *target,
+    uint8_t *target,
     size_t target_length,
     uint8_t *source);
 
diff --git a/cbits/simd_avx2.c b/cbits/simd_avx2.c
--- a/cbits/simd_avx2.c
+++ b/cbits/simd_avx2.c
@@ -33,7 +33,7 @@
 
 void avx2_cmpeq8(
     uint8_t byte,
-    uint64_t *target,
+    uint8_t *target,
     size_t target_length,
     uint8_t *source) {
 #if defined(AVX2_ENABLED)
diff --git a/hw-simd.cabal b/hw-simd.cabal
--- a/hw-simd.cabal
+++ b/hw-simd.cabal
@@ -3,7 +3,7 @@
 -- see: https://github.com/sol/hpack
 
 name:           hw-simd
-version:        0.1.0.3
+version:        0.1.1.0
 synopsis:       SIMD library
 description:    Please see the README on Github at <https://github.com/haskell-works/hw-simd#readme>
 category:       Data, Bit, SIMD
@@ -60,7 +60,7 @@
     , hw-bits               >= 0.7.0.2  && < 0.8
     , hw-rankselect         >= 0.12.0.2 && < 0.13
     , hw-rankselect-base    >= 0.3.2.0  && < 0.4
-    , hw-prim               >= 0.6.2.0  && < 0.7
+    , hw-prim               >= 0.6.2.12 && < 0.7
     , vector                >= 0.12.0.1 && < 0.13
   build-tools:
       c2hs
@@ -84,11 +84,13 @@
       , semigroups            >= 0.8.4      && < 0.19
   exposed-modules:
       HaskellWorks.Data.Simd.Capabilities
+      HaskellWorks.Data.Simd.ChunkString
       HaskellWorks.Data.Simd.Comparison
       HaskellWorks.Data.Simd.Comparison.Avx2
       HaskellWorks.Data.Simd.Comparison.Stock
       HaskellWorks.Data.Simd.Internal.Bits
       HaskellWorks.Data.Simd.Internal.Broadword
+      HaskellWorks.Data.Simd.Internal.ChunkString
       HaskellWorks.Data.Simd.Internal.Foreign
       HaskellWorks.Data.Simd.Internal.Marshal
       HaskellWorks.Data.Simd.Logical
@@ -112,7 +114,7 @@
     , hw-bits               >= 0.7.0.2  && < 0.8
     , hw-rankselect         >= 0.12.0.2 && < 0.13
     , hw-rankselect-base    >= 0.3.2.0  && < 0.4
-    , hw-prim               >= 0.6.2.0  && < 0.7
+    , hw-prim               >= 0.6.2.12 && < 0.7
     , vector                >= 0.12.0.1 && < 0.13
     , directory               >= 1.2.2      && < 1.4
     , lens
@@ -160,7 +162,7 @@
     , hw-bits               >= 0.7.0.2  && < 0.8
     , hw-rankselect         >= 0.12.0.2 && < 0.13
     , hw-rankselect-base    >= 0.3.2.0  && < 0.4
-    , hw-prim               >= 0.6.2.0  && < 0.7
+    , hw-prim               >= 0.6.2.12 && < 0.7
     , vector                >= 0.12.0.1 && < 0.13
     , cassava               >= 0.5.1.0    && < 0.6
     , containers
diff --git a/src/HaskellWorks/Data/Simd/ChunkString.hs b/src/HaskellWorks/Data/Simd/ChunkString.hs
new file mode 100644
--- /dev/null
+++ b/src/HaskellWorks/Data/Simd/ChunkString.hs
@@ -0,0 +1,14 @@
+module HaskellWorks.Data.Simd.ChunkString
+  ( ChunkString
+  , ToChunkString(..)
+  , hGetContents
+  ) where
+
+import HaskellWorks.Data.Simd.Internal.ChunkString
+
+import qualified HaskellWorks.Data.ByteString as BS
+import qualified System.IO                    as IO
+
+hGetContents :: IO.Handle -> IO ChunkString
+hGetContents = (ChunkString <$>) . BS.hGetContentsChunkedBy chunkSize
+{-# INLINE hGetContents #-}
diff --git a/src/HaskellWorks/Data/Simd/Comparison/Avx2.hs b/src/HaskellWorks/Data/Simd/Comparison/Avx2.hs
--- a/src/HaskellWorks/Data/Simd/Comparison/Avx2.hs
+++ b/src/HaskellWorks/Data/Simd/Comparison/Avx2.hs
@@ -1,26 +1,53 @@
 {-# LANGUAGE CPP               #-}
 {-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE TypeFamilies      #-}
 
 module HaskellWorks.Data.Simd.Comparison.Avx2 where
 
-import Data.Monoid ((<>))
+import Control.Monad
+import Data.Monoid   ((<>))
 import Data.Word
 
+import qualified Data.ByteString                         as BS
 import qualified Data.Vector.Storable                    as DVS
 import qualified Foreign.ForeignPtr                      as F
 import qualified Foreign.Marshal.Unsafe                  as F
 import qualified Foreign.Ptr                             as F
+import qualified HaskellWorks.Data.ByteString            as BS
 import qualified HaskellWorks.Data.Simd.Internal.Foreign as F
+import qualified HaskellWorks.Data.Vector.AsVector8      as V
+import qualified HaskellWorks.Data.Vector.Storable       as DVS
 
 {-# ANN module ("HLint: ignore Redundant do"        :: String) #-}
 
 class CmpEqWord8s a where
-  cmpEqWord8s :: Word8 -> a -> a
+  type Target a
+  cmpEqWord8s :: Word8 -> a -> Target a
 
 instance CmpEqWord8s (DVS.Vector Word8) where
-  cmpEqWord8s w8 v = DVS.unsafeCast (cmpEqWord8s w8 (DVS.unsafeCast v :: DVS.Vector Word64))
+  type Target (DVS.Vector Word8) = DVS.Vector Word8
+  cmpEqWord8s w8 v = F.unsafeLocalState $ do
+    tgtFptr <- F.mallocForeignPtrBytes bufLen
+    F.withForeignPtr srcFptr $ \srcPtr -> do
+      F.withForeignPtr tgtFptr $ \tgtPtr -> do
+        _ <- F.avx2Cmpeq8 (fromIntegral w8) (F.castPtr tgtPtr) (fromIntegral w64sLen) (srcPtr `F.plusPtr` srcOffset)
+        when (disalignment /= 0) $ do
+          let ending = DVS.padded ((DVS.length v + 63) `div` 64)  (DVS.drop alignment v)
+          let (endFptr, _, _) = DVS.unsafeToForeignPtr ending
+          F.withForeignPtr endFptr $ \endPtr -> do
+            void $ F.avx2Cmpeq8 (fromIntegral w8) (tgtPtr `F.plusPtr` (w64sLen * 64)) (fromIntegral w64sLen) (F.castPtr endPtr)
 
+        return $ DVS.unsafeFromForeignPtr tgtFptr 0 tgtLen
+    where (srcFptr, srcOffset, srcLen) = DVS.unsafeToForeignPtr v
+          bufLen        = (srcLen + 63) `div` 8
+          tgtLen        = (srcLen + 7) `div` 8
+          w64sLen       = srcLen `div` 64
+          alignment     = w64sLen * 64
+          disalignment  = srcLen - alignment
+  {-# INLINE cmpEqWord8s #-}
+
 instance CmpEqWord8s (DVS.Vector Word64) where
+  type Target (DVS.Vector Word64) = DVS.Vector Word64
   cmpEqWord8s w8 v = case DVS.unsafeCast v :: DVS.Vector Word8 of
     u -> case DVS.unsafeToForeignPtr u of
       (srcFptr, srcOffset, srcLength) -> if disalignment == 0
@@ -40,9 +67,21 @@
   {-# INLINE cmpEqWord8s #-}
 
 instance CmpEqWord8s [DVS.Vector Word64] where
+  type Target [DVS.Vector Word64] = [DVS.Vector Word64]
   cmpEqWord8s w8 vs = cmpEqWord8s w8 <$> vs
   {-# INLINE cmpEqWord8s #-}
 
 instance CmpEqWord8s [DVS.Vector Word8] where
+  type Target [DVS.Vector Word8] = [DVS.Vector Word8]
   cmpEqWord8s w8 vs = cmpEqWord8s w8 <$> vs
   {-# INLINE cmpEqWord8s #-}
+
+instance CmpEqWord8s [BS.ByteString] where
+  type Target [BS.ByteString] = [BS.ByteString]
+  cmpEqWord8s w8 vs = BS.toByteString . cmpEqWord8s w8 . V.asVector8 <$> vs
+  {-# INLINE cmpEqWord8s #-}
+
+-- instance CmpEqWord8s CS.ChunkString where
+--   type Target CS.ChunkString = CS.ChunkString
+--   cmpEqWord8s w8 = CS.toChunkString . cmpEqWord8s w8 . BS.toByteStrings
+--   {-# INLINE cmpEqWord8s #-}
diff --git a/src/HaskellWorks/Data/Simd/Comparison/Stock.hs b/src/HaskellWorks/Data/Simd/Comparison/Stock.hs
--- a/src/HaskellWorks/Data/Simd/Comparison/Stock.hs
+++ b/src/HaskellWorks/Data/Simd/Comparison/Stock.hs
@@ -10,7 +10,11 @@
 import HaskellWorks.Data.Simd.Internal.Bits
 import HaskellWorks.Data.Simd.Internal.Broadword
 
-import qualified Data.Vector.Storable as DVS
+import qualified Data.ByteString                    as BS
+import qualified Data.Vector.Storable               as DVS
+import qualified HaskellWorks.Data.ByteString       as BS
+import qualified HaskellWorks.Data.Simd.ChunkString as CS
+import qualified HaskellWorks.Data.Vector.AsVector8 as V
 
 class CmpEqWord8s a where
   cmpEqWord8s :: Word8 -> a -> a
@@ -70,3 +74,10 @@
   cmpEqWord8s w8 vs = cmpEqWord8s w8 <$> vs
   {-# INLINE cmpEqWord8s #-}
 
+instance CmpEqWord8s [BS.ByteString] where
+  cmpEqWord8s w8 vs = BS.toByteString . cmpEqWord8s w8 . V.asVector8 <$> vs
+  {-# INLINE cmpEqWord8s #-}
+
+instance CmpEqWord8s CS.ChunkString where
+  cmpEqWord8s w8 = CS.toChunkString . cmpEqWord8s w8 . BS.toByteStrings
+  {-# INLINE cmpEqWord8s #-}
diff --git a/src/HaskellWorks/Data/Simd/Internal/ChunkString.hs b/src/HaskellWorks/Data/Simd/Internal/ChunkString.hs
new file mode 100644
--- /dev/null
+++ b/src/HaskellWorks/Data/Simd/Internal/ChunkString.hs
@@ -0,0 +1,102 @@
+{-# LANGUAGE CPP               #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module HaskellWorks.Data.Simd.Internal.ChunkString where
+
+import Data.Word
+import HaskellWorks.Data.AtIndex
+import HaskellWorks.Data.Bits.BitWise
+import HaskellWorks.Data.ByteString
+import HaskellWorks.Data.ByteString.Lazy
+
+import qualified Data.ByteString              as BS
+import qualified Data.ByteString.Lazy         as LBS
+import qualified Data.Vector.Storable         as DVS
+import qualified HaskellWorks.Data.ByteString as BS
+
+newtype ChunkString = ChunkString
+  { chunks :: [BS.ByteString]
+  } deriving (Eq, Show)
+
+instance ToLazyByteString ChunkString where
+  toLazyByteString (ChunkString cs) = LBS.fromChunks cs
+
+instance ToByteStrings ChunkString where
+  toByteStrings (ChunkString bss) = bss
+
+class ToChunkString a where
+  toChunkString :: a -> ChunkString
+
+instance ToChunkString LBS.ByteString where
+  toChunkString = toChunkString . LBS.toChunks
+
+instance ToChunkString [BS.ByteString] where
+  toChunkString = ChunkString . BS.rechunk chunkSize
+
+instance ToChunkString [DVS.Vector Word8] where
+  toChunkString = toChunkString . (toByteString <$>)
+
+instance ToChunkString [DVS.Vector Word16] where
+  toChunkString = toChunkString . (toByteString <$>)
+
+instance ToChunkString [DVS.Vector Word32] where
+  toChunkString = toChunkString . (toByteString <$>)
+
+instance ToChunkString [DVS.Vector Word64] where
+  toChunkString = toChunkString . (toByteString <$>)
+
+instance ToChunkString (DVS.Vector Word8) where
+  toChunkString v = toChunkString [toByteString v]
+
+instance ToChunkString (DVS.Vector Word16) where
+  toChunkString v = toChunkString [toByteString v]
+
+instance ToChunkString (DVS.Vector Word32) where
+  toChunkString v = toChunkString [toByteString v]
+
+instance ToChunkString (DVS.Vector Word64) where
+  toChunkString v = toChunkString [toByteString v]
+
+#if 0
+instance BitWise ChunkString where
+  ChunkString (a:as) .&. ChunkString (b:bs) = ChunkString (c:cs)
+    where len             = end a `min` end b
+          c               = toByteString $ DVS.constructN (fromIntegral len) go
+          ChunkString cs  = ChunkString as .&. ChunkString bs
+          go u            = let ui = end u in (a !!! ui) .&. (b !!! ui)
+  ChunkString _ .&. ChunkString _ = ChunkString []
+  {-# INLINE (.&.) #-}
+
+  ChunkString (a:as) .|. ChunkString (b:bs) = ChunkString (c:cs)
+    where len             = end a `min` end b
+          c               = toByteString $ DVS.constructN (fromIntegral len) go
+          ChunkString cs  = ChunkString as .|. ChunkString bs
+          go u            = let ui = end u in (a !!! ui) .&. (b !!! ui)
+  ChunkString _ .|. ChunkString _ = ChunkString []
+  {-# INLINE (.|.) #-}
+
+  ChunkString (a:as) .^. ChunkString (b:bs) = ChunkString (c:cs)
+    where len             = end a `min` end b
+          c               = toByteString $ DVS.constructN (fromIntegral len) go
+          ChunkString cs  = ChunkString as .^. ChunkString bs
+          go u            = let ui = end u in (a !!! ui) .&. (b !!! ui)
+  ChunkString _ .^. ChunkString _ = ChunkString []
+  {-# INLINE (.^.) #-}
+
+  comp (ChunkString (a:as)) = ChunkString (c:cs)
+    where c               = toByteString $ DVS.constructN (fromIntegral (end a)) go
+          ChunkString cs  = comp (ChunkString as)
+          go u            = let ui = end u in comp (a !!! ui)
+  comp (ChunkString _) = ChunkString []
+  {-# INLINE comp #-}
+
+  all0s = ChunkString $ repeat $ toByteString $ DVS.replicate chunkSize (0x00 :: Word8)
+  {-# INLINE all0s #-}
+
+  all1s = ChunkString $ repeat $ toByteString $ DVS.replicate chunkSize (0xff :: Word8)
+  {-# INLINE all1s #-}
+#endif
+
+chunkSize :: Int
+chunkSize = 32 * 1024 - 64
+{-# INLINE chunkSize #-}
diff --git a/src/HaskellWorks/Data/Simd/Internal/Foreign.chs b/src/HaskellWorks/Data/Simd/Internal/Foreign.chs
--- a/src/HaskellWorks/Data/Simd/Internal/Foreign.chs
+++ b/src/HaskellWorks/Data/Simd/Internal/Foreign.chs
@@ -16,7 +16,7 @@
   {#call unsafe avx2_memcpy as c_build_ibs#} target source len
 {-# INLINE avx2Memcpy #-}
 
-avx2Cmpeq8 :: UInt8 -> Ptr UInt64 -> Size -> Ptr UInt8 -> IO ()
+avx2Cmpeq8 :: UInt8 -> Ptr UInt8 -> Size -> Ptr UInt8 -> IO ()
 avx2Cmpeq8 byte target targetLength source = requireAvx2 $ do
   {#call unsafe avx2_cmpeq8 as c_cmpeq8#} byte target targetLength source
 {-# INLINE avx2Cmpeq8 #-}