{-# LANGUAGE MultiWayIf #-}
{-# LANGUAGE ViewPatterns #-}
{-# LANGUAGE Strict #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE TypeApplications #-}
{-# OPTIONS_GHC -Wno-name-shadowing #-}
module Data.FMIndex.Internal (
FMIndexB(..),
FMIndexT(..),
OccCKB(..),
OccCKT(..),
CcB(..),
CcT(..),
CB(..),
CT(..),
PBOccCKSeqB,
OccCKSeqB,
STOccCKSeqB,
updateSTOccCKSeqAB,
updateSTOccCKSeqBB,
emptySTOccCKSeqB,
STOccCKILB,
loadSTOccCKILB,
emptySTOccCKILB,
STOccCKCounterB,
updateSTOccCKCounterB,
emptySTOccCKCounterB,
seqToOccCKB,
PTOccCKSeqT,
OccCKSeqT,
STOccCKSeqT,
updateSTOccCKSeqAT,
updateSTOccCKSeqBT,
emptySTOccCKSeqT,
STOccCKILT,
loadSTOccCKILT,
emptySTOccCKILT,
STOccCKCounterT,
updateSTOccCKCounterT,
emptySTOccCKCounterT,
seqToOccCKT,
PBCcSeqB,
CcSeqB,
STCcSeqB,
updateSTCcSeqB,
emptySTCcSeqB,
STCcILB,
loadSTCcILB,
emptySTCcILB,
STCcCounterB,
updateSTCcCounterB,
emptySTCcCounterB,
seqToCcB,
PTCcSeqT,
CcSeqT,
STCcSeqT,
updateSTCcSeqT,
emptySTCcSeqT,
STCcILT,
loadSTCcILT,
emptySTCcILT,
STCcCounterT,
updateSTCcCounterT,
emptySTCcCounterT,
seqToCcT,
FFMIndexSeqB,
seqFromFMIndexB,
FFMIndexSeqT,
seqFromFMIndexT,
PBCPat,
CIntB,
STCBoolB,
updateSTCBoolB,
emptySTCBoolB,
STCCounterB,
updateSTCCounterB,
emptySTCCounterB,
STCCurrentStartB,
updateSTCCurrentStartB,
emptySTCCurrentStartB,
STCCurrentEndB,
updateSTCCurrentEndB,
emptySTCCurrentEndB,
countFMIndexB,
PTCPat,
CIntT,
STCBoolT,
updateSTCBoolT,
emptySTCBoolT,
STCCounterT,
updateSTCCounterT,
emptySTCCounterT,
STCCurrentStartT,
updateSTCCurrentStartT,
emptySTCCurrentStartT,
STCCurrentEndT,
updateSTCCurrentEndT,
emptySTCCurrentEndT,
countFMIndexT,
PBLPat,
LIntB,
STLBoolB,
updateSTLBoolB,
emptySTLBoolB,
STLCounterB,
updateSTLCounterB,
emptySTLCounterB,
STLCurrentStartB,
updateSTLCurrentStartB,
emptySTLCurrentStartB,
STLCurrentEndB,
updateSTLCurrentEndB,
emptySTLCurrentEndB,
locateFMIndexB,
PTLPat,
LIntT,
STLBoolT,
updateSTLBoolT,
emptySTLBoolT,
STLCounterT,
updateSTLCounterT,
emptySTLCounterT,
STLCurrentStartT,
updateSTLCurrentStartT,
emptySTLCurrentStartT,
STLCurrentEndT,
updateSTLCurrentEndT,
emptySTLCurrentEndT,
locateFMIndexT
) where
import Data.BWT.Internal()
import Data.MTF.Internal
import Control.Monad as CM
import Control.Monad.ST as CMST
import Control.Monad.State.Strict()
import Data.ByteString as BS hiding (count)
import Data.ByteString.Char8()
import Data.ByteString.Internal()
import Data.Foldable()
import Data.List()
import Data.Maybe()
import Data.Sequence as DS (Seq(..),ViewL(..),ViewR(..),empty,findIndexL,fromList,index,length,(|>))
import Data.Sequence.Internal as DSI
import Data.STRef as DSTR
import Data.Text as DText hiding (count)
import GHC.Generics (Generic)
import Prelude as P
newtype FMIndexB = FMIndexB (CcB,OccCKB)
deriving (FMIndexB -> FMIndexB -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FMIndexB -> FMIndexB -> Bool
$c/= :: FMIndexB -> FMIndexB -> Bool
== :: FMIndexB -> FMIndexB -> Bool
$c== :: FMIndexB -> FMIndexB -> Bool
Eq,Eq FMIndexB
FMIndexB -> FMIndexB -> Bool
FMIndexB -> FMIndexB -> Ordering
FMIndexB -> FMIndexB -> FMIndexB
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: FMIndexB -> FMIndexB -> FMIndexB
$cmin :: FMIndexB -> FMIndexB -> FMIndexB
max :: FMIndexB -> FMIndexB -> FMIndexB
$cmax :: FMIndexB -> FMIndexB -> FMIndexB
>= :: FMIndexB -> FMIndexB -> Bool
$c>= :: FMIndexB -> FMIndexB -> Bool
> :: FMIndexB -> FMIndexB -> Bool
$c> :: FMIndexB -> FMIndexB -> Bool
<= :: FMIndexB -> FMIndexB -> Bool
$c<= :: FMIndexB -> FMIndexB -> Bool
< :: FMIndexB -> FMIndexB -> Bool
$c< :: FMIndexB -> FMIndexB -> Bool
compare :: FMIndexB -> FMIndexB -> Ordering
$ccompare :: FMIndexB -> FMIndexB -> Ordering
Ord,Int -> FMIndexB -> ShowS
[FMIndexB] -> ShowS
FMIndexB -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FMIndexB] -> ShowS
$cshowList :: [FMIndexB] -> ShowS
show :: FMIndexB -> String
$cshow :: FMIndexB -> String
showsPrec :: Int -> FMIndexB -> ShowS
$cshowsPrec :: Int -> FMIndexB -> ShowS
Show,ReadPrec [FMIndexB]
ReadPrec FMIndexB
Int -> ReadS FMIndexB
ReadS [FMIndexB]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FMIndexB]
$creadListPrec :: ReadPrec [FMIndexB]
readPrec :: ReadPrec FMIndexB
$creadPrec :: ReadPrec FMIndexB
readList :: ReadS [FMIndexB]
$creadList :: ReadS [FMIndexB]
readsPrec :: Int -> ReadS FMIndexB
$creadsPrec :: Int -> ReadS FMIndexB
Read,forall x. Rep FMIndexB x -> FMIndexB
forall x. FMIndexB -> Rep FMIndexB x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FMIndexB x -> FMIndexB
$cfrom :: forall x. FMIndexB -> Rep FMIndexB x
Generic)
newtype FMIndexT = FMIndexT (CcT,OccCKT)
deriving (FMIndexT -> FMIndexT -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FMIndexT -> FMIndexT -> Bool
$c/= :: FMIndexT -> FMIndexT -> Bool
== :: FMIndexT -> FMIndexT -> Bool
$c== :: FMIndexT -> FMIndexT -> Bool
Eq,Eq FMIndexT
FMIndexT -> FMIndexT -> Bool
FMIndexT -> FMIndexT -> Ordering
FMIndexT -> FMIndexT -> FMIndexT
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: FMIndexT -> FMIndexT -> FMIndexT
$cmin :: FMIndexT -> FMIndexT -> FMIndexT
max :: FMIndexT -> FMIndexT -> FMIndexT
$cmax :: FMIndexT -> FMIndexT -> FMIndexT
>= :: FMIndexT -> FMIndexT -> Bool
$c>= :: FMIndexT -> FMIndexT -> Bool
> :: FMIndexT -> FMIndexT -> Bool
$c> :: FMIndexT -> FMIndexT -> Bool
<= :: FMIndexT -> FMIndexT -> Bool
$c<= :: FMIndexT -> FMIndexT -> Bool
< :: FMIndexT -> FMIndexT -> Bool
$c< :: FMIndexT -> FMIndexT -> Bool
compare :: FMIndexT -> FMIndexT -> Ordering
$ccompare :: FMIndexT -> FMIndexT -> Ordering
Ord,Int -> FMIndexT -> ShowS
[FMIndexT] -> ShowS
FMIndexT -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [FMIndexT] -> ShowS
$cshowList :: [FMIndexT] -> ShowS
show :: FMIndexT -> String
$cshow :: FMIndexT -> String
showsPrec :: Int -> FMIndexT -> ShowS
$cshowsPrec :: Int -> FMIndexT -> ShowS
Show,ReadPrec [FMIndexT]
ReadPrec FMIndexT
Int -> ReadS FMIndexT
ReadS [FMIndexT]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [FMIndexT]
$creadListPrec :: ReadPrec [FMIndexT]
readPrec :: ReadPrec FMIndexT
$creadPrec :: ReadPrec FMIndexT
readList :: ReadS [FMIndexT]
$creadList :: ReadS [FMIndexT]
readsPrec :: Int -> ReadS FMIndexT
$creadsPrec :: Int -> ReadS FMIndexT
Read,forall x. Rep FMIndexT x -> FMIndexT
forall x. FMIndexT -> Rep FMIndexT x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep FMIndexT x -> FMIndexT
$cfrom :: forall x. FMIndexT -> Rep FMIndexT x
Generic)
newtype OccCKB = OccCKB (Seq (Maybe ByteString,Seq (Int,Int,Maybe ByteString)))
deriving (OccCKB -> OccCKB -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OccCKB -> OccCKB -> Bool
$c/= :: OccCKB -> OccCKB -> Bool
== :: OccCKB -> OccCKB -> Bool
$c== :: OccCKB -> OccCKB -> Bool
Eq,Eq OccCKB
OccCKB -> OccCKB -> Bool
OccCKB -> OccCKB -> Ordering
OccCKB -> OccCKB -> OccCKB
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: OccCKB -> OccCKB -> OccCKB
$cmin :: OccCKB -> OccCKB -> OccCKB
max :: OccCKB -> OccCKB -> OccCKB
$cmax :: OccCKB -> OccCKB -> OccCKB
>= :: OccCKB -> OccCKB -> Bool
$c>= :: OccCKB -> OccCKB -> Bool
> :: OccCKB -> OccCKB -> Bool
$c> :: OccCKB -> OccCKB -> Bool
<= :: OccCKB -> OccCKB -> Bool
$c<= :: OccCKB -> OccCKB -> Bool
< :: OccCKB -> OccCKB -> Bool
$c< :: OccCKB -> OccCKB -> Bool
compare :: OccCKB -> OccCKB -> Ordering
$ccompare :: OccCKB -> OccCKB -> Ordering
Ord,Int -> OccCKB -> ShowS
[OccCKB] -> ShowS
OccCKB -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OccCKB] -> ShowS
$cshowList :: [OccCKB] -> ShowS
show :: OccCKB -> String
$cshow :: OccCKB -> String
showsPrec :: Int -> OccCKB -> ShowS
$cshowsPrec :: Int -> OccCKB -> ShowS
Show,ReadPrec [OccCKB]
ReadPrec OccCKB
Int -> ReadS OccCKB
ReadS [OccCKB]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [OccCKB]
$creadListPrec :: ReadPrec [OccCKB]
readPrec :: ReadPrec OccCKB
$creadPrec :: ReadPrec OccCKB
readList :: ReadS [OccCKB]
$creadList :: ReadS [OccCKB]
readsPrec :: Int -> ReadS OccCKB
$creadsPrec :: Int -> ReadS OccCKB
Read,forall x. Rep OccCKB x -> OccCKB
forall x. OccCKB -> Rep OccCKB x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep OccCKB x -> OccCKB
$cfrom :: forall x. OccCKB -> Rep OccCKB x
Generic)
newtype OccCKT = OccCKT (Seq (Maybe Text,Seq (Int,Int,Maybe Text)))
deriving (OccCKT -> OccCKT -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OccCKT -> OccCKT -> Bool
$c/= :: OccCKT -> OccCKT -> Bool
== :: OccCKT -> OccCKT -> Bool
$c== :: OccCKT -> OccCKT -> Bool
Eq,Eq OccCKT
OccCKT -> OccCKT -> Bool
OccCKT -> OccCKT -> Ordering
OccCKT -> OccCKT -> OccCKT
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: OccCKT -> OccCKT -> OccCKT
$cmin :: OccCKT -> OccCKT -> OccCKT
max :: OccCKT -> OccCKT -> OccCKT
$cmax :: OccCKT -> OccCKT -> OccCKT
>= :: OccCKT -> OccCKT -> Bool
$c>= :: OccCKT -> OccCKT -> Bool
> :: OccCKT -> OccCKT -> Bool
$c> :: OccCKT -> OccCKT -> Bool
<= :: OccCKT -> OccCKT -> Bool
$c<= :: OccCKT -> OccCKT -> Bool
< :: OccCKT -> OccCKT -> Bool
$c< :: OccCKT -> OccCKT -> Bool
compare :: OccCKT -> OccCKT -> Ordering
$ccompare :: OccCKT -> OccCKT -> Ordering
Ord,Int -> OccCKT -> ShowS
[OccCKT] -> ShowS
OccCKT -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OccCKT] -> ShowS
$cshowList :: [OccCKT] -> ShowS
show :: OccCKT -> String
$cshow :: OccCKT -> String
showsPrec :: Int -> OccCKT -> ShowS
$cshowsPrec :: Int -> OccCKT -> ShowS
Show,ReadPrec [OccCKT]
ReadPrec OccCKT
Int -> ReadS OccCKT
ReadS [OccCKT]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [OccCKT]
$creadListPrec :: ReadPrec [OccCKT]
readPrec :: ReadPrec OccCKT
$creadPrec :: ReadPrec OccCKT
readList :: ReadS [OccCKT]
$creadList :: ReadS [OccCKT]
readsPrec :: Int -> ReadS OccCKT
$creadsPrec :: Int -> ReadS OccCKT
Read,forall x. Rep OccCKT x -> OccCKT
forall x. OccCKT -> Rep OccCKT x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep OccCKT x -> OccCKT
$cfrom :: forall x. OccCKT -> Rep OccCKT x
Generic)
newtype CcB = CcB (Seq (Int,Maybe ByteString))
deriving (CcB -> CcB -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CcB -> CcB -> Bool
$c/= :: CcB -> CcB -> Bool
== :: CcB -> CcB -> Bool
$c== :: CcB -> CcB -> Bool
Eq,Eq CcB
CcB -> CcB -> Bool
CcB -> CcB -> Ordering
CcB -> CcB -> CcB
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CcB -> CcB -> CcB
$cmin :: CcB -> CcB -> CcB
max :: CcB -> CcB -> CcB
$cmax :: CcB -> CcB -> CcB
>= :: CcB -> CcB -> Bool
$c>= :: CcB -> CcB -> Bool
> :: CcB -> CcB -> Bool
$c> :: CcB -> CcB -> Bool
<= :: CcB -> CcB -> Bool
$c<= :: CcB -> CcB -> Bool
< :: CcB -> CcB -> Bool
$c< :: CcB -> CcB -> Bool
compare :: CcB -> CcB -> Ordering
$ccompare :: CcB -> CcB -> Ordering
Ord,Int -> CcB -> ShowS
[CcB] -> ShowS
CcB -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CcB] -> ShowS
$cshowList :: [CcB] -> ShowS
show :: CcB -> String
$cshow :: CcB -> String
showsPrec :: Int -> CcB -> ShowS
$cshowsPrec :: Int -> CcB -> ShowS
Show,ReadPrec [CcB]
ReadPrec CcB
Int -> ReadS CcB
ReadS [CcB]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CcB]
$creadListPrec :: ReadPrec [CcB]
readPrec :: ReadPrec CcB
$creadPrec :: ReadPrec CcB
readList :: ReadS [CcB]
$creadList :: ReadS [CcB]
readsPrec :: Int -> ReadS CcB
$creadsPrec :: Int -> ReadS CcB
Read,forall x. Rep CcB x -> CcB
forall x. CcB -> Rep CcB x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CcB x -> CcB
$cfrom :: forall x. CcB -> Rep CcB x
Generic)
newtype CcT = CcT (Seq (Int,Maybe Text))
deriving (CcT -> CcT -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CcT -> CcT -> Bool
$c/= :: CcT -> CcT -> Bool
== :: CcT -> CcT -> Bool
$c== :: CcT -> CcT -> Bool
Eq,Eq CcT
CcT -> CcT -> Bool
CcT -> CcT -> Ordering
CcT -> CcT -> CcT
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CcT -> CcT -> CcT
$cmin :: CcT -> CcT -> CcT
max :: CcT -> CcT -> CcT
$cmax :: CcT -> CcT -> CcT
>= :: CcT -> CcT -> Bool
$c>= :: CcT -> CcT -> Bool
> :: CcT -> CcT -> Bool
$c> :: CcT -> CcT -> Bool
<= :: CcT -> CcT -> Bool
$c<= :: CcT -> CcT -> Bool
< :: CcT -> CcT -> Bool
$c< :: CcT -> CcT -> Bool
compare :: CcT -> CcT -> Ordering
$ccompare :: CcT -> CcT -> Ordering
Ord,Int -> CcT -> ShowS
[CcT] -> ShowS
CcT -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CcT] -> ShowS
$cshowList :: [CcT] -> ShowS
show :: CcT -> String
$cshow :: CcT -> String
showsPrec :: Int -> CcT -> ShowS
$cshowsPrec :: Int -> CcT -> ShowS
Show,ReadPrec [CcT]
ReadPrec CcT
Int -> ReadS CcT
ReadS [CcT]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CcT]
$creadListPrec :: ReadPrec [CcT]
readPrec :: ReadPrec CcT
$creadPrec :: ReadPrec CcT
readList :: ReadS [CcT]
$creadList :: ReadS [CcT]
readsPrec :: Int -> ReadS CcT
$creadsPrec :: Int -> ReadS CcT
Read,forall x. Rep CcT x -> CcT
forall x. CcT -> Rep CcT x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CcT x -> CcT
$cfrom :: forall x. CcT -> Rep CcT x
Generic)
newtype CB = CB (Maybe Int)
deriving (CB -> CB -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CB -> CB -> Bool
$c/= :: CB -> CB -> Bool
== :: CB -> CB -> Bool
$c== :: CB -> CB -> Bool
Eq,Eq CB
CB -> CB -> Bool
CB -> CB -> Ordering
CB -> CB -> CB
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CB -> CB -> CB
$cmin :: CB -> CB -> CB
max :: CB -> CB -> CB
$cmax :: CB -> CB -> CB
>= :: CB -> CB -> Bool
$c>= :: CB -> CB -> Bool
> :: CB -> CB -> Bool
$c> :: CB -> CB -> Bool
<= :: CB -> CB -> Bool
$c<= :: CB -> CB -> Bool
< :: CB -> CB -> Bool
$c< :: CB -> CB -> Bool
compare :: CB -> CB -> Ordering
$ccompare :: CB -> CB -> Ordering
Ord,Int -> CB -> ShowS
[CB] -> ShowS
CB -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CB] -> ShowS
$cshowList :: [CB] -> ShowS
show :: CB -> String
$cshow :: CB -> String
showsPrec :: Int -> CB -> ShowS
$cshowsPrec :: Int -> CB -> ShowS
Show,ReadPrec [CB]
ReadPrec CB
Int -> ReadS CB
ReadS [CB]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CB]
$creadListPrec :: ReadPrec [CB]
readPrec :: ReadPrec CB
$creadPrec :: ReadPrec CB
readList :: ReadS [CB]
$creadList :: ReadS [CB]
readsPrec :: Int -> ReadS CB
$creadsPrec :: Int -> ReadS CB
Read,forall x. Rep CB x -> CB
forall x. CB -> Rep CB x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CB x -> CB
$cfrom :: forall x. CB -> Rep CB x
Generic)
newtype CT = CT (Maybe Int)
deriving (CT -> CT -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CT -> CT -> Bool
$c/= :: CT -> CT -> Bool
== :: CT -> CT -> Bool
$c== :: CT -> CT -> Bool
Eq,Eq CT
CT -> CT -> Bool
CT -> CT -> Ordering
CT -> CT -> CT
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: CT -> CT -> CT
$cmin :: CT -> CT -> CT
max :: CT -> CT -> CT
$cmax :: CT -> CT -> CT
>= :: CT -> CT -> Bool
$c>= :: CT -> CT -> Bool
> :: CT -> CT -> Bool
$c> :: CT -> CT -> Bool
<= :: CT -> CT -> Bool
$c<= :: CT -> CT -> Bool
< :: CT -> CT -> Bool
$c< :: CT -> CT -> Bool
compare :: CT -> CT -> Ordering
$ccompare :: CT -> CT -> Ordering
Ord,Int -> CT -> ShowS
[CT] -> ShowS
CT -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CT] -> ShowS
$cshowList :: [CT] -> ShowS
show :: CT -> String
$cshow :: CT -> String
showsPrec :: Int -> CT -> ShowS
$cshowsPrec :: Int -> CT -> ShowS
Show,ReadPrec [CT]
ReadPrec CT
Int -> ReadS CT
ReadS [CT]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CT]
$creadListPrec :: ReadPrec [CT]
readPrec :: ReadPrec CT
$creadPrec :: ReadPrec CT
readList :: ReadS [CT]
$creadList :: ReadS [CT]
readsPrec :: Int -> ReadS CT
$creadsPrec :: Int -> ReadS CT
Read,forall x. Rep CT x -> CT
forall x. CT -> Rep CT x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CT x -> CT
$cfrom :: forall x. CT -> Rep CT x
Generic)
type PBOccCKSeqB = Seq (Maybe ByteString)
type OccCKSeqB = Seq (Maybe ByteString,Seq (Int,Int,Maybe ByteString))
type STOccCKSeqB s a = STRef s OccCKSeqB
updateSTOccCKSeqAB :: STOccCKSeqB s (Seq (Maybe ByteString,Seq (Int,Int,Maybe ByteString)))
-> (Int,Int,Maybe ByteString)
-> ST s ()
updateSTOccCKSeqAB :: forall s.
STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
-> (Int, Int, Maybe ByteString) -> ST s ()
updateSTOccCKSeqAB STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
s (Int, Int, Maybe ByteString)
e = do
Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
s2 <- forall s a. STRef s a -> ST s a
readSTRef STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
s
case forall a. Seq a -> ViewR a
viewr Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
s2 of
ViewR (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
EmptyR -> forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
(Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
s2h DS.:> (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
s2fm) -> forall s a. STRef s a -> a -> ST s ()
writeSTRef STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
s2h forall a. Seq a -> a -> Seq a
DS.|> (((\(Maybe ByteString
a,Seq (Int, Int, Maybe ByteString)
_) -> Maybe ByteString
a) (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
s2fm),((\(Maybe ByteString
_,Seq (Int, Int, Maybe ByteString)
b) -> Seq (Int, Int, Maybe ByteString)
b) (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
s2fm) forall a. Seq a -> a -> Seq a
DS.|> (Int, Int, Maybe ByteString)
e))
updateSTOccCKSeqBB :: STOccCKSeqB s (Seq (Maybe ByteString,Seq (Int,Int,Maybe ByteString)))
-> Maybe ByteString
-> ST s ()
updateSTOccCKSeqBB :: forall s.
STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
-> Maybe ByteString -> ST s ()
updateSTOccCKSeqBB STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
s Maybe ByteString
e = do
Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
s2 <- forall s a. STRef s a -> ST s a
readSTRef STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
s
forall s a. STRef s a -> a -> ST s ()
writeSTRef STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
s2 forall a. Seq a -> a -> Seq a
DS.|> (Maybe ByteString
e,forall a. Seq a
DS.empty))
emptySTOccCKSeqB :: ST s (STOccCKSeqB s a)
emptySTOccCKSeqB :: forall s a. ST s (STOccCKSeqB s a)
emptySTOccCKSeqB = forall a s. a -> ST s (STRef s a)
newSTRef forall a. Seq a
DS.empty
type STOccCKILB s a = STRef s (Seq (Maybe ByteString))
loadSTOccCKILB :: STOccCKILB s (Maybe ByteString)
-> Seq (Maybe ByteString)
-> ST s ()
loadSTOccCKILB :: forall s.
STOccCKILB s (Maybe ByteString)
-> Seq (Maybe ByteString) -> ST s ()
loadSTOccCKILB STOccCKILB s (Maybe ByteString)
s Seq (Maybe ByteString)
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STOccCKILB s (Maybe ByteString)
s Seq (Maybe ByteString)
e
emptySTOccCKILB :: ST s (STOccCKILB s a)
emptySTOccCKILB :: forall s a. ST s (STOccCKILB s a)
emptySTOccCKILB = forall a s. a -> ST s (STRef s a)
newSTRef forall a. Seq a
DS.empty
type STOccCKCounterB s a = STRef s Int
updateSTOccCKCounterB :: STOccCKCounterB s Int
-> Int
-> ST s ()
updateSTOccCKCounterB :: forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTOccCKCounterB STOccCKCounterB s Int
s Int
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STOccCKCounterB s Int
s Int
e
emptySTOccCKCounterB :: ST s (STOccCKCounterB s Int)
emptySTOccCKCounterB :: forall s. ST s (STOccCKCounterB s Int)
emptySTOccCKCounterB = forall a s. a -> ST s (STRef s a)
newSTRef Int
0
seqToOccCKB :: PBOccCKSeqB
-> ST s OccCKSeqB
seqToOccCKB :: forall s.
Seq (Maybe ByteString)
-> ST s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
seqToOccCKB Seq (Maybe ByteString)
DS.Empty = do
STOccCKSeqB s Any
boccckseqstackempty <- forall s a. ST s (STOccCKSeqB s a)
emptySTOccCKSeqB
Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
boccckseqstackemptyr <- forall s a. STRef s a -> ST s a
readSTRef STOccCKSeqB s Any
boccckseqstackempty
forall (m :: * -> *) a. Monad m => a -> m a
return Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
boccckseqstackemptyr
seqToOccCKB Seq (Maybe ByteString)
xs = do
STOccCKSeqB s Any
boccckseqstack <- forall s a. ST s (STOccCKSeqB s a)
emptySTOccCKSeqB
STOccCKILB s Any
boccckinitiallist <- forall s a. ST s (STOccCKILB s a)
emptySTOccCKILB
STOccCKCounterB s Int
boccckcounterstack <- forall s. ST s (STOccCKCounterB s Int)
emptySTOccCKCounterB
let il :: Seq (Maybe ByteString)
il = forall a. Ord a => Seq (Maybe a) -> Seq (Maybe a)
nubSeq' Seq (Maybe ByteString)
xs
forall s.
STOccCKILB s (Maybe ByteString)
-> Seq (Maybe ByteString) -> ST s ()
loadSTOccCKILB STOccCKILB s Any
boccckinitiallist
Seq (Maybe ByteString)
il
Seq (Maybe ByteString)
cboccckinitiallist <- forall s a. STRef s a -> ST s a
readSTRef STOccCKILB s Any
boccckinitiallist
forall {s}.
Seq (Maybe ByteString)
-> Seq (Maybe ByteString)
-> STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
-> STOccCKCounterB s Int
-> ST s ()
iOccCKB Seq (Maybe ByteString)
cboccckinitiallist
Seq (Maybe ByteString)
xs
STOccCKSeqB s Any
boccckseqstack
STOccCKCounterB s Int
boccckcounterstack
Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
boccckseqstackr <- forall s a. STRef s a -> ST s a
readSTRef STOccCKSeqB s Any
boccckseqstack
forall (m :: * -> *) a. Monad m => a -> m a
return Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
boccckseqstackr
where
iOccCKB :: Seq (Maybe ByteString)
-> Seq (Maybe ByteString)
-> STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
-> STOccCKCounterB s Int
-> ST s ()
iOccCKB Seq (Maybe ByteString)
DS.Empty Seq (Maybe ByteString)
_ STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
_ STOccCKCounterB s Int
_ = forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
iOccCKB (Maybe ByteString
y DS.:<| Seq (Maybe ByteString)
ys) Seq (Maybe ByteString)
zs STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
boccckss STOccCKCounterB s Int
boccckcs = do
STOccCKCounterB s Int
boccckis <- forall s. ST s (STOccCKCounterB s Int)
emptySTOccCKCounterB
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTOccCKCounterB STOccCKCounterB s Int
boccckis
Int
1
forall s.
STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
-> Maybe ByteString -> ST s ()
updateSTOccCKSeqBB STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
boccckss
Maybe ByteString
y
forall {s}.
Maybe ByteString
-> Seq (Maybe ByteString)
-> STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
-> STRef s Int
-> STRef s Int
-> ST s ()
iiOccCKB Maybe ByteString
y
Seq (Maybe ByteString)
zs
STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
boccckss
STOccCKCounterB s Int
boccckis
STOccCKCounterB s Int
boccckcs
Seq (Maybe ByteString)
-> Seq (Maybe ByteString)
-> STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
-> STOccCKCounterB s Int
-> ST s ()
iOccCKB Seq (Maybe ByteString)
ys
Seq (Maybe ByteString)
zs
STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
boccckss
STOccCKCounterB s Int
boccckcs
iiOccCKB :: Maybe ByteString
-> Seq (Maybe ByteString)
-> STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
-> STRef s Int
-> STRef s Int
-> ST s ()
iiOccCKB Maybe ByteString
_ Seq (Maybe ByteString)
DS.Empty STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
_ STRef s Int
_ STRef s Int
boccckcs = do
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTOccCKCounterB STRef s Int
boccckcs
Int
0
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
iiOccCKB Maybe ByteString
as (Maybe ByteString
b DS.:<| Seq (Maybe ByteString)
bs) STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
boccckss STRef s Int
boccckis STRef s Int
boccckcs = do
Int
cboccckis <- forall s a. STRef s a -> ST s a
readSTRef STRef s Int
boccckis
Int
cboccckcs <- forall s a. STRef s a -> ST s a
readSTRef STRef s Int
boccckcs
if | Maybe ByteString
as forall a. Eq a => a -> a -> Bool
== Maybe ByteString
b
-> do forall s.
STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
-> (Int, Int, Maybe ByteString) -> ST s ()
updateSTOccCKSeqAB STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
boccckss
(Int
cboccckis,Int
cboccckcs forall a. Num a => a -> a -> a
+ Int
1,Maybe ByteString
b)
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTOccCKCounterB STRef s Int
boccckcs
(Int
cboccckcs forall a. Num a => a -> a -> a
+ Int
1)
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTOccCKCounterB STRef s Int
boccckis
(Int
cboccckis forall a. Num a => a -> a -> a
+ Int
1)
Maybe ByteString
-> Seq (Maybe ByteString)
-> STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
-> STRef s Int
-> STRef s Int
-> ST s ()
iiOccCKB Maybe ByteString
as
Seq (Maybe ByteString)
bs
STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
boccckss
STRef s Int
boccckis
STRef s Int
boccckcs
| Bool
otherwise
-> do forall s.
STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
-> (Int, Int, Maybe ByteString) -> ST s ()
updateSTOccCKSeqAB STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
boccckss
(Int
cboccckis,Int
cboccckcs,Maybe ByteString
b)
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTOccCKCounterB STRef s Int
boccckis
(Int
cboccckis forall a. Num a => a -> a -> a
+ Int
1)
Maybe ByteString
-> Seq (Maybe ByteString)
-> STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
-> STRef s Int
-> STRef s Int
-> ST s ()
iiOccCKB Maybe ByteString
as
Seq (Maybe ByteString)
bs
STOccCKSeqB
s (Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString)))
boccckss
STRef s Int
boccckis
STRef s Int
boccckcs
type PTOccCKSeqT = Seq (Maybe Text)
type OccCKSeqT = Seq (Maybe Text,Seq (Int,Int,Maybe Text))
type STOccCKSeqT s a = STRef s OccCKSeqT
updateSTOccCKSeqAT :: STOccCKSeqT s (Seq (Maybe Text,Seq (Int,Int,Maybe Text)))
-> (Int,Int,Maybe Text)
-> ST s ()
updateSTOccCKSeqAT :: forall s.
STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
-> (Int, Int, Maybe Text) -> ST s ()
updateSTOccCKSeqAT STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
s (Int, Int, Maybe Text)
e = do
Seq (Maybe Text, Seq (Int, Int, Maybe Text))
s2 <- forall s a. STRef s a -> ST s a
readSTRef STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
s
case forall a. Seq a -> ViewR a
viewr Seq (Maybe Text, Seq (Int, Int, Maybe Text))
s2 of
ViewR (Maybe Text, Seq (Int, Int, Maybe Text))
EmptyR -> forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
(Seq (Maybe Text, Seq (Int, Int, Maybe Text))
s2h DS.:> (Maybe Text, Seq (Int, Int, Maybe Text))
s2fm) -> forall s a. STRef s a -> a -> ST s ()
writeSTRef STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
s (Seq (Maybe Text, Seq (Int, Int, Maybe Text))
s2h forall a. Seq a -> a -> Seq a
DS.|> (((\(Maybe Text
a,Seq (Int, Int, Maybe Text)
_) -> Maybe Text
a) (Maybe Text, Seq (Int, Int, Maybe Text))
s2fm),((\(Maybe Text
_,Seq (Int, Int, Maybe Text)
b) -> Seq (Int, Int, Maybe Text)
b) (Maybe Text, Seq (Int, Int, Maybe Text))
s2fm) forall a. Seq a -> a -> Seq a
DS.|> (Int, Int, Maybe Text)
e))
updateSTOccCKSeqBT :: STOccCKSeqT s (Seq (Maybe Text,Seq (Int,Int,Maybe Text)))
-> Maybe Text
-> ST s ()
updateSTOccCKSeqBT :: forall s.
STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
-> Maybe Text -> ST s ()
updateSTOccCKSeqBT STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
s Maybe Text
e = do
Seq (Maybe Text, Seq (Int, Int, Maybe Text))
s2 <- forall s a. STRef s a -> ST s a
readSTRef STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
s
forall s a. STRef s a -> a -> ST s ()
writeSTRef STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
s (Seq (Maybe Text, Seq (Int, Int, Maybe Text))
s2 forall a. Seq a -> a -> Seq a
DS.|> (Maybe Text
e,forall a. Seq a
DS.empty))
emptySTOccCKSeqT :: ST s (STOccCKSeqT s a)
emptySTOccCKSeqT :: forall s a. ST s (STOccCKSeqT s a)
emptySTOccCKSeqT = forall a s. a -> ST s (STRef s a)
newSTRef forall a. Seq a
DS.empty
type STOccCKILT s a = STRef s (Seq (Maybe Text))
loadSTOccCKILT :: STOccCKILT s (Maybe Text)
-> Seq (Maybe Text)
-> ST s ()
loadSTOccCKILT :: forall s. STOccCKILT s (Maybe Text) -> Seq (Maybe Text) -> ST s ()
loadSTOccCKILT STOccCKILT s (Maybe Text)
s Seq (Maybe Text)
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STOccCKILT s (Maybe Text)
s Seq (Maybe Text)
e
emptySTOccCKILT :: ST s (STOccCKILT s a)
emptySTOccCKILT :: forall s a. ST s (STOccCKILT s a)
emptySTOccCKILT = forall a s. a -> ST s (STRef s a)
newSTRef forall a. Seq a
DS.empty
type STOccCKCounterT s a = STRef s Int
updateSTOccCKCounterT :: STOccCKCounterT s Int
-> Int
-> ST s ()
updateSTOccCKCounterT :: forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTOccCKCounterT STOccCKCounterT s Int
s Int
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STOccCKCounterT s Int
s Int
e
emptySTOccCKCounterT :: ST s (STOccCKCounterT s Int)
emptySTOccCKCounterT :: forall s. ST s (STOccCKCounterB s Int)
emptySTOccCKCounterT = forall a s. a -> ST s (STRef s a)
newSTRef Int
0
seqToOccCKT :: PTOccCKSeqT
-> ST s OccCKSeqT
seqToOccCKT :: forall s.
Seq (Maybe Text)
-> ST s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
seqToOccCKT Seq (Maybe Text)
DS.Empty = do
STOccCKSeqT s Any
toccckseqstackempty <- forall s a. ST s (STOccCKSeqT s a)
emptySTOccCKSeqT
Seq (Maybe Text, Seq (Int, Int, Maybe Text))
toccckseqstackemptyr <- forall s a. STRef s a -> ST s a
readSTRef STOccCKSeqT s Any
toccckseqstackempty
forall (m :: * -> *) a. Monad m => a -> m a
return Seq (Maybe Text, Seq (Int, Int, Maybe Text))
toccckseqstackemptyr
seqToOccCKT Seq (Maybe Text)
xs = do
STOccCKSeqT s Any
toccckseqstack <- forall s a. ST s (STOccCKSeqT s a)
emptySTOccCKSeqT
STOccCKILT s Any
toccckinitiallist <- forall s a. ST s (STOccCKILT s a)
emptySTOccCKILT
STOccCKCounterT s Int
toccckcounterstack <- forall s. ST s (STOccCKCounterB s Int)
emptySTOccCKCounterT
let il :: Seq (Maybe Text)
il = forall a. Ord a => Seq (Maybe a) -> Seq (Maybe a)
nubSeq' Seq (Maybe Text)
xs
forall s. STOccCKILT s (Maybe Text) -> Seq (Maybe Text) -> ST s ()
loadSTOccCKILT STOccCKILT s Any
toccckinitiallist
Seq (Maybe Text)
il
Seq (Maybe Text)
ctoccckinitiallist <- forall s a. STRef s a -> ST s a
readSTRef STOccCKILT s Any
toccckinitiallist
forall {s}.
Seq (Maybe Text)
-> Seq (Maybe Text)
-> STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
-> STOccCKCounterT s Int
-> ST s ()
iOccCKT Seq (Maybe Text)
ctoccckinitiallist
Seq (Maybe Text)
xs
STOccCKSeqT s Any
toccckseqstack
STOccCKCounterT s Int
toccckcounterstack
Seq (Maybe Text, Seq (Int, Int, Maybe Text))
toccckseqstackr <- forall s a. STRef s a -> ST s a
readSTRef STOccCKSeqT s Any
toccckseqstack
forall (m :: * -> *) a. Monad m => a -> m a
return Seq (Maybe Text, Seq (Int, Int, Maybe Text))
toccckseqstackr
where
iOccCKT :: Seq (Maybe Text)
-> Seq (Maybe Text)
-> STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
-> STOccCKCounterT s Int
-> ST s ()
iOccCKT Seq (Maybe Text)
DS.Empty Seq (Maybe Text)
_ STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
_ STOccCKCounterT s Int
_ = forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
iOccCKT (Maybe Text
y DS.:<| Seq (Maybe Text)
ys) Seq (Maybe Text)
zs STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
toccckss STOccCKCounterT s Int
toccckcs = do
STOccCKCounterT s Int
toccckis <- forall s. ST s (STOccCKCounterB s Int)
emptySTOccCKCounterT
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTOccCKCounterT STOccCKCounterT s Int
toccckis
Int
1
forall s.
STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
-> Maybe Text -> ST s ()
updateSTOccCKSeqBT STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
toccckss
Maybe Text
y
forall {s}.
Maybe Text
-> Seq (Maybe Text)
-> STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
-> STRef s Int
-> STRef s Int
-> ST s ()
iiOccCKT Maybe Text
y
Seq (Maybe Text)
zs
STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
toccckss
STOccCKCounterT s Int
toccckis
STOccCKCounterT s Int
toccckcs
Seq (Maybe Text)
-> Seq (Maybe Text)
-> STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
-> STOccCKCounterT s Int
-> ST s ()
iOccCKT Seq (Maybe Text)
ys
Seq (Maybe Text)
zs
STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
toccckss
STOccCKCounterT s Int
toccckcs
iiOccCKT :: Maybe Text
-> Seq (Maybe Text)
-> STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
-> STRef s Int
-> STRef s Int
-> ST s ()
iiOccCKT Maybe Text
_ Seq (Maybe Text)
DS.Empty STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
_ STRef s Int
_ STRef s Int
toccckcs = do
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTOccCKCounterT STRef s Int
toccckcs
Int
0
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
iiOccCKT Maybe Text
as (Maybe Text
b DS.:<| Seq (Maybe Text)
bs) STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
toccckss STRef s Int
toccckis STRef s Int
toccckcs = do
Int
ctoccckis <- forall s a. STRef s a -> ST s a
readSTRef STRef s Int
toccckis
Int
ctoccckcs <- forall s a. STRef s a -> ST s a
readSTRef STRef s Int
toccckcs
if | Maybe Text
as forall a. Eq a => a -> a -> Bool
== Maybe Text
b
-> do forall s.
STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
-> (Int, Int, Maybe Text) -> ST s ()
updateSTOccCKSeqAT STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
toccckss
(Int
ctoccckis,Int
ctoccckcs forall a. Num a => a -> a -> a
+ Int
1,Maybe Text
b)
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTOccCKCounterT STRef s Int
toccckcs
(Int
ctoccckcs forall a. Num a => a -> a -> a
+ Int
1)
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTOccCKCounterT STRef s Int
toccckis
(Int
ctoccckis forall a. Num a => a -> a -> a
+ Int
1)
Maybe Text
-> Seq (Maybe Text)
-> STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
-> STRef s Int
-> STRef s Int
-> ST s ()
iiOccCKT Maybe Text
as
Seq (Maybe Text)
bs
STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
toccckss
STRef s Int
toccckis
STRef s Int
toccckcs
| Bool
otherwise
-> do forall s.
STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
-> (Int, Int, Maybe Text) -> ST s ()
updateSTOccCKSeqAT STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
toccckss
(Int
ctoccckis,Int
ctoccckcs,Maybe Text
b)
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTOccCKCounterT STRef s Int
toccckis
(Int
ctoccckis forall a. Num a => a -> a -> a
+ Int
1)
Maybe Text
-> Seq (Maybe Text)
-> STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
-> STRef s Int
-> STRef s Int
-> ST s ()
iiOccCKT Maybe Text
as
Seq (Maybe Text)
bs
STOccCKSeqT s (Seq (Maybe Text, Seq (Int, Int, Maybe Text)))
toccckss
STRef s Int
toccckis
STRef s Int
toccckcs
type PBCcSeqB = Seq (Maybe ByteString)
type CcSeqB = Seq (Int,Maybe ByteString)
type STCcSeqB s a = STRef s CcSeqB
updateSTCcSeqB :: STCcSeqB s (Seq (Int,Maybe ByteString))
-> (Int,Maybe ByteString)
-> ST s ()
updateSTCcSeqB :: forall s.
STCcSeqB s (Seq (Int, Maybe ByteString))
-> (Int, Maybe ByteString) -> ST s ()
updateSTCcSeqB STCcSeqB s (Seq (Int, Maybe ByteString))
s (Int, Maybe ByteString)
e = do
Seq (Int, Maybe ByteString)
s2 <- forall s a. STRef s a -> ST s a
readSTRef STCcSeqB s (Seq (Int, Maybe ByteString))
s
forall s a. STRef s a -> a -> ST s ()
writeSTRef STCcSeqB s (Seq (Int, Maybe ByteString))
s (Seq (Int, Maybe ByteString)
s2 forall a. Seq a -> a -> Seq a
DS.|> (Int, Maybe ByteString)
e)
emptySTCcSeqB :: ST s (STCcSeqB s a)
emptySTCcSeqB :: forall s a. ST s (STCcSeqB s a)
emptySTCcSeqB = forall a s. a -> ST s (STRef s a)
newSTRef forall a. Seq a
DS.empty
type STCcILB s a = STRef s (Seq (Maybe ByteString))
loadSTCcILB :: STCcILB s (Maybe ByteString)
-> Seq (Maybe ByteString)
-> ST s ()
loadSTCcILB :: forall s.
STOccCKILB s (Maybe ByteString)
-> Seq (Maybe ByteString) -> ST s ()
loadSTCcILB STCcILB s (Maybe ByteString)
s Seq (Maybe ByteString)
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STCcILB s (Maybe ByteString)
s Seq (Maybe ByteString)
e
emptySTCcILB :: ST s (STCcILB s a)
emptySTCcILB :: forall s a. ST s (STOccCKILB s a)
emptySTCcILB = forall a s. a -> ST s (STRef s a)
newSTRef forall a. Seq a
DS.empty
type STCcCounterB s a = STRef s Int
updateSTCcCounterB :: STCcCounterB s Int
-> Int
-> ST s ()
updateSTCcCounterB :: forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCcCounterB STCcCounterB s Int
s Int
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STCcCounterB s Int
s Int
e
emptySTCcCounterB :: ST s (STCcCounterB s Int)
emptySTCcCounterB :: forall s. ST s (STOccCKCounterB s Int)
emptySTCcCounterB = forall a s. a -> ST s (STRef s a)
newSTRef Int
0
seqToCcB :: PBCcSeqB
-> ST s CcSeqB
seqToCcB :: forall s.
Seq (Maybe ByteString) -> ST s (Seq (Int, Maybe ByteString))
seqToCcB Seq (Maybe ByteString)
DS.Empty = do
STCcSeqB s Any
bccseqstackempty <- forall s a. ST s (STCcSeqB s a)
emptySTCcSeqB
Seq (Int, Maybe ByteString)
bccseqstackemptyr <- forall s a. STRef s a -> ST s a
readSTRef STCcSeqB s Any
bccseqstackempty
forall (m :: * -> *) a. Monad m => a -> m a
return Seq (Int, Maybe ByteString)
bccseqstackemptyr
seqToCcB Seq (Maybe ByteString)
xs = do
STCcSeqB s Any
bccseqstack <- forall s a. ST s (STCcSeqB s a)
emptySTCcSeqB
STCcILB s Any
bccinitiallist <- forall s a. ST s (STOccCKILB s a)
emptySTCcILB
STCcCounterB s Int
bcccounterstack <- forall s. ST s (STOccCKCounterB s Int)
emptySTCcCounterB
let il :: Seq (Maybe ByteString)
il = forall a. Ord a => Seq (Maybe a) -> Seq (Maybe a)
nubSeq' Seq (Maybe ByteString)
xs
forall s.
STOccCKILB s (Maybe ByteString)
-> Seq (Maybe ByteString) -> ST s ()
loadSTCcILB STCcILB s Any
bccinitiallist
Seq (Maybe ByteString)
il
Seq (Maybe ByteString)
cbccinitiallist <- forall s a. STRef s a -> ST s a
readSTRef STCcILB s Any
bccinitiallist
forall {s}.
Seq (Maybe ByteString)
-> Seq (Maybe ByteString)
-> STCcSeqB s (Seq (Int, Maybe ByteString))
-> STCcCounterB s Int
-> ST s ()
iCcB Seq (Maybe ByteString)
cbccinitiallist
Seq (Maybe ByteString)
xs
STCcSeqB s Any
bccseqstack
STCcCounterB s Int
bcccounterstack
Seq (Int, Maybe ByteString)
bccseqstackr <- forall s a. STRef s a -> ST s a
readSTRef STCcSeqB s Any
bccseqstack
forall (m :: * -> *) a. Monad m => a -> m a
return Seq (Int, Maybe ByteString)
bccseqstackr
where
iCcB :: Seq (Maybe ByteString)
-> Seq (Maybe ByteString)
-> STCcSeqB s (Seq (Int, Maybe ByteString))
-> STCcCounterB s Int
-> ST s ()
iCcB Seq (Maybe ByteString)
DS.Empty Seq (Maybe ByteString)
_ STCcSeqB s (Seq (Int, Maybe ByteString))
_ STCcCounterB s Int
_ = forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
iCcB (Maybe ByteString
y DS.:<| Seq (Maybe ByteString)
ys) Seq (Maybe ByteString)
zs STCcSeqB s (Seq (Int, Maybe ByteString))
bccss STCcCounterB s Int
bcccs = do
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCcCounterB STCcCounterB s Int
bcccs
Int
0
forall {s}.
Maybe ByteString
-> Seq (Maybe ByteString)
-> STCcSeqB s (Seq (Int, Maybe ByteString))
-> STRef s Int
-> ST s ()
iiCcB Maybe ByteString
y
Seq (Maybe ByteString)
zs
STCcSeqB s (Seq (Int, Maybe ByteString))
bccss
STCcCounterB s Int
bcccs
Seq (Maybe ByteString)
-> Seq (Maybe ByteString)
-> STCcSeqB s (Seq (Int, Maybe ByteString))
-> STCcCounterB s Int
-> ST s ()
iCcB Seq (Maybe ByteString)
ys
Seq (Maybe ByteString)
zs
STCcSeqB s (Seq (Int, Maybe ByteString))
bccss
STCcCounterB s Int
bcccs
iiCcB :: Maybe ByteString
-> Seq (Maybe ByteString)
-> STCcSeqB s (Seq (Int, Maybe ByteString))
-> STRef s Int
-> ST s ()
iiCcB Maybe ByteString
_ Seq (Maybe ByteString)
DS.Empty STCcSeqB s (Seq (Int, Maybe ByteString))
_ STRef s Int
_ = forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
iiCcB Maybe ByteString
as (Maybe ByteString
b DS.:<| Seq (Maybe ByteString)
bs) STCcSeqB s (Seq (Int, Maybe ByteString))
bccss STRef s Int
bcccs = do
Int
cbcccs <- forall s a. STRef s a -> ST s a
readSTRef STRef s Int
bcccs
if | Maybe ByteString
as forall a. Eq a => a -> a -> Bool
== Maybe ByteString
b
-> forall s.
STCcSeqB s (Seq (Int, Maybe ByteString))
-> (Int, Maybe ByteString) -> ST s ()
updateSTCcSeqB STCcSeqB s (Seq (Int, Maybe ByteString))
bccss
(Int
cbcccs,Maybe ByteString
as)
| Bool
otherwise
-> do forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCcCounterB STRef s Int
bcccs
(Int
cbcccs forall a. Num a => a -> a -> a
+ Int
1)
Maybe ByteString
-> Seq (Maybe ByteString)
-> STCcSeqB s (Seq (Int, Maybe ByteString))
-> STRef s Int
-> ST s ()
iiCcB Maybe ByteString
as
Seq (Maybe ByteString)
bs
STCcSeqB s (Seq (Int, Maybe ByteString))
bccss
STRef s Int
bcccs
type PTCcSeqT = Seq (Maybe Text)
type CcSeqT = Seq (Int,Maybe Text)
type STCcSeqT s a = STRef s CcSeqT
updateSTCcSeqT :: STCcSeqT s (Seq (Int,Maybe Text))
-> (Int,Maybe Text)
-> ST s ()
updateSTCcSeqT :: forall s.
STCcSeqT s (Seq (Int, Maybe Text)) -> (Int, Maybe Text) -> ST s ()
updateSTCcSeqT STCcSeqT s (Seq (Int, Maybe Text))
s (Int, Maybe Text)
e = do
Seq (Int, Maybe Text)
s2 <- forall s a. STRef s a -> ST s a
readSTRef STCcSeqT s (Seq (Int, Maybe Text))
s
forall s a. STRef s a -> a -> ST s ()
writeSTRef STCcSeqT s (Seq (Int, Maybe Text))
s (Seq (Int, Maybe Text)
s2 forall a. Seq a -> a -> Seq a
DS.|> (Int, Maybe Text)
e)
emptySTCcSeqT :: ST s (STCcSeqT s a)
emptySTCcSeqT :: forall s a. ST s (STCcSeqT s a)
emptySTCcSeqT = forall a s. a -> ST s (STRef s a)
newSTRef forall a. Seq a
DS.empty
type STCcILT s a = STRef s (Seq (Maybe Text))
loadSTCcILT :: STCcILT s (Maybe Text)
-> Seq (Maybe Text)
-> ST s ()
loadSTCcILT :: forall s. STOccCKILT s (Maybe Text) -> Seq (Maybe Text) -> ST s ()
loadSTCcILT STCcILT s (Maybe Text)
s Seq (Maybe Text)
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STCcILT s (Maybe Text)
s Seq (Maybe Text)
e
emptySTCcILT :: ST s (STCcILT s a)
emptySTCcILT :: forall s a. ST s (STOccCKILT s a)
emptySTCcILT = forall a s. a -> ST s (STRef s a)
newSTRef forall a. Seq a
DS.empty
type STCcCounterT s a = STRef s Int
updateSTCcCounterT :: STCcCounterT s Int
-> Int
-> ST s ()
updateSTCcCounterT :: forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCcCounterT STCcCounterT s Int
s Int
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STCcCounterT s Int
s Int
e
emptySTCcCounterT :: ST s (STCcCounterT s Int)
emptySTCcCounterT :: forall s. ST s (STOccCKCounterB s Int)
emptySTCcCounterT = forall a s. a -> ST s (STRef s a)
newSTRef Int
0
seqToCcT :: PTCcSeqT
-> ST s CcSeqT
seqToCcT :: forall s. Seq (Maybe Text) -> ST s (Seq (Int, Maybe Text))
seqToCcT Seq (Maybe Text)
DS.Empty = do
STCcSeqT s Any
tccseqstackempty <- forall s a. ST s (STCcSeqT s a)
emptySTCcSeqT
Seq (Int, Maybe Text)
tccseqstackemptyr <- forall s a. STRef s a -> ST s a
readSTRef STCcSeqT s Any
tccseqstackempty
forall (m :: * -> *) a. Monad m => a -> m a
return Seq (Int, Maybe Text)
tccseqstackemptyr
seqToCcT Seq (Maybe Text)
xs = do
STCcSeqT s Any
tccseqstack <- forall s a. ST s (STCcSeqT s a)
emptySTCcSeqT
STCcILT s Any
tccinitiallist <- forall s a. ST s (STOccCKILT s a)
emptySTCcILT
STCcCounterT s Int
tcccounterstack <- forall s. ST s (STOccCKCounterB s Int)
emptySTCcCounterT
let il :: Seq (Maybe Text)
il = forall a. Ord a => Seq (Maybe a) -> Seq (Maybe a)
nubSeq' Seq (Maybe Text)
xs
forall s. STOccCKILT s (Maybe Text) -> Seq (Maybe Text) -> ST s ()
loadSTCcILT STCcILT s Any
tccinitiallist
Seq (Maybe Text)
il
Seq (Maybe Text)
ctccinitiallist <- forall s a. STRef s a -> ST s a
readSTRef STCcILT s Any
tccinitiallist
forall {s}.
Seq (Maybe Text)
-> Seq (Maybe Text)
-> STCcSeqT s (Seq (Int, Maybe Text))
-> STCcCounterT s Int
-> ST s ()
iCcT Seq (Maybe Text)
ctccinitiallist
Seq (Maybe Text)
xs
STCcSeqT s Any
tccseqstack
STCcCounterT s Int
tcccounterstack
Seq (Int, Maybe Text)
tccseqstackr <- forall s a. STRef s a -> ST s a
readSTRef STCcSeqT s Any
tccseqstack
forall (m :: * -> *) a. Monad m => a -> m a
return Seq (Int, Maybe Text)
tccseqstackr
where
iCcT :: Seq (Maybe Text)
-> Seq (Maybe Text)
-> STCcSeqT s (Seq (Int, Maybe Text))
-> STCcCounterT s Int
-> ST s ()
iCcT Seq (Maybe Text)
DS.Empty Seq (Maybe Text)
_ STCcSeqT s (Seq (Int, Maybe Text))
_ STCcCounterT s Int
_ = forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
iCcT (Maybe Text
y DS.:<| Seq (Maybe Text)
ys) Seq (Maybe Text)
zs STCcSeqT s (Seq (Int, Maybe Text))
tccss STCcCounterT s Int
tcccs = do
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCcCounterT STCcCounterT s Int
tcccs
Int
0
forall {s}.
Maybe Text
-> Seq (Maybe Text)
-> STCcSeqT s (Seq (Int, Maybe Text))
-> STRef s Int
-> ST s ()
iiCcT Maybe Text
y
Seq (Maybe Text)
zs
STCcSeqT s (Seq (Int, Maybe Text))
tccss
STCcCounterT s Int
tcccs
Seq (Maybe Text)
-> Seq (Maybe Text)
-> STCcSeqT s (Seq (Int, Maybe Text))
-> STCcCounterT s Int
-> ST s ()
iCcT Seq (Maybe Text)
ys
Seq (Maybe Text)
zs
STCcSeqT s (Seq (Int, Maybe Text))
tccss
STCcCounterT s Int
tcccs
iiCcT :: Maybe Text
-> Seq (Maybe Text)
-> STCcSeqT s (Seq (Int, Maybe Text))
-> STRef s Int
-> ST s ()
iiCcT Maybe Text
_ Seq (Maybe Text)
DS.Empty STCcSeqT s (Seq (Int, Maybe Text))
_ STRef s Int
_ = forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
iiCcT Maybe Text
as (Maybe Text
b DS.:<| Seq (Maybe Text)
bs) STCcSeqT s (Seq (Int, Maybe Text))
tccss STRef s Int
tcccs = do
Int
ctcccs <- forall s a. STRef s a -> ST s a
readSTRef STRef s Int
tcccs
if | Maybe Text
as forall a. Eq a => a -> a -> Bool
== Maybe Text
b
-> forall s.
STCcSeqT s (Seq (Int, Maybe Text)) -> (Int, Maybe Text) -> ST s ()
updateSTCcSeqT STCcSeqT s (Seq (Int, Maybe Text))
tccss
(Int
ctcccs,Maybe Text
as)
| Bool
otherwise
-> do forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCcCounterT STRef s Int
tcccs
(Int
ctcccs forall a. Num a => a -> a -> a
+ Int
1)
Maybe Text
-> Seq (Maybe Text)
-> STCcSeqT s (Seq (Int, Maybe Text))
-> STRef s Int
-> ST s ()
iiCcT Maybe Text
as
Seq (Maybe Text)
bs
STCcSeqT s (Seq (Int, Maybe Text))
tccss
STRef s Int
tcccs
type FFMIndexSeqB = Seq (Maybe ByteString)
seqFromFMIndexB :: FMIndexB
-> FFMIndexSeqB
seqFromFMIndexB :: FMIndexB -> Seq (Maybe ByteString)
seqFromFMIndexB (FMIndexB (CcB Seq (Int, Maybe ByteString)
DS.Empty,OccCKB
_)) = forall a. Seq a
DS.Empty
seqFromFMIndexB (FMIndexB (CcB
_,OccCKB Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
DS.Empty)) = forall a. Seq a
DS.Empty
seqFromFMIndexB FMIndexB
xs = do
let xss :: Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
xss = (\(OccCKB Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
b) -> Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
b) forall a b. (a -> b) -> a -> b
$
(\(CcB
_,OccCKB
b) -> OccCKB
b) forall a b. (a -> b) -> a -> b
$
(\(FMIndexB (CcB, OccCKB)
b) -> (CcB, OccCKB)
b) FMIndexB
xs
forall {a} {a} {b} {a}. Seq (a, Seq (a, b, a)) -> Seq a
iFFMIndexB Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
xss
where
iFFMIndexB :: Seq (a, Seq (a, b, a)) -> Seq a
iFFMIndexB Seq (a, Seq (a, b, a))
DS.Empty = forall a. Seq a
DS.Empty
iFFMIndexB ((a
_,Seq (a, b, a)
b) DS.:<| Seq (a, Seq (a, b, a))
_) =
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(a
_,b
_,a
e) -> a
e) Seq (a, b, a)
b
type FFMIndexSeqT = Seq (Maybe Text)
seqFromFMIndexT :: FMIndexT
-> FFMIndexSeqT
seqFromFMIndexT :: FMIndexT -> Seq (Maybe Text)
seqFromFMIndexT (FMIndexT (CcT Seq (Int, Maybe Text)
DS.Empty,OccCKT
_)) = forall a. Seq a
DS.Empty
seqFromFMIndexT (FMIndexT (CcT
_,OccCKT Seq (Maybe Text, Seq (Int, Int, Maybe Text))
DS.Empty)) = forall a. Seq a
DS.Empty
seqFromFMIndexT FMIndexT
xs = do
let xss :: Seq (Maybe Text, Seq (Int, Int, Maybe Text))
xss = (\(OccCKT Seq (Maybe Text, Seq (Int, Int, Maybe Text))
t) -> Seq (Maybe Text, Seq (Int, Int, Maybe Text))
t) forall a b. (a -> b) -> a -> b
$
(\(CcT
_,OccCKT
b) -> OccCKT
b) forall a b. (a -> b) -> a -> b
$
(\(FMIndexT (CcT, OccCKT)
t) -> (CcT, OccCKT)
t) FMIndexT
xs
forall {a} {a} {b} {a}. Seq (a, Seq (a, b, a)) -> Seq a
iFFMIndexT Seq (Maybe Text, Seq (Int, Int, Maybe Text))
xss
where
iFFMIndexT :: Seq (a, Seq (a, b, a)) -> Seq a
iFFMIndexT Seq (a, Seq (a, b, a))
DS.Empty = forall a. Seq a
DS.Empty
iFFMIndexT ((a
_,Seq (a, b, a)
b) DS.:<| Seq (a, Seq (a, b, a))
_) =
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(a
_,b
_,a
e) -> a
e) Seq (a, b, a)
b
type PBCPat = Seq ByteString
type CIntB = Maybe Int
type STCBoolB s a = STRef s Bool
updateSTCBoolB :: STCBoolB s Bool
-> Bool
-> ST s ()
updateSTCBoolB :: forall s. STCBoolB s Bool -> Bool -> ST s ()
updateSTCBoolB STCBoolB s Bool
s Bool
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STCBoolB s Bool
s Bool
e
emptySTCBoolB :: ST s (STCBoolB s Bool)
emptySTCBoolB :: forall s. ST s (STCBoolB s Bool)
emptySTCBoolB = forall a s. a -> ST s (STRef s a)
newSTRef Bool
False
type STCCounterB s a = STRef s Int
updateSTCCounterB :: STCCounterB s Int
-> Int
-> ST s ()
updateSTCCounterB :: forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCCounterB STCCounterB s Int
s Int
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STCCounterB s Int
s Int
e
emptySTCCounterB :: ST s (STCCounterB s Int)
emptySTCCounterB :: forall s. ST s (STOccCKCounterB s Int)
emptySTCCounterB = forall a s. a -> ST s (STRef s a)
newSTRef Int
0
type STCCurrentStartB s a = STRef s Int
updateSTCCurrentStartB :: STCCurrentStartB s Int
-> Int
-> ST s ()
updateSTCCurrentStartB :: forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCCurrentStartB STCCurrentStartB s Int
s Int
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STCCurrentStartB s Int
s Int
e
emptySTCCurrentStartB :: ST s (STCCurrentStartB s Int)
emptySTCCurrentStartB :: forall s. ST s (STOccCKCounterB s Int)
emptySTCCurrentStartB = forall a s. a -> ST s (STRef s a)
newSTRef (-Int
1)
type STCCurrentEndB s a = STRef s Int
updateSTCCurrentEndB :: STCCurrentEndB s Int
-> Int
-> ST s ()
updateSTCCurrentEndB :: forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCCurrentEndB STCCurrentEndB s Int
s Int
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STCCurrentEndB s Int
s Int
e
emptySTCCurrentEndB :: ST s (STCCurrentEndB s Int)
emptySTCCurrentEndB :: forall s. ST s (STOccCKCounterB s Int)
emptySTCCurrentEndB = forall a s. a -> ST s (STRef s a)
newSTRef (-Int
1)
countFMIndexB :: PBCPat
-> FMIndexB
-> ST s CIntB
countFMIndexB :: forall s. PBCPat -> FMIndexB -> ST s (Maybe Int)
countFMIndexB PBCPat
DS.Empty FMIndexB
_ = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
countFMIndexB PBCPat
_ (FMIndexB (CcB Seq (Int, Maybe ByteString)
DS.Empty,OccCKB
_)) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
countFMIndexB PBCPat
_ (FMIndexB (CcB
_,OccCKB Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
DS.Empty)) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
countFMIndexB PBCPat
xs FMIndexB
ys = do
STCCounterB s Int
bccounter <- forall s. ST s (STOccCKCounterB s Int)
emptySTCCounterB
STCBoolB s Bool
bcbool <- forall s. ST s (STCBoolB s Bool)
emptySTCBoolB
STCCounterB s Int
bccurrentstart <- forall s. ST s (STOccCKCounterB s Int)
emptySTCCurrentStartB
STCCounterB s Int
bccurrentend <- forall s. ST s (STOccCKCounterB s Int)
emptySTCCurrentEndB
forall {s}.
PBCPat
-> FMIndexB
-> STRef s Int
-> STCBoolB s Bool
-> STRef s Int
-> STRef s Int
-> ST s ()
iCB PBCPat
xs
FMIndexB
ys
STCCounterB s Int
bccounter
STCBoolB s Bool
bcbool
STCCounterB s Int
bccurrentstart
STCCounterB s Int
bccurrentend
Int
cbccurrentstart <- forall s a. STRef s a -> ST s a
readSTRef STCCounterB s Int
bccurrentstart
Int
cbccurrentend <- forall s a. STRef s a -> ST s a
readSTRef STCCounterB s Int
bccurrentend
Bool
cbcbool <- forall s a. STRef s a -> ST s a
readSTRef STCBoolB s Bool
bcbool
let count :: Maybe Int
count = if | (Int
cbccurrentstart forall a. Eq a => a -> a -> Bool
== (-Int
1) Bool -> Bool -> Bool
&& Int
cbccurrentend forall a. Eq a => a -> a -> Bool
== (-Int
1)) Bool -> Bool -> Bool
||
((Int
cbccurrentend forall a. Num a => a -> a -> a
- Int
cbccurrentstart) forall a. Num a => a -> a -> a
+ Int
1) forall a. Eq a => a -> a -> Bool
== Int
0 Bool -> Bool -> Bool
||
Bool
cbcbool
-> forall a. Maybe a
Nothing
| Bool
otherwise
-> forall a. a -> Maybe a
Just ((Int
cbccurrentend forall a. Num a => a -> a -> a
- Int
cbccurrentstart) forall a. Num a => a -> a -> a
+ Int
1)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Int
count
where
iCB :: PBCPat
-> FMIndexB
-> STRef s Int
-> STCBoolB s Bool
-> STRef s Int
-> STRef s Int
-> ST s ()
iCB PBCPat
DS.Empty FMIndexB
_ STRef s Int
_ STCBoolB s Bool
_ STRef s Int
_ STRef s Int
_ = forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
iCB (PBCPat
as DS.:|> ByteString
a) FMIndexB
bs STRef s Int
bcc STCBoolB s Bool
bcb STRef s Int
bccs STRef s Int
bcce = do
let ccbbs :: Seq (Int, Maybe ByteString)
ccbbs = (\(CcB Seq (Int, Maybe ByteString)
b) -> Seq (Int, Maybe ByteString)
b) forall a b. (a -> b) -> a -> b
$
(\(CcB
a,OccCKB
_) -> CcB
a) forall a b. (a -> b) -> a -> b
$
(\(FMIndexB (CcB, OccCKB)
b) -> (CcB, OccCKB)
b) FMIndexB
bs
let coccckbs :: Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
coccckbs = (\(OccCKB Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
b) -> Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
b) forall a b. (a -> b) -> a -> b
$
(\(CcB
_,OccCKB
b) -> OccCKB
b) forall a b. (a -> b) -> a -> b
$
(\(FMIndexB (CcB, OccCKB)
b) -> (CcB, OccCKB)
b) FMIndexB
bs
Int
cbcc <- forall s a. STRef s a -> ST s a
readSTRef STRef s Int
bcc
Int
cbccs <- forall s a. STRef s a -> ST s a
readSTRef STRef s Int
bccs
Int
cbcce <- forall s a. STRef s a -> ST s a
readSTRef STRef s Int
bcce
if | Int
cbccs forall a. Ord a => a -> a -> Bool
> Int
cbcce
-> do forall s. STCBoolB s Bool -> Bool -> ST s ()
updateSTCBoolB STCBoolB s Bool
bcb
Bool
True
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
| Bool
otherwise
-> if | Int
cbcc forall a. Eq a => a -> a -> Bool
== Int
0
-> do case forall a. (a -> Bool) -> Seq a -> Maybe Int
DS.findIndexL (\(Int
_,Maybe ByteString
d) -> Maybe ByteString
d forall a. Eq a => a -> a -> Bool
== forall a. a -> Maybe a
Just ByteString
a) Seq (Int, Maybe ByteString)
ccbbs of
Maybe Int
Nothing -> forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
Just Int
bindex -> do if | Int
bindex forall a. Eq a => a -> a -> Bool
== (forall a. Seq a -> Int
DS.length Seq (Int, Maybe ByteString)
ccbbs) forall a. Num a => a -> a -> a
- Int
1
-> do let istart :: Int
istart = (forall a b. (a, b) -> a
fst forall a b. (a -> b) -> a -> b
$ forall a. Seq a -> Int -> a
DS.index Seq (Int, Maybe ByteString)
ccbbs Int
bindex) forall a. Num a => a -> a -> a
+ Int
1
let iend :: Int
iend = case forall a. Seq a -> ViewL a
viewl Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
coccckbs of
ViewL (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
EmptyL -> (-Int
1)
((Maybe ByteString, Seq (Int, Int, Maybe ByteString))
x DS.:< Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
_) -> forall a. Seq a -> Int
DS.length forall a b. (a -> b) -> a -> b
$
forall a b. (a, b) -> b
snd (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
x
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCCurrentStartB STRef s Int
bccs
Int
istart
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCCurrentEndB STRef s Int
bcce
Int
iend
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCCounterB STRef s Int
bcc
Int
1
PBCPat
-> FMIndexB
-> STRef s Int
-> STCBoolB s Bool
-> STRef s Int
-> STRef s Int
-> ST s ()
iCB PBCPat
as
FMIndexB
bs
STRef s Int
bcc
STCBoolB s Bool
bcb
STRef s Int
bccs
STRef s Int
bcce
| Bool
otherwise
-> do let istart :: Int
istart = (forall a b. (a, b) -> a
fst forall a b. (a -> b) -> a -> b
$ forall a. Seq a -> Int -> a
DS.index Seq (Int, Maybe ByteString)
ccbbs Int
bindex) forall a. Num a => a -> a -> a
+ Int
1
let iend :: Int
iend = forall a b. (a, b) -> a
fst forall a b. (a -> b) -> a -> b
$ forall a. Seq a -> Int -> a
DS.index Seq (Int, Maybe ByteString)
ccbbs (Int
bindex forall a. Num a => a -> a -> a
+ Int
1)
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCCurrentStartB STRef s Int
bccs
Int
istart
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCCurrentEndB STRef s Int
bcce
Int
iend
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCCounterB STRef s Int
bcc
Int
1
PBCPat
-> FMIndexB
-> STRef s Int
-> STCBoolB s Bool
-> STRef s Int
-> STRef s Int
-> ST s ()
iCB PBCPat
as
FMIndexB
bs
STRef s Int
bcc
STCBoolB s Bool
bcb
STRef s Int
bccs
STRef s Int
bcce
| Bool
otherwise
-> do case forall a. (a -> Bool) -> Seq a -> Maybe Int
DS.findIndexL (\(Int
_,Maybe ByteString
d) -> Maybe ByteString
d forall a. Eq a => a -> a -> Bool
== forall a. a -> Maybe a
Just ByteString
a) Seq (Int, Maybe ByteString)
ccbbs of
Maybe Int
Nothing -> forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
Just Int
bindex -> do case forall a. (a -> Bool) -> Seq a -> Maybe Int
DS.findIndexL (\(Maybe ByteString
e,Seq (Int, Int, Maybe ByteString)
_) -> Maybe ByteString
e forall a. Eq a => a -> a -> Bool
== forall a. a -> Maybe a
Just ByteString
a) Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
coccckbs of
Maybe Int
Nothing -> forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
Just Int
cindex -> do let istart :: Int
istart = (forall a b. (a, b) -> a
fst forall a b. (a -> b) -> a -> b
$ forall a. Seq a -> Int -> a
DS.index Seq (Int, Maybe ByteString)
ccbbs Int
bindex) forall a. Num a => a -> a -> a
+
((\(Int
_,Int
b,Maybe ByteString
_) -> Int
b) forall a b. (a -> b) -> a -> b
$
forall a. Seq a -> Int -> a
DS.index (forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall a. Seq a -> Int -> a
DS.index Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
coccckbs Int
cindex) (Int
cbccs forall a. Num a => a -> a -> a
- Int
1 forall a. Num a => a -> a -> a
- Int
1)) forall a. Num a => a -> a -> a
+
Int
1
let iend :: Int
iend = (forall a b. (a, b) -> a
fst forall a b. (a -> b) -> a -> b
$ forall a. Seq a -> Int -> a
DS.index Seq (Int, Maybe ByteString)
ccbbs Int
bindex) forall a. Num a => a -> a -> a
+
((\(Int
_,Int
b,Maybe ByteString
_) -> Int
b) forall a b. (a -> b) -> a -> b
$
forall a. Seq a -> Int -> a
DS.index (forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall a. Seq a -> Int -> a
DS.index Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
coccckbs Int
cindex) (Int
cbcce forall a. Num a => a -> a -> a
- Int
1))
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCCurrentStartB STRef s Int
bccs
Int
istart
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCCurrentEndB STRef s Int
bcce
Int
iend
PBCPat
-> FMIndexB
-> STRef s Int
-> STCBoolB s Bool
-> STRef s Int
-> STRef s Int
-> ST s ()
iCB PBCPat
as
FMIndexB
bs
STRef s Int
bcc
STCBoolB s Bool
bcb
STRef s Int
bccs
STRef s Int
bcce
type PTCPat = Seq Text
type CIntT = Maybe Int
type STCBoolT s a = STRef s Bool
updateSTCBoolT :: STCBoolT s Bool
-> Bool
-> ST s ()
updateSTCBoolT :: forall s. STCBoolB s Bool -> Bool -> ST s ()
updateSTCBoolT STCBoolT s Bool
s Bool
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STCBoolT s Bool
s Bool
e
emptySTCBoolT :: ST s (STCBoolT s Bool)
emptySTCBoolT :: forall s. ST s (STCBoolB s Bool)
emptySTCBoolT = forall a s. a -> ST s (STRef s a)
newSTRef Bool
False
type STCCounterT s a = STRef s Int
updateSTCCounterT :: STCCounterT s Int
-> Int
-> ST s ()
updateSTCCounterT :: forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCCounterT STCCounterT s Int
s Int
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STCCounterT s Int
s Int
e
emptySTCCounterT :: ST s (STCCounterT s Int)
emptySTCCounterT :: forall s. ST s (STOccCKCounterB s Int)
emptySTCCounterT = forall a s. a -> ST s (STRef s a)
newSTRef Int
0
type STCCurrentStartT s a = STRef s Int
updateSTCCurrentStartT :: STCCurrentStartT s Int
-> Int
-> ST s ()
updateSTCCurrentStartT :: forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCCurrentStartT STCCurrentStartT s Int
s Int
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STCCurrentStartT s Int
s Int
e
emptySTCCurrentStartT :: ST s (STCCurrentStartT s Int)
emptySTCCurrentStartT :: forall s. ST s (STOccCKCounterB s Int)
emptySTCCurrentStartT = forall a s. a -> ST s (STRef s a)
newSTRef (-Int
1)
type STCCurrentEndT s a = STRef s Int
updateSTCCurrentEndT :: STCCurrentEndT s Int
-> Int
-> ST s ()
updateSTCCurrentEndT :: forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCCurrentEndT STCCurrentEndT s Int
s Int
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STCCurrentEndT s Int
s Int
e
emptySTCCurrentEndT :: ST s (STCCurrentEndT s Int)
emptySTCCurrentEndT :: forall s. ST s (STOccCKCounterB s Int)
emptySTCCurrentEndT = forall a s. a -> ST s (STRef s a)
newSTRef (-Int
1)
countFMIndexT :: PTCPat
-> FMIndexT
-> ST s CIntT
countFMIndexT :: forall s. PTCPat -> FMIndexT -> ST s (Maybe Int)
countFMIndexT PTCPat
DS.Empty FMIndexT
_ = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
countFMIndexT PTCPat
_ (FMIndexT (CcT Seq (Int, Maybe Text)
DS.Empty,OccCKT
_)) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
countFMIndexT PTCPat
_ (FMIndexT (CcT
_,OccCKT Seq (Maybe Text, Seq (Int, Int, Maybe Text))
DS.Empty)) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
countFMIndexT PTCPat
xs FMIndexT
ys = do
STCCounterT s Int
tccounter <- forall s. ST s (STOccCKCounterB s Int)
emptySTCCounterT
STCBoolT s Bool
tcbool <- forall s. ST s (STCBoolB s Bool)
emptySTCBoolT
STCCounterT s Int
tccurrentstart <- forall s. ST s (STOccCKCounterB s Int)
emptySTCCurrentStartT
STCCounterT s Int
tccurrentend <- forall s. ST s (STOccCKCounterB s Int)
emptySTCCurrentEndT
forall {s}.
PTCPat
-> FMIndexT
-> STRef s Int
-> STCBoolT s Bool
-> STRef s Int
-> STRef s Int
-> ST s ()
iCT PTCPat
xs
FMIndexT
ys
STCCounterT s Int
tccounter
STCBoolT s Bool
tcbool
STCCounterT s Int
tccurrentstart
STCCounterT s Int
tccurrentend
Int
ctccurrentstart <- forall s a. STRef s a -> ST s a
readSTRef STCCounterT s Int
tccurrentstart
Int
ctccurrentend <- forall s a. STRef s a -> ST s a
readSTRef STCCounterT s Int
tccurrentend
Bool
ctcbool <- forall s a. STRef s a -> ST s a
readSTRef STCBoolT s Bool
tcbool
let count :: Maybe Int
count = if | (Int
ctccurrentstart forall a. Eq a => a -> a -> Bool
== (-Int
1) Bool -> Bool -> Bool
&& Int
ctccurrentend forall a. Eq a => a -> a -> Bool
== (-Int
1)) Bool -> Bool -> Bool
||
((Int
ctccurrentend forall a. Num a => a -> a -> a
- Int
ctccurrentstart) forall a. Num a => a -> a -> a
+ Int
1) forall a. Eq a => a -> a -> Bool
== Int
0 Bool -> Bool -> Bool
||
Bool
ctcbool
-> forall a. Maybe a
Nothing
| Bool
otherwise
-> forall a. a -> Maybe a
Just ((Int
ctccurrentend forall a. Num a => a -> a -> a
- Int
ctccurrentstart) forall a. Num a => a -> a -> a
+ Int
1)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Int
count
where
iCT :: PTCPat
-> FMIndexT
-> STRef s Int
-> STCBoolT s Bool
-> STRef s Int
-> STRef s Int
-> ST s ()
iCT PTCPat
DS.Empty FMIndexT
_ STRef s Int
_ STCBoolT s Bool
_ STRef s Int
_ STRef s Int
_ = forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
iCT (PTCPat
as DS.:|> Text
a) FMIndexT
bs STRef s Int
tcc STCBoolT s Bool
tcb STRef s Int
tccs STRef s Int
tcce = do
let cctbs :: Seq (Int, Maybe Text)
cctbs = (\(CcT Seq (Int, Maybe Text)
t) -> Seq (Int, Maybe Text)
t) forall a b. (a -> b) -> a -> b
$
(\(CcT
a,OccCKT
_) -> CcT
a) forall a b. (a -> b) -> a -> b
$
(\(FMIndexT (CcT, OccCKT)
t) -> (CcT, OccCKT)
t) FMIndexT
bs
let coccckts :: Seq (Maybe Text, Seq (Int, Int, Maybe Text))
coccckts = (\(OccCKT Seq (Maybe Text, Seq (Int, Int, Maybe Text))
t) -> Seq (Maybe Text, Seq (Int, Int, Maybe Text))
t) forall a b. (a -> b) -> a -> b
$
(\(CcT
_,OccCKT
b) -> OccCKT
b) forall a b. (a -> b) -> a -> b
$
(\(FMIndexT (CcT, OccCKT)
t) -> (CcT, OccCKT)
t) FMIndexT
bs
Int
ctcc <- forall s a. STRef s a -> ST s a
readSTRef STRef s Int
tcc
Int
ctccs <- forall s a. STRef s a -> ST s a
readSTRef STRef s Int
tccs
Int
ctcce <- forall s a. STRef s a -> ST s a
readSTRef STRef s Int
tcce
if | Int
ctccs forall a. Ord a => a -> a -> Bool
> Int
ctcce
-> do forall s. STCBoolB s Bool -> Bool -> ST s ()
updateSTCBoolT STCBoolT s Bool
tcb
Bool
True
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
| Bool
otherwise
-> if | Int
ctcc forall a. Eq a => a -> a -> Bool
== Int
0
-> do case forall a. (a -> Bool) -> Seq a -> Maybe Int
DS.findIndexL (\(Int
_,Maybe Text
d) -> Maybe Text
d forall a. Eq a => a -> a -> Bool
== forall a. a -> Maybe a
Just Text
a) Seq (Int, Maybe Text)
cctbs of
Maybe Int
Nothing -> forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
Just Int
bindex -> do if | Int
bindex forall a. Eq a => a -> a -> Bool
== (forall a. Seq a -> Int
DS.length Seq (Int, Maybe Text)
cctbs) forall a. Num a => a -> a -> a
- Int
1
-> do let istart :: Int
istart = (forall a b. (a, b) -> a
fst forall a b. (a -> b) -> a -> b
$ forall a. Seq a -> Int -> a
DS.index Seq (Int, Maybe Text)
cctbs Int
bindex) forall a. Num a => a -> a -> a
+ Int
1
let iend :: Int
iend = case forall a. Seq a -> ViewL a
viewl Seq (Maybe Text, Seq (Int, Int, Maybe Text))
coccckts of
ViewL (Maybe Text, Seq (Int, Int, Maybe Text))
EmptyL -> (-Int
1)
((Maybe Text, Seq (Int, Int, Maybe Text))
x DS.:< Seq (Maybe Text, Seq (Int, Int, Maybe Text))
_) -> forall a. Seq a -> Int
DS.length forall a b. (a -> b) -> a -> b
$
forall a b. (a, b) -> b
snd (Maybe Text, Seq (Int, Int, Maybe Text))
x
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCCurrentStartT STRef s Int
tccs
Int
istart
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCCurrentEndT STRef s Int
tcce
Int
iend
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCCounterT STRef s Int
tcc
Int
1
PTCPat
-> FMIndexT
-> STRef s Int
-> STCBoolT s Bool
-> STRef s Int
-> STRef s Int
-> ST s ()
iCT PTCPat
as
FMIndexT
bs
STRef s Int
tcc
STCBoolT s Bool
tcb
STRef s Int
tccs
STRef s Int
tcce
| Bool
otherwise
-> do let istart :: Int
istart = (forall a b. (a, b) -> a
fst forall a b. (a -> b) -> a -> b
$ forall a. Seq a -> Int -> a
DS.index Seq (Int, Maybe Text)
cctbs Int
bindex) forall a. Num a => a -> a -> a
+ Int
1
let iend :: Int
iend = forall a b. (a, b) -> a
fst forall a b. (a -> b) -> a -> b
$ forall a. Seq a -> Int -> a
DS.index Seq (Int, Maybe Text)
cctbs (Int
bindex forall a. Num a => a -> a -> a
+ Int
1)
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCCurrentStartT STRef s Int
tccs
Int
istart
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCCurrentEndT STRef s Int
tcce
Int
iend
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCCounterT STRef s Int
tcc
Int
1
PTCPat
-> FMIndexT
-> STRef s Int
-> STCBoolT s Bool
-> STRef s Int
-> STRef s Int
-> ST s ()
iCT PTCPat
as
FMIndexT
bs
STRef s Int
tcc
STCBoolT s Bool
tcb
STRef s Int
tccs
STRef s Int
tcce
| Bool
otherwise
-> do case forall a. (a -> Bool) -> Seq a -> Maybe Int
DS.findIndexL (\(Int
_,Maybe Text
d) -> Maybe Text
d forall a. Eq a => a -> a -> Bool
== forall a. a -> Maybe a
Just Text
a) Seq (Int, Maybe Text)
cctbs of
Maybe Int
Nothing -> forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
Just Int
bindex -> do case forall a. (a -> Bool) -> Seq a -> Maybe Int
DS.findIndexL (\(Maybe Text
e,Seq (Int, Int, Maybe Text)
_) -> Maybe Text
e forall a. Eq a => a -> a -> Bool
== forall a. a -> Maybe a
Just Text
a) Seq (Maybe Text, Seq (Int, Int, Maybe Text))
coccckts of
Maybe Int
Nothing -> forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
Just Int
cindex -> do let istart :: Int
istart = (forall a b. (a, b) -> a
fst forall a b. (a -> b) -> a -> b
$ forall a. Seq a -> Int -> a
DS.index Seq (Int, Maybe Text)
cctbs Int
bindex) forall a. Num a => a -> a -> a
+
((\(Int
_,Int
b,Maybe Text
_) -> Int
b) forall a b. (a -> b) -> a -> b
$
forall a. Seq a -> Int -> a
DS.index (forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall a. Seq a -> Int -> a
DS.index Seq (Maybe Text, Seq (Int, Int, Maybe Text))
coccckts Int
cindex) (Int
ctccs forall a. Num a => a -> a -> a
- Int
1 forall a. Num a => a -> a -> a
- Int
1)) forall a. Num a => a -> a -> a
+
Int
1
let iend :: Int
iend = (forall a b. (a, b) -> a
fst forall a b. (a -> b) -> a -> b
$ forall a. Seq a -> Int -> a
DS.index Seq (Int, Maybe Text)
cctbs Int
bindex) forall a. Num a => a -> a -> a
+
((\(Int
_,Int
b,Maybe Text
_) -> Int
b) forall a b. (a -> b) -> a -> b
$
forall a. Seq a -> Int -> a
DS.index (forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall a. Seq a -> Int -> a
DS.index Seq (Maybe Text, Seq (Int, Int, Maybe Text))
coccckts Int
cindex) (Int
ctcce forall a. Num a => a -> a -> a
- Int
1))
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCCurrentStartT STRef s Int
tccs
Int
istart
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCCurrentEndT STRef s Int
tcce
Int
iend
PTCPat
-> FMIndexT
-> STRef s Int
-> STCBoolT s Bool
-> STRef s Int
-> STRef s Int
-> ST s ()
iCT PTCPat
as
FMIndexT
bs
STRef s Int
tcc
STCBoolT s Bool
tcb
STRef s Int
tccs
STRef s Int
tcce
type PBLPat = Seq ByteString
type LIntB = Seq (Maybe Int)
type STLBoolB s a = STRef s Bool
updateSTLBoolB :: STLBoolB s Bool
-> Bool
-> ST s ()
updateSTLBoolB :: forall s. STCBoolB s Bool -> Bool -> ST s ()
updateSTLBoolB STLBoolB s Bool
s Bool
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STLBoolB s Bool
s Bool
e
emptySTLBoolB :: ST s (STLBoolB s Bool)
emptySTLBoolB :: forall s. ST s (STCBoolB s Bool)
emptySTLBoolB = forall a s. a -> ST s (STRef s a)
newSTRef Bool
False
type STLCounterB s a = STRef s Int
updateSTLCounterB :: STLCounterB s Int
-> Int
-> ST s ()
updateSTLCounterB :: forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTLCounterB STLCounterB s Int
s Int
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STLCounterB s Int
s Int
e
emptySTLCounterB :: ST s (STLCounterB s Int)
emptySTLCounterB :: forall s. ST s (STOccCKCounterB s Int)
emptySTLCounterB = forall a s. a -> ST s (STRef s a)
newSTRef Int
0
type STLCurrentStartB s a = STRef s Int
updateSTLCurrentStartB :: STLCurrentStartB s Int
-> Int
-> ST s ()
updateSTLCurrentStartB :: forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTLCurrentStartB STLCurrentStartB s Int
s Int
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STLCurrentStartB s Int
s Int
e
emptySTLCurrentStartB :: ST s (STLCurrentStartB s Int)
emptySTLCurrentStartB :: forall s. ST s (STOccCKCounterB s Int)
emptySTLCurrentStartB = forall a s. a -> ST s (STRef s a)
newSTRef (-Int
1)
type STLCurrentEndB s a = STRef s Int
updateSTLCurrentEndB :: STLCurrentEndB s Int
-> Int
-> ST s ()
updateSTLCurrentEndB :: forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTLCurrentEndB STLCurrentEndB s Int
s Int
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STLCurrentEndB s Int
s Int
e
emptySTLCurrentEndB :: ST s (STCCurrentEndB s Int)
emptySTLCurrentEndB :: forall s. ST s (STOccCKCounterB s Int)
emptySTLCurrentEndB = forall a s. a -> ST s (STRef s a)
newSTRef (-Int
1)
locateFMIndexB :: PBLPat
-> FMIndexB
-> ST s LIntB
locateFMIndexB :: forall s. PBCPat -> FMIndexB -> ST s LIntB
locateFMIndexB PBCPat
DS.Empty FMIndexB
_ = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Seq a
DS.Empty
locateFMIndexB PBCPat
_ (FMIndexB (CcB Seq (Int, Maybe ByteString)
DS.Empty,OccCKB
_)) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Seq a
DS.Empty
locateFMIndexB PBCPat
_ (FMIndexB (CcB
_,OccCKB Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
DS.Empty)) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Seq a
DS.Empty
locateFMIndexB PBCPat
xs FMIndexB
ys = do
STLCounterB s Int
blcounter <- forall s. ST s (STOccCKCounterB s Int)
emptySTLCounterB
STLBoolB s Bool
blbool <- forall s. ST s (STCBoolB s Bool)
emptySTLBoolB
STLCounterB s Int
blcurrentstart <- forall s. ST s (STOccCKCounterB s Int)
emptySTLCurrentStartB
STLCounterB s Int
blcurrentend <- forall s. ST s (STOccCKCounterB s Int)
emptySTLCurrentEndB
forall {s}.
PBCPat
-> FMIndexB
-> STRef s Int
-> STCBoolB s Bool
-> STRef s Int
-> STRef s Int
-> ST s ()
iLB PBCPat
xs
FMIndexB
ys
STLCounterB s Int
blcounter
STLBoolB s Bool
blbool
STLCounterB s Int
blcurrentstart
STLCounterB s Int
blcurrentend
Int
cblcurrentstart <- forall s a. STRef s a -> ST s a
readSTRef STLCounterB s Int
blcurrentstart
Int
cblcurrentend <- forall s a. STRef s a -> ST s a
readSTRef STLCounterB s Int
blcurrentend
Bool
cblbool <- forall s a. STRef s a -> ST s a
readSTRef STLBoolB s Bool
blbool
let indexes :: LIntB
indexes = if | (Int
cblcurrentstart forall a. Eq a => a -> a -> Bool
== (-Int
1) Bool -> Bool -> Bool
&& Int
cblcurrentend forall a. Eq a => a -> a -> Bool
== (-Int
1)) Bool -> Bool -> Bool
||
((Int
cblcurrentend forall a. Num a => a -> a -> a
- Int
cblcurrentstart) forall a. Num a => a -> a -> a
+ Int
1) forall a. Eq a => a -> a -> Bool
== Int
0 Bool -> Bool -> Bool
||
Bool
cblbool
-> forall a. Seq a
DS.Empty
| Bool
otherwise
-> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
forall a. [a] -> Seq a
DS.fromList forall a b. (a -> b) -> a -> b
$
[Int
cblcurrentstart..Int
cblcurrentend]
forall (m :: * -> *) a. Monad m => a -> m a
return LIntB
indexes
where
iLB :: PBCPat
-> FMIndexB
-> STRef s Int
-> STLBoolB s Bool
-> STRef s Int
-> STRef s Int
-> ST s ()
iLB PBCPat
DS.Empty FMIndexB
_ STRef s Int
_ STLBoolB s Bool
_ STRef s Int
_ STRef s Int
_ = forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
iLB (PBCPat
as DS.:|> ByteString
a) FMIndexB
bs STRef s Int
blc STLBoolB s Bool
blb STRef s Int
blcs STRef s Int
blce = do
let ccbbs :: Seq (Int, Maybe ByteString)
ccbbs = (\(CcB Seq (Int, Maybe ByteString)
b) -> Seq (Int, Maybe ByteString)
b) forall a b. (a -> b) -> a -> b
$
(\(CcB
a,OccCKB
_) -> CcB
a) forall a b. (a -> b) -> a -> b
$
(\(FMIndexB (CcB, OccCKB)
b) -> (CcB, OccCKB)
b) FMIndexB
bs
let coccckbs :: Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
coccckbs = (\(OccCKB Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
b) -> Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
b) forall a b. (a -> b) -> a -> b
$
(\(CcB
_,OccCKB
b) -> OccCKB
b) forall a b. (a -> b) -> a -> b
$
(\(FMIndexB (CcB, OccCKB)
b) -> (CcB, OccCKB)
b) FMIndexB
bs
Int
cblc <- forall s a. STRef s a -> ST s a
readSTRef STRef s Int
blc
Int
cblcs <- forall s a. STRef s a -> ST s a
readSTRef STRef s Int
blcs
Int
cblce <- forall s a. STRef s a -> ST s a
readSTRef STRef s Int
blce
if | Int
cblcs forall a. Ord a => a -> a -> Bool
> Int
cblce
-> do forall s. STCBoolB s Bool -> Bool -> ST s ()
updateSTLBoolB STLBoolB s Bool
blb
Bool
True
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
| Bool
otherwise
-> if | Int
cblc forall a. Eq a => a -> a -> Bool
== Int
0
-> do case forall a. (a -> Bool) -> Seq a -> Maybe Int
DS.findIndexL (\(Int
_,Maybe ByteString
d) -> Maybe ByteString
d forall a. Eq a => a -> a -> Bool
== forall a. a -> Maybe a
Just ByteString
a) Seq (Int, Maybe ByteString)
ccbbs of
Maybe Int
Nothing -> forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
Just Int
bindex -> do if | Int
bindex forall a. Eq a => a -> a -> Bool
== (forall a. Seq a -> Int
DS.length Seq (Int, Maybe ByteString)
ccbbs) forall a. Num a => a -> a -> a
- Int
1
-> do let istart :: Int
istart = (forall a b. (a, b) -> a
fst forall a b. (a -> b) -> a -> b
$ forall a. Seq a -> Int -> a
DS.index Seq (Int, Maybe ByteString)
ccbbs Int
bindex) forall a. Num a => a -> a -> a
+ Int
1
let iend :: Int
iend = case forall a. Seq a -> ViewL a
viewl Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
coccckbs of
ViewL (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
EmptyL -> (-Int
1)
((Maybe ByteString, Seq (Int, Int, Maybe ByteString))
x DS.:< Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
_) -> forall a. Seq a -> Int
DS.length forall a b. (a -> b) -> a -> b
$
forall a b. (a, b) -> b
snd (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
x
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTLCurrentStartB STRef s Int
blcs
Int
istart
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTLCurrentEndB STRef s Int
blce
Int
iend
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTLCounterB STRef s Int
blc
Int
1
PBCPat
-> FMIndexB
-> STRef s Int
-> STLBoolB s Bool
-> STRef s Int
-> STRef s Int
-> ST s ()
iLB PBCPat
as
FMIndexB
bs
STRef s Int
blc
STLBoolB s Bool
blb
STRef s Int
blcs
STRef s Int
blce
| Bool
otherwise
-> do let istart :: Int
istart = (forall a b. (a, b) -> a
fst forall a b. (a -> b) -> a -> b
$ forall a. Seq a -> Int -> a
DS.index Seq (Int, Maybe ByteString)
ccbbs Int
bindex) forall a. Num a => a -> a -> a
+ Int
1
let iend :: Int
iend = forall a b. (a, b) -> a
fst forall a b. (a -> b) -> a -> b
$ forall a. Seq a -> Int -> a
DS.index Seq (Int, Maybe ByteString)
ccbbs (Int
bindex forall a. Num a => a -> a -> a
+ Int
1)
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTLCurrentStartB STRef s Int
blcs
Int
istart
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTLCurrentEndB STRef s Int
blce
Int
iend
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTLCounterB STRef s Int
blc
Int
1
PBCPat
-> FMIndexB
-> STRef s Int
-> STLBoolB s Bool
-> STRef s Int
-> STRef s Int
-> ST s ()
iLB PBCPat
as
FMIndexB
bs
STRef s Int
blc
STLBoolB s Bool
blb
STRef s Int
blcs
STRef s Int
blce
| Bool
otherwise
-> do case forall a. (a -> Bool) -> Seq a -> Maybe Int
DS.findIndexL (\(Int
_,Maybe ByteString
d) -> Maybe ByteString
d forall a. Eq a => a -> a -> Bool
== forall a. a -> Maybe a
Just ByteString
a) Seq (Int, Maybe ByteString)
ccbbs of
Maybe Int
Nothing -> forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
Just Int
bindex -> do case forall a. (a -> Bool) -> Seq a -> Maybe Int
DS.findIndexL (\(Maybe ByteString
e,Seq (Int, Int, Maybe ByteString)
_) -> Maybe ByteString
e forall a. Eq a => a -> a -> Bool
== forall a. a -> Maybe a
Just ByteString
a) Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
coccckbs of
Maybe Int
Nothing -> forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
Just Int
cindex -> do let istart :: Int
istart = (forall a b. (a, b) -> a
fst forall a b. (a -> b) -> a -> b
$ forall a. Seq a -> Int -> a
DS.index Seq (Int, Maybe ByteString)
ccbbs Int
bindex) forall a. Num a => a -> a -> a
+
((\(Int
_,Int
b,Maybe ByteString
_) -> Int
b) forall a b. (a -> b) -> a -> b
$
forall a. Seq a -> Int -> a
DS.index (forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall a. Seq a -> Int -> a
DS.index Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
coccckbs Int
cindex) (Int
cblcs forall a. Num a => a -> a -> a
- Int
1 forall a. Num a => a -> a -> a
- Int
1)) forall a. Num a => a -> a -> a
+
Int
1
let iend :: Int
iend = (forall a b. (a, b) -> a
fst forall a b. (a -> b) -> a -> b
$ forall a. Seq a -> Int -> a
DS.index Seq (Int, Maybe ByteString)
ccbbs Int
bindex) forall a. Num a => a -> a -> a
+
((\(Int
_,Int
b,Maybe ByteString
_) -> Int
b) forall a b. (a -> b) -> a -> b
$
forall a. Seq a -> Int -> a
DS.index (forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall a. Seq a -> Int -> a
DS.index Seq (Maybe ByteString, Seq (Int, Int, Maybe ByteString))
coccckbs Int
cindex) (Int
cblce forall a. Num a => a -> a -> a
- Int
1))
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTLCurrentStartB STRef s Int
blcs
Int
istart
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTLCurrentEndB STRef s Int
blce
Int
iend
PBCPat
-> FMIndexB
-> STRef s Int
-> STLBoolB s Bool
-> STRef s Int
-> STRef s Int
-> ST s ()
iLB PBCPat
as
FMIndexB
bs
STRef s Int
blc
STLBoolB s Bool
blb
STRef s Int
blcs
STRef s Int
blce
type PTLPat = Seq Text
type LIntT = Seq (Maybe Int)
type STLBoolT s a = STRef s Bool
updateSTLBoolT :: STLBoolT s Bool
-> Bool
-> ST s ()
updateSTLBoolT :: forall s. STCBoolB s Bool -> Bool -> ST s ()
updateSTLBoolT STLBoolT s Bool
s Bool
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STLBoolT s Bool
s Bool
e
emptySTLBoolT :: ST s (STLBoolT s Bool)
emptySTLBoolT :: forall s. ST s (STCBoolB s Bool)
emptySTLBoolT = forall a s. a -> ST s (STRef s a)
newSTRef Bool
False
type STLCounterT s a = STRef s Int
updateSTLCounterT :: STLCounterT s Int
-> Int
-> ST s ()
updateSTLCounterT :: forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTLCounterT STLCounterT s Int
s Int
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STLCounterT s Int
s Int
e
emptySTLCounterT :: ST s (STLCounterT s Int)
emptySTLCounterT :: forall s. ST s (STOccCKCounterB s Int)
emptySTLCounterT = forall a s. a -> ST s (STRef s a)
newSTRef Int
0
type STLCurrentStartT s a = STRef s Int
updateSTLCurrentStartT :: STLCurrentStartT s Int
-> Int
-> ST s ()
updateSTLCurrentStartT :: forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTLCurrentStartT STLCurrentStartT s Int
s Int
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STLCurrentStartT s Int
s Int
e
emptySTLCurrentStartT :: ST s (STLCurrentStartT s Int)
emptySTLCurrentStartT :: forall s. ST s (STOccCKCounterB s Int)
emptySTLCurrentStartT = forall a s. a -> ST s (STRef s a)
newSTRef (-Int
1)
type STLCurrentEndT s a = STRef s Int
updateSTLCurrentEndT :: STLCurrentEndT s Int
-> Int
-> ST s ()
updateSTLCurrentEndT :: forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTLCurrentEndT STLCurrentEndT s Int
s Int
e = forall s a. STRef s a -> a -> ST s ()
writeSTRef STLCurrentEndT s Int
s Int
e
emptySTLCurrentEndT :: ST s (STLCurrentEndT s Int)
emptySTLCurrentEndT :: forall s. ST s (STOccCKCounterB s Int)
emptySTLCurrentEndT = forall a s. a -> ST s (STRef s a)
newSTRef (-Int
1)
locateFMIndexT :: PTLPat
-> FMIndexT
-> ST s LIntT
locateFMIndexT :: forall s. PTCPat -> FMIndexT -> ST s LIntB
locateFMIndexT PTCPat
DS.Empty FMIndexT
_ = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Seq a
DS.Empty
locateFMIndexT PTCPat
_ (FMIndexT (CcT Seq (Int, Maybe Text)
DS.Empty,OccCKT
_)) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Seq a
DS.Empty
locateFMIndexT PTCPat
_ (FMIndexT (CcT
_,OccCKT Seq (Maybe Text, Seq (Int, Int, Maybe Text))
DS.Empty)) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Seq a
DS.Empty
locateFMIndexT PTCPat
xs FMIndexT
ys = do
STLCounterT s Int
tlcounter <- forall s. ST s (STOccCKCounterB s Int)
emptySTLCounterT
STLBoolT s Bool
tlbool <- forall s. ST s (STCBoolB s Bool)
emptySTLBoolT
STLCounterT s Int
tlcurrentstart <- forall s. ST s (STOccCKCounterB s Int)
emptySTLCurrentStartT
STLCounterT s Int
tlcurrentend <- forall s. ST s (STOccCKCounterB s Int)
emptySTLCurrentEndT
forall {s}.
PTCPat
-> FMIndexT
-> STRef s Int
-> STCBoolT s Bool
-> STRef s Int
-> STRef s Int
-> ST s ()
iLT PTCPat
xs
FMIndexT
ys
STLCounterT s Int
tlcounter
STLBoolT s Bool
tlbool
STLCounterT s Int
tlcurrentstart
STLCounterT s Int
tlcurrentend
Int
ctlcurrentstart <- forall s a. STRef s a -> ST s a
readSTRef STLCounterT s Int
tlcurrentstart
Int
ctlcurrentend <- forall s a. STRef s a -> ST s a
readSTRef STLCounterT s Int
tlcurrentend
Bool
ctlbool <- forall s a. STRef s a -> ST s a
readSTRef STLBoolT s Bool
tlbool
let indexes :: LIntB
indexes = if | (Int
ctlcurrentstart forall a. Eq a => a -> a -> Bool
== (-Int
1) Bool -> Bool -> Bool
&& Int
ctlcurrentend forall a. Eq a => a -> a -> Bool
== (-Int
1)) Bool -> Bool -> Bool
||
((Int
ctlcurrentend forall a. Num a => a -> a -> a
- Int
ctlcurrentstart) forall a. Num a => a -> a -> a
+ Int
1) forall a. Eq a => a -> a -> Bool
== Int
0 Bool -> Bool -> Bool
||
Bool
ctlbool
-> forall a. Seq a
DS.Empty
| Bool
otherwise
-> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$
forall a. [a] -> Seq a
DS.fromList forall a b. (a -> b) -> a -> b
$
[Int
ctlcurrentstart..Int
ctlcurrentend]
forall (m :: * -> *) a. Monad m => a -> m a
return LIntB
indexes
where
iLT :: PTCPat
-> FMIndexT
-> STRef s Int
-> STLBoolT s Bool
-> STRef s Int
-> STRef s Int
-> ST s ()
iLT PTCPat
DS.Empty FMIndexT
_ STRef s Int
_ STLBoolT s Bool
_ STRef s Int
_ STRef s Int
_ = forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
iLT (PTCPat
as DS.:|> Text
a) FMIndexT
bs STRef s Int
tlc STLBoolT s Bool
tlb STRef s Int
tlcs STRef s Int
tlce = do
let cctbs :: Seq (Int, Maybe Text)
cctbs = (\(CcT Seq (Int, Maybe Text)
t) -> Seq (Int, Maybe Text)
t) forall a b. (a -> b) -> a -> b
$
(\(CcT
a,OccCKT
_) -> CcT
a) forall a b. (a -> b) -> a -> b
$
(\(FMIndexT (CcT, OccCKT)
t) -> (CcT, OccCKT)
t) FMIndexT
bs
let coccckts :: Seq (Maybe Text, Seq (Int, Int, Maybe Text))
coccckts = (\(OccCKT Seq (Maybe Text, Seq (Int, Int, Maybe Text))
t) -> Seq (Maybe Text, Seq (Int, Int, Maybe Text))
t) forall a b. (a -> b) -> a -> b
$
(\(CcT
_,OccCKT
b) -> OccCKT
b) forall a b. (a -> b) -> a -> b
$
(\(FMIndexT (CcT, OccCKT)
t) -> (CcT, OccCKT)
t) FMIndexT
bs
Int
ctlc <- forall s a. STRef s a -> ST s a
readSTRef STRef s Int
tlc
Int
ctlcs <- forall s a. STRef s a -> ST s a
readSTRef STRef s Int
tlcs
Int
ctlce <- forall s a. STRef s a -> ST s a
readSTRef STRef s Int
tlce
if | Int
ctlcs forall a. Ord a => a -> a -> Bool
> Int
ctlce
-> do forall s. STCBoolB s Bool -> Bool -> ST s ()
updateSTLBoolT STLBoolT s Bool
tlb
Bool
True
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
| Bool
otherwise
-> if | Int
ctlc forall a. Eq a => a -> a -> Bool
== Int
0
-> do case forall a. (a -> Bool) -> Seq a -> Maybe Int
DS.findIndexL (\(Int
_,Maybe Text
d) -> Maybe Text
d forall a. Eq a => a -> a -> Bool
== forall a. a -> Maybe a
Just Text
a) Seq (Int, Maybe Text)
cctbs of
Maybe Int
Nothing -> forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
Just Int
bindex -> do if | Int
bindex forall a. Eq a => a -> a -> Bool
== (forall a. Seq a -> Int
DS.length Seq (Int, Maybe Text)
cctbs) forall a. Num a => a -> a -> a
- Int
1
-> do let istart :: Int
istart = (forall a b. (a, b) -> a
fst forall a b. (a -> b) -> a -> b
$ forall a. Seq a -> Int -> a
DS.index Seq (Int, Maybe Text)
cctbs Int
bindex) forall a. Num a => a -> a -> a
+ Int
1
let iend :: Int
iend = case forall a. Seq a -> ViewL a
viewl Seq (Maybe Text, Seq (Int, Int, Maybe Text))
coccckts of
ViewL (Maybe Text, Seq (Int, Int, Maybe Text))
EmptyL -> (-Int
1)
((Maybe Text, Seq (Int, Int, Maybe Text))
x DS.:< Seq (Maybe Text, Seq (Int, Int, Maybe Text))
_) -> forall a. Seq a -> Int
DS.length forall a b. (a -> b) -> a -> b
$
forall a b. (a, b) -> b
snd (Maybe Text, Seq (Int, Int, Maybe Text))
x
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTLCurrentStartT STRef s Int
tlcs
Int
istart
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTLCurrentEndT STRef s Int
tlce
Int
iend
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTLCounterT STRef s Int
tlc
Int
1
PTCPat
-> FMIndexT
-> STRef s Int
-> STLBoolT s Bool
-> STRef s Int
-> STRef s Int
-> ST s ()
iLT PTCPat
as
FMIndexT
bs
STRef s Int
tlc
STLBoolT s Bool
tlb
STRef s Int
tlcs
STRef s Int
tlce
| Bool
otherwise
-> do let istart :: Int
istart = (forall a b. (a, b) -> a
fst forall a b. (a -> b) -> a -> b
$ forall a. Seq a -> Int -> a
DS.index Seq (Int, Maybe Text)
cctbs Int
bindex) forall a. Num a => a -> a -> a
+ Int
1
let iend :: Int
iend = forall a b. (a, b) -> a
fst forall a b. (a -> b) -> a -> b
$ forall a. Seq a -> Int -> a
DS.index Seq (Int, Maybe Text)
cctbs (Int
bindex forall a. Num a => a -> a -> a
+ Int
1)
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTLCurrentStartT STRef s Int
tlcs
Int
istart
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTLCurrentEndT STRef s Int
tlce
Int
iend
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTLCounterT STRef s Int
tlc
Int
1
PTCPat
-> FMIndexT
-> STRef s Int
-> STLBoolT s Bool
-> STRef s Int
-> STRef s Int
-> ST s ()
iLT PTCPat
as
FMIndexT
bs
STRef s Int
tlc
STLBoolT s Bool
tlb
STRef s Int
tlcs
STRef s Int
tlce
| Bool
otherwise
-> do case forall a. (a -> Bool) -> Seq a -> Maybe Int
DS.findIndexL (\(Int
_,Maybe Text
d) -> Maybe Text
d forall a. Eq a => a -> a -> Bool
== forall a. a -> Maybe a
Just Text
a) Seq (Int, Maybe Text)
cctbs of
Maybe Int
Nothing -> forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
Just Int
bindex -> do case forall a. (a -> Bool) -> Seq a -> Maybe Int
DS.findIndexL (\(Maybe Text
e,Seq (Int, Int, Maybe Text)
_) -> Maybe Text
e forall a. Eq a => a -> a -> Bool
== forall a. a -> Maybe a
Just Text
a) Seq (Maybe Text, Seq (Int, Int, Maybe Text))
coccckts of
Maybe Int
Nothing -> forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
Just Int
cindex -> do let istart :: Int
istart = (forall a b. (a, b) -> a
fst forall a b. (a -> b) -> a -> b
$ forall a. Seq a -> Int -> a
DS.index Seq (Int, Maybe Text)
cctbs Int
bindex) forall a. Num a => a -> a -> a
+
((\(Int
_,Int
b,Maybe Text
_) -> Int
b) forall a b. (a -> b) -> a -> b
$
forall a. Seq a -> Int -> a
DS.index (forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall a. Seq a -> Int -> a
DS.index Seq (Maybe Text, Seq (Int, Int, Maybe Text))
coccckts Int
cindex) (Int
ctlcs forall a. Num a => a -> a -> a
- Int
1 forall a. Num a => a -> a -> a
- Int
1)) forall a. Num a => a -> a -> a
+
Int
1
let iend :: Int
iend = (forall a b. (a, b) -> a
fst forall a b. (a -> b) -> a -> b
$ forall a. Seq a -> Int -> a
DS.index Seq (Int, Maybe Text)
cctbs Int
bindex) forall a. Num a => a -> a -> a
+
((\(Int
_,Int
b,Maybe Text
_) -> Int
b) forall a b. (a -> b) -> a -> b
$
forall a. Seq a -> Int -> a
DS.index (forall a b. (a, b) -> b
snd forall a b. (a -> b) -> a -> b
$ forall a. Seq a -> Int -> a
DS.index Seq (Maybe Text, Seq (Int, Int, Maybe Text))
coccckts Int
cindex) (Int
ctlce forall a. Num a => a -> a -> a
- Int
1))
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCCurrentStartT STRef s Int
tlcs
Int
istart
forall s. STOccCKCounterB s Int -> Int -> ST s ()
updateSTCCurrentEndT STRef s Int
tlce
Int
iend
PTCPat
-> FMIndexT
-> STRef s Int
-> STLBoolT s Bool
-> STRef s Int
-> STRef s Int
-> ST s ()
iLT PTCPat
as
FMIndexT
bs
STRef s Int
tlc
STLBoolT s Bool
tlb
STRef s Int
tlcs
STRef s Int
tlce