{-# LANGUAGE MultiWayIf             #-}
{-# LANGUAGE ViewPatterns           #-}
{-# LANGUAGE Strict                 #-}
{-# LANGUAGE DeriveGeneric          #-}
{-# LANGUAGE TypeApplications       #-}
{-# OPTIONS_GHC -Wno-name-shadowing #-}


-- |
-- Module      :  Data.FMIndex.Internal
-- Copyright   :  (c) Matthew Mosior 2022
-- License     :  BSD-style
-- Maintainer  :  mattm.github@gmail.com
-- Portability :  portable
--
-- = WARNING
--
-- This module is considered __internal__.
--
-- The Package Versioning Policy __does not apply__.
--
-- The contents of this module may change __in any way whatsoever__
-- and __without any warning__ between minor versions of this package.
--
-- Authors importing this library are expected to track development
-- closely.
--
-- All credit goes to the author(s)/maintainer(s) of the
-- [containers](https://hackage.haskell.org/package/containers) library
-- for the above warning text.
--
-- = Description
--
-- Various data structures and custom data types to describe the
-- [Full-text Minute-space index (FM-index)](https://en.wikipedia.org/wiki/FM-index)
-- and the Inverse FM-index implementations, namely 'seqToOccCKB', 'seqToOccCKT', 'seqToCcB', 'seqToCcT', 'seqFromFMIndexB', and 'seqFromFMIndexT'.
--
-- The FM-index implementations rely heavily upon 'Seq' provided by the [containers](https://hackage.haskell.org/package/containers) library,
-- 'STRef' and associated functions in the [stref](https://hackage.haskell.org/package/base-4.17.0.0/docs/Data-STRef.html) library,
-- and 'runST' in the [Control.Monad.ST](https://hackage.haskell.org/package/base-4.17.0.0/docs/Control-Monad-ST.html) library.
--
-- = Example FM-index Output
--
-- The below example is taken from [this](https://en.wikipedia.org/wiki/FM-index) wikipedia page.
--
--
--
-- Given the following input, "abracadabra"
--
-- and
--
-- the following Burrows-Wheeler matrix (BWM) of the input "abracadabra":
--
-- +----+---+---------------------------------------+---+
-- | I  | F |                                       | L |
-- +====+===+===+===+===+===+===+===+===+===+===+===+===+
-- | 1  | $ | a | b | r | a | c | a | d | a | b | r | a |
-- +----+---+---+---+---+---+---+---+---+---+---+---+---+
-- | 2  | a | $ | a | b | r | a | c | a | d | a | b | r |
-- +----+---+---+---+---+---+---+---+---+---+---+---+---+
-- | 3  | a | b | r | a | $ | a | b | r | a | c | a | d |
-- +----+---+---+---+---+---+---+---+---+---+---+---+---+
-- | 4  | a | b | r | a | c | a | d | a | b | r | a | $ |
-- +----+---+---+---+---+---+---+---+---+---+---+---+---+
-- | 5  | a | c | a | d | a | b | r | a | $ | a | b | r |
-- +----+---+---+---+---+---+---+---+---+---+---+---+---+
-- | 6  | a | d | a | b | r | a | $ | a | b | r | a | c |
-- +----+---+---+---+---+---+---+---+---+---+---+---+---+
-- | 7  | b | r | a | $ | a | b | r | a | c | a | d | a |
-- +----+---+---+---+---+---+---+---+---+---+---+---+---+
-- | 8  | b | r | a | c | a | d | a | b | r | a | $ | a |
-- +----+---+---+---+---+---+---+---+---+---+---+---+---+
-- | 9  | c | a | d | a | b | r | a | $ | a | b | r | a |
-- +----+---+---+---+---+---+---+---+---+---+---+---+---+
-- | 10 | d | a | b | r | a | $ | a | b | r | a | c | a |
-- +----+---+---+---+---+---+---+---+---+---+---+---+---+
-- | 11 | r | a | $ | a | b | r | a | c | a | d | a | b |
-- +----+---+---+---+---+---+---+---+---+---+---+---+---+
-- | 12 | r | a | c | a | d | a | b | r | a | $ | a | b |
-- +----+---+---+---+---+---+---+---+---+---+---+---+---+
--
-- The FM-index output of the Burrows-Wheeler transform of the input is:
--
-- C[c] of "ard$rcaaaabb"
--
-- +------+---+---+---+---+---+----+
-- | c    | $ | a | b | c | d | r  |
-- +------+---+---+---+---+---+----+
-- | C[c] | 0 | 1 | 6 | 8 | 9 | 10 |
-- +------+---+---+---+---+---+----+
--
-- and
--
-- Occ(c,k) of "ard$rcaaaabb"
--
-- +---+---+---+---+---+---+---+---+---+---+----+----+----+
-- |   | a | r | d | $ | r | c | a | a | a | a  | b  | b  |
-- +---+---+---+---+---+---+---+---+---+---+----+----+----+
-- |   | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 |
-- +===+===+===+===+===+===+===+===+===+===+====+====+====+
-- | $ | 0 | 0 | 0 | 1 | 1 | 1 | 1 | 1 | 1 | 1  | 1  | 1  |
-- +---+---+---+---+---+---+---+---+---+---+----+----+----+
-- | a | 1 | 1 | 1 | 1 | 1 | 1 | 2 | 3 | 4 | 5  | 5  | 5  |
-- +---+---+---+---+---+---+---+---+---+---+----+----+----+
-- | b | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0  | 1  | 2  |
-- +---+---+---+---+---+---+---+---+---+---+----+----+----+
-- | c | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 1 | 1 | 1  | 1  | 1  |
-- +---+---+---+---+---+---+---+---+---+---+----+----+----+
-- | d | 0 | 0 | 1 | 1 | 1 | 1 | 1 | 1 | 1 | 1  | 1  | 1  |
-- +---+---+---+---+---+---+---+---+---+---+----+----+----+
-- | r | 0 | 1 | 1 | 1 | 2 | 2 | 2 | 2 | 2 | 2  | 2  | 2  |
-- +---+---+---+---+---+---+---+---+---+---+----+----+----+
--
--
--
-- Keep in mind that the __$__ is translated into a __Nothing__.


module Data.FMIndex.Internal ( -- * Base FM-index types
                               FMIndexB(..),
                               FMIndexT(..),
                               OccCKB(..),
                               OccCKT(..),
                               CcB(..),
                               CcT(..),
                               CB(..),
                               CT(..),
                               -- * To OccCK (ByteString) functions
                               PBOccCKSeqB,
                               OccCKSeqB,
                               STOccCKSeqB,
                               updateSTOccCKSeqAB,
                               updateSTOccCKSeqBB,
                               emptySTOccCKSeqB,
                               STOccCKILB,
                               loadSTOccCKILB,
                               emptySTOccCKILB,
                               STOccCKCounterB,
                               updateSTOccCKCounterB,
                               emptySTOccCKCounterB,
                               seqToOccCKB,              
                               -- * To OccCK (Text) functions
                               PTOccCKSeqT,
                               OccCKSeqT,
                               STOccCKSeqT,
                               updateSTOccCKSeqAT,
                               updateSTOccCKSeqBT,
                               emptySTOccCKSeqT,
                               STOccCKILT,
                               loadSTOccCKILT,
                               emptySTOccCKILT,
                               STOccCKCounterT,
                               updateSTOccCKCounterT,
                               emptySTOccCKCounterT,
                               seqToOccCKT,
                               -- * Cc (ByteString) functions
                               PBCcSeqB,
                               CcSeqB,
                               STCcSeqB,
                               updateSTCcSeqB,
                               emptySTCcSeqB,
                               STCcILB,
                               loadSTCcILB,
                               emptySTCcILB,
                               STCcCounterB,
                               updateSTCcCounterB,
                               emptySTCcCounterB,
                               seqToCcB,                                                              
                               -- * Cc (Text) functions
                               PTCcSeqT,
                               CcSeqT,
                               STCcSeqT,
                               updateSTCcSeqT,
                               emptySTCcSeqT,
                               STCcILT,
                               loadSTCcILT,
                               emptySTCcILT,
                               STCcCounterT,
                               updateSTCcCounterT,
                               emptySTCcCounterT,
                               seqToCcT,
                               -- * From FMIndex (ByteString) functions
                               FFMIndexSeqB,
                               seqFromFMIndexB,
                               -- * From FMIndex (Text) functions
                               FFMIndexSeqT,
                               seqFromFMIndexT,
                               -- * Count (ByteString) operation
                               PBCPat,
                               CIntB,
                               STCBoolB,
                               updateSTCBoolB,
                               emptySTCBoolB,
                               STCCounterB,
                               updateSTCCounterB,
                               emptySTCCounterB,
                               STCCurrentStartB,
                               updateSTCCurrentStartB,
                               emptySTCCurrentStartB,
                               STCCurrentEndB,
                               updateSTCCurrentEndB,
                               emptySTCCurrentEndB,
                               countFMIndexB,
                               -- * Count (Text) operation
                               PTCPat,
                               CIntT,
                               STCBoolT,
                               updateSTCBoolT,
                               emptySTCBoolT,
                               STCCounterT,
                               updateSTCCounterT,
                               emptySTCCounterT,
                               STCCurrentStartT,
                               updateSTCCurrentStartT,
                               emptySTCCurrentStartT,
                               STCCurrentEndT,
                               updateSTCCurrentEndT,
                               emptySTCCurrentEndT,
                               countFMIndexT,
                               -- * Locate (ByteString) operation
                               PBLPat,
                               LIntB,
                               STLBoolB,
                               updateSTLBoolB,
                               emptySTLBoolB,
                               STLCounterB,
                               updateSTLCounterB,
                               emptySTLCounterB,
                               STLCurrentStartB,
                               updateSTLCurrentStartB,
                               emptySTLCurrentStartB,
                               STLCurrentEndB,
                               updateSTLCurrentEndB,
                               emptySTLCurrentEndB,
                               locateFMIndexB,
                               -- * Locate (Text) operation
                               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


{-Base level types.-}

-- | Basic FMIndex ('ByteString') data type.
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)

-- | Basic FMIndex ('Text') data type.
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)

-- | Basic OccCKB ('ByteString') data type.
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)

-- | Basic OccCKT ('Text') data type.
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)

-- | Basic C[c] table ('ByteString') data type.
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)

-- | Basic C[c] table ('Text') data type.
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)

-- | Basic count ('ByteString') operation data type.
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)

-- | Basic count ('Text') operation data type.
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)

{-------------------}


{-toOccCK (ByteString) functions.-}

-- | Abstract 'PBOccCKSeqB' type utilizing a 'Seq'.
type PBOccCKSeqB = Seq (Maybe ByteString)

-- | Abstract 'OccCKSeqB' type utilizing a 'Seq'.
-- (c,(indexofinputcurrentelement,Occ(c,k),inputcurrentelement))
type OccCKSeqB = Seq (Maybe ByteString,Seq (Int,Int,Maybe ByteString))

-- | Abstract data type representing a 'OccCKSeqB' in the (strict) ST monad.
type STOccCKSeqB s a = STRef s OccCKSeqB

-- | State function to update 'OccCKSeqB'
-- with each step of the OccCK.
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))

-- | State function to update 'OccCKSeqB'
-- with each step of the OccCK.
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))

-- | State function to create empty 'STOccCKSeqB' type.
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

-- | Abstract 'STOccCKILB' and associated state type.
type STOccCKILB s a = STRef s (Seq (Maybe ByteString))

-- | State function to load list into 'STOccCKILB'.
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

-- | State function to create empty 'STOccCKILB' type.
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

-- | Abstract 'STOccCKCounterB' and associated state type.
type STOccCKCounterB s a = STRef s Int

-- | State function to update 'STOccCKCounterB'.
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

-- | State function to create empty 'STOccCKCounterB' type.
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 

-- | Strict state monad function.
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

{---------------------------------}


{-toOccCK (Text) functions.-}

-- | Abstract 'PTOccCKSeqT' type utilizing a 'Seq'.
type PTOccCKSeqT = Seq (Maybe Text)

-- | Abstract 'OccCKSeqT' type utilizing a 'Seq'.
-- (c,(indexofinputcurrentelement,Occ(c,k),inputcurrentelement))
type OccCKSeqT = Seq (Maybe Text,Seq (Int,Int,Maybe Text))

-- | Abstract data type representing a 'OccCKSeqT' in the (strict) ST monad.
type STOccCKSeqT s a = STRef s OccCKSeqT

-- | State function to update 'OccCKSeqT'
-- with each step of the OccCK.
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))

-- | State function to update 'OccCKSeqT'
-- with each step of the OccCK.
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))

-- | State function to create empty 'STOccCKSeqT' type.
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

-- | Abstract 'STOccCKILT' and associated state type.
type STOccCKILT s a = STRef s (Seq (Maybe Text))

-- | State function to load list into 'STOccCKILT'.
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

-- | State function to create empty 'STOccCKILT' type.
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

-- | Abstract 'STOccCKCounterT' and associated state type.
type STOccCKCounterT s a = STRef s Int

-- | State function to update 'STOccCKCounterT'.
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

-- | State function to create empty 'STOccCKCounterT' type.
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

-- | Strict state monad function.
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

{---------------------------}


{-To Cc (ByteString) functions.-}

-- | Abstract 'PBCcSeqB' type utilizing a 'Seq'.
type PBCcSeqB = Seq (Maybe ByteString)

-- | Abstract 'CcSeqB' type utilizing a 'Seq'.
-- (C[c],c)
type CcSeqB = Seq (Int,Maybe ByteString)

-- | Abstract data type representing a 'CcSeqB' in the (strict) ST monad.
type STCcSeqB s a = STRef s CcSeqB

-- | State function to update 'CcSeqB'
-- with each step of the C[c].
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)

-- | State function to create empty 'STCcSeqT' type.
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

-- | Abstract 'STCcILB' and associated state type.
type STCcILB s a = STRef s (Seq (Maybe ByteString))

-- | State function to load list into 'STCcILB'.
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

-- | State function to create empty 'STCcILB' type.
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

-- | Abstract 'STCcCounterB' and associated state type.
type STCcCounterB s a = STRef s Int

-- | State function to update 'STCcCounterB'.
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

-- | State function to create empty 'STCcCounterT' type.
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

-- | Strict state monad function.
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

{-------------------------------}


{-To Cc (Text) functions.-}

-- | Abstract 'PTCcSeqT' type utilizing a 'Seq'.
type PTCcSeqT = Seq (Maybe Text)

-- | Abstract 'CcSeqT' type utilizing a 'Seq'.
-- (C[c],c)
type CcSeqT = Seq (Int,Maybe Text)

-- | Abstract data type representing a 'CcSeqT' in the (strict) ST monad.
type STCcSeqT s a = STRef s CcSeqT

-- | State function to update 'CcSeqT'
-- with each step of the C[c].
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)

-- | State function to create empty 'STCcSeqT' type.
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

-- | Abstract 'STCcILT' and associated state type.
type STCcILT s a = STRef s (Seq (Maybe Text))

-- | State function to load list into 'STCcILT'.
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

-- | State function to create empty 'STCcILT' type.
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

-- | Abstract 'STCcCounterT' and associated state type.
type STCcCounterT s a = STRef s Int

-- | State function to update 'STCcCounterT'.
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

-- | State function to create empty 'STCcCounterT' type.
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

-- | Strict state monad function.
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

{-------------------------}


{-fromFMIndex (ByteString) functions.-}

-- | Abstract 'FFMIndexSeqB' type utilizing a 'Seq'.
type FFMIndexSeqB = Seq (Maybe ByteString)

-- | Simple Inverse FMIndex function. 
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

{-------------------------------------}


{-fromFMIndex (Text) functions.-}

-- | Abstract 'FFMIndexSeqT' type utilizing a 'Seq'.
type FFMIndexSeqT = Seq (Maybe Text)

-- | Simple Inverse FMIndex function.
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

{-------------------------------}


{-Count (ByteString) operation.-}

-- | Abstract 'PBCPat' type utilizing a 'Seq'.
type PBCPat = Seq ByteString

-- | Abstract 'CIntB' type utilizing an 'Int'.
type CIntB = Maybe Int

-- | Abstract 'STCBoolB' type utilizing a 'Bool'.
type STCBoolB s a = STRef s Bool

-- | State function to update 'STCBoolB' in the (strict) ST monad.
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

-- | State function to create empty 'STCBoolB' type.
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

-- | Abstract data type representing a 'STCCounterB' in the (strict) ST monad.
type STCCounterB s a = STRef s Int

-- | State function to update 'STCCounterB'
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

-- | State function to create empty 'STCCounterB' type.
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

-- | Abstract 'STCCurrentStartB' type utilizing a 'Seq'.
type STCCurrentStartB s a = STRef s Int

-- | State function to update 'STCCurrentStartB'.
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

-- | State function to create empty 'STCCurrentStartB' type.
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)

-- | Abstract 'STCCurrentEndB' type utilizing a 'Seq'.
type STCCurrentEndB s a = STRef s Int

-- | State function to update 'STCCurrentEndB'.
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

-- | State function to create empty 'STCCurrentEndB' type.
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)

-- | Count operation on a 'FMIndexB'.
-- This operation takes a pattern ('Seq' 'ByteString')
-- and returns the number of occurences of that pattern
-- in the original text T [credit](https://en.wikipedia.org/wiki/FM-index).
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

{-------------------------------}


{-Count (Text) operation.-}

-- | Abstract 'PTCPat' type utilizing a 'Seq'.
type PTCPat = Seq Text

-- | Abstract 'CIntT' type utilizing an 'Int'.
type CIntT = Maybe Int

-- | Abstract 'STCBoolT' type utilizing a 'Bool'.
type STCBoolT s a = STRef s Bool

-- | State function to update 'STCBoolT' in the (strict) ST monad.
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

-- | State function to create empty 'STCBoolT' type.
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

-- | Abstract data type representing a 'STCCounterT' in the (strict) ST monad.
type STCCounterT s a = STRef s Int

-- | State function to update 'STCCounterT'
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

-- | State function to create empty 'STCCounterT' type.
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

-- | Abstract 'STCCurrentStartT' type utilizing a 'Seq'.
type STCCurrentStartT s a = STRef s Int

-- | State function to update 'STCCurrentStartT'.
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

-- | State function to create empty 'STCCurrentStartT' type.
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)

-- | Abstract 'STCCurrentEndT' type utilizing a 'Seq'.
type STCCurrentEndT s a = STRef s Int

-- | State function to update 'STCCurrentEndT'.
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

-- | State function to create empty 'STCCurrentEndT' type.
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)

-- | Count operation on a 'FMIndexT'.
-- This operation takes a pattern ('Seq' 'Text')
-- and returns the number of occurences of that pattern
-- in the original text T [credit](https://en.wikipedia.org/wiki/FM-index).
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

{-------------------------------}


{-Locate (ByteString) operation.-}

-- | Abstract 'PBLPat' type utilizing a 'Seq'.
type PBLPat = Seq ByteString

-- | Abstract 'LIntB' type utilizing an 'Int'.
type LIntB = Seq (Maybe Int)

-- | Abstract 'STLBoolB' type utilizing a 'Bool'.
type STLBoolB s a = STRef s Bool

-- | State function to update 'STLBoolB' in the (strict) ST monad.
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

-- | State function to create empty 'STLBoolB' type.
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

-- | Abstract data type representing a 'STLCounterB' in the (strict) ST monad.
type STLCounterB s a = STRef s Int

-- | State function to update 'STLCounterB'
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

-- | State function to create empty 'STLCounterB' type.
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

-- | Abstract 'STLCurrentStartB' type utilizing a 'Seq'.
type STLCurrentStartB s a = STRef s Int

-- | State function to update 'STLCurrentStartB'.
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

-- | State function to create empty 'STLCurrentStartB' type.
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)

-- | Abstract 'STLCurrentEndB' type utilizing a 'Seq'.
type STLCurrentEndB s a = STRef s Int

-- | State function to update 'STLCurrentEndB'.
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

-- | State function to create empty 'STLCurrentEndB' type.
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)

-- | Locate operation on a 'FMIndexB'.
-- This operation takes a pattern ('Seq' 'ByteString')
-- and returns the indexe(s) of occurences of that pattern
-- in the original text T [credit](https://en.wikipedia.org/wiki/FM-index).
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

{--------------------------------}


{-Locate (Text) operation.-}

-- | Abstract 'PTLPat' type utilizing a 'Seq'.
type PTLPat = Seq Text

-- | Abstract 'LIntT' type utilizing an 'Int'.
type LIntT = Seq (Maybe Int)

-- | Abstract 'STLBoolT' type utilizing a 'Bool'.
type STLBoolT s a = STRef s Bool

-- | State function to update 'STLBoolT' in the (strict) ST monad.
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

-- | State function to create empty 'STLBoolT' type.
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

-- | Abstract data type representing a 'STLCounterT' in the (strict) ST monad.
type STLCounterT s a = STRef s Int

-- | State function to update 'STLCounterT'
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

-- | State function to create empty 'STLCounterT' type.
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

-- | Abstract 'STLCurrentStartT' type utilizing a 'Seq'.
type STLCurrentStartT s a = STRef s Int

-- | State function to update 'STLCurrentStartT'.
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

-- | State function to create empty 'STLCurrentStartT' type.
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)

-- | Abstract 'STLCurrentEndT' type utilizing a 'Seq'.
type STLCurrentEndT s a = STRef s Int

-- | State function to update 'STLCurrentEndT'.
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

-- | State function to create empty 'STLCurrentEndT' type.
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)

-- | Locate operation on a 'FMIndexT'.
-- This operation takes a pattern ('Seq' 'Text')
-- and returns the indexe(s) of occurences of that pattern
-- in the original text T [credit](https://en.wikipedia.org/wiki/FM-index).
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

{--------------------------}