{-# LANGUAGE BinaryLiterals      #-}
{-# LANGUAGE DeriveFunctor       #-}
{-# LANGUAGE DeriveGeneric       #-}
{-# LANGUAGE DeriveTraversable   #-}
{-# LANGUAGE InstanceSigs        #-}
{-# LANGUAGE MultiWayIf          #-}
{-# LANGUAGE RankNTypes          #-}
{-# LANGUAGE ScopedTypeVariables #-}

module HaskellWorks.Data.Json.Standard.Cursor.SemiIndex
  ( semiIndexBuilder
  , SemiIndex(..)
  , PreSiChunk(..)
  , SiChunk(..)
  , buildSemiIndex
  , State(..)
  , buildFromByteString2
  , buildFromByteString3
  , toIbBpBuilders
  ) where

import Control.Monad.ST
import Data.Bits.Pdep
import Data.Bits.Pext
import Data.Word
import Foreign.Storable                                             (Storable (..))
import GHC.Generics
import HaskellWorks.Data.Bits.BitWise
import HaskellWorks.Data.Bits.PopCount.PopCount1
import HaskellWorks.Data.Json.Standard.Cursor.Internal.StateMachine (IntState (..), State (..))
import HaskellWorks.Data.Vector.AsVector64

import qualified Data.ByteString                                                    as BS
import qualified Data.ByteString.Builder                                            as B
import qualified Data.ByteString.Lazy                                               as LBS
import qualified Data.ByteString.Unsafe                                             as BSU
import qualified Data.Vector.Storable                                               as DVS
import qualified Data.Vector.Storable.Mutable                                       as DVSM
import qualified HaskellWorks.Data.Bits.Writer.Storable                             as W
import qualified HaskellWorks.Data.ByteString                                       as BS
import qualified HaskellWorks.Data.Json.Standard.Cursor.Internal.Blank              as J
import qualified HaskellWorks.Data.Json.Standard.Cursor.Internal.BlankedJson        as J
import qualified HaskellWorks.Data.Json.Standard.Cursor.Internal.MakeIndex          as J
import qualified HaskellWorks.Data.Json.Standard.Cursor.Internal.StateMachine       as SM
import qualified HaskellWorks.Data.Json.Standard.Cursor.Internal.ToBalancedParens64 as J
import qualified HaskellWorks.Data.Json.Standard.Cursor.Internal.Word8              as W8

{- HLINT ignore "Reduce duplication"  -}
{- HLINT ignore "Redundant do"        -}

data PreSiChunk v = PreSiChunk
  { PreSiChunk v -> v
preSiChunkIb   :: !v -- interest bits
  , PreSiChunk v -> v
preSiChunkBpOp :: !v -- balanced parens interest bits
  , PreSiChunk v -> v
preSiChunkBpCl :: !v -- balanced parens open close
  } deriving (a -> PreSiChunk b -> PreSiChunk a
(a -> b) -> PreSiChunk a -> PreSiChunk b
(forall a b. (a -> b) -> PreSiChunk a -> PreSiChunk b)
-> (forall a b. a -> PreSiChunk b -> PreSiChunk a)
-> Functor PreSiChunk
forall a b. a -> PreSiChunk b -> PreSiChunk a
forall a b. (a -> b) -> PreSiChunk a -> PreSiChunk b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> PreSiChunk b -> PreSiChunk a
$c<$ :: forall a b. a -> PreSiChunk b -> PreSiChunk a
fmap :: (a -> b) -> PreSiChunk a -> PreSiChunk b
$cfmap :: forall a b. (a -> b) -> PreSiChunk a -> PreSiChunk b
Functor, Functor PreSiChunk
Foldable PreSiChunk
Functor PreSiChunk
-> Foldable PreSiChunk
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> PreSiChunk a -> f (PreSiChunk b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    PreSiChunk (f a) -> f (PreSiChunk a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> PreSiChunk a -> m (PreSiChunk b))
-> (forall (m :: * -> *) a.
    Monad m =>
    PreSiChunk (m a) -> m (PreSiChunk a))
-> Traversable PreSiChunk
(a -> f b) -> PreSiChunk a -> f (PreSiChunk b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
PreSiChunk (m a) -> m (PreSiChunk a)
forall (f :: * -> *) a.
Applicative f =>
PreSiChunk (f a) -> f (PreSiChunk a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PreSiChunk a -> m (PreSiChunk b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PreSiChunk a -> f (PreSiChunk b)
sequence :: PreSiChunk (m a) -> m (PreSiChunk a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
PreSiChunk (m a) -> m (PreSiChunk a)
mapM :: (a -> m b) -> PreSiChunk a -> m (PreSiChunk b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PreSiChunk a -> m (PreSiChunk b)
sequenceA :: PreSiChunk (f a) -> f (PreSiChunk a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
PreSiChunk (f a) -> f (PreSiChunk a)
traverse :: (a -> f b) -> PreSiChunk a -> f (PreSiChunk b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PreSiChunk a -> f (PreSiChunk b)
$cp2Traversable :: Foldable PreSiChunk
$cp1Traversable :: Functor PreSiChunk
Traversable, PreSiChunk a -> Bool
(a -> m) -> PreSiChunk a -> m
(a -> b -> b) -> b -> PreSiChunk a -> b
(forall m. Monoid m => PreSiChunk m -> m)
-> (forall m a. Monoid m => (a -> m) -> PreSiChunk a -> m)
-> (forall m a. Monoid m => (a -> m) -> PreSiChunk a -> m)
-> (forall a b. (a -> b -> b) -> b -> PreSiChunk a -> b)
-> (forall a b. (a -> b -> b) -> b -> PreSiChunk a -> b)
-> (forall b a. (b -> a -> b) -> b -> PreSiChunk a -> b)
-> (forall b a. (b -> a -> b) -> b -> PreSiChunk a -> b)
-> (forall a. (a -> a -> a) -> PreSiChunk a -> a)
-> (forall a. (a -> a -> a) -> PreSiChunk a -> a)
-> (forall a. PreSiChunk a -> [a])
-> (forall a. PreSiChunk a -> Bool)
-> (forall a. PreSiChunk a -> Int)
-> (forall a. Eq a => a -> PreSiChunk a -> Bool)
-> (forall a. Ord a => PreSiChunk a -> a)
-> (forall a. Ord a => PreSiChunk a -> a)
-> (forall a. Num a => PreSiChunk a -> a)
-> (forall a. Num a => PreSiChunk a -> a)
-> Foldable PreSiChunk
forall a. Eq a => a -> PreSiChunk a -> Bool
forall a. Num a => PreSiChunk a -> a
forall a. Ord a => PreSiChunk a -> a
forall m. Monoid m => PreSiChunk m -> m
forall a. PreSiChunk a -> Bool
forall a. PreSiChunk a -> Int
forall a. PreSiChunk a -> [a]
forall a. (a -> a -> a) -> PreSiChunk a -> a
forall m a. Monoid m => (a -> m) -> PreSiChunk a -> m
forall b a. (b -> a -> b) -> b -> PreSiChunk a -> b
forall a b. (a -> b -> b) -> b -> PreSiChunk a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: PreSiChunk a -> a
$cproduct :: forall a. Num a => PreSiChunk a -> a
sum :: PreSiChunk a -> a
$csum :: forall a. Num a => PreSiChunk a -> a
minimum :: PreSiChunk a -> a
$cminimum :: forall a. Ord a => PreSiChunk a -> a
maximum :: PreSiChunk a -> a
$cmaximum :: forall a. Ord a => PreSiChunk a -> a
elem :: a -> PreSiChunk a -> Bool
$celem :: forall a. Eq a => a -> PreSiChunk a -> Bool
length :: PreSiChunk a -> Int
$clength :: forall a. PreSiChunk a -> Int
null :: PreSiChunk a -> Bool
$cnull :: forall a. PreSiChunk a -> Bool
toList :: PreSiChunk a -> [a]
$ctoList :: forall a. PreSiChunk a -> [a]
foldl1 :: (a -> a -> a) -> PreSiChunk a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> PreSiChunk a -> a
foldr1 :: (a -> a -> a) -> PreSiChunk a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> PreSiChunk a -> a
foldl' :: (b -> a -> b) -> b -> PreSiChunk a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> PreSiChunk a -> b
foldl :: (b -> a -> b) -> b -> PreSiChunk a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> PreSiChunk a -> b
foldr' :: (a -> b -> b) -> b -> PreSiChunk a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> PreSiChunk a -> b
foldr :: (a -> b -> b) -> b -> PreSiChunk a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> PreSiChunk a -> b
foldMap' :: (a -> m) -> PreSiChunk a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> PreSiChunk a -> m
foldMap :: (a -> m) -> PreSiChunk a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> PreSiChunk a -> m
fold :: PreSiChunk m -> m
$cfold :: forall m. Monoid m => PreSiChunk m -> m
Foldable, (forall x. PreSiChunk v -> Rep (PreSiChunk v) x)
-> (forall x. Rep (PreSiChunk v) x -> PreSiChunk v)
-> Generic (PreSiChunk v)
forall x. Rep (PreSiChunk v) x -> PreSiChunk v
forall x. PreSiChunk v -> Rep (PreSiChunk v) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall v x. Rep (PreSiChunk v) x -> PreSiChunk v
forall v x. PreSiChunk v -> Rep (PreSiChunk v) x
$cto :: forall v x. Rep (PreSiChunk v) x -> PreSiChunk v
$cfrom :: forall v x. PreSiChunk v -> Rep (PreSiChunk v) x
Generic)

data SiChunk v = SiChunk
  { SiChunk v -> v
siChunkIb :: !v -- interest bits
  , SiChunk v -> v
siChunkBp :: !v -- balanced parens open close
  } deriving (a -> SiChunk b -> SiChunk a
(a -> b) -> SiChunk a -> SiChunk b
(forall a b. (a -> b) -> SiChunk a -> SiChunk b)
-> (forall a b. a -> SiChunk b -> SiChunk a) -> Functor SiChunk
forall a b. a -> SiChunk b -> SiChunk a
forall a b. (a -> b) -> SiChunk a -> SiChunk b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> SiChunk b -> SiChunk a
$c<$ :: forall a b. a -> SiChunk b -> SiChunk a
fmap :: (a -> b) -> SiChunk a -> SiChunk b
$cfmap :: forall a b. (a -> b) -> SiChunk a -> SiChunk b
Functor, Functor SiChunk
Foldable SiChunk
Functor SiChunk
-> Foldable SiChunk
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> SiChunk a -> f (SiChunk b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    SiChunk (f a) -> f (SiChunk a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> SiChunk a -> m (SiChunk b))
-> (forall (m :: * -> *) a.
    Monad m =>
    SiChunk (m a) -> m (SiChunk a))
-> Traversable SiChunk
(a -> f b) -> SiChunk a -> f (SiChunk b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => SiChunk (m a) -> m (SiChunk a)
forall (f :: * -> *) a.
Applicative f =>
SiChunk (f a) -> f (SiChunk a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SiChunk a -> m (SiChunk b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SiChunk a -> f (SiChunk b)
sequence :: SiChunk (m a) -> m (SiChunk a)
$csequence :: forall (m :: * -> *) a. Monad m => SiChunk (m a) -> m (SiChunk a)
mapM :: (a -> m b) -> SiChunk a -> m (SiChunk b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SiChunk a -> m (SiChunk b)
sequenceA :: SiChunk (f a) -> f (SiChunk a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
SiChunk (f a) -> f (SiChunk a)
traverse :: (a -> f b) -> SiChunk a -> f (SiChunk b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SiChunk a -> f (SiChunk b)
$cp2Traversable :: Foldable SiChunk
$cp1Traversable :: Functor SiChunk
Traversable, SiChunk a -> Bool
(a -> m) -> SiChunk a -> m
(a -> b -> b) -> b -> SiChunk a -> b
(forall m. Monoid m => SiChunk m -> m)
-> (forall m a. Monoid m => (a -> m) -> SiChunk a -> m)
-> (forall m a. Monoid m => (a -> m) -> SiChunk a -> m)
-> (forall a b. (a -> b -> b) -> b -> SiChunk a -> b)
-> (forall a b. (a -> b -> b) -> b -> SiChunk a -> b)
-> (forall b a. (b -> a -> b) -> b -> SiChunk a -> b)
-> (forall b a. (b -> a -> b) -> b -> SiChunk a -> b)
-> (forall a. (a -> a -> a) -> SiChunk a -> a)
-> (forall a. (a -> a -> a) -> SiChunk a -> a)
-> (forall a. SiChunk a -> [a])
-> (forall a. SiChunk a -> Bool)
-> (forall a. SiChunk a -> Int)
-> (forall a. Eq a => a -> SiChunk a -> Bool)
-> (forall a. Ord a => SiChunk a -> a)
-> (forall a. Ord a => SiChunk a -> a)
-> (forall a. Num a => SiChunk a -> a)
-> (forall a. Num a => SiChunk a -> a)
-> Foldable SiChunk
forall a. Eq a => a -> SiChunk a -> Bool
forall a. Num a => SiChunk a -> a
forall a. Ord a => SiChunk a -> a
forall m. Monoid m => SiChunk m -> m
forall a. SiChunk a -> Bool
forall a. SiChunk a -> Int
forall a. SiChunk a -> [a]
forall a. (a -> a -> a) -> SiChunk a -> a
forall m a. Monoid m => (a -> m) -> SiChunk a -> m
forall b a. (b -> a -> b) -> b -> SiChunk a -> b
forall a b. (a -> b -> b) -> b -> SiChunk a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: SiChunk a -> a
$cproduct :: forall a. Num a => SiChunk a -> a
sum :: SiChunk a -> a
$csum :: forall a. Num a => SiChunk a -> a
minimum :: SiChunk a -> a
$cminimum :: forall a. Ord a => SiChunk a -> a
maximum :: SiChunk a -> a
$cmaximum :: forall a. Ord a => SiChunk a -> a
elem :: a -> SiChunk a -> Bool
$celem :: forall a. Eq a => a -> SiChunk a -> Bool
length :: SiChunk a -> Int
$clength :: forall a. SiChunk a -> Int
null :: SiChunk a -> Bool
$cnull :: forall a. SiChunk a -> Bool
toList :: SiChunk a -> [a]
$ctoList :: forall a. SiChunk a -> [a]
foldl1 :: (a -> a -> a) -> SiChunk a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> SiChunk a -> a
foldr1 :: (a -> a -> a) -> SiChunk a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> SiChunk a -> a
foldl' :: (b -> a -> b) -> b -> SiChunk a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> SiChunk a -> b
foldl :: (b -> a -> b) -> b -> SiChunk a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> SiChunk a -> b
foldr' :: (a -> b -> b) -> b -> SiChunk a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> SiChunk a -> b
foldr :: (a -> b -> b) -> b -> SiChunk a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> SiChunk a -> b
foldMap' :: (a -> m) -> SiChunk a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> SiChunk a -> m
foldMap :: (a -> m) -> SiChunk a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> SiChunk a -> m
fold :: SiChunk m -> m
$cfold :: forall m. Monoid m => SiChunk m -> m
Foldable, (forall x. SiChunk v -> Rep (SiChunk v) x)
-> (forall x. Rep (SiChunk v) x -> SiChunk v)
-> Generic (SiChunk v)
forall x. Rep (SiChunk v) x -> SiChunk v
forall x. SiChunk v -> Rep (SiChunk v) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall v x. Rep (SiChunk v) x -> SiChunk v
forall v x. SiChunk v -> Rep (SiChunk v) x
$cto :: forall v x. Rep (SiChunk v) x -> SiChunk v
$cfrom :: forall v x. SiChunk v -> Rep (SiChunk v) x
Generic)

data SemiIndex v = SemiIndex
  { SemiIndex v -> v
semiIndexIb :: !v
  , SemiIndex v -> v
semiIndexBp :: !v
  } deriving (a -> SemiIndex b -> SemiIndex a
(a -> b) -> SemiIndex a -> SemiIndex b
(forall a b. (a -> b) -> SemiIndex a -> SemiIndex b)
-> (forall a b. a -> SemiIndex b -> SemiIndex a)
-> Functor SemiIndex
forall a b. a -> SemiIndex b -> SemiIndex a
forall a b. (a -> b) -> SemiIndex a -> SemiIndex b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> SemiIndex b -> SemiIndex a
$c<$ :: forall a b. a -> SemiIndex b -> SemiIndex a
fmap :: (a -> b) -> SemiIndex a -> SemiIndex b
$cfmap :: forall a b. (a -> b) -> SemiIndex a -> SemiIndex b
Functor, Functor SemiIndex
Foldable SemiIndex
Functor SemiIndex
-> Foldable SemiIndex
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> SemiIndex a -> f (SemiIndex b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    SemiIndex (f a) -> f (SemiIndex a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> SemiIndex a -> m (SemiIndex b))
-> (forall (m :: * -> *) a.
    Monad m =>
    SemiIndex (m a) -> m (SemiIndex a))
-> Traversable SemiIndex
(a -> f b) -> SemiIndex a -> f (SemiIndex b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
SemiIndex (m a) -> m (SemiIndex a)
forall (f :: * -> *) a.
Applicative f =>
SemiIndex (f a) -> f (SemiIndex a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SemiIndex a -> m (SemiIndex b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SemiIndex a -> f (SemiIndex b)
sequence :: SemiIndex (m a) -> m (SemiIndex a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
SemiIndex (m a) -> m (SemiIndex a)
mapM :: (a -> m b) -> SemiIndex a -> m (SemiIndex b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> SemiIndex a -> m (SemiIndex b)
sequenceA :: SemiIndex (f a) -> f (SemiIndex a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
SemiIndex (f a) -> f (SemiIndex a)
traverse :: (a -> f b) -> SemiIndex a -> f (SemiIndex b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> SemiIndex a -> f (SemiIndex b)
$cp2Traversable :: Foldable SemiIndex
$cp1Traversable :: Functor SemiIndex
Traversable, SemiIndex a -> Bool
(a -> m) -> SemiIndex a -> m
(a -> b -> b) -> b -> SemiIndex a -> b
(forall m. Monoid m => SemiIndex m -> m)
-> (forall m a. Monoid m => (a -> m) -> SemiIndex a -> m)
-> (forall m a. Monoid m => (a -> m) -> SemiIndex a -> m)
-> (forall a b. (a -> b -> b) -> b -> SemiIndex a -> b)
-> (forall a b. (a -> b -> b) -> b -> SemiIndex a -> b)
-> (forall b a. (b -> a -> b) -> b -> SemiIndex a -> b)
-> (forall b a. (b -> a -> b) -> b -> SemiIndex a -> b)
-> (forall a. (a -> a -> a) -> SemiIndex a -> a)
-> (forall a. (a -> a -> a) -> SemiIndex a -> a)
-> (forall a. SemiIndex a -> [a])
-> (forall a. SemiIndex a -> Bool)
-> (forall a. SemiIndex a -> Int)
-> (forall a. Eq a => a -> SemiIndex a -> Bool)
-> (forall a. Ord a => SemiIndex a -> a)
-> (forall a. Ord a => SemiIndex a -> a)
-> (forall a. Num a => SemiIndex a -> a)
-> (forall a. Num a => SemiIndex a -> a)
-> Foldable SemiIndex
forall a. Eq a => a -> SemiIndex a -> Bool
forall a. Num a => SemiIndex a -> a
forall a. Ord a => SemiIndex a -> a
forall m. Monoid m => SemiIndex m -> m
forall a. SemiIndex a -> Bool
forall a. SemiIndex a -> Int
forall a. SemiIndex a -> [a]
forall a. (a -> a -> a) -> SemiIndex a -> a
forall m a. Monoid m => (a -> m) -> SemiIndex a -> m
forall b a. (b -> a -> b) -> b -> SemiIndex a -> b
forall a b. (a -> b -> b) -> b -> SemiIndex a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: SemiIndex a -> a
$cproduct :: forall a. Num a => SemiIndex a -> a
sum :: SemiIndex a -> a
$csum :: forall a. Num a => SemiIndex a -> a
minimum :: SemiIndex a -> a
$cminimum :: forall a. Ord a => SemiIndex a -> a
maximum :: SemiIndex a -> a
$cmaximum :: forall a. Ord a => SemiIndex a -> a
elem :: a -> SemiIndex a -> Bool
$celem :: forall a. Eq a => a -> SemiIndex a -> Bool
length :: SemiIndex a -> Int
$clength :: forall a. SemiIndex a -> Int
null :: SemiIndex a -> Bool
$cnull :: forall a. SemiIndex a -> Bool
toList :: SemiIndex a -> [a]
$ctoList :: forall a. SemiIndex a -> [a]
foldl1 :: (a -> a -> a) -> SemiIndex a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> SemiIndex a -> a
foldr1 :: (a -> a -> a) -> SemiIndex a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> SemiIndex a -> a
foldl' :: (b -> a -> b) -> b -> SemiIndex a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> SemiIndex a -> b
foldl :: (b -> a -> b) -> b -> SemiIndex a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> SemiIndex a -> b
foldr' :: (a -> b -> b) -> b -> SemiIndex a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> SemiIndex a -> b
foldr :: (a -> b -> b) -> b -> SemiIndex a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> SemiIndex a -> b
foldMap' :: (a -> m) -> SemiIndex a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> SemiIndex a -> m
foldMap :: (a -> m) -> SemiIndex a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> SemiIndex a -> m
fold :: SemiIndex m -> m
$cfold :: forall m. Monoid m => SemiIndex m -> m
Foldable, (forall x. SemiIndex v -> Rep (SemiIndex v) x)
-> (forall x. Rep (SemiIndex v) x -> SemiIndex v)
-> Generic (SemiIndex v)
forall x. Rep (SemiIndex v) x -> SemiIndex v
forall x. SemiIndex v -> Rep (SemiIndex v) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall v x. Rep (SemiIndex v) x -> SemiIndex v
forall v x. SemiIndex v -> Rep (SemiIndex v) x
$cto :: forall v x. Rep (SemiIndex v) x -> SemiIndex v
$cfrom :: forall v x. SemiIndex v -> Rep (SemiIndex v) x
Generic)

semiIndexBuilder :: LBS.ByteString -> SemiIndex B.Builder
semiIndexBuilder :: ByteString -> SemiIndex Builder
semiIndexBuilder ByteString
lbs = Builder -> Builder -> SemiIndex Builder
forall v. v -> v -> SemiIndex v
SemiIndex (ByteString -> Builder
B.lazyByteString ByteString
ibs) (ByteString -> Builder
B.byteString (Vector Word64 -> ByteString
forall a. ToByteString a => a -> ByteString
BS.toByteString Vector Word64
bps))
  where blankedJson :: [ByteString]
blankedJson = [ByteString] -> [ByteString]
J.blankJson (ByteString -> [ByteString]
LBS.toChunks ByteString
lbs)
        ibs :: ByteString
ibs = [ByteString] -> ByteString
LBS.fromChunks ([ByteString] -> [ByteString]
J.blankedJsonToInterestBits [ByteString]
blankedJson)
        bps :: Vector Word64
bps = BlankedJson -> Vector Word64
forall a. ToBalancedParens64 a => a -> Vector Word64
J.toBalancedParens64 ([ByteString] -> BlankedJson
J.BlankedJson [ByteString]
blankedJson)
{-# INLINE semiIndexBuilder #-}

buildSemiIndex :: BS.ByteString -> SemiIndex (DVS.Vector Word64)
buildSemiIndex :: ByteString -> SemiIndex (Vector Word64)
buildSemiIndex ByteString
bs = (forall s. ST s (SemiIndex (MVector s Word64)))
-> SemiIndex (Vector Word64)
forall (f :: * -> *) a.
(Traversable f, Storable a) =>
(forall s. ST s (f (MVector s a))) -> f (Vector a)
DVS.createT ((forall s. ST s (SemiIndex (MVector s Word64)))
 -> SemiIndex (Vector Word64))
-> (forall s. ST s (SemiIndex (MVector s Word64)))
-> SemiIndex (Vector Word64)
forall a b. (a -> b) -> a -> b
$ do
  let len :: Int
len = (ByteString -> Int
BS.length ByteString
bs 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
  Writer s
mib <- Int -> ST s (Writer s)
forall s. Int -> ST s (Writer s)
W.newWriter Int
len
  Writer s
mbp <- Int -> ST s (Writer s)
forall s. Int -> ST s (Writer s)
W.newWriter (Int
len Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
2)
  Writer s
-> Writer s
-> ByteString
-> Int
-> State
-> ST s (SemiIndex (MVector s Word64))
forall s.
Writer s
-> Writer s
-> ByteString
-> Int
-> State
-> ST s (SemiIndex (MVector s Word64))
buildFromByteString Writer s
mib Writer s
mbp ByteString
bs Int
0 State
InJson
{-# INLINE buildSemiIndex #-}

buildFromByteString :: W.Writer s -> W.Writer s -> BS.ByteString -> Int -> State -> ST s (SemiIndex (DVS.MVector s Word64))
buildFromByteString :: Writer s
-> Writer s
-> ByteString
-> Int
-> State
-> ST s (SemiIndex (MVector s Word64))
buildFromByteString Writer s
ib Writer s
bp ByteString
bs Int
i = State -> ST s (SemiIndex (MVector s Word64))
go
  where go :: State -> ST s (SemiIndex (MVector s Word64))
go State
state = if Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< ByteString -> Int
BS.length ByteString
bs
          then do
            let c :: Word8
c = ByteString -> Int -> Word8
BSU.unsafeIndex ByteString
bs Int
i
            case State
state of
              State
InJson -> if
                | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
W8.openBracket Bool -> Bool -> Bool
|| Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
W8.openBrace -> do
                  Writer s -> Word64 -> ST s ()
forall s. Writer s -> Word64 -> ST s ()
W.unsafeWriteBit Writer s
ib Word64
1
                  Writer s -> Word64 -> ST s ()
forall s. Writer s -> Word64 -> ST s ()
W.unsafeWriteBit Writer s
bp Word64
1
                  Writer s
-> Writer s
-> ByteString
-> Int
-> State
-> ST s (SemiIndex (MVector s Word64))
forall s.
Writer s
-> Writer s
-> ByteString
-> Int
-> State
-> ST s (SemiIndex (MVector s Word64))
buildFromByteString Writer s
ib Writer s
bp ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) State
InJson
                | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
W8.closeBracket Bool -> Bool -> Bool
|| Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
W8.closeBrace -> do
                  Writer s -> Word64 -> ST s ()
forall s. Writer s -> Word64 -> ST s ()
W.unsafeWriteBit Writer s
bp Word64
0
                  Writer s -> Word64 -> ST s ()
forall s. Writer s -> Word64 -> ST s ()
W.unsafeWriteBit Writer s
ib Word64
0
                  Writer s
-> Writer s
-> ByteString
-> Int
-> State
-> ST s (SemiIndex (MVector s Word64))
forall s.
Writer s
-> Writer s
-> ByteString
-> Int
-> State
-> ST s (SemiIndex (MVector s Word64))
buildFromByteString Writer s
ib Writer s
bp ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) State
InJson
                | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
W8.comma Bool -> Bool -> Bool
|| Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
W8.colon -> do
                  Writer s -> Word64 -> ST s ()
forall s. Writer s -> Word64 -> ST s ()
W.unsafeWriteBit Writer s
ib Word64
0
                  Writer s
-> Writer s
-> ByteString
-> Int
-> State
-> ST s (SemiIndex (MVector s Word64))
forall s.
Writer s
-> Writer s
-> ByteString
-> Int
-> State
-> ST s (SemiIndex (MVector s Word64))
buildFromByteString Writer s
ib Writer s
bp ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) State
InJson
                | Word8 -> Bool
W8.isAlphabetic Word8
c Bool -> Bool -> Bool
|| Word8 -> Bool
W8.isDigit Word8
c Bool -> Bool -> Bool
|| Word8 -> Bool
W8.isPeriod Word8
c Bool -> Bool -> Bool
|| Word8 -> Bool
W8.isMinus Word8
c Bool -> Bool -> Bool
|| Word8 -> Bool
W8.isPlus Word8
c -> do
                  Writer s -> Word64 -> ST s ()
forall s. Writer s -> Word64 -> ST s ()
W.unsafeWriteBit Writer s
ib Word64
1
                  Writer s -> Word64 -> ST s ()
forall s. Writer s -> Word64 -> ST s ()
W.unsafeWriteBit Writer s
bp Word64
1
                  Writer s -> Word64 -> ST s ()
forall s. Writer s -> Word64 -> ST s ()
W.unsafeWriteBit Writer s
bp Word64
0
                  Writer s
-> Writer s
-> ByteString
-> Int
-> State
-> ST s (SemiIndex (MVector s Word64))
forall s.
Writer s
-> Writer s
-> ByteString
-> Int
-> State
-> ST s (SemiIndex (MVector s Word64))
buildFromByteString Writer s
ib Writer s
bp ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) State
InValue
                | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
W8.doubleQuote -> do
                  Writer s -> Word64 -> ST s ()
forall s. Writer s -> Word64 -> ST s ()
W.unsafeWriteBit Writer s
ib Word64
1
                  Writer s -> Word64 -> ST s ()
forall s. Writer s -> Word64 -> ST s ()
W.unsafeWriteBit Writer s
bp Word64
1
                  Writer s -> Word64 -> ST s ()
forall s. Writer s -> Word64 -> ST s ()
W.unsafeWriteBit Writer s
bp Word64
0
                  Writer s
-> Writer s
-> ByteString
-> Int
-> State
-> ST s (SemiIndex (MVector s Word64))
forall s.
Writer s
-> Writer s
-> ByteString
-> Int
-> State
-> ST s (SemiIndex (MVector s Word64))
buildFromByteString Writer s
ib Writer s
bp ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) State
InString
                | Bool
otherwise -> do
                  Writer s -> Word64 -> ST s ()
forall s. Writer s -> Word64 -> ST s ()
W.unsafeWriteBit Writer s
ib Word64
0
                  Writer s
-> Writer s
-> ByteString
-> Int
-> State
-> ST s (SemiIndex (MVector s Word64))
forall s.
Writer s
-> Writer s
-> ByteString
-> Int
-> State
-> ST s (SemiIndex (MVector s Word64))
buildFromByteString Writer s
ib Writer s
bp ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) State
InJson
              State
InString -> do
                Writer s -> Word64 -> ST s ()
forall s. Writer s -> Word64 -> ST s ()
W.unsafeWriteBit Writer s
ib Word64
0
                let newContext :: State
newContext = if
                      | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
W8.doubleQuote -> State
InJson
                      | Word8
c Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
W8.backSlash   -> State
InEscape
                      | Bool
otherwise           -> State
InString
                Writer s
-> Writer s
-> ByteString
-> Int
-> State
-> ST s (SemiIndex (MVector s Word64))
forall s.
Writer s
-> Writer s
-> ByteString
-> Int
-> State
-> ST s (SemiIndex (MVector s Word64))
buildFromByteString Writer s
ib Writer s
bp ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) State
newContext
              State
InEscape -> do
                Writer s -> Word64 -> ST s ()
forall s. Writer s -> Word64 -> ST s ()
W.unsafeWriteBit Writer s
ib Word64
0
                Writer s
-> Writer s
-> ByteString
-> Int
-> State
-> ST s (SemiIndex (MVector s Word64))
forall s.
Writer s
-> Writer s
-> ByteString
-> Int
-> State
-> ST s (SemiIndex (MVector s Word64))
buildFromByteString Writer s
ib Writer s
bp ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) State
InString
              State
InValue -> if
                | Word8 -> Bool
W8.isAlphabetic Word8
c Bool -> Bool -> Bool
|| Word8 -> Bool
W8.isDigit Word8
c Bool -> Bool -> Bool
|| Word8 -> Bool
W8.isPeriod Word8
c Bool -> Bool -> Bool
|| Word8 -> Bool
W8.isMinus Word8
c Bool -> Bool -> Bool
|| Word8 -> Bool
W8.isPlus Word8
c -> do
                  Writer s -> Word64 -> ST s ()
forall s. Writer s -> Word64 -> ST s ()
W.unsafeWriteBit Writer s
ib Word64
0
                  Writer s
-> Writer s
-> ByteString
-> Int
-> State
-> ST s (SemiIndex (MVector s Word64))
forall s.
Writer s
-> Writer s
-> ByteString
-> Int
-> State
-> ST s (SemiIndex (MVector s Word64))
buildFromByteString Writer s
ib Writer s
bp ByteString
bs (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) State
InValue
                | Bool
otherwise -> State -> ST s (SemiIndex (MVector s Word64))
go State
InJson
          else do
            MVector s Word64
ibv <- Writer s -> ST s (MVector s Word64)
forall s. Writer s -> ST s (MVector s Word64)
W.written Writer s
ib
            MVector s Word64
bpv <- Writer s -> ST s (MVector s Word64)
forall s. Writer s -> ST s (MVector s Word64)
W.written Writer s
bp
            SemiIndex (MVector s Word64) -> ST s (SemiIndex (MVector s Word64))
forall (m :: * -> *) a. Monad m => a -> m a
return (MVector s Word64
-> MVector s Word64 -> SemiIndex (MVector s Word64)
forall v. v -> v -> SemiIndex v
SemiIndex MVector s Word64
ibv MVector s Word64
bpv)
{-# INLINE buildFromByteString #-}

constructSI :: forall a s. Storable a => Int -> (Int -> s -> (s, a)) -> s -> (s, DVS.Vector a)
constructSI :: Int -> (Int -> s -> (s, a)) -> s -> (s, Vector a)
constructSI Int
n Int -> s -> (s, a)
f s
state = (forall s. ST s (s, MVector s a)) -> (s, Vector a)
forall (f :: * -> *) a.
(Traversable f, Storable a) =>
(forall s. ST s (f (MVector s a))) -> f (Vector a)
DVS.createT ((forall s. ST s (s, MVector s a)) -> (s, Vector a))
-> (forall s. ST s (s, MVector s a)) -> (s, Vector a)
forall a b. (a -> b) -> a -> b
$ do
  MVector s a
mv <- Int -> ST s (MVector (PrimState (ST s)) a)
forall (m :: * -> *) a.
(PrimMonad m, Storable a) =>
Int -> m (MVector (PrimState m) a)
DVSM.unsafeNew Int
n
  s
state' <- Int -> s -> MVector s a -> ST s s
forall t. Int -> s -> MVector t a -> ST t s
go Int
0 s
state MVector s a
mv
  (s, MVector s a) -> ST s (s, MVector s a)
forall (m :: * -> *) a. Monad m => a -> m a
return (s
state', MVector s a
mv)
  where go :: Int -> s -> DVSM.MVector t a -> ST t s
        go :: Int -> s -> MVector t a -> ST t s
go Int
i s
s MVector t a
mv = if Int
i Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< MVector t a -> Int
forall a s. Storable a => MVector s a -> Int
DVSM.length MVector t a
mv
          then do
            let (s
s', a
a) = Int -> s -> (s, a)
f Int
i s
s
            MVector (PrimState (ST t)) a -> Int -> a -> ST t ()
forall (m :: * -> *) a.
(PrimMonad m, Storable a) =>
MVector (PrimState m) a -> Int -> a -> m ()
DVSM.unsafeWrite MVector t a
MVector (PrimState (ST t)) a
mv Int
i a
a
            Int -> s -> MVector t a -> ST t s
forall t. Int -> s -> MVector t a -> ST t s
go (Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) s
s' MVector t a
mv
          else s -> ST t s
forall (m :: * -> *) a. Monad m => a -> m a
return s
s
{-# INLINE constructSI #-}

buildFromByteString2 :: [BS.ByteString] -> [DVS.Vector Word64]
buildFromByteString2 :: [ByteString] -> [Vector Word64]
buildFromByteString2 = IntState -> [ByteString] -> [Vector Word64]
go (Int -> IntState
IntState (State -> Int
forall a. Enum a => a -> Int
fromEnum State
InJson))
  where go :: IntState -> [BS.ByteString] -> [DVS.Vector Word64]
        go :: IntState -> [ByteString] -> [Vector Word64]
go IntState
s (ByteString
bs:[ByteString]
bss) = Vector Word64
vVector Word64 -> [Vector Word64] -> [Vector Word64]
forall a. a -> [a] -> [a]
:IntState -> [ByteString] -> [Vector Word64]
go IntState
s' [ByteString]
bss
          where (IntState
s', Vector Word64
v) = Int
-> (Int -> IntState -> (IntState, Word64))
-> IntState
-> (IntState, Vector Word64)
forall a s.
Storable a =>
Int -> (Int -> s -> (s, a)) -> s -> (s, Vector a)
constructSI (ByteString -> Int
BS.length ByteString
bs Int -> Int -> Int
forall a. Integral a => a -> a -> a
`div` Int
16) Int -> IntState -> (IntState, Word64)
f IntState
s -- TODO adjust length
                f :: Int -> IntState -> (IntState, Word64)
                f :: Int -> IntState -> (IntState, Word64)
f Int
i IntState
s'' = let j :: Int
j = Int
i Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
16 in IntState
-> Word8
-> Word8
-> Word8
-> Word8
-> Word8
-> Word8
-> Word8
-> Word8
-> Word8
-> Word8
-> Word8
-> Word8
-> Word8
-> Word8
-> Word8
-> Word8
-> (IntState, Word64)
transition16 IntState
s''
                  (ByteString -> Int -> Word8
BSU.unsafeIndex ByteString
bs  Int
j      )
                  (ByteString -> Int -> Word8
BSU.unsafeIndex ByteString
bs (Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
+  Int
1))
                  (ByteString -> Int -> Word8
BSU.unsafeIndex ByteString
bs (Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
+  Int
2))
                  (ByteString -> Int -> Word8
BSU.unsafeIndex ByteString
bs (Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
+  Int
3))
                  (ByteString -> Int -> Word8
BSU.unsafeIndex ByteString
bs (Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
+  Int
4))
                  (ByteString -> Int -> Word8
BSU.unsafeIndex ByteString
bs (Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
+  Int
5))
                  (ByteString -> Int -> Word8
BSU.unsafeIndex ByteString
bs (Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
+  Int
6))
                  (ByteString -> Int -> Word8
BSU.unsafeIndex ByteString
bs (Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
+  Int
7))
                  (ByteString -> Int -> Word8
BSU.unsafeIndex ByteString
bs (Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
+  Int
8))
                  (ByteString -> Int -> Word8
BSU.unsafeIndex ByteString
bs (Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
+  Int
9))
                  (ByteString -> Int -> Word8
BSU.unsafeIndex ByteString
bs (Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
10))
                  (ByteString -> Int -> Word8
BSU.unsafeIndex ByteString
bs (Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
11))
                  (ByteString -> Int -> Word8
BSU.unsafeIndex ByteString
bs (Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
12))
                  (ByteString -> Int -> Word8
BSU.unsafeIndex ByteString
bs (Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
13))
                  (ByteString -> Int -> Word8
BSU.unsafeIndex ByteString
bs (Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
14))
                  (ByteString -> Int -> Word8
BSU.unsafeIndex ByteString
bs (Int
j Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
15))
        go IntState
_ [] = []
{-# INLINE buildFromByteString2 #-}

transition16 :: IntState
  -> Word8 -> Word8 -> Word8 -> Word8 -> Word8 -> Word8 -> Word8 -> Word8
  -> Word8 -> Word8 -> Word8 -> Word8 -> Word8 -> Word8 -> Word8 -> Word8
  -> (IntState, Word64)
transition16 :: IntState
-> Word8
-> Word8
-> Word8
-> Word8
-> Word8
-> Word8
-> Word8
-> Word8
-> Word8
-> Word8
-> Word8
-> Word8
-> Word8
-> Word8
-> Word8
-> Word8
-> (IntState, Word64)
transition16 IntState
s  Word8
a Word8
b Word8
c Word8
d  Word8
e Word8
f Word8
g Word8
h  Word8
i Word8
j Word8
k Word8
l  Word8
m Word8
n Word8
o Word8
p = (IntState
sp, Word64
w)
  where (IntState
sa, Word64
wa) = IntState -> Word8 -> (IntState, Word64)
transition1 IntState
s  Word8
a
        (IntState
sb, Word64
wb) = IntState -> Word8 -> (IntState, Word64)
transition1 IntState
sa Word8
b
        (IntState
sc, Word64
wc) = IntState -> Word8 -> (IntState, Word64)
transition1 IntState
sb Word8
c
        (IntState
sd, Word64
wd) = IntState -> Word8 -> (IntState, Word64)
transition1 IntState
sc Word8
d
        (IntState
se, Word64
we) = IntState -> Word8 -> (IntState, Word64)
transition1 IntState
sd Word8
e
        (IntState
sf, Word64
wf) = IntState -> Word8 -> (IntState, Word64)
transition1 IntState
se Word8
f
        (IntState
sg, Word64
wg) = IntState -> Word8 -> (IntState, Word64)
transition1 IntState
sf Word8
g
        (IntState
sh, Word64
wh) = IntState -> Word8 -> (IntState, Word64)
transition1 IntState
sg Word8
h
        (IntState
si, Word64
wi) = IntState -> Word8 -> (IntState, Word64)
transition1 IntState
sh Word8
i
        (IntState
sj, Word64
wj) = IntState -> Word8 -> (IntState, Word64)
transition1 IntState
si Word8
j
        (IntState
sk, Word64
wk) = IntState -> Word8 -> (IntState, Word64)
transition1 IntState
sj Word8
k
        (IntState
sl, Word64
wl) = IntState -> Word8 -> (IntState, Word64)
transition1 IntState
sk Word8
l
        (IntState
sm, Word64
wm) = IntState -> Word8 -> (IntState, Word64)
transition1 IntState
sl Word8
m
        (IntState
sn, Word64
wn) = IntState -> Word8 -> (IntState, Word64)
transition1 IntState
sm Word8
n
        (IntState
so, Word64
wo) = IntState -> Word8 -> (IntState, Word64)
transition1 IntState
sn Word8
o
        (IntState
sp, Word64
wp) = IntState -> Word8 -> (IntState, Word64)
transition1 IntState
so Word8
p
        w :: Word64
w = (Word64 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
wa       ) Word64 -> Word64 -> Word64
forall a. BitWise a => a -> a -> a
.|.
            (Word64 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
wb Word64 -> Word64 -> Word64
forall a. Shift a => a -> Word64 -> a
.<.  Word64
4) Word64 -> Word64 -> Word64
forall a. BitWise a => a -> a -> a
.|.
            (Word64 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
wc Word64 -> Word64 -> Word64
forall a. Shift a => a -> Word64 -> a
.<.  Word64
8) Word64 -> Word64 -> Word64
forall a. BitWise a => a -> a -> a
.|.
            (Word64 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
wd Word64 -> Word64 -> Word64
forall a. Shift a => a -> Word64 -> a
.<. Word64
12) Word64 -> Word64 -> Word64
forall a. BitWise a => a -> a -> a
.|.
            (Word64 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
we Word64 -> Word64 -> Word64
forall a. Shift a => a -> Word64 -> a
.<. Word64
16) Word64 -> Word64 -> Word64
forall a. BitWise a => a -> a -> a
.|.
            (Word64 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
wf Word64 -> Word64 -> Word64
forall a. Shift a => a -> Word64 -> a
.<. Word64
20) Word64 -> Word64 -> Word64
forall a. BitWise a => a -> a -> a
.|.
            (Word64 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
wg Word64 -> Word64 -> Word64
forall a. Shift a => a -> Word64 -> a
.<. Word64
24) Word64 -> Word64 -> Word64
forall a. BitWise a => a -> a -> a
.|.
            (Word64 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
wh Word64 -> Word64 -> Word64
forall a. Shift a => a -> Word64 -> a
.<. Word64
28) Word64 -> Word64 -> Word64
forall a. BitWise a => a -> a -> a
.|.
            (Word64 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
wi Word64 -> Word64 -> Word64
forall a. Shift a => a -> Word64 -> a
.<. Word64
32) Word64 -> Word64 -> Word64
forall a. BitWise a => a -> a -> a
.|.
            (Word64 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
wj Word64 -> Word64 -> Word64
forall a. Shift a => a -> Word64 -> a
.<. Word64
36) Word64 -> Word64 -> Word64
forall a. BitWise a => a -> a -> a
.|.
            (Word64 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
wk Word64 -> Word64 -> Word64
forall a. Shift a => a -> Word64 -> a
.<. Word64
40) Word64 -> Word64 -> Word64
forall a. BitWise a => a -> a -> a
.|.
            (Word64 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
wl Word64 -> Word64 -> Word64
forall a. Shift a => a -> Word64 -> a
.<. Word64
44) Word64 -> Word64 -> Word64
forall a. BitWise a => a -> a -> a
.|.
            (Word64 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
wm Word64 -> Word64 -> Word64
forall a. Shift a => a -> Word64 -> a
.<. Word64
48) Word64 -> Word64 -> Word64
forall a. BitWise a => a -> a -> a
.|.
            (Word64 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
wn Word64 -> Word64 -> Word64
forall a. Shift a => a -> Word64 -> a
.<. Word64
52) Word64 -> Word64 -> Word64
forall a. BitWise a => a -> a -> a
.|.
            (Word64 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
wo Word64 -> Word64 -> Word64
forall a. Shift a => a -> Word64 -> a
.<. Word64
56) Word64 -> Word64 -> Word64
forall a. BitWise a => a -> a -> a
.|.
            (Word64 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word64
wp Word64 -> Word64 -> Word64
forall a. Shift a => a -> Word64 -> a
.<. Word64
60)
{-# INLINE transition16 #-}

transition1 :: IntState -> Word8 -> (IntState, Word64)
transition1 :: IntState -> Word8 -> (IntState, Word64)
transition1 IntState
s Word8
a = (IntState
s', Word64
w)
  where s' :: IntState
s' =                IntState -> Word8 -> IntState
SM.lookupTransitionTable IntState
s (Word8 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
a)
        w :: Word64
w  = Word8 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word8 -> Word64) -> Word8 -> Word64
forall a b. (a -> b) -> a -> b
$ IntState -> Word8 -> Word8
SM.lookupPhiTable        IntState
s (Word8 -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
a)
{-# INLINE transition1 #-}

buildFromByteString3 :: [BS.ByteString] -> [PreSiChunk (DVS.Vector Word64)]
buildFromByteString3 :: [ByteString] -> [PreSiChunk (Vector Word64)]
buildFromByteString3 [ByteString]
bss = Vector Word64 -> PreSiChunk (Vector Word64)
makePreSiChunk (Vector Word64 -> PreSiChunk (Vector Word64))
-> [Vector Word64] -> [PreSiChunk (Vector Word64)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [ByteString] -> [Vector Word64]
buildFromByteString2 [ByteString]
bss
  where makePreSiChunk :: DVS.Vector Word64 -> PreSiChunk (DVS.Vector Word64)
        makePreSiChunk :: Vector Word64 -> PreSiChunk (Vector Word64)
makePreSiChunk Vector Word64
v = Vector Word64
-> Vector Word64 -> Vector Word64 -> PreSiChunk (Vector Word64)
forall v. v -> v -> v -> PreSiChunk v
PreSiChunk (Vector Word64 -> Vector Word64
makeIb Vector Word64
v) (Vector Word64 -> Vector Word64
makeBpOp Vector Word64
v) (Vector Word64 -> Vector Word64
forall a.
(Integral a, Pext a, Storable a) =>
Vector a -> Vector Word64
makeBpCl Vector Word64
v)
        makeIb :: DVS.Vector Word64 -> DVS.Vector Word64
        makeIb :: Vector Word64 -> Vector Word64
makeIb Vector Word64
v = ByteString -> Vector Word64
forall a. AsVector64 a => a -> Vector Word64
asVector64 (ByteString -> Vector Word64) -> ByteString -> Vector Word64
forall a b. (a -> b) -> a -> b
$ Vector Word16 -> ByteString
forall a. ToByteString a => a -> ByteString
BS.toByteString (Vector Word16 -> ByteString) -> Vector Word16 -> ByteString
forall a b. (a -> b) -> a -> b
$ Int -> (Int -> Word16) -> Vector Word16
forall a. Storable a => Int -> (Int -> a) -> Vector a
DVS.generate (Vector Word64 -> Int
forall a. Storable a => Vector a -> Int
DVS.length Vector Word64
v) Int -> Word16
go
          where go :: Int -> Word16
                go :: Int -> Word16
go Int
uj = let ui :: Int
ui = Int -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
uj in Word64 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word64 -> Word64 -> Word64
forall a. Pext a => a -> a -> a
pext (Vector Word64 -> Int -> Word64
forall a. Storable a => Vector a -> Int -> a
DVS.unsafeIndex Vector Word64
v Int
ui) Word64
0x4444444444444444)
        makeBpOp :: DVS.Vector Word64 -> DVS.Vector Word64
        makeBpOp :: Vector Word64 -> Vector Word64
makeBpOp Vector Word64
v = ByteString -> Vector Word64
forall a. AsVector64 a => a -> Vector Word64
asVector64 (ByteString -> Vector Word64) -> ByteString -> Vector Word64
forall a b. (a -> b) -> a -> b
$ Vector Word16 -> ByteString
forall a. ToByteString a => a -> ByteString
BS.toByteString (Vector Word16 -> ByteString) -> Vector Word16 -> ByteString
forall a b. (a -> b) -> a -> b
$ Int -> (Int -> Word16) -> Vector Word16
forall a. Storable a => Int -> (Int -> a) -> Vector a
DVS.generate (Vector Word64 -> Int
forall a. Storable a => Vector a -> Int
DVS.length Vector Word64
v) Int -> Word16
go
          where go :: Int -> Word16
                go :: Int -> Word16
go Int
uj = let ui :: Int
ui = Int -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
uj in Word64 -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word64 -> Word64 -> Word64
forall a. Pext a => a -> a -> a
pext (Vector Word64 -> Int -> Word64
forall a. Storable a => Vector a -> Int -> a
DVS.unsafeIndex Vector Word64
v Int
ui) Word64
0x2222222222222222)
        makeBpCl :: Vector a -> Vector Word64
makeBpCl Vector a
v = ByteString -> Vector Word64
forall a. AsVector64 a => a -> Vector Word64
asVector64 (ByteString -> Vector Word64) -> ByteString -> Vector Word64
forall a b. (a -> b) -> a -> b
$ Vector Word16 -> ByteString
forall a. ToByteString a => a -> ByteString
BS.toByteString (Vector Word16 -> ByteString) -> Vector Word16 -> ByteString
forall a b. (a -> b) -> a -> b
$ Int -> (Int -> Word16) -> Vector Word16
forall a. Storable a => Int -> (Int -> a) -> Vector a
DVS.generate (Vector a -> Int
forall a. Storable a => Vector a -> Int
DVS.length Vector a
v) Int -> Word16
go
          where go :: Int -> Word16
                go :: Int -> Word16
go Int
uj = let ui :: Int
ui = Int -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
uj in a -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral (a -> a -> a
forall a. Pext a => a -> a -> a
pext (Vector a -> Int -> a
forall a. Storable a => Vector a -> Int -> a
DVS.unsafeIndex Vector a
v Int
ui) a
0x1111111111111111)

toIbBpBuilders :: [PreSiChunk (DVS.Vector Word64)] -> [SiChunk (DVS.Vector Word64)]
toIbBpBuilders :: [PreSiChunk (Vector Word64)] -> [SiChunk (Vector Word64)]
toIbBpBuilders = Word64
-> Word64
-> [PreSiChunk (Vector Word64)]
-> [SiChunk (Vector Word64)]
go Word64
0 Word64
0
  where go :: Word64 -> Word64 -> [PreSiChunk (DVS.Vector Word64)] -> [SiChunk (DVS.Vector Word64)]
        go :: Word64
-> Word64
-> [PreSiChunk (Vector Word64)]
-> [SiChunk (Vector Word64)]
go Word64
b Word64
n (PreSiChunk Vector Word64
ib Vector Word64
bpOp Vector Word64
bpCl:[PreSiChunk (Vector Word64)]
cs) = Vector Word64 -> Vector Word64 -> SiChunk (Vector Word64)
forall v. v -> v -> SiChunk v
SiChunk Vector Word64
ib Vector Word64
bpSiChunk (Vector Word64)
-> [SiChunk (Vector Word64)] -> [SiChunk (Vector Word64)]
forall a. a -> [a] -> [a]
: Word64
-> Word64
-> [PreSiChunk (Vector Word64)]
-> [SiChunk (Vector Word64)]
go Word64
b' Word64
n' [PreSiChunk (Vector Word64)]
cs
          where ((Word64
b', Word64
n'), Vector Word64
bp) = Word64
-> Word64
-> Vector Word32
-> Vector Word32
-> ((Word64, Word64), Vector Word64)
mkBp Word64
b Word64
n (Vector Word64 -> Vector Word32
forall a b. (Storable a, Storable b) => Vector a -> Vector b
DVS.unsafeCast Vector Word64
bpOp) (Vector Word64 -> Vector Word32
forall a b. (Storable a, Storable b) => Vector a -> Vector b
DVS.unsafeCast Vector Word64
bpCl)
        go Word64
b Word64
_ [] = [Vector Word64 -> Vector Word64 -> SiChunk (Vector Word64)
forall v. v -> v -> SiChunk v
SiChunk Vector Word64
forall a. Storable a => Vector a
DVS.empty (Word64 -> Vector Word64
forall a. Storable a => a -> Vector a
DVS.singleton Word64
b)]
        mkBp :: Word64 -> Word64 -> DVS.Vector Word32 -> DVS.Vector Word32 -> ((Word64, Word64), DVS.Vector Word64)
        mkBp :: Word64
-> Word64
-> Vector Word32
-> Vector Word32
-> ((Word64, Word64), Vector Word64)
mkBp Word64
b Word64
n Vector Word32
bpOp Vector Word32
bpCl = (forall s. ST s ((Word64, Word64), MVector s Word64))
-> ((Word64, Word64), Vector Word64)
forall (f :: * -> *) a.
(Traversable f, Storable a) =>
(forall s. ST s (f (MVector s a))) -> f (Vector a)
DVS.createT ((forall s. ST s ((Word64, Word64), MVector s Word64))
 -> ((Word64, Word64), Vector Word64))
-> (forall s. ST s ((Word64, Word64), MVector s Word64))
-> ((Word64, Word64), Vector Word64)
forall a b. (a -> b) -> a -> b
$ do
          MVector s Word64
mv <- Int -> ST s (MVector (PrimState (ST s)) Word64)
forall (m :: * -> *) a.
(PrimMonad m, Storable a) =>
Int -> m (MVector (PrimState m) a)
DVSM.unsafeNew (Vector Word32 -> Int
forall a. Storable a => Vector a -> Int
DVS.length Vector Word32
bpOp)
          Word64
-> Word64
-> Vector Word32
-> Vector Word32
-> MVector s Word64
-> Int
-> Int
-> ST s ((Word64, Word64), MVector s Word64)
forall s.
Word64
-> Word64
-> Vector Word32
-> Vector Word32
-> MVector s Word64
-> Int
-> Int
-> ST s ((Word64, Word64), MVector s Word64)
mkBpGo Word64
b Word64
n Vector Word32
bpOp Vector Word32
bpCl MVector s Word64
mv Int
0 Int
0
        mkBpGo :: Word64 -> Word64 -> DVS.Vector Word32 -> DVS.Vector Word32 -> DVS.MVector s Word64 -> Int -> Int -> ST s ((Word64, Word64), DVS.MVector s Word64)
        mkBpGo :: Word64
-> Word64
-> Vector Word32
-> Vector Word32
-> MVector s Word64
-> Int
-> Int
-> ST s ((Word64, Word64), MVector s Word64)
mkBpGo Word64
b Word64
n Vector Word32
bpOp Vector Word32
bpCl MVector s Word64
mv Int
vi Int
mvi = if Int
vi Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< Vector Word32 -> Int
forall a. Storable a => Vector a -> Int
DVS.length Vector Word32
bpOp
          then do
            let op :: Word32
op = Vector Word32 -> Int -> Word32
forall a. Storable a => Vector a -> Int -> a
DVS.unsafeIndex Vector Word32
bpOp Int
vi
            let cl :: Word32
cl = Vector Word32 -> Int -> Word32
forall a. Storable a => Vector a -> Int -> a
DVS.unsafeIndex Vector Word32
bpCl Int
vi
            let (Word64
slo, Word64
mlo) = Word32 -> Word32 -> (Word64, Word64)
compress Word32
op Word32
cl -- slo: source lo, mlo: mask lo
            let wb :: Word64
wb = Word64 -> Word64 -> Word64
forall a. Pext a => a -> a -> a
pext Word64
slo Word64
mlo
            let wn :: Word64
wn = Word64 -> Word64
forall v. PopCount1 v => v -> Word64
popCount1 Word64
mlo
            let tb :: Word64
tb = (Word64
wb Word64 -> Word64 -> Word64
forall a. Shift a => a -> Word64 -> a
.<. Word64
n) Word64 -> Word64 -> Word64
forall a. BitWise a => a -> a -> a
.|. Word64
b
            let tn :: Word64
tn = Word64
n Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
+ Word64
wn
            if Word64
tn Word64 -> Word64 -> Bool
forall a. Ord a => a -> a -> Bool
< Word64
64
              then do
                Word64
-> Word64
-> Vector Word32
-> Vector Word32
-> MVector s Word64
-> Int
-> Int
-> ST s ((Word64, Word64), MVector s Word64)
forall s.
Word64
-> Word64
-> Vector Word32
-> Vector Word32
-> MVector s Word64
-> Int
-> Int
-> ST s ((Word64, Word64), MVector s Word64)
mkBpGo Word64
tb Word64
tn Vector Word32
bpOp Vector Word32
bpCl MVector s Word64
mv (Int
vi Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Int
mvi
              else do
                MVector (PrimState (ST s)) Word64 -> Int -> Word64 -> ST s ()
forall (m :: * -> *) a.
(PrimMonad m, Storable a) =>
MVector (PrimState m) a -> Int -> a -> m ()
DVSM.unsafeWrite MVector s Word64
MVector (PrimState (ST s)) Word64
mv Int
mvi Word64
tb
                let ub :: Word64
ub = Word64
wb Word64 -> Word64 -> Word64
forall a. Shift a => a -> Word64 -> a
.>. (Word64
64 Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
- Word64
n)
                let un :: Word64
un = Word64
tn Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
- Word64
64
                Word64
-> Word64
-> Vector Word32
-> Vector Word32
-> MVector s Word64
-> Int
-> Int
-> ST s ((Word64, Word64), MVector s Word64)
forall s.
Word64
-> Word64
-> Vector Word32
-> Vector Word32
-> MVector s Word64
-> Int
-> Int
-> ST s ((Word64, Word64), MVector s Word64)
mkBpGo Word64
ub Word64
un Vector Word32
bpOp Vector Word32
bpCl MVector s Word64
mv (Int
vi Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) (Int
mvi Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1)
          else ((Word64, Word64), MVector s Word64)
-> ST s ((Word64, Word64), MVector s Word64)
forall (m :: * -> *) a. Monad m => a -> m a
return ((Word64
b, Word64
n), Int -> MVector s Word64 -> MVector s Word64
forall a s. Storable a => Int -> MVector s a -> MVector s a
DVSM.take Int
mvi MVector s Word64
mv)
        compress :: Word32 -> Word32 -> (Word64, Word64)
        compress :: Word32 -> Word32 -> (Word64, Word64)
compress Word32
op Word32
cl = (Word64
sw, Word64
mw)
          where iop :: Word64
iop = Word64 -> Word64 -> Word64
forall a. Pdep a => a -> a -> a
pdep (Word32 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
op :: Word64) Word64
0x5555555555555555 -- interleaved open
                icl :: Word64
icl = Word64 -> Word64 -> Word64
forall a. Pdep a => a -> a -> a
pdep (Word32 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word32
cl :: Word64) Word64
0xaaaaaaaaaaaaaaaa -- interleaved close
                ioc :: Word64
ioc = Word64
iop Word64 -> Word64 -> Word64
forall a. BitWise a => a -> a -> a
.|. Word64
icl                                         -- interleaved open/close
                sw :: Word64
sw  = Word64 -> Word64 -> Word64
forall a. Pext a => a -> a -> a
pext Word64
iop Word64
ioc
                pc :: Word64
pc  = Word64 -> Word64
forall v. PopCount1 v => v -> Word64
popCount1 Word64
ioc
                mw :: Word64
mw  = (Word64
1 Word64 -> Word64 -> Word64
forall a. Shift a => a -> Word64 -> a
.<. Word64
pc) Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
- Word64
1