{-# OPTIONS_GHC -w #-}
{-# OPTIONS -XMagicHash -XBangPatterns -XTypeSynonymInstances -XFlexibleInstances -cpp #-}
#if __GLASGOW_HASKELL__ >= 710
{-# OPTIONS_GHC -XPartialTypeSignatures #-}
#endif
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE TemplateHaskell            #-}


module Data.API.Parse
    ( parseAPI
    , parseAPIWithChangelog
    , api
    , apiWithChangelog
    ) where

import           Data.API.Changes
import           Data.API.Scan
import           Data.API.Types
import           Data.API.Utils
import           Data.Char
import           Data.String
import qualified Data.Text                  as T
import qualified Data.CaseInsensitive       as CI
import qualified Data.Version               as V
import           Language.Haskell.TH
import           Language.Haskell.TH.Quote
import           Text.Printf
import           Text.Regex
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 1.20.0

newtype HappyAbsSyn  = HappyAbsSyn HappyAny
#if __GLASGOW_HASKELL__ >= 607
type HappyAny = Happy_GHC_Exts.Any
#else
type HappyAny = forall a . a
#endif
newtype HappyWrap5 = HappyWrap5 (APIWithChangelog)
happyIn5 :: (APIWithChangelog) -> (HappyAbsSyn )
happyIn5 :: APIWithChangelog -> HappyAbsSyn
happyIn5 APIWithChangelog
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (APIWithChangelog -> HappyWrap5
HappyWrap5 APIWithChangelog
x)
{-# INLINE happyIn5 #-}
happyOut5 :: (HappyAbsSyn ) -> HappyWrap5
happyOut5 :: HappyAbsSyn -> HappyWrap5
happyOut5 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut5 #-}
newtype HappyWrap6 = HappyWrap6 (API)
happyIn6 :: (API) -> (HappyAbsSyn )
happyIn6 :: API -> HappyAbsSyn
happyIn6 API
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (API -> HappyWrap6
HappyWrap6 API
x)
{-# INLINE happyIn6 #-}
happyOut6 :: (HappyAbsSyn ) -> HappyWrap6
happyOut6 :: HappyAbsSyn -> HappyWrap6
happyOut6 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut6 #-}
newtype HappyWrap7 = HappyWrap7 ([Thing])
happyIn7 :: ([Thing]) -> (HappyAbsSyn )
happyIn7 :: API -> HappyAbsSyn
happyIn7 API
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (API -> HappyWrap7
HappyWrap7 API
x)
{-# INLINE happyIn7 #-}
happyOut7 :: (HappyAbsSyn ) -> HappyWrap7
happyOut7 :: HappyAbsSyn -> HappyWrap7
happyOut7 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut7 #-}
newtype HappyWrap8 = HappyWrap8 (Thing)
happyIn8 :: (Thing) -> (HappyAbsSyn )
happyIn8 :: Thing -> HappyAbsSyn
happyIn8 Thing
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (Thing -> HappyWrap8
HappyWrap8 Thing
x)
{-# INLINE happyIn8 #-}
happyOut8 :: (HappyAbsSyn ) -> HappyWrap8
happyOut8 :: HappyAbsSyn -> HappyWrap8
happyOut8 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut8 #-}
newtype HappyWrap9 = HappyWrap9 (APINode)
happyIn9 :: (APINode) -> (HappyAbsSyn )
happyIn9 :: APINode -> HappyAbsSyn
happyIn9 APINode
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (APINode -> HappyWrap9
HappyWrap9 APINode
x)
{-# INLINE happyIn9 #-}
happyOut9 :: (HappyAbsSyn ) -> HappyWrap9
happyOut9 :: HappyAbsSyn -> HappyWrap9
happyOut9 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut9 #-}
newtype HappyWrap10 = HappyWrap10 (Spec)
happyIn10 :: (Spec) -> (HappyAbsSyn )
happyIn10 :: Spec -> HappyAbsSyn
happyIn10 Spec
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (Spec -> HappyWrap10
HappyWrap10 Spec
x)
{-# INLINE happyIn10 #-}
happyOut10 :: (HappyAbsSyn ) -> HappyWrap10
happyOut10 :: HappyAbsSyn -> HappyWrap10
happyOut10 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut10 #-}
newtype HappyWrap11 = HappyWrap11 (Conversion)
happyIn11 :: (Conversion) -> (HappyAbsSyn )
happyIn11 :: Conversion -> HappyAbsSyn
happyIn11 Conversion
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (Conversion -> HappyWrap11
HappyWrap11 Conversion
x)
{-# INLINE happyIn11 #-}
happyOut11 :: (HappyAbsSyn ) -> HappyWrap11
happyOut11 :: HappyAbsSyn -> HappyWrap11
happyOut11 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut11 #-}
newtype HappyWrap12 = HappyWrap12 (MDComment)
happyIn12 :: (MDComment) -> (HappyAbsSyn )
happyIn12 :: String -> HappyAbsSyn
happyIn12 String
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (String -> HappyWrap12
HappyWrap12 String
x)
{-# INLINE happyIn12 #-}
happyOut12 :: (HappyAbsSyn ) -> HappyWrap12
happyOut12 :: HappyAbsSyn -> HappyWrap12
happyOut12 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut12 #-}
newtype HappyWrap13 = HappyWrap13 ([MDComment])
happyIn13 :: ([MDComment]) -> (HappyAbsSyn )
happyIn13 :: [String] -> HappyAbsSyn
happyIn13 [String]
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# ([String] -> HappyWrap13
HappyWrap13 [String]
x)
{-# INLINE happyIn13 #-}
happyOut13 :: (HappyAbsSyn ) -> HappyWrap13
happyOut13 :: HappyAbsSyn -> HappyWrap13
happyOut13 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut13 #-}
newtype HappyWrap14 = HappyWrap14 (Prefix)
happyIn14 :: (Prefix) -> (HappyAbsSyn )
happyIn14 :: Prefix -> HappyAbsSyn
happyIn14 Prefix
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (Prefix -> HappyWrap14
HappyWrap14 Prefix
x)
{-# INLINE happyIn14 #-}
happyOut14 :: (HappyAbsSyn ) -> HappyWrap14
happyOut14 :: HappyAbsSyn -> HappyWrap14
happyOut14 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut14 #-}
newtype HappyWrap15 = HappyWrap15 (SpecRecord)
happyIn15 :: (SpecRecord) -> (HappyAbsSyn )
happyIn15 :: SpecRecord -> HappyAbsSyn
happyIn15 SpecRecord
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (SpecRecord -> HappyWrap15
HappyWrap15 SpecRecord
x)
{-# INLINE happyIn15 #-}
happyOut15 :: (HappyAbsSyn ) -> HappyWrap15
happyOut15 :: HappyAbsSyn -> HappyWrap15
happyOut15 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut15 #-}
newtype HappyWrap16 = HappyWrap16 (SpecUnion)
happyIn16 :: (SpecUnion) -> (HappyAbsSyn )
happyIn16 :: SpecUnion -> HappyAbsSyn
happyIn16 SpecUnion
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (SpecUnion -> HappyWrap16
HappyWrap16 SpecUnion
x)
{-# INLINE happyIn16 #-}
happyOut16 :: (HappyAbsSyn ) -> HappyWrap16
happyOut16 :: HappyAbsSyn -> HappyWrap16
happyOut16 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut16 #-}
newtype HappyWrap17 = HappyWrap17 ([(FieldName, FieldType)])
happyIn17 :: ([(FieldName, FieldType)]) -> (HappyAbsSyn )
happyIn17 :: [(FieldName, FieldType)] -> HappyAbsSyn
happyIn17 [(FieldName, FieldType)]
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# ([(FieldName, FieldType)] -> HappyWrap17
HappyWrap17 [(FieldName, FieldType)]
x)
{-# INLINE happyIn17 #-}
happyOut17 :: (HappyAbsSyn ) -> HappyWrap17
happyOut17 :: HappyAbsSyn -> HappyWrap17
happyOut17 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut17 #-}
newtype HappyWrap18 = HappyWrap18 (FieldType)
happyIn18 :: (FieldType) -> (HappyAbsSyn )
happyIn18 :: FieldType -> HappyAbsSyn
happyIn18 FieldType
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (FieldType -> HappyWrap18
HappyWrap18 FieldType
x)
{-# INLINE happyIn18 #-}
happyOut18 :: (HappyAbsSyn ) -> HappyWrap18
happyOut18 :: HappyAbsSyn -> HappyWrap18
happyOut18 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut18 #-}
newtype HappyWrap19 = HappyWrap19 (Bool)
happyIn19 :: (Bool) -> (HappyAbsSyn )
happyIn19 :: Bool -> HappyAbsSyn
happyIn19 Bool
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (Bool -> HappyWrap19
HappyWrap19 Bool
x)
{-# INLINE happyIn19 #-}
happyOut19 :: (HappyAbsSyn ) -> HappyWrap19
happyOut19 :: HappyAbsSyn -> HappyWrap19
happyOut19 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut19 #-}
newtype HappyWrap20 = HappyWrap20 ([(FieldName,(APIType,MDComment))])
happyIn20 :: ([(FieldName,(APIType,MDComment))]) -> (HappyAbsSyn )
happyIn20 :: [(FieldName, (APIType, String))] -> HappyAbsSyn
happyIn20 [(FieldName, (APIType, String))]
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# ([(FieldName, (APIType, String))] -> HappyWrap20
HappyWrap20 [(FieldName, (APIType, String))]
x)
{-# INLINE happyIn20 #-}
happyOut20 :: (HappyAbsSyn ) -> HappyWrap20
happyOut20 :: HappyAbsSyn -> HappyWrap20
happyOut20 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut20 #-}
newtype HappyWrap21 = HappyWrap21 (SpecEnum)
happyIn21 :: (SpecEnum) -> (HappyAbsSyn )
happyIn21 :: SpecEnum -> HappyAbsSyn
happyIn21 SpecEnum
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (SpecEnum -> HappyWrap21
HappyWrap21 SpecEnum
x)
{-# INLINE happyIn21 #-}
happyOut21 :: (HappyAbsSyn ) -> HappyWrap21
happyOut21 :: HappyAbsSyn -> HappyWrap21
happyOut21 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut21 #-}
newtype HappyWrap22 = HappyWrap22 ([(FieldName,MDComment)])
happyIn22 :: ([(FieldName,MDComment)]) -> (HappyAbsSyn )
happyIn22 :: [(FieldName, String)] -> HappyAbsSyn
happyIn22 [(FieldName, String)]
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# ([(FieldName, String)] -> HappyWrap22
HappyWrap22 [(FieldName, String)]
x)
{-# INLINE happyIn22 #-}
happyOut22 :: (HappyAbsSyn ) -> HappyWrap22
happyOut22 :: HappyAbsSyn -> HappyWrap22
happyOut22 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut22 #-}
newtype HappyWrap23 = HappyWrap23 (SpecNewtype)
happyIn23 :: (SpecNewtype) -> (HappyAbsSyn )
happyIn23 :: SpecNewtype -> HappyAbsSyn
happyIn23 SpecNewtype
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (SpecNewtype -> HappyWrap23
HappyWrap23 SpecNewtype
x)
{-# INLINE happyIn23 #-}
happyOut23 :: (HappyAbsSyn ) -> HappyWrap23
happyOut23 :: HappyAbsSyn -> HappyWrap23
happyOut23 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut23 #-}
newtype HappyWrap24 = HappyWrap24 (Maybe Filter)
happyIn24 :: (Maybe Filter) -> (HappyAbsSyn )
happyIn24 :: Maybe Filter -> HappyAbsSyn
happyIn24 Maybe Filter
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (Maybe Filter -> HappyWrap24
HappyWrap24 Maybe Filter
x)
{-# INLINE happyIn24 #-}
happyOut24 :: (HappyAbsSyn ) -> HappyWrap24
happyOut24 :: HappyAbsSyn -> HappyWrap24
happyOut24 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut24 #-}
newtype HappyWrap25 = HappyWrap25 (Filter)
happyIn25 :: (Filter) -> (HappyAbsSyn )
happyIn25 :: Filter -> HappyAbsSyn
happyIn25 Filter
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (Filter -> HappyWrap25
HappyWrap25 Filter
x)
{-# INLINE happyIn25 #-}
happyOut25 :: (HappyAbsSyn ) -> HappyWrap25
happyOut25 :: HappyAbsSyn -> HappyWrap25
happyOut25 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut25 #-}
newtype HappyWrap26 = HappyWrap26 (RegEx)
happyIn26 :: (RegEx) -> (HappyAbsSyn )
happyIn26 :: RegEx -> HappyAbsSyn
happyIn26 RegEx
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (RegEx -> HappyWrap26
HappyWrap26 RegEx
x)
{-# INLINE happyIn26 #-}
happyOut26 :: (HappyAbsSyn ) -> HappyWrap26
happyOut26 :: HappyAbsSyn -> HappyWrap26
happyOut26 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut26 #-}
newtype HappyWrap27 = HappyWrap27 (APIType)
happyIn27 :: (APIType) -> (HappyAbsSyn )
happyIn27 :: APIType -> HappyAbsSyn
happyIn27 APIType
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (APIType -> HappyWrap27
HappyWrap27 APIType
x)
{-# INLINE happyIn27 #-}
happyOut27 :: (HappyAbsSyn ) -> HappyWrap27
happyOut27 :: HappyAbsSyn -> HappyWrap27
happyOut27 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut27 #-}
newtype HappyWrap28 = HappyWrap28 (Maybe DefaultValue)
happyIn28 :: (Maybe DefaultValue) -> (HappyAbsSyn )
happyIn28 :: Maybe DefaultValue -> HappyAbsSyn
happyIn28 Maybe DefaultValue
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (Maybe DefaultValue -> HappyWrap28
HappyWrap28 Maybe DefaultValue
x)
{-# INLINE happyIn28 #-}
happyOut28 :: (HappyAbsSyn ) -> HappyWrap28
happyOut28 :: HappyAbsSyn -> HappyWrap28
happyOut28 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut28 #-}
newtype HappyWrap29 = HappyWrap29 (BasicType)
happyIn29 :: (BasicType) -> (HappyAbsSyn )
happyIn29 :: BasicType -> HappyAbsSyn
happyIn29 BasicType
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (BasicType -> HappyWrap29
HappyWrap29 BasicType
x)
{-# INLINE happyIn29 #-}
happyOut29 :: (HappyAbsSyn ) -> HappyWrap29
happyOut29 :: HappyAbsSyn -> HappyWrap29
happyOut29 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut29 #-}
newtype HappyWrap30 = HappyWrap30 (FieldName)
happyIn30 :: (FieldName) -> (HappyAbsSyn )
happyIn30 :: FieldName -> HappyAbsSyn
happyIn30 FieldName
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (FieldName -> HappyWrap30
HappyWrap30 FieldName
x)
{-# INLINE happyIn30 #-}
happyOut30 :: (HappyAbsSyn ) -> HappyWrap30
happyOut30 :: HappyAbsSyn -> HappyWrap30
happyOut30 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut30 #-}
newtype HappyWrap31 = HappyWrap31 (String)
happyIn31 :: (String) -> (HappyAbsSyn )
happyIn31 :: String -> HappyAbsSyn
happyIn31 String
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (String -> HappyWrap31
HappyWrap31 String
x)
{-# INLINE happyIn31 #-}
happyOut31 :: (HappyAbsSyn ) -> HappyWrap31
happyOut31 :: HappyAbsSyn -> HappyWrap31
happyOut31 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut31 #-}
newtype HappyWrap32 = HappyWrap32 (TypeName)
happyIn32 :: (TypeName) -> (HappyAbsSyn )
happyIn32 :: TypeName -> HappyAbsSyn
happyIn32 TypeName
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (TypeName -> HappyWrap32
HappyWrap32 TypeName
x)
{-# INLINE happyIn32 #-}
happyOut32 :: (HappyAbsSyn ) -> HappyWrap32
happyOut32 :: HappyAbsSyn -> HappyWrap32
happyOut32 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut32 #-}
newtype HappyWrap33 = HappyWrap33 (APIChangelog)
happyIn33 :: (APIChangelog) -> (HappyAbsSyn )
happyIn33 :: APIChangelog -> HappyAbsSyn
happyIn33 APIChangelog
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (APIChangelog -> HappyWrap33
HappyWrap33 APIChangelog
x)
{-# INLINE happyIn33 #-}
happyOut33 :: (HappyAbsSyn ) -> HappyWrap33
happyOut33 :: HappyAbsSyn -> HappyWrap33
happyOut33 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut33 #-}
newtype HappyWrap34 = HappyWrap34 (V.Version)
happyIn34 :: (V.Version) -> (HappyAbsSyn )
happyIn34 :: Version -> HappyAbsSyn
happyIn34 Version
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (Version -> HappyWrap34
HappyWrap34 Version
x)
{-# INLINE happyIn34 #-}
happyOut34 :: (HappyAbsSyn ) -> HappyWrap34
happyOut34 :: HappyAbsSyn -> HappyWrap34
happyOut34 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut34 #-}
newtype HappyWrap35 = HappyWrap35 (VersionExtra)
happyIn35 :: (VersionExtra) -> (HappyAbsSyn )
happyIn35 :: VersionExtra -> HappyAbsSyn
happyIn35 VersionExtra
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (VersionExtra -> HappyWrap35
HappyWrap35 VersionExtra
x)
{-# INLINE happyIn35 #-}
happyOut35 :: (HappyAbsSyn ) -> HappyWrap35
happyOut35 :: HappyAbsSyn -> HappyWrap35
happyOut35 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut35 #-}
newtype HappyWrap36 = HappyWrap36 ([APIChange])
happyIn36 :: ([APIChange]) -> (HappyAbsSyn )
happyIn36 :: [APIChange] -> HappyAbsSyn
happyIn36 [APIChange]
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# ([APIChange] -> HappyWrap36
HappyWrap36 [APIChange]
x)
{-# INLINE happyIn36 #-}
happyOut36 :: (HappyAbsSyn ) -> HappyWrap36
happyOut36 :: HappyAbsSyn -> HappyWrap36
happyOut36 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut36 #-}
newtype HappyWrap37 = HappyWrap37 ([[APIChange]])
happyIn37 :: ([[APIChange]]) -> (HappyAbsSyn )
happyIn37 :: [[APIChange]] -> HappyAbsSyn
happyIn37 [[APIChange]]
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# ([[APIChange]] -> HappyWrap37
HappyWrap37 [[APIChange]]
x)
{-# INLINE happyIn37 #-}
happyOut37 :: (HappyAbsSyn ) -> HappyWrap37
happyOut37 :: HappyAbsSyn -> HappyWrap37
happyOut37 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut37 #-}
newtype HappyWrap38 = HappyWrap38 ([APIChange])
happyIn38 :: ([APIChange]) -> (HappyAbsSyn )
happyIn38 :: [APIChange] -> HappyAbsSyn
happyIn38 [APIChange]
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# ([APIChange] -> HappyWrap38
HappyWrap38 [APIChange]
x)
{-# INLINE happyIn38 #-}
happyOut38 :: (HappyAbsSyn ) -> HappyWrap38
happyOut38 :: HappyAbsSyn -> HappyWrap38
happyOut38 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut38 #-}
newtype HappyWrap39 = HappyWrap39 ([FieldChange])
happyIn39 :: ([FieldChange]) -> (HappyAbsSyn )
happyIn39 :: [FieldChange] -> HappyAbsSyn
happyIn39 [FieldChange]
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# ([FieldChange] -> HappyWrap39
HappyWrap39 [FieldChange]
x)
{-# INLINE happyIn39 #-}
happyOut39 :: (HappyAbsSyn ) -> HappyWrap39
happyOut39 :: HappyAbsSyn -> HappyWrap39
happyOut39 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut39 #-}
newtype HappyWrap40 = HappyWrap40 ([FieldChange])
happyIn40 :: ([FieldChange]) -> (HappyAbsSyn )
happyIn40 :: [FieldChange] -> HappyAbsSyn
happyIn40 [FieldChange]
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# ([FieldChange] -> HappyWrap40
HappyWrap40 [FieldChange]
x)
{-# INLINE happyIn40 #-}
happyOut40 :: (HappyAbsSyn ) -> HappyWrap40
happyOut40 :: HappyAbsSyn -> HappyWrap40
happyOut40 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut40 #-}
newtype HappyWrap41 = HappyWrap41 (Maybe DefaultValue)
happyIn41 :: (Maybe DefaultValue) -> (HappyAbsSyn )
happyIn41 :: Maybe DefaultValue -> HappyAbsSyn
happyIn41 Maybe DefaultValue
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (Maybe DefaultValue -> HappyWrap41
HappyWrap41 Maybe DefaultValue
x)
{-# INLINE happyIn41 #-}
happyOut41 :: (HappyAbsSyn ) -> HappyWrap41
happyOut41 :: HappyAbsSyn -> HappyWrap41
happyOut41 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut41 #-}
newtype HappyWrap42 = HappyWrap42 (DefaultValue)
happyIn42 :: (DefaultValue) -> (HappyAbsSyn )
happyIn42 :: DefaultValue -> HappyAbsSyn
happyIn42 DefaultValue
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (DefaultValue -> HappyWrap42
HappyWrap42 DefaultValue
x)
{-# INLINE happyIn42 #-}
happyOut42 :: (HappyAbsSyn ) -> HappyWrap42
happyOut42 :: HappyAbsSyn -> HappyWrap42
happyOut42 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut42 #-}
newtype HappyWrap43 = HappyWrap43 ([UnionChange])
happyIn43 :: ([UnionChange]) -> (HappyAbsSyn )
happyIn43 :: [UnionChange] -> HappyAbsSyn
happyIn43 [UnionChange]
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# ([UnionChange] -> HappyWrap43
HappyWrap43 [UnionChange]
x)
{-# INLINE happyIn43 #-}
happyOut43 :: (HappyAbsSyn ) -> HappyWrap43
happyOut43 :: HappyAbsSyn -> HappyWrap43
happyOut43 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut43 #-}
newtype HappyWrap44 = HappyWrap44 ([UnionChange])
happyIn44 :: ([UnionChange]) -> (HappyAbsSyn )
happyIn44 :: [UnionChange] -> HappyAbsSyn
happyIn44 [UnionChange]
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# ([UnionChange] -> HappyWrap44
HappyWrap44 [UnionChange]
x)
{-# INLINE happyIn44 #-}
happyOut44 :: (HappyAbsSyn ) -> HappyWrap44
happyOut44 :: HappyAbsSyn -> HappyWrap44
happyOut44 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut44 #-}
newtype HappyWrap45 = HappyWrap45 ([EnumChange])
happyIn45 :: ([EnumChange]) -> (HappyAbsSyn )
happyIn45 :: [EnumChange] -> HappyAbsSyn
happyIn45 [EnumChange]
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# ([EnumChange] -> HappyWrap45
HappyWrap45 [EnumChange]
x)
{-# INLINE happyIn45 #-}
happyOut45 :: (HappyAbsSyn ) -> HappyWrap45
happyOut45 :: HappyAbsSyn -> HappyWrap45
happyOut45 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut45 #-}
newtype HappyWrap46 = HappyWrap46 ([EnumChange])
happyIn46 :: ([EnumChange]) -> (HappyAbsSyn )
happyIn46 :: [EnumChange] -> HappyAbsSyn
happyIn46 [EnumChange]
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# ([EnumChange] -> HappyWrap46
HappyWrap46 [EnumChange]
x)
{-# INLINE happyIn46 #-}
happyOut46 :: (HappyAbsSyn ) -> HappyWrap46
happyOut46 :: HappyAbsSyn -> HappyWrap46
happyOut46 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut46 #-}
newtype HappyWrap47 = HappyWrap47 (MigrationTag)
happyIn47 :: (MigrationTag) -> (HappyAbsSyn )
happyIn47 :: String -> HappyAbsSyn
happyIn47 String
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# (String -> HappyWrap47
HappyWrap47 String
x)
{-# INLINE happyIn47 #-}
happyOut47 :: (HappyAbsSyn ) -> HappyWrap47
happyOut47 :: HappyAbsSyn -> HappyWrap47
happyOut47 HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut47 #-}
happyInTok :: (PToken) -> (HappyAbsSyn )
happyInTok :: PToken -> HappyAbsSyn
happyInTok PToken
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# PToken
x
{-# INLINE happyInTok #-}
happyOutTok :: (HappyAbsSyn ) -> (PToken)
happyOutTok :: HappyAbsSyn -> PToken
happyOutTok HappyAbsSyn
x = unsafeCoerce# :: forall a b. a -> b
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOutTok #-}


happyExpList :: HappyAddr
happyExpList :: HappyAddr
happyExpList = Addr# -> HappyAddr
HappyA# Addr#
"\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\x08\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x02\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\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\x20\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\x08\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\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\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x88\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\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\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x80\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\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\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x22\xf8\x1f\x00\x04\x00\x00\x00\x00\x00\x00\x88\xe0\x7f\x00\x10\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\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\x20\x82\x1f\x00\x40\x00\x00\x00\x00\x00\x00\x80\x08\x7e\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x85\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x70\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x70\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\x10\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\x5c\x08\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x02\x00\x00\x00\x00\x00\x00\x08\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\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\x70\x21\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x22\xf8\x01\x00\x04\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x21\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x21\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x21\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x21\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\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\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\x40\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\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\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x08\x7e\x00\x00\x01\x00\x00\x00\x00\x00\x00\x22\xf8\x01\x00\x04\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\x00\x00\x00\x00\x00\x00\x00\x17\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\xc2\x07\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\x88\xe0\x07\x00\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x02\x00\x00\x00\x00\x00\x00\x22\xf8\x01\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x21\x00\x00\x00\x00\x00\x00\x20\x82\x1f\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x02\x00\x00\x00\x00\x00\x00\x22\xf8\x01\x00\x04\x00\x00\x00\x00\x00\x00\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\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\x20\x00\x00\x00\x00\x00\x00\x00\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\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\x10\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\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x08\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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"#

{-# NOINLINE happyExpListPerState #-}
happyExpListPerState :: Int -> [String]
happyExpListPerState Int
st =
    [String]
token_strs_expected
  where token_strs :: [String]
token_strs = [String
"error",String
"%dummy",String
"%start_parse",String
"%start_parse_with_changelog",String
"APIWithChangelog",String
"API",String
"RAPI",String
"Thing",String
"Node",String
"Spec",String
"With",String
"Comments",String
"RCommentList",String
"Prefix",String
"Record",String
"Union",String
"RRFields",String
"FieldType",String
"IsReadOnly",String
"RUFields",String
"Enum",String
"REnums",String
"Basic",String
"MbFilter",String
"Filter",String
"RegEx",String
"Type",String
"MayBasicLit",String
"BasicType",String
"FieldName",String
"VarIdentifier",String
"TypeName",String
"APIChangelog",String
"Version",String
"VersionExtra",String
"Changes",String
"RChanges",String
"Change",String
"RFieldChanges",String
"FieldChange",String
"MbDefaultValue",String
"DefaultValue",String
"RUnionChanges",String
"UnionChange",String
"REnumChanges",String
"EnumChange",String
"MigrationTag",String
"';'",String
"'|'",String
"'['",String
"']'",String
"'::'",String
"'='",String
"'?'",String
"','",String
"'<='",String
"'>='",String
"version",String
"with",String
"integer",String
"boolean",String
"utc",String
"string",String
"binary",String
"json",String
"record",String
"union",String
"enum",String
"basic",String
"changes",String
"added",String
"removed",String
"renamed",String
"changed",String
"default",String
"field",String
"alternative",String
"migration",String
"to",String
"nothing",String
"readonly",String
"comment",String
"typeiden",String
"variden",String
"intlit",String
"strlit",String
"true",String
"false",String
"utclit",String
"%eof"]
        bit_start :: Int
bit_start = Int
st forall a. Num a => a -> a -> a
Prelude.* Int
90
        bit_end :: Int
bit_end = (Int
st forall a. Num a => a -> a -> a
Prelude.+ Int
1) forall a. Num a => a -> a -> a
Prelude.* Int
90
        read_bit :: Int -> Bool
read_bit = HappyAddr -> Int -> Bool
readArrayBit HappyAddr
happyExpList
        bits :: [Bool]
bits = forall a b. (a -> b) -> [a] -> [b]
Prelude.map Int -> Bool
read_bit [Int
bit_start..Int
bit_end forall a. Num a => a -> a -> a
Prelude.- Int
1]
        bits_indexed :: [(Bool, Int)]
bits_indexed = forall a b. [a] -> [b] -> [(a, b)]
Prelude.zip [Bool]
bits [Int
0..Int
89]
        token_strs_expected :: [String]
token_strs_expected = forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
Prelude.concatMap (Bool, Int) -> [String]
f [(Bool, Int)]
bits_indexed
        f :: (Bool, Int) -> [String]
f (Bool
Prelude.False, Int
_) = []
        f (Bool
Prelude.True, Int
nr) = [[String]
token_strs forall a. [a] -> Int -> a
Prelude.!! Int
nr]

happyActOffsets :: HappyAddr
happyActOffsets :: HappyAddr
happyActOffsets = Addr# -> HappyAddr
HappyA# Addr#
"\x00\x00\x00\x00\x00\x00\x0b\x00\x58\x00\x21\x00\x21\x00\x53\x00\x57\x00\x85\x00\x4a\x00\x00\x00\x8b\x00\x00\x00\x00\x00\x00\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x72\x00\x00\x00\xbc\x00\x00\x00\xdf\x00\x4f\x00\x00\x00\x00\x00\x9f\x00\x00\x00\xbe\x00\xbe\x00\xbe\x00\x17\x00\xf2\xff\x00\x00\xd6\x00\x00\x00\x00\x00\xc0\x00\x00\x00\xc0\x00\xc0\x00\xc0\x00\xc3\x00\x00\x00\xff\xff\xff\xff\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x00\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\xe4\x00\xe5\x00\x7c\x00\x00\x00\xc4\x00\x1e\x00\x1f\x00\xfd\xff\xc5\x00\x00\x00\xfd\xff\x00\x00\x76\x00\x00\x00\x1f\x00\x00\x00\x7a\x00\x00\x00\x25\x00\x00\x00\x7d\x00\x00\x00\x00\x00\xe8\x00\xe9\x00\x53\x00\xea\x00\x53\x00\x53\x00\xeb\x00\x00\x00\x00\x00\xed\x00\x00\x00\x53\x00\xe6\x00\x00\x00\x26\x00\xee\x00\xef\x00\x53\x00\x00\x00\x53\x00\x00\x00\xfa\xff\x53\x00\x53\x00\x53\x00\x00\x00\x53\x00\x53\x00\x53\x00\x00\x00\x53\x00\x53\x00\x53\x00\x53\x00\x00\x00\xf0\x00\xcf\x00\x00\x00\xf1\x00\xd2\x00\x00\x00\xf2\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2d\x00\x00\x00\x00\x00\x00\x00\xf4\x00\x26\x00\x26\x00\x00\x00\xcb\x00\x53\x00\x00\x00\xfe\xff\x00\x00\x00\x00\x00\x00\x26\x00\x00\x00\xf3\x00\xf5\x00\x00\x00\x00\x00\x53\x00\x26\x00\x53\x00\x26\x00\x53\x00\x26\x00\xdb\x00\x00\x00\xe0\x00\x00\x00\x00\x00\x00\x00\xf6\x00\xf7\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdc\x00\xda\x00\x00\x00\xfe\xff\xdd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#

happyGotoOffsets :: HappyAddr
happyGotoOffsets :: HappyAddr
happyGotoOffsets = Addr# -> HappyAddr
HappyA# Addr#
"\x06\x00\x98\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x14\x00\x02\x00\x00\x00\x00\x00\x00\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xec\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\xe2\x00\x99\x00\x00\x00\x00\x00\x00\x00\xf8\x00\xf9\x00\xfb\x00\x00\x00\xde\x00\x00\x00\x2a\x00\x00\x00\x00\x00\xfc\x00\x00\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x00\x00\x35\x00\x44\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x52\x00\x01\x01\x04\x01\x03\x01\x00\x00\x02\x01\x7b\x00\x80\x00\x86\x00\xe1\x00\x00\x00\xe7\x00\x00\x00\x00\x00\x00\x00\x05\x01\x00\x00\x00\x00\x00\x00\xe3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\x01\x00\x00\x91\x00\x00\x00\x93\x00\x95\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\x00\x00\x00\x00\x00\x45\x00\x00\x00\x00\x00\x9a\x00\xae\x00\x9e\x00\x00\x00\xa5\x00\xa2\x00\xa4\x00\xa6\x00\x00\x00\xa8\x00\xaa\x00\xac\x00\x00\x00\xaf\x00\xb1\x00\xb3\x00\xb5\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\xc9\x00\x00\x00\x00\x00\x5f\x00\x4b\x00\x00\x00\x10\x01\xb9\x00\x00\x00\xf4\xff\x00\x00\x00\x00\xcd\x00\x65\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x66\x00\xbf\x00\x6c\x00\xc1\x00\x6d\x00\x00\x00\x00\x00\x06\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\x00\x00\xd7\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\x08\x01\x07\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"#

happyAdjustOffset :: Happy_GHC_Exts.Int# -> Happy_GHC_Exts.Int#
happyAdjustOffset :: Int# -> Int#
happyAdjustOffset Int#
off = Int#
off

happyDefActions :: HappyAddr
happyDefActions :: HappyAddr
happyDefActions = Addr# -> HappyAddr
HappyA# Addr#
"\xfa\xff\xfa\xff\x00\x00\x00\x00\xfc\xff\x00\x00\x00\x00\xed\xff\xed\xff\x00\x00\xef\xff\xfd\xff\x00\x00\xfb\xff\xf9\xff\xf8\xff\x00\x00\xec\xff\xc6\xff\xc5\xff\xc4\xff\xc3\xff\xc7\xff\x00\x00\xc0\xff\xba\xff\xbd\xff\xee\xff\xed\xff\xbf\xff\x00\x00\xbc\xff\xed\xff\xc2\xff\x00\x00\xbb\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\xff\xed\xff\xc1\xff\xb2\xff\x00\x00\x94\xff\x00\x00\x00\x00\x00\x00\x00\x00\xb8\xff\x00\x00\x00\x00\xf0\xff\xf6\xff\xf5\xff\xf4\xff\xf3\xff\xf2\xff\xd1\xff\xd2\xff\x00\x00\x00\x00\xca\xff\xcb\xff\xc9\xff\xcd\xff\xcc\xff\xd0\xff\x00\x00\x00\x00\x00\x00\x00\x00\xb9\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\xff\xb6\xff\xaf\xff\x00\x00\xaa\xff\xb5\xff\x9f\xff\x00\x00\x9b\xff\xb4\xff\x99\xff\x00\x00\x95\xff\xb7\xff\xdd\xff\xe2\xff\x00\x00\xea\xff\x00\x00\xeb\xff\x00\x00\xc8\xff\xd4\xff\x00\x00\xf7\xff\x00\x00\x00\x00\xd3\xff\x00\x00\x00\x00\x00\x00\x00\x00\xed\xff\x00\x00\xdf\xff\x00\x00\x00\x00\x00\x00\x00\x00\x9a\xff\x00\x00\x00\x00\x00\x00\xa0\xff\x00\x00\x00\x00\x00\x00\x00\x00\xb0\xff\x00\x00\x00\x00\xad\xff\x00\x00\x00\x00\x9d\xff\x00\x00\x00\x00\x97\xff\x98\xff\xde\xff\xdc\xff\x00\x00\x00\x00\xd5\xff\xed\xff\xe0\xff\x00\x00\x00\x00\x00\x00\xe8\xff\xe5\xff\x00\x00\xf1\xff\xce\xff\xe6\xff\xe9\xff\xed\xff\x00\x00\xe1\xff\xdb\xff\xd8\xff\xd9\xff\xd6\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\xff\xa8\xff\x9c\xff\x9e\xff\x96\xff\x00\x00\x00\x00\xed\xff\xe3\xff\xed\xff\xcf\xff\x00\x00\xa6\xff\xa2\xff\xa5\xff\xa4\xff\xa3\xff\xa1\xff\xa7\xff\xe7\xff\xe4\xff\x00\x00\x00\x00\xae\xff\x00\x00\x00\x00\xab\xff\xa9\xff\xd7\xff\xda\xff"#

happyCheck :: HappyAddr
happyCheck :: HappyAddr
happyCheck = Addr# -> HappyAddr
HappyA# Addr#
"\xff\xff\x03\x00\x03\x00\x09\x00\x0a\x00\x13\x00\x07\x00\x01\x00\x02\x00\x07\x00\x08\x00\x17\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x24\x00\x03\x00\x04\x00\x25\x00\x1d\x00\x07\x00\x08\x00\x09\x00\x1c\x00\x21\x00\x23\x00\x27\x00\x17\x00\x24\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x03\x00\x13\x00\x14\x00\x15\x00\x07\x00\x1a\x00\x07\x00\x08\x00\x07\x00\x08\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x16\x00\x05\x00\x18\x00\x1e\x00\x1e\x00\x1b\x00\x0a\x00\x0b\x00\x23\x00\x23\x00\x1e\x00\x1c\x00\x10\x00\x1c\x00\x12\x00\x23\x00\x05\x00\x24\x00\x16\x00\x2b\x00\x18\x00\x0a\x00\x0b\x00\x1b\x00\x26\x00\x0d\x00\x26\x00\x10\x00\x2a\x00\x12\x00\x2a\x00\x0d\x00\x01\x00\x16\x00\x16\x00\x18\x00\x18\x00\x0c\x00\x1b\x00\x1b\x00\x16\x00\x0b\x00\x18\x00\x01\x00\x02\x00\x1b\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x19\x00\x1a\x00\x23\x00\x1f\x00\x1c\x00\x1d\x00\x1e\x00\x23\x00\x20\x00\x16\x00\x16\x00\x18\x00\x18\x00\x25\x00\x1b\x00\x1b\x00\x16\x00\x16\x00\x18\x00\x18\x00\x24\x00\x1b\x00\x1b\x00\x16\x00\x16\x00\x18\x00\x18\x00\x01\x00\x1b\x00\x1b\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x18\x00\x19\x00\x1a\x00\x18\x00\x19\x00\x1a\x00\x00\x00\x01\x00\x02\x00\x1d\x00\x1e\x00\x2b\x00\x1f\x00\x20\x00\x07\x00\x08\x00\x05\x00\x28\x00\x29\x00\x06\x00\x26\x00\x27\x00\x22\x00\x23\x00\x19\x00\x1a\x00\x19\x00\x1a\x00\x19\x00\x1a\x00\x19\x00\x1a\x00\x27\x00\x19\x00\x1a\x00\x07\x00\x08\x00\x19\x00\x1a\x00\x14\x00\x15\x00\x19\x00\x1a\x00\x19\x00\x1a\x00\x19\x00\x1a\x00\x19\x00\x1a\x00\x19\x00\x1a\x00\x19\x00\x1a\x00\x0b\x00\x19\x00\x1a\x00\x19\x00\x1a\x00\x19\x00\x1a\x00\x19\x00\x1a\x00\x07\x00\x08\x00\x19\x00\x1a\x00\x07\x00\x08\x00\x19\x00\x1a\x00\x19\x00\x1a\x00\x19\x00\x1a\x00\x07\x00\x08\x00\x07\x00\x08\x00\x01\x00\x0b\x00\x24\x00\x20\x00\x24\x00\x0c\x00\x02\x00\x02\x00\x24\x00\x24\x00\x02\x00\x02\x00\x02\x00\x22\x00\x08\x00\x20\x00\x05\x00\x04\x00\x20\x00\x05\x00\x05\x00\x05\x00\x05\x00\x05\x00\x20\x00\x05\x00\x1f\x00\x08\x00\x1c\x00\x08\x00\x04\x00\x09\x00\x09\x00\x24\x00\x26\x00\x21\x00\x2a\x00\xff\xff\x06\x00\x1b\x00\x2a\x00\xff\xff\x23\x00\x2a\x00\x29\x00\xff\xff\xff\xff\xff\xff\x0f\x00\xff\xff\xff\xff\x1b\x00\x1b\x00\x11\x00\x1b\x00\x1b\x00\x1b\x00\x1b\x00\x1b\x00\x18\x00\x13\x00\x1b\x00\x0e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\xff\xff\x27\x00\x25\x00\xff\xff\xff\xff\xff\xff\x2a\x00\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\xb6\x00\x3f\x00\x8e\x00\x8f\x00\x2e\x00\x40\x00\x06\x00\x04\x00\x09\x00\x0a\x00\xb3\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x2f\x00\x0d\x00\x0e\x00\xb4\x00\x54\x00\x0f\x00\x0a\x00\x10\x00\x0b\x00\xb7\x00\x55\x00\x90\x00\x09\x00\x22\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\x3f\x00\x30\x00\x31\x00\x32\x00\x40\x00\x11\x00\x09\x00\x0a\x00\x09\x00\x0a\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\x67\x00\x4a\x00\x3c\x00\x5c\x00\x58\x00\x3d\x00\x37\x00\x38\x00\x5d\x00\x59\x00\x5c\x00\x1d\x00\x39\x00\x2b\x00\x3a\x00\x5d\x00\x36\x00\x22\x00\x3b\x00\xff\xff\x3c\x00\x37\x00\x38\x00\x3d\x00\xa2\x00\x95\x00\xa0\x00\x39\x00\xa3\x00\x3a\x00\xa1\x00\x9b\x00\x08\x00\x3b\x00\x96\x00\x3c\x00\x3c\x00\x63\x00\x3d\x00\x3d\x00\x96\x00\x0d\x00\x3c\x00\x03\x00\x04\x00\x3d\x00\x25\x00\x26\x00\x27\x00\x28\x00\x64\x00\x65\x00\x1c\x00\x29\x00\x13\x00\x14\x00\x15\x00\x2a\x00\x16\x00\x66\x00\x9c\x00\x3c\x00\x3c\x00\x17\x00\x3d\x00\x3d\x00\xb1\x00\xad\x00\x3c\x00\x3c\x00\x22\x00\x3d\x00\x3d\x00\xab\x00\xa9\x00\x3c\x00\x3c\x00\x1d\x00\x3d\x00\x3d\x00\x41\x00\x42\x00\x43\x00\x44\x00\x45\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x79\x00\x7a\x00\x7b\x00\x75\x00\x76\x00\x77\x00\x05\x00\x03\x00\x04\x00\x18\x00\x19\x00\xbe\xff\x1e\x00\x1f\x00\x22\x00\x0a\x00\x18\x00\x59\x00\x5a\x00\x36\x00\x55\x00\x56\x00\x51\x00\x52\x00\x70\x00\x65\x00\x6e\x00\x65\x00\x6d\x00\x65\x00\x6a\x00\x65\x00\x1b\x00\x92\x00\x65\x00\x91\x00\x0a\x00\x90\x00\x65\x00\x8b\x00\x8c\x00\x8a\x00\x65\x00\x89\x00\x65\x00\x88\x00\x65\x00\x87\x00\x65\x00\x86\x00\x65\x00\x85\x00\x65\x00\x0d\x00\x84\x00\x65\x00\x83\x00\x65\x00\x82\x00\x65\x00\x81\x00\x65\x00\x9e\x00\x0a\x00\x98\x00\x65\x00\xb2\x00\x0a\x00\xae\x00\x65\x00\xac\x00\x65\x00\xaa\x00\x65\x00\xbe\x00\x0a\x00\xbd\x00\x0a\x00\x2b\x00\x0d\x00\x22\x00\x4c\x00\x22\x00\x6a\x00\x63\x00\x61\x00\x22\x00\x2f\x00\x74\x00\x72\x00\x70\x00\x9b\x00\x98\x00\xa8\x00\x6d\x00\x6c\x00\xa6\x00\x95\x00\x94\x00\xa9\x00\xa7\x00\xa5\x00\xa4\x00\x9e\x00\xc4\x00\xb1\x00\xc3\x00\xb0\x00\xbd\x00\xc1\x00\xc0\x00\x2f\x00\xc8\x00\x23\x00\xc7\x00\x00\x00\x68\x00\x20\x00\x2c\x00\x00\x00\x80\x00\x50\x00\x77\x00\x00\x00\x00\x00\x00\x00\x61\x00\x00\x00\x00\x00\x34\x00\x33\x00\x5f\x00\x32\x00\x4f\x00\x4e\x00\x4d\x00\x4c\x00\x5e\x00\x72\x00\x5d\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\x00\x00\x00\x7b\x00\xc5\x00\x00\x00\x00\x00\x00\x00\xc4\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#
   -> PToken
   -> Int#
   -> Happy_IntList
   -> HappyStk HappyAbsSyn
   -> [PToken]
   -> ParseM HappyAbsSyn)
happyReduceArr = forall i e. Ix i => (i, i) -> [(i, e)] -> Array i e
Happy_Data_Array.array (Int
2, Int
107) [
	(Int
2 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_2),
	(Int
3 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_3),
	(Int
4 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_4),
	(Int
5 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_5),
	(Int
6 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_6),
	(Int
7 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_7),
	(Int
8 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_8),
	(Int
9 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_9),
	(Int
10 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_10),
	(Int
11 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_11),
	(Int
12 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_12),
	(Int
13 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_13),
	(Int
14 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_14),
	(Int
15 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_15),
	(Int
16 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_16),
	(Int
17 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_17),
	(Int
18 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_18),
	(Int
19 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_19),
	(Int
20 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_20),
	(Int
21 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_21),
	(Int
22 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_22),
	(Int
23 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_23),
	(Int
24 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_24),
	(Int
25 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_25),
	(Int
26 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_26),
	(Int
27 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_27),
	(Int
28 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_28),
	(Int
29 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_29),
	(Int
30 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_30),
	(Int
31 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_31),
	(Int
32 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_32),
	(Int
33 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_33),
	(Int
34 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_34),
	(Int
35 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_35),
	(Int
36 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_36),
	(Int
37 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_37),
	(Int
38 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_38),
	(Int
39 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_39),
	(Int
40 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_40),
	(Int
41 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_41),
	(Int
42 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_42),
	(Int
43 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_43),
	(Int
44 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_44),
	(Int
45 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_45),
	(Int
46 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_46),
	(Int
47 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_47),
	(Int
48 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_48),
	(Int
49 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_49),
	(Int
50 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_50),
	(Int
51 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_51),
	(Int
52 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_52),
	(Int
53 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_53),
	(Int
54 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_54),
	(Int
55 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_55),
	(Int
56 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_56),
	(Int
57 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_57),
	(Int
58 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_58),
	(Int
59 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_59),
	(Int
60 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_60),
	(Int
61 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_61),
	(Int
62 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_62),
	(Int
63 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_63),
	(Int
64 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_64),
	(Int
65 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_65),
	(Int
66 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_66),
	(Int
67 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_67),
	(Int
68 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_68),
	(Int
69 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_69),
	(Int
70 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_70),
	(Int
71 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_71),
	(Int
72 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_72),
	(Int
73 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_73),
	(Int
74 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_74),
	(Int
75 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_75),
	(Int
76 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_76),
	(Int
77 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_77),
	(Int
78 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_78),
	(Int
79 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_79),
	(Int
80 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_80),
	(Int
81 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_81),
	(Int
82 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_82),
	(Int
83 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_83),
	(Int
84 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_84),
	(Int
85 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_85),
	(Int
86 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_86),
	(Int
87 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_87),
	(Int
88 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_88),
	(Int
89 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_89),
	(Int
90 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_90),
	(Int
91 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_91),
	(Int
92 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_92),
	(Int
93 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_93),
	(Int
94 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_94),
	(Int
95 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_95),
	(Int
96 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_96),
	(Int
97 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_97),
	(Int
98 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_98),
	(Int
99 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_99),
	(Int
100 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_100),
	(Int
101 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_101),
	(Int
102 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_102),
	(Int
103 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_103),
	(Int
104 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_104),
	(Int
105 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_105),
	(Int
106 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_106),
	(Int
107 , Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_107)
	]

happy_n_terms :: Int
happy_n_terms = Int
44 :: Prelude.Int
happy_n_nonterms :: Int
happy_n_nonterms = Int
43 :: Prelude.Int

happyReduce_2 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_2 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_3  Int#
0# forall {p}. HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
happyReduction_2
happyReduction_2 :: HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
happyReduction_2 HappyAbsSyn
happy_x_3
	p
happy_x_2
	HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap6
happyOut6 HappyAbsSyn
happy_x_1 of { (HappyWrap6 API
happy_var_1) -> 
	case HappyAbsSyn -> HappyWrap33
happyOut33 HappyAbsSyn
happy_x_3 of { (HappyWrap33 APIChangelog
happy_var_3) -> 
	APIWithChangelog -> HappyAbsSyn
happyIn5
		 ((API
happy_var_1, APIChangelog
happy_var_3)
	)}}

happyReduce_3 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_3 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
1# HappyAbsSyn -> HappyAbsSyn
happyReduction_3
happyReduction_3 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_3 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap7
happyOut7 HappyAbsSyn
happy_x_1 of { (HappyWrap7 API
happy_var_1) -> 
	API -> HappyAbsSyn
happyIn6
		 (forall a. [a] -> [a]
reverse API
happy_var_1
	)}

happyReduce_4 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_4 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_3  Int#
2# forall {p}. HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
happyReduction_4
happyReduction_4 :: HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
happyReduction_4 HappyAbsSyn
happy_x_3
	p
happy_x_2
	HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap7
happyOut7 HappyAbsSyn
happy_x_1 of { (HappyWrap7 API
happy_var_1) -> 
	case HappyAbsSyn -> HappyWrap8
happyOut8 HappyAbsSyn
happy_x_3 of { (HappyWrap8 Thing
happy_var_3) -> 
	API -> HappyAbsSyn
happyIn7
		 (Thing
happy_var_3 forall a. a -> [a] -> [a]
: API
happy_var_1
	)}}

happyReduce_5 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_5 = Int#
-> HappyAbsSyn
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_0  Int#
2# HappyAbsSyn
happyReduction_5
happyReduction_5 :: HappyAbsSyn
happyReduction_5  =  API -> HappyAbsSyn
happyIn7
		 ([]
	)

happyReduce_6 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_6 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
3# HappyAbsSyn -> HappyAbsSyn
happyReduction_6
happyReduction_6 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_6 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap9
happyOut9 HappyAbsSyn
happy_x_1 of { (HappyWrap9 APINode
happy_var_1) -> 
	Thing -> HappyAbsSyn
happyIn8
		 (APINode -> Thing
ThNode    APINode
happy_var_1
	)}

happyReduce_7 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_7 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
3# HappyAbsSyn -> HappyAbsSyn
happyReduction_7
happyReduction_7 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_7 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap12
happyOut12 HappyAbsSyn
happy_x_1 of { (HappyWrap12 String
happy_var_1) -> 
	Thing -> HappyAbsSyn
happyIn8
		 (String -> Thing
ThComment String
happy_var_1
	)}

happyReduce_8 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_8 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce Int#
7# Int#
4# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_8
happyReduction_8 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_8 (HappyAbsSyn
happy_x_7 `HappyStk`
	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 -> HappyWrap14
happyOut14 HappyAbsSyn
happy_x_1 of { (HappyWrap14 Prefix
happy_var_1) -> 
	case HappyAbsSyn -> HappyWrap32
happyOut32 HappyAbsSyn
happy_x_3 of { (HappyWrap32 TypeName
happy_var_3) -> 
	case HappyAbsSyn -> HappyWrap12
happyOut12 HappyAbsSyn
happy_x_4 of { (HappyWrap12 String
happy_var_4) -> 
	case HappyAbsSyn -> HappyWrap10
happyOut10 HappyAbsSyn
happy_x_6 of { (HappyWrap10 Spec
happy_var_6) -> 
	case HappyAbsSyn -> HappyWrap11
happyOut11 HappyAbsSyn
happy_x_7 of { (HappyWrap11 Conversion
happy_var_7) -> 
	APINode -> HappyAbsSyn
happyIn9
		 (TypeName -> String -> Prefix -> Spec -> Conversion -> APINode
APINode TypeName
happy_var_3 String
happy_var_4 Prefix
happy_var_1 Spec
happy_var_6 Conversion
happy_var_7
	) forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}}}}}

happyReduce_9 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_9 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
5# HappyAbsSyn -> HappyAbsSyn
happyReduction_9
happyReduction_9 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_9 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap15
happyOut15 HappyAbsSyn
happy_x_1 of { (HappyWrap15 SpecRecord
happy_var_1) -> 
	Spec -> HappyAbsSyn
happyIn10
		 (SpecRecord -> Spec
SpRecord  SpecRecord
happy_var_1
	)}

happyReduce_10 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_10 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
5# HappyAbsSyn -> HappyAbsSyn
happyReduction_10
happyReduction_10 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_10 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap16
happyOut16 HappyAbsSyn
happy_x_1 of { (HappyWrap16 SpecUnion
happy_var_1) -> 
	Spec -> HappyAbsSyn
happyIn10
		 (SpecUnion -> Spec
SpUnion   SpecUnion
happy_var_1
	)}

happyReduce_11 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_11 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
5# HappyAbsSyn -> HappyAbsSyn
happyReduction_11
happyReduction_11 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_11 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap21
happyOut21 HappyAbsSyn
happy_x_1 of { (HappyWrap21 SpecEnum
happy_var_1) -> 
	Spec -> HappyAbsSyn
happyIn10
		 (SpecEnum -> Spec
SpEnum    SpecEnum
happy_var_1
	)}

happyReduce_12 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_12 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
5# HappyAbsSyn -> HappyAbsSyn
happyReduction_12
happyReduction_12 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_12 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap23
happyOut23 HappyAbsSyn
happy_x_1 of { (HappyWrap23 SpecNewtype
happy_var_1) -> 
	Spec -> HappyAbsSyn
happyIn10
		 (SpecNewtype -> Spec
SpNewtype SpecNewtype
happy_var_1
	)}

happyReduce_13 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_13 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
5# HappyAbsSyn -> HappyAbsSyn
happyReduction_13
happyReduction_13 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_13 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap27
happyOut27 HappyAbsSyn
happy_x_1 of { (HappyWrap27 APIType
happy_var_1) -> 
	Spec -> HappyAbsSyn
happyIn10
		 (APIType -> Spec
SpSynonym APIType
happy_var_1
	)}

happyReduce_14 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_14 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce Int#
4# Int#
6# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_14
happyReduction_14 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_14 (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 -> HappyWrap30
happyOut30 HappyAbsSyn
happy_x_2 of { (HappyWrap30 FieldName
happy_var_2) -> 
	case HappyAbsSyn -> HappyWrap30
happyOut30 HappyAbsSyn
happy_x_4 of { (HappyWrap30 FieldName
happy_var_4) -> 
	Conversion -> HappyAbsSyn
happyIn11
		 (forall a. a -> Maybe a
Just (FieldName
happy_var_2,FieldName
happy_var_4)
	) forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}}

happyReduce_15 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_15 = Int#
-> HappyAbsSyn
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_0  Int#
6# HappyAbsSyn
happyReduction_15
happyReduction_15 :: HappyAbsSyn
happyReduction_15  =  Conversion -> HappyAbsSyn
happyIn11
		 (forall a. Maybe a
Nothing
	)

happyReduce_16 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_16 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
7# HappyAbsSyn -> HappyAbsSyn
happyReduction_16
happyReduction_16 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_16 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap13
happyOut13 HappyAbsSyn
happy_x_1 of { (HappyWrap13 [String]
happy_var_1) -> 
	String -> HappyAbsSyn
happyIn12
		 ([String] -> String
unlines forall a b. (a -> b) -> a -> b
$ forall a. [a] -> [a]
reverse [String]
happy_var_1
	)}

happyReduce_17 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_17 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_2  Int#
8# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_17
happyReduction_17 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_17 HappyAbsSyn
happy_x_2
	HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap13
happyOut13 HappyAbsSyn
happy_x_1 of { (HappyWrap13 [String]
happy_var_1) -> 
	case HappyAbsSyn -> PToken
happyOutTok HappyAbsSyn
happy_x_2 of { ((,) AlexPosn
_ (Comment  String
happy_var_2)) -> 
	[String] -> HappyAbsSyn
happyIn13
		 (String
happy_var_2 forall a. a -> [a] -> [a]
: [String]
happy_var_1
	)}}

happyReduce_18 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_18 = Int#
-> HappyAbsSyn
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_0  Int#
8# HappyAbsSyn
happyReduction_18
happyReduction_18 :: HappyAbsSyn
happyReduction_18  =  [String] -> HappyAbsSyn
happyIn13
		 ([]
	)

happyReduce_19 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_19 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
9# HappyAbsSyn -> HappyAbsSyn
happyReduction_19
happyReduction_19 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_19 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap31
happyOut31 HappyAbsSyn
happy_x_1 of { (HappyWrap31 String
happy_var_1) -> 
	Prefix -> HappyAbsSyn
happyIn14
		 (forall s. FoldCase s => s -> CI s
CI.mk String
happy_var_1
	)}

happyReduce_20 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_20 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_2  Int#
10# forall {p}. HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_20
happyReduction_20 :: HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_20 HappyAbsSyn
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap17
happyOut17 HappyAbsSyn
happy_x_2 of { (HappyWrap17 [(FieldName, FieldType)]
happy_var_2) -> 
	SpecRecord -> HappyAbsSyn
happyIn15
		 ([(FieldName, FieldType)] -> SpecRecord
SpecRecord forall a b. (a -> b) -> a -> b
$ forall a. [a] -> [a]
reverse [(FieldName, FieldType)]
happy_var_2
	)}

happyReduce_21 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_21 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_2  Int#
11# forall {p}. HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_21
happyReduction_21 :: HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_21 HappyAbsSyn
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap20
happyOut20 HappyAbsSyn
happy_x_2 of { (HappyWrap20 [(FieldName, (APIType, String))]
happy_var_2) -> 
	SpecUnion -> HappyAbsSyn
happyIn16
		 ([(FieldName, (APIType, String))] -> SpecUnion
SpecUnion  forall a b. (a -> b) -> a -> b
$ forall a. [a] -> [a]
reverse [(FieldName, (APIType, String))]
happy_var_2
	)}

happyReduce_22 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_22 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce Int#
4# Int#
12# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_22
happyReduction_22 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_22 (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 -> HappyWrap17
happyOut17 HappyAbsSyn
happy_x_1 of { (HappyWrap17 [(FieldName, FieldType)]
happy_var_1) -> 
	case HappyAbsSyn -> HappyWrap30
happyOut30 HappyAbsSyn
happy_x_2 of { (HappyWrap30 FieldName
happy_var_2) -> 
	case HappyAbsSyn -> HappyWrap18
happyOut18 HappyAbsSyn
happy_x_4 of { (HappyWrap18 FieldType
happy_var_4) -> 
	[(FieldName, FieldType)] -> HappyAbsSyn
happyIn17
		 ((FieldName
happy_var_2,FieldType
happy_var_4) forall a. a -> [a] -> [a]
: [(FieldName, FieldType)]
happy_var_1
	) forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}}}

happyReduce_23 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_23 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_3  Int#
12# forall {p}. HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
happyReduction_23
happyReduction_23 :: HappyAbsSyn -> p -> HappyAbsSyn -> HappyAbsSyn
happyReduction_23 HappyAbsSyn
happy_x_3
	p
happy_x_2
	HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap30
happyOut30 HappyAbsSyn
happy_x_1 of { (HappyWrap30 FieldName
happy_var_1) -> 
	case HappyAbsSyn -> HappyWrap18
happyOut18 HappyAbsSyn
happy_x_3 of { (HappyWrap18 FieldType
happy_var_3) -> 
	[(FieldName, FieldType)] -> HappyAbsSyn
happyIn17
		 ([(FieldName
happy_var_1,FieldType
happy_var_3)]
	)}}

happyReduce_24 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_24 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce Int#
4# Int#
13# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_24
happyReduction_24 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_24 (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 APIType
happy_var_1) -> 
	case HappyAbsSyn -> HappyWrap19
happyOut19 HappyAbsSyn
happy_x_2 of { (HappyWrap19 Bool
happy_var_2) -> 
	case HappyAbsSyn -> HappyWrap28
happyOut28 HappyAbsSyn
happy_x_3 of { (HappyWrap28 Maybe DefaultValue
happy_var_3) -> 
	case HappyAbsSyn -> HappyWrap12
happyOut12 HappyAbsSyn
happy_x_4 of { (HappyWrap12 String
happy_var_4) -> 
	FieldType -> HappyAbsSyn
happyIn18
		 (APIType -> Bool -> Maybe DefaultValue -> String -> FieldType
FieldType APIType
happy_var_1 Bool
happy_var_2 Maybe DefaultValue
happy_var_3 String
happy_var_4
	) forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}}}}

happyReduce_25 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_25 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
14# forall {p}. p -> HappyAbsSyn
happyReduction_25
happyReduction_25 :: p -> HappyAbsSyn
happyReduction_25 p
happy_x_1
	 =  Bool -> HappyAbsSyn
happyIn19
		 (Bool
True
	)

happyReduce_26 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_26 = Int#
-> HappyAbsSyn
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_0  Int#
14# HappyAbsSyn
happyReduction_26
happyReduction_26 :: HappyAbsSyn
happyReduction_26  =  Bool -> HappyAbsSyn
happyIn19
		 (Bool
False
	)

happyReduce_27 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_27 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce Int#
6# Int#
15# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_27
happyReduction_27 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_27 (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 -> HappyWrap20
happyOut20 HappyAbsSyn
happy_x_1 of { (HappyWrap20 [(FieldName, (APIType, String))]
happy_var_1) -> 
	case HappyAbsSyn -> HappyWrap30
happyOut30 HappyAbsSyn
happy_x_3 of { (HappyWrap30 FieldName
happy_var_3) -> 
	case HappyAbsSyn -> HappyWrap27
happyOut27 HappyAbsSyn
happy_x_5 of { (HappyWrap27 APIType
happy_var_5) -> 
	case HappyAbsSyn -> HappyWrap12
happyOut12 HappyAbsSyn
happy_x_6 of { (HappyWrap12 String
happy_var_6) -> 
	[(FieldName, (APIType, String))] -> HappyAbsSyn
happyIn20
		 ((FieldName
happy_var_3,(APIType
happy_var_5,String
happy_var_6)) forall a. a -> [a] -> [a]
: [(FieldName, (APIType, String))]
happy_var_1
	) forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}}}}

happyReduce_28 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_28 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce Int#
5# Int#
15# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_28
happyReduction_28 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_28 (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 -> HappyWrap30
happyOut30 HappyAbsSyn
happy_x_2 of { (HappyWrap30 FieldName
happy_var_2) -> 
	case HappyAbsSyn -> HappyWrap27
happyOut27 HappyAbsSyn
happy_x_4 of { (HappyWrap27 APIType
happy_var_4) -> 
	case HappyAbsSyn -> HappyWrap12
happyOut12 HappyAbsSyn
happy_x_5 of { (HappyWrap12 String
happy_var_5) -> 
	[(FieldName, (APIType, String))] -> HappyAbsSyn
happyIn20
		 ([(FieldName
happy_var_2,(APIType
happy_var_4,String
happy_var_5))]
	) forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}}}

happyReduce_29 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_29 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_2  Int#
16# forall {p}. HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_29
happyReduction_29 :: HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_29 HappyAbsSyn
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap22
happyOut22 HappyAbsSyn
happy_x_2 of { (HappyWrap22 [(FieldName, String)]
happy_var_2) -> 
	SpecEnum -> HappyAbsSyn
happyIn21
		 ([(FieldName, String)] -> SpecEnum
SpecEnum forall a b. (a -> b) -> a -> b
$ forall a. [a] -> [a]
reverse [(FieldName, String)]
happy_var_2
	)}

happyReduce_30 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_30 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce Int#
4# Int#
17# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_30
happyReduction_30 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_30 (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 -> HappyWrap22
happyOut22 HappyAbsSyn
happy_x_1 of { (HappyWrap22 [(FieldName, String)]
happy_var_1) -> 
	case HappyAbsSyn -> HappyWrap30
happyOut30 HappyAbsSyn
happy_x_3 of { (HappyWrap30 FieldName
happy_var_3) -> 
	case HappyAbsSyn -> HappyWrap12
happyOut12 HappyAbsSyn
happy_x_4 of { (HappyWrap12 String
happy_var_4) -> 
	[(FieldName, String)] -> HappyAbsSyn
happyIn22
		 ((FieldName
happy_var_3,String
happy_var_4) forall a. a -> [a] -> [a]
: [(FieldName, String)]
happy_var_1
	) forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}}}

happyReduce_31 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_31 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_3  Int#
17# forall {p}. HappyAbsSyn -> HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_31
happyReduction_31 :: HappyAbsSyn -> HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_31 HappyAbsSyn
happy_x_3
	HappyAbsSyn
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap30
happyOut30 HappyAbsSyn
happy_x_2 of { (HappyWrap30 FieldName
happy_var_2) -> 
	case HappyAbsSyn -> HappyWrap12
happyOut12 HappyAbsSyn
happy_x_3 of { (HappyWrap12 String
happy_var_3) -> 
	[(FieldName, String)] -> HappyAbsSyn
happyIn22
		 ([(FieldName
happy_var_2,String
happy_var_3)]
	)}}

happyReduce_32 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_32 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_3  Int#
18# forall {p}. HappyAbsSyn -> HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_32
happyReduction_32 :: HappyAbsSyn -> HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_32 HappyAbsSyn
happy_x_3
	HappyAbsSyn
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap29
happyOut29 HappyAbsSyn
happy_x_2 of { (HappyWrap29 BasicType
happy_var_2) -> 
	case HappyAbsSyn -> HappyWrap24
happyOut24 HappyAbsSyn
happy_x_3 of { (HappyWrap24 Maybe Filter
happy_var_3) -> 
	SpecNewtype -> HappyAbsSyn
happyIn23
		 (BasicType -> Maybe Filter -> SpecNewtype
SpecNewtype BasicType
happy_var_2 Maybe Filter
happy_var_3
	)}}

happyReduce_33 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_33 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_2  Int#
19# forall {p}. HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_33
happyReduction_33 :: HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_33 HappyAbsSyn
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap25
happyOut25 HappyAbsSyn
happy_x_2 of { (HappyWrap25 Filter
happy_var_2) -> 
	Maybe Filter -> HappyAbsSyn
happyIn24
		 (forall a. a -> Maybe a
Just Filter
happy_var_2
	)}

happyReduce_34 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_34 = Int#
-> HappyAbsSyn
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_0  Int#
19# HappyAbsSyn
happyReduction_34
happyReduction_34 :: HappyAbsSyn
happyReduction_34  =  Maybe Filter -> HappyAbsSyn
happyIn24
		 (forall a. Maybe a
Nothing
	)

happyReduce_35 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_35 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
20# HappyAbsSyn -> HappyAbsSyn
happyReduction_35
happyReduction_35 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_35 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap26
happyOut26 HappyAbsSyn
happy_x_1 of { (HappyWrap26 RegEx
happy_var_1) -> 
	Filter -> HappyAbsSyn
happyIn25
		 (RegEx -> Filter
FtrStrg RegEx
happy_var_1
	)}

happyReduce_36 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_36 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_2  Int#
20# forall {p}. HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_36
happyReduction_36 :: HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_36 HappyAbsSyn
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> PToken
happyOutTok HappyAbsSyn
happy_x_2 of { ((,) AlexPosn
_ (Intg     Int
happy_var_2)) -> 
	Filter -> HappyAbsSyn
happyIn25
		 (IntRange -> Filter
FtrIntg forall a b. (a -> b) -> a -> b
$ Maybe Int -> Maybe Int -> IntRange
IntRange (forall a. a -> Maybe a
Just Int
happy_var_2) forall a. Maybe a
Nothing
	)}

happyReduce_37 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_37 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce Int#
5# Int#
20# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_37
happyReduction_37 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_37 (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 -> PToken
happyOutTok HappyAbsSyn
happy_x_2 of { ((,) AlexPosn
_ (Intg     Int
happy_var_2)) -> 
	case HappyAbsSyn -> PToken
happyOutTok HappyAbsSyn
happy_x_5 of { ((,) AlexPosn
_ (Intg     Int
happy_var_5)) -> 
	Filter -> HappyAbsSyn
happyIn25
		 (IntRange -> Filter
FtrIntg forall a b. (a -> b) -> a -> b
$ Maybe Int -> Maybe Int -> IntRange
IntRange (forall a. a -> Maybe a
Just Int
happy_var_2) (forall a. a -> Maybe a
Just Int
happy_var_5)
	) forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}}

happyReduce_38 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_38 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_2  Int#
20# forall {p}. HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_38
happyReduction_38 :: HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_38 HappyAbsSyn
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> PToken
happyOutTok HappyAbsSyn
happy_x_2 of { ((,) AlexPosn
_ (Intg     Int
happy_var_2)) -> 
	Filter -> HappyAbsSyn
happyIn25
		 (IntRange -> Filter
FtrIntg forall a b. (a -> b) -> a -> b
$ Maybe Int -> Maybe Int -> IntRange
IntRange forall a. Maybe a
Nothing   (forall a. a -> Maybe a
Just Int
happy_var_2)
	)}

happyReduce_39 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_39 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_2  Int#
20# forall {p}. HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_39
happyReduction_39 :: HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_39 HappyAbsSyn
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> PToken
happyOutTok HappyAbsSyn
happy_x_2 of { ((,) AlexPosn
_ (UTCTIME  UTCTime
happy_var_2)) -> 
	Filter -> HappyAbsSyn
happyIn25
		 (UTCRange -> Filter
FtrUTC  forall a b. (a -> b) -> a -> b
$ Maybe UTCTime -> Maybe UTCTime -> UTCRange
UTCRange (forall a. a -> Maybe a
Just UTCTime
happy_var_2) forall a. Maybe a
Nothing
	)}

happyReduce_40 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_40 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce Int#
5# Int#
20# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_40
happyReduction_40 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_40 (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 -> PToken
happyOutTok HappyAbsSyn
happy_x_2 of { ((,) AlexPosn
_ (UTCTIME  UTCTime
happy_var_2)) -> 
	case HappyAbsSyn -> PToken
happyOutTok HappyAbsSyn
happy_x_5 of { ((,) AlexPosn
_ (UTCTIME  UTCTime
happy_var_5)) -> 
	Filter -> HappyAbsSyn
happyIn25
		 (UTCRange -> Filter
FtrUTC  forall a b. (a -> b) -> a -> b
$ Maybe UTCTime -> Maybe UTCTime -> UTCRange
UTCRange (forall a. a -> Maybe a
Just UTCTime
happy_var_2) (forall a. a -> Maybe a
Just UTCTime
happy_var_5)
	) forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}}

happyReduce_41 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_41 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_2  Int#
20# forall {p}. HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_41
happyReduction_41 :: HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_41 HappyAbsSyn
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> PToken
happyOutTok HappyAbsSyn
happy_x_2 of { ((,) AlexPosn
_ (UTCTIME  UTCTime
happy_var_2)) -> 
	Filter -> HappyAbsSyn
happyIn25
		 (UTCRange -> Filter
FtrUTC  forall a b. (a -> b) -> a -> b
$ Maybe UTCTime -> Maybe UTCTime -> UTCRange
UTCRange forall a. Maybe a
Nothing   (forall a. a -> Maybe a
Just UTCTime
happy_var_2)
	)}

happyReduce_42 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_42 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
21# HappyAbsSyn -> HappyAbsSyn
happyReduction_42
happyReduction_42 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_42 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> PToken
happyOutTok HappyAbsSyn
happy_x_1 of { ((,) AlexPosn
_ (Strg     String
happy_var_1)) -> 
	RegEx -> HappyAbsSyn
happyIn26
		 (Text -> Regex -> RegEx
RegEx (String -> Text
T.pack String
happy_var_1) forall a b. (a -> b) -> a -> b
$ String -> Bool -> Bool -> Regex
mkRegexWithOpts String
happy_var_1 Bool
False Bool
True
	)}

happyReduce_43 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_43 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_2  Int#
22# forall {p}. HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_43
happyReduction_43 :: HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_43 HappyAbsSyn
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap27
happyOut27 HappyAbsSyn
happy_x_2 of { (HappyWrap27 APIType
happy_var_2) -> 
	APIType -> HappyAbsSyn
happyIn27
		 (APIType -> APIType
TyMaybe            APIType
happy_var_2
	)}

happyReduce_44 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_44 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_3  Int#
22# forall {p} {p}. p -> HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_44
happyReduction_44 :: p -> HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_44 p
happy_x_3
	HappyAbsSyn
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap27
happyOut27 HappyAbsSyn
happy_x_2 of { (HappyWrap27 APIType
happy_var_2) -> 
	APIType -> HappyAbsSyn
happyIn27
		 (APIType -> APIType
TyList             APIType
happy_var_2
	)}

happyReduce_45 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_45 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
22# HappyAbsSyn -> HappyAbsSyn
happyReduction_45
happyReduction_45 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_45 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap32
happyOut32 HappyAbsSyn
happy_x_1 of { (HappyWrap32 TypeName
happy_var_1) -> 
	APIType -> HappyAbsSyn
happyIn27
		 (TypeName -> APIType
TyName             TypeName
happy_var_1
	)}

happyReduce_46 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_46 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
22# HappyAbsSyn -> HappyAbsSyn
happyReduction_46
happyReduction_46 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_46 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap29
happyOut29 HappyAbsSyn
happy_x_1 of { (HappyWrap29 BasicType
happy_var_1) -> 
	APIType -> HappyAbsSyn
happyIn27
		 (BasicType -> APIType
TyBasic            BasicType
happy_var_1
	)}

happyReduce_47 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_47 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
22# forall {p}. p -> HappyAbsSyn
happyReduction_47
happyReduction_47 :: p -> HappyAbsSyn
happyReduction_47 p
happy_x_1
	 =  APIType -> HappyAbsSyn
happyIn27
		 (APIType
TyJSON
	)

happyReduce_48 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_48 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
23# HappyAbsSyn -> HappyAbsSyn
happyReduction_48
happyReduction_48 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_48 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap42
happyOut42 HappyAbsSyn
happy_x_1 of { (HappyWrap42 DefaultValue
happy_var_1) -> 
	Maybe DefaultValue -> HappyAbsSyn
happyIn28
		 (forall a. a -> Maybe a
Just DefaultValue
happy_var_1
	)}

happyReduce_49 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_49 = Int#
-> HappyAbsSyn
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_0  Int#
23# HappyAbsSyn
happyReduction_49
happyReduction_49 :: HappyAbsSyn
happyReduction_49  =  Maybe DefaultValue -> HappyAbsSyn
happyIn28
		 (forall a. Maybe a
Nothing
	)

happyReduce_50 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_50 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
24# forall {p}. p -> HappyAbsSyn
happyReduction_50
happyReduction_50 :: p -> HappyAbsSyn
happyReduction_50 p
happy_x_1
	 =  BasicType -> HappyAbsSyn
happyIn29
		 (BasicType
BTstring
	)

happyReduce_51 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_51 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
24# forall {p}. p -> HappyAbsSyn
happyReduction_51
happyReduction_51 :: p -> HappyAbsSyn
happyReduction_51 p
happy_x_1
	 =  BasicType -> HappyAbsSyn
happyIn29
		 (BasicType
BTbinary
	)

happyReduce_52 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_52 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
24# forall {p}. p -> HappyAbsSyn
happyReduction_52
happyReduction_52 :: p -> HappyAbsSyn
happyReduction_52 p
happy_x_1
	 =  BasicType -> HappyAbsSyn
happyIn29
		 (BasicType
BTbool
	)

happyReduce_53 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_53 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
24# forall {p}. p -> HappyAbsSyn
happyReduction_53
happyReduction_53 :: p -> HappyAbsSyn
happyReduction_53 p
happy_x_1
	 =  BasicType -> HappyAbsSyn
happyIn29
		 (BasicType
BTint
	)

happyReduce_54 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_54 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
24# forall {p}. p -> HappyAbsSyn
happyReduction_54
happyReduction_54 :: p -> HappyAbsSyn
happyReduction_54 p
happy_x_1
	 =  BasicType -> HappyAbsSyn
happyIn29
		 (BasicType
BTutc
	)

happyReduce_55 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_55 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
25# HappyAbsSyn -> HappyAbsSyn
happyReduction_55
happyReduction_55 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_55 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap31
happyOut31 HappyAbsSyn
happy_x_1 of { (HappyWrap31 String
happy_var_1) -> 
	FieldName -> HappyAbsSyn
happyIn30
		 (Text -> FieldName
FieldName (String -> Text
T.pack String
happy_var_1)
	)}

happyReduce_56 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_56 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
26# HappyAbsSyn -> HappyAbsSyn
happyReduction_56
happyReduction_56 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_56 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> PToken
happyOutTok HappyAbsSyn
happy_x_1 of { ((,) AlexPosn
_ (VarIden  String
happy_var_1)) -> 
	String -> HappyAbsSyn
happyIn31
		 (String
happy_var_1
	)}

happyReduce_57 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_57 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
26# forall {p}. p -> HappyAbsSyn
happyReduction_57
happyReduction_57 :: p -> HappyAbsSyn
happyReduction_57 p
happy_x_1
	 =  String -> HappyAbsSyn
happyIn31
		 (String
"default"
	)

happyReduce_58 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_58 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
26# forall {p}. p -> HappyAbsSyn
happyReduction_58
happyReduction_58 :: p -> HappyAbsSyn
happyReduction_58 p
happy_x_1
	 =  String -> HappyAbsSyn
happyIn31
		 (String
"field"
	)

happyReduce_59 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_59 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
26# forall {p}. p -> HappyAbsSyn
happyReduction_59
happyReduction_59 :: p -> HappyAbsSyn
happyReduction_59 p
happy_x_1
	 =  String -> HappyAbsSyn
happyIn31
		 (String
"alternative"
	)

happyReduce_60 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_60 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
26# forall {p}. p -> HappyAbsSyn
happyReduction_60
happyReduction_60 :: p -> HappyAbsSyn
happyReduction_60 p
happy_x_1
	 =  String -> HappyAbsSyn
happyIn31
		 (String
"to"
	)

happyReduce_61 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_61 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
27# HappyAbsSyn -> HappyAbsSyn
happyReduction_61
happyReduction_61 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_61 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> PToken
happyOutTok HappyAbsSyn
happy_x_1 of { ((,) AlexPosn
_ (TypeIden String
happy_var_1)) -> 
	TypeName -> HappyAbsSyn
happyIn32
		 (Text -> TypeName
TypeName (String -> Text
T.pack String
happy_var_1)
	)}

happyReduce_62 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_62 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce Int#
5# Int#
28# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_62
happyReduction_62 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_62 (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 -> HappyWrap35
happyOut35 HappyAbsSyn
happy_x_2 of { (HappyWrap35 VersionExtra
happy_var_2) -> 
	case HappyAbsSyn -> HappyWrap36
happyOut36 HappyAbsSyn
happy_x_3 of { (HappyWrap36 [APIChange]
happy_var_3) -> 
	case HappyAbsSyn -> HappyWrap33
happyOut33 HappyAbsSyn
happy_x_5 of { (HappyWrap33 APIChangelog
happy_var_5) -> 
	APIChangelog -> HappyAbsSyn
happyIn33
		 (VersionExtra -> [APIChange] -> APIChangelog -> APIChangelog
ChangesUpTo VersionExtra
happy_var_2 [APIChange]
happy_var_3 APIChangelog
happy_var_5
	) forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}}}

happyReduce_63 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_63 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_2  Int#
28# forall {p}. HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_63
happyReduction_63 :: HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_63 HappyAbsSyn
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap34
happyOut34 HappyAbsSyn
happy_x_2 of { (HappyWrap34 Version
happy_var_2) -> 
	APIChangelog -> HappyAbsSyn
happyIn33
		 (Version -> APIChangelog
ChangesStart Version
happy_var_2
	)}

happyReduce_64 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_64 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_3  Int#
28# forall {p} {p}. HappyAbsSyn -> p -> p -> HappyAbsSyn
happyReduction_64
happyReduction_64 :: HappyAbsSyn -> p -> p -> HappyAbsSyn
happyReduction_64 HappyAbsSyn
happy_x_3
	p
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap33
happyOut33 HappyAbsSyn
happy_x_3 of { (HappyWrap33 APIChangelog
happy_var_3) -> 
	APIChangelog -> HappyAbsSyn
happyIn33
		 (APIChangelog
happy_var_3
	)}

happyReduce_65 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_65 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
29# HappyAbsSyn -> HappyAbsSyn
happyReduction_65
happyReduction_65 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_65 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> PToken
happyOutTok HappyAbsSyn
happy_x_1 of { ((,) AlexPosn
_ (Strg     String
happy_var_1)) -> 
	Version -> HappyAbsSyn
happyIn34
		 (String -> Version
parseVer String
happy_var_1
	)}

happyReduce_66 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_66 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
30# HappyAbsSyn -> HappyAbsSyn
happyReduction_66
happyReduction_66 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_66 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> PToken
happyOutTok HappyAbsSyn
happy_x_1 of { ((,) AlexPosn
_ (Strg     String
happy_var_1)) -> 
	VersionExtra -> HappyAbsSyn
happyIn35
		 (String -> VersionExtra
parseVersionExtra String
happy_var_1
	)}

happyReduce_67 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_67 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
31# HappyAbsSyn -> HappyAbsSyn
happyReduction_67
happyReduction_67 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_67 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap37
happyOut37 HappyAbsSyn
happy_x_1 of { (HappyWrap37 [[APIChange]]
happy_var_1) -> 
	[APIChange] -> HappyAbsSyn
happyIn36
		 (forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat (forall a. [a] -> [a]
reverse [[APIChange]]
happy_var_1)
	)}

happyReduce_68 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_68 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_2  Int#
32# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_68
happyReduction_68 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_68 HappyAbsSyn
happy_x_2
	HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap37
happyOut37 HappyAbsSyn
happy_x_1 of { (HappyWrap37 [[APIChange]]
happy_var_1) -> 
	case HappyAbsSyn -> HappyWrap38
happyOut38 HappyAbsSyn
happy_x_2 of { (HappyWrap38 [APIChange]
happy_var_2) -> 
	[[APIChange]] -> HappyAbsSyn
happyIn37
		 ([APIChange]
happy_var_2 forall a. a -> [a] -> [a]
: [[APIChange]]
happy_var_1
	)}}

happyReduce_69 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_69 = Int#
-> HappyAbsSyn
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_0  Int#
32# HappyAbsSyn
happyReduction_69
happyReduction_69 :: HappyAbsSyn
happyReduction_69  =  [[APIChange]] -> HappyAbsSyn
happyIn37
		 ([]
	)

happyReduce_70 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_70 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_3  Int#
33# forall {p}. HappyAbsSyn -> HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_70
happyReduction_70 :: HappyAbsSyn -> HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_70 HappyAbsSyn
happy_x_3
	HappyAbsSyn
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap32
happyOut32 HappyAbsSyn
happy_x_2 of { (HappyWrap32 TypeName
happy_var_2) -> 
	case HappyAbsSyn -> HappyWrap10
happyOut10 HappyAbsSyn
happy_x_3 of { (HappyWrap10 Spec
happy_var_3) -> 
	[APIChange] -> HappyAbsSyn
happyIn38
		 ([TypeName -> NormTypeDecl -> APIChange
ChAddType TypeName
happy_var_2 (Spec -> NormTypeDecl
declNF Spec
happy_var_3)]
	)}}

happyReduce_71 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_71 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_2  Int#
33# forall {p}. HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_71
happyReduction_71 :: HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_71 HappyAbsSyn
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap32
happyOut32 HappyAbsSyn
happy_x_2 of { (HappyWrap32 TypeName
happy_var_2) -> 
	[APIChange] -> HappyAbsSyn
happyIn38
		 ([TypeName -> APIChange
ChDeleteType TypeName
happy_var_2]
	)}

happyReduce_72 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_72 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce Int#
4# Int#
33# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_72
happyReduction_72 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_72 (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 -> HappyWrap32
happyOut32 HappyAbsSyn
happy_x_2 of { (HappyWrap32 TypeName
happy_var_2) -> 
	case HappyAbsSyn -> HappyWrap32
happyOut32 HappyAbsSyn
happy_x_4 of { (HappyWrap32 TypeName
happy_var_4) -> 
	[APIChange] -> HappyAbsSyn
happyIn38
		 ([TypeName -> TypeName -> APIChange
ChRenameType TypeName
happy_var_2 TypeName
happy_var_4]
	) forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}}

happyReduce_73 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_73 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce Int#
4# Int#
33# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_73
happyReduction_73 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_73 (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 -> HappyWrap32
happyOut32 HappyAbsSyn
happy_x_3 of { (HappyWrap32 TypeName
happy_var_3) -> 
	case HappyAbsSyn -> HappyWrap39
happyOut39 HappyAbsSyn
happy_x_4 of { (HappyWrap39 [FieldChange]
happy_var_4) -> 
	[APIChange] -> HappyAbsSyn
happyIn38
		 (forall a b. (a -> b) -> [a] -> [b]
map (TypeName -> FieldChange -> APIChange
fldChangeToAPIChange TypeName
happy_var_3)   (forall a. [a] -> [a]
reverse [FieldChange]
happy_var_4)
	) forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}}

happyReduce_74 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_74 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce Int#
4# Int#
33# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_74
happyReduction_74 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_74 (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 -> HappyWrap32
happyOut32 HappyAbsSyn
happy_x_3 of { (HappyWrap32 TypeName
happy_var_3) -> 
	case HappyAbsSyn -> HappyWrap43
happyOut43 HappyAbsSyn
happy_x_4 of { (HappyWrap43 [UnionChange]
happy_var_4) -> 
	[APIChange] -> HappyAbsSyn
happyIn38
		 (forall a b. (a -> b) -> [a] -> [b]
map (TypeName -> UnionChange -> APIChange
unionChangeToAPIChange TypeName
happy_var_3) (forall a. [a] -> [a]
reverse [UnionChange]
happy_var_4)
	) forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}}

happyReduce_75 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_75 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce Int#
4# Int#
33# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_75
happyReduction_75 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_75 (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 -> HappyWrap32
happyOut32 HappyAbsSyn
happy_x_3 of { (HappyWrap32 TypeName
happy_var_3) -> 
	case HappyAbsSyn -> HappyWrap45
happyOut45 HappyAbsSyn
happy_x_4 of { (HappyWrap45 [EnumChange]
happy_var_4) -> 
	[APIChange] -> HappyAbsSyn
happyIn38
		 (forall a b. (a -> b) -> [a] -> [b]
map (TypeName -> EnumChange -> APIChange
enumChangeToAPIChange TypeName
happy_var_3)  (forall a. [a] -> [a]
reverse [EnumChange]
happy_var_4)
	) forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}}

happyReduce_76 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_76 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce Int#
4# Int#
33# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_76
happyReduction_76 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_76 (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 -> HappyWrap32
happyOut32 HappyAbsSyn
happy_x_3 of { (HappyWrap32 TypeName
happy_var_3) -> 
	case HappyAbsSyn -> HappyWrap47
happyOut47 HappyAbsSyn
happy_x_4 of { (HappyWrap47 String
happy_var_4) -> 
	[APIChange] -> HappyAbsSyn
happyIn38
		 ([TypeName -> String -> APIChange
ChCustomType TypeName
happy_var_3 String
happy_var_4]
	) forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}}

happyReduce_77 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_77 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_2  Int#
33# forall {p}. HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_77
happyReduction_77 :: HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_77 HappyAbsSyn
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap47
happyOut47 HappyAbsSyn
happy_x_2 of { (HappyWrap47 String
happy_var_2) -> 
	[APIChange] -> HappyAbsSyn
happyIn38
		 ([String -> APIChange
ChCustomAll String
happy_var_2]
	)}

happyReduce_78 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_78 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
33# forall {p}. p -> HappyAbsSyn
happyReduction_78
happyReduction_78 :: p -> HappyAbsSyn
happyReduction_78 p
happy_x_1
	 =  [APIChange] -> HappyAbsSyn
happyIn38
		 ([]
	)

happyReduce_79 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_79 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_2  Int#
34# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_79
happyReduction_79 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_79 HappyAbsSyn
happy_x_2
	HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap39
happyOut39 HappyAbsSyn
happy_x_1 of { (HappyWrap39 [FieldChange]
happy_var_1) -> 
	case HappyAbsSyn -> HappyWrap40
happyOut40 HappyAbsSyn
happy_x_2 of { (HappyWrap40 [FieldChange]
happy_var_2) -> 
	[FieldChange] -> HappyAbsSyn
happyIn39
		 ([FieldChange]
happy_var_2 forall a. [a] -> [a] -> [a]
++ [FieldChange]
happy_var_1
	)}}

happyReduce_80 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_80 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
34# HappyAbsSyn -> HappyAbsSyn
happyReduction_80
happyReduction_80 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_80 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap40
happyOut40 HappyAbsSyn
happy_x_1 of { (HappyWrap40 [FieldChange]
happy_var_1) -> 
	[FieldChange] -> HappyAbsSyn
happyIn39
		 ([FieldChange]
happy_var_1
	)}

happyReduce_81 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_81 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce Int#
6# Int#
35# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_81
happyReduction_81 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_81 (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 -> HappyWrap30
happyOut30 HappyAbsSyn
happy_x_3 of { (HappyWrap30 FieldName
happy_var_3) -> 
	case HappyAbsSyn -> HappyWrap27
happyOut27 HappyAbsSyn
happy_x_5 of { (HappyWrap27 APIType
happy_var_5) -> 
	case HappyAbsSyn -> HappyWrap41
happyOut41 HappyAbsSyn
happy_x_6 of { (HappyWrap41 Maybe DefaultValue
happy_var_6) -> 
	[FieldChange] -> HappyAbsSyn
happyIn40
		 ([FieldName -> APIType -> Maybe DefaultValue -> FieldChange
FldChAdd FieldName
happy_var_3 APIType
happy_var_5 Maybe DefaultValue
happy_var_6]
	) forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}}}

happyReduce_82 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_82 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_3  Int#
35# forall {p} {p}. HappyAbsSyn -> p -> p -> HappyAbsSyn
happyReduction_82
happyReduction_82 :: HappyAbsSyn -> p -> p -> HappyAbsSyn
happyReduction_82 HappyAbsSyn
happy_x_3
	p
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap30
happyOut30 HappyAbsSyn
happy_x_3 of { (HappyWrap30 FieldName
happy_var_3) -> 
	[FieldChange] -> HappyAbsSyn
happyIn40
		 ([FieldName -> FieldChange
FldChDelete FieldName
happy_var_3]
	)}

happyReduce_83 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_83 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce Int#
5# Int#
35# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_83
happyReduction_83 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_83 (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 -> HappyWrap30
happyOut30 HappyAbsSyn
happy_x_3 of { (HappyWrap30 FieldName
happy_var_3) -> 
	case HappyAbsSyn -> HappyWrap30
happyOut30 HappyAbsSyn
happy_x_5 of { (HappyWrap30 FieldName
happy_var_5) -> 
	[FieldChange] -> HappyAbsSyn
happyIn40
		 ([FieldName -> FieldName -> FieldChange
FldChRename FieldName
happy_var_3 FieldName
happy_var_5]
	) forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}}

happyReduce_84 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_84 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce Int#
7# Int#
35# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_84
happyReduction_84 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_84 (HappyAbsSyn
happy_x_7 `HappyStk`
	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 -> HappyWrap30
happyOut30 HappyAbsSyn
happy_x_3 of { (HappyWrap30 FieldName
happy_var_3) -> 
	case HappyAbsSyn -> HappyWrap27
happyOut27 HappyAbsSyn
happy_x_5 of { (HappyWrap27 APIType
happy_var_5) -> 
	case HappyAbsSyn -> HappyWrap47
happyOut47 HappyAbsSyn
happy_x_7 of { (HappyWrap47 String
happy_var_7) -> 
	[FieldChange] -> HappyAbsSyn
happyIn40
		 ([FieldName -> APIType -> String -> FieldChange
FldChChange FieldName
happy_var_3 APIType
happy_var_5 String
happy_var_7]
	) forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}}}

happyReduce_85 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_85 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
35# forall {p}. p -> HappyAbsSyn
happyReduction_85
happyReduction_85 :: p -> HappyAbsSyn
happyReduction_85 p
happy_x_1
	 =  [FieldChange] -> HappyAbsSyn
happyIn40
		 ([]
	)

happyReduce_86 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_86 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_2  Int#
36# forall {p}. HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_86
happyReduction_86 :: HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_86 HappyAbsSyn
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap42
happyOut42 HappyAbsSyn
happy_x_2 of { (HappyWrap42 DefaultValue
happy_var_2) -> 
	Maybe DefaultValue -> HappyAbsSyn
happyIn41
		 (forall a. a -> Maybe a
Just DefaultValue
happy_var_2
	)}

happyReduce_87 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_87 = Int#
-> HappyAbsSyn
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_0  Int#
36# HappyAbsSyn
happyReduction_87
happyReduction_87 :: HappyAbsSyn
happyReduction_87  =  Maybe DefaultValue -> HappyAbsSyn
happyIn41
		 (forall a. Maybe a
Nothing
	)

happyReduce_88 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_88 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_2  Int#
37# forall {p} {p}. p -> p -> HappyAbsSyn
happyReduction_88
happyReduction_88 :: p -> p -> HappyAbsSyn
happyReduction_88 p
happy_x_2
	p
happy_x_1
	 =  DefaultValue -> HappyAbsSyn
happyIn42
		 (DefaultValue
DefValList
	)

happyReduce_89 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_89 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
37# forall {p}. p -> HappyAbsSyn
happyReduction_89
happyReduction_89 :: p -> HappyAbsSyn
happyReduction_89 p
happy_x_1
	 =  DefaultValue -> HappyAbsSyn
happyIn42
		 (DefaultValue
DefValMaybe
	)

happyReduce_90 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_90 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
37# HappyAbsSyn -> HappyAbsSyn
happyReduction_90
happyReduction_90 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_90 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> PToken
happyOutTok HappyAbsSyn
happy_x_1 of { ((,) AlexPosn
_ (Strg     String
happy_var_1)) -> 
	DefaultValue -> HappyAbsSyn
happyIn42
		 (Text -> DefaultValue
DefValString (String -> Text
T.pack String
happy_var_1)
	)}

happyReduce_91 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_91 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
37# forall {p}. p -> HappyAbsSyn
happyReduction_91
happyReduction_91 :: p -> HappyAbsSyn
happyReduction_91 p
happy_x_1
	 =  DefaultValue -> HappyAbsSyn
happyIn42
		 (Bool -> DefaultValue
DefValBool Bool
True
	)

happyReduce_92 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_92 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
37# forall {p}. p -> HappyAbsSyn
happyReduction_92
happyReduction_92 :: p -> HappyAbsSyn
happyReduction_92 p
happy_x_1
	 =  DefaultValue -> HappyAbsSyn
happyIn42
		 (Bool -> DefaultValue
DefValBool Bool
False
	)

happyReduce_93 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_93 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
37# HappyAbsSyn -> HappyAbsSyn
happyReduction_93
happyReduction_93 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_93 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> PToken
happyOutTok HappyAbsSyn
happy_x_1 of { ((,) AlexPosn
_ (Intg     Int
happy_var_1)) -> 
	DefaultValue -> HappyAbsSyn
happyIn42
		 (Int -> DefaultValue
DefValInt Int
happy_var_1
	)}

happyReduce_94 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_94 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
37# HappyAbsSyn -> HappyAbsSyn
happyReduction_94
happyReduction_94 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_94 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> PToken
happyOutTok HappyAbsSyn
happy_x_1 of { ((,) AlexPosn
_ (UTCTIME  UTCTime
happy_var_1)) -> 
	DefaultValue -> HappyAbsSyn
happyIn42
		 (UTCTime -> DefaultValue
DefValUtc UTCTime
happy_var_1
	)}

happyReduce_95 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_95 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_2  Int#
38# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_95
happyReduction_95 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_95 HappyAbsSyn
happy_x_2
	HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap43
happyOut43 HappyAbsSyn
happy_x_1 of { (HappyWrap43 [UnionChange]
happy_var_1) -> 
	case HappyAbsSyn -> HappyWrap44
happyOut44 HappyAbsSyn
happy_x_2 of { (HappyWrap44 [UnionChange]
happy_var_2) -> 
	[UnionChange] -> HappyAbsSyn
happyIn43
		 ([UnionChange]
happy_var_2 forall a. [a] -> [a] -> [a]
++ [UnionChange]
happy_var_1
	)}}

happyReduce_96 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_96 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
38# HappyAbsSyn -> HappyAbsSyn
happyReduction_96
happyReduction_96 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_96 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap44
happyOut44 HappyAbsSyn
happy_x_1 of { (HappyWrap44 [UnionChange]
happy_var_1) -> 
	[UnionChange] -> HappyAbsSyn
happyIn43
		 ([UnionChange]
happy_var_1
	)}

happyReduce_97 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_97 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce Int#
5# Int#
39# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_97
happyReduction_97 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_97 (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 -> HappyWrap30
happyOut30 HappyAbsSyn
happy_x_3 of { (HappyWrap30 FieldName
happy_var_3) -> 
	case HappyAbsSyn -> HappyWrap27
happyOut27 HappyAbsSyn
happy_x_5 of { (HappyWrap27 APIType
happy_var_5) -> 
	[UnionChange] -> HappyAbsSyn
happyIn44
		 ([FieldName -> APIType -> UnionChange
UnChAdd FieldName
happy_var_3 APIType
happy_var_5]
	) forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}}

happyReduce_98 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_98 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_3  Int#
39# forall {p} {p}. HappyAbsSyn -> p -> p -> HappyAbsSyn
happyReduction_98
happyReduction_98 :: HappyAbsSyn -> p -> p -> HappyAbsSyn
happyReduction_98 HappyAbsSyn
happy_x_3
	p
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap30
happyOut30 HappyAbsSyn
happy_x_3 of { (HappyWrap30 FieldName
happy_var_3) -> 
	[UnionChange] -> HappyAbsSyn
happyIn44
		 ([FieldName -> UnionChange
UnChDelete FieldName
happy_var_3]
	)}

happyReduce_99 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_99 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce Int#
5# Int#
39# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_99
happyReduction_99 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_99 (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 -> HappyWrap30
happyOut30 HappyAbsSyn
happy_x_3 of { (HappyWrap30 FieldName
happy_var_3) -> 
	case HappyAbsSyn -> HappyWrap30
happyOut30 HappyAbsSyn
happy_x_5 of { (HappyWrap30 FieldName
happy_var_5) -> 
	[UnionChange] -> HappyAbsSyn
happyIn44
		 ([FieldName -> FieldName -> UnionChange
UnChRename FieldName
happy_var_3 FieldName
happy_var_5]
	) forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}}

happyReduce_100 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_100 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
39# forall {p}. p -> HappyAbsSyn
happyReduction_100
happyReduction_100 :: p -> HappyAbsSyn
happyReduction_100 p
happy_x_1
	 =  [UnionChange] -> HappyAbsSyn
happyIn44
		 ([]
	)

happyReduce_101 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_101 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_2  Int#
40# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_101
happyReduction_101 :: HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
happyReduction_101 HappyAbsSyn
happy_x_2
	HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap45
happyOut45 HappyAbsSyn
happy_x_1 of { (HappyWrap45 [EnumChange]
happy_var_1) -> 
	case HappyAbsSyn -> HappyWrap46
happyOut46 HappyAbsSyn
happy_x_2 of { (HappyWrap46 [EnumChange]
happy_var_2) -> 
	[EnumChange] -> HappyAbsSyn
happyIn45
		 ([EnumChange]
happy_var_2 forall a. [a] -> [a] -> [a]
++ [EnumChange]
happy_var_1
	)}}

happyReduce_102 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_102 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
40# HappyAbsSyn -> HappyAbsSyn
happyReduction_102
happyReduction_102 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_102 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap46
happyOut46 HappyAbsSyn
happy_x_1 of { (HappyWrap46 [EnumChange]
happy_var_1) -> 
	[EnumChange] -> HappyAbsSyn
happyIn45
		 ([EnumChange]
happy_var_1
	)}

happyReduce_103 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_103 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_3  Int#
41# forall {p} {p}. HappyAbsSyn -> p -> p -> HappyAbsSyn
happyReduction_103
happyReduction_103 :: HappyAbsSyn -> p -> p -> HappyAbsSyn
happyReduction_103 HappyAbsSyn
happy_x_3
	p
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap30
happyOut30 HappyAbsSyn
happy_x_3 of { (HappyWrap30 FieldName
happy_var_3) -> 
	[EnumChange] -> HappyAbsSyn
happyIn46
		 ([FieldName -> EnumChange
EnChAdd FieldName
happy_var_3]
	)}

happyReduce_104 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_104 = Int#
-> (HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_3  Int#
41# forall {p} {p}. HappyAbsSyn -> p -> p -> HappyAbsSyn
happyReduction_104
happyReduction_104 :: HappyAbsSyn -> p -> p -> HappyAbsSyn
happyReduction_104 HappyAbsSyn
happy_x_3
	p
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> HappyWrap30
happyOut30 HappyAbsSyn
happy_x_3 of { (HappyWrap30 FieldName
happy_var_3) -> 
	[EnumChange] -> HappyAbsSyn
happyIn46
		 ([FieldName -> EnumChange
EnChDelete FieldName
happy_var_3]
	)}

happyReduce_105 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_105 = Int#
-> Int#
-> (HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce Int#
5# Int#
41# HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_105
happyReduction_105 :: HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
happyReduction_105 (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 -> HappyWrap30
happyOut30 HappyAbsSyn
happy_x_3 of { (HappyWrap30 FieldName
happy_var_3) -> 
	case HappyAbsSyn -> HappyWrap30
happyOut30 HappyAbsSyn
happy_x_5 of { (HappyWrap30 FieldName
happy_var_5) -> 
	[EnumChange] -> HappyAbsSyn
happyIn46
		 ([FieldName -> FieldName -> EnumChange
EnChRename FieldName
happy_var_3 FieldName
happy_var_5]
	) forall a. a -> HappyStk a -> HappyStk a
`HappyStk` HappyStk HappyAbsSyn
happyRest}}

happyReduce_106 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_106 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
41# forall {p}. p -> HappyAbsSyn
happyReduction_106
happyReduction_106 :: p -> HappyAbsSyn
happyReduction_106 p
happy_x_1
	 =  [EnumChange] -> HappyAbsSyn
happyIn46
		 ([]
	)

happyReduce_107 :: Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyReduce_107 = Int#
-> (HappyAbsSyn -> HappyAbsSyn)
-> Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happySpecReduce_1  Int#
42# HappyAbsSyn -> HappyAbsSyn
happyReduction_107
happyReduction_107 :: HappyAbsSyn -> HappyAbsSyn
happyReduction_107 HappyAbsSyn
happy_x_1
	 =  case HappyAbsSyn -> PToken
happyOutTok HappyAbsSyn
happy_x_1 of { ((,) AlexPosn
_ (TypeIden String
happy_var_1)) -> 
	String -> HappyAbsSyn
happyIn47
		 (String
happy_var_1
	)}

happyNewToken :: Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyNewToken Int#
action Happy_IntList
sts HappyStk HappyAbsSyn
stk [] =
	Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyDoAction Int#
43# forall a. a
notHappyAtAll Int#
action Happy_IntList
sts HappyStk HappyAbsSyn
stk []

happyNewToken Int#
action Happy_IntList
sts HappyStk HappyAbsSyn
stk (PToken
tk:[PToken]
tks) =
	let cont :: Int# -> ParseM HappyAbsSyn
cont Int#
i = Int#
-> PToken
-> Int#
-> Happy_IntList
-> HappyStk HappyAbsSyn
-> [PToken]
-> ParseM HappyAbsSyn
happyDoAction Int#
i PToken
tk Int#
action Happy_IntList
sts HappyStk HappyAbsSyn
stk [PToken]
tks in
	case PToken
tk of {
	(,) AlexPosn
_ Token
Semi -> Int# -> ParseM HappyAbsSyn
cont Int#
1#;
	(,) AlexPosn
_ Token
Bar -> Int# -> ParseM HappyAbsSyn
cont Int#
2#;
	(,) AlexPosn
_ Token
Bra -> Int# -> ParseM HappyAbsSyn
cont Int#
3#;
	(,) AlexPosn
_ Token
Ket -> Int# -> ParseM HappyAbsSyn
cont Int#
4#;
	(,) AlexPosn
_ Token
ColCol -> Int# -> ParseM HappyAbsSyn
cont Int#
5#;
	(,) AlexPosn
_ Token
Equals -> Int# -> ParseM HappyAbsSyn
cont Int#
6#;
	(,) AlexPosn
_ Token
Query -> Int# -> ParseM HappyAbsSyn
cont Int#
7#;
	(,) AlexPosn
_ Token
Comma -> Int# -> ParseM HappyAbsSyn
cont Int#
8#;
	(,) AlexPosn
_ Token
LtEq -> Int# -> ParseM HappyAbsSyn
cont Int#
9#;
	(,) AlexPosn
_ Token
GtEq -> Int# -> ParseM HappyAbsSyn
cont Int#
10#;
	(,) AlexPosn
_ Token
Version -> Int# -> ParseM HappyAbsSyn
cont Int#
11#;
	(,) AlexPosn
_ Token
With -> Int# -> ParseM HappyAbsSyn
cont Int#
12#;
	(,) AlexPosn
_ Token
Integer -> Int# -> ParseM HappyAbsSyn
cont Int#
13#;
	(,) AlexPosn
_ Token
Boolean -> Int# -> ParseM HappyAbsSyn
cont Int#
14#;
	(,) AlexPosn
_ Token
UTC -> Int# -> ParseM HappyAbsSyn
cont Int#
15#;
	(,) AlexPosn
_ Token
String -> Int# -> ParseM HappyAbsSyn
cont Int#
16#;
	(,) AlexPosn
_ Token
BInary -> Int# -> ParseM HappyAbsSyn
cont Int#
17#;
	(,) AlexPosn
_ Token
Json -> Int# -> ParseM HappyAbsSyn
cont Int#
18#;
	(,) AlexPosn
_ Token
Record -> Int# -> ParseM HappyAbsSyn
cont Int#
19#;
	(,) AlexPosn
_ Token
Union -> Int# -> ParseM HappyAbsSyn
cont Int#
20#;
	(,) AlexPosn
_ Token
Enum -> Int# -> ParseM HappyAbsSyn
cont Int#
21#;
	(,) AlexPosn
_ Token
Basic -> Int# -> ParseM HappyAbsSyn
cont Int#
22#;
	(,) AlexPosn
_ Token
Changes -> Int# -> ParseM HappyAbsSyn
cont Int#
23#;
	(,) AlexPosn
_ Token
Added -> Int# -> ParseM HappyAbsSyn
cont Int#
24#;
	(,) AlexPosn
_ Token
Removed -> Int# -> ParseM HappyAbsSyn
cont Int#
25#;
	(,) AlexPosn
_ Token
Renamed -> Int# -> ParseM HappyAbsSyn
cont Int#
26#;
	(,) AlexPosn
_ Token
Changed -> Int# -> ParseM HappyAbsSyn
cont Int#
27#;
	(,) AlexPosn
_ Token
Default -> Int# -> ParseM HappyAbsSyn
cont Int#
28#;
	(,) AlexPosn
_ Token
Field -> Int# -> ParseM HappyAbsSyn
cont Int#
29#;
	(,) AlexPosn
_ Token
Alternative -> Int# -> ParseM HappyAbsSyn
cont Int#
30#;
	(,) AlexPosn
_ Token
Migration -> Int# -> ParseM HappyAbsSyn
cont Int#
31#;
	(,) AlexPosn
_ Token
To -> Int# -> ParseM HappyAbsSyn
cont Int#
32#;
	(,) AlexPosn
_ Token
NOTHING -> Int# -> ParseM HappyAbsSyn
cont Int#
33#;
	(,) AlexPosn
_ Token
Readonly -> Int# -> ParseM HappyAbsSyn
cont Int#
34#;
	(,) AlexPosn
_ (Comment  String
happy_dollar_dollar) -> Int# -> ParseM HappyAbsSyn
cont Int#
35#;
	(,) AlexPosn
_ (TypeIden String
happy_dollar_dollar) -> Int# -> ParseM HappyAbsSyn
cont Int#
36#;
	(,) AlexPosn
_ (VarIden  String
happy_dollar_dollar) -> Int# -> ParseM HappyAbsSyn
cont Int#
37#;
	(,) AlexPosn
_ (Intg     Int
happy_dollar_dollar) -> Int# -> ParseM HappyAbsSyn
cont Int#
38#;
	(,) AlexPosn
_ (Strg     String
happy_dollar_dollar) -> Int# -> ParseM HappyAbsSyn
cont Int#
39#;
	(,) AlexPosn
_ Token
TRUE -> Int# -> ParseM HappyAbsSyn
cont Int#
40#;
	(,) AlexPosn
_ Token
FALSE -> Int# -> ParseM HappyAbsSyn
cont Int#
41#;
	(,) AlexPosn
_ (UTCTIME  UTCTime
happy_dollar_dollar) -> Int# -> ParseM HappyAbsSyn
cont Int#
42#;
	PToken
_ -> forall a. ([PToken], [String]) -> ParseM a
happyError' ((PToken
tkforall a. a -> [a] -> [a]
:[PToken]
tks), [])
	}

happyError_ :: [String] -> Int# -> PToken -> [PToken] -> ParseM a
happyError_ [String]
explist Int#
43# PToken
tk [PToken]
tks = forall a. ([PToken], [String]) -> ParseM a
happyError' ([PToken]
tks, [String]
explist)
happyError_ [String]
explist Int#
_ PToken
tk [PToken]
tks = forall a. ([PToken], [String]) -> ParseM a
happyError' ((PToken
tkforall a. a -> [a] -> [a]
:[PToken]
tks), [String]
explist)

happyThen :: () => ParseM a -> (a -> ParseM b) -> ParseM b
happyThen :: forall a b. ParseM a -> (a -> ParseM b) -> ParseM b
happyThen = forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
(>>=)
happyReturn :: () => a -> ParseM a
happyReturn :: forall a. a -> ParseM a
happyReturn = (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)
happyReturn1 :: () => a -> b -> ParseM a
happyReturn1 :: forall a b. a -> b -> ParseM a
happyReturn1 = \a
a b
tks -> (forall (m :: * -> *) a. Monad m => a -> m a
return) a
a
happyError' :: () => ([(PToken)], [Prelude.String]) -> ParseM a
happyError' :: forall a. ([PToken], [String]) -> ParseM a
happyError' = (\([PToken]
tokens, [String]
_) -> forall a. [PToken] -> ParseM a
happyError [PToken]
tokens)
parse :: [PToken] -> ParseM API
parse [PToken]
tks = ParseM API
happySomeParser where
 happySomeParser :: ParseM API
happySomeParser = forall a b. ParseM a -> (a -> ParseM b) -> ParseM b
happyThen (Int# -> [PToken] -> ParseM HappyAbsSyn
happyParse Int#
0# [PToken]
tks) (\HappyAbsSyn
x -> forall a. a -> ParseM a
happyReturn (let {(HappyWrap6 API
x') = HappyAbsSyn -> HappyWrap6
happyOut6 HappyAbsSyn
x} in API
x'))

parse_with_changelog :: [PToken] -> ParseM APIWithChangelog
parse_with_changelog [PToken]
tks = ParseM APIWithChangelog
happySomeParser where
 happySomeParser :: ParseM APIWithChangelog
happySomeParser = forall a b. ParseM a -> (a -> ParseM b) -> ParseM b
happyThen (Int# -> [PToken] -> ParseM HappyAbsSyn
happyParse Int#
1# [PToken]
tks) (\HappyAbsSyn
x -> forall a. a -> ParseM a
happyReturn (let {(HappyWrap5 APIWithChangelog
x') = HappyAbsSyn -> HappyWrap5
happyOut5 HappyAbsSyn
x} in APIWithChangelog
x'))

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


type ParseM = Either [PToken]

happyError :: [PToken] -> ParseM a
happyError :: forall a. [PToken] -> ParseM a
happyError = forall a b. a -> Either a b
Left

parseAPI :: String -> (Int, Int) -> String -> API
parseAPI :: String -> CharPos -> String -> API
parseAPI = forall a.
([PToken] -> ParseM a) -> String -> CharPos -> String -> a
wrap [PToken] -> ParseM API
parse

wrap :: ([PToken] -> ParseM a) -> String -> (Int, Int) -> String -> a
wrap :: forall a.
([PToken] -> ParseM a) -> String -> CharPos -> String -> a
wrap [PToken] -> ParseM a
parser String
fn (Int
start_ln,Int
_start_cn) String
s = case [PToken] -> ParseM a
parser (String -> [PToken]
scan String
s) of
    Right a
v  -> a
v
    Left [PToken]
tks -> forall a. HasCallStack => String -> a
error forall a b. (a -> b) -> a -> b
$ forall r. PrintfType r => String -> r
printf String
"Syntax error at %s of %s:\n        %s\n" (forall {b}. [(AlexPosn, b)] -> String
loc [PToken]
tks) String
fn forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> String
show (forall a. Int -> [a] -> [a]
take Int
5 [PToken]
tks)
  where
    loc :: [(AlexPosn, b)] -> String
loc [(AlexPosn, b)]
tks = case [(AlexPosn, b)]
tks of
            []                    -> String
"<EOF>"
            (AlexPn Int
ad Int
ln Int
cn,b
_):[(AlexPosn, b)]
_ -> forall r. PrintfType r => String -> r
printf String
"line %d, column %d (@%d)" (Int
start_lnforall a. Num a => a -> a -> a
+Int
lnforall a. Num a => a -> a -> a
-Int
1) (Int
cnforall a. Num a => a -> a -> a
-Int
1) Int
ad

parseAPIWithChangelog :: String -> (Int, Int) -> String -> APIWithChangelog
parseAPIWithChangelog :: String -> CharPos -> String -> APIWithChangelog
parseAPIWithChangelog = forall a.
([PToken] -> ParseM a) -> String -> CharPos -> String -> a
wrap [PToken] -> ParseM APIWithChangelog
parse_with_changelog


data FieldChange = FldChAdd FieldName APIType (Maybe DefaultValue)
                 | FldChDelete FieldName
                 | FldChRename FieldName FieldName
                 | FldChChange FieldName APIType MigrationTag

fldChangeToAPIChange :: TypeName -> FieldChange -> APIChange
fldChangeToAPIChange :: TypeName -> FieldChange -> APIChange
fldChangeToAPIChange TypeName
t (FldChAdd FieldName
f APIType
ty Maybe DefaultValue
def)  = TypeName -> FieldName -> APIType -> Maybe DefaultValue -> APIChange
ChAddField TypeName
t FieldName
f APIType
ty Maybe DefaultValue
def
fldChangeToAPIChange TypeName
t (FldChDelete FieldName
f)      = TypeName -> FieldName -> APIChange
ChDeleteField TypeName
t FieldName
f
fldChangeToAPIChange TypeName
t (FldChRename FieldName
f FieldName
f')   = TypeName -> FieldName -> FieldName -> APIChange
ChRenameField TypeName
t FieldName
f FieldName
f'
fldChangeToAPIChange TypeName
t (FldChChange FieldName
f APIType
ty String
m) = TypeName -> FieldName -> APIType -> String -> APIChange
ChChangeField TypeName
t FieldName
f APIType
ty String
m

data UnionChange = UnChAdd FieldName APIType
                 | UnChDelete FieldName
                 | UnChRename FieldName FieldName

unionChangeToAPIChange :: TypeName -> UnionChange -> APIChange
unionChangeToAPIChange :: TypeName -> UnionChange -> APIChange
unionChangeToAPIChange TypeName
t (UnChAdd FieldName
f APIType
ty)    = TypeName -> FieldName -> APIType -> APIChange
ChAddUnionAlt TypeName
t FieldName
f APIType
ty
unionChangeToAPIChange TypeName
t (UnChDelete FieldName
f)    = TypeName -> FieldName -> APIChange
ChDeleteUnionAlt TypeName
t FieldName
f
unionChangeToAPIChange TypeName
t (UnChRename FieldName
f FieldName
f') = TypeName -> FieldName -> FieldName -> APIChange
ChRenameUnionAlt TypeName
t FieldName
f FieldName
f'

data EnumChange = EnChAdd FieldName
                | EnChDelete FieldName
                | EnChRename FieldName FieldName

enumChangeToAPIChange :: TypeName -> EnumChange -> APIChange
enumChangeToAPIChange :: TypeName -> EnumChange -> APIChange
enumChangeToAPIChange TypeName
t (EnChAdd FieldName
f)       = TypeName -> FieldName -> APIChange
ChAddEnumVal TypeName
t FieldName
f
enumChangeToAPIChange TypeName
t (EnChDelete FieldName
f)    = TypeName -> FieldName -> APIChange
ChDeleteEnumVal TypeName
t FieldName
f
enumChangeToAPIChange TypeName
t (EnChRename FieldName
f FieldName
f') = TypeName -> FieldName -> FieldName -> APIChange
ChRenameEnumVal TypeName
t FieldName
f FieldName
f'


parseVer :: String -> V.Version
parseVer :: String -> Version
parseVer String
x = case String -> Maybe Version
simpleParseVersion String
x of
                 Just Version
v -> Version
v
                 Maybe Version
Nothing -> forall a. HasCallStack => String -> a
error forall a b. (a -> b) -> a -> b
$ String
"Syntax error while parsing version " forall a. [a] -> [a] -> [a]
++ String
x

parseVersionExtra :: String -> VersionExtra
parseVersionExtra :: String -> VersionExtra
parseVersionExtra String
"development" = VersionExtra
DevVersion
parseVersionExtra String
s             = Version -> VersionExtra
Release forall a b. (a -> b) -> a -> b
$ String -> Version
parseVer String
s


api :: QuasiQuoter
api :: QuasiQuoter
api =
    QuasiQuoter
        { quoteExp :: String -> Q Exp
quoteExp  = Q Exp -> String -> Q Exp
located [|parseAPI|]
        , quotePat :: String -> Q Pat
quotePat  = forall a. HasCallStack => String -> a
error String
"api QuasiQuoter used in patten      context"
        , quoteType :: String -> Q Type
quoteType = forall a. HasCallStack => String -> a
error String
"api QuasiQuoter used in type        context"
        , quoteDec :: String -> Q [Dec]
quoteDec  = forall a. HasCallStack => String -> a
error String
"api QuasiQuoter used in declaration context"
        }

apiWithChangelog :: QuasiQuoter
apiWithChangelog :: QuasiQuoter
apiWithChangelog =
    QuasiQuoter
        { quoteExp :: String -> Q Exp
quoteExp  = Q Exp -> String -> Q Exp
located [|parseAPIWithChangelog|]
        , quotePat :: String -> Q Pat
quotePat  = forall a. HasCallStack => String -> a
error String
"apiWithChangelog QuasiQuoter used in patten      context"
        , quoteType :: String -> Q Type
quoteType = forall a. HasCallStack => String -> a
error String
"apiWithChangelog QuasiQuoter used in type        context"
        , quoteDec :: String -> Q [Dec]
quoteDec  = forall a. HasCallStack => String -> a
error String
"apiWithChangelog QuasiQuoter used in declaration context"
        }

located :: ExpQ -> String -> ExpQ
located :: Q Exp -> String -> Q Exp
located Q Exp
e String
s = do
    Loc
l <- Q Loc
location
    let fn :: String
fn = Loc -> String
loc_filename Loc
l
        ls :: CharPos
ls = Loc -> CharPos
loc_start    Loc
l
    [|$(e) fn ls s|]
{-# LINE 1 "templates/GenericTemplate.hs" #-}
-- $Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp $













-- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex.
#if __GLASGOW_HASKELL__ > 706
#define LT(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.<# m)) :: Prelude.Bool)
#define GTE(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.>=# m)) :: Prelude.Bool)
#define EQ(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.==# m)) :: Prelude.Bool)
#else
#define LT(n,m) (n Happy_GHC_Exts.<# m)
#define GTE(n,m) (n Happy_GHC_Exts.>=# m)
#define EQ(n,m) (n Happy_GHC_Exts.==# m)
#endif



















data Happy_IntList = HappyCons Happy_GHC_Exts.Int# Happy_IntList








































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

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

happyParse start_state = happyNewToken start_state notHappyAtAll 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 0# tk st sts (_ `HappyStk` ans `HappyStk` _) =
        happyReturn1 ans
happyAccept j tk st sts (HappyStk ans _) = 
        (happyTcHack j (happyTcHack st)) (happyReturn1 ans)

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



happyDoAction i tk st
        = {- nothing -}
          case action of
                0#           -> {- nothing -}
                                     happyFail (happyExpListPerState ((Happy_GHC_Exts.I# (st)) :: Prelude.Int)) i tk st
                -1#          -> {- nothing -}
                                     happyAccept i tk st
                n | LT(n,(0# :: Happy_GHC_Exts.Int#)) -> {- nothing -}
                                                   (happyReduceArr Happy_Data_Array.! rule) i tk st
                                                   where rule = (Happy_GHC_Exts.I# ((Happy_GHC_Exts.negateInt# ((n Happy_GHC_Exts.+# (1# :: Happy_GHC_Exts.Int#))))))
                n                 -> {- nothing -}
                                     happyShift new_state i tk st
                                     where new_state = (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#))
   where off    = happyAdjustOffset (indexShortOffAddr happyActOffsets st)
         off_i  = (off Happy_GHC_Exts.+# i)
         check  = if GTE(off_i,(0# :: Happy_GHC_Exts.Int#))
                  then EQ(indexShortOffAddr happyCheck off_i, i)
                  else Prelude.False
         action
          | check     = indexShortOffAddr happyTable off_i
          | Prelude.otherwise = indexShortOffAddr happyDefActions st




indexShortOffAddr (HappyA# arr) off =
        Happy_GHC_Exts.narrow16Int# i
  where
        i = Happy_GHC_Exts.word2Int# (Happy_GHC_Exts.or# (Happy_GHC_Exts.uncheckedShiftL# high 8#) low)
        high = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr (off' Happy_GHC_Exts.+# 1#)))
        low  = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr off'))
        off' = off Happy_GHC_Exts.*# 2#




{-# INLINE happyLt #-}
happyLt x y = LT(x,y)


readArrayBit arr bit =
    Bits.testBit (Happy_GHC_Exts.I# (indexShortOffAddr arr ((unbox_int bit) `Happy_GHC_Exts.iShiftRA#` 4#))) (bit `Prelude.mod` 16)
  where unbox_int (Happy_GHC_Exts.I# x) = x






data HappyAddr = HappyA# Happy_GHC_Exts.Addr#


-----------------------------------------------------------------------------
-- HappyState data type (not arrays)













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

happyShift new_state 0# tk st sts stk@(x `HappyStk` _) =
     let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in
--     trace "shifting the error token" $
     happyDoAction i tk new_state (HappyCons (st) (sts)) (stk)

happyShift new_state i tk st sts stk =
     happyNewToken new_state (HappyCons (st) (sts)) ((happyInTok (tk))`HappyStk`stk)

-- happyReduce is specialised for the common cases.

happySpecReduce_0 i fn 0# tk st sts stk
     = happyFail [] 0# tk st sts stk
happySpecReduce_0 nt fn j tk st@((action)) sts stk
     = happyGoto nt j tk st (HappyCons (st) (sts)) (fn `HappyStk` stk)

happySpecReduce_1 i fn 0# tk st sts stk
     = happyFail [] 0# tk st sts stk
happySpecReduce_1 nt fn j tk _ sts@((HappyCons (st@(action)) (_))) (v1`HappyStk`stk')
     = let r = fn v1 in
       happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))

happySpecReduce_2 i fn 0# tk st sts stk
     = happyFail [] 0# tk st sts stk
happySpecReduce_2 nt fn j tk _ (HappyCons (_) (sts@((HappyCons (st@(action)) (_))))) (v1`HappyStk`v2`HappyStk`stk')
     = let r = fn v1 v2 in
       happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))

happySpecReduce_3 i fn 0# tk st sts stk
     = happyFail [] 0# tk st sts stk
happySpecReduce_3 nt fn j tk _ (HappyCons (_) ((HappyCons (_) (sts@((HappyCons (st@(action)) (_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk')
     = let r = fn v1 v2 v3 in
       happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk'))

happyReduce k i fn 0# tk st sts stk
     = happyFail [] 0# tk st sts stk
happyReduce k nt fn j tk st sts stk
     = case happyDrop (k Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) sts of
         sts1@((HappyCons (st1@(action)) (_))) ->
                let r = fn stk in  -- it doesn't hurt to always seq here...
                happyDoSeq r (happyGoto nt j tk st1 sts1 r)

happyMonadReduce k nt fn 0# tk st sts stk
     = happyFail [] 0# tk st sts stk
happyMonadReduce k nt fn j tk st sts stk =
      case happyDrop k (HappyCons (st) (sts)) of
        sts1@((HappyCons (st1@(action)) (_))) ->
          let drop_stk = happyDropStk k stk in
          happyThen1 (fn stk tk) (\r -> happyGoto nt j tk st1 sts1 (r `HappyStk` drop_stk))

happyMonad2Reduce k nt fn 0# tk st sts stk
     = happyFail [] 0# tk st sts stk
happyMonad2Reduce k nt fn j tk st sts stk =
      case happyDrop k (HappyCons (st) (sts)) of
        sts1@((HappyCons (st1@(action)) (_))) ->
         let drop_stk = happyDropStk k stk

             off = happyAdjustOffset (indexShortOffAddr happyGotoOffsets st1)
             off_i = (off Happy_GHC_Exts.+# nt)
             new_state = indexShortOffAddr happyTable off_i




          in
          happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk))

happyDrop 0# l = l
happyDrop n (HappyCons (_) (t)) = happyDrop (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) t

happyDropStk 0# l = l
happyDropStk n (x `HappyStk` xs) = happyDropStk (n Happy_GHC_Exts.-# (1#::Happy_GHC_Exts.Int#)) xs

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


happyGoto nt j tk st = 
   {- nothing -}
   happyDoAction j tk new_state
   where off = happyAdjustOffset (indexShortOffAddr happyGotoOffsets st)
         off_i = (off Happy_GHC_Exts.+# nt)
         new_state = indexShortOffAddr happyTable off_i




-----------------------------------------------------------------------------
-- Error recovery (ERROR_TOK is the error token)

-- parse error if we are in recovery and we fail again
happyFail explist 0# tk old_st _ stk@(x `HappyStk` _) =
     let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in
--      trace "failing" $ 
        happyError_ explist i tk

{-  We don't need state discarding for our restricted implementation of
    "error".  In fact, it can cause some bogus parses, so I've disabled it
    for now --SDM

-- discard a state
happyFail  ERROR_TOK tk old_st CONS(HAPPYSTATE(action),sts) 
                                                (saved_tok `HappyStk` _ `HappyStk` stk) =
--      trace ("discarding state, depth " ++ show (length stk))  $
        DO_ACTION(action,ERROR_TOK,tk,sts,(saved_tok`HappyStk`stk))
-}

-- Enter error recovery: generate an error token,
--                       save the old token and carry on.
happyFail explist i tk (action) sts stk =
--      trace "entering error recovery" $
        happyDoAction 0# tk action sts ((Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# (i))) `HappyStk` stk)

-- Internal happy errors:

notHappyAtAll :: a
notHappyAtAll = Prelude.error "Internal Happy error\n"

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


happyTcHack :: Happy_GHC_Exts.Int# -> a -> a
happyTcHack x y = 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   a b = a `Prelude.seq` b
happyDontSeq a 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.