{-# LANGUAGE CPP                 #-}
{-# LANGUAGE FlexibleInstances   #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeFamilies        #-}

module HaskellWorks.Data.Simd.Comparison.Avx2 where

import Control.Monad
import Data.Word

import qualified Data.ByteString                         as BS
import qualified Data.Vector                             as DV
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.ChunkString      as CS
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

{- HLINT ignore "Redundant do"        -}

class CmpEqWord8s a where
  type Target a
  cmpEqWord8s :: Word8 -> a -> Target a

instance CmpEqWord8s (DVS.Vector Word8) where
  type Target (DVS.Vector Word8) = DVS.Vector Word8
  cmpEqWord8s :: Word8 -> Vector Word8 -> Target (Vector Word8)
cmpEqWord8s Word8
w8 Vector Word8
v = IO (Vector Word8) -> Vector Word8
forall a. IO a -> a
F.unsafeLocalState (IO (Vector Word8) -> Vector Word8)
-> IO (Vector Word8) -> Vector Word8
forall a b. (a -> b) -> a -> b
$ do
    ForeignPtr Word8
tgtFptr <- Int -> IO (ForeignPtr Word8)
forall a. Int -> IO (ForeignPtr a)
F.mallocForeignPtrBytes Int
bufLen
    ForeignPtr Word8
-> (Ptr Word8 -> IO (Vector Word8)) -> IO (Vector Word8)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
F.withForeignPtr ForeignPtr Word8
srcFptr ((Ptr Word8 -> IO (Vector Word8)) -> IO (Vector Word8))
-> (Ptr Word8 -> IO (Vector Word8)) -> IO (Vector Word8)
forall a b. (a -> b) -> a -> b
$ \Ptr Word8
srcPtr -> do
      ForeignPtr Word8
-> (Ptr Word8 -> IO (Vector Word8)) -> IO (Vector Word8)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
F.withForeignPtr ForeignPtr Word8
tgtFptr ((Ptr Word8 -> IO (Vector Word8)) -> IO (Vector Word8))
-> (Ptr Word8 -> IO (Vector Word8)) -> IO (Vector Word8)
forall a b. (a -> b) -> a -> b
$ \Ptr Word8
tgtPtr -> do
        ()
_ <- UInt8 -> Ptr UInt8 -> Size -> Ptr UInt8 -> IO ()
F.avx2Cmpeq8 (Word8 -> UInt8
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
w8) (Ptr Word8 -> Ptr UInt8
forall a b. Ptr a -> Ptr b
F.castPtr Ptr Word8
tgtPtr) (Int -> Size
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
w64sLen) (Ptr Word8
srcPtr Ptr Word8 -> Int -> Ptr UInt8
forall a b. Ptr a -> Int -> Ptr b
`F.plusPtr` Int
srcOffset)
        Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Int
disalignment Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
0) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ do
          let ending :: Vector Word8
ending = Int -> Vector Word8 -> Vector Word8
DVS.padded ((Vector Word8 -> Int
forall a. Storable a => Vector a -> Int
DVS.length Vector Word8
v Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
63) Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
64)  (Int -> Vector Word8 -> Vector Word8
forall a. Storable a => Int -> Vector a -> Vector a
DVS.drop Int
alignment Vector Word8
v)
          let (ForeignPtr Word8
endFptr, Int
_, Int
_) = Vector Word8 -> (ForeignPtr Word8, Int, Int)
forall a. Storable a => Vector a -> (ForeignPtr a, Int, Int)
DVS.unsafeToForeignPtr Vector Word8
ending
          ForeignPtr Word8 -> (Ptr Word8 -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
F.withForeignPtr ForeignPtr Word8
endFptr ((Ptr Word8 -> IO ()) -> IO ()) -> (Ptr Word8 -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Word8
endPtr -> do
            IO () -> IO ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$ UInt8 -> Ptr UInt8 -> Size -> Ptr UInt8 -> IO ()
F.avx2Cmpeq8 (Word8 -> UInt8
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
w8) (Ptr Word8
tgtPtr Ptr Word8 -> Int -> Ptr UInt8
forall a b. Ptr a -> Int -> Ptr b
`F.plusPtr` (Int
w64sLen Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
8)) (Int -> Size
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
disalignment) (Ptr Word8 -> Ptr UInt8
forall a b. Ptr a -> Ptr b
F.castPtr Ptr Word8
endPtr)

        Vector Word8 -> IO (Vector Word8)
forall (m :: * -> *) a. Monad m => a -> m a
return (Vector Word8 -> IO (Vector Word8))
-> Vector Word8 -> IO (Vector Word8)
forall a b. (a -> b) -> a -> b
$ ForeignPtr Word8 -> Int -> Int -> Vector Word8
forall a. Storable a => ForeignPtr a -> Int -> Int -> Vector a
DVS.unsafeFromForeignPtr ForeignPtr Word8
tgtFptr Int
0 Int
tgtLen
    where (ForeignPtr Word8
srcFptr, Int
srcOffset, Int
srcLen) = Vector Word8 -> (ForeignPtr Word8, Int, Int)
forall a. Storable a => Vector a -> (ForeignPtr a, Int, Int)
DVS.unsafeToForeignPtr Vector Word8
v
          bufLen :: Int
bufLen        = (Int
srcLen Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
63) Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
8
          tgtLen :: Int
tgtLen        = (Int
srcLen Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
7) Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
8
          w64sLen :: Int
w64sLen       = Int
srcLen Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
64
          alignment :: Int
alignment     = Int
w64sLen Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
64
          disalignment :: Int
disalignment  = Int
srcLen Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
alignment
  {-# INLINE cmpEqWord8s #-}

instance CmpEqWord8s (DVS.Vector Word64) where
  type Target (DVS.Vector Word64) = DVS.Vector Word64
  cmpEqWord8s :: Word8 -> Vector Word64 -> Target (Vector Word64)
cmpEqWord8s Word8
w8 Vector Word64
v = case Vector Word64 -> Vector Word8
forall a b. (Storable a, Storable b) => Vector a -> Vector b
DVS.unsafeCast Vector Word64
v :: DVS.Vector Word8 of
    Vector Word8
u -> case Vector Word8 -> (ForeignPtr Word8, Int, Int)
forall a. Storable a => Vector a -> (ForeignPtr a, Int, Int)
DVS.unsafeToForeignPtr Vector Word8
u of
      (ForeignPtr Word8
srcFptr, Int
srcOffset, Int
srcLength) -> if Int
disalignment Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0
        then IO (Vector Word64) -> Vector Word64
forall a. IO a -> a
F.unsafeLocalState (IO (Vector Word64) -> Vector Word64)
-> IO (Vector Word64) -> Vector Word64
forall a b. (a -> b) -> a -> b
$ do
          ForeignPtr Word64
targetFptr <- Int -> IO (ForeignPtr Word64)
forall a. Int -> IO (ForeignPtr a)
F.mallocForeignPtrBytes Int
srcLength
          ForeignPtr Word8
-> (Ptr Word8 -> IO (Vector Word64)) -> IO (Vector Word64)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
F.withForeignPtr ForeignPtr Word8
srcFptr ((Ptr Word8 -> IO (Vector Word64)) -> IO (Vector Word64))
-> (Ptr Word8 -> IO (Vector Word64)) -> IO (Vector Word64)
forall a b. (a -> b) -> a -> b
$ \Ptr Word8
srcPtr -> do
            ForeignPtr Word64
-> (Ptr Word64 -> IO (Vector Word64)) -> IO (Vector Word64)
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
F.withForeignPtr ForeignPtr Word64
targetFptr ((Ptr Word64 -> IO (Vector Word64)) -> IO (Vector Word64))
-> (Ptr Word64 -> IO (Vector Word64)) -> IO (Vector Word64)
forall a b. (a -> b) -> a -> b
$ \Ptr Word64
targetPtr -> do
              ()
_ <- UInt8 -> Ptr UInt8 -> Size -> Ptr UInt8 -> IO ()
F.avx2Cmpeq8
                (Word8 -> UInt8
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
w8)
                (Ptr Word64 -> Ptr UInt8
forall a b. Ptr a -> Ptr b
F.castPtr Ptr Word64
targetPtr)
                (Int -> Size
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
w64sLen)
                (Ptr Word8 -> Ptr Any
forall a b. Ptr a -> Ptr b
F.castPtr Ptr Word8
srcPtr Ptr Any -> Int -> Ptr UInt8
forall a b. Ptr a -> Int -> Ptr b
`F.plusPtr` Int
srcOffset)
              Vector Word64 -> IO (Vector Word64)
forall (m :: * -> *) a. Monad m => a -> m a
return (Vector Word64 -> IO (Vector Word64))
-> Vector Word64 -> IO (Vector Word64)
forall a b. (a -> b) -> a -> b
$ ForeignPtr Word64 -> Int -> Int -> Vector Word64
forall a. Storable a => ForeignPtr a -> Int -> Int -> Vector a
DVS.unsafeFromForeignPtr ForeignPtr Word64
targetFptr Int
0 Int
w64sLen
        else [Char] -> Vector Word64
forall a. HasCallStack => [Char] -> a
error ([Char] -> Vector Word64) -> [Char] -> Vector Word64
forall a b. (a -> b) -> a -> b
$ [Char]
"Unaligned byte string: " [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> Int -> [Char]
forall a. Show a => a -> [Char]
show Int
disalignment
        where w64sLen :: Int
w64sLen       = Int
srcLength Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
64
              disalignment :: Int
disalignment  = Int
srcLength Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
w64sLen Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
64
  {-# INLINE cmpEqWord8s #-}

instance CmpEqWord8s [DVS.Vector Word64] where
  type Target [DVS.Vector Word64] = [DVS.Vector Word64]
  cmpEqWord8s :: Word8 -> [Vector Word64] -> Target [Vector Word64]
cmpEqWord8s Word8
w8 [Vector Word64]
vs = Word8 -> Vector Word64 -> Target (Vector Word64)
forall a. CmpEqWord8s a => Word8 -> a -> Target a
cmpEqWord8s Word8
w8 (Vector Word64 -> Vector Word64)
-> [Vector Word64] -> [Vector Word64]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Vector Word64]
vs
  {-# INLINE cmpEqWord8s #-}

instance CmpEqWord8s [DVS.Vector Word8] where
  type Target [DVS.Vector Word8] = [DVS.Vector Word8]
  cmpEqWord8s :: Word8 -> [Vector Word8] -> Target [Vector Word8]
cmpEqWord8s Word8
w8 [Vector Word8]
vs = Word8 -> Vector Word8 -> Target (Vector Word8)
forall a. CmpEqWord8s a => Word8 -> a -> Target a
cmpEqWord8s Word8
w8 (Vector Word8 -> Vector Word8) -> [Vector Word8] -> [Vector Word8]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Vector Word8]
vs
  {-# INLINE cmpEqWord8s #-}

instance CmpEqWord8s [BS.ByteString] where
  type Target [BS.ByteString] = [BS.ByteString]
  cmpEqWord8s :: Word8 -> [ByteString] -> Target [ByteString]
cmpEqWord8s Word8
w8 [ByteString]
vs = Vector Word8 -> ByteString
forall a. ToByteString a => a -> ByteString
BS.toByteString (Vector Word8 -> ByteString)
-> (ByteString -> Vector Word8) -> ByteString -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Vector Word8 -> Target (Vector Word8)
forall a. CmpEqWord8s a => Word8 -> a -> Target a
cmpEqWord8s Word8
w8 (Vector Word8 -> Vector Word8)
-> (ByteString -> Vector Word8) -> ByteString -> Vector Word8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Vector Word8
forall a. AsVector8 a => a -> Vector Word8
V.asVector8 (ByteString -> ByteString) -> [ByteString] -> [ByteString]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [ByteString]
vs
  {-# INLINE cmpEqWord8s #-}

instance CmpEqWord8s CS.ChunkString where
  type Target CS.ChunkString = CS.ChunkString
  cmpEqWord8s :: Word8 -> ChunkString -> Target ChunkString
cmpEqWord8s Word8
w8 = [ByteString] -> ChunkString
forall a. ToChunkString a => a -> ChunkString
CS.toChunkString ([ByteString] -> ChunkString)
-> (ChunkString -> [ByteString]) -> ChunkString -> ChunkString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> [ByteString] -> Target [ByteString]
forall a. CmpEqWord8s a => Word8 -> a -> Target a
cmpEqWord8s Word8
w8 ([ByteString] -> [ByteString])
-> (ChunkString -> [ByteString]) -> ChunkString -> [ByteString]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ChunkString -> [ByteString]
forall a. ToByteStrings a => a -> [ByteString]
BS.toByteStrings
  {-# INLINE cmpEqWord8s #-}

class CmpEqWord8sPara a where
  type CmpEqWord8sParaTarget a
  cmpEqWord8sPara :: DVS.Vector Word8 -> a -> CmpEqWord8sParaTarget a

instance CmpEqWord8sPara (DVS.Vector Word64) where
  type CmpEqWord8sParaTarget (DVS.Vector Word64) = DV.Vector (DVS.Vector Word64)
  cmpEqWord8sPara :: Vector Word8
-> Vector Word64 -> CmpEqWord8sParaTarget (Vector Word64)
cmpEqWord8sPara Vector Word8
w8s Vector Word64
v = case Vector Word64 -> Vector Word8
forall a b. (Storable a, Storable b) => Vector a -> Vector b
DVS.unsafeCast Vector Word64
v :: DVS.Vector Word8 of
    Vector Word8
u -> case Vector Word8 -> (ForeignPtr Word8, Int, Int)
forall a. Storable a => Vector a -> (ForeignPtr a, Int, Int)
DVS.unsafeToForeignPtr Vector Word8
u of
      (ForeignPtr Word8
srcFptr, Int
srcOffset, Int
srcLength) -> if Int
disalignment Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0
        then IO (Vector (Vector Word64)) -> Vector (Vector Word64)
forall a. IO a -> a
F.unsafeLocalState (IO (Vector (Vector Word64)) -> Vector (Vector Word64))
-> IO (Vector (Vector Word64)) -> Vector (Vector Word64)
forall a b. (a -> b) -> a -> b
$ do
          ForeignPtr Word64
tgtFptr <- Int -> IO (ForeignPtr Word64)
forall a. Int -> IO (ForeignPtr a)
F.mallocForeignPtrBytes (Int
srcLength Int -> Int -> Int
forall a. Num a => a -> a -> a
* Vector Word8 -> Int
forall a. Storable a => Vector a -> Int
DVS.length Vector Word8
w8s)
          ForeignPtr Word8
-> (Ptr Word8 -> IO (Vector (Vector Word64)))
-> IO (Vector (Vector Word64))
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
F.withForeignPtr ForeignPtr Word8
srcFptr ((Ptr Word8 -> IO (Vector (Vector Word64)))
 -> IO (Vector (Vector Word64)))
-> (Ptr Word8 -> IO (Vector (Vector Word64)))
-> IO (Vector (Vector Word64))
forall a b. (a -> b) -> a -> b
$ \Ptr Word8
srcPtr -> do
            ForeignPtr Word64
-> (Ptr Word64 -> IO (Vector (Vector Word64)))
-> IO (Vector (Vector Word64))
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
F.withForeignPtr ForeignPtr Word64
tgtFptr ((Ptr Word64 -> IO (Vector (Vector Word64)))
 -> IO (Vector (Vector Word64)))
-> (Ptr Word64 -> IO (Vector (Vector Word64)))
-> IO (Vector (Vector Word64))
forall a b. (a -> b) -> a -> b
$ \Ptr Word64
tgtPtr -> do
              let Vector (Ptr Word8)
tgtsPtrsV :: DVS.Vector (F.Ptr Word8) = Int -> (Vector (Ptr Word8) -> Ptr Word8) -> Vector (Ptr Word8)
forall a. Storable a => Int -> (Vector a -> a) -> Vector a
DVS.constructN (Vector Word8 -> Int
forall a. Storable a => Vector a -> Int
DVS.length Vector Word8
w8s) ((Vector (Ptr Word8) -> Ptr Word8) -> Vector (Ptr Word8))
-> (Vector (Ptr Word8) -> Ptr Word8) -> Vector (Ptr Word8)
forall a b. (a -> b) -> a -> b
$ \Vector (Ptr Word8)
t ->
                    Ptr Word64
tgtPtr Ptr Word64 -> Int -> Ptr Word8
forall a b. Ptr a -> Int -> Ptr b
`F.plusPtr` (Vector (Ptr Word8) -> Int
forall a. Storable a => Vector a -> Int
DVS.length Vector (Ptr Word8)
t Int -> Int -> Int
forall a. Num a => a -> a -> a
* Vector Word64 -> Int
forall a. Storable a => Vector a -> Int
DVS.length Vector Word64
v)
              let (ForeignPtr Word8
w8sFptr, Int
_, Int
w8sLen) = Vector Word8 -> (ForeignPtr Word8, Int, Int)
forall a. Storable a => Vector a -> (ForeignPtr a, Int, Int)
DVS.unsafeToForeignPtr Vector Word8
w8s
              let (ForeignPtr (Ptr Word8)
tgtsPtrsFptr, Int
_, Int
_) = Vector (Ptr Word8) -> (ForeignPtr (Ptr Word8), Int, Int)
forall a. Storable a => Vector a -> (ForeignPtr a, Int, Int)
DVS.unsafeToForeignPtr Vector (Ptr Word8)
tgtsPtrsV
              ForeignPtr Word8 -> (Ptr Word8 -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
F.withForeignPtr ForeignPtr Word8
w8sFptr ((Ptr Word8 -> IO ()) -> IO ()) -> (Ptr Word8 -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr Word8
w8sPtr -> do
                ForeignPtr (Ptr Word8) -> (Ptr (Ptr Word8) -> IO ()) -> IO ()
forall a b. ForeignPtr a -> (Ptr a -> IO b) -> IO b
F.withForeignPtr ForeignPtr (Ptr Word8)
tgtsPtrsFptr ((Ptr (Ptr Word8) -> IO ()) -> IO ())
-> (Ptr (Ptr Word8) -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr (Ptr Word8)
tgtsPtrsPtr -> do
                  Ptr UInt8 -> Size -> Ptr (Ptr UInt8) -> Size -> Ptr UInt8 -> IO ()
F.avx2Cmpeq8Para (Ptr Word8 -> Ptr UInt8
forall a b. Ptr a -> Ptr b
F.castPtr Ptr Word8
w8sPtr) (Int -> Size
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
w8sLen) (Ptr (Ptr Word8) -> Ptr (Ptr UInt8)
forall a b. Ptr a -> Ptr b
F.castPtr Ptr (Ptr Word8)
tgtsPtrsPtr) (Int -> Size
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
w64sLen) (Ptr Word8
srcPtr Ptr Word8 -> Int -> Ptr UInt8
forall a b. Ptr a -> Int -> Ptr b
`F.plusPtr` Int
srcOffset)

              let tgtV :: Vector Word64
tgtV = ForeignPtr Word64 -> Int -> Int -> Vector Word64
forall a. Storable a => ForeignPtr a -> Int -> Int -> Vector a
DVS.unsafeFromForeignPtr ForeignPtr Word64
tgtFptr Int
0 (Int
w64sLen Int -> Int -> Int
forall a. Num a => a -> a -> a
* Vector Word8 -> Int
forall a. Storable a => Vector a -> Int
DVS.length Vector Word8
w8s)
              Vector (Vector Word64) -> IO (Vector (Vector Word64))
forall (m :: * -> *) a. Monad m => a -> m a
return (Vector (Vector Word64) -> IO (Vector (Vector Word64)))
-> Vector (Vector Word64) -> IO (Vector (Vector Word64))
forall a b. (a -> b) -> a -> b
$ Int
-> (Vector (Vector Word64) -> Vector Word64)
-> Vector (Vector Word64)
forall a. Int -> (Vector a -> a) -> Vector a
DV.constructN (Vector Word8 -> Int
forall a. Storable a => Vector a -> Int
DVS.length Vector Word8
w8s) ((Vector (Vector Word64) -> Vector Word64)
 -> Vector (Vector Word64))
-> (Vector (Vector Word64) -> Vector Word64)
-> Vector (Vector Word64)
forall a b. (a -> b) -> a -> b
$ \Vector (Vector Word64)
t -> Int -> Vector Word64 -> Vector Word64
forall a. Storable a => Int -> Vector a -> Vector a
DVS.take Int
w64sLen (Int -> Vector Word64 -> Vector Word64
forall a. Storable a => Int -> Vector a -> Vector a
DVS.drop (Vector (Vector Word64) -> Int
forall a. Vector a -> Int
DV.length Vector (Vector Word64)
t Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
w64sLen) Vector Word64
tgtV)

        else [Char] -> Vector (Vector Word64)
forall a. HasCallStack => [Char] -> a
error ([Char] -> Vector (Vector Word64))
-> [Char] -> Vector (Vector Word64)
forall a b. (a -> b) -> a -> b
$ [Char]
"Unaligned byte string: " [Char] -> [Char] -> [Char]
forall a. Semigroup a => a -> a -> a
<> Int -> [Char]
forall a. Show a => a -> [Char]
show Int
disalignment
        where w64sLen :: Int
w64sLen       = Int
srcLength Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
64
              disalignment :: Int
disalignment  = Int
srcLength Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
w64sLen Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
64
  {-# INLINE cmpEqWord8sPara #-}