    -- File generated by the BNF Converter (bnfc 2.9.5).

    {-# LANGUAGE GeneralizedNewtypeDeriving #-}

    -- | The abstract syntax of language SMV.

    module Language.SMV.AbsSMV where

    import Prelude (Double, Integer, String)
    import qualified Prelude as C (Eq, Ord, Show, Read)
    import qualified Data.String

    data BoolSpec
        = BoolSpecSignal Ident
        | BoolSpecConst BoolConst
        | BoolSpecNum NumExpr
        | BoolSpecCmp BoolSpec OrdOp BoolSpec
        | BoolSpecNeg BoolSpec
        | BoolSpecAnd BoolSpec BoolSpec
        | BoolSpecOr BoolSpec BoolSpec
        | BoolSpecXor BoolSpec BoolSpec
        | BoolSpecImplies BoolSpec BoolSpec
        | BoolSpecEquivs BoolSpec BoolSpec
        | BoolSpecOp1 OpOne BoolSpec
        | BoolSpecOp2 BoolSpec OpTwo BoolSpec
      deriving (BoolSpec -> BoolSpec -> Bool
    (BoolSpec -> BoolSpec -> Bool)
    -> (BoolSpec -> BoolSpec -> Bool) -> Eq BoolSpec
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: BoolSpec -> BoolSpec -> Bool
    == :: BoolSpec -> BoolSpec -> Bool
    $c/= :: BoolSpec -> BoolSpec -> Bool
    /= :: BoolSpec -> BoolSpec -> Bool
    C.Eq, Eq BoolSpec
    Eq BoolSpec =>
    (BoolSpec -> BoolSpec -> Ordering)
    -> (BoolSpec -> BoolSpec -> Bool)
    -> (BoolSpec -> BoolSpec -> Bool)
    -> (BoolSpec -> BoolSpec -> Bool)
    -> (BoolSpec -> BoolSpec -> Bool)
    -> (BoolSpec -> BoolSpec -> BoolSpec)
    -> (BoolSpec -> BoolSpec -> BoolSpec)
    -> Ord BoolSpec
    BoolSpec -> BoolSpec -> Bool
    BoolSpec -> BoolSpec -> Ordering
    BoolSpec -> BoolSpec -> BoolSpec
    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 :: BoolSpec -> BoolSpec -> Ordering
    compare :: BoolSpec -> BoolSpec -> Ordering
    $c< :: BoolSpec -> BoolSpec -> Bool
    < :: BoolSpec -> BoolSpec -> Bool
    $c<= :: BoolSpec -> BoolSpec -> Bool
    <= :: BoolSpec -> BoolSpec -> Bool
    $c> :: BoolSpec -> BoolSpec -> Bool
    > :: BoolSpec -> BoolSpec -> Bool
    $c>= :: BoolSpec -> BoolSpec -> Bool
    >= :: BoolSpec -> BoolSpec -> Bool
    $cmax :: BoolSpec -> BoolSpec -> BoolSpec
    max :: BoolSpec -> BoolSpec -> BoolSpec
    $cmin :: BoolSpec -> BoolSpec -> BoolSpec
    min :: BoolSpec -> BoolSpec -> BoolSpec
    C.Ord, Int -> BoolSpec -> ShowS
    [BoolSpec] -> ShowS
    BoolSpec -> String
    (Int -> BoolSpec -> ShowS)
    -> (BoolSpec -> String) -> ([BoolSpec] -> ShowS) -> Show BoolSpec
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> BoolSpec -> ShowS
    showsPrec :: Int -> BoolSpec -> ShowS
    $cshow :: BoolSpec -> String
    show :: BoolSpec -> String
    $cshowList :: [BoolSpec] -> ShowS
    showList :: [BoolSpec] -> ShowS
    C.Show, ReadPrec [BoolSpec]
    ReadPrec BoolSpec
    Int -> ReadS BoolSpec
    ReadS [BoolSpec]
    (Int -> ReadS BoolSpec)
    -> ReadS [BoolSpec]
    -> ReadPrec BoolSpec
    -> ReadPrec [BoolSpec]
    -> Read BoolSpec
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS BoolSpec
    readsPrec :: Int -> ReadS BoolSpec
    $creadList :: ReadS [BoolSpec]
    readList :: ReadS [BoolSpec]
    $creadPrec :: ReadPrec BoolSpec
    readPrec :: ReadPrec BoolSpec
    $creadListPrec :: ReadPrec [BoolSpec]
    readListPrec :: ReadPrec [BoolSpec]
    C.Read)

    data NumExpr
        = NumId Ident
        | NumConstI Integer
        | NumConstD Double
        | NumAdd NumExpr AdditiveOp NumExpr
        | NumMult NumExpr MultOp NumExpr
      deriving (NumExpr -> NumExpr -> Bool
    (NumExpr -> NumExpr -> Bool)
    -> (NumExpr -> NumExpr -> Bool) -> Eq NumExpr
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: NumExpr -> NumExpr -> Bool
    == :: NumExpr -> NumExpr -> Bool
    $c/= :: NumExpr -> NumExpr -> Bool
    /= :: NumExpr -> NumExpr -> Bool
    C.Eq, Eq NumExpr
    Eq NumExpr =>
    (NumExpr -> NumExpr -> Ordering)
    -> (NumExpr -> NumExpr -> Bool)
    -> (NumExpr -> NumExpr -> Bool)
    -> (NumExpr -> NumExpr -> Bool)
    -> (NumExpr -> NumExpr -> Bool)
    -> (NumExpr -> NumExpr -> NumExpr)
    -> (NumExpr -> NumExpr -> NumExpr)
    -> Ord NumExpr
    NumExpr -> NumExpr -> Bool
    NumExpr -> NumExpr -> Ordering
    NumExpr -> NumExpr -> NumExpr
    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 :: NumExpr -> NumExpr -> Ordering
    compare :: NumExpr -> NumExpr -> Ordering
    $c< :: NumExpr -> NumExpr -> Bool
    < :: NumExpr -> NumExpr -> Bool
    $c<= :: NumExpr -> NumExpr -> Bool
    <= :: NumExpr -> NumExpr -> Bool
    $c> :: NumExpr -> NumExpr -> Bool
    > :: NumExpr -> NumExpr -> Bool
    $c>= :: NumExpr -> NumExpr -> Bool
    >= :: NumExpr -> NumExpr -> Bool
    $cmax :: NumExpr -> NumExpr -> NumExpr
    max :: NumExpr -> NumExpr -> NumExpr
    $cmin :: NumExpr -> NumExpr -> NumExpr
    min :: NumExpr -> NumExpr -> NumExpr
    C.Ord, Int -> NumExpr -> ShowS
    [NumExpr] -> ShowS
    NumExpr -> String
    (Int -> NumExpr -> ShowS)
    -> (NumExpr -> String) -> ([NumExpr] -> ShowS) -> Show NumExpr
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> NumExpr -> ShowS
    showsPrec :: Int -> NumExpr -> ShowS
    $cshow :: NumExpr -> String
    show :: NumExpr -> String
    $cshowList :: [NumExpr] -> ShowS
    showList :: [NumExpr] -> ShowS
    C.Show, ReadPrec [NumExpr]
    ReadPrec NumExpr
    Int -> ReadS NumExpr
    ReadS [NumExpr]
    (Int -> ReadS NumExpr)
    -> ReadS [NumExpr]
    -> ReadPrec NumExpr
    -> ReadPrec [NumExpr]
    -> Read NumExpr
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS NumExpr
    readsPrec :: Int -> ReadS NumExpr
    $creadList :: ReadS [NumExpr]
    readList :: ReadS [NumExpr]
    $creadPrec :: ReadPrec NumExpr
    readPrec :: ReadPrec NumExpr
    $creadListPrec :: ReadPrec [NumExpr]
    readListPrec :: ReadPrec [NumExpr]
    C.Read)

    data AdditiveOp = OpPlus | OpMinus
      deriving (AdditiveOp -> AdditiveOp -> Bool
    (AdditiveOp -> AdditiveOp -> Bool)
    -> (AdditiveOp -> AdditiveOp -> Bool) -> Eq AdditiveOp
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: AdditiveOp -> AdditiveOp -> Bool
    == :: AdditiveOp -> AdditiveOp -> Bool
    $c/= :: AdditiveOp -> AdditiveOp -> Bool
    /= :: AdditiveOp -> AdditiveOp -> Bool
    C.Eq, Eq AdditiveOp
    Eq AdditiveOp =>
    (AdditiveOp -> AdditiveOp -> Ordering)
    -> (AdditiveOp -> AdditiveOp -> Bool)
    -> (AdditiveOp -> AdditiveOp -> Bool)
    -> (AdditiveOp -> AdditiveOp -> Bool)
    -> (AdditiveOp -> AdditiveOp -> Bool)
    -> (AdditiveOp -> AdditiveOp -> AdditiveOp)
    -> (AdditiveOp -> AdditiveOp -> AdditiveOp)
    -> Ord AdditiveOp
    AdditiveOp -> AdditiveOp -> Bool
    AdditiveOp -> AdditiveOp -> Ordering
    AdditiveOp -> AdditiveOp -> AdditiveOp
    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 :: AdditiveOp -> AdditiveOp -> Ordering
    compare :: AdditiveOp -> AdditiveOp -> Ordering
    $c< :: AdditiveOp -> AdditiveOp -> Bool
    < :: AdditiveOp -> AdditiveOp -> Bool
    $c<= :: AdditiveOp -> AdditiveOp -> Bool
    <= :: AdditiveOp -> AdditiveOp -> Bool
    $c> :: AdditiveOp -> AdditiveOp -> Bool
    > :: AdditiveOp -> AdditiveOp -> Bool
    $c>= :: AdditiveOp -> AdditiveOp -> Bool
    >= :: AdditiveOp -> AdditiveOp -> Bool
    $cmax :: AdditiveOp -> AdditiveOp -> AdditiveOp
    max :: AdditiveOp -> AdditiveOp -> AdditiveOp
    $cmin :: AdditiveOp -> AdditiveOp -> AdditiveOp
    min :: AdditiveOp -> AdditiveOp -> AdditiveOp
    C.Ord, Int -> AdditiveOp -> ShowS
    [AdditiveOp] -> ShowS
    AdditiveOp -> String
    (Int -> AdditiveOp -> ShowS)
    -> (AdditiveOp -> String)
    -> ([AdditiveOp] -> ShowS)
    -> Show AdditiveOp
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> AdditiveOp -> ShowS
    showsPrec :: Int -> AdditiveOp -> ShowS
    $cshow :: AdditiveOp -> String
    show :: AdditiveOp -> String
    $cshowList :: [AdditiveOp] -> ShowS
    showList :: [AdditiveOp] -> ShowS
    C.Show, ReadPrec [AdditiveOp]
    ReadPrec AdditiveOp
    Int -> ReadS AdditiveOp
    ReadS [AdditiveOp]
    (Int -> ReadS AdditiveOp)
    -> ReadS [AdditiveOp]
    -> ReadPrec AdditiveOp
    -> ReadPrec [AdditiveOp]
    -> Read AdditiveOp
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS AdditiveOp
    readsPrec :: Int -> ReadS AdditiveOp
    $creadList :: ReadS [AdditiveOp]
    readList :: ReadS [AdditiveOp]
    $creadPrec :: ReadPrec AdditiveOp
    readPrec :: ReadPrec AdditiveOp
    $creadListPrec :: ReadPrec [AdditiveOp]
    readListPrec :: ReadPrec [AdditiveOp]
    C.Read)

    data MultOp = OpTimes | OpDiv
      deriving (MultOp -> MultOp -> Bool
    (MultOp -> MultOp -> Bool)
    -> (MultOp -> MultOp -> Bool) -> Eq MultOp
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: MultOp -> MultOp -> Bool
    == :: MultOp -> MultOp -> Bool
    $c/= :: MultOp -> MultOp -> Bool
    /= :: MultOp -> MultOp -> Bool
    C.Eq, Eq MultOp
    Eq MultOp =>
    (MultOp -> MultOp -> Ordering)
    -> (MultOp -> MultOp -> Bool)
    -> (MultOp -> MultOp -> Bool)
    -> (MultOp -> MultOp -> Bool)
    -> (MultOp -> MultOp -> Bool)
    -> (MultOp -> MultOp -> MultOp)
    -> (MultOp -> MultOp -> MultOp)
    -> Ord MultOp
    MultOp -> MultOp -> Bool
    MultOp -> MultOp -> Ordering
    MultOp -> MultOp -> MultOp
    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 :: MultOp -> MultOp -> Ordering
    compare :: MultOp -> MultOp -> Ordering
    $c< :: MultOp -> MultOp -> Bool
    < :: MultOp -> MultOp -> Bool
    $c<= :: MultOp -> MultOp -> Bool
    <= :: MultOp -> MultOp -> Bool
    $c> :: MultOp -> MultOp -> Bool
    > :: MultOp -> MultOp -> Bool
    $c>= :: MultOp -> MultOp -> Bool
    >= :: MultOp -> MultOp -> Bool
    $cmax :: MultOp -> MultOp -> MultOp
    max :: MultOp -> MultOp -> MultOp
    $cmin :: MultOp -> MultOp -> MultOp
    min :: MultOp -> MultOp -> MultOp
    C.Ord, Int -> MultOp -> ShowS
    [MultOp] -> ShowS
    MultOp -> String
    (Int -> MultOp -> ShowS)
    -> (MultOp -> String) -> ([MultOp] -> ShowS) -> Show MultOp
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> MultOp -> ShowS
    showsPrec :: Int -> MultOp -> ShowS
    $cshow :: MultOp -> String
    show :: MultOp -> String
    $cshowList :: [MultOp] -> ShowS
    showList :: [MultOp] -> ShowS
    C.Show, ReadPrec [MultOp]
    ReadPrec MultOp
    Int -> ReadS MultOp
    ReadS [MultOp]
    (Int -> ReadS MultOp)
    -> ReadS [MultOp]
    -> ReadPrec MultOp
    -> ReadPrec [MultOp]
    -> Read MultOp
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS MultOp
    readsPrec :: Int -> ReadS MultOp
    $creadList :: ReadS [MultOp]
    readList :: ReadS [MultOp]
    $creadPrec :: ReadPrec MultOp
    readPrec :: ReadPrec MultOp
    $creadListPrec :: ReadPrec [MultOp]
    readListPrec :: ReadPrec [MultOp]
    C.Read)

    data BoolConst
        = BoolConstTrue | BoolConstFalse | BoolConstFTP | BoolConstLAST
      deriving (BoolConst -> BoolConst -> Bool
    (BoolConst -> BoolConst -> Bool)
    -> (BoolConst -> BoolConst -> Bool) -> Eq BoolConst
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: BoolConst -> BoolConst -> Bool
    == :: BoolConst -> BoolConst -> Bool
    $c/= :: BoolConst -> BoolConst -> Bool
    /= :: BoolConst -> BoolConst -> Bool
    C.Eq, Eq BoolConst
    Eq BoolConst =>
    (BoolConst -> BoolConst -> Ordering)
    -> (BoolConst -> BoolConst -> Bool)
    -> (BoolConst -> BoolConst -> Bool)
    -> (BoolConst -> BoolConst -> Bool)
    -> (BoolConst -> BoolConst -> Bool)
    -> (BoolConst -> BoolConst -> BoolConst)
    -> (BoolConst -> BoolConst -> BoolConst)
    -> Ord BoolConst
    BoolConst -> BoolConst -> Bool
    BoolConst -> BoolConst -> Ordering
    BoolConst -> BoolConst -> BoolConst
    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 :: BoolConst -> BoolConst -> Ordering
    compare :: BoolConst -> BoolConst -> Ordering
    $c< :: BoolConst -> BoolConst -> Bool
    < :: BoolConst -> BoolConst -> Bool
    $c<= :: BoolConst -> BoolConst -> Bool
    <= :: BoolConst -> BoolConst -> Bool
    $c> :: BoolConst -> BoolConst -> Bool
    > :: BoolConst -> BoolConst -> Bool
    $c>= :: BoolConst -> BoolConst -> Bool
    >= :: BoolConst -> BoolConst -> Bool
    $cmax :: BoolConst -> BoolConst -> BoolConst
    max :: BoolConst -> BoolConst -> BoolConst
    $cmin :: BoolConst -> BoolConst -> BoolConst
    min :: BoolConst -> BoolConst -> BoolConst
    C.Ord, Int -> BoolConst -> ShowS
    [BoolConst] -> ShowS
    BoolConst -> String
    (Int -> BoolConst -> ShowS)
    -> (BoolConst -> String)
    -> ([BoolConst] -> ShowS)
    -> Show BoolConst
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> BoolConst -> ShowS
    showsPrec :: Int -> BoolConst -> ShowS
    $cshow :: BoolConst -> String
    show :: BoolConst -> String
    $cshowList :: [BoolConst] -> ShowS
    showList :: [BoolConst] -> ShowS
    C.Show, ReadPrec [BoolConst]
    ReadPrec BoolConst
    Int -> ReadS BoolConst
    ReadS [BoolConst]
    (Int -> ReadS BoolConst)
    -> ReadS [BoolConst]
    -> ReadPrec BoolConst
    -> ReadPrec [BoolConst]
    -> Read BoolConst
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS BoolConst
    readsPrec :: Int -> ReadS BoolConst
    $creadList :: ReadS [BoolConst]
    readList :: ReadS [BoolConst]
    $creadPrec :: ReadPrec BoolConst
    readPrec :: ReadPrec BoolConst
    $creadListPrec :: ReadPrec [BoolConst]
    readListPrec :: ReadPrec [BoolConst]
    C.Read)

    data OpOne
        = Op1Alone Op1Name
        | Op1MTL Op1Name OrdOp Number
        | Op1MTLRange Op1Name Number Number
      deriving (OpOne -> OpOne -> Bool
    (OpOne -> OpOne -> Bool) -> (OpOne -> OpOne -> Bool) -> Eq OpOne
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: OpOne -> OpOne -> Bool
    == :: OpOne -> OpOne -> Bool
    $c/= :: OpOne -> OpOne -> Bool
    /= :: OpOne -> OpOne -> Bool
    C.Eq, Eq OpOne
    Eq OpOne =>
    (OpOne -> OpOne -> Ordering)
    -> (OpOne -> OpOne -> Bool)
    -> (OpOne -> OpOne -> Bool)
    -> (OpOne -> OpOne -> Bool)
    -> (OpOne -> OpOne -> Bool)
    -> (OpOne -> OpOne -> OpOne)
    -> (OpOne -> OpOne -> OpOne)
    -> Ord OpOne
    OpOne -> OpOne -> Bool
    OpOne -> OpOne -> Ordering
    OpOne -> OpOne -> OpOne
    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 :: OpOne -> OpOne -> Ordering
    compare :: OpOne -> OpOne -> Ordering
    $c< :: OpOne -> OpOne -> Bool
    < :: OpOne -> OpOne -> Bool
    $c<= :: OpOne -> OpOne -> Bool
    <= :: OpOne -> OpOne -> Bool
    $c> :: OpOne -> OpOne -> Bool
    > :: OpOne -> OpOne -> Bool
    $c>= :: OpOne -> OpOne -> Bool
    >= :: OpOne -> OpOne -> Bool
    $cmax :: OpOne -> OpOne -> OpOne
    max :: OpOne -> OpOne -> OpOne
    $cmin :: OpOne -> OpOne -> OpOne
    min :: OpOne -> OpOne -> OpOne
    C.Ord, Int -> OpOne -> ShowS
    [OpOne] -> ShowS
    OpOne -> String
    (Int -> OpOne -> ShowS)
    -> (OpOne -> String) -> ([OpOne] -> ShowS) -> Show OpOne
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> OpOne -> ShowS
    showsPrec :: Int -> OpOne -> ShowS
    $cshow :: OpOne -> String
    show :: OpOne -> String
    $cshowList :: [OpOne] -> ShowS
    showList :: [OpOne] -> ShowS
    C.Show, ReadPrec [OpOne]
    ReadPrec OpOne
    Int -> ReadS OpOne
    ReadS [OpOne]
    (Int -> ReadS OpOne)
    -> ReadS [OpOne]
    -> ReadPrec OpOne
    -> ReadPrec [OpOne]
    -> Read OpOne
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS OpOne
    readsPrec :: Int -> ReadS OpOne
    $creadList :: ReadS [OpOne]
    readList :: ReadS [OpOne]
    $creadPrec :: ReadPrec OpOne
    readPrec :: ReadPrec OpOne
    $creadListPrec :: ReadPrec [OpOne]
    readListPrec :: ReadPrec [OpOne]
    C.Read)

    data Number = NumberInt Integer
      deriving (Number -> Number -> Bool
    (Number -> Number -> Bool)
    -> (Number -> Number -> Bool) -> Eq Number
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Number -> Number -> Bool
    == :: Number -> Number -> Bool
    $c/= :: Number -> Number -> Bool
    /= :: Number -> Number -> Bool
    C.Eq, Eq Number
    Eq Number =>
    (Number -> Number -> Ordering)
    -> (Number -> Number -> Bool)
    -> (Number -> Number -> Bool)
    -> (Number -> Number -> Bool)
    -> (Number -> Number -> Bool)
    -> (Number -> Number -> Number)
    -> (Number -> Number -> Number)
    -> Ord Number
    Number -> Number -> Bool
    Number -> Number -> Ordering
    Number -> Number -> Number
    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 :: Number -> Number -> Ordering
    compare :: Number -> Number -> Ordering
    $c< :: Number -> Number -> Bool
    < :: Number -> Number -> Bool
    $c<= :: Number -> Number -> Bool
    <= :: Number -> Number -> Bool
    $c> :: Number -> Number -> Bool
    > :: Number -> Number -> Bool
    $c>= :: Number -> Number -> Bool
    >= :: Number -> Number -> Bool
    $cmax :: Number -> Number -> Number
    max :: Number -> Number -> Number
    $cmin :: Number -> Number -> Number
    min :: Number -> Number -> Number
    C.Ord, Int -> Number -> ShowS
    [Number] -> ShowS
    Number -> String
    (Int -> Number -> ShowS)
    -> (Number -> String) -> ([Number] -> ShowS) -> Show Number
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Number -> ShowS
    showsPrec :: Int -> Number -> ShowS
    $cshow :: Number -> String
    show :: Number -> String
    $cshowList :: [Number] -> ShowS
    showList :: [Number] -> ShowS
    C.Show, ReadPrec [Number]
    ReadPrec Number
    Int -> ReadS Number
    ReadS [Number]
    (Int -> ReadS Number)
    -> ReadS [Number]
    -> ReadPrec Number
    -> ReadPrec [Number]
    -> Read Number
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Number
    readsPrec :: Int -> ReadS Number
    $creadList :: ReadS [Number]
    readList :: ReadS [Number]
    $creadPrec :: ReadPrec Number
    readPrec :: ReadPrec Number
    $creadListPrec :: ReadPrec [Number]
    readListPrec :: ReadPrec [Number]
    C.Read)

    data OrdOp
        = OrdOpLT | OrdOpLE | OrdOpEQ | OrdOpNE | OrdOpGT | OrdOpGE
      deriving (OrdOp -> OrdOp -> Bool
    (OrdOp -> OrdOp -> Bool) -> (OrdOp -> OrdOp -> Bool) -> Eq OrdOp
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: OrdOp -> OrdOp -> Bool
    == :: OrdOp -> OrdOp -> Bool
    $c/= :: OrdOp -> OrdOp -> Bool
    /= :: OrdOp -> OrdOp -> Bool
    C.Eq, Eq OrdOp
    Eq OrdOp =>
    (OrdOp -> OrdOp -> Ordering)
    -> (OrdOp -> OrdOp -> Bool)
    -> (OrdOp -> OrdOp -> Bool)
    -> (OrdOp -> OrdOp -> Bool)
    -> (OrdOp -> OrdOp -> Bool)
    -> (OrdOp -> OrdOp -> OrdOp)
    -> (OrdOp -> OrdOp -> OrdOp)
    -> Ord OrdOp
    OrdOp -> OrdOp -> Bool
    OrdOp -> OrdOp -> Ordering
    OrdOp -> OrdOp -> OrdOp
    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 :: OrdOp -> OrdOp -> Ordering
    compare :: OrdOp -> OrdOp -> Ordering
    $c< :: OrdOp -> OrdOp -> Bool
    < :: OrdOp -> OrdOp -> Bool
    $c<= :: OrdOp -> OrdOp -> Bool
    <= :: OrdOp -> OrdOp -> Bool
    $c> :: OrdOp -> OrdOp -> Bool
    > :: OrdOp -> OrdOp -> Bool
    $c>= :: OrdOp -> OrdOp -> Bool
    >= :: OrdOp -> OrdOp -> Bool
    $cmax :: OrdOp -> OrdOp -> OrdOp
    max :: OrdOp -> OrdOp -> OrdOp
    $cmin :: OrdOp -> OrdOp -> OrdOp
    min :: OrdOp -> OrdOp -> OrdOp
    C.Ord, Int -> OrdOp -> ShowS
    [OrdOp] -> ShowS
    OrdOp -> String
    (Int -> OrdOp -> ShowS)
    -> (OrdOp -> String) -> ([OrdOp] -> ShowS) -> Show OrdOp
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> OrdOp -> ShowS
    showsPrec :: Int -> OrdOp -> ShowS
    $cshow :: OrdOp -> String
    show :: OrdOp -> String
    $cshowList :: [OrdOp] -> ShowS
    showList :: [OrdOp] -> ShowS
    C.Show, ReadPrec [OrdOp]
    ReadPrec OrdOp
    Int -> ReadS OrdOp
    ReadS [OrdOp]
    (Int -> ReadS OrdOp)
    -> ReadS [OrdOp]
    -> ReadPrec OrdOp
    -> ReadPrec [OrdOp]
    -> Read OrdOp
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS OrdOp
    readsPrec :: Int -> ReadS OrdOp
    $creadList :: ReadS [OrdOp]
    readList :: ReadS [OrdOp]
    $creadPrec :: ReadPrec OrdOp
    readPrec :: ReadPrec OrdOp
    $creadListPrec :: ReadPrec [OrdOp]
    readListPrec :: ReadPrec [OrdOp]
    C.Read)

    data Op1Name
        = Op1Pre | Op1X | Op1G | Op1F | Op1Y | Op1Z | Op1Hist | Op1O
      deriving (Op1Name -> Op1Name -> Bool
    (Op1Name -> Op1Name -> Bool)
    -> (Op1Name -> Op1Name -> Bool) -> Eq Op1Name
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Op1Name -> Op1Name -> Bool
    == :: Op1Name -> Op1Name -> Bool
    $c/= :: Op1Name -> Op1Name -> Bool
    /= :: Op1Name -> Op1Name -> Bool
    C.Eq, Eq Op1Name
    Eq Op1Name =>
    (Op1Name -> Op1Name -> Ordering)
    -> (Op1Name -> Op1Name -> Bool)
    -> (Op1Name -> Op1Name -> Bool)
    -> (Op1Name -> Op1Name -> Bool)
    -> (Op1Name -> Op1Name -> Bool)
    -> (Op1Name -> Op1Name -> Op1Name)
    -> (Op1Name -> Op1Name -> Op1Name)
    -> Ord Op1Name
    Op1Name -> Op1Name -> Bool
    Op1Name -> Op1Name -> Ordering
    Op1Name -> Op1Name -> Op1Name
    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 :: Op1Name -> Op1Name -> Ordering
    compare :: Op1Name -> Op1Name -> Ordering
    $c< :: Op1Name -> Op1Name -> Bool
    < :: Op1Name -> Op1Name -> Bool
    $c<= :: Op1Name -> Op1Name -> Bool
    <= :: Op1Name -> Op1Name -> Bool
    $c> :: Op1Name -> Op1Name -> Bool
    > :: Op1Name -> Op1Name -> Bool
    $c>= :: Op1Name -> Op1Name -> Bool
    >= :: Op1Name -> Op1Name -> Bool
    $cmax :: Op1Name -> Op1Name -> Op1Name
    max :: Op1Name -> Op1Name -> Op1Name
    $cmin :: Op1Name -> Op1Name -> Op1Name
    min :: Op1Name -> Op1Name -> Op1Name
    C.Ord, Int -> Op1Name -> ShowS
    [Op1Name] -> ShowS
    Op1Name -> String
    (Int -> Op1Name -> ShowS)
    -> (Op1Name -> String) -> ([Op1Name] -> ShowS) -> Show Op1Name
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Op1Name -> ShowS
    showsPrec :: Int -> Op1Name -> ShowS
    $cshow :: Op1Name -> String
    show :: Op1Name -> String
    $cshowList :: [Op1Name] -> ShowS
    showList :: [Op1Name] -> ShowS
    C.Show, ReadPrec [Op1Name]
    ReadPrec Op1Name
    Int -> ReadS Op1Name
    ReadS [Op1Name]
    (Int -> ReadS Op1Name)
    -> ReadS [Op1Name]
    -> ReadPrec Op1Name
    -> ReadPrec [Op1Name]
    -> Read Op1Name
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Op1Name
    readsPrec :: Int -> ReadS Op1Name
    $creadList :: ReadS [Op1Name]
    readList :: ReadS [Op1Name]
    $creadPrec :: ReadPrec Op1Name
    readPrec :: ReadPrec Op1Name
    $creadListPrec :: ReadPrec [Op1Name]
    readListPrec :: ReadPrec [Op1Name]
    C.Read)

    data OpTwo = Op2S | Op2T | Op2V | Op2U
      deriving (OpTwo -> OpTwo -> Bool
    (OpTwo -> OpTwo -> Bool) -> (OpTwo -> OpTwo -> Bool) -> Eq OpTwo
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: OpTwo -> OpTwo -> Bool
    == :: OpTwo -> OpTwo -> Bool
    $c/= :: OpTwo -> OpTwo -> Bool
    /= :: OpTwo -> OpTwo -> Bool
    C.Eq, Eq OpTwo
    Eq OpTwo =>
    (OpTwo -> OpTwo -> Ordering)
    -> (OpTwo -> OpTwo -> Bool)
    -> (OpTwo -> OpTwo -> Bool)
    -> (OpTwo -> OpTwo -> Bool)
    -> (OpTwo -> OpTwo -> Bool)
    -> (OpTwo -> OpTwo -> OpTwo)
    -> (OpTwo -> OpTwo -> OpTwo)
    -> Ord OpTwo
    OpTwo -> OpTwo -> Bool
    OpTwo -> OpTwo -> Ordering
    OpTwo -> OpTwo -> OpTwo
    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 :: OpTwo -> OpTwo -> Ordering
    compare :: OpTwo -> OpTwo -> Ordering
    $c< :: OpTwo -> OpTwo -> Bool
    < :: OpTwo -> OpTwo -> Bool
    $c<= :: OpTwo -> OpTwo -> Bool
    <= :: OpTwo -> OpTwo -> Bool
    $c> :: OpTwo -> OpTwo -> Bool
    > :: OpTwo -> OpTwo -> Bool
    $c>= :: OpTwo -> OpTwo -> Bool
    >= :: OpTwo -> OpTwo -> Bool
    $cmax :: OpTwo -> OpTwo -> OpTwo
    max :: OpTwo -> OpTwo -> OpTwo
    $cmin :: OpTwo -> OpTwo -> OpTwo
    min :: OpTwo -> OpTwo -> OpTwo
    C.Ord, Int -> OpTwo -> ShowS
    [OpTwo] -> ShowS
    OpTwo -> String
    (Int -> OpTwo -> ShowS)
    -> (OpTwo -> String) -> ([OpTwo] -> ShowS) -> Show OpTwo
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> OpTwo -> ShowS
    showsPrec :: Int -> OpTwo -> ShowS
    $cshow :: OpTwo -> String
    show :: OpTwo -> String
    $cshowList :: [OpTwo] -> ShowS
    showList :: [OpTwo] -> ShowS
    C.Show, ReadPrec [OpTwo]
    ReadPrec OpTwo
    Int -> ReadS OpTwo
    ReadS [OpTwo]
    (Int -> ReadS OpTwo)
    -> ReadS [OpTwo]
    -> ReadPrec OpTwo
    -> ReadPrec [OpTwo]
    -> Read OpTwo
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS OpTwo
    readsPrec :: Int -> ReadS OpTwo
    $creadList :: ReadS [OpTwo]
    readList :: ReadS [OpTwo]
    $creadPrec :: ReadPrec OpTwo
    readPrec :: ReadPrec OpTwo
    $creadListPrec :: ReadPrec [OpTwo]
    readListPrec :: ReadPrec [OpTwo]
    C.Read)

    newtype Ident = Ident String
      deriving (Ident -> Ident -> Bool
    (Ident -> Ident -> Bool) -> (Ident -> Ident -> Bool) -> Eq Ident
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Ident -> Ident -> Bool
    == :: Ident -> Ident -> Bool
    $c/= :: Ident -> Ident -> Bool
    /= :: Ident -> Ident -> Bool
    C.Eq, Eq Ident
    Eq Ident =>
    (Ident -> Ident -> Ordering)
    -> (Ident -> Ident -> Bool)
    -> (Ident -> Ident -> Bool)
    -> (Ident -> Ident -> Bool)
    -> (Ident -> Ident -> Bool)
    -> (Ident -> Ident -> Ident)
    -> (Ident -> Ident -> Ident)
    -> Ord Ident
    Ident -> Ident -> Bool
    Ident -> Ident -> Ordering
    Ident -> Ident -> Ident
    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 :: Ident -> Ident -> Ordering
    compare :: Ident -> Ident -> Ordering
    $c< :: Ident -> Ident -> Bool
    < :: Ident -> Ident -> Bool
    $c<= :: Ident -> Ident -> Bool
    <= :: Ident -> Ident -> Bool
    $c> :: Ident -> Ident -> Bool
    > :: Ident -> Ident -> Bool
    $c>= :: Ident -> Ident -> Bool
    >= :: Ident -> Ident -> Bool
    $cmax :: Ident -> Ident -> Ident
    max :: Ident -> Ident -> Ident
    $cmin :: Ident -> Ident -> Ident
    min :: Ident -> Ident -> Ident
    C.Ord, Int -> Ident -> ShowS
    [Ident] -> ShowS
    Ident -> String
    (Int -> Ident -> ShowS)
    -> (Ident -> String) -> ([Ident] -> ShowS) -> Show Ident
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Ident -> ShowS
    showsPrec :: Int -> Ident -> ShowS
    $cshow :: Ident -> String
    show :: Ident -> String
    $cshowList :: [Ident] -> ShowS
    showList :: [Ident] -> ShowS
    C.Show, ReadPrec [Ident]
    ReadPrec Ident
    Int -> ReadS Ident
    ReadS [Ident]
    (Int -> ReadS Ident)
    -> ReadS [Ident]
    -> ReadPrec Ident
    -> ReadPrec [Ident]
    -> Read Ident
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Ident
    readsPrec :: Int -> ReadS Ident
    $creadList :: ReadS [Ident]
    readList :: ReadS [Ident]
    $creadPrec :: ReadPrec Ident
    readPrec :: ReadPrec Ident
    $creadListPrec :: ReadPrec [Ident]
    readListPrec :: ReadPrec [Ident]
    C.Read, String -> Ident
    (String -> Ident) -> IsString Ident
    forall a. (String -> a) -> IsString a
    $cfromString :: String -> Ident
    fromString :: String -> Ident
    Data.String.IsString)