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

    {-# LANGUAGE GeneralizedNewtypeDeriving #-}

    -- | The abstract syntax of language Lustre.

    module Language.Lustre.AbsLustre where

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

    data BoolSpec
        = BoolSpecPar BoolSpec
        | BoolSpecConstI Integer
        | BoolSpecConstD Double
        | BoolSpecConstB BoolConst
        | BoolSpecSignal Ident
        | BoolSpecOp1Pre Op1Pre BoolSpec
        | BoolSpecOp2In BoolSpec Op2In BoolSpec
        | BoolSpecOp2Pre Op2Pre BoolSpec BoolSpec
        | BoolSpecOp2OT NumExpr NumExpr BoolSpec
        | BoolSpecOp2HT NumExpr NumExpr BoolSpec
        | BoolSpecOp2ST NumExpr NumExpr BoolSpec 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 Op1Pre
        = Op1Once
        | Op1Pre
        | Op1YtoPre
        | Op1ZtoPre
        | Op1Hist
        | Op1Y
        | Op1Not
        | Op1Bang
      deriving (Op1Pre -> Op1Pre -> Bool
    (Op1Pre -> Op1Pre -> Bool)
    -> (Op1Pre -> Op1Pre -> Bool) -> Eq Op1Pre
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: Op1Pre -> Op1Pre -> Bool
    == :: Op1Pre -> Op1Pre -> Bool
    $c/= :: Op1Pre -> Op1Pre -> Bool
    /= :: Op1Pre -> Op1Pre -> Bool
    C.Eq, Eq Op1Pre
    Eq Op1Pre =>
    (Op1Pre -> Op1Pre -> Ordering)
    -> (Op1Pre -> Op1Pre -> Bool)
    -> (Op1Pre -> Op1Pre -> Bool)
    -> (Op1Pre -> Op1Pre -> Bool)
    -> (Op1Pre -> Op1Pre -> Bool)
    -> (Op1Pre -> Op1Pre -> Op1Pre)
    -> (Op1Pre -> Op1Pre -> Op1Pre)
    -> Ord Op1Pre
    Op1Pre -> Op1Pre -> Bool
    Op1Pre -> Op1Pre -> Ordering
    Op1Pre -> Op1Pre -> Op1Pre
    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 :: Op1Pre -> Op1Pre -> Ordering
    compare :: Op1Pre -> Op1Pre -> Ordering
    $c< :: Op1Pre -> Op1Pre -> Bool
    < :: Op1Pre -> Op1Pre -> Bool
    $c<= :: Op1Pre -> Op1Pre -> Bool
    <= :: Op1Pre -> Op1Pre -> Bool
    $c> :: Op1Pre -> Op1Pre -> Bool
    > :: Op1Pre -> Op1Pre -> Bool
    $c>= :: Op1Pre -> Op1Pre -> Bool
    >= :: Op1Pre -> Op1Pre -> Bool
    $cmax :: Op1Pre -> Op1Pre -> Op1Pre
    max :: Op1Pre -> Op1Pre -> Op1Pre
    $cmin :: Op1Pre -> Op1Pre -> Op1Pre
    min :: Op1Pre -> Op1Pre -> Op1Pre
    C.Ord, Int -> Op1Pre -> ShowS
    [Op1Pre] -> ShowS
    Op1Pre -> String
    (Int -> Op1Pre -> ShowS)
    -> (Op1Pre -> String) -> ([Op1Pre] -> ShowS) -> Show Op1Pre
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> Op1Pre -> ShowS
    showsPrec :: Int -> Op1Pre -> ShowS
    $cshow :: Op1Pre -> String
    show :: Op1Pre -> String
    $cshowList :: [Op1Pre] -> ShowS
    showList :: [Op1Pre] -> ShowS
    C.Show, ReadPrec [Op1Pre]
    ReadPrec Op1Pre
    Int -> ReadS Op1Pre
    ReadS [Op1Pre]
    (Int -> ReadS Op1Pre)
    -> ReadS [Op1Pre]
    -> ReadPrec Op1Pre
    -> ReadPrec [Op1Pre]
    -> Read Op1Pre
    forall a.
    (Int -> ReadS a)
    -> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
    $creadsPrec :: Int -> ReadS Op1Pre
    readsPrec :: Int -> ReadS Op1Pre
    $creadList :: ReadS [Op1Pre]
    readList :: ReadS [Op1Pre]
    $creadPrec :: ReadPrec Op1Pre
    readPrec :: ReadPrec Op1Pre
    $creadListPrec :: ReadPrec [Op1Pre]
    readListPrec :: ReadPrec [Op1Pre]
    C.Read)

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

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

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

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

    data BoolConst = BoolConstTrue | BoolConstFalse | BoolConstFTP
      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)

    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)