-- Module      : Verismith.Verilog2005.Token
-- Description : Tokens for Verilog 2005 lexing and parsing.
-- Copyright   : (c) 2023 Quentin Corradi
-- License     : GPL-3
-- Maintainer  : q [dot] corradi22 [at] imperial [dot] ac [dot] uk
-- Stability   : experimental
-- Portability : POSIX
{-# LANGUAGE DeriveAnyClass, DeriveDataTypeable, DeriveGeneric #-}

module Verismith.Verilog2005.Token
  ( PosToken (..),
    Position (..),
    PSource (..),
    helperShowPositions,
    showWithPosition,
    Token (..),
    AFRNP (..),
    BXZ (..),
    OXZ (..),
    HXZ (..),
    ZOX (..),
    Base (..),
  )
where

import Control.DeepSeq (NFData)
import qualified Data.ByteString as B
import Data.ByteString.Internal
import qualified Data.ByteString.Lazy as LBS
import Data.Data (Data)
import Data.List.NonEmpty (NonEmpty (..))
import GHC.Generics (Generic)
import Numeric.Natural
import Text.Printf (printf)
import Verismith.Utils

data PosToken = PosToken
  { PosToken -> NonEmpty Position
_ptPos :: !(NonEmpty Position),
    PosToken -> Token
_ptToken :: !Token
  }
  deriving (PosToken -> PosToken -> Bool
(PosToken -> PosToken -> Bool)
-> (PosToken -> PosToken -> Bool) -> Eq PosToken
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PosToken -> PosToken -> Bool
== :: PosToken -> PosToken -> Bool
$c/= :: PosToken -> PosToken -> Bool
/= :: PosToken -> PosToken -> Bool
Eq)

instance Show PosToken where
  show :: PosToken -> [Char]
show (PosToken NonEmpty Position
_ Token
t) = Token -> [Char]
forall a. Show a => a -> [Char]
show Token
t

data Position = Position
  { Position -> Word
_posLine :: !Word,
    Position -> Word
_posColumn :: !Word,
    Position -> PSource
_posSource :: !PSource
  }
  deriving (Position -> Position -> Bool
(Position -> Position -> Bool)
-> (Position -> Position -> Bool) -> Eq Position
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Position -> Position -> Bool
== :: Position -> Position -> Bool
$c/= :: Position -> Position -> Bool
/= :: Position -> Position -> Bool
Eq)

data PSource
  = PSFile !String
  | PSDefine !LBS.ByteString
  | PSLine
    { PSource -> [Char]
_pslFile :: !String,
      PSource -> Bool
_pslEntering :: !Bool
    }
  deriving (PSource -> PSource -> Bool
(PSource -> PSource -> Bool)
-> (PSource -> PSource -> Bool) -> Eq PSource
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PSource -> PSource -> Bool
== :: PSource -> PSource -> Bool
$c/= :: PSource -> PSource -> Bool
/= :: PSource -> PSource -> Bool
Eq)

instance Show PSource where
  show :: PSource -> [Char]
show PSource
x = case PSource
x of
    PSFile [Char]
f -> [Char]
"file " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
f
    PSDefine ByteString
t -> [Char]
"macro replacement \"" [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ (Word8 -> Char) -> [Word8] -> [Char]
forall a b. (a -> b) -> [a] -> [b]
map Word8 -> Char
w2c (ByteString -> [Word8]
LBS.unpack ByteString
t) [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
"\""
    PSLine [Char]
f Bool
_ -> [Char]
"file " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
f

instance Show Position where
  show :: Position -> [Char]
show (Position Word
l Word
c PSource
s) = [Char] -> Word -> Word -> [Char]
forall r. PrintfType r => [Char] -> r
printf [Char]
"line %d, column %d of " Word
l Word
c [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ PSource -> [Char]
forall a. Show a => a -> [Char]
show PSource
s

helperShowPositions :: NonEmpty Position -> String
helperShowPositions :: NonEmpty Position -> [Char]
helperShowPositions =
  (Position -> [Char])
-> (Position -> ShowS) -> NonEmpty Position -> [Char]
forall a b. (a -> b) -> (a -> b -> b) -> NonEmpty a -> b
foldrMap1
    Position -> [Char]
forall a. Show a => a -> [Char]
show
    ((Position -> ShowS) -> NonEmpty Position -> [Char])
-> (Position -> ShowS) -> NonEmpty Position -> [Char]
forall a b. (a -> b) -> a -> b
$ \a :: Position
a@(Position Word
_ Word
_ PSource
s) [Char]
b -> Position -> [Char]
forall a. Show a => a -> [Char]
show Position
a
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ case PSource
s of {PSFile [Char]
_ -> [Char]
" included"; PSDefine ByteString
_ -> [Char]
""; PSLine [Char]
_ Bool
_ -> [Char]
" set"}
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" from "
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
b

showWithPosition :: PosToken -> String
showWithPosition :: PosToken -> [Char]
showWithPosition (PosToken NonEmpty Position
p Token
t) = Token -> [Char]
forall a. Show a => a -> [Char]
show Token
t [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" at " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ NonEmpty Position -> [Char]
helperShowPositions NonEmpty Position
p

data AFRNP = AFRNPA | AFRNPF | AFRNPR | AFRNPN | AFRNPP
  deriving (AFRNP -> AFRNP -> Bool
(AFRNP -> AFRNP -> Bool) -> (AFRNP -> AFRNP -> Bool) -> Eq AFRNP
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: AFRNP -> AFRNP -> Bool
== :: AFRNP -> AFRNP -> Bool
$c/= :: AFRNP -> AFRNP -> Bool
/= :: AFRNP -> AFRNP -> Bool
Eq, Eq AFRNP
Eq AFRNP =>
(AFRNP -> AFRNP -> Ordering)
-> (AFRNP -> AFRNP -> Bool)
-> (AFRNP -> AFRNP -> Bool)
-> (AFRNP -> AFRNP -> Bool)
-> (AFRNP -> AFRNP -> Bool)
-> (AFRNP -> AFRNP -> AFRNP)
-> (AFRNP -> AFRNP -> AFRNP)
-> Ord AFRNP
AFRNP -> AFRNP -> Bool
AFRNP -> AFRNP -> Ordering
AFRNP -> AFRNP -> AFRNP
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
$ccompare :: AFRNP -> AFRNP -> Ordering
compare :: AFRNP -> AFRNP -> Ordering
$c< :: AFRNP -> AFRNP -> Bool
< :: AFRNP -> AFRNP -> Bool
$c<= :: AFRNP -> AFRNP -> Bool
<= :: AFRNP -> AFRNP -> Bool
$c> :: AFRNP -> AFRNP -> Bool
> :: AFRNP -> AFRNP -> Bool
$c>= :: AFRNP -> AFRNP -> Bool
>= :: AFRNP -> AFRNP -> Bool
$cmax :: AFRNP -> AFRNP -> AFRNP
max :: AFRNP -> AFRNP -> AFRNP
$cmin :: AFRNP -> AFRNP -> AFRNP
min :: AFRNP -> AFRNP -> AFRNP
Ord, Typeable AFRNP
Typeable AFRNP =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> AFRNP -> c AFRNP)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AFRNP)
-> (AFRNP -> Constr)
-> (AFRNP -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AFRNP))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AFRNP))
-> ((forall b. Data b => b -> b) -> AFRNP -> AFRNP)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AFRNP -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AFRNP -> r)
-> (forall u. (forall d. Data d => d -> u) -> AFRNP -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> AFRNP -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AFRNP -> m AFRNP)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AFRNP -> m AFRNP)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AFRNP -> m AFRNP)
-> Data AFRNP
AFRNP -> Constr
AFRNP -> DataType
(forall b. Data b => b -> b) -> AFRNP -> AFRNP
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> AFRNP -> u
forall u. (forall d. Data d => d -> u) -> AFRNP -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AFRNP -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AFRNP -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AFRNP -> m AFRNP
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AFRNP -> m AFRNP
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AFRNP
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AFRNP -> c AFRNP
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AFRNP)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AFRNP)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AFRNP -> c AFRNP
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AFRNP -> c AFRNP
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AFRNP
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AFRNP
$ctoConstr :: AFRNP -> Constr
toConstr :: AFRNP -> Constr
$cdataTypeOf :: AFRNP -> DataType
dataTypeOf :: AFRNP -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AFRNP)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AFRNP)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AFRNP)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c AFRNP)
$cgmapT :: (forall b. Data b => b -> b) -> AFRNP -> AFRNP
gmapT :: (forall b. Data b => b -> b) -> AFRNP -> AFRNP
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AFRNP -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> AFRNP -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AFRNP -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> AFRNP -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AFRNP -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> AFRNP -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AFRNP -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AFRNP -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AFRNP -> m AFRNP
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AFRNP -> m AFRNP
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AFRNP -> m AFRNP
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AFRNP -> m AFRNP
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AFRNP -> m AFRNP
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AFRNP -> m AFRNP
Data, (forall x. AFRNP -> Rep AFRNP x)
-> (forall x. Rep AFRNP x -> AFRNP) -> Generic AFRNP
forall x. Rep AFRNP x -> AFRNP
forall x. AFRNP -> Rep AFRNP x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. AFRNP -> Rep AFRNP x
from :: forall x. AFRNP -> Rep AFRNP x
$cto :: forall x. Rep AFRNP x -> AFRNP
to :: forall x. Rep AFRNP x -> AFRNP
Generic, AFRNP -> ()
(AFRNP -> ()) -> NFData AFRNP
forall a. (a -> ()) -> NFData a
$crnf :: AFRNP -> ()
rnf :: AFRNP -> ()
NFData)

data BXZ = BXZ0 | BXZ1 | BXZX | BXZZ
  deriving (BXZ -> BXZ -> Bool
(BXZ -> BXZ -> Bool) -> (BXZ -> BXZ -> Bool) -> Eq BXZ
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: BXZ -> BXZ -> Bool
== :: BXZ -> BXZ -> Bool
$c/= :: BXZ -> BXZ -> Bool
/= :: BXZ -> BXZ -> Bool
Eq, Eq BXZ
Eq BXZ =>
(BXZ -> BXZ -> Ordering)
-> (BXZ -> BXZ -> Bool)
-> (BXZ -> BXZ -> Bool)
-> (BXZ -> BXZ -> Bool)
-> (BXZ -> BXZ -> Bool)
-> (BXZ -> BXZ -> BXZ)
-> (BXZ -> BXZ -> BXZ)
-> Ord BXZ
BXZ -> BXZ -> Bool
BXZ -> BXZ -> Ordering
BXZ -> BXZ -> BXZ
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
$ccompare :: BXZ -> BXZ -> Ordering
compare :: BXZ -> BXZ -> Ordering
$c< :: BXZ -> BXZ -> Bool
< :: BXZ -> BXZ -> Bool
$c<= :: BXZ -> BXZ -> Bool
<= :: BXZ -> BXZ -> Bool
$c> :: BXZ -> BXZ -> Bool
> :: BXZ -> BXZ -> Bool
$c>= :: BXZ -> BXZ -> Bool
>= :: BXZ -> BXZ -> Bool
$cmax :: BXZ -> BXZ -> BXZ
max :: BXZ -> BXZ -> BXZ
$cmin :: BXZ -> BXZ -> BXZ
min :: BXZ -> BXZ -> BXZ
Ord, BXZ
BXZ -> BXZ -> Bounded BXZ
forall a. a -> a -> Bounded a
$cminBound :: BXZ
minBound :: BXZ
$cmaxBound :: BXZ
maxBound :: BXZ
Bounded, Int -> BXZ
BXZ -> Int
BXZ -> [BXZ]
BXZ -> BXZ
BXZ -> BXZ -> [BXZ]
BXZ -> BXZ -> BXZ -> [BXZ]
(BXZ -> BXZ)
-> (BXZ -> BXZ)
-> (Int -> BXZ)
-> (BXZ -> Int)
-> (BXZ -> [BXZ])
-> (BXZ -> BXZ -> [BXZ])
-> (BXZ -> BXZ -> [BXZ])
-> (BXZ -> BXZ -> BXZ -> [BXZ])
-> Enum BXZ
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: BXZ -> BXZ
succ :: BXZ -> BXZ
$cpred :: BXZ -> BXZ
pred :: BXZ -> BXZ
$ctoEnum :: Int -> BXZ
toEnum :: Int -> BXZ
$cfromEnum :: BXZ -> Int
fromEnum :: BXZ -> Int
$cenumFrom :: BXZ -> [BXZ]
enumFrom :: BXZ -> [BXZ]
$cenumFromThen :: BXZ -> BXZ -> [BXZ]
enumFromThen :: BXZ -> BXZ -> [BXZ]
$cenumFromTo :: BXZ -> BXZ -> [BXZ]
enumFromTo :: BXZ -> BXZ -> [BXZ]
$cenumFromThenTo :: BXZ -> BXZ -> BXZ -> [BXZ]
enumFromThenTo :: BXZ -> BXZ -> BXZ -> [BXZ]
Enum, Typeable BXZ
Typeable BXZ =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> BXZ -> c BXZ)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BXZ)
-> (BXZ -> Constr)
-> (BXZ -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BXZ))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BXZ))
-> ((forall b. Data b => b -> b) -> BXZ -> BXZ)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BXZ -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BXZ -> r)
-> (forall u. (forall d. Data d => d -> u) -> BXZ -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> BXZ -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BXZ -> m BXZ)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BXZ -> m BXZ)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BXZ -> m BXZ)
-> Data BXZ
BXZ -> Constr
BXZ -> DataType
(forall b. Data b => b -> b) -> BXZ -> BXZ
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> BXZ -> u
forall u. (forall d. Data d => d -> u) -> BXZ -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BXZ -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BXZ -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BXZ -> m BXZ
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BXZ -> m BXZ
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BXZ
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BXZ -> c BXZ
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BXZ)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BXZ)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BXZ -> c BXZ
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BXZ -> c BXZ
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BXZ
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BXZ
$ctoConstr :: BXZ -> Constr
toConstr :: BXZ -> Constr
$cdataTypeOf :: BXZ -> DataType
dataTypeOf :: BXZ -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BXZ)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BXZ)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BXZ)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BXZ)
$cgmapT :: (forall b. Data b => b -> b) -> BXZ -> BXZ
gmapT :: (forall b. Data b => b -> b) -> BXZ -> BXZ
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BXZ -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BXZ -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BXZ -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BXZ -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BXZ -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> BXZ -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BXZ -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BXZ -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BXZ -> m BXZ
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BXZ -> m BXZ
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BXZ -> m BXZ
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BXZ -> m BXZ
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BXZ -> m BXZ
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BXZ -> m BXZ
Data, (forall x. BXZ -> Rep BXZ x)
-> (forall x. Rep BXZ x -> BXZ) -> Generic BXZ
forall x. Rep BXZ x -> BXZ
forall x. BXZ -> Rep BXZ x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. BXZ -> Rep BXZ x
from :: forall x. BXZ -> Rep BXZ x
$cto :: forall x. Rep BXZ x -> BXZ
to :: forall x. Rep BXZ x -> BXZ
Generic, BXZ -> ()
(BXZ -> ()) -> NFData BXZ
forall a. (a -> ()) -> NFData a
$crnf :: BXZ -> ()
rnf :: BXZ -> ()
NFData)

data OXZ = OXZ0 | OXZ1 | OXZ2 | OXZ3 | OXZ4 | OXZ5 | OXZ6 | OXZ7 | OXZX | OXZZ
  deriving (OXZ -> OXZ -> Bool
(OXZ -> OXZ -> Bool) -> (OXZ -> OXZ -> Bool) -> Eq OXZ
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: OXZ -> OXZ -> Bool
== :: OXZ -> OXZ -> Bool
$c/= :: OXZ -> OXZ -> Bool
/= :: OXZ -> OXZ -> Bool
Eq, Eq OXZ
Eq OXZ =>
(OXZ -> OXZ -> Ordering)
-> (OXZ -> OXZ -> Bool)
-> (OXZ -> OXZ -> Bool)
-> (OXZ -> OXZ -> Bool)
-> (OXZ -> OXZ -> Bool)
-> (OXZ -> OXZ -> OXZ)
-> (OXZ -> OXZ -> OXZ)
-> Ord OXZ
OXZ -> OXZ -> Bool
OXZ -> OXZ -> Ordering
OXZ -> OXZ -> OXZ
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
$ccompare :: OXZ -> OXZ -> Ordering
compare :: OXZ -> OXZ -> Ordering
$c< :: OXZ -> OXZ -> Bool
< :: OXZ -> OXZ -> Bool
$c<= :: OXZ -> OXZ -> Bool
<= :: OXZ -> OXZ -> Bool
$c> :: OXZ -> OXZ -> Bool
> :: OXZ -> OXZ -> Bool
$c>= :: OXZ -> OXZ -> Bool
>= :: OXZ -> OXZ -> Bool
$cmax :: OXZ -> OXZ -> OXZ
max :: OXZ -> OXZ -> OXZ
$cmin :: OXZ -> OXZ -> OXZ
min :: OXZ -> OXZ -> OXZ
Ord, OXZ
OXZ -> OXZ -> Bounded OXZ
forall a. a -> a -> Bounded a
$cminBound :: OXZ
minBound :: OXZ
$cmaxBound :: OXZ
maxBound :: OXZ
Bounded, Int -> OXZ
OXZ -> Int
OXZ -> [OXZ]
OXZ -> OXZ
OXZ -> OXZ -> [OXZ]
OXZ -> OXZ -> OXZ -> [OXZ]
(OXZ -> OXZ)
-> (OXZ -> OXZ)
-> (Int -> OXZ)
-> (OXZ -> Int)
-> (OXZ -> [OXZ])
-> (OXZ -> OXZ -> [OXZ])
-> (OXZ -> OXZ -> [OXZ])
-> (OXZ -> OXZ -> OXZ -> [OXZ])
-> Enum OXZ
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: OXZ -> OXZ
succ :: OXZ -> OXZ
$cpred :: OXZ -> OXZ
pred :: OXZ -> OXZ
$ctoEnum :: Int -> OXZ
toEnum :: Int -> OXZ
$cfromEnum :: OXZ -> Int
fromEnum :: OXZ -> Int
$cenumFrom :: OXZ -> [OXZ]
enumFrom :: OXZ -> [OXZ]
$cenumFromThen :: OXZ -> OXZ -> [OXZ]
enumFromThen :: OXZ -> OXZ -> [OXZ]
$cenumFromTo :: OXZ -> OXZ -> [OXZ]
enumFromTo :: OXZ -> OXZ -> [OXZ]
$cenumFromThenTo :: OXZ -> OXZ -> OXZ -> [OXZ]
enumFromThenTo :: OXZ -> OXZ -> OXZ -> [OXZ]
Enum, Typeable OXZ
Typeable OXZ =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> OXZ -> c OXZ)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c OXZ)
-> (OXZ -> Constr)
-> (OXZ -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c OXZ))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OXZ))
-> ((forall b. Data b => b -> b) -> OXZ -> OXZ)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OXZ -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OXZ -> r)
-> (forall u. (forall d. Data d => d -> u) -> OXZ -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> OXZ -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> OXZ -> m OXZ)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OXZ -> m OXZ)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OXZ -> m OXZ)
-> Data OXZ
OXZ -> Constr
OXZ -> DataType
(forall b. Data b => b -> b) -> OXZ -> OXZ
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> OXZ -> u
forall u. (forall d. Data d => d -> u) -> OXZ -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OXZ -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OXZ -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OXZ -> m OXZ
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OXZ -> m OXZ
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OXZ
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OXZ -> c OXZ
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OXZ)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OXZ)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OXZ -> c OXZ
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OXZ -> c OXZ
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OXZ
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OXZ
$ctoConstr :: OXZ -> Constr
toConstr :: OXZ -> Constr
$cdataTypeOf :: OXZ -> DataType
dataTypeOf :: OXZ -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OXZ)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OXZ)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OXZ)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c OXZ)
$cgmapT :: (forall b. Data b => b -> b) -> OXZ -> OXZ
gmapT :: (forall b. Data b => b -> b) -> OXZ -> OXZ
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OXZ -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> OXZ -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OXZ -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> OXZ -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> OXZ -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> OXZ -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> OXZ -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> OXZ -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OXZ -> m OXZ
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OXZ -> m OXZ
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OXZ -> m OXZ
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OXZ -> m OXZ
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OXZ -> m OXZ
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OXZ -> m OXZ
Data, (forall x. OXZ -> Rep OXZ x)
-> (forall x. Rep OXZ x -> OXZ) -> Generic OXZ
forall x. Rep OXZ x -> OXZ
forall x. OXZ -> Rep OXZ x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. OXZ -> Rep OXZ x
from :: forall x. OXZ -> Rep OXZ x
$cto :: forall x. Rep OXZ x -> OXZ
to :: forall x. Rep OXZ x -> OXZ
Generic, OXZ -> ()
(OXZ -> ()) -> NFData OXZ
forall a. (a -> ()) -> NFData a
$crnf :: OXZ -> ()
rnf :: OXZ -> ()
NFData)

data HXZ
  = HXZ0
  | HXZ1
  | HXZ2
  | HXZ3
  | HXZ4
  | HXZ5
  | HXZ6
  | HXZ7
  | HXZ8
  | HXZ9
  | HXZA
  | HXZB
  | HXZC
  | HXZD
  | HXZE
  | HXZF
  | HXZX
  | HXZZ
  deriving (HXZ -> HXZ -> Bool
(HXZ -> HXZ -> Bool) -> (HXZ -> HXZ -> Bool) -> Eq HXZ
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: HXZ -> HXZ -> Bool
== :: HXZ -> HXZ -> Bool
$c/= :: HXZ -> HXZ -> Bool
/= :: HXZ -> HXZ -> Bool
Eq, Eq HXZ
Eq HXZ =>
(HXZ -> HXZ -> Ordering)
-> (HXZ -> HXZ -> Bool)
-> (HXZ -> HXZ -> Bool)
-> (HXZ -> HXZ -> Bool)
-> (HXZ -> HXZ -> Bool)
-> (HXZ -> HXZ -> HXZ)
-> (HXZ -> HXZ -> HXZ)
-> Ord HXZ
HXZ -> HXZ -> Bool
HXZ -> HXZ -> Ordering
HXZ -> HXZ -> HXZ
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
$ccompare :: HXZ -> HXZ -> Ordering
compare :: HXZ -> HXZ -> Ordering
$c< :: HXZ -> HXZ -> Bool
< :: HXZ -> HXZ -> Bool
$c<= :: HXZ -> HXZ -> Bool
<= :: HXZ -> HXZ -> Bool
$c> :: HXZ -> HXZ -> Bool
> :: HXZ -> HXZ -> Bool
$c>= :: HXZ -> HXZ -> Bool
>= :: HXZ -> HXZ -> Bool
$cmax :: HXZ -> HXZ -> HXZ
max :: HXZ -> HXZ -> HXZ
$cmin :: HXZ -> HXZ -> HXZ
min :: HXZ -> HXZ -> HXZ
Ord, HXZ
HXZ -> HXZ -> Bounded HXZ
forall a. a -> a -> Bounded a
$cminBound :: HXZ
minBound :: HXZ
$cmaxBound :: HXZ
maxBound :: HXZ
Bounded, Int -> HXZ
HXZ -> Int
HXZ -> [HXZ]
HXZ -> HXZ
HXZ -> HXZ -> [HXZ]
HXZ -> HXZ -> HXZ -> [HXZ]
(HXZ -> HXZ)
-> (HXZ -> HXZ)
-> (Int -> HXZ)
-> (HXZ -> Int)
-> (HXZ -> [HXZ])
-> (HXZ -> HXZ -> [HXZ])
-> (HXZ -> HXZ -> [HXZ])
-> (HXZ -> HXZ -> HXZ -> [HXZ])
-> Enum HXZ
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: HXZ -> HXZ
succ :: HXZ -> HXZ
$cpred :: HXZ -> HXZ
pred :: HXZ -> HXZ
$ctoEnum :: Int -> HXZ
toEnum :: Int -> HXZ
$cfromEnum :: HXZ -> Int
fromEnum :: HXZ -> Int
$cenumFrom :: HXZ -> [HXZ]
enumFrom :: HXZ -> [HXZ]
$cenumFromThen :: HXZ -> HXZ -> [HXZ]
enumFromThen :: HXZ -> HXZ -> [HXZ]
$cenumFromTo :: HXZ -> HXZ -> [HXZ]
enumFromTo :: HXZ -> HXZ -> [HXZ]
$cenumFromThenTo :: HXZ -> HXZ -> HXZ -> [HXZ]
enumFromThenTo :: HXZ -> HXZ -> HXZ -> [HXZ]
Enum, Typeable HXZ
Typeable HXZ =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> HXZ -> c HXZ)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HXZ)
-> (HXZ -> Constr)
-> (HXZ -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HXZ))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HXZ))
-> ((forall b. Data b => b -> b) -> HXZ -> HXZ)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HXZ -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HXZ -> r)
-> (forall u. (forall d. Data d => d -> u) -> HXZ -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> HXZ -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HXZ -> m HXZ)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HXZ -> m HXZ)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HXZ -> m HXZ)
-> Data HXZ
HXZ -> Constr
HXZ -> DataType
(forall b. Data b => b -> b) -> HXZ -> HXZ
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> HXZ -> u
forall u. (forall d. Data d => d -> u) -> HXZ -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HXZ -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HXZ -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HXZ -> m HXZ
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HXZ -> m HXZ
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HXZ
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HXZ -> c HXZ
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HXZ)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HXZ)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HXZ -> c HXZ
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HXZ -> c HXZ
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HXZ
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HXZ
$ctoConstr :: HXZ -> Constr
toConstr :: HXZ -> Constr
$cdataTypeOf :: HXZ -> DataType
dataTypeOf :: HXZ -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HXZ)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HXZ)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HXZ)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HXZ)
$cgmapT :: (forall b. Data b => b -> b) -> HXZ -> HXZ
gmapT :: (forall b. Data b => b -> b) -> HXZ -> HXZ
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HXZ -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HXZ -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HXZ -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HXZ -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HXZ -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> HXZ -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HXZ -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HXZ -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HXZ -> m HXZ
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HXZ -> m HXZ
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HXZ -> m HXZ
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HXZ -> m HXZ
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HXZ -> m HXZ
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HXZ -> m HXZ
Data, (forall x. HXZ -> Rep HXZ x)
-> (forall x. Rep HXZ x -> HXZ) -> Generic HXZ
forall x. Rep HXZ x -> HXZ
forall x. HXZ -> Rep HXZ x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. HXZ -> Rep HXZ x
from :: forall x. HXZ -> Rep HXZ x
$cto :: forall x. Rep HXZ x -> HXZ
to :: forall x. Rep HXZ x -> HXZ
Generic, HXZ -> ()
(HXZ -> ()) -> NFData HXZ
forall a. (a -> ()) -> NFData a
$crnf :: HXZ -> ()
rnf :: HXZ -> ()
NFData)

data ZOX = ZOXZ | ZOXO | ZOXX
  deriving (ZOX -> ZOX -> Bool
(ZOX -> ZOX -> Bool) -> (ZOX -> ZOX -> Bool) -> Eq ZOX
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ZOX -> ZOX -> Bool
== :: ZOX -> ZOX -> Bool
$c/= :: ZOX -> ZOX -> Bool
/= :: ZOX -> ZOX -> Bool
Eq, Eq ZOX
Eq ZOX =>
(ZOX -> ZOX -> Ordering)
-> (ZOX -> ZOX -> Bool)
-> (ZOX -> ZOX -> Bool)
-> (ZOX -> ZOX -> Bool)
-> (ZOX -> ZOX -> Bool)
-> (ZOX -> ZOX -> ZOX)
-> (ZOX -> ZOX -> ZOX)
-> Ord ZOX
ZOX -> ZOX -> Bool
ZOX -> ZOX -> Ordering
ZOX -> ZOX -> ZOX
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
$ccompare :: ZOX -> ZOX -> Ordering
compare :: ZOX -> ZOX -> Ordering
$c< :: ZOX -> ZOX -> Bool
< :: ZOX -> ZOX -> Bool
$c<= :: ZOX -> ZOX -> Bool
<= :: ZOX -> ZOX -> Bool
$c> :: ZOX -> ZOX -> Bool
> :: ZOX -> ZOX -> Bool
$c>= :: ZOX -> ZOX -> Bool
>= :: ZOX -> ZOX -> Bool
$cmax :: ZOX -> ZOX -> ZOX
max :: ZOX -> ZOX -> ZOX
$cmin :: ZOX -> ZOX -> ZOX
min :: ZOX -> ZOX -> ZOX
Ord, ZOX
ZOX -> ZOX -> Bounded ZOX
forall a. a -> a -> Bounded a
$cminBound :: ZOX
minBound :: ZOX
$cmaxBound :: ZOX
maxBound :: ZOX
Bounded, Int -> ZOX
ZOX -> Int
ZOX -> [ZOX]
ZOX -> ZOX
ZOX -> ZOX -> [ZOX]
ZOX -> ZOX -> ZOX -> [ZOX]
(ZOX -> ZOX)
-> (ZOX -> ZOX)
-> (Int -> ZOX)
-> (ZOX -> Int)
-> (ZOX -> [ZOX])
-> (ZOX -> ZOX -> [ZOX])
-> (ZOX -> ZOX -> [ZOX])
-> (ZOX -> ZOX -> ZOX -> [ZOX])
-> Enum ZOX
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: ZOX -> ZOX
succ :: ZOX -> ZOX
$cpred :: ZOX -> ZOX
pred :: ZOX -> ZOX
$ctoEnum :: Int -> ZOX
toEnum :: Int -> ZOX
$cfromEnum :: ZOX -> Int
fromEnum :: ZOX -> Int
$cenumFrom :: ZOX -> [ZOX]
enumFrom :: ZOX -> [ZOX]
$cenumFromThen :: ZOX -> ZOX -> [ZOX]
enumFromThen :: ZOX -> ZOX -> [ZOX]
$cenumFromTo :: ZOX -> ZOX -> [ZOX]
enumFromTo :: ZOX -> ZOX -> [ZOX]
$cenumFromThenTo :: ZOX -> ZOX -> ZOX -> [ZOX]
enumFromThenTo :: ZOX -> ZOX -> ZOX -> [ZOX]
Enum, Typeable ZOX
Typeable ZOX =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ZOX -> c ZOX)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ZOX)
-> (ZOX -> Constr)
-> (ZOX -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ZOX))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ZOX))
-> ((forall b. Data b => b -> b) -> ZOX -> ZOX)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ZOX -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ZOX -> r)
-> (forall u. (forall d. Data d => d -> u) -> ZOX -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> ZOX -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ZOX -> m ZOX)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ZOX -> m ZOX)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ZOX -> m ZOX)
-> Data ZOX
ZOX -> Constr
ZOX -> DataType
(forall b. Data b => b -> b) -> ZOX -> ZOX
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ZOX -> u
forall u. (forall d. Data d => d -> u) -> ZOX -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ZOX -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ZOX -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ZOX -> m ZOX
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ZOX -> m ZOX
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ZOX
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ZOX -> c ZOX
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ZOX)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ZOX)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ZOX -> c ZOX
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ZOX -> c ZOX
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ZOX
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ZOX
$ctoConstr :: ZOX -> Constr
toConstr :: ZOX -> Constr
$cdataTypeOf :: ZOX -> DataType
dataTypeOf :: ZOX -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ZOX)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ZOX)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ZOX)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ZOX)
$cgmapT :: (forall b. Data b => b -> b) -> ZOX -> ZOX
gmapT :: (forall b. Data b => b -> b) -> ZOX -> ZOX
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ZOX -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ZOX -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ZOX -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ZOX -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ZOX -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ZOX -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ZOX -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ZOX -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ZOX -> m ZOX
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ZOX -> m ZOX
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ZOX -> m ZOX
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ZOX -> m ZOX
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ZOX -> m ZOX
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ZOX -> m ZOX
Data, (forall x. ZOX -> Rep ZOX x)
-> (forall x. Rep ZOX x -> ZOX) -> Generic ZOX
forall x. Rep ZOX x -> ZOX
forall x. ZOX -> Rep ZOX x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ZOX -> Rep ZOX x
from :: forall x. ZOX -> Rep ZOX x
$cto :: forall x. Rep ZOX x -> ZOX
to :: forall x. Rep ZOX x -> ZOX
Generic, ZOX -> ()
(ZOX -> ()) -> NFData ZOX
forall a. (a -> ()) -> NFData a
$crnf :: ZOX -> ()
rnf :: ZOX -> ()
NFData)

data Base = BBin | BOct | BDec | BHex
  deriving (Base -> Base -> Bool
(Base -> Base -> Bool) -> (Base -> Base -> Bool) -> Eq Base
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Base -> Base -> Bool
== :: Base -> Base -> Bool
$c/= :: Base -> Base -> Bool
/= :: Base -> Base -> Bool
Eq, Eq Base
Eq Base =>
(Base -> Base -> Ordering)
-> (Base -> Base -> Bool)
-> (Base -> Base -> Bool)
-> (Base -> Base -> Bool)
-> (Base -> Base -> Bool)
-> (Base -> Base -> Base)
-> (Base -> Base -> Base)
-> Ord Base
Base -> Base -> Bool
Base -> Base -> Ordering
Base -> Base -> Base
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
$ccompare :: Base -> Base -> Ordering
compare :: Base -> Base -> Ordering
$c< :: Base -> Base -> Bool
< :: Base -> Base -> Bool
$c<= :: Base -> Base -> Bool
<= :: Base -> Base -> Bool
$c> :: Base -> Base -> Bool
> :: Base -> Base -> Bool
$c>= :: Base -> Base -> Bool
>= :: Base -> Base -> Bool
$cmax :: Base -> Base -> Base
max :: Base -> Base -> Base
$cmin :: Base -> Base -> Base
min :: Base -> Base -> Base
Ord, Typeable Base
Typeable Base =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Base -> c Base)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Base)
-> (Base -> Constr)
-> (Base -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Base))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Base))
-> ((forall b. Data b => b -> b) -> Base -> Base)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Base -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Base -> r)
-> (forall u. (forall d. Data d => d -> u) -> Base -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Base -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Base -> m Base)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Base -> m Base)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Base -> m Base)
-> Data Base
Base -> Constr
Base -> DataType
(forall b. Data b => b -> b) -> Base -> Base
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Base -> u
forall u. (forall d. Data d => d -> u) -> Base -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Base -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Base -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Base -> m Base
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Base -> m Base
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Base
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Base -> c Base
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Base)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Base)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Base -> c Base
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Base -> c Base
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Base
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Base
$ctoConstr :: Base -> Constr
toConstr :: Base -> Constr
$cdataTypeOf :: Base -> DataType
dataTypeOf :: Base -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Base)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Base)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Base)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Base)
$cgmapT :: (forall b. Data b => b -> b) -> Base -> Base
gmapT :: (forall b. Data b => b -> b) -> Base -> Base
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Base -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Base -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Base -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Base -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Base -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Base -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Base -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Base -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Base -> m Base
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Base -> m Base
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Base -> m Base
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Base -> m Base
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Base -> m Base
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Base -> m Base
Data, (forall x. Base -> Rep Base x)
-> (forall x. Rep Base x -> Base) -> Generic Base
forall x. Rep Base x -> Base
forall x. Base -> Rep Base x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Base -> Rep Base x
from :: forall x. Base -> Rep Base x
$cto :: forall x. Rep Base x -> Base
to :: forall x. Rep Base x -> Base
Generic, Base -> ()
(Base -> ()) -> NFData Base
forall a. (a -> ()) -> NFData a
$crnf :: Base -> ()
rnf :: Base -> ()
NFData)

instance Show AFRNP where
  show :: AFRNP -> [Char]
show AFRNP
x =
    case AFRNP
x of AFRNP
AFRNPA -> [Char]
"*"; AFRNP
AFRNPF -> [Char]
"f"; AFRNP
AFRNPR -> [Char]
"r"; AFRNP
AFRNPN -> [Char]
"n"; AFRNP
AFRNPP -> [Char]
"p"

instance Show ZOX where
  show :: ZOX -> [Char]
show ZOX
x = case ZOX
x of ZOX
ZOXZ -> [Char]
"0"; ZOX
ZOXO -> [Char]
"1"; ZOX
ZOXX -> [Char]
"x"

instance Show BXZ where
  show :: BXZ -> [Char]
show BXZ
x = case BXZ
x of BXZ
BXZ0 -> [Char]
"0"; BXZ
BXZ1 -> [Char]
"1"; BXZ
BXZX -> [Char]
"x"; BXZ
BXZZ -> [Char]
"z"

instance Show OXZ where
  show :: OXZ -> [Char]
show OXZ
x = case OXZ
x of
    OXZ
OXZ0 -> [Char]
"0"
    OXZ
OXZ1 -> [Char]
"1"
    OXZ
OXZ2 -> [Char]
"2"
    OXZ
OXZ3 -> [Char]
"3"
    OXZ
OXZ4 -> [Char]
"4"
    OXZ
OXZ5 -> [Char]
"5"
    OXZ
OXZ6 -> [Char]
"6"
    OXZ
OXZ7 -> [Char]
"7"
    OXZ
OXZX -> [Char]
"x"
    OXZ
OXZZ -> [Char]
"z"

instance Show HXZ where
  show :: HXZ -> [Char]
show HXZ
x = case HXZ
x of
    HXZ
HXZ0 -> [Char]
"0"
    HXZ
HXZ1 -> [Char]
"1"
    HXZ
HXZ2 -> [Char]
"2"
    HXZ
HXZ3 -> [Char]
"3"
    HXZ
HXZ4 -> [Char]
"4"
    HXZ
HXZ5 -> [Char]
"5"
    HXZ
HXZ6 -> [Char]
"6"
    HXZ
HXZ7 -> [Char]
"7"
    HXZ
HXZ8 -> [Char]
"8"
    HXZ
HXZ9 -> [Char]
"9"
    HXZ
HXZA -> [Char]
"A"
    HXZ
HXZB -> [Char]
"B"
    HXZ
HXZC -> [Char]
"C"
    HXZ
HXZD -> [Char]
"D"
    HXZ
HXZE -> [Char]
"E"
    HXZ
HXZF -> [Char]
"F"
    HXZ
HXZX -> [Char]
"x"
    HXZ
HXZZ -> [Char]
"z"

instance Show Base where
  show :: Base -> [Char]
show Base
x = case Base
x of Base
BBin -> [Char]
"b"; Base
BOct -> [Char]
"o"; Base
BDec -> [Char]
"d"; Base
BHex -> [Char]
"h"

data Token
  = IdSimple !B.ByteString
  | IdEscaped !B.ByteString
  | IdSystem !B.ByteString
  | LitReal !B.ByteString
  | LitString !B.ByteString
  | NumberBase !Bool !Base
  | LitXZ !Bool
  | LitBinary ![BXZ]
  | LitDecimal !Natural
  | LitOctal ![OXZ]
  | LitHex ![HXZ]
  | TableOut !ZOX
  | TableIn !Bool
  | TableEdge !AFRNP
  | EdgeEdge !BXZ !BXZ
  | TknPP !B.ByteString
  | AmBar
  | AmHat
  | AmAmp
  | AmTildeHat
  | UnTilde
  | UnBang
  | UnTildeAmp
  | UnTildeBar
  | BinSlash
  | BinPercent
  | BinLt
  | BinGt
  | BinEqEq
  | BinBangEq
  | BinEqEqEq
  | BinBangEqEq
  | BinAmpAmp
  | BinBarBar
  | BinAsterAster
  | BinGtEq
  | BinLtLt
  | BinGtGt
  | BinLtLtLt
  | BinGtGtGt
  | SymParenL
  | SymParenR
  | SymBrackL
  | SymBrackR
  | SymBraceL
  | SymBraceR
  | SymAt
  | SymPound
  | SymDollar
  | SymAster
  | SymDot
  | SymComma
  | SymColon
  | SymSemi
  | SymEq
  | SymDash
  | SymPlus
  | SymParenAster
  | SymAsterParen
  | SymQuestion
  | SymLtEq
  | SymPlusColon
  | SymDashColon
  | SymDashGt
  | SymEqGt
  | SymAsterGt
  | SymAmpAmpAmp
  | CDCelldefine
  | CDDefaultnettype
  | CDEndcelldefine
  | CDInclude
  | CDNounconnecteddrive
  | CDResetall
  | CDTimescale
  | CDTSInt !Int
  | CDTSUnit !Int
  | CDUnconnecteddrive
  | CDBeginKeywords
  | CDEndKeywords
-- | CDPragma
-- | CDEndPragma
  | KWAlways
  | KWAnd
  | KWAssign
  | KWAutomatic
  | KWBegin
  | KWBuf
  | KWBufif0
  | KWBufif1
  | KWCase
  | KWCasex
  | KWCasez
  | KWCell
  | KWCmos
  | KWConfig
  | KWDeassign
  | KWDefault
  | KWDefparam
  | KWDesign
  | KWDisable
  | KWEdge
  | KWElse
  | KWEnd
  | KWEndcase
  | KWEndconfig
  | KWEndfunction
  | KWEndgenerate
  | KWEndmodule
  | KWEndprimitive
  | KWEndspecify
  | KWEndtable
  | KWEndtask
  | KWEvent
  | KWFor
  | KWForce
  | KWForever
  | KWFork
  | KWFunction
  | KWGenerate
  | KWGenvar
  | KWHighz0
  | KWHighz1
  | KWIf
  | KWIfnone
  | KWIncdir
  | KWInclude
  | KWInitial
  | KWInout
  | KWInput
  | KWInstance
  | KWInteger
  | KWJoin
  | KWLarge
  | KWLiblist
  | KWLibrary
  | KWLocalparam
  | KWMacromodule
  | KWMedium
  | KWModule
  | KWNand
  | KWNegedge
  | KWNmos
  | KWNor
  | KWNoshowcancelled
  | KWNot
  | KWNotif0
  | KWNotif1
  | KWOr
  | KWOutput
  | KWParameter
  | KWPmos
  | KWPosedge
  | KWPrimitive
  | KWPull0
  | KWPull1
  | KWPulldown
  | KWPullup
  | KWPulsestyleonevent
  | KWPulsestyleondetect
  | KWRcmos
  | KWReal
  | KWRealtime
  | KWReg
  | KWRelease
  | KWRepeat
  | KWRnmos
  | KWRpmos
  | KWRtran
  | KWRtranif0
  | KWRtranif1
  | KWScalared
  | KWShowcancelled
  | KWSigned
  | KWSmall
  | KWSpecify
  | KWSpecparam
  | KWStrong0
  | KWStrong1
  | KWSupply0
  | KWSupply1
  | KWTable
  | KWTask
  | KWTime
  | KWTran
  | KWTranif0
  | KWTranif1
  | KWTri
  | KWTri0
  | KWTri1
  | KWTriand
  | KWTrior
  | KWTrireg
  | KWUnsigned
  | KWUse
  | KWUwire
  | KWVectored
  | KWWait
  | KWWand
  | KWWeak0
  | KWWeak1
  | KWWhile
  | KWWire
  | KWWor
  | KWXnor
  | KWXor
  | TokSVKeyword !B.ByteString
  deriving (Token -> Token -> Bool
(Token -> Token -> Bool) -> (Token -> Token -> Bool) -> Eq Token
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Token -> Token -> Bool
== :: Token -> Token -> Bool
$c/= :: Token -> Token -> Bool
/= :: Token -> Token -> Bool
Eq, Typeable Token
Typeable Token =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Token -> c Token)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Token)
-> (Token -> Constr)
-> (Token -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Token))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Token))
-> ((forall b. Data b => b -> b) -> Token -> Token)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Token -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Token -> r)
-> (forall u. (forall d. Data d => d -> u) -> Token -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Token -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Token -> m Token)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Token -> m Token)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Token -> m Token)
-> Data Token
Token -> Constr
Token -> DataType
(forall b. Data b => b -> b) -> Token -> Token
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Token -> u
forall u. (forall d. Data d => d -> u) -> Token -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Token -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Token -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Token -> m Token
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Token -> m Token
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Token
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Token -> c Token
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Token)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Token)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Token -> c Token
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Token -> c Token
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Token
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Token
$ctoConstr :: Token -> Constr
toConstr :: Token -> Constr
$cdataTypeOf :: Token -> DataType
dataTypeOf :: Token -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Token)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Token)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Token)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Token)
$cgmapT :: (forall b. Data b => b -> b) -> Token -> Token
gmapT :: (forall b. Data b => b -> b) -> Token -> Token
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Token -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Token -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Token -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Token -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Token -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Token -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Token -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Token -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Token -> m Token
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Token -> m Token
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Token -> m Token
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Token -> m Token
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Token -> m Token
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Token -> m Token
Data)

instance Show Token where
  show :: Token -> [Char]
show Token
x = case Token
x of
    IdSimple ByteString
s -> ByteString -> [Char]
unpackChars ByteString
s
    IdEscaped ByteString
s -> ByteString -> [Char]
unpackChars ByteString
s
    IdSystem ByteString
s -> Char
'$' Char -> ShowS
forall a. a -> [a] -> [a]
: ByteString -> [Char]
unpackChars ByteString
s
    LitReal ByteString
s -> ByteString -> [Char]
unpackChars ByteString
s
    LitString ByteString
s -> Char
'"' Char -> ShowS
forall a. a -> [a] -> [a]
: ByteString -> [Char]
unpackChars ByteString
s [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
"\""
    NumberBase Bool
s Base
b -> Char
'\'' Char -> ShowS
forall a. a -> [a] -> [a]
: if Bool
s then Char
's' Char -> ShowS
forall a. a -> [a] -> [a]
: Base -> [Char]
forall a. Show a => a -> [Char]
show Base
b else Base -> [Char]
forall a. Show a => a -> [Char]
show Base
b
    LitXZ Bool
b -> if Bool
b then [Char]
"x" else [Char]
"z"
    LitBinary [BXZ]
l -> (BXZ -> [Char]) -> [BXZ] -> [Char]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap BXZ -> [Char]
forall a. Show a => a -> [Char]
show [BXZ]
l
    LitDecimal Natural
i -> Natural -> [Char]
forall a. Show a => a -> [Char]
show Natural
i
    LitOctal [OXZ]
l -> (OXZ -> [Char]) -> [OXZ] -> [Char]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap OXZ -> [Char]
forall a. Show a => a -> [Char]
show [OXZ]
l
    LitHex [HXZ]
l -> (HXZ -> [Char]) -> [HXZ] -> [Char]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap HXZ -> [Char]
forall a. Show a => a -> [Char]
show [HXZ]
l
    TableOut ZOX
x -> ZOX -> [Char]
forall a. Show a => a -> [Char]
show ZOX
x
    TableIn Bool
b -> if Bool
b then [Char]
"b" else [Char]
"?"
    TableEdge AFRNP
x -> AFRNP -> [Char]
forall a. Show a => a -> [Char]
show AFRNP
x
    EdgeEdge BXZ
e0 BXZ
e1 -> BXZ -> [Char]
forall a. Show a => a -> [Char]
show BXZ
e0 [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ BXZ -> [Char]
forall a. Show a => a -> [Char]
show BXZ
e1
    TknPP ByteString
s -> [Char]
"PATHPULSE$" [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ ByteString -> [Char]
unpackChars ByteString
s
    Token
AmBar -> [Char]
"|"
    Token
AmHat -> [Char]
"^"
    Token
AmAmp -> [Char]
"&"
    Token
AmTildeHat -> [Char]
"~^ or ^~"
    Token
UnTilde -> [Char]
"~"
    Token
UnBang -> [Char]
"!"
    Token
UnTildeAmp -> [Char]
"~&"
    Token
UnTildeBar -> [Char]
"~|"
    Token
BinSlash -> [Char]
"/"
    Token
BinPercent -> [Char]
"%"
    Token
BinLt -> [Char]
"<"
    Token
BinGt -> [Char]
">"
    Token
BinEqEq -> [Char]
"=="
    Token
BinBangEq -> [Char]
"!="
    Token
BinEqEqEq -> [Char]
"==="
    Token
BinBangEqEq -> [Char]
"!=="
    Token
BinAmpAmp -> [Char]
"&&"
    Token
BinBarBar -> [Char]
"||"
    Token
BinAsterAster -> [Char]
"**"
    Token
BinGtEq -> [Char]
">="
    Token
BinLtLt -> [Char]
"<<"
    Token
BinGtGt -> [Char]
">>"
    Token
BinLtLtLt -> [Char]
"<<<"
    Token
BinGtGtGt -> [Char]
">>>"
    Token
SymParenL -> [Char]
"'('"
    Token
SymParenR -> [Char]
"')'"
    Token
SymBrackL -> [Char]
"'['"
    Token
SymBrackR -> [Char]
"']'"
    Token
SymBraceL -> [Char]
"'{'"
    Token
SymBraceR -> [Char]
"'}'"
    Token
SymAt -> [Char]
"@"
    Token
SymPound -> [Char]
"#"
    Token
SymDollar -> [Char]
"$"
    Token
SymAster -> [Char]
"*"
    Token
SymDot -> [Char]
"'.'"
    Token
SymComma -> [Char]
"','"
    Token
SymColon -> [Char]
"':'"
    Token
SymSemi -> [Char]
"';'"
    Token
SymEq -> [Char]
"="
    Token
SymDash -> [Char]
"-"
    Token
SymPlus -> [Char]
"+"
    Token
SymParenAster -> [Char]
"'(*'"
    Token
SymAsterParen -> [Char]
"'*)'"
    Token
SymQuestion -> [Char]
"?"
    Token
SymLtEq -> [Char]
"<="
    Token
SymPlusColon -> [Char]
"'+:'"
    Token
SymDashColon -> [Char]
"'-:'"
    Token
SymDashGt -> [Char]
"->"
    Token
SymEqGt -> [Char]
"=>"
    Token
SymAsterGt -> [Char]
"*>"
    Token
SymAmpAmpAmp -> [Char]
"&&&"
    Token
CDCelldefine -> [Char]
"`celldefine"
    Token
CDDefaultnettype -> [Char]
"`default_nettype"
    Token
CDEndcelldefine -> [Char]
"`endcelldefine"
    Token
CDInclude -> [Char]
"`include"
    Token
CDNounconnecteddrive -> [Char]
"`nounconnected_drive"
    Token
CDResetall -> [Char]
"`resetall"
    Token
CDTimescale -> [Char]
"`timescale"
    CDTSInt Int
i -> Char
'1' Char -> ShowS
forall a. a -> [a] -> [a]
: case Int
i of Int
0 -> [Char]
""; Int
1 -> [Char]
"0"; Int
2 -> [Char]
"00"
    CDTSUnit Int
i ->
      case Int
i of { Int
0 -> [Char]
""; -1 -> [Char]
"m"; -2 -> [Char]
"u"; -3 -> [Char]
"n"; -4 -> [Char]
"p"; -5 -> [Char]
"f" } [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
"s"
    Token
CDUnconnecteddrive -> [Char]
"`unconnected_drive"
    Token
CDBeginKeywords -> [Char]
"`begin_keywords"
    Token
CDEndKeywords -> [Char]
"`end_keywords"
-- CDPragma
-- CDEndPragma
    Token
KWAlways -> [Char]
"always"
    Token
KWAnd -> [Char]
"and"
    Token
KWAssign -> [Char]
"assign"
    Token
KWAutomatic -> [Char]
"automatic"
    Token
KWBegin -> [Char]
"begin"
    Token
KWBuf -> [Char]
"buf"
    Token
KWBufif0 -> [Char]
"bufif0"
    Token
KWBufif1 -> [Char]
"bufif1"
    Token
KWCase -> [Char]
"case"
    Token
KWCasex -> [Char]
"casex"
    Token
KWCasez -> [Char]
"casez"
    Token
KWCell -> [Char]
"cell"
    Token
KWCmos -> [Char]
"cmos"
    Token
KWConfig -> [Char]
"config"
    Token
KWDeassign -> [Char]
"deassign"
    Token
KWDefault -> [Char]
"default"
    Token
KWDefparam -> [Char]
"defparam"
    Token
KWDesign -> [Char]
"design"
    Token
KWDisable -> [Char]
"disable"
    Token
KWEdge -> [Char]
"edge"
    Token
KWElse -> [Char]
"else"
    Token
KWEnd -> [Char]
"end"
    Token
KWEndcase -> [Char]
"endcase"
    Token
KWEndconfig -> [Char]
"endconfig"
    Token
KWEndfunction -> [Char]
"endfunction"
    Token
KWEndgenerate -> [Char]
"endgenerate"
    Token
KWEndmodule -> [Char]
"endmodule"
    Token
KWEndprimitive -> [Char]
"endprimitive"
    Token
KWEndspecify -> [Char]
"endspecify"
    Token
KWEndtable -> [Char]
"endtable"
    Token
KWEndtask -> [Char]
"endtask"
    Token
KWEvent -> [Char]
"event"
    Token
KWFor -> [Char]
"for"
    Token
KWForce -> [Char]
"force"
    Token
KWForever -> [Char]
"forever"
    Token
KWFork -> [Char]
"fork"
    Token
KWFunction -> [Char]
"function"
    Token
KWGenerate -> [Char]
"generate"
    Token
KWGenvar -> [Char]
"genvar"
    Token
KWHighz0 -> [Char]
"highz0"
    Token
KWHighz1 -> [Char]
"highz1"
    Token
KWIf -> [Char]
"if"
    Token
KWIfnone -> [Char]
"ifnone"
    Token
KWIncdir -> [Char]
"incdir"
    Token
KWInclude -> [Char]
"include"
    Token
KWInitial -> [Char]
"initial"
    Token
KWInout -> [Char]
"inout"
    Token
KWInput -> [Char]
"input"
    Token
KWInstance -> [Char]
"instance"
    Token
KWInteger -> [Char]
"integer"
    Token
KWJoin -> [Char]
"join"
    Token
KWLarge -> [Char]
"large"
    Token
KWLiblist -> [Char]
"liblist"
    Token
KWLibrary -> [Char]
"library"
    Token
KWLocalparam -> [Char]
"localparam"
    Token
KWMacromodule -> [Char]
"macromodule"
    Token
KWMedium -> [Char]
"medium"
    Token
KWModule -> [Char]
"module"
    Token
KWNand -> [Char]
"nand"
    Token
KWNegedge -> [Char]
"negedge"
    Token
KWNmos -> [Char]
"nmos"
    Token
KWNor -> [Char]
"now"
    Token
KWNoshowcancelled -> [Char]
"noshowcancelled"
    Token
KWNot -> [Char]
"not"
    Token
KWNotif0 -> [Char]
"notif0"
    Token
KWNotif1 -> [Char]
"notif1"
    Token
KWOr -> [Char]
"or"
    Token
KWOutput -> [Char]
"output"
    Token
KWParameter -> [Char]
"parameter"
    Token
KWPmos -> [Char]
"pmos"
    Token
KWPosedge -> [Char]
"posedge"
    Token
KWPrimitive -> [Char]
"primitive"
    Token
KWPull0 -> [Char]
"pull0"
    Token
KWPull1 -> [Char]
"pull1"
    Token
KWPulldown -> [Char]
"pulldown"
    Token
KWPullup -> [Char]
"pullup"
    Token
KWPulsestyleonevent -> [Char]
"pulsestyle_onevent"
    Token
KWPulsestyleondetect -> [Char]
"plusestyle_ondetect"
    Token
KWRcmos -> [Char]
"rcmos"
    Token
KWReal -> [Char]
"real"
    Token
KWRealtime -> [Char]
"realtime"
    Token
KWReg -> [Char]
"reg"
    Token
KWRelease -> [Char]
"release"
    Token
KWRepeat -> [Char]
"repeat"
    Token
KWRnmos -> [Char]
"rnmos"
    Token
KWRpmos -> [Char]
"rpmos"
    Token
KWRtran -> [Char]
"rtan"
    Token
KWRtranif0 -> [Char]
"rtranif0"
    Token
KWRtranif1 -> [Char]
"rtranif1"
    Token
KWScalared -> [Char]
"scalared"
    Token
KWShowcancelled -> [Char]
"showcancelled"
    Token
KWSigned -> [Char]
"signed"
    Token
KWSmall -> [Char]
"small"
    Token
KWSpecify -> [Char]
"specify"
    Token
KWSpecparam -> [Char]
"specparam"
    Token
KWStrong0 -> [Char]
"strong0"
    Token
KWStrong1 -> [Char]
"strong1"
    Token
KWSupply0 -> [Char]
"supply0"
    Token
KWSupply1 -> [Char]
"supply1"
    Token
KWTable -> [Char]
"table"
    Token
KWTask -> [Char]
"task"
    Token
KWTime -> [Char]
"time"
    Token
KWTran -> [Char]
"tran"
    Token
KWTranif0 -> [Char]
"tranif0"
    Token
KWTranif1 -> [Char]
"tranif1"
    Token
KWTri -> [Char]
"tri"
    Token
KWTri0 -> [Char]
"tri0"
    Token
KWTri1 -> [Char]
"tri1"
    Token
KWTriand -> [Char]
"triand"
    Token
KWTrior -> [Char]
"trior"
    Token
KWTrireg -> [Char]
"trireg"
    Token
KWUnsigned -> [Char]
"unsigned"
    Token
KWUse -> [Char]
"use"
    Token
KWUwire -> [Char]
"uwire"
    Token
KWVectored -> [Char]
"vectored"
    Token
KWWait -> [Char]
"wait"
    Token
KWWand -> [Char]
"wand"
    Token
KWWeak0 -> [Char]
"weak0"
    Token
KWWeak1 -> [Char]
"weak1"
    Token
KWWhile -> [Char]
"while"
    Token
KWWire -> [Char]
"wire"
    Token
KWWor -> [Char]
"wor"
    Token
KWXnor -> [Char]
"xnor"
    Token
KWXor -> [Char]
"xor"
    TokSVKeyword ByteString
kw -> ByteString -> [Char]
unpackChars ByteString
kw