    {-# OPTIONS_GHC -w #-}
    {-# LANGUAGE CPP #-}
    {-# LANGUAGE MagicHash #-}
    {-# LANGUAGE BangPatterns #-}
    {-# LANGUAGE TypeSynonymInstances #-}
    {-# LANGUAGE FlexibleInstances #-}
    {-# LANGUAGE PatternGuards #-}
    {-# LANGUAGE NoStrictData #-}
    {-# LANGUAGE UnboxedTuples #-}
    {-# LANGUAGE PartialTypeSignatures #-}
    {-# OPTIONS_GHC -Wno-incomplete-patterns -Wno-overlapping-patterns #-}
    {-# LANGUAGE PatternSynonyms #-}

    module Language.SMV.ParSMV
      ( happyError
      , myLexer
      , pBoolSpec
      ) where

    import Prelude

    import qualified Language.SMV.AbsSMV
    import Language.SMV.LexSMV
    import qualified Control.Monad as Happy_Prelude
    import qualified Data.Bool as Happy_Prelude
    import qualified Data.Function as Happy_Prelude
    import qualified Data.Int as Happy_Prelude
    import qualified Data.List as Happy_Prelude
    import qualified Data.Maybe as Happy_Prelude
    import qualified Data.String as Happy_Prelude
    import qualified Data.Tuple as Happy_Prelude
    import qualified GHC.Err as Happy_Prelude
    import qualified GHC.Num as Happy_Prelude
    import qualified Text.Show as Happy_Prelude
    import qualified Data.Array as Happy_Data_Array
    import qualified Data.Bits as Bits
    import qualified GHC.Exts as Happy_GHC_Exts
    import Control.Applicative(Applicative(..))
    import Control.Monad (ap)

    -- parser produced by Happy Version 2.1.7

    newtype HappyAbsSyn  = HappyAbsSyn HappyAny
    #if __GLASGOW_HASKELL__ >= 607
    type HappyAny = Happy_GHC_Exts.Any
    #else
    type HappyAny = forall a . a
    #endif
    newtype HappyWrap5 = HappyWrap5 (Language.SMV.AbsSMV.Ident)
    happyIn5 :: (Language.SMV.AbsSMV.Ident) -> (HappyAbsSyn )
    happyIn5 :: Ident -> HappyAbsSyn
    happyIn5 Ident
    x = HappyWrap5 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (Ident -> HappyWrap5
    HappyWrap5 Ident
    x)
    {-# INLINE happyIn5 #-}
    happyOut5 :: (HappyAbsSyn ) -> HappyWrap5
    happyOut5 :: HappyAbsSyn -> HappyWrap5
    happyOut5 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap5
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut5 #-}
    newtype HappyWrap6 = HappyWrap6 (Double)
    happyIn6 :: (Double) -> (HappyAbsSyn )
    happyIn6 :: Double -> HappyAbsSyn
    happyIn6 Double
    x = HappyWrap6 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (Double -> HappyWrap6
    HappyWrap6 Double
    x)
    {-# INLINE happyIn6 #-}
    happyOut6 :: (HappyAbsSyn ) -> HappyWrap6
    happyOut6 :: HappyAbsSyn -> HappyWrap6
    happyOut6 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap6
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut6 #-}
    newtype HappyWrap7 = HappyWrap7 (Integer)
    happyIn7 :: (Integer) -> (HappyAbsSyn )
    happyIn7 :: Integer -> HappyAbsSyn
    happyIn7 Integer
    x = HappyWrap7 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (Integer -> HappyWrap7
    HappyWrap7 Integer
    x)
    {-# INLINE happyIn7 #-}
    happyOut7 :: (HappyAbsSyn ) -> HappyWrap7
    happyOut7 :: HappyAbsSyn -> HappyWrap7
    happyOut7 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap7
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut7 #-}
    newtype HappyWrap8 = HappyWrap8 (Language.SMV.AbsSMV.BoolSpec)
    happyIn8 :: (Language.SMV.AbsSMV.BoolSpec) -> (HappyAbsSyn )
    happyIn8 :: BoolSpec -> HappyAbsSyn
    happyIn8 BoolSpec
    x = HappyWrap8 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (BoolSpec -> HappyWrap8
    HappyWrap8 BoolSpec
    x)
    {-# INLINE happyIn8 #-}
    happyOut8 :: (HappyAbsSyn ) -> HappyWrap8
    happyOut8 :: HappyAbsSyn -> HappyWrap8
    happyOut8 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap8
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut8 #-}
    newtype HappyWrap9 = HappyWrap9 (Language.SMV.AbsSMV.BoolSpec)
    happyIn9 :: (Language.SMV.AbsSMV.BoolSpec) -> (HappyAbsSyn )
    happyIn9 :: BoolSpec -> HappyAbsSyn
    happyIn9 BoolSpec
    x = HappyWrap9 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (BoolSpec -> HappyWrap9
    HappyWrap9 BoolSpec
    x)
    {-# INLINE happyIn9 #-}
    happyOut9 :: (HappyAbsSyn ) -> HappyWrap9
    happyOut9 :: HappyAbsSyn -> HappyWrap9
    happyOut9 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap9
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut9 #-}
    newtype HappyWrap10 = HappyWrap10 (Language.SMV.AbsSMV.BoolSpec)
    happyIn10 :: (Language.SMV.AbsSMV.BoolSpec) -> (HappyAbsSyn )
    happyIn10 :: BoolSpec -> HappyAbsSyn
    happyIn10 BoolSpec
    x = HappyWrap10 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (BoolSpec -> HappyWrap10
    HappyWrap10 BoolSpec
    x)
    {-# INLINE happyIn10 #-}
    happyOut10 :: (HappyAbsSyn ) -> HappyWrap10
    happyOut10 :: HappyAbsSyn -> HappyWrap10
    happyOut10 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap10
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut10 #-}
    newtype HappyWrap11 = HappyWrap11 (Language.SMV.AbsSMV.BoolSpec)
    happyIn11 :: (Language.SMV.AbsSMV.BoolSpec) -> (HappyAbsSyn )
    happyIn11 :: BoolSpec -> HappyAbsSyn
    happyIn11 BoolSpec
    x = HappyWrap11 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (BoolSpec -> HappyWrap11
    HappyWrap11 BoolSpec
    x)
    {-# INLINE happyIn11 #-}
    happyOut11 :: (HappyAbsSyn ) -> HappyWrap11
    happyOut11 :: HappyAbsSyn -> HappyWrap11
    happyOut11 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap11
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut11 #-}
    newtype HappyWrap12 = HappyWrap12 (Language.SMV.AbsSMV.BoolSpec)
    happyIn12 :: (Language.SMV.AbsSMV.BoolSpec) -> (HappyAbsSyn )
    happyIn12 :: BoolSpec -> HappyAbsSyn
    happyIn12 BoolSpec
    x = HappyWrap12 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (BoolSpec -> HappyWrap12
    HappyWrap12 BoolSpec
    x)
    {-# INLINE happyIn12 #-}
    happyOut12 :: (HappyAbsSyn ) -> HappyWrap12
    happyOut12 :: HappyAbsSyn -> HappyWrap12
    happyOut12 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap12
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut12 #-}
    newtype HappyWrap13 = HappyWrap13 (Language.SMV.AbsSMV.BoolSpec)
    happyIn13 :: (Language.SMV.AbsSMV.BoolSpec) -> (HappyAbsSyn )
    happyIn13 :: BoolSpec -> HappyAbsSyn
    happyIn13 BoolSpec
    x = HappyWrap13 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (BoolSpec -> HappyWrap13
    HappyWrap13 BoolSpec
    x)
    {-# INLINE happyIn13 #-}
    happyOut13 :: (HappyAbsSyn ) -> HappyWrap13
    happyOut13 :: HappyAbsSyn -> HappyWrap13
    happyOut13 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap13
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut13 #-}
    newtype HappyWrap14 = HappyWrap14 (Language.SMV.AbsSMV.BoolSpec)
    happyIn14 :: (Language.SMV.AbsSMV.BoolSpec) -> (HappyAbsSyn )
    happyIn14 :: BoolSpec -> HappyAbsSyn
    happyIn14 BoolSpec
    x = HappyWrap14 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (BoolSpec -> HappyWrap14
    HappyWrap14 BoolSpec
    x)
    {-# INLINE happyIn14 #-}
    happyOut14 :: (HappyAbsSyn ) -> HappyWrap14
    happyOut14 :: HappyAbsSyn -> HappyWrap14
    happyOut14 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap14
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut14 #-}
    newtype HappyWrap15 = HappyWrap15 (Language.SMV.AbsSMV.BoolSpec)
    happyIn15 :: (Language.SMV.AbsSMV.BoolSpec) -> (HappyAbsSyn )
    happyIn15 :: BoolSpec -> HappyAbsSyn
    happyIn15 BoolSpec
    x = HappyWrap15 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (BoolSpec -> HappyWrap15
    HappyWrap15 BoolSpec
    x)
    {-# INLINE happyIn15 #-}
    happyOut15 :: (HappyAbsSyn ) -> HappyWrap15
    happyOut15 :: HappyAbsSyn -> HappyWrap15
    happyOut15 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap15
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut15 #-}
    newtype HappyWrap16 = HappyWrap16 (Language.SMV.AbsSMV.BoolSpec)
    happyIn16 :: (Language.SMV.AbsSMV.BoolSpec) -> (HappyAbsSyn )
    happyIn16 :: BoolSpec -> HappyAbsSyn
    happyIn16 BoolSpec
    x = HappyWrap16 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (BoolSpec -> HappyWrap16
    HappyWrap16 BoolSpec
    x)
    {-# INLINE happyIn16 #-}
    happyOut16 :: (HappyAbsSyn ) -> HappyWrap16
    happyOut16 :: HappyAbsSyn -> HappyWrap16
    happyOut16 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap16
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut16 #-}
    newtype HappyWrap17 = HappyWrap17 (Language.SMV.AbsSMV.BoolSpec)
    happyIn17 :: (Language.SMV.AbsSMV.BoolSpec) -> (HappyAbsSyn )
    happyIn17 :: BoolSpec -> HappyAbsSyn
    happyIn17 BoolSpec
    x = HappyWrap17 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (BoolSpec -> HappyWrap17
    HappyWrap17 BoolSpec
    x)
    {-# INLINE happyIn17 #-}
    happyOut17 :: (HappyAbsSyn ) -> HappyWrap17
    happyOut17 :: HappyAbsSyn -> HappyWrap17
    happyOut17 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap17
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut17 #-}
    newtype HappyWrap18 = HappyWrap18 (Language.SMV.AbsSMV.NumExpr)
    happyIn18 :: (Language.SMV.AbsSMV.NumExpr) -> (HappyAbsSyn )
    happyIn18 :: NumExpr -> HappyAbsSyn
    happyIn18 NumExpr
    x = HappyWrap18 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (NumExpr -> HappyWrap18
    HappyWrap18 NumExpr
    x)
    {-# INLINE happyIn18 #-}
    happyOut18 :: (HappyAbsSyn ) -> HappyWrap18
    happyOut18 :: HappyAbsSyn -> HappyWrap18
    happyOut18 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap18
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut18 #-}
    newtype HappyWrap19 = HappyWrap19 (Language.SMV.AbsSMV.NumExpr)
    happyIn19 :: (Language.SMV.AbsSMV.NumExpr) -> (HappyAbsSyn )
    happyIn19 :: NumExpr -> HappyAbsSyn
    happyIn19 NumExpr
    x = HappyWrap19 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (NumExpr -> HappyWrap19
    HappyWrap19 NumExpr
    x)
    {-# INLINE happyIn19 #-}
    happyOut19 :: (HappyAbsSyn ) -> HappyWrap19
    happyOut19 :: HappyAbsSyn -> HappyWrap19
    happyOut19 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap19
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut19 #-}
    newtype HappyWrap20 = HappyWrap20 (Language.SMV.AbsSMV.NumExpr)
    happyIn20 :: (Language.SMV.AbsSMV.NumExpr) -> (HappyAbsSyn )
    happyIn20 :: NumExpr -> HappyAbsSyn
    happyIn20 NumExpr
    x = HappyWrap20 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (NumExpr -> HappyWrap20
    HappyWrap20 NumExpr
    x)
    {-# INLINE happyIn20 #-}
    happyOut20 :: (HappyAbsSyn ) -> HappyWrap20
    happyOut20 :: HappyAbsSyn -> HappyWrap20
    happyOut20 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap20
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut20 #-}
    newtype HappyWrap21 = HappyWrap21 (Language.SMV.AbsSMV.AdditiveOp)
    happyIn21 :: (Language.SMV.AbsSMV.AdditiveOp) -> (HappyAbsSyn )
    happyIn21 :: AdditiveOp -> HappyAbsSyn
    happyIn21 AdditiveOp
    x = HappyWrap21 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (AdditiveOp -> HappyWrap21
    HappyWrap21 AdditiveOp
    x)
    {-# INLINE happyIn21 #-}
    happyOut21 :: (HappyAbsSyn ) -> HappyWrap21
    happyOut21 :: HappyAbsSyn -> HappyWrap21
    happyOut21 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap21
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut21 #-}
    newtype HappyWrap22 = HappyWrap22 (Language.SMV.AbsSMV.MultOp)
    happyIn22 :: (Language.SMV.AbsSMV.MultOp) -> (HappyAbsSyn )
    happyIn22 :: MultOp -> HappyAbsSyn
    happyIn22 MultOp
    x = HappyWrap22 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (MultOp -> HappyWrap22
    HappyWrap22 MultOp
    x)
    {-# INLINE happyIn22 #-}
    happyOut22 :: (HappyAbsSyn ) -> HappyWrap22
    happyOut22 :: HappyAbsSyn -> HappyWrap22
    happyOut22 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap22
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut22 #-}
    newtype HappyWrap23 = HappyWrap23 (Language.SMV.AbsSMV.BoolConst)
    happyIn23 :: (Language.SMV.AbsSMV.BoolConst) -> (HappyAbsSyn )
    happyIn23 :: BoolConst -> HappyAbsSyn
    happyIn23 BoolConst
    x = HappyWrap23 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (BoolConst -> HappyWrap23
    HappyWrap23 BoolConst
    x)
    {-# INLINE happyIn23 #-}
    happyOut23 :: (HappyAbsSyn ) -> HappyWrap23
    happyOut23 :: HappyAbsSyn -> HappyWrap23
    happyOut23 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap23
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut23 #-}
    newtype HappyWrap24 = HappyWrap24 (Language.SMV.AbsSMV.OpOne)
    happyIn24 :: (Language.SMV.AbsSMV.OpOne) -> (HappyAbsSyn )
    happyIn24 :: OpOne -> HappyAbsSyn
    happyIn24 OpOne
    x = HappyWrap24 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (OpOne -> HappyWrap24
    HappyWrap24 OpOne
    x)
    {-# INLINE happyIn24 #-}
    happyOut24 :: (HappyAbsSyn ) -> HappyWrap24
    happyOut24 :: HappyAbsSyn -> HappyWrap24
    happyOut24 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap24
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut24 #-}
    newtype HappyWrap25 = HappyWrap25 (Language.SMV.AbsSMV.Number)
    happyIn25 :: (Language.SMV.AbsSMV.Number) -> (HappyAbsSyn )
    happyIn25 :: Number -> HappyAbsSyn
    happyIn25 Number
    x = HappyWrap25 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (Number -> HappyWrap25
    HappyWrap25 Number
    x)
    {-# INLINE happyIn25 #-}
    happyOut25 :: (HappyAbsSyn ) -> HappyWrap25
    happyOut25 :: HappyAbsSyn -> HappyWrap25
    happyOut25 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap25
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut25 #-}
    newtype HappyWrap26 = HappyWrap26 (Language.SMV.AbsSMV.OrdOp)
    happyIn26 :: (Language.SMV.AbsSMV.OrdOp) -> (HappyAbsSyn )
    happyIn26 :: OrdOp -> HappyAbsSyn
    happyIn26 OrdOp
    x = HappyWrap26 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (OrdOp -> HappyWrap26
    HappyWrap26 OrdOp
    x)
    {-# INLINE happyIn26 #-}
    happyOut26 :: (HappyAbsSyn ) -> HappyWrap26
    happyOut26 :: HappyAbsSyn -> HappyWrap26
    happyOut26 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap26
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut26 #-}
    newtype HappyWrap27 = HappyWrap27 (Language.SMV.AbsSMV.Op1Name)
    happyIn27 :: (Language.SMV.AbsSMV.Op1Name) -> (HappyAbsSyn )
    happyIn27 :: Op1Name -> HappyAbsSyn
    happyIn27 Op1Name
    x = HappyWrap27 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (Op1Name -> HappyWrap27
    HappyWrap27 Op1Name
    x)
    {-# INLINE happyIn27 #-}
    happyOut27 :: (HappyAbsSyn ) -> HappyWrap27
    happyOut27 :: HappyAbsSyn -> HappyWrap27
    happyOut27 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap27
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut27 #-}
    newtype HappyWrap28 = HappyWrap28 (Language.SMV.AbsSMV.OpTwo)
    happyIn28 :: (Language.SMV.AbsSMV.OpTwo) -> (HappyAbsSyn )
    happyIn28 :: OpTwo -> HappyAbsSyn
    happyIn28 OpTwo
    x = HappyWrap28 -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# (OpTwo -> HappyWrap28
    HappyWrap28 OpTwo
    x)
    {-# INLINE happyIn28 #-}
    happyOut28 :: (HappyAbsSyn ) -> HappyWrap28
    happyOut28 :: HappyAbsSyn -> HappyWrap28
    happyOut28 HappyAbsSyn
    x = HappyAbsSyn -> HappyWrap28
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOut28 #-}
    happyInTok :: (Token) -> (HappyAbsSyn )
    happyInTok :: Token -> HappyAbsSyn
    happyInTok Token
    x = Token -> HappyAbsSyn
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# Token
    x
    {-# INLINE happyInTok #-}
    happyOutTok :: (HappyAbsSyn ) -> (Token)
    happyOutTok :: HappyAbsSyn -> Token
    happyOutTok HappyAbsSyn
    x = HappyAbsSyn -> Token
    forall a b. a -> b
    Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
    x
    {-# INLINE happyOutTok #-}

    {-# NOINLINE happyTokenStrings #-}
    happyTokenStrings :: [String]
    happyTokenStrings = [String
    "'!'",String
    "'!='",String
    "'&'",String
    "'('",String
    "')'",String
    "'*'",String
    "'+'",String
    "','",String
    "'-'",String
    "'->'",String
    "'/'",String
    "'<'",String
    "'<->'",String
    "'</b>'",String
    "'</i>'",String
    "'<='",String
    "'<b>'",String
    "'<i>'",String
    "'='",String
    "'>'",String
    "'>='",String
    "'F'",String
    "'FALSE'",String
    "'FTP'",String
    "'G'",String
    "'H'",String
    "'LAST'",String
    "'O'",String
    "'S'",String
    "'T'",String
    "'TRUE'",String
    "'U'",String
    "'V'",String
    "'X'",String
    "'Y'",String
    "'Z'",String
    "'['",String
    "']'",String
    "'pre'",String
    "'xor'",String
    "'|'",String
    "L_Ident",String
    "L_doubl",String
    "L_integ",String
    "%eof"]

    happyActOffsets :: HappyAddr
    happyActOffsets :: HappyAddr
    happyActOffsets = Addr# -> HappyAddr
    HappyA# Addr#
    "\xff\xff\xff\xff\xdc\xff\xff\xff\x00\x00\x00\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x00\x00\x00\x00\x00\x00\x00\x09\x00\x00\x00\x0b\x00\x00\x00\x15\x00\x00\x00\x1e\x00\x00\x00\x26\x00\x00\x00\x00\x00\x00\x00\xe7\xff\xff\xff\x00\x00\x00\x00\x4c\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x27\x00\x00\x00\x72\x00\x00\x00\x40\x00\x00\x00\x40\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7d\x01\x00\x00\xf9\x00\x00\x00\x28\x00\x00\x00\x04\x00\x00\x00\x83\x00\x00\x00\x6d\x00\x00\x00\x47\x00\x00\x00\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x00\x00\x00\x5c\x00\x00\x00\x5c\x00\x00\x00\x5c\x00\x00\x00\x5c\x00\x00\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x35\x00\x00\x00\x39\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0e\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\xf0\xff\xff\xff\xf0\xff\xff\xff\xf0\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x62\x00\x00\x00\x43\x00\x00\x00\xf0\xff\xff\xff\x04\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#

    happyGotoOffsets :: HappyAddr
    happyGotoOffsets :: HappyAddr
    happyGotoOffsets = Addr# -> HappyAddr
    HappyA# Addr#
    "\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x64\x00\x00\x00\x00\x00\x00\x00\x63\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x1c\x01\x00\x00\x00\x00\x00\x00\x82\x01\x00\x00\xb7\x00\x00\x00\xce\x00\x00\x00\xe5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x66\x00\x00\x00\x66\x00\x00\x00\x66\x00\x00\x00\x7b\x00\x00\x00\x78\x00\x00\x00\x0c\x00\x00\x00\x00\x00\x00\x00\xa3\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2f\x01\x00\x00\x42\x01\x00\x00\x55\x01\x00\x00\x68\x01\x00\x00\x6f\x01\x00\x00\x88\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa0\x01\x00\x00\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#

    happyDefActions :: HappyAddr
    happyDefActions :: HappyAddr
    happyDefActions = Addr# -> HappyAddr
    HappyA# Addr#
    "\x00\x00\x00\x00\x00\x00\x00\x00\xfe\xff\xff\xff\xe3\xff\xff\xff\xe1\xff\xff\xff\xe2\xff\xff\xff\xf4\xff\xff\xff\xf2\xff\xff\xff\xf0\xff\xff\xff\xee\xff\xff\xff\xec\xff\xff\xff\xea\xff\xff\xff\xe8\xff\xff\xff\xe6\xff\xff\xff\xe4\xff\xff\xff\x00\x00\x00\x00\xde\xff\xff\xff\xdc\xff\xff\xff\xf9\xff\xff\xff\xfa\xff\xff\xff\x00\x00\x00\x00\xd3\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc4\xff\xff\xff\xd6\xff\xff\xff\xd5\xff\xff\xff\xc5\xff\xff\xff\xc1\xff\xff\xff\xd4\xff\xff\xff\xc0\xff\xff\xff\xd7\xff\xff\xff\xc6\xff\xff\xff\xc3\xff\xff\xff\xc2\xff\xff\xff\xc7\xff\xff\xff\xfd\xff\xff\xff\xfc\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\xff\xff\xff\xf3\xff\xff\xff\x00\x00\x00\x00\xe7\xff\xff\xff\x00\x00\x00\x00\xd9\xff\xff\xff\xd8\xff\xff\xff\x00\x00\x00\x00\xdb\xff\xff\xff\xda\xff\xff\xff\x00\x00\x00\x00\xbf\xff\xff\xff\xbe\xff\xff\xff\xbc\xff\xff\xff\xbd\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xca\xff\xff\xff\xcd\xff\xff\xff\xcc\xff\xff\xff\xcb\xff\xff\xff\xc9\xff\xff\xff\xc8\xff\xff\xff\xf5\xff\xff\xff\xf1\xff\xff\xff\xef\xff\xff\xff\xed\xff\xff\xff\xeb\xff\xff\xff\xe9\xff\xff\xff\xe5\xff\xff\xff\xe3\xff\xff\xff\xdf\xff\xff\xff\x00\x00\x00\x00\xdd\xff\xff\xff\xd0\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\xff\xff\xff\xf8\xff\xff\xff\xf7\xff\xff\xff\xf6\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd2\xff\xff\xff\xcf\xff\xff\xff\xce\xff\xff\xff\xd1\xff\xff\xff"#

    happyCheck :: HappyAddr
    happyCheck :: HappyAddr
    happyCheck = Addr# -> HappyAddr
    HappyA# Addr#
    "\xff\xff\xff\xff\x02\x00\x00\x00\x12\x00\x00\x00\x13\x00\x00\x00\x05\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x2b\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x02\x00\x00\x00\x04\x00\x00\x00\x02\x00\x00\x00\x07\x00\x00\x00\x0c\x00\x00\x00\x12\x00\x00\x00\x13\x00\x00\x00\x05\x00\x00\x00\x0c\x00\x00\x00\x2e\x00\x00\x00\x17\x00\x00\x00\x18\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x1b\x00\x00\x00\x1c\x00\x00\x00\x1d\x00\x00\x00\x2d\x00\x00\x00\x14\x00\x00\x00\x20\x00\x00\x00\x14\x00\x00\x00\x15\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x28\x00\x00\x00\x06\x00\x00\x00\x0b\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x0b\x00\x00\x00\x06\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x0e\x00\x00\x00\x2a\x00\x00\x00\x14\x00\x00\x00\x15\x00\x00\x00\x16\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x02\x00\x00\x00\x02\x00\x00\x00\x29\x00\x00\x00\x02\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x02\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x05\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x04\x00\x00\x00\x21\x00\x00\x00\x22\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x26\x00\x00\x00\x14\x00\x00\x00\x14\x00\x00\x00\x2e\x00\x00\x00\x14\x00\x00\x00\x12\x00\x00\x00\x13\x00\x00\x00\x08\x00\x00\x00\x0e\x00\x00\x00\x0a\x00\x00\x00\x17\x00\x00\x00\x18\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x1b\x00\x00\x00\x1c\x00\x00\x00\x1d\x00\x00\x00\x02\x00\x00\x00\x2a\x00\x00\x00\x20\x00\x00\x00\x05\x00\x00\x00\x29\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x0b\x00\x00\x00\x09\x00\x00\x00\x28\x00\x00\x00\x10\x00\x00\x00\x27\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x12\x00\x00\x00\x13\x00\x00\x00\x03\x00\x00\x00\x0f\x00\x00\x00\x27\x00\x00\x00\x10\x00\x00\x00\x18\x00\x00\x00\x19\x00\x00\x00\x15\x00\x00\x00\x05\x00\x00\x00\x1c\x00\x00\x00\x11\x00\x00\x00\x0d\x00\x00\x00\x17\x00\x00\x00\x20\x00\x00\x00\x17\x00\x00\x00\x11\x00\x00\x00\x12\x00\x00\x00\x13\x00\x00\x00\x14\x00\x00\x00\x15\x00\x00\x00\x16\x00\x00\x00\x12\x00\x00\x00\x13\x00\x00\x00\x03\x00\x00\x00\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x18\x00\x00\x00\x19\x00\x00\x00\x11\x00\x00\x00\x15\x00\x00\x00\x1c\x00\x00\x00\x10\x00\x00\x00\x0d\x00\x00\x00\x11\x00\x00\x00\x20\x00\x00\x00\xff\xff\xff\xff\x11\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x14\x00\x00\x00\x15\x00\x00\x00\x16\x00\x00\x00\x2d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2b\x00\x00\x00\x2c\x00\x00\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x0c\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\x00\x00\x13\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x0c\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\x00\x00\x13\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x0c\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\x00\x00\x13\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x0c\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\x00\x00\x13\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x0f\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\x00\x00\x13\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\x00\x00\x1f\x00\x00\x00\xff\xff\xff\xff\x21\x00\x00\x00\x22\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x0a\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\x00\x00\xff\xff\xff\xff\x0d\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\xff\xff\xff\xff\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x03\x00\x00\x00\xff\xff\xff\xff\x10\x00\x00\x00\xff\xff\xff\xff\x0d\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\x12\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\xff\xff\xff\xff\x21\x00\x00\x00\x22\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\xff\xff\xff\xff\x0d\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"#

    happyTable :: HappyAddr
    happyTable :: HappyAddr
    happyTable = Addr# -> HappyAddr
    HappyA# Addr#
    "\x00\x00\x00\x00\x17\x00\x00\x00\x55\x00\x00\x00\x56\x00\x00\x00\x18\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x03\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x57\x00\x00\x00\x31\x00\x00\x00\x51\x00\x00\x00\x3f\x00\x00\x00\x51\x00\x00\x00\x31\x00\x00\x00\x32\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x50\x00\x00\x00\x32\x00\x00\x00\xff\xff\xff\xff\x1b\x00\x00\x00\x1c\x00\x00\x00\x1d\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x20\x00\x00\x00\x21\x00\x00\x00\x28\x00\x00\x00\x5c\x00\x00\x00\x22\x00\x00\x00\x52\x00\x00\x00\x53\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\xe3\xff\xff\xff\xe3\xff\xff\xff\x26\x00\x00\x00\xe3\xff\xff\xff\x3c\x00\x00\x00\x03\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\xe3\xff\xff\xff\x58\x00\x00\x00\xe3\xff\xff\xff\xe3\xff\xff\xff\xe3\xff\xff\xff\xe3\xff\xff\xff\xe3\xff\xff\xff\x3b\x00\x00\x00\x3e\x00\x00\x00\xe3\xff\xff\xff\xe3\xff\xff\xff\xe3\xff\xff\xff\x03\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x51\x00\x00\x00\x51\x00\x00\x00\x3d\x00\x00\x00\x51\x00\x00\x00\xe3\xff\xff\xff\xe3\xff\xff\xff\x17\x00\x00\x00\xe3\xff\xff\xff\xe3\xff\xff\xff\x18\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x3f\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\xe3\xff\xff\xff\xe3\xff\xff\xff\x2e\x00\x00\x00\x5b\x00\x00\x00\x5a\x00\x00\x00\xe3\xff\xff\xff\x5f\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x34\x00\x00\x00\x3b\x00\x00\x00\x35\x00\x00\x00\x1b\x00\x00\x00\x1c\x00\x00\x00\x1d\x00\x00\x00\x1e\x00\x00\x00\x1f\x00\x00\x00\x20\x00\x00\x00\x21\x00\x00\x00\x17\x00\x00\x00\x3e\x00\x00\x00\x22\x00\x00\x00\x18\x00\x00\x00\x3d\x00\x00\x00\x23\x00\x00\x00\x24\x00\x00\x00\x25\x00\x00\x00\x3c\x00\x00\x00\x5e\x00\x00\x00\x26\x00\x00\x00\x63\x00\x00\x00\x61\x00\x00\x00\x03\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x41\x00\x00\x00\x62\x00\x00\x00\x64\x00\x00\x00\x32\x00\x00\x00\x1c\x00\x00\x00\x1d\x00\x00\x00\x3f\x00\x00\x00\x18\x00\x00\x00\x20\x00\x00\x00\x2f\x00\x00\x00\x42\x00\x00\x00\x35\x00\x00\x00\x22\x00\x00\x00\x35\x00\x00\x00\x43\x00\x00\x00\x55\x00\x00\x00\x56\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x46\x00\x00\x00\x19\x00\x00\x00\x1a\x00\x00\x00\x41\x00\x00\x00\x03\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x1c\x00\x00\x00\x1d\x00\x00\x00\x2f\x00\x00\x00\x3f\x00\x00\x00\x20\x00\x00\x00\x32\x00\x00\x00\x42\x00\x00\x00\x2f\x00\x00\x00\x22\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x00\x00\x45\x00\x00\x00\x46\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x0c\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x0f\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x0c\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x2a\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x0c\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x29\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x0c\x00\x00\x00\x0d\x00\x00\x00\x0e\x00\x00\x00\x28\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x0c\x00\x00\x00\x0d\x00\x00\x00\x4c\x00\x00\x00\x59\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x00\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x0c\x00\x00\x00\x2e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x0a\x00\x00\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\x09\x00\x00\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x08\x00\x00\x00\x48\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x07\x00\x00\x00\x47\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x06\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x00\x00\x37\x00\x00\x00\x38\x00\x00\x00\x00\x00\x00\x00\x39\x00\x00\x00\x3a\x00\x00\x00\x4d\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x4d\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x4d\x00\x00\x00\x04\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x11\x00\x00\x00\x5e\x00\x00\x00\x10\x00\x00\x00\x50\x00\x00\x00\x00\x00\x00\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#

    happyReduceArr :: Array
      Int
      (Int#
       -> Token
       -> Int#
       -> Happy_IntList
       -> HappyStk HappyAbsSyn
       -> [Token]
       -> Err HappyAbsSyn)
    happyReduceArr = (Int, Int)
    -> [(Int,
         Int#
         -> Token
         -> Int#
         -> Happy_IntList
         -> HappyStk HappyAbsSyn
         -> [Token]
         -> Err HappyAbsSyn)]
    -> Array
         Int
         (Int#
          -> Token
          -> Int#
          -> Happy_IntList
          -> HappyStk HappyAbsSyn
          -> [Token]
          -> Err HappyAbsSyn)
    forall i e. Ix i => (i, i) -> [(i, e)] -> Array i e
    Happy_Data_Array.array (Int
    1, Int
    67) [
            (Int
    1 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_1),
            (Int
    2 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_2),
            (Int
    3 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_3),
            (Int
    4 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_4),
            (Int
    5 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_5),
            (Int
    6 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_6),
            (Int
    7 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_7),
            (Int
    8 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_8),
            (Int
    9 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_9),
            (Int
    10 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_10),
            (Int
    11 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_11),
            (Int
    12 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_12),
            (Int
    13 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_13),
            (Int
    14 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_14),
            (Int
    15 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_15),
            (Int
    16 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_16),
            (Int
    17 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_17),
            (Int
    18 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_18),
            (Int
    19 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_19),
            (Int
    20 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_20),
            (Int
    21 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_21),
            (Int
    22 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_22),
            (Int
    23 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_23),
            (Int
    24 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_24),
            (Int
    25 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_25),
            (Int
    26 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_26),
            (Int
    27 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_27),
            (Int
    28 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_28),
            (Int
    29 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_29),
            (Int
    30 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_30),
            (Int
    31 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_31),
            (Int
    32 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_32),
            (Int
    33 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_33),
            (Int
    34 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_34),
            (Int
    35 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_35),
            (Int
    36 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_36),
            (Int
    37 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_37),
            (Int
    38 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_38),
            (Int
    39 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_39),
            (Int
    40 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_40),
            (Int
    41 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_41),
            (Int
    42 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_42),
            (Int
    43 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_43),
            (Int
    44 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_44),
            (Int
    45 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_45),
            (Int
    46 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_46),
            (Int
    47 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_47),
            (Int
    48 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_48),
            (Int
    49 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_49),
            (Int
    50 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_50),
            (Int
    51 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_51),
            (Int
    52 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_52),
            (Int
    53 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_53),
            (Int
    54 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_54),
            (Int
    55 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_55),
            (Int
    56 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_56),
            (Int
    57 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_57),
            (Int
    58 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_58),
            (Int
    59 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_59),
            (Int
    60 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_60),
            (Int
    61 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_61),
            (Int
    62 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_62),
            (Int
    63 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_63),
            (Int
    64 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_64),
            (Int
    65 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_65),
            (Int
    66 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_66),
            (Int
    67 , Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_67)
            ]

    happyRuleArr :: HappyAddr
    happyRuleArr :: HappyAddr
    happyRuleArr = Addr# -> HappyAddr
    HappyA# Addr#
    "\x00\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x01\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00\x01\x00\x00\x00\x03\x00\x00\x00\x03\x00\x00\x00\x03\x00\x00\x00\x03\x00\x00\x00\x03\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x03\x00\x00\x00\x04\x00\x00\x00\x01\x00\x00\x00\x05\x00\x00\x00\x02\x00\x00\x00\x05\x00\x00\x00\x01\x00\x00\x00\x06\x00\x00\x00\x03\x00\x00\x00\x06\x00\x00\x00\x01\x00\x00\x00\x07\x00\x00\x00\x03\x00\x00\x00\x07\x00\x00\x00\x01\x00\x00\x00\x08\x00\x00\x00\x03\x00\x00\x00\x08\x00\x00\x00\x01\x00\x00\x00\x09\x00\x00\x00\x03\x00\x00\x00\x09\x00\x00\x00\x01\x00\x00\x00\x0a\x00\x00\x00\x03\x00\x00\x00\x0a\x00\x00\x00\x01\x00\x00\x00\x0b\x00\x00\x00\x02\x00\x00\x00\x0b\x00\x00\x00\x01\x00\x00\x00\x0c\x00\x00\x00\x03\x00\x00\x00\x0c\x00\x00\x00\x01\x00\x00\x00\x0d\x00\x00\x00\x01\x00\x00\x00\x0d\x00\x00\x00\x01\x00\x00\x00\x0d\x00\x00\x00\x01\x00\x00\x00\x0d\x00\x00\x00\x03\x00\x00\x00\x0e\x00\x00\x00\x03\x00\x00\x00\x0e\x00\x00\x00\x01\x00\x00\x00\x0f\x00\x00\x00\x03\x00\x00\x00\x0f\x00\x00\x00\x01\x00\x00\x00\x10\x00\x00\x00\x01\x00\x00\x00\x10\x00\x00\x00\x01\x00\x00\x00\x11\x00\x00\x00\x01\x00\x00\x00\x11\x00\x00\x00\x01\x00\x00\x00\x12\x00\x00\x00\x01\x00\x00\x00\x12\x00\x00\x00\x01\x00\x00\x00\x12\x00\x00\x00\x01\x00\x00\x00\x12\x00\x00\x00\x01\x00\x00\x00\x13\x00\x00\x00\x01\x00\x00\x00\x13\x00\x00\x00\x05\x00\x00\x00\x13\x00\x00\x00\x06\x00\x00\x00\x14\x00\x00\x00\x01\x00\x00\x00\x14\x00\x00\x00\x03\x00\x00\x00\x14\x00\x00\x00\x03\x00\x00\x00\x15\x00\x00\x00\x01\x00\x00\x00\x15\x00\x00\x00\x01\x00\x00\x00\x15\x00\x00\x00\x01\x00\x00\x00\x15\x00\x00\x00\x01\x00\x00\x00\x15\x00\x00\x00\x01\x00\x00\x00\x15\x00\x00\x00\x01\x00\x00\x00\x16\x00\x00\x00\x01\x00\x00\x00\x16\x00\x00\x00\x01\x00\x00\x00\x16\x00\x00\x00\x01\x00\x00\x00\x16\x00\x00\x00\x01\x00\x00\x00\x16\x00\x00\x00\x01\x00\x00\x00\x16\x00\x00\x00\x01\x00\x00\x00\x16\x00\x00\x00\x01\x00\x00\x00\x16\x00\x00\x00\x01\x00\x00\x00\x17\x00\x00\x00\x01\x00\x00\x00\x17\x00\x00\x00\x01\x00\x00\x00\x17\x00\x00\x00\x01\x00\x00\x00\x17\x00\x00\x00\x01\x00\x00\x00"#

    happyCatchStates :: [Happy_Prelude.Int]
    happyCatchStates :: [Int]
    happyCatchStates = []

    happy_n_terms :: Int
    happy_n_terms = Int
    47 :: Happy_Prelude.Int
    happy_n_nonterms :: Int
    happy_n_nonterms = Int
    24 :: Happy_Prelude.Int

    happy_n_starts :: Int
    happy_n_starts = Int
    1 :: Happy_Prelude.Int

    happyReduce_1 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_1 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    0# HappyAbsSyn -> HappyAbsSyn
    happyReduction_1
    happyReduction_1 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_1 HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> Token
    happyOutTok HappyAbsSyn
    happy_x_1 of { (PT Posn
    _ (TV String
    happy_var_1)) ->
            Ident -> HappyAbsSyn
    happyIn5
                     (String -> Ident
    Language.SMV.AbsSMV.Ident String
    happy_var_1
            )}

    happyReduce_2 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_2 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    1# HappyAbsSyn -> HappyAbsSyn
    happyReduction_2
    happyReduction_2 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_2 HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> Token
    happyOutTok HappyAbsSyn
    happy_x_1 of { (PT Posn
    _ (TD String
    happy_var_1)) ->
            Double -> HappyAbsSyn
    happyIn6
                     ((String -> Double
    forall a. Read a => String -> a
    read String
    happy_var_1) :: Double
            )}

    happyReduce_3 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_3 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    2# HappyAbsSyn -> HappyAbsSyn
    happyReduction_3
    happyReduction_3 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_3 HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> Token
    happyOutTok HappyAbsSyn
    happy_x_1 of { (PT Posn
    _ (TI String
    happy_var_1)) ->
            Integer -> HappyAbsSyn
    happyIn7
                     ((String -> Integer
    forall a. Read a => String -> a
    read String
    happy_var_1) :: Integer
            )}

    happyReduce_4 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_4 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    3# HappyAbsSyn -> HappyAbsSyn
    happyReduction_4
    happyReduction_4 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_4 HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap5
    happyOut5 HappyAbsSyn
    happy_x_1 of { (HappyWrap5 Ident
    happy_var_1) ->
            BoolSpec -> HappyAbsSyn
    happyIn8
                     (Ident -> BoolSpec
    Language.SMV.AbsSMV.BoolSpecSignal Ident
    happy_var_1
            )}

    happyReduce_5 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_5 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    3# HappyAbsSyn -> HappyAbsSyn
    happyReduction_5
    happyReduction_5 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_5 HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap23
    happyOut23 HappyAbsSyn
    happy_x_1 of { (HappyWrap23 BoolConst
    happy_var_1) ->
            BoolSpec -> HappyAbsSyn
    happyIn8
                     (BoolConst -> BoolSpec
    Language.SMV.AbsSMV.BoolSpecConst BoolConst
    happy_var_1
            )}

    happyReduce_6 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_6 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    3# HappyAbsSyn -> HappyAbsSyn
    happyReduction_6
    happyReduction_6 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_6 HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap20
    happyOut20 HappyAbsSyn
    happy_x_1 of { (HappyWrap20 NumExpr
    happy_var_1) ->
            BoolSpec -> HappyAbsSyn
    happyIn8
                     (NumExpr -> BoolSpec
    Language.SMV.AbsSMV.BoolSpecNum NumExpr
    happy_var_1
            )}

    happyReduce_7 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_7 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_3  Int#
    3# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p} {p}. p -> HappyAbsSyn -> p -> HappyAbsSyn
    happyReduction_7
    happyReduction_7 :: p -> HappyAbsSyn -> p -> HappyAbsSyn
    happyReduction_7 p
    happy_x_3
            HappyAbsSyn
    happy_x_2
            p
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap17
    happyOut17 HappyAbsSyn
    happy_x_2 of { (HappyWrap17 BoolSpec
    happy_var_2) ->
            BoolSpec -> HappyAbsSyn
    happyIn8
                     (BoolSpec
    happy_var_2
            )}

    happyReduce_8 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_8 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_3  Int#
    3# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p} {p}. p -> HappyAbsSyn -> p -> HappyAbsSyn
    happyReduction_8
    happyReduction_8 :: p -> HappyAbsSyn -> p -> HappyAbsSyn
    happyReduction_8 p
    happy_x_3
            HappyAbsSyn
    happy_x_2
            p
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap17
    happyOut17 HappyAbsSyn
    happy_x_2 of { (HappyWrap17 BoolSpec
    happy_var_2) ->
            BoolSpec -> HappyAbsSyn
    happyIn8
                     (BoolSpec
    happy_var_2
            )}

    happyReduce_9 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_9 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_3  Int#
    3# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p} {p}. p -> HappyAbsSyn -> p -> HappyAbsSyn
    happyReduction_9
    happyReduction_9 :: p -> HappyAbsSyn -> p -> HappyAbsSyn
    happyReduction_9 p
    happy_x_3
            HappyAbsSyn
    happy_x_2
            p
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap17
    happyOut17 HappyAbsSyn
    happy_x_2 of { (HappyWrap17 BoolSpec
    happy_var_2) ->
            BoolSpec -> HappyAbsSyn
    happyIn8
                     (BoolSpec
    happy_var_2
            )}

    happyReduce_10 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_10 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_3  Int#
    4# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_10
    happyReduction_10 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_10 HappyAbsSyn
    happy_x_3
            HappyAbsSyn
    happy_x_2
            HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap9
    happyOut9 HappyAbsSyn
    happy_x_1 of { (HappyWrap9 BoolSpec
    happy_var_1) ->
            case HappyAbsSyn -> HappyWrap26
    happyOut26 HappyAbsSyn
    happy_x_2 of { (HappyWrap26 OrdOp
    happy_var_2) ->
            case HappyAbsSyn -> HappyWrap8
    happyOut8 HappyAbsSyn
    happy_x_3 of { (HappyWrap8 BoolSpec
    happy_var_3) ->
            BoolSpec -> HappyAbsSyn
    happyIn9
                     (BoolSpec -> OrdOp -> BoolSpec -> BoolSpec
    Language.SMV.AbsSMV.BoolSpecCmp BoolSpec
    happy_var_1 OrdOp
    happy_var_2 BoolSpec
    happy_var_3
            )}}}

    happyReduce_11 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_11 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    4# HappyAbsSyn -> HappyAbsSyn
    happyReduction_11
    happyReduction_11 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_11 HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap8
    happyOut8 HappyAbsSyn
    happy_x_1 of { (HappyWrap8 BoolSpec
    happy_var_1) ->
            BoolSpec -> HappyAbsSyn
    happyIn9
                     (BoolSpec
    happy_var_1
            )}

    happyReduce_12 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_12 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_2  Int#
    5# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p}. HappyAbsSyn -> p -> HappyAbsSyn
    happyReduction_12
    happyReduction_12 :: HappyAbsSyn -> p -> HappyAbsSyn
    happyReduction_12 HappyAbsSyn
    happy_x_2
            p
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap9
    happyOut9 HappyAbsSyn
    happy_x_2 of { (HappyWrap9 BoolSpec
    happy_var_2) ->
            BoolSpec -> HappyAbsSyn
    happyIn10
                     (BoolSpec -> BoolSpec
    Language.SMV.AbsSMV.BoolSpecNeg BoolSpec
    happy_var_2
            )}

    happyReduce_13 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_13 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    5# HappyAbsSyn -> HappyAbsSyn
    happyReduction_13
    happyReduction_13 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_13 HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap9
    happyOut9 HappyAbsSyn
    happy_x_1 of { (HappyWrap9 BoolSpec
    happy_var_1) ->
            BoolSpec -> HappyAbsSyn
    happyIn10
                     (BoolSpec
    happy_var_1
            )}

    happyReduce_14 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_14 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_3  Int#
    6# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p}. HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_14
    happyReduction_14 :: HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_14 HappyAbsSyn
    happy_x_3
            p
    happy_x_2
            HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap11
    happyOut11 HappyAbsSyn
    happy_x_1 of { (HappyWrap11 BoolSpec
    happy_var_1) ->
            case HappyAbsSyn -> HappyWrap10
    happyOut10 HappyAbsSyn
    happy_x_3 of { (HappyWrap10 BoolSpec
    happy_var_3) ->
            BoolSpec -> HappyAbsSyn
    happyIn11
                     (BoolSpec -> BoolSpec -> BoolSpec
    Language.SMV.AbsSMV.BoolSpecAnd BoolSpec
    happy_var_1 BoolSpec
    happy_var_3
            )}}

    happyReduce_15 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_15 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    6# HappyAbsSyn -> HappyAbsSyn
    happyReduction_15
    happyReduction_15 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_15 HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap10
    happyOut10 HappyAbsSyn
    happy_x_1 of { (HappyWrap10 BoolSpec
    happy_var_1) ->
            BoolSpec -> HappyAbsSyn
    happyIn11
                     (BoolSpec
    happy_var_1
            )}

    happyReduce_16 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_16 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_3  Int#
    7# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p}. HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_16
    happyReduction_16 :: HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_16 HappyAbsSyn
    happy_x_3
            p
    happy_x_2
            HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap12
    happyOut12 HappyAbsSyn
    happy_x_1 of { (HappyWrap12 BoolSpec
    happy_var_1) ->
            case HappyAbsSyn -> HappyWrap11
    happyOut11 HappyAbsSyn
    happy_x_3 of { (HappyWrap11 BoolSpec
    happy_var_3) ->
            BoolSpec -> HappyAbsSyn
    happyIn12
                     (BoolSpec -> BoolSpec -> BoolSpec
    Language.SMV.AbsSMV.BoolSpecOr BoolSpec
    happy_var_1 BoolSpec
    happy_var_3
            )}}

    happyReduce_17 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_17 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    7# HappyAbsSyn -> HappyAbsSyn
    happyReduction_17
    happyReduction_17 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_17 HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap11
    happyOut11 HappyAbsSyn
    happy_x_1 of { (HappyWrap11 BoolSpec
    happy_var_1) ->
            BoolSpec -> HappyAbsSyn
    happyIn12
                     (BoolSpec
    happy_var_1
            )}

    happyReduce_18 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_18 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_3  Int#
    8# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p}. HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_18
    happyReduction_18 :: HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_18 HappyAbsSyn
    happy_x_3
            p
    happy_x_2
            HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap13
    happyOut13 HappyAbsSyn
    happy_x_1 of { (HappyWrap13 BoolSpec
    happy_var_1) ->
            case HappyAbsSyn -> HappyWrap12
    happyOut12 HappyAbsSyn
    happy_x_3 of { (HappyWrap12 BoolSpec
    happy_var_3) ->
            BoolSpec -> HappyAbsSyn
    happyIn13
                     (BoolSpec -> BoolSpec -> BoolSpec
    Language.SMV.AbsSMV.BoolSpecXor BoolSpec
    happy_var_1 BoolSpec
    happy_var_3
            )}}

    happyReduce_19 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_19 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    8# HappyAbsSyn -> HappyAbsSyn
    happyReduction_19
    happyReduction_19 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_19 HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap12
    happyOut12 HappyAbsSyn
    happy_x_1 of { (HappyWrap12 BoolSpec
    happy_var_1) ->
            BoolSpec -> HappyAbsSyn
    happyIn13
                     (BoolSpec
    happy_var_1
            )}

    happyReduce_20 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_20 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_3  Int#
    9# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p}. HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_20
    happyReduction_20 :: HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_20 HappyAbsSyn
    happy_x_3
            p
    happy_x_2
            HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap14
    happyOut14 HappyAbsSyn
    happy_x_1 of { (HappyWrap14 BoolSpec
    happy_var_1) ->
            case HappyAbsSyn -> HappyWrap13
    happyOut13 HappyAbsSyn
    happy_x_3 of { (HappyWrap13 BoolSpec
    happy_var_3) ->
            BoolSpec -> HappyAbsSyn
    happyIn14
                     (BoolSpec -> BoolSpec -> BoolSpec
    Language.SMV.AbsSMV.BoolSpecImplies BoolSpec
    happy_var_1 BoolSpec
    happy_var_3
            )}}

    happyReduce_21 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_21 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    9# HappyAbsSyn -> HappyAbsSyn
    happyReduction_21
    happyReduction_21 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_21 HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap13
    happyOut13 HappyAbsSyn
    happy_x_1 of { (HappyWrap13 BoolSpec
    happy_var_1) ->
            BoolSpec -> HappyAbsSyn
    happyIn14
                     (BoolSpec
    happy_var_1
            )}

    happyReduce_22 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_22 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_3  Int#
    10# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p}. HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_22
    happyReduction_22 :: HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_22 HappyAbsSyn
    happy_x_3
            p
    happy_x_2
            HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap15
    happyOut15 HappyAbsSyn
    happy_x_1 of { (HappyWrap15 BoolSpec
    happy_var_1) ->
            case HappyAbsSyn -> HappyWrap14
    happyOut14 HappyAbsSyn
    happy_x_3 of { (HappyWrap14 BoolSpec
    happy_var_3) ->
            BoolSpec -> HappyAbsSyn
    happyIn15
                     (BoolSpec -> BoolSpec -> BoolSpec
    Language.SMV.AbsSMV.BoolSpecEquivs BoolSpec
    happy_var_1 BoolSpec
    happy_var_3
            )}}

    happyReduce_23 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_23 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    10# HappyAbsSyn -> HappyAbsSyn
    happyReduction_23
    happyReduction_23 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_23 HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap14
    happyOut14 HappyAbsSyn
    happy_x_1 of { (HappyWrap14 BoolSpec
    happy_var_1) ->
            BoolSpec -> HappyAbsSyn
    happyIn15
                     (BoolSpec
    happy_var_1
            )}

    happyReduce_24 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_24 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_2  Int#
    11# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_24
    happyReduction_24 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_24 HappyAbsSyn
    happy_x_2
            HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap24
    happyOut24 HappyAbsSyn
    happy_x_1 of { (HappyWrap24 OpOne
    happy_var_1) ->
            case HappyAbsSyn -> HappyWrap15
    happyOut15 HappyAbsSyn
    happy_x_2 of { (HappyWrap15 BoolSpec
    happy_var_2) ->
            BoolSpec -> HappyAbsSyn
    happyIn16
                     (OpOne -> BoolSpec -> BoolSpec
    Language.SMV.AbsSMV.BoolSpecOp1 OpOne
    happy_var_1 BoolSpec
    happy_var_2
            )}}

    happyReduce_25 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_25 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    11# HappyAbsSyn -> HappyAbsSyn
    happyReduction_25
    happyReduction_25 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_25 HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap15
    happyOut15 HappyAbsSyn
    happy_x_1 of { (HappyWrap15 BoolSpec
    happy_var_1) ->
            BoolSpec -> HappyAbsSyn
    happyIn16
                     (BoolSpec
    happy_var_1
            )}

    happyReduce_26 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_26 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_3  Int#
    12# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_26
    happyReduction_26 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_26 HappyAbsSyn
    happy_x_3
            HappyAbsSyn
    happy_x_2
            HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap17
    happyOut17 HappyAbsSyn
    happy_x_1 of { (HappyWrap17 BoolSpec
    happy_var_1) ->
            case HappyAbsSyn -> HappyWrap28
    happyOut28 HappyAbsSyn
    happy_x_2 of { (HappyWrap28 OpTwo
    happy_var_2) ->
            case HappyAbsSyn -> HappyWrap16
    happyOut16 HappyAbsSyn
    happy_x_3 of { (HappyWrap16 BoolSpec
    happy_var_3) ->
            BoolSpec -> HappyAbsSyn
    happyIn17
                     (BoolSpec -> OpTwo -> BoolSpec -> BoolSpec
    Language.SMV.AbsSMV.BoolSpecOp2 BoolSpec
    happy_var_1 OpTwo
    happy_var_2 BoolSpec
    happy_var_3
            )}}}

    happyReduce_27 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_27 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    12# HappyAbsSyn -> HappyAbsSyn
    happyReduction_27
    happyReduction_27 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_27 HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap16
    happyOut16 HappyAbsSyn
    happy_x_1 of { (HappyWrap16 BoolSpec
    happy_var_1) ->
            BoolSpec -> HappyAbsSyn
    happyIn17
                     (BoolSpec
    happy_var_1
            )}

    happyReduce_28 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_28 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    13# HappyAbsSyn -> HappyAbsSyn
    happyReduction_28
    happyReduction_28 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_28 HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap5
    happyOut5 HappyAbsSyn
    happy_x_1 of { (HappyWrap5 Ident
    happy_var_1) ->
            NumExpr -> HappyAbsSyn
    happyIn18
                     (Ident -> NumExpr
    Language.SMV.AbsSMV.NumId Ident
    happy_var_1
            )}

    happyReduce_29 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_29 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    13# HappyAbsSyn -> HappyAbsSyn
    happyReduction_29
    happyReduction_29 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_29 HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap7
    happyOut7 HappyAbsSyn
    happy_x_1 of { (HappyWrap7 Integer
    happy_var_1) ->
            NumExpr -> HappyAbsSyn
    happyIn18
                     (Integer -> NumExpr
    Language.SMV.AbsSMV.NumConstI Integer
    happy_var_1
            )}

    happyReduce_30 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_30 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    13# HappyAbsSyn -> HappyAbsSyn
    happyReduction_30
    happyReduction_30 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_30 HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap6
    happyOut6 HappyAbsSyn
    happy_x_1 of { (HappyWrap6 Double
    happy_var_1) ->
            NumExpr -> HappyAbsSyn
    happyIn18
                     (Double -> NumExpr
    Language.SMV.AbsSMV.NumConstD Double
    happy_var_1
            )}

    happyReduce_31 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_31 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_3  Int#
    13# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p} {p}. p -> HappyAbsSyn -> p -> HappyAbsSyn
    happyReduction_31
    happyReduction_31 :: p -> HappyAbsSyn -> p -> HappyAbsSyn
    happyReduction_31 p
    happy_x_3
            HappyAbsSyn
    happy_x_2
            p
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap20
    happyOut20 HappyAbsSyn
    happy_x_2 of { (HappyWrap20 NumExpr
    happy_var_2) ->
            NumExpr -> HappyAbsSyn
    happyIn18
                     (NumExpr
    happy_var_2
            )}

    happyReduce_32 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_32 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_3  Int#
    14# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_32
    happyReduction_32 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_32 HappyAbsSyn
    happy_x_3
            HappyAbsSyn
    happy_x_2
            HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap19
    happyOut19 HappyAbsSyn
    happy_x_1 of { (HappyWrap19 NumExpr
    happy_var_1) ->
            case HappyAbsSyn -> HappyWrap21
    happyOut21 HappyAbsSyn
    happy_x_2 of { (HappyWrap21 AdditiveOp
    happy_var_2) ->
            case HappyAbsSyn -> HappyWrap18
    happyOut18 HappyAbsSyn
    happy_x_3 of { (HappyWrap18 NumExpr
    happy_var_3) ->
            NumExpr -> HappyAbsSyn
    happyIn19
                     (NumExpr -> AdditiveOp -> NumExpr -> NumExpr
    Language.SMV.AbsSMV.NumAdd NumExpr
    happy_var_1 AdditiveOp
    happy_var_2 NumExpr
    happy_var_3
            )}}}

    happyReduce_33 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_33 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    14# HappyAbsSyn -> HappyAbsSyn
    happyReduction_33
    happyReduction_33 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_33 HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap18
    happyOut18 HappyAbsSyn
    happy_x_1 of { (HappyWrap18 NumExpr
    happy_var_1) ->
            NumExpr -> HappyAbsSyn
    happyIn19
                     (NumExpr
    happy_var_1
            )}

    happyReduce_34 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_34 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_3  Int#
    15# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_34
    happyReduction_34 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    happyReduction_34 HappyAbsSyn
    happy_x_3
            HappyAbsSyn
    happy_x_2
            HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap20
    happyOut20 HappyAbsSyn
    happy_x_1 of { (HappyWrap20 NumExpr
    happy_var_1) ->
            case HappyAbsSyn -> HappyWrap22
    happyOut22 HappyAbsSyn
    happy_x_2 of { (HappyWrap22 MultOp
    happy_var_2) ->
            case HappyAbsSyn -> HappyWrap19
    happyOut19 HappyAbsSyn
    happy_x_3 of { (HappyWrap19 NumExpr
    happy_var_3) ->
            NumExpr -> HappyAbsSyn
    happyIn20
                     (NumExpr -> MultOp -> NumExpr -> NumExpr
    Language.SMV.AbsSMV.NumMult NumExpr
    happy_var_1 MultOp
    happy_var_2 NumExpr
    happy_var_3
            )}}}

    happyReduce_35 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_35 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    15# HappyAbsSyn -> HappyAbsSyn
    happyReduction_35
    happyReduction_35 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_35 HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap19
    happyOut19 HappyAbsSyn
    happy_x_1 of { (HappyWrap19 NumExpr
    happy_var_1) ->
            NumExpr -> HappyAbsSyn
    happyIn20
                     (NumExpr
    happy_var_1
            )}

    happyReduce_36 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_36 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    16# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_36
    happyReduction_36 :: p -> HappyAbsSyn
    happyReduction_36 p
    happy_x_1
             =  AdditiveOp -> HappyAbsSyn
    happyIn21
                     (AdditiveOp
    Language.SMV.AbsSMV.OpPlus
            )

    happyReduce_37 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_37 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    16# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_37
    happyReduction_37 :: p -> HappyAbsSyn
    happyReduction_37 p
    happy_x_1
             =  AdditiveOp -> HappyAbsSyn
    happyIn21
                     (AdditiveOp
    Language.SMV.AbsSMV.OpMinus
            )

    happyReduce_38 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_38 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    17# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_38
    happyReduction_38 :: p -> HappyAbsSyn
    happyReduction_38 p
    happy_x_1
             =  MultOp -> HappyAbsSyn
    happyIn22
                     (MultOp
    Language.SMV.AbsSMV.OpTimes
            )

    happyReduce_39 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_39 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    17# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_39
    happyReduction_39 :: p -> HappyAbsSyn
    happyReduction_39 p
    happy_x_1
             =  MultOp -> HappyAbsSyn
    happyIn22
                     (MultOp
    Language.SMV.AbsSMV.OpDiv
            )

    happyReduce_40 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_40 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    18# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_40
    happyReduction_40 :: p -> HappyAbsSyn
    happyReduction_40 p
    happy_x_1
             =  BoolConst -> HappyAbsSyn
    happyIn23
                     (BoolConst
    Language.SMV.AbsSMV.BoolConstTrue
            )

    happyReduce_41 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_41 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    18# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_41
    happyReduction_41 :: p -> HappyAbsSyn
    happyReduction_41 p
    happy_x_1
             =  BoolConst -> HappyAbsSyn
    happyIn23
                     (BoolConst
    Language.SMV.AbsSMV.BoolConstFalse
            )

    happyReduce_42 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_42 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    18# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_42
    happyReduction_42 :: p -> HappyAbsSyn
    happyReduction_42 p
    happy_x_1
             =  BoolConst -> HappyAbsSyn
    happyIn23
                     (BoolConst
    Language.SMV.AbsSMV.BoolConstFTP
            )

    happyReduce_43 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_43 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    18# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_43
    happyReduction_43 :: p -> HappyAbsSyn
    happyReduction_43 p
    happy_x_1
             =  BoolConst -> HappyAbsSyn
    happyIn23
                     (BoolConst
    Language.SMV.AbsSMV.BoolConstLAST
            )

    happyReduce_44 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_44 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    19# HappyAbsSyn -> HappyAbsSyn
    happyReduction_44
    happyReduction_44 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_44 HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap27
    happyOut27 HappyAbsSyn
    happy_x_1 of { (HappyWrap27 Op1Name
    happy_var_1) ->
            OpOne -> HappyAbsSyn
    happyIn24
                     (Op1Name -> OpOne
    Language.SMV.AbsSMV.Op1Alone Op1Name
    happy_var_1
            )}

    happyReduce_45 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_45 = Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce Int#
    5# Int#
    19# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    happyReduction_45
    happyReduction_45 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    happyReduction_45 (HappyAbsSyn
    happy_x_5 `HappyStk`
            HappyAbsSyn
    happy_x_4 `HappyStk`
            HappyAbsSyn
    happy_x_3 `HappyStk`
            HappyAbsSyn
    happy_x_2 `HappyStk`
            HappyAbsSyn
    happy_x_1 `HappyStk`
            HappyStk HappyAbsSyn
    happyRest)
             = case HappyAbsSyn -> HappyWrap27
    happyOut27 HappyAbsSyn
    happy_x_1 of { (HappyWrap27 Op1Name
    happy_var_1) ->
            case HappyAbsSyn -> HappyWrap26
    happyOut26 HappyAbsSyn
    happy_x_3 of { (HappyWrap26 OrdOp
    happy_var_3) ->
            case HappyAbsSyn -> HappyWrap25
    happyOut25 HappyAbsSyn
    happy_x_4 of { (HappyWrap25 Number
    happy_var_4) ->
            OpOne -> HappyAbsSyn
    happyIn24
                     (Op1Name -> OrdOp -> Number -> OpOne
    Language.SMV.AbsSMV.Op1MTL Op1Name
    happy_var_1 OrdOp
    happy_var_3 Number
    happy_var_4
            ) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    forall a. a -> HappyStk a -> HappyStk a
    `HappyStk` HappyStk HappyAbsSyn
    happyRest}}}

    happyReduce_46 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_46 = Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce Int#
    6# Int#
    19# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    happyReduction_46
    happyReduction_46 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    happyReduction_46 (HappyAbsSyn
    happy_x_6 `HappyStk`
            HappyAbsSyn
    happy_x_5 `HappyStk`
            HappyAbsSyn
    happy_x_4 `HappyStk`
            HappyAbsSyn
    happy_x_3 `HappyStk`
            HappyAbsSyn
    happy_x_2 `HappyStk`
            HappyAbsSyn
    happy_x_1 `HappyStk`
            HappyStk HappyAbsSyn
    happyRest)
             = case HappyAbsSyn -> HappyWrap27
    happyOut27 HappyAbsSyn
    happy_x_1 of { (HappyWrap27 Op1Name
    happy_var_1) ->
            case HappyAbsSyn -> HappyWrap25
    happyOut25 HappyAbsSyn
    happy_x_3 of { (HappyWrap25 Number
    happy_var_3) ->
            case HappyAbsSyn -> HappyWrap25
    happyOut25 HappyAbsSyn
    happy_x_5 of { (HappyWrap25 Number
    happy_var_5) ->
            OpOne -> HappyAbsSyn
    happyIn24
                     (Op1Name -> Number -> Number -> OpOne
    Language.SMV.AbsSMV.Op1MTLRange Op1Name
    happy_var_1 Number
    happy_var_3 Number
    happy_var_5
            ) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    forall a. a -> HappyStk a -> HappyStk a
    `HappyStk` HappyStk HappyAbsSyn
    happyRest}}}

    happyReduce_47 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_47 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    20# HappyAbsSyn -> HappyAbsSyn
    happyReduction_47
    happyReduction_47 :: HappyAbsSyn -> HappyAbsSyn
    happyReduction_47 HappyAbsSyn
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap7
    happyOut7 HappyAbsSyn
    happy_x_1 of { (HappyWrap7 Integer
    happy_var_1) ->
            Number -> HappyAbsSyn
    happyIn25
                     (Integer -> Number
    Language.SMV.AbsSMV.NumberInt Integer
    happy_var_1
            )}

    happyReduce_48 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_48 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_3  Int#
    20# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p} {p}. p -> HappyAbsSyn -> p -> HappyAbsSyn
    happyReduction_48
    happyReduction_48 :: p -> HappyAbsSyn -> p -> HappyAbsSyn
    happyReduction_48 p
    happy_x_3
            HappyAbsSyn
    happy_x_2
            p
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap25
    happyOut25 HappyAbsSyn
    happy_x_2 of { (HappyWrap25 Number
    happy_var_2) ->
            Number -> HappyAbsSyn
    happyIn25
                     (Number
    happy_var_2
            )}

    happyReduce_49 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_49 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_3  Int#
    20# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    forall {p} {p}. p -> HappyAbsSyn -> p -> HappyAbsSyn
    happyReduction_49
    happyReduction_49 :: p -> HappyAbsSyn -> p -> HappyAbsSyn
    happyReduction_49 p
    happy_x_3
            HappyAbsSyn
    happy_x_2
            p
    happy_x_1
             =  case HappyAbsSyn -> HappyWrap25
    happyOut25 HappyAbsSyn
    happy_x_2 of { (HappyWrap25 Number
    happy_var_2) ->
            Number -> HappyAbsSyn
    happyIn25
                     (Number
    happy_var_2
            )}

    happyReduce_50 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_50 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    21# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_50
    happyReduction_50 :: p -> HappyAbsSyn
    happyReduction_50 p
    happy_x_1
             =  OrdOp -> HappyAbsSyn
    happyIn26
                     (OrdOp
    Language.SMV.AbsSMV.OrdOpLT
            )

    happyReduce_51 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_51 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    21# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_51
    happyReduction_51 :: p -> HappyAbsSyn
    happyReduction_51 p
    happy_x_1
             =  OrdOp -> HappyAbsSyn
    happyIn26
                     (OrdOp
    Language.SMV.AbsSMV.OrdOpLE
            )

    happyReduce_52 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_52 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    21# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_52
    happyReduction_52 :: p -> HappyAbsSyn
    happyReduction_52 p
    happy_x_1
             =  OrdOp -> HappyAbsSyn
    happyIn26
                     (OrdOp
    Language.SMV.AbsSMV.OrdOpEQ
            )

    happyReduce_53 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_53 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    21# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_53
    happyReduction_53 :: p -> HappyAbsSyn
    happyReduction_53 p
    happy_x_1
             =  OrdOp -> HappyAbsSyn
    happyIn26
                     (OrdOp
    Language.SMV.AbsSMV.OrdOpNE
            )

    happyReduce_54 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_54 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    21# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_54
    happyReduction_54 :: p -> HappyAbsSyn
    happyReduction_54 p
    happy_x_1
             =  OrdOp -> HappyAbsSyn
    happyIn26
                     (OrdOp
    Language.SMV.AbsSMV.OrdOpGT
            )

    happyReduce_55 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_55 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    21# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_55
    happyReduction_55 :: p -> HappyAbsSyn
    happyReduction_55 p
    happy_x_1
             =  OrdOp -> HappyAbsSyn
    happyIn26
                     (OrdOp
    Language.SMV.AbsSMV.OrdOpGE
            )

    happyReduce_56 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_56 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    22# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_56
    happyReduction_56 :: p -> HappyAbsSyn
    happyReduction_56 p
    happy_x_1
             =  Op1Name -> HappyAbsSyn
    happyIn27
                     (Op1Name
    Language.SMV.AbsSMV.Op1Pre
            )

    happyReduce_57 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_57 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    22# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_57
    happyReduction_57 :: p -> HappyAbsSyn
    happyReduction_57 p
    happy_x_1
             =  Op1Name -> HappyAbsSyn
    happyIn27
                     (Op1Name
    Language.SMV.AbsSMV.Op1X
            )

    happyReduce_58 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_58 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    22# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_58
    happyReduction_58 :: p -> HappyAbsSyn
    happyReduction_58 p
    happy_x_1
             =  Op1Name -> HappyAbsSyn
    happyIn27
                     (Op1Name
    Language.SMV.AbsSMV.Op1G
            )

    happyReduce_59 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_59 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    22# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_59
    happyReduction_59 :: p -> HappyAbsSyn
    happyReduction_59 p
    happy_x_1
             =  Op1Name -> HappyAbsSyn
    happyIn27
                     (Op1Name
    Language.SMV.AbsSMV.Op1F
            )

    happyReduce_60 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_60 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    22# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_60
    happyReduction_60 :: p -> HappyAbsSyn
    happyReduction_60 p
    happy_x_1
             =  Op1Name -> HappyAbsSyn
    happyIn27
                     (Op1Name
    Language.SMV.AbsSMV.Op1Y
            )

    happyReduce_61 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_61 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    22# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_61
    happyReduction_61 :: p -> HappyAbsSyn
    happyReduction_61 p
    happy_x_1
             =  Op1Name -> HappyAbsSyn
    happyIn27
                     (Op1Name
    Language.SMV.AbsSMV.Op1Z
            )

    happyReduce_62 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_62 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    22# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_62
    happyReduction_62 :: p -> HappyAbsSyn
    happyReduction_62 p
    happy_x_1
             =  Op1Name -> HappyAbsSyn
    happyIn27
                     (Op1Name
    Language.SMV.AbsSMV.Op1Hist
            )

    happyReduce_63 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_63 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    22# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_63
    happyReduction_63 :: p -> HappyAbsSyn
    happyReduction_63 p
    happy_x_1
             =  Op1Name -> HappyAbsSyn
    happyIn27
                     (Op1Name
    Language.SMV.AbsSMV.Op1O
            )

    happyReduce_64 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_64 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    23# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_64
    happyReduction_64 :: p -> HappyAbsSyn
    happyReduction_64 p
    happy_x_1
             =  OpTwo -> HappyAbsSyn
    happyIn28
                     (OpTwo
    Language.SMV.AbsSMV.Op2S
            )

    happyReduce_65 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_65 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    23# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_65
    happyReduction_65 :: p -> HappyAbsSyn
    happyReduction_65 p
    happy_x_1
             =  OpTwo -> HappyAbsSyn
    happyIn28
                     (OpTwo
    Language.SMV.AbsSMV.Op2T
            )

    happyReduce_66 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_66 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    23# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_66
    happyReduction_66 :: p -> HappyAbsSyn
    happyReduction_66 p
    happy_x_1
             =  OpTwo -> HappyAbsSyn
    happyIn28
                     (OpTwo
    Language.SMV.AbsSMV.Op2V
            )

    happyReduce_67 :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce_67 = Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1  Int#
    23# HappyAbsSyn -> HappyAbsSyn
    forall {p}. p -> HappyAbsSyn
    happyReduction_67
    happyReduction_67 :: p -> HappyAbsSyn
    happyReduction_67 p
    happy_x_1
             =  OpTwo -> HappyAbsSyn
    happyIn28
                     (OpTwo
    Language.SMV.AbsSMV.Op2U
            )

    happyTerminalToTok :: Token -> Int#
    happyTerminalToTok Token
    term = case Token
    term of {
            PT Posn
    _ (TS String
    _ Int
    1) -> Int#
    2#;
            PT Posn
    _ (TS String
    _ Int
    2) -> Int#
    3#;
            PT Posn
    _ (TS String
    _ Int
    3) -> Int#
    4#;
            PT Posn
    _ (TS String
    _ Int
    4) -> Int#
    5#;
            PT Posn
    _ (TS String
    _ Int
    5) -> Int#
    6#;
            PT Posn
    _ (TS String
    _ Int
    6) -> Int#
    7#;
            PT Posn
    _ (TS String
    _ Int
    7) -> Int#
    8#;
            PT Posn
    _ (TS String
    _ Int
    8) -> Int#
    9#;
            PT Posn
    _ (TS String
    _ Int
    9) -> Int#
    10#;
            PT Posn
    _ (TS String
    _ Int
    10) -> Int#
    11#;
            PT Posn
    _ (TS String
    _ Int
    11) -> Int#
    12#;
            PT Posn
    _ (TS String
    _ Int
    12) -> Int#
    13#;
            PT Posn
    _ (TS String
    _ Int
    13) -> Int#
    14#;
            PT Posn
    _ (TS String
    _ Int
    14) -> Int#
    15#;
            PT Posn
    _ (TS String
    _ Int
    15) -> Int#
    16#;
            PT Posn
    _ (TS String
    _ Int
    16) -> Int#
    17#;
            PT Posn
    _ (TS String
    _ Int
    17) -> Int#
    18#;
            PT Posn
    _ (TS String
    _ Int
    18) -> Int#
    19#;
            PT Posn
    _ (TS String
    _ Int
    19) -> Int#
    20#;
            PT Posn
    _ (TS String
    _ Int
    20) -> Int#
    21#;
            PT Posn
    _ (TS String
    _ Int
    21) -> Int#
    22#;
            PT Posn
    _ (TS String
    _ Int
    22) -> Int#
    23#;
            PT Posn
    _ (TS String
    _ Int
    23) -> Int#
    24#;
            PT Posn
    _ (TS String
    _ Int
    24) -> Int#
    25#;
            PT Posn
    _ (TS String
    _ Int
    25) -> Int#
    26#;
            PT Posn
    _ (TS String
    _ Int
    26) -> Int#
    27#;
            PT Posn
    _ (TS String
    _ Int
    27) -> Int#
    28#;
            PT Posn
    _ (TS String
    _ Int
    28) -> Int#
    29#;
            PT Posn
    _ (TS String
    _ Int
    29) -> Int#
    30#;
            PT Posn
    _ (TS String
    _ Int
    30) -> Int#
    31#;
            PT Posn
    _ (TS String
    _ Int
    31) -> Int#
    32#;
            PT Posn
    _ (TS String
    _ Int
    32) -> Int#
    33#;
            PT Posn
    _ (TS String
    _ Int
    33) -> Int#
    34#;
            PT Posn
    _ (TS String
    _ Int
    34) -> Int#
    35#;
            PT Posn
    _ (TS String
    _ Int
    35) -> Int#
    36#;
            PT Posn
    _ (TS String
    _ Int
    36) -> Int#
    37#;
            PT Posn
    _ (TS String
    _ Int
    37) -> Int#
    38#;
            PT Posn
    _ (TS String
    _ Int
    38) -> Int#
    39#;
            PT Posn
    _ (TS String
    _ Int
    39) -> Int#
    40#;
            PT Posn
    _ (TS String
    _ Int
    40) -> Int#
    41#;
            PT Posn
    _ (TS String
    _ Int
    41) -> Int#
    42#;
            PT Posn
    _ (TV String
    happy_dollar_dollar) -> Int#
    43#;
            PT Posn
    _ (TD String
    happy_dollar_dollar) -> Int#
    44#;
            PT Posn
    _ (TI String
    happy_dollar_dollar) -> Int#
    45#;
            Token
    _ -> Int#
    -1#;
            }
    {-# NOINLINE happyTerminalToTok #-}

    happyLex :: (t -> [a] -> t) -> (Int# -> Token -> [Token] -> t) -> [Token] -> t
    happyLex t -> [a] -> t
    kend  Int# -> Token -> [Token] -> t
    _kmore []       = t -> [a] -> t
    kend t
    forall a. a
    notHappyAtAll []
    happyLex t -> [a] -> t
    _kend Int# -> Token -> [Token] -> t
    kmore  (Token
    tk:[Token]
    tks) = Int# -> Token -> [Token] -> t
    kmore (Token -> Int#
    happyTerminalToTok Token
    tk) Token
    tk [Token]
    tks
    {-# INLINE happyLex #-}

    happyNewToken :: Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyNewToken Int#
    action Happy_IntList
    sts HappyStk HappyAbsSyn
    stk = (ZonkAny 0 -> [Token] -> Err HappyAbsSyn)
    -> (Int# -> Token -> [Token] -> Err HappyAbsSyn)
    -> [Token]
    -> Err HappyAbsSyn
    forall {t} {a} {t}.
    (t -> [a] -> t) -> (Int# -> Token -> [Token] -> t) -> [Token] -> t
    happyLex (\ZonkAny 0
    tk -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyDoAction Int#
    46# Token
    forall a. a
    notHappyAtAll Int#
    action Happy_IntList
    sts HappyStk HappyAbsSyn
    stk) (\Int#
    i Token
    tk -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyDoAction Int#
    i Token
    tk Int#
    action Happy_IntList
    sts HappyStk HappyAbsSyn
    stk)

    happyReport :: Int# -> Token -> [String] -> ([Token] -> Err a) -> [Token] -> Err a
    happyReport Int#
    46# Token
    tk [String]
    explist [Token] -> Err a
    resume [Token]
    tks = [Token] -> [String] -> ([Token] -> Err a) -> Err a
    forall a. [Token] -> [String] -> ([Token] -> Err a) -> Err a
    happyReport' [Token]
    tks [String]
    explist [Token] -> Err a
    resume
    happyReport Int#
    _ Token
    tk [String]
    explist [Token] -> Err a
    resume [Token]
    tks = [Token] -> [String] -> ([Token] -> Err a) -> Err a
    forall a. [Token] -> [String] -> ([Token] -> Err a) -> Err a
    happyReport' (Token
    tkToken -> [Token] -> [Token]
    forall a. a -> [a] -> [a]
    :[Token]
    tks) [String]
    explist (\[Token]
    tks -> [Token] -> Err a
    resume ([Token] -> [Token]
    forall a. HasCallStack => [a] -> [a]
    Happy_Prelude.tail [Token]
    tks))

    happyThen :: () => (Err a) -> (a -> (Err b)) -> (Err b)
    happyThen :: forall a b. Err a -> (a -> Err b) -> Err b
    happyThen = (Either String a -> (a -> Either String b) -> Either String b
    forall a b. Err a -> (a -> Err b) -> Err b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    (>>=))
    happyReturn :: () => a -> (Err a)
    happyReturn :: forall a. a -> Err a
    happyReturn = (a -> Either String a
    forall a. a -> Err a
    forall (m :: * -> *) a. Monad m => a -> m a
    return)
    happyThen1 :: m t -> (t -> t -> m b) -> t -> m b
    happyThen1 m t
    m t -> t -> m b
    k t
    tks = (forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    (>>=)) m t
    m (\t
    a -> t -> t -> m b
    k t
    a t
    tks)
    happyFmap1 :: (t -> b) -> (t -> Err t) -> t -> Err b
    happyFmap1 t -> b
    f t -> Err t
    m t
    tks = Err t -> (t -> Err b) -> Err b
    forall a b. Err a -> (a -> Err b) -> Err b
    happyThen (t -> Err t
    m t
    tks) (\t
    a -> b -> Err b
    forall a. a -> Err a
    happyReturn (t -> b
    f t
    a))
    happyReturn1 :: () => a -> b -> (Err a)
    happyReturn1 :: forall a b. a -> b -> Err a
    happyReturn1 = \a
    a b
    tks -> (forall (m :: * -> *) a. Monad m => a -> m a
    return) a
    a
    happyReport' :: () => [(Token)] -> [Happy_Prelude.String] -> ([(Token)] -> (Err a)) -> (Err a)
    happyReport' :: forall a. [Token] -> [String] -> ([Token] -> Err a) -> Err a
    happyReport' = (\[Token]
    tokens [String]
    expected [Token] -> Err a
    resume -> [Token] -> Err a
    forall a. [Token] -> Err a
    happyError [Token]
    tokens)

    happyAbort :: () => [(Token)] -> (Err a)
    happyAbort :: forall a. [Token] -> Err a
    happyAbort = String -> [Token] -> Err a
    forall a. HasCallStack => String -> a
    Happy_Prelude.error String
    "Called abort handler in non-resumptive parser"

    pBoolSpec :: [Token] -> Err BoolSpec
    pBoolSpec [Token]
    tks = Err BoolSpec
    happySomeParser where
     happySomeParser :: Err BoolSpec
    happySomeParser = Err HappyAbsSyn -> (HappyAbsSyn -> Err BoolSpec) -> Err BoolSpec
    forall a b. Err a -> (a -> Err b) -> Err b
    happyThen (Int# -> [Token] -> Err HappyAbsSyn
    happyDoParse Int#
    0# [Token]
    tks) (\HappyAbsSyn
    x -> BoolSpec -> Err BoolSpec
    forall a. a -> Err a
    happyReturn (let {(HappyWrap17 BoolSpec
    x') = HappyAbsSyn -> HappyWrap17
    happyOut17 HappyAbsSyn
    x} in BoolSpec
    x'))

    happySeq :: a -> b -> b
    happySeq = a -> b -> b
    forall a b. a -> b -> b
    happyDontSeq

    type Err = Either String

    happyError :: [Token] -> Err a
    happyError :: forall a. [Token] -> Err a
    happyError [Token]
    ts = String -> Either String a
    forall a b. a -> Either a b
    Left (String -> Either String a) -> String -> Either String a
    forall a b. (a -> b) -> a -> b
    $
      String
    "syntax error at " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ [Token] -> String
    tokenPos [Token]
    ts String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++
      case [Token]
    ts of
        []      -> []
        [Err Posn
    _] -> String
    " due to lexer error"
        Token
    t:[Token]
    _     -> String
    " before `" String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ (Token -> String
    prToken Token
    t) String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    "'"

    myLexer :: String -> [Token]
    myLexer :: String -> [Token]
    myLexer = String -> [Token]
    tokens
    #define HAPPY_COERCE 1
    -- $Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp $

    #if !defined(__GLASGOW_HASKELL__)
    #  error This code isn't being built with GHC.
    #endif

    -- Get WORDS_BIGENDIAN (if defined)
    #include "MachDeps.h"

    -- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.
    #define LT(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.<# m)) :: Happy_Prelude.Bool)
    #define GTE(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.>=# m)) :: Happy_Prelude.Bool)
    #define EQ(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.==# m)) :: Happy_Prelude.Bool)
    #define PLUS(n,m) (n Happy_GHC_Exts.+# m)
    #define MINUS(n,m) (n Happy_GHC_Exts.-# m)
    #define TIMES(n,m) (n Happy_GHC_Exts.*# m)
    #define NEGATE(n) (Happy_GHC_Exts.negateInt# (n))

    type Happy_Int = Happy_GHC_Exts.Int#
    data Happy_IntList = HappyCons Happy_Int Happy_IntList

    #define INVALID_TOK -1#
    #define ERROR_TOK 0#
    #define CATCH_TOK 1#

    #if defined(HAPPY_COERCE)
    #  define GET_ERROR_TOKEN(x)  (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# i) -> i })
    #  define MK_ERROR_TOKEN(i)   (Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# i))
    #  define MK_TOKEN(x)         (happyInTok (x))
    #else
    #  define GET_ERROR_TOKEN(x)  (case x of { HappyErrorToken (Happy_GHC_Exts.I# i) -> i })
    #  define MK_ERROR_TOKEN(i)   (HappyErrorToken (Happy_GHC_Exts.I# i))
    #  define MK_TOKEN(x)         (HappyTerminal (x))
    #endif

    #if defined(HAPPY_DEBUG)
    #  define DEBUG_TRACE(s)    (happyTrace (s)) Happy_Prelude.$
    happyTrace string expr = Happy_System_IO_Unsafe.unsafePerformIO Happy_Prelude.$ do
        Happy_System_IO.hPutStr Happy_System_IO.stderr string
        Happy_Prelude.return expr
    #else
    #  define DEBUG_TRACE(s)    {- nothing -}
    #endif

    infixr 9 `HappyStk`
    data HappyStk a = HappyStk a (HappyStk a)

    -----------------------------------------------------------------------------
    -- starting the parse

    happyDoParse :: Int# -> [Token] -> Err HappyAbsSyn
    happyDoParse Int#
    start_state = Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyNewToken Int#
    start_state Happy_IntList
    forall a. a
    notHappyAtAll HappyStk HappyAbsSyn
    forall a. a
    notHappyAtAll

    -----------------------------------------------------------------------------
    -- Accepting the parse

    -- If the current token is ERROR_TOK, it means we've just accepted a partial
    -- parse (a %partial parser).  We must ignore the saved token on the top of
    -- the stack in this case.
    happyAccept :: Int# -> p -> Int# -> p -> HappyStk a -> b -> Err a
    happyAccept ERROR_TOK tk st sts (_ `HappyStk` ans `HappyStk` _) =
            happyReturn1 ans
    happyAccept Int#
    j p
    tk Int#
    st p
    sts (HappyStk a
    ans HappyStk a
    _) =
            (Int# -> ((b -> Err a) -> b -> Err a) -> (b -> Err a) -> b -> Err a
    forall a. Int# -> a -> a
    happyTcHack Int#
    j (Int# -> (b -> Err a) -> b -> Err a
    forall a. Int# -> a -> a
    happyTcHack Int#
    st)) (a -> b -> Err a
    forall a b. a -> b -> Err a
    happyReturn1 a
    ans)

    -----------------------------------------------------------------------------
    -- Arrays only: do the next action

    happyDoAction :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyDoAction Int#
    i Token
    tk Int#
    st =
      DEBUG_TRACE("state: " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# st) Happy_Prelude.++
                  ",\ttoken: " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# i) Happy_Prelude.++
                  ",\taction: ")
      case Int# -> HappyAction
    happyDecodeAction (Int# -> Int# -> Int#
    happyNextAction Int#
    i Int#
    st) of
        HappyAction
    HappyFail             -> DEBUG_TRACE("failing.\n")
                                 Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyFail Int#
    i Token
    tk Int#
    st
        HappyAction
    HappyAccept           -> DEBUG_TRACE("accept.\n")
                                 Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    forall {p} {p} {a} {b}.
    Int# -> p -> Int# -> p -> HappyStk a -> b -> Err a
    happyAccept Int#
    i Token
    tk Int#
    st
        HappyReduce Int#
    rule      -> DEBUG_TRACE("reduce (rule " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# rule) Happy_Prelude.++ ")")
                                 (Array
      Int
      (Int#
       -> Token
       -> Int#
       -> Happy_IntList
       -> HappyStk HappyAbsSyn
       -> [Token]
       -> Err HappyAbsSyn)
    happyReduceArr Array
      Int
      (Int#
       -> Token
       -> Int#
       -> Happy_IntList
       -> HappyStk HappyAbsSyn
       -> [Token]
       -> Err HappyAbsSyn)
    -> Int
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    forall i e. Ix i => Array i e -> i -> e
    Happy_Data_Array.! (Int# -> Int
    Happy_GHC_Exts.I# Int#
    rule)) Int#
    i Token
    tk Int#
    st
        HappyShift  Int#
    new_state -> DEBUG_TRACE("shift, enter state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# new_state) Happy_Prelude.++ "\n")
                                 Int#
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyShift Int#
    new_state Int#
    i Token
    tk Int#
    st

    {-# INLINE happyNextAction #-}
    happyNextAction :: Int# -> Int# -> Int#
    happyNextAction Int#
    i Int#
    st = case Int# -> Int# -> Maybe Int
    happyIndexActionTable Int#
    i Int#
    st of
      Happy_Prelude.Just (Happy_GHC_Exts.I# Int#
    act) -> Int#
    act
      Maybe Int
    Happy_Prelude.Nothing                      -> HappyAddr -> Int# -> Int#
    happyIndexOffAddr HappyAddr
    happyDefActions Int#
    st

    {-# INLINE happyIndexActionTable #-}
    happyIndexActionTable :: Int# -> Int# -> Maybe Int
    happyIndexActionTable Int#
    i Int#
    st
      | GTE(i, 0#), GTE(off, 0#), EQ(happyIndexOffAddr happyCheck off, i)
      -- i >= 0:   Guard against INVALID_TOK (do the default action, which ultimately errors)
      -- off >= 0: Otherwise it's a default action
      -- equality check: Ensure that the entry in the compressed array is owned by st
      = Int -> Maybe Int
    forall a. a -> Maybe a
    Happy_Prelude.Just (Int# -> Int
    Happy_GHC_Exts.I# (HappyAddr -> Int# -> Int#
    happyIndexOffAddr HappyAddr
    happyTable Int#
    off))
      | Bool
    Happy_Prelude.otherwise
      = Maybe Int
    forall a. Maybe a
    Happy_Prelude.Nothing
      where
        off :: Int#
    off = PLUS(happyIndexOffAddr happyActOffsets st, i)

    data HappyAction
      = HappyFail
      | HappyAccept
      | HappyReduce Happy_Int -- rule number
      | HappyShift Happy_Int  -- new state
      deriving Int -> HappyAction -> String -> String
    [HappyAction] -> String -> String
    HappyAction -> String
    (Int -> HappyAction -> String -> String)
    -> (HappyAction -> String)
    -> ([HappyAction] -> String -> String)
    -> Show HappyAction
    forall a.
    (Int -> a -> String -> String)
    -> (a -> String) -> ([a] -> String -> String) -> Show a
    $cshowsPrec :: Int -> HappyAction -> String -> String
    showsPrec :: Int -> HappyAction -> String -> String
    $cshow :: HappyAction -> String
    show :: HappyAction -> String
    $cshowList :: [HappyAction] -> String -> String
    showList :: [HappyAction] -> String -> String
    Happy_Prelude.Show

    {-# INLINE happyDecodeAction #-}
    happyDecodeAction :: Happy_Int -> HappyAction
    happyDecodeAction :: Int# -> HappyAction
    happyDecodeAction  Int#
    0#                        = HappyAction
    HappyFail
    happyDecodeAction Int#
    -1#                        = HappyAction
    HappyAccept
    happyDecodeAction Int#
    action | LT(action, 0#)    = HappyReduce NEGATE(PLUS(action, 1#))
                             | Bool
    Happy_Prelude.otherwise = Int# -> HappyAction
    HappyShift MINUS(action, 1#)

    {-# INLINE happyIndexGotoTable #-}
    happyIndexGotoTable :: Int# -> Int# -> Int#
    happyIndexGotoTable Int#
    nt Int#
    st = HappyAddr -> Int# -> Int#
    happyIndexOffAddr HappyAddr
    happyTable Int#
    off
      where
        off :: Int#
    off = PLUS(happyIndexOffAddr happyGotoOffsets st, nt)

    {-# INLINE happyIndexOffAddr #-}
    happyIndexOffAddr :: HappyAddr -> Happy_Int -> Happy_Int
    happyIndexOffAddr :: HappyAddr -> Int# -> Int#
    happyIndexOffAddr (HappyA# Addr#
    arr) Int#
    off =
    #if __GLASGOW_HASKELL__ >= 901
      Int32# -> Int#
    Happy_GHC_Exts.int32ToInt# -- qualified import because it doesn't exist on older GHC's
    #endif
    #ifdef WORDS_BIGENDIAN
      -- The CI of `alex` tests this code path
      (Happy_GHC_Exts.word32ToInt32# (Happy_GHC_Exts.wordToWord32# (Happy_GHC_Exts.byteSwap32# (Happy_GHC_Exts.word32ToWord# (Happy_GHC_Exts.int32ToWord32#
    #endif
      (Addr# -> Int# -> Int32#
    Happy_GHC_Exts.indexInt32OffAddr# Addr#
    arr Int#
    off)
    #ifdef WORDS_BIGENDIAN
      )))))
    #endif

    happyIndexRuleArr :: Happy_Int -> (# Happy_Int, Happy_Int #)
    happyIndexRuleArr :: Int# -> (# Int#, Int# #)
    happyIndexRuleArr Int#
    r = (# Int#
    nt, Int#
    len #)
      where
        !(Happy_GHC_Exts.I# Int#
    n_starts) = Int
    happy_n_starts
        offs :: Int#
    offs = TIMES(MINUS(r,n_starts),2#)
        nt :: Int#
    nt = HappyAddr -> Int# -> Int#
    happyIndexOffAddr HappyAddr
    happyRuleArr Int#
    offs
        len :: Int#
    len = HappyAddr -> Int# -> Int#
    happyIndexOffAddr HappyAddr
    happyRuleArr PLUS(offs,1#)

    data HappyAddr = HappyA# Happy_GHC_Exts.Addr#

    -----------------------------------------------------------------------------
    -- Shifting a token

    happyShift :: Int#
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyShift Int#
    new_state ERROR_TOK tk st sts stk@(x `HappyStk` _) =
         -- See "Error Fixup" below
         let i = GET_ERROR_TOKEN(x) in
         DEBUG_TRACE("shifting the error token")
         happyDoAction i tk new_state (HappyCons st sts) stk

    happyShift Int#
    new_state Int#
    i Token
    tk Int#
    st Happy_IntList
    sts HappyStk HappyAbsSyn
    stk =
         Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyNewToken Int#
    new_state (Int# -> Happy_IntList -> Happy_IntList
    HappyCons Int#
    st Happy_IntList
    sts) (MK_TOKEN(tk) `HappyStk` stk)

    -- happyReduce is specialised for the common cases.

    happySpecReduce_0 :: Int#
    -> HappyAbsSyn
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_0 Int#
    nt HappyAbsSyn
    fn Int#
    j Token
    tk Int#
    st Happy_IntList
    sts HappyStk HappyAbsSyn
    stk
         = HappyAbsSyn
    -> ([Token] -> Err HappyAbsSyn) -> [Token] -> Err HappyAbsSyn
    forall a b. a -> b -> b
    happySeq HappyAbsSyn
    fn (Int#
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyGoto Int#
    nt Int#
    j Token
    tk Int#
    st (Int# -> Happy_IntList -> Happy_IntList
    HappyCons Int#
    st Happy_IntList
    sts) (HappyAbsSyn
    fn HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    forall a. a -> HappyStk a -> HappyStk a
    `HappyStk` HappyStk HappyAbsSyn
    stk))

    happySpecReduce_1 :: Int#
    -> (HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_1 Int#
    nt HappyAbsSyn -> HappyAbsSyn
    fn Int#
    j Token
    tk Int#
    old_st sts :: Happy_IntList
    sts@(HappyCons Int#
    st Happy_IntList
    _) (HappyAbsSyn
    v1 `HappyStk` HappyStk HappyAbsSyn
    stk')
         = let r :: HappyAbsSyn
    r = HappyAbsSyn -> HappyAbsSyn
    fn HappyAbsSyn
    v1 in
           Int# -> ([Token] -> Err HappyAbsSyn) -> [Token] -> Err HappyAbsSyn
    forall a. Int# -> a -> a
    happyTcHack Int#
    old_st (HappyAbsSyn
    -> ([Token] -> Err HappyAbsSyn) -> [Token] -> Err HappyAbsSyn
    forall a b. a -> b -> b
    happySeq HappyAbsSyn
    r (Int#
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyGoto Int#
    nt Int#
    j Token
    tk Int#
    st Happy_IntList
    sts (HappyAbsSyn
    r HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    forall a. a -> HappyStk a -> HappyStk a
    `HappyStk` HappyStk HappyAbsSyn
    stk')))

    happySpecReduce_2 :: Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_2 Int#
    nt HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    fn Int#
    j Token
    tk Int#
    old_st
      (HappyCons Int#
    _ sts :: Happy_IntList
    sts@(HappyCons Int#
    st Happy_IntList
    _))
      (HappyAbsSyn
    v1 `HappyStk` HappyAbsSyn
    v2 `HappyStk` HappyStk HappyAbsSyn
    stk')
         = let r :: HappyAbsSyn
    r = HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    fn HappyAbsSyn
    v1 HappyAbsSyn
    v2 in
           Int# -> ([Token] -> Err HappyAbsSyn) -> [Token] -> Err HappyAbsSyn
    forall a. Int# -> a -> a
    happyTcHack Int#
    old_st (HappyAbsSyn
    -> ([Token] -> Err HappyAbsSyn) -> [Token] -> Err HappyAbsSyn
    forall a b. a -> b -> b
    happySeq HappyAbsSyn
    r (Int#
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyGoto Int#
    nt Int#
    j Token
    tk Int#
    st Happy_IntList
    sts (HappyAbsSyn
    r HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    forall a. a -> HappyStk a -> HappyStk a
    `HappyStk` HappyStk HappyAbsSyn
    stk')))

    happySpecReduce_3 :: Int#
    -> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happySpecReduce_3 Int#
    nt HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    fn Int#
    j Token
    tk Int#
    old_st
      (HappyCons Int#
    _ (HappyCons Int#
    _ sts :: Happy_IntList
    sts@(HappyCons Int#
    st Happy_IntList
    _)))
      (HappyAbsSyn
    v1 `HappyStk` HappyAbsSyn
    v2 `HappyStk` HappyAbsSyn
    v3 `HappyStk` HappyStk HappyAbsSyn
    stk')
         = let r :: HappyAbsSyn
    r = HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
    fn HappyAbsSyn
    v1 HappyAbsSyn
    v2 HappyAbsSyn
    v3 in
           Int# -> ([Token] -> Err HappyAbsSyn) -> [Token] -> Err HappyAbsSyn
    forall a. Int# -> a -> a
    happyTcHack Int#
    old_st (HappyAbsSyn
    -> ([Token] -> Err HappyAbsSyn) -> [Token] -> Err HappyAbsSyn
    forall a b. a -> b -> b
    happySeq HappyAbsSyn
    r (Int#
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyGoto Int#
    nt Int#
    j Token
    tk Int#
    st Happy_IntList
    sts (HappyAbsSyn
    r HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    forall a. a -> HappyStk a -> HappyStk a
    `HappyStk` HappyStk HappyAbsSyn
    stk')))

    happyReduce :: Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyReduce Int#
    k Int#
    nt HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    fn Int#
    j Token
    tk Int#
    st Happy_IntList
    sts HappyStk HappyAbsSyn
    stk
         = case Int# -> Happy_IntList -> Happy_IntList
    happyDrop MINUS(k,(1# :: Happy_Int)) sts of
             sts1 :: Happy_IntList
    sts1@(HappyCons Int#
    st1 Happy_IntList
    _) ->
                    let r :: HappyStk HappyAbsSyn
    r = HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    fn HappyStk HappyAbsSyn
    stk in -- it doesn't hurt to always seq here...
                    Int#
    st Int# -> ([Token] -> Err HappyAbsSyn) -> [Token] -> Err HappyAbsSyn
    forall a. Int# -> a -> a
    `happyTcHack` HappyStk HappyAbsSyn
    -> ([Token] -> Err HappyAbsSyn) -> [Token] -> Err HappyAbsSyn
    forall a b. a -> b -> b
    happyDoSeq HappyStk HappyAbsSyn
    r (Int#
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyGoto Int#
    nt Int#
    j Token
    tk Int#
    st1 Happy_IntList
    sts1 HappyStk HappyAbsSyn
    r)

    happyMonadReduce :: Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> Token -> Err HappyAbsSyn)
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyMonadReduce Int#
    k Int#
    nt HappyStk HappyAbsSyn -> Token -> Err HappyAbsSyn
    fn Int#
    j Token
    tk Int#
    st Happy_IntList
    sts HappyStk HappyAbsSyn
    stk =
          case Int# -> Happy_IntList -> Happy_IntList
    happyDrop Int#
    k (Int# -> Happy_IntList -> Happy_IntList
    HappyCons Int#
    st Happy_IntList
    sts) of
            sts1 :: Happy_IntList
    sts1@(HappyCons Int#
    st1 Happy_IntList
    _) ->
              let drop_stk :: HappyStk HappyAbsSyn
    drop_stk = Int# -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    forall {a}. Int# -> HappyStk a -> HappyStk a
    happyDropStk Int#
    k HappyStk HappyAbsSyn
    stk in
              Int#
    j Int# -> ([Token] -> Err HappyAbsSyn) -> [Token] -> Err HappyAbsSyn
    forall a. Int# -> a -> a
    `happyTcHack` Err HappyAbsSyn
    -> (HappyAbsSyn -> [Token] -> Err HappyAbsSyn)
    -> [Token]
    -> Err HappyAbsSyn
    forall {m :: * -> *} {t} {t} {b}.
    Monad m =>
    m t -> (t -> t -> m b) -> t -> m b
    happyThen1 (HappyStk HappyAbsSyn -> Token -> Err HappyAbsSyn
    fn HappyStk HappyAbsSyn
    stk Token
    tk)
                                         (\HappyAbsSyn
    r -> Int#
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyGoto Int#
    nt Int#
    j Token
    tk Int#
    st1 Happy_IntList
    sts1 (HappyAbsSyn
    r HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    forall a. a -> HappyStk a -> HappyStk a
    `HappyStk` HappyStk HappyAbsSyn
    drop_stk))

    happyMonad2Reduce :: Int#
    -> Int#
    -> (HappyStk HappyAbsSyn -> t -> Err HappyAbsSyn)
    -> Int#
    -> t
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyMonad2Reduce Int#
    k Int#
    nt HappyStk HappyAbsSyn -> t -> Err HappyAbsSyn
    fn Int#
    j t
    tk Int#
    st Happy_IntList
    sts HappyStk HappyAbsSyn
    stk =
          case Int# -> Happy_IntList -> Happy_IntList
    happyDrop Int#
    k (Int# -> Happy_IntList -> Happy_IntList
    HappyCons Int#
    st Happy_IntList
    sts) of
            sts1 :: Happy_IntList
    sts1@(HappyCons Int#
    st1 Happy_IntList
    _) ->
              let drop_stk :: HappyStk HappyAbsSyn
    drop_stk = Int# -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    forall {a}. Int# -> HappyStk a -> HappyStk a
    happyDropStk Int#
    k HappyStk HappyAbsSyn
    stk
                  off :: Int#
    off = HappyAddr -> Int# -> Int#
    happyIndexOffAddr HappyAddr
    happyGotoOffsets Int#
    st1
                  off_i :: Int#
    off_i = PLUS(off, nt)
                  new_state :: Int#
    new_state = HappyAddr -> Int# -> Int#
    happyIndexOffAddr HappyAddr
    happyTable Int#
    off_i
              in
                Int#
    j Int# -> ([Token] -> Err HappyAbsSyn) -> [Token] -> Err HappyAbsSyn
    forall a. Int# -> a -> a
    `happyTcHack` Err HappyAbsSyn
    -> (HappyAbsSyn -> [Token] -> Err HappyAbsSyn)
    -> [Token]
    -> Err HappyAbsSyn
    forall {m :: * -> *} {t} {t} {b}.
    Monad m =>
    m t -> (t -> t -> m b) -> t -> m b
    happyThen1 (HappyStk HappyAbsSyn -> t -> Err HappyAbsSyn
    fn HappyStk HappyAbsSyn
    stk t
    tk)
                                           (\HappyAbsSyn
    r -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyNewToken Int#
    new_state Happy_IntList
    sts1 (HappyAbsSyn
    r HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
    forall a. a -> HappyStk a -> HappyStk a
    `HappyStk` HappyStk HappyAbsSyn
    drop_stk))

    happyDrop :: Int# -> Happy_IntList -> Happy_IntList
    happyDrop Int#
    0# Happy_IntList
    l               = Happy_IntList
    l
    happyDrop Int#
    n  (HappyCons Int#
    _ Happy_IntList
    t) = Int# -> Happy_IntList -> Happy_IntList
    happyDrop MINUS(n,(1# :: Happy_Int)) t

    happyDropStk :: Int# -> HappyStk a -> HappyStk a
    happyDropStk Int#
    0# HappyStk a
    l                 = HappyStk a
    l
    happyDropStk Int#
    n  (a
    x `HappyStk` HappyStk a
    xs) = Int# -> HappyStk a -> HappyStk a
    happyDropStk MINUS(n,(1#::Happy_Int)) xs

    -----------------------------------------------------------------------------
    -- Moving to a new state after a reduction

    happyGoto :: Int#
    -> Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyGoto Int#
    nt Int#
    j Token
    tk Int#
    st =
       DEBUG_TRACE(", goto state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# new_state) Happy_Prelude.++ "\n")
       Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyDoAction Int#
    j Token
    tk Int#
    new_state
      where new_state :: Int#
    new_state = Int# -> Int# -> Int#
    happyIndexGotoTable Int#
    nt Int#
    st

    {- Note [Error recovery]
    ~~~~~~~~~~~~~~~~~~~~~~~~
    When there is no applicable action for the current lookahead token `tk`,
    happy enters error recovery mode. Depending on whether the grammar file
    declares the two action form `%error { abort } { report }` for
        Resumptive Error Handling,
    it works in one (not resumptive) or two phases (resumptive):

     1. Fixup mode:
        Try to see if there is an action for the error token ERROR_TOK. If there
        is, do *not* emit an error and pretend instead that an `error` token was
        inserted.
        When there is no ERROR_TOK action, report an error.

        In non-resumptive error handling, calling the single error handler
        (e.g. `happyError`) will throw an exception and abort the parser.
        However, in resumptive error handling we enter *error resumption mode*.

     2. Error resumption mode:
        After reporting the error (with `report`), happy will attempt to find
        a good state stack to resume parsing in.
        For each candidate stack, it discards input until one of the candidates
        resumes (i.e. shifts the current input).
        If no candidate resumes before the end of input, resumption failed and
        calls the `abort` function, to much the same effect as in non-resumptive
        error handling.

        Candidate stacks are declared by the grammar author using the special
        `catch` terminal and called "catch frames".
        This mechanism is described in detail in Note [happyResume].

    The `catch` resumption mechanism (2) is what usually is associated with
    `error` in `bison` or `menhir`. Since `error` is used for the Fixup mechanism
    (1) above, we call the corresponding token `catch`.
    Furthermore, in constrast to `bison`, our implementation of `catch`
    non-deterministically considers multiple catch frames on the stack for
    resumption (See Note [Multiple catch frames]).

    Note [happyResume]
    ~~~~~~~~~~~~~~~~~~
    `happyResume` implements the resumption mechanism from Note [Error recovery].
    It is best understood by example. Consider

    Exp :: { String }
    Exp : '1'                { "1" }
        | catch              { "catch" }
        | Exp '+' Exp %shift { $1 Happy_Prelude.++ " + " Happy_Prelude.++ $3 } -- %shift: associate 1 + 1 + 1 to the right
        | '(' Exp ')'        { "(" Happy_Prelude.++ $2 Happy_Prelude.++ ")" }

    The idea of the use of `catch` here is that upon encountering a parse error
    during expression parsing, we can gracefully degrade using the `catch` rule,
    still producing a partial syntax tree and keep on parsing to find further
    syntax errors.

    Let's trace the parser state for input 11+1, which will error out after shifting 1.
    After shifting, we have the following item stack (growing downwards and omitting
    transitive closure items):

      State 0: %start_parseExp -> . Exp
      State 5: Exp -> '1' .

    (Stack as a list of state numbers: [5,0].)
    As Note [Error recovery] describes, we will first try Fixup mode.
    That fails because no production can shift the `error` token.
    Next we try Error resumption mode. This works as follows:

      1. Pop off the item stack until we find an item that can shift the `catch`
         token. (Implemented in `pop_items`.)
           * State 5 cannot shift catch. Pop.
           * State 0 can shift catch, which would transition into
              State 4: Exp -> catch .
         So record the *stack* `[4,0]` after doing the shift transition.
         We call this a *catch frame*, where the top is a *catch state*,
         corresponding to an item in which we just shifted a `catch` token.
         There can be multiple such catch stacks, see Note [Multiple catch frames].

      2. Discard tokens from the input until the lookahead can be shifted in one
         of the catch stacks. (Implemented in `discard_input_until_exp` and
         `some_catch_state_shifts`.)
           * We cannot shift the current lookahead '1' in state 4, so we discard
           * We *can* shift the next lookahead '+' in state 4, but only after
             reducing, which pops State 4 and goes to State 3:
               State 3: %start_parseExp -> Exp .
                        Exp -> Exp . '+' Exp
             Here we can shift '+'.
         As you can see, to implement this machinery we need to simulate
         the operation of the LALR automaton, especially reduction
         (`happySimulateReduce`).

    Note [Multiple catch frames]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    For fewer spurious error messages, it can be beneficial to trace multiple catch
    items. Consider

    Exp : '1'
        | catch
        | Exp '+' Exp %shift
        | '(' Exp ')'

    Let's trace the parser state for input (;+1, which will error out after shifting (.
    After shifting, we have the following item stack (growing downwards):

      State 0: %start_parseExp -> . Exp
      State 6: Exp -> '(' . Exp ')'

    Upon error, we want to find items in the stack which can shift a catch token.
    Note that both State 0 and State 6 can shift a catch token, transitioning into
      State 4: Exp -> catch .
    Hence we record the catch frames `[4,6,0]` and `[4,0]` for possible resumption.

    Which catch frame do we pick for resumption?
    Note that resuming catch frame `[4,0]` will parse as "catch+1", whereas
    resuming the innermost frame `[4,6,0]` corresponds to parsing "(catch+1".
    The latter would keep discarding input until the closing ')' is found.
    So we will discard + and 1, leading to a spurious syntax error at the end of
    input, aborting the parse and never producing a partial syntax tree. Bad!

    It is far preferable to resume with catch frame `[4,0]`, where we can resume
    successfully on input +, so that is what we do.

    In general, we pick the catch frame for resumption that discards the least
    amount of input for a successful shift, preferring the topmost such catch frame.
    -}

    -- happyFail :: Happy_Int -> Token -> Happy_Int -> _
    -- This function triggers Note [Error recovery].
    -- If the current token is ERROR_TOK, phase (1) has failed and we might try
    -- phase (2).
    happyFail :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyFail ERROR_TOK = happyFixupFailed
    happyFail Int#
    i         = Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyTryFixup Int#
    i

    -- Enter Error Fixup (see Note [Error recovery]):
    -- generate an error token, save the old token and carry on.
    -- When a `happyShift` accepts the error token, we will pop off the error token
    -- to resume parsing with the current lookahead `i`.
    happyTryFixup :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyTryFixup Int#
    i Token
    tk Int#
    action Happy_IntList
    sts HappyStk HappyAbsSyn
    stk =
      DEBUG_TRACE("entering `error` fixup.\n")
      Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyDoAction ERROR_TOK tk action sts (MK_ERROR_TOKEN(i) `HappyStk` stk)
      -- NB: `happyShift` will simply pop the error token and carry on with
      --     `tk`. Hence we don't change `tk` in the call here

    -- See Note [Error recovery], phase (2).
    -- Enter resumption mode after reporting the error by calling `happyResume`.
    happyFixupFailed :: Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyFixupFailed Token
    tk Int#
    st Happy_IntList
    sts (HappyAbsSyn
    x `HappyStk` HappyStk HappyAbsSyn
    stk) =
      let i :: Int#
    i = GET_ERROR_TOKEN(x) in
      DEBUG_TRACE("`error` fixup failed.\n")
      let resume :: [Token] -> Err HappyAbsSyn
    resume   = Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyResume Int#
    i Token
    tk Int#
    st Happy_IntList
    sts HappyStk HappyAbsSyn
    stk
          expected :: [String]
    expected = Int# -> Happy_IntList -> [String]
    happyExpectedTokens Int#
    st Happy_IntList
    sts in
      Int#
    -> Token
    -> [String]
    -> ([Token] -> Err HappyAbsSyn)
    -> [Token]
    -> Err HappyAbsSyn
    forall {a}.
    Int# -> Token -> [String] -> ([Token] -> Err a) -> [Token] -> Err a
    happyReport Int#
    i Token
    tk [String]
    expected [Token] -> Err HappyAbsSyn
    resume

    -- happyResume :: Happy_Int -> Token -> Happy_Int -> _
    -- See Note [happyResume]
    happyResume :: Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyResume Int#
    i Token
    tk Int#
    st Happy_IntList
    sts HappyStk HappyAbsSyn
    stk = [(Happy_IntList, HappyStk HappyAbsSyn)]
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    pop_items [] Int#
    st Happy_IntList
    sts HappyStk HappyAbsSyn
    stk
      where
        !(Happy_GHC_Exts.I# Int#
    n_starts) = Int
    happy_n_starts   -- this is to test whether we have a start token
        !(Happy_GHC_Exts.I# Int#
    eof_i) = Int
    happy_n_terms Int -> Int -> Int
    forall a. Num a => a -> a -> a
    Happy_Prelude.- Int
    1   -- this is the token number of the EOF token
        happy_list_to_list :: Happy_IntList -> [Happy_Prelude.Int]
        happy_list_to_list :: Happy_IntList -> [Int]
    happy_list_to_list (HappyCons Int#
    st Happy_IntList
    sts)
          | LT(st, n_starts)
          = [(Int# -> Int
    Happy_GHC_Exts.I# Int#
    st)]
          | Bool
    Happy_Prelude.otherwise
          = (Int# -> Int
    Happy_GHC_Exts.I# Int#
    st) Int -> [Int] -> [Int]
    forall a. a -> [a] -> [a]
    : Happy_IntList -> [Int]
    happy_list_to_list Happy_IntList
    sts

        -- See (1) of Note [happyResume]
        pop_items :: [(Happy_IntList, HappyStk HappyAbsSyn)]
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    pop_items [(Happy_IntList, HappyStk HappyAbsSyn)]
    catch_frames Int#
    st Happy_IntList
    sts HappyStk HappyAbsSyn
    stk
          | LT(st, n_starts)
          = DEBUG_TRACE("reached start state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# st) Happy_Prelude.++ ", ")
            if [(Happy_IntList, HappyStk HappyAbsSyn)] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    Happy_Prelude.null [(Happy_IntList, HappyStk HappyAbsSyn)]
    catch_frames_new
              then DEBUG_TRACE("no resumption.\n")
                   [Token] -> Err HappyAbsSyn
    forall a. [Token] -> Err a
    happyAbort
              else DEBUG_TRACE("now discard input, trying to anchor in states " Happy_Prelude.++ Happy_Prelude.show (Happy_Prelude.map (happy_list_to_list . Happy_Prelude.fst) (Happy_Prelude.reverse catch_frames_new)) Happy_Prelude.++ ".\n")
                   Int#
    -> Token
    -> [(Happy_IntList, HappyStk HappyAbsSyn)]
    -> [Token]
    -> Err HappyAbsSyn
    discard_input_until_exp Int#
    i Token
    tk ([(Happy_IntList, HappyStk HappyAbsSyn)]
    -> [(Happy_IntList, HappyStk HappyAbsSyn)]
    forall a. [a] -> [a]
    Happy_Prelude.reverse [(Happy_IntList, HappyStk HappyAbsSyn)]
    catch_frames_new)
          | (HappyCons Int#
    st1 Happy_IntList
    sts1) <- Happy_IntList
    sts, HappyAbsSyn
    _ `HappyStk` HappyStk HappyAbsSyn
    stk1 <- HappyStk HappyAbsSyn
    stk
          = [(Happy_IntList, HappyStk HappyAbsSyn)]
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    pop_items [(Happy_IntList, HappyStk HappyAbsSyn)]
    catch_frames_new Int#
    st1 Happy_IntList
    sts1 HappyStk HappyAbsSyn
    stk1
          where
            !catch_frames_new :: [(Happy_IntList, HappyStk HappyAbsSyn)]
    catch_frames_new
              | HappyShift Int#
    new_state <- Int# -> HappyAction
    happyDecodeAction (Int# -> Int# -> Int#
    happyNextAction CATCH_TOK st)
              , DEBUG_TRACE("can shift catch token in state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# st) Happy_Prelude.++ ", into state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# new_state) Happy_Prelude.++ "\n")
                [(Happy_IntList, HappyStk HappyAbsSyn)] -> Bool
    forall a. [a] -> Bool
    forall (t :: * -> *) a. Foldable t => t a -> Bool
    Happy_Prelude.null (((Happy_IntList, HappyStk HappyAbsSyn) -> Bool)
    -> [(Happy_IntList, HappyStk HappyAbsSyn)]
    -> [(Happy_IntList, HappyStk HappyAbsSyn)]
    forall a. (a -> Bool) -> [a] -> [a]
    Happy_Prelude.filter (\(HappyCons Int#
    _ (HappyCons Int#
    h Happy_IntList
    _),HappyStk HappyAbsSyn
    _) -> EQ(st,h)) catch_frames)
              = (Int# -> Happy_IntList -> Happy_IntList
    HappyCons Int#
    new_state (Int# -> Happy_IntList -> Happy_IntList
    HappyCons Int#
    st Happy_IntList
    sts), MK_ERROR_TOKEN(i) `HappyStk` stk):catch_frames -- MK_ERROR_TOKEN(i) is just some dummy that should not be accessed by user code
              | Bool
    Happy_Prelude.otherwise
              = DEBUG_TRACE("already shifted or can't shift catch in " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# st) Happy_Prelude.++ "\n")
                [(Happy_IntList, HappyStk HappyAbsSyn)]
    catch_frames

        -- See (2) of Note [happyResume]
        discard_input_until_exp :: Int#
    -> Token
    -> [(Happy_IntList, HappyStk HappyAbsSyn)]
    -> [Token]
    -> Err HappyAbsSyn
    discard_input_until_exp Int#
    i Token
    tk [(Happy_IntList, HappyStk HappyAbsSyn)]
    catch_frames
          | Happy_Prelude.Just (HappyCons Int#
    st (HappyCons Int#
    catch_st Happy_IntList
    sts), HappyStk HappyAbsSyn
    catch_frame) <- Int#
    -> [(Happy_IntList, HappyStk HappyAbsSyn)]
    -> Maybe (Happy_IntList, HappyStk HappyAbsSyn)
    forall {b}.
    Int# -> [(Happy_IntList, b)] -> Maybe (Happy_IntList, b)
    some_catch_state_shifts Int#
    i [(Happy_IntList, HappyStk HappyAbsSyn)]
    catch_frames
          = DEBUG_TRACE("found expected token in state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# st) Happy_Prelude.++ " after shifting from " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# catch_st) Happy_Prelude.++ ": " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# i) Happy_Prelude.++ "\n")
            Int#
    -> Token
    -> Int#
    -> Happy_IntList
    -> HappyStk HappyAbsSyn
    -> [Token]
    -> Err HappyAbsSyn
    happyDoAction Int#
    i Token
    tk Int#
    st (Int# -> Happy_IntList -> Happy_IntList
    HappyCons Int#
    catch_st Happy_IntList
    sts) HappyStk HappyAbsSyn
    catch_frame
          | EQ(i,eof_i) -- is i EOF?
          = DEBUG_TRACE("reached EOF, cannot resume. abort parse :(\n")
            [Token] -> Err HappyAbsSyn
    forall a. [Token] -> Err a
    happyAbort
          | Bool
    Happy_Prelude.otherwise
          = DEBUG_TRACE("discard token " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# i) Happy_Prelude.++ "\n")
            (Token -> [Token] -> Err HappyAbsSyn)
    -> (Int# -> Token -> [Token] -> Err HappyAbsSyn)
    -> [Token]
    -> Err HappyAbsSyn
    forall {t} {a} {t}.
    (t -> [a] -> t) -> (Int# -> Token -> [Token] -> t) -> [Token] -> t
    happyLex (\Token
    eof_tk -> Int#
    -> Token
    -> [(Happy_IntList, HappyStk HappyAbsSyn)]
    -> [Token]
    -> Err HappyAbsSyn
    discard_input_until_exp Int#
    eof_i Token
    eof_tk [(Happy_IntList, HappyStk HappyAbsSyn)]
    catch_frames) -- eof
                     (\Int#
    i Token
    tk   -> Int#
    -> Token
    -> [(Happy_IntList, HappyStk HappyAbsSyn)]
    -> [Token]
    -> Err HappyAbsSyn
    discard_input_until_exp Int#
    i Token
    tk [(Happy_IntList, HappyStk HappyAbsSyn)]
    catch_frames)         -- not eof

        some_catch_state_shifts :: Int# -> [(Happy_IntList, b)] -> Maybe (Happy_IntList, b)
    some_catch_state_shifts Int#
    _ [] = DEBUG_TRACE("no catch state could shift.\n") Happy_Prelude.Nothing
        some_catch_state_shifts Int#
    i catch_frames :: [(Happy_IntList, b)]
    catch_frames@(((HappyCons Int#
    st Happy_IntList
    sts),b
    _):[(Happy_IntList, b)]
    _) = Int#
    -> Int#
    -> Happy_IntList
    -> [(Happy_IntList, b)]
    -> Maybe (Happy_IntList, b)
    try_head Int#
    i Int#
    st Happy_IntList
    sts [(Happy_IntList, b)]
    catch_frames
          where
            try_head :: Int#
    -> Int#
    -> Happy_IntList
    -> [(Happy_IntList, b)]
    -> Maybe (Happy_IntList, b)
    try_head Int#
    i Int#
    st Happy_IntList
    sts [(Happy_IntList, b)]
    catch_frames = -- PRECONDITION: head catch_frames = (HappyCons st sts)
              DEBUG_TRACE("trying token " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# i) Happy_Prelude.++ " in state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# st) Happy_Prelude.++ ": ")
              case Int# -> HappyAction
    happyDecodeAction (Int# -> Int# -> Int#
    happyNextAction Int#
    i Int#
    st) of
                HappyAction
    HappyFail     -> DEBUG_TRACE("fail.\n")   some_catch_state_shifts i (Happy_Prelude.tail catch_frames)
                HappyAction
    HappyAccept   -> DEBUG_TRACE("accept.\n") Happy_Prelude.Just (Happy_Prelude.head catch_frames)
                HappyShift Int#
    _  -> DEBUG_TRACE("shift.\n")  Happy_Prelude.Just (Happy_Prelude.head catch_frames)
                HappyReduce Int#
    r -> case Int# -> Int# -> Happy_IntList -> Happy_IntList
    happySimulateReduce Int#
    r Int#
    st Happy_IntList
    sts of
                  (HappyCons Int#
    st1 Happy_IntList
    sts1) -> Int#
    -> Int#
    -> Happy_IntList
    -> [(Happy_IntList, b)]
    -> Maybe (Happy_IntList, b)
    try_head Int#
    i Int#
    st1 Happy_IntList
    sts1 [(Happy_IntList, b)]
    catch_frames

    happySimulateReduce :: Int# -> Int# -> Happy_IntList -> Happy_IntList
    happySimulateReduce Int#
    r Int#
    st Happy_IntList
    sts =
      DEBUG_TRACE("simulate reduction of rule " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# r) Happy_Prelude.++ ", ")
      let (# Int#
    nt, Int#
    len #) = Int# -> (# Int#, Int# #)
    happyIndexRuleArr Int#
    r in
      DEBUG_TRACE("nt " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# nt) Happy_Prelude.++ ", len: " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# len) Happy_Prelude.++ ", new_st ")
      let !(sts1 :: Happy_IntList
    sts1@(HappyCons Int#
    st1 Happy_IntList
    _)) = Int# -> Happy_IntList -> Happy_IntList
    happyDrop Int#
    len (Int# -> Happy_IntList -> Happy_IntList
    HappyCons Int#
    st Happy_IntList
    sts)
          new_st :: Int#
    new_st = Int# -> Int# -> Int#
    happyIndexGotoTable Int#
    nt Int#
    st1 in
      DEBUG_TRACE(Happy_Prelude.show (Happy_GHC_Exts.I# new_st) Happy_Prelude.++ ".\n")
      (Int# -> Happy_IntList -> Happy_IntList
    HappyCons Int#
    new_st Happy_IntList
    sts1)

    happyTokenToString :: Happy_Prelude.Int -> Happy_Prelude.String
    happyTokenToString :: Int -> String
    happyTokenToString Int
    i = [String]
    happyTokenStrings [String] -> Int -> String
    forall a. HasCallStack => [a] -> Int -> a
    Happy_Prelude.!! (Int
    i Int -> Int -> Int
    forall a. Num a => a -> a -> a
    Happy_Prelude.- Int
    2) -- 2: errorTok, catchTok

    happyExpectedTokens :: Happy_Int -> Happy_IntList -> [Happy_Prelude.String]
    -- Upon a parse error, we want to suggest tokens that are expected in that
    -- situation. This function computes such tokens.
    -- It works by examining the top of the state stack.
    -- For every token number that does a shift transition, record that token number.
    -- For every token number that does a reduce transition, simulate that reduction
    -- on the state state stack and repeat.
    -- The recorded token numbers are then formatted with 'happyTokenToString' and
    -- returned.
    happyExpectedTokens :: Int# -> Happy_IntList -> [String]
    happyExpectedTokens Int#
    st Happy_IntList
    sts =
      DEBUG_TRACE("constructing expected tokens.\n")
      (Int -> String) -> [Int] -> [String]
    forall a b. (a -> b) -> [a] -> [b]
    Happy_Prelude.map Int -> String
    happyTokenToString (Int# -> Happy_IntList -> [Int] -> [Int]
    search_shifts Int#
    st Happy_IntList
    sts [])
      where
        search_shifts :: Int# -> Happy_IntList -> [Int] -> [Int]
    search_shifts Int#
    st Happy_IntList
    sts [Int]
    shifts = ((Int, Int) -> [Int] -> [Int]) -> [Int] -> [(Int, Int)] -> [Int]
    forall a b. (a -> b -> b) -> b -> [a] -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    Happy_Prelude.foldr (Int# -> Happy_IntList -> (Int, Int) -> [Int] -> [Int]
    add_action Int#
    st Happy_IntList
    sts) [Int]
    shifts (Int# -> [(Int, Int)]
    distinct_actions Int#
    st)
        add_action :: Int# -> Happy_IntList -> (Int, Int) -> [Int] -> [Int]
    add_action Int#
    st Happy_IntList
    sts (Happy_GHC_Exts.I# Int#
    i, Happy_GHC_Exts.I# Int#
    act) [Int]
    shifts =
          DEBUG_TRACE("found action in state " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# st) Happy_Prelude.++ ", input " Happy_Prelude.++ Happy_Prelude.show (Happy_GHC_Exts.I# i) Happy_Prelude.++ ", " Happy_Prelude.++ Happy_Prelude.show (happyDecodeAction act) Happy_Prelude.++ "\n")
          case Int# -> HappyAction
    happyDecodeAction Int#
    act of
            HappyAction
    HappyFail     -> [Int]
    shifts
            HappyAction
    HappyAccept   -> [Int]
    shifts -- This would always be %eof or error... Not helpful
            HappyShift Int#
    _  -> Int -> [Int] -> [Int]
    forall a. Ord a => a -> [a] -> [a]
    Happy_Prelude.insert (Int# -> Int
    Happy_GHC_Exts.I# Int#
    i) [Int]
    shifts
            HappyReduce Int#
    r -> case Int# -> Int# -> Happy_IntList -> Happy_IntList
    happySimulateReduce Int#
    r Int#
    st Happy_IntList
    sts of
              (HappyCons Int#
    st1 Happy_IntList
    sts1) -> Int# -> Happy_IntList -> [Int] -> [Int]
    search_shifts Int#
    st1 Happy_IntList
    sts1 [Int]
    shifts
        distinct_actions :: Int# -> [(Int, Int)]
    distinct_actions Int#
    st
          -- The (token number, action) pairs of all actions in the given state
          = ((-Int
    1), (Int# -> Int
    Happy_GHC_Exts.I# (HappyAddr -> Int# -> Int#
    happyIndexOffAddr HappyAddr
    happyDefActions Int#
    st)))
          (Int, Int) -> [(Int, Int)] -> [(Int, Int)]
    forall a. a -> [a] -> [a]
    : [ (Int
    i, Int
    act) | Int
    i <- [Int
    begin_i..Int
    happy_n_terms], Int
    act <- Int# -> Int -> [Int]
    get_act Int#
    row_off Int
    i ]
          where
            row_off :: Int#
    row_off = HappyAddr -> Int# -> Int#
    happyIndexOffAddr HappyAddr
    happyActOffsets Int#
    st
            begin_i :: Int
    begin_i = Int
    2 -- +2: errorTok,catchTok
        get_act :: Int# -> Int -> [Int]
    get_act Int#
    off (Happy_GHC_Exts.I# Int#
    i) -- happyIndexActionTable with cached row offset
          | let off_i :: Int#
    off_i = PLUS(off,i)
          , GTE(off_i,0#)
          , EQ(happyIndexOffAddr happyCheck off_i,i)
          = [(Int# -> Int
    Happy_GHC_Exts.I# (HappyAddr -> Int# -> Int#
    happyIndexOffAddr HappyAddr
    happyTable Int#
    off_i))]
          | Bool
    Happy_Prelude.otherwise
          = []

    -- Internal happy errors:

    notHappyAtAll :: a
    notHappyAtAll :: forall a. a
    notHappyAtAll = String -> a
    forall a. HasCallStack => String -> a
    Happy_Prelude.error String
    "Internal Happy parser panic. This is not supposed to happen! Please open a bug report at https://github.com/haskell/happy/issues.\n"

    -----------------------------------------------------------------------------
    -- Hack to get the typechecker to accept our action functions

    happyTcHack :: Happy_Int -> a -> a
    happyTcHack :: forall a. Int# -> a -> a
    happyTcHack Int#
    x a
    y = a
    y
    {-# INLINE happyTcHack #-}

    -----------------------------------------------------------------------------
    -- Seq-ing.  If the --strict flag is given, then Happy emits
    --      happySeq = happyDoSeq
    -- otherwise it emits
    --      happySeq = happyDontSeq

    happyDoSeq, happyDontSeq :: a -> b -> b
    happyDoSeq :: forall a b. a -> b -> b
    happyDoSeq   a
    a b
    b = a
    a a -> b -> b
    forall a b. a -> b -> b
    `Happy_GHC_Exts.seq` b
    b
    happyDontSeq :: forall a b. a -> b -> b
    happyDontSeq a
    a b
    b = b
    b

    -----------------------------------------------------------------------------
    -- Don't inline any functions from the template.  GHC has a nasty habit
    -- of deciding to inline happyGoto everywhere, which increases the size of
    -- the generated parser quite a bit.

    {-# NOINLINE happyDoAction #-}
    {-# NOINLINE happyTable #-}
    {-# NOINLINE happyCheck #-}
    {-# NOINLINE happyActOffsets #-}
    {-# NOINLINE happyGotoOffsets #-}
    {-# NOINLINE happyDefActions #-}

    {-# NOINLINE happyShift #-}
    {-# NOINLINE happySpecReduce_0 #-}
    {-# NOINLINE happySpecReduce_1 #-}
    {-# NOINLINE happySpecReduce_2 #-}
    {-# NOINLINE happySpecReduce_3 #-}
    {-# NOINLINE happyReduce #-}
    {-# NOINLINE happyMonadReduce #-}
    {-# NOINLINE happyGoto #-}
    {-# NOINLINE happyFail #-}

    -- end of Happy Template.