{-# 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.19.9

newtype HappyAbsSyn  = HappyAbsSyn HappyAny
#if __GLASGOW_HASKELL__ >= 607
type HappyAny = Happy_GHC_Exts.Any
#else
type HappyAny = forall a . a
#endif
happyIn5 :: (APIWithChangelog) -> (HappyAbsSyn )
happyIn5 :: APIWithChangelog -> HappyAbsSyn
happyIn5 APIWithChangelog
x = APIWithChangelog -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# APIWithChangelog
x
{-# INLINE happyIn5 #-}
happyOut5 :: (HappyAbsSyn ) -> (APIWithChangelog)
happyOut5 :: HappyAbsSyn -> APIWithChangelog
happyOut5 HappyAbsSyn
x = HappyAbsSyn -> APIWithChangelog
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut5 #-}
happyIn6 :: (API) -> (HappyAbsSyn )
happyIn6 :: API -> HappyAbsSyn
happyIn6 API
x = API -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# API
x
{-# INLINE happyIn6 #-}
happyOut6 :: (HappyAbsSyn ) -> (API)
happyOut6 :: HappyAbsSyn -> API
happyOut6 HappyAbsSyn
x = HappyAbsSyn -> API
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut6 #-}
happyIn7 :: ([Thing]) -> (HappyAbsSyn )
happyIn7 :: API -> HappyAbsSyn
happyIn7 API
x = API -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# API
x
{-# INLINE happyIn7 #-}
happyOut7 :: (HappyAbsSyn ) -> ([Thing])
happyOut7 :: HappyAbsSyn -> API
happyOut7 HappyAbsSyn
x = HappyAbsSyn -> API
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut7 #-}
happyIn8 :: (Thing) -> (HappyAbsSyn )
happyIn8 :: Thing -> HappyAbsSyn
happyIn8 Thing
x = Thing -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# Thing
x
{-# INLINE happyIn8 #-}
happyOut8 :: (HappyAbsSyn ) -> (Thing)
happyOut8 :: HappyAbsSyn -> Thing
happyOut8 HappyAbsSyn
x = HappyAbsSyn -> Thing
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut8 #-}
happyIn9 :: (APINode) -> (HappyAbsSyn )
happyIn9 :: APINode -> HappyAbsSyn
happyIn9 APINode
x = APINode -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# APINode
x
{-# INLINE happyIn9 #-}
happyOut9 :: (HappyAbsSyn ) -> (APINode)
happyOut9 :: HappyAbsSyn -> APINode
happyOut9 HappyAbsSyn
x = HappyAbsSyn -> APINode
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut9 #-}
happyIn10 :: (Spec) -> (HappyAbsSyn )
happyIn10 :: Spec -> HappyAbsSyn
happyIn10 Spec
x = Spec -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# Spec
x
{-# INLINE happyIn10 #-}
happyOut10 :: (HappyAbsSyn ) -> (Spec)
happyOut10 :: HappyAbsSyn -> Spec
happyOut10 HappyAbsSyn
x = HappyAbsSyn -> Spec
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut10 #-}
happyIn11 :: (Conversion) -> (HappyAbsSyn )
happyIn11 :: Conversion -> HappyAbsSyn
happyIn11 Conversion
x = Conversion -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# Conversion
x
{-# INLINE happyIn11 #-}
happyOut11 :: (HappyAbsSyn ) -> (Conversion)
happyOut11 :: HappyAbsSyn -> Conversion
happyOut11 HappyAbsSyn
x = HappyAbsSyn -> Conversion
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut11 #-}
happyIn12 :: (MDComment) -> (HappyAbsSyn )
happyIn12 :: MDComment -> HappyAbsSyn
happyIn12 MDComment
x = MDComment -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# MDComment
x
{-# INLINE happyIn12 #-}
happyOut12 :: (HappyAbsSyn ) -> (MDComment)
happyOut12 :: HappyAbsSyn -> MDComment
happyOut12 HappyAbsSyn
x = HappyAbsSyn -> MDComment
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut12 #-}
happyIn13 :: ([MDComment]) -> (HappyAbsSyn )
happyIn13 :: [MDComment] -> HappyAbsSyn
happyIn13 [MDComment]
x = [MDComment] -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# [MDComment]
x
{-# INLINE happyIn13 #-}
happyOut13 :: (HappyAbsSyn ) -> ([MDComment])
happyOut13 :: HappyAbsSyn -> [MDComment]
happyOut13 HappyAbsSyn
x = HappyAbsSyn -> [MDComment]
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut13 #-}
happyIn14 :: (Prefix) -> (HappyAbsSyn )
happyIn14 :: Prefix -> HappyAbsSyn
happyIn14 Prefix
x = Prefix -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# Prefix
x
{-# INLINE happyIn14 #-}
happyOut14 :: (HappyAbsSyn ) -> (Prefix)
happyOut14 :: HappyAbsSyn -> Prefix
happyOut14 HappyAbsSyn
x = HappyAbsSyn -> Prefix
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut14 #-}
happyIn15 :: (SpecRecord) -> (HappyAbsSyn )
happyIn15 :: SpecRecord -> HappyAbsSyn
happyIn15 SpecRecord
x = SpecRecord -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# SpecRecord
x
{-# INLINE happyIn15 #-}
happyOut15 :: (HappyAbsSyn ) -> (SpecRecord)
happyOut15 :: HappyAbsSyn -> SpecRecord
happyOut15 HappyAbsSyn
x = HappyAbsSyn -> SpecRecord
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut15 #-}
happyIn16 :: (SpecUnion) -> (HappyAbsSyn )
happyIn16 :: SpecUnion -> HappyAbsSyn
happyIn16 SpecUnion
x = SpecUnion -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# SpecUnion
x
{-# INLINE happyIn16 #-}
happyOut16 :: (HappyAbsSyn ) -> (SpecUnion)
happyOut16 :: HappyAbsSyn -> SpecUnion
happyOut16 HappyAbsSyn
x = HappyAbsSyn -> SpecUnion
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut16 #-}
happyIn17 :: ([(FieldName, FieldType)]) -> (HappyAbsSyn )
happyIn17 :: [(FieldName, FieldType)] -> HappyAbsSyn
happyIn17 [(FieldName, FieldType)]
x = [(FieldName, FieldType)] -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# [(FieldName, FieldType)]
x
{-# INLINE happyIn17 #-}
happyOut17 :: (HappyAbsSyn ) -> ([(FieldName, FieldType)])
happyOut17 :: HappyAbsSyn -> [(FieldName, FieldType)]
happyOut17 HappyAbsSyn
x = HappyAbsSyn -> [(FieldName, FieldType)]
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut17 #-}
happyIn18 :: (FieldType) -> (HappyAbsSyn )
happyIn18 :: FieldType -> HappyAbsSyn
happyIn18 FieldType
x = FieldType -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# FieldType
x
{-# INLINE happyIn18 #-}
happyOut18 :: (HappyAbsSyn ) -> (FieldType)
happyOut18 :: HappyAbsSyn -> FieldType
happyOut18 HappyAbsSyn
x = HappyAbsSyn -> FieldType
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut18 #-}
happyIn19 :: (Bool) -> (HappyAbsSyn )
happyIn19 :: Bool -> HappyAbsSyn
happyIn19 Bool
x = Bool -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# Bool
x
{-# INLINE happyIn19 #-}
happyOut19 :: (HappyAbsSyn ) -> (Bool)
happyOut19 :: HappyAbsSyn -> Bool
happyOut19 HappyAbsSyn
x = HappyAbsSyn -> Bool
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut19 #-}
happyIn20 :: ([(FieldName,(APIType,MDComment))]) -> (HappyAbsSyn )
happyIn20 :: [(FieldName, (APIType, MDComment))] -> HappyAbsSyn
happyIn20 [(FieldName, (APIType, MDComment))]
x = [(FieldName, (APIType, MDComment))] -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# [(FieldName, (APIType, MDComment))]
x
{-# INLINE happyIn20 #-}
happyOut20 :: (HappyAbsSyn ) -> ([(FieldName,(APIType,MDComment))])
happyOut20 :: HappyAbsSyn -> [(FieldName, (APIType, MDComment))]
happyOut20 HappyAbsSyn
x = HappyAbsSyn -> [(FieldName, (APIType, MDComment))]
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut20 #-}
happyIn21 :: (SpecEnum) -> (HappyAbsSyn )
happyIn21 :: SpecEnum -> HappyAbsSyn
happyIn21 SpecEnum
x = SpecEnum -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# SpecEnum
x
{-# INLINE happyIn21 #-}
happyOut21 :: (HappyAbsSyn ) -> (SpecEnum)
happyOut21 :: HappyAbsSyn -> SpecEnum
happyOut21 HappyAbsSyn
x = HappyAbsSyn -> SpecEnum
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut21 #-}
happyIn22 :: ([(FieldName,MDComment)]) -> (HappyAbsSyn )
happyIn22 :: [(FieldName, MDComment)] -> HappyAbsSyn
happyIn22 [(FieldName, MDComment)]
x = [(FieldName, MDComment)] -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# [(FieldName, MDComment)]
x
{-# INLINE happyIn22 #-}
happyOut22 :: (HappyAbsSyn ) -> ([(FieldName,MDComment)])
happyOut22 :: HappyAbsSyn -> [(FieldName, MDComment)]
happyOut22 HappyAbsSyn
x = HappyAbsSyn -> [(FieldName, MDComment)]
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut22 #-}
happyIn23 :: (SpecNewtype) -> (HappyAbsSyn )
happyIn23 :: SpecNewtype -> HappyAbsSyn
happyIn23 SpecNewtype
x = SpecNewtype -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# SpecNewtype
x
{-# INLINE happyIn23 #-}
happyOut23 :: (HappyAbsSyn ) -> (SpecNewtype)
happyOut23 :: HappyAbsSyn -> SpecNewtype
happyOut23 HappyAbsSyn
x = HappyAbsSyn -> SpecNewtype
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut23 #-}
happyIn24 :: (Maybe Filter) -> (HappyAbsSyn )
happyIn24 :: Maybe Filter -> HappyAbsSyn
happyIn24 Maybe Filter
x = Maybe Filter -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# Maybe Filter
x
{-# INLINE happyIn24 #-}
happyOut24 :: (HappyAbsSyn ) -> (Maybe Filter)
happyOut24 :: HappyAbsSyn -> Maybe Filter
happyOut24 HappyAbsSyn
x = HappyAbsSyn -> Maybe Filter
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut24 #-}
happyIn25 :: (Filter) -> (HappyAbsSyn )
happyIn25 :: Filter -> HappyAbsSyn
happyIn25 Filter
x = Filter -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# Filter
x
{-# INLINE happyIn25 #-}
happyOut25 :: (HappyAbsSyn ) -> (Filter)
happyOut25 :: HappyAbsSyn -> Filter
happyOut25 HappyAbsSyn
x = HappyAbsSyn -> Filter
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut25 #-}
happyIn26 :: (RegEx) -> (HappyAbsSyn )
happyIn26 :: RegEx -> HappyAbsSyn
happyIn26 RegEx
x = RegEx -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# RegEx
x
{-# INLINE happyIn26 #-}
happyOut26 :: (HappyAbsSyn ) -> (RegEx)
happyOut26 :: HappyAbsSyn -> RegEx
happyOut26 HappyAbsSyn
x = HappyAbsSyn -> RegEx
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut26 #-}
happyIn27 :: (APIType) -> (HappyAbsSyn )
happyIn27 :: APIType -> HappyAbsSyn
happyIn27 APIType
x = APIType -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# APIType
x
{-# INLINE happyIn27 #-}
happyOut27 :: (HappyAbsSyn ) -> (APIType)
happyOut27 :: HappyAbsSyn -> APIType
happyOut27 HappyAbsSyn
x = HappyAbsSyn -> APIType
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut27 #-}
happyIn28 :: (Maybe DefaultValue) -> (HappyAbsSyn )
happyIn28 :: Maybe DefaultValue -> HappyAbsSyn
happyIn28 Maybe DefaultValue
x = Maybe DefaultValue -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# Maybe DefaultValue
x
{-# INLINE happyIn28 #-}
happyOut28 :: (HappyAbsSyn ) -> (Maybe DefaultValue)
happyOut28 :: HappyAbsSyn -> Maybe DefaultValue
happyOut28 HappyAbsSyn
x = HappyAbsSyn -> Maybe DefaultValue
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut28 #-}
happyIn29 :: (BasicType) -> (HappyAbsSyn )
happyIn29 :: BasicType -> HappyAbsSyn
happyIn29 BasicType
x = BasicType -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# BasicType
x
{-# INLINE happyIn29 #-}
happyOut29 :: (HappyAbsSyn ) -> (BasicType)
happyOut29 :: HappyAbsSyn -> BasicType
happyOut29 HappyAbsSyn
x = HappyAbsSyn -> BasicType
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut29 #-}
happyIn30 :: (FieldName) -> (HappyAbsSyn )
happyIn30 :: FieldName -> HappyAbsSyn
happyIn30 FieldName
x = FieldName -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# FieldName
x
{-# INLINE happyIn30 #-}
happyOut30 :: (HappyAbsSyn ) -> (FieldName)
happyOut30 :: HappyAbsSyn -> FieldName
happyOut30 HappyAbsSyn
x = HappyAbsSyn -> FieldName
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut30 #-}
happyIn31 :: (String) -> (HappyAbsSyn )
happyIn31 :: MDComment -> HappyAbsSyn
happyIn31 MDComment
x = MDComment -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# MDComment
x
{-# INLINE happyIn31 #-}
happyOut31 :: (HappyAbsSyn ) -> (String)
happyOut31 :: HappyAbsSyn -> MDComment
happyOut31 HappyAbsSyn
x = HappyAbsSyn -> MDComment
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut31 #-}
happyIn32 :: (TypeName) -> (HappyAbsSyn )
happyIn32 :: TypeName -> HappyAbsSyn
happyIn32 TypeName
x = TypeName -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# TypeName
x
{-# INLINE happyIn32 #-}
happyOut32 :: (HappyAbsSyn ) -> (TypeName)
happyOut32 :: HappyAbsSyn -> TypeName
happyOut32 HappyAbsSyn
x = HappyAbsSyn -> TypeName
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut32 #-}
happyIn33 :: (APIChangelog) -> (HappyAbsSyn )
happyIn33 :: APIChangelog -> HappyAbsSyn
happyIn33 APIChangelog
x = APIChangelog -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# APIChangelog
x
{-# INLINE happyIn33 #-}
happyOut33 :: (HappyAbsSyn ) -> (APIChangelog)
happyOut33 :: HappyAbsSyn -> APIChangelog
happyOut33 HappyAbsSyn
x = HappyAbsSyn -> APIChangelog
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut33 #-}
happyIn34 :: (V.Version) -> (HappyAbsSyn )
happyIn34 :: Version -> HappyAbsSyn
happyIn34 Version
x = Version -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# Version
x
{-# INLINE happyIn34 #-}
happyOut34 :: (HappyAbsSyn ) -> (V.Version)
happyOut34 :: HappyAbsSyn -> Version
happyOut34 HappyAbsSyn
x = HappyAbsSyn -> Version
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut34 #-}
happyIn35 :: (VersionExtra) -> (HappyAbsSyn )
happyIn35 :: VersionExtra -> HappyAbsSyn
happyIn35 VersionExtra
x = VersionExtra -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# VersionExtra
x
{-# INLINE happyIn35 #-}
happyOut35 :: (HappyAbsSyn ) -> (VersionExtra)
happyOut35 :: HappyAbsSyn -> VersionExtra
happyOut35 HappyAbsSyn
x = HappyAbsSyn -> VersionExtra
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut35 #-}
happyIn36 :: ([APIChange]) -> (HappyAbsSyn )
happyIn36 :: [APIChange] -> HappyAbsSyn
happyIn36 [APIChange]
x = [APIChange] -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# [APIChange]
x
{-# INLINE happyIn36 #-}
happyOut36 :: (HappyAbsSyn ) -> ([APIChange])
happyOut36 :: HappyAbsSyn -> [APIChange]
happyOut36 HappyAbsSyn
x = HappyAbsSyn -> [APIChange]
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut36 #-}
happyIn37 :: ([[APIChange]]) -> (HappyAbsSyn )
happyIn37 :: [[APIChange]] -> HappyAbsSyn
happyIn37 [[APIChange]]
x = [[APIChange]] -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# [[APIChange]]
x
{-# INLINE happyIn37 #-}
happyOut37 :: (HappyAbsSyn ) -> ([[APIChange]])
happyOut37 :: HappyAbsSyn -> [[APIChange]]
happyOut37 HappyAbsSyn
x = HappyAbsSyn -> [[APIChange]]
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut37 #-}
happyIn38 :: ([APIChange]) -> (HappyAbsSyn )
happyIn38 :: [APIChange] -> HappyAbsSyn
happyIn38 [APIChange]
x = [APIChange] -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# [APIChange]
x
{-# INLINE happyIn38 #-}
happyOut38 :: (HappyAbsSyn ) -> ([APIChange])
happyOut38 :: HappyAbsSyn -> [APIChange]
happyOut38 HappyAbsSyn
x = HappyAbsSyn -> [APIChange]
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut38 #-}
happyIn39 :: ([FieldChange]) -> (HappyAbsSyn )
happyIn39 :: [FieldChange] -> HappyAbsSyn
happyIn39 [FieldChange]
x = [FieldChange] -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# [FieldChange]
x
{-# INLINE happyIn39 #-}
happyOut39 :: (HappyAbsSyn ) -> ([FieldChange])
happyOut39 :: HappyAbsSyn -> [FieldChange]
happyOut39 HappyAbsSyn
x = HappyAbsSyn -> [FieldChange]
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut39 #-}
happyIn40 :: ([FieldChange]) -> (HappyAbsSyn )
happyIn40 :: [FieldChange] -> HappyAbsSyn
happyIn40 [FieldChange]
x = [FieldChange] -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# [FieldChange]
x
{-# INLINE happyIn40 #-}
happyOut40 :: (HappyAbsSyn ) -> ([FieldChange])
happyOut40 :: HappyAbsSyn -> [FieldChange]
happyOut40 HappyAbsSyn
x = HappyAbsSyn -> [FieldChange]
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut40 #-}
happyIn41 :: (Maybe DefaultValue) -> (HappyAbsSyn )
happyIn41 :: Maybe DefaultValue -> HappyAbsSyn
happyIn41 Maybe DefaultValue
x = Maybe DefaultValue -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# Maybe DefaultValue
x
{-# INLINE happyIn41 #-}
happyOut41 :: (HappyAbsSyn ) -> (Maybe DefaultValue)
happyOut41 :: HappyAbsSyn -> Maybe DefaultValue
happyOut41 HappyAbsSyn
x = HappyAbsSyn -> Maybe DefaultValue
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut41 #-}
happyIn42 :: (DefaultValue) -> (HappyAbsSyn )
happyIn42 :: DefaultValue -> HappyAbsSyn
happyIn42 DefaultValue
x = DefaultValue -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# DefaultValue
x
{-# INLINE happyIn42 #-}
happyOut42 :: (HappyAbsSyn ) -> (DefaultValue)
happyOut42 :: HappyAbsSyn -> DefaultValue
happyOut42 HappyAbsSyn
x = HappyAbsSyn -> DefaultValue
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut42 #-}
happyIn43 :: ([UnionChange]) -> (HappyAbsSyn )
happyIn43 :: [UnionChange] -> HappyAbsSyn
happyIn43 [UnionChange]
x = [UnionChange] -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# [UnionChange]
x
{-# INLINE happyIn43 #-}
happyOut43 :: (HappyAbsSyn ) -> ([UnionChange])
happyOut43 :: HappyAbsSyn -> [UnionChange]
happyOut43 HappyAbsSyn
x = HappyAbsSyn -> [UnionChange]
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut43 #-}
happyIn44 :: ([UnionChange]) -> (HappyAbsSyn )
happyIn44 :: [UnionChange] -> HappyAbsSyn
happyIn44 [UnionChange]
x = [UnionChange] -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# [UnionChange]
x
{-# INLINE happyIn44 #-}
happyOut44 :: (HappyAbsSyn ) -> ([UnionChange])
happyOut44 :: HappyAbsSyn -> [UnionChange]
happyOut44 HappyAbsSyn
x = HappyAbsSyn -> [UnionChange]
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut44 #-}
happyIn45 :: ([EnumChange]) -> (HappyAbsSyn )
happyIn45 :: [EnumChange] -> HappyAbsSyn
happyIn45 [EnumChange]
x = [EnumChange] -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# [EnumChange]
x
{-# INLINE happyIn45 #-}
happyOut45 :: (HappyAbsSyn ) -> ([EnumChange])
happyOut45 :: HappyAbsSyn -> [EnumChange]
happyOut45 HappyAbsSyn
x = HappyAbsSyn -> [EnumChange]
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut45 #-}
happyIn46 :: ([EnumChange]) -> (HappyAbsSyn )
happyIn46 :: [EnumChange] -> HappyAbsSyn
happyIn46 [EnumChange]
x = [EnumChange] -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# [EnumChange]
x
{-# INLINE happyIn46 #-}
happyOut46 :: (HappyAbsSyn ) -> ([EnumChange])
happyOut46 :: HappyAbsSyn -> [EnumChange]
happyOut46 HappyAbsSyn
x = HappyAbsSyn -> [EnumChange]
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut46 #-}
happyIn47 :: (MigrationTag) -> (HappyAbsSyn )
happyIn47 :: MDComment -> HappyAbsSyn
happyIn47 MDComment
x = MDComment -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# MDComment
x
{-# INLINE happyIn47 #-}
happyOut47 :: (HappyAbsSyn ) -> (MigrationTag)
happyOut47 :: HappyAbsSyn -> MDComment
happyOut47 HappyAbsSyn
x = HappyAbsSyn -> MDComment
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut47 #-}
happyInTok :: (PToken) -> (HappyAbsSyn )
happyInTok :: PToken -> HappyAbsSyn
happyInTok PToken
x = PToken -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# PToken
x
{-# INLINE happyInTok #-}
happyOutTok :: (HappyAbsSyn ) -> (PToken)
happyOutTok :: HappyAbsSyn -> PToken
happyOutTok HappyAbsSyn
x = HappyAbsSyn -> PToken
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 -> [MDComment]
happyExpListPerState Int
st =
    [MDComment]
token_strs_expected
  where token_strs :: [MDComment]
token_strs = [MDComment
"error",MDComment
"%dummy",MDComment
"%start_parse",MDComment
"%start_parse_with_changelog",MDComment
"APIWithChangelog",MDComment
"API",MDComment
"RAPI",MDComment
"Thing",MDComment
"Node",MDComment
"Spec",MDComment
"With",MDComment
"Comments",MDComment
"RCommentList",MDComment
"Prefix",MDComment
"Record",MDComment
"Union",MDComment
"RRFields",MDComment
"FieldType",MDComment
"IsReadOnly",MDComment
"RUFields",MDComment
"Enum",MDComment
"REnums",MDComment
"Basic",MDComment
"MbFilter",MDComment
"Filter",MDComment
"RegEx",MDComment
"Type",MDComment
"MayBasicLit",MDComment
"BasicType",MDComment
"FieldName",MDComment
"VarIdentifier",MDComment
"TypeName",MDComment
"APIChangelog",MDComment
"Version",MDComment
"VersionExtra",MDComment
"Changes",MDComment
"RChanges",MDComment
"Change",MDComment
"RFieldChanges",MDComment
"FieldChange",MDComment
"MbDefaultValue",MDComment
"DefaultValue",MDComment
"RUnionChanges",MDComment
"UnionChange",MDComment
"REnumChanges",MDComment
"EnumChange",MDComment
"MigrationTag",MDComment
"';'",MDComment
"'|'",MDComment
"'['",MDComment
"']'",MDComment
"'::'",MDComment
"'='",MDComment
"'?'",MDComment
"','",MDComment
"'<='",MDComment
"'>='",MDComment
"version",MDComment
"with",MDComment
"integer",MDComment
"boolean",MDComment
"utc",MDComment
"string",MDComment
"binary",MDComment
"json",MDComment
"record",MDComment
"union",MDComment
"enum",MDComment
"basic",MDComment
"changes",MDComment
"added",MDComment
"removed",MDComment
"renamed",MDComment
"changed",MDComment
"default",MDComment
"field",MDComment
"alternative",MDComment
"migration",MDComment
"to",MDComment
"nothing",MDComment
"readonly",MDComment
"comment",MDComment
"typeiden",MDComment
"variden",MDComment
"intlit",MDComment
"strlit",MDComment
"true",MDComment
"false",MDComment
"utclit",MDComment
"%eof"]
        bit_start :: Int
bit_start = Int
st Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
90
        bit_end :: Int
bit_end = (Int
st Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1) Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
90
        read_bit :: Int -> Bool
read_bit = HappyAddr -> Int -> Bool
readArrayBit HappyAddr
happyExpList
        bits :: [Bool]
bits = (Int -> Bool) -> [Int] -> [Bool]
forall a b. (a -> b) -> [a] -> [b]
map Int -> Bool
read_bit [Int
bit_start..Int
bit_end Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1]
        bits_indexed :: [(Bool, Int)]
bits_indexed = [Bool] -> [Int] -> [(Bool, Int)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Bool]
bits [Int
0..Int
89]
        token_strs_expected :: [MDComment]
token_strs_expected = ((Bool, Int) -> [MDComment]) -> [(Bool, Int)] -> [MDComment]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Bool, Int) -> [MDComment]
f [(Bool, Int)]
bits_indexed
        f :: (Bool, Int) -> [MDComment]
f (Bool
False, Int
_) = []
        f (Bool
True, Int
nr) = [[MDComment]
token_strs [MDComment] -> Int -> MDComment
forall a. [a] -> Int -> a
!! 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 = (Int, Int)
-> [(Int,
     Int#
     -> PToken
     -> Int#
     -> Happy_IntList
     -> HappyStk HappyAbsSyn
     -> [PToken]
     -> ParseM HappyAbsSyn)]
-> Array
     Int
     (Int#
      -> PToken
      -> Int#
      -> Happy_IntList
      -> HappyStk HappyAbsSyn
      -> [PToken]
      -> ParseM HappyAbsSyn)
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 :: Int
happy_n_nonterms :: Int
happy_n_nonterms = Int
43 :: 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# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
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 -> API
happyOut6 HappyAbsSyn
happy_x_1 of { API
happy_var_1 -> 
	case HappyAbsSyn -> APIChangelog
happyOut33 HappyAbsSyn
happy_x_3 of { 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 -> API
happyOut7 HappyAbsSyn
happy_x_1 of { API
happy_var_1 -> 
	API -> HappyAbsSyn
happyIn6
		 (API -> API
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# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
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 -> API
happyOut7 HappyAbsSyn
happy_x_1 of { API
happy_var_1 -> 
	case HappyAbsSyn -> Thing
happyOut8 HappyAbsSyn
happy_x_3 of { Thing
happy_var_3 -> 
	API -> HappyAbsSyn
happyIn7
		 (Thing
happy_var_3 Thing -> API -> API
forall k1. k1 -> [k1] -> [k1]
: 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 -> APINode
happyOut9 HappyAbsSyn
happy_x_1 of { 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 -> MDComment
happyOut12 HappyAbsSyn
happy_x_1 of { MDComment
happy_var_1 -> 
	Thing -> HappyAbsSyn
happyIn8
		 (MDComment -> Thing
ThComment MDComment
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 -> Prefix
happyOut14 HappyAbsSyn
happy_x_1 of { Prefix
happy_var_1 -> 
	case HappyAbsSyn -> TypeName
happyOut32 HappyAbsSyn
happy_x_3 of { TypeName
happy_var_3 -> 
	case HappyAbsSyn -> MDComment
happyOut12 HappyAbsSyn
happy_x_4 of { MDComment
happy_var_4 -> 
	case HappyAbsSyn -> Spec
happyOut10 HappyAbsSyn
happy_x_6 of { Spec
happy_var_6 -> 
	case HappyAbsSyn -> Conversion
happyOut11 HappyAbsSyn
happy_x_7 of { Conversion
happy_var_7 -> 
	APINode -> HappyAbsSyn
happyIn9
		 (TypeName -> MDComment -> Prefix -> Spec -> Conversion -> APINode
APINode TypeName
happy_var_3 MDComment
happy_var_4 Prefix
happy_var_1 Spec
happy_var_6 Conversion
happy_var_7
	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
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 -> SpecRecord
happyOut15 HappyAbsSyn
happy_x_1 of { 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 -> SpecUnion
happyOut16 HappyAbsSyn
happy_x_1 of { 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 -> SpecEnum
happyOut21 HappyAbsSyn
happy_x_1 of { 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 -> SpecNewtype
happyOut23 HappyAbsSyn
happy_x_1 of { 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 -> APIType
happyOut27 HappyAbsSyn
happy_x_1 of { 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 -> FieldName
happyOut30 HappyAbsSyn
happy_x_2 of { FieldName
happy_var_2 -> 
	case HappyAbsSyn -> FieldName
happyOut30 HappyAbsSyn
happy_x_4 of { FieldName
happy_var_4 -> 
	Conversion -> HappyAbsSyn
happyIn11
		 ((FieldName, FieldName) -> Conversion
forall k1. k1 -> Maybe k1
Just (FieldName
happy_var_2,FieldName
happy_var_4)
	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
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
		 (Conversion
forall k1. Maybe k1
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 -> [MDComment]
happyOut13 HappyAbsSyn
happy_x_1 of { [MDComment]
happy_var_1 -> 
	MDComment -> HappyAbsSyn
happyIn12
		 ([MDComment] -> MDComment
unlines ([MDComment] -> MDComment) -> [MDComment] -> MDComment
forall a b. (a -> b) -> a -> b
$ [MDComment] -> [MDComment]
forall a. [a] -> [a]
reverse [MDComment]
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 -> [MDComment]
happyOut13 HappyAbsSyn
happy_x_1 of { [MDComment]
happy_var_1 -> 
	case HappyAbsSyn -> PToken
happyOutTok HappyAbsSyn
happy_x_2 of { ((,) AlexPosn
_ (Comment  MDComment
happy_var_2)) -> 
	[MDComment] -> HappyAbsSyn
happyIn13
		 (MDComment
happy_var_2 MDComment -> [MDComment] -> [MDComment]
forall k1. k1 -> [k1] -> [k1]
: [MDComment]
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  =  [MDComment] -> 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 -> MDComment
happyOut31 HappyAbsSyn
happy_x_1 of { MDComment
happy_var_1 -> 
	Prefix -> HappyAbsSyn
happyIn14
		 (MDComment -> Prefix
forall s. FoldCase s => s -> CI s
CI.mk MDComment
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# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
forall p. HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_20
happyReduction_20 :: HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_20 HappyAbsSyn
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> [(FieldName, FieldType)]
happyOut17 HappyAbsSyn
happy_x_2 of { [(FieldName, FieldType)]
happy_var_2 -> 
	SpecRecord -> HappyAbsSyn
happyIn15
		 ([(FieldName, FieldType)] -> SpecRecord
SpecRecord ([(FieldName, FieldType)] -> SpecRecord)
-> [(FieldName, FieldType)] -> SpecRecord
forall a b. (a -> b) -> a -> b
$ [(FieldName, FieldType)] -> [(FieldName, FieldType)]
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# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
forall p. HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_21
happyReduction_21 :: HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_21 HappyAbsSyn
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> [(FieldName, (APIType, MDComment))]
happyOut20 HappyAbsSyn
happy_x_2 of { [(FieldName, (APIType, MDComment))]
happy_var_2 -> 
	SpecUnion -> HappyAbsSyn
happyIn16
		 ([(FieldName, (APIType, MDComment))] -> SpecUnion
SpecUnion  ([(FieldName, (APIType, MDComment))] -> SpecUnion)
-> [(FieldName, (APIType, MDComment))] -> SpecUnion
forall a b. (a -> b) -> a -> b
$ [(FieldName, (APIType, MDComment))]
-> [(FieldName, (APIType, MDComment))]
forall a. [a] -> [a]
reverse [(FieldName, (APIType, MDComment))]
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 -> [(FieldName, FieldType)]
happyOut17 HappyAbsSyn
happy_x_1 of { [(FieldName, FieldType)]
happy_var_1 -> 
	case HappyAbsSyn -> FieldName
happyOut30 HappyAbsSyn
happy_x_2 of { FieldName
happy_var_2 -> 
	case HappyAbsSyn -> FieldType
happyOut18 HappyAbsSyn
happy_x_4 of { FieldType
happy_var_4 -> 
	[(FieldName, FieldType)] -> HappyAbsSyn
happyIn17
		 ((FieldName
happy_var_2,FieldType
happy_var_4) (FieldName, FieldType)
-> [(FieldName, FieldType)] -> [(FieldName, FieldType)]
forall k1. k1 -> [k1] -> [k1]
: [(FieldName, FieldType)]
happy_var_1
	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
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# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
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 -> FieldName
happyOut30 HappyAbsSyn
happy_x_1 of { FieldName
happy_var_1 -> 
	case HappyAbsSyn -> FieldType
happyOut18 HappyAbsSyn
happy_x_3 of { 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 -> APIType
happyOut27 HappyAbsSyn
happy_x_1 of { APIType
happy_var_1 -> 
	case HappyAbsSyn -> Bool
happyOut19 HappyAbsSyn
happy_x_2 of { Bool
happy_var_2 -> 
	case HappyAbsSyn -> Maybe DefaultValue
happyOut28 HappyAbsSyn
happy_x_3 of { Maybe DefaultValue
happy_var_3 -> 
	case HappyAbsSyn -> MDComment
happyOut12 HappyAbsSyn
happy_x_4 of { MDComment
happy_var_4 -> 
	FieldType -> HappyAbsSyn
happyIn18
		 (APIType -> Bool -> Maybe DefaultValue -> MDComment -> FieldType
FieldType APIType
happy_var_1 Bool
happy_var_2 Maybe DefaultValue
happy_var_3 MDComment
happy_var_4
	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
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# HappyAbsSyn -> HappyAbsSyn
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 -> [(FieldName, (APIType, MDComment))]
happyOut20 HappyAbsSyn
happy_x_1 of { [(FieldName, (APIType, MDComment))]
happy_var_1 -> 
	case HappyAbsSyn -> FieldName
happyOut30 HappyAbsSyn
happy_x_3 of { FieldName
happy_var_3 -> 
	case HappyAbsSyn -> APIType
happyOut27 HappyAbsSyn
happy_x_5 of { APIType
happy_var_5 -> 
	case HappyAbsSyn -> MDComment
happyOut12 HappyAbsSyn
happy_x_6 of { MDComment
happy_var_6 -> 
	[(FieldName, (APIType, MDComment))] -> HappyAbsSyn
happyIn20
		 ((FieldName
happy_var_3,(APIType
happy_var_5,MDComment
happy_var_6)) (FieldName, (APIType, MDComment))
-> [(FieldName, (APIType, MDComment))]
-> [(FieldName, (APIType, MDComment))]
forall k1. k1 -> [k1] -> [k1]
: [(FieldName, (APIType, MDComment))]
happy_var_1
	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
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 -> FieldName
happyOut30 HappyAbsSyn
happy_x_2 of { FieldName
happy_var_2 -> 
	case HappyAbsSyn -> APIType
happyOut27 HappyAbsSyn
happy_x_4 of { APIType
happy_var_4 -> 
	case HappyAbsSyn -> MDComment
happyOut12 HappyAbsSyn
happy_x_5 of { MDComment
happy_var_5 -> 
	[(FieldName, (APIType, MDComment))] -> HappyAbsSyn
happyIn20
		 ([(FieldName
happy_var_2,(APIType
happy_var_4,MDComment
happy_var_5))]
	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
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# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
forall p. HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_29
happyReduction_29 :: HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_29 HappyAbsSyn
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> [(FieldName, MDComment)]
happyOut22 HappyAbsSyn
happy_x_2 of { [(FieldName, MDComment)]
happy_var_2 -> 
	SpecEnum -> HappyAbsSyn
happyIn21
		 ([(FieldName, MDComment)] -> SpecEnum
SpecEnum ([(FieldName, MDComment)] -> SpecEnum)
-> [(FieldName, MDComment)] -> SpecEnum
forall a b. (a -> b) -> a -> b
$ [(FieldName, MDComment)] -> [(FieldName, MDComment)]
forall a. [a] -> [a]
reverse [(FieldName, MDComment)]
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 -> [(FieldName, MDComment)]
happyOut22 HappyAbsSyn
happy_x_1 of { [(FieldName, MDComment)]
happy_var_1 -> 
	case HappyAbsSyn -> FieldName
happyOut30 HappyAbsSyn
happy_x_3 of { FieldName
happy_var_3 -> 
	case HappyAbsSyn -> MDComment
happyOut12 HappyAbsSyn
happy_x_4 of { MDComment
happy_var_4 -> 
	[(FieldName, MDComment)] -> HappyAbsSyn
happyIn22
		 ((FieldName
happy_var_3,MDComment
happy_var_4) (FieldName, MDComment)
-> [(FieldName, MDComment)] -> [(FieldName, MDComment)]
forall k1. k1 -> [k1] -> [k1]
: [(FieldName, MDComment)]
happy_var_1
	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
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# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
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 -> FieldName
happyOut30 HappyAbsSyn
happy_x_2 of { FieldName
happy_var_2 -> 
	case HappyAbsSyn -> MDComment
happyOut12 HappyAbsSyn
happy_x_3 of { MDComment
happy_var_3 -> 
	[(FieldName, MDComment)] -> HappyAbsSyn
happyIn22
		 ([(FieldName
happy_var_2,MDComment
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# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
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 -> BasicType
happyOut29 HappyAbsSyn
happy_x_2 of { BasicType
happy_var_2 -> 
	case HappyAbsSyn -> Maybe Filter
happyOut24 HappyAbsSyn
happy_x_3 of { 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# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
forall p. HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_33
happyReduction_33 :: HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_33 HappyAbsSyn
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> Filter
happyOut25 HappyAbsSyn
happy_x_2 of { Filter
happy_var_2 -> 
	Maybe Filter -> HappyAbsSyn
happyIn24
		 (Filter -> Maybe Filter
forall k1. k1 -> Maybe k1
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
		 (Maybe Filter
forall k1. Maybe k1
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 -> RegEx
happyOut26 HappyAbsSyn
happy_x_1 of { 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# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
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 (IntRange -> Filter) -> IntRange -> Filter
forall a b. (a -> b) -> a -> b
$ Maybe Int -> Maybe Int -> IntRange
IntRange (Int -> Maybe Int
forall k1. k1 -> Maybe k1
Just Int
happy_var_2) Maybe Int
forall k1. Maybe k1
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 (IntRange -> Filter) -> IntRange -> Filter
forall a b. (a -> b) -> a -> b
$ Maybe Int -> Maybe Int -> IntRange
IntRange (Int -> Maybe Int
forall k1. k1 -> Maybe k1
Just Int
happy_var_2) (Int -> Maybe Int
forall k1. k1 -> Maybe k1
Just Int
happy_var_5)
	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
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# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
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 (IntRange -> Filter) -> IntRange -> Filter
forall a b. (a -> b) -> a -> b
$ Maybe Int -> Maybe Int -> IntRange
IntRange Maybe Int
forall k1. Maybe k1
Nothing   (Int -> Maybe Int
forall k1. k1 -> Maybe k1
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# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
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  (UTCRange -> Filter) -> UTCRange -> Filter
forall a b. (a -> b) -> a -> b
$ Maybe UTCTime -> Maybe UTCTime -> UTCRange
UTCRange (UTCTime -> Maybe UTCTime
forall k1. k1 -> Maybe k1
Just UTCTime
happy_var_2) Maybe UTCTime
forall k1. Maybe k1
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  (UTCRange -> Filter) -> UTCRange -> Filter
forall a b. (a -> b) -> a -> b
$ Maybe UTCTime -> Maybe UTCTime -> UTCRange
UTCRange (UTCTime -> Maybe UTCTime
forall k1. k1 -> Maybe k1
Just UTCTime
happy_var_2) (UTCTime -> Maybe UTCTime
forall k1. k1 -> Maybe k1
Just UTCTime
happy_var_5)
	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
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# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
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  (UTCRange -> Filter) -> UTCRange -> Filter
forall a b. (a -> b) -> a -> b
$ Maybe UTCTime -> Maybe UTCTime -> UTCRange
UTCRange Maybe UTCTime
forall k1. Maybe k1
Nothing   (UTCTime -> Maybe UTCTime
forall k1. k1 -> Maybe k1
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     MDComment
happy_var_1)) -> 
	RegEx -> HappyAbsSyn
happyIn26
		 (Text -> Regex -> RegEx
RegEx (MDComment -> Text
T.pack MDComment
happy_var_1) (Regex -> RegEx) -> Regex -> RegEx
forall a b. (a -> b) -> a -> b
$ MDComment -> Bool -> Bool -> Regex
mkRegexWithOpts MDComment
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# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
forall p. HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_43
happyReduction_43 :: HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_43 HappyAbsSyn
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> APIType
happyOut27 HappyAbsSyn
happy_x_2 of { 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# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
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 -> APIType
happyOut27 HappyAbsSyn
happy_x_2 of { 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 -> TypeName
happyOut32 HappyAbsSyn
happy_x_1 of { 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 -> BasicType
happyOut29 HappyAbsSyn
happy_x_1 of { 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# HappyAbsSyn -> HappyAbsSyn
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 -> DefaultValue
happyOut42 HappyAbsSyn
happy_x_1 of { DefaultValue
happy_var_1 -> 
	Maybe DefaultValue -> HappyAbsSyn
happyIn28
		 (DefaultValue -> Maybe DefaultValue
forall k1. k1 -> Maybe k1
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
		 (Maybe DefaultValue
forall k1. Maybe k1
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# HappyAbsSyn -> HappyAbsSyn
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# HappyAbsSyn -> HappyAbsSyn
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# HappyAbsSyn -> HappyAbsSyn
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# HappyAbsSyn -> HappyAbsSyn
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# HappyAbsSyn -> HappyAbsSyn
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 -> MDComment
happyOut31 HappyAbsSyn
happy_x_1 of { MDComment
happy_var_1 -> 
	FieldName -> HappyAbsSyn
happyIn30
		 (Text -> FieldName
FieldName (MDComment -> Text
T.pack MDComment
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  MDComment
happy_var_1)) -> 
	MDComment -> HappyAbsSyn
happyIn31
		 (MDComment
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# HappyAbsSyn -> HappyAbsSyn
forall p. p -> HappyAbsSyn
happyReduction_57
happyReduction_57 :: p -> HappyAbsSyn
happyReduction_57 p
happy_x_1
	 =  MDComment -> HappyAbsSyn
happyIn31
		 (MDComment
"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# HappyAbsSyn -> HappyAbsSyn
forall p. p -> HappyAbsSyn
happyReduction_58
happyReduction_58 :: p -> HappyAbsSyn
happyReduction_58 p
happy_x_1
	 =  MDComment -> HappyAbsSyn
happyIn31
		 (MDComment
"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# HappyAbsSyn -> HappyAbsSyn
forall p. p -> HappyAbsSyn
happyReduction_59
happyReduction_59 :: p -> HappyAbsSyn
happyReduction_59 p
happy_x_1
	 =  MDComment -> HappyAbsSyn
happyIn31
		 (MDComment
"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# HappyAbsSyn -> HappyAbsSyn
forall p. p -> HappyAbsSyn
happyReduction_60
happyReduction_60 :: p -> HappyAbsSyn
happyReduction_60 p
happy_x_1
	 =  MDComment -> HappyAbsSyn
happyIn31
		 (MDComment
"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 MDComment
happy_var_1)) -> 
	TypeName -> HappyAbsSyn
happyIn32
		 (Text -> TypeName
TypeName (MDComment -> Text
T.pack MDComment
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 -> VersionExtra
happyOut35 HappyAbsSyn
happy_x_2 of { VersionExtra
happy_var_2 -> 
	case HappyAbsSyn -> [APIChange]
happyOut36 HappyAbsSyn
happy_x_3 of { [APIChange]
happy_var_3 -> 
	case HappyAbsSyn -> APIChangelog
happyOut33 HappyAbsSyn
happy_x_5 of { APIChangelog
happy_var_5 -> 
	APIChangelog -> HappyAbsSyn
happyIn33
		 (VersionExtra -> [APIChange] -> APIChangelog -> APIChangelog
ChangesUpTo VersionExtra
happy_var_2 [APIChange]
happy_var_3 APIChangelog
happy_var_5
	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
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# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
forall p. HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_63
happyReduction_63 :: HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_63 HappyAbsSyn
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> Version
happyOut34 HappyAbsSyn
happy_x_2 of { 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# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
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 -> APIChangelog
happyOut33 HappyAbsSyn
happy_x_3 of { 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     MDComment
happy_var_1)) -> 
	Version -> HappyAbsSyn
happyIn34
		 (MDComment -> Version
parseVer MDComment
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     MDComment
happy_var_1)) -> 
	VersionExtra -> HappyAbsSyn
happyIn35
		 (MDComment -> VersionExtra
parseVersionExtra MDComment
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 -> [[APIChange]]
happyOut37 HappyAbsSyn
happy_x_1 of { [[APIChange]]
happy_var_1 -> 
	[APIChange] -> HappyAbsSyn
happyIn36
		 ([[APIChange]] -> [APIChange]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[APIChange]] -> [[APIChange]]
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 -> [[APIChange]]
happyOut37 HappyAbsSyn
happy_x_1 of { [[APIChange]]
happy_var_1 -> 
	case HappyAbsSyn -> [APIChange]
happyOut38 HappyAbsSyn
happy_x_2 of { [APIChange]
happy_var_2 -> 
	[[APIChange]] -> HappyAbsSyn
happyIn37
		 ([APIChange]
happy_var_2 [APIChange] -> [[APIChange]] -> [[APIChange]]
forall k1. k1 -> [k1] -> [k1]
: [[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# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
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 -> TypeName
happyOut32 HappyAbsSyn
happy_x_2 of { TypeName
happy_var_2 -> 
	case HappyAbsSyn -> Spec
happyOut10 HappyAbsSyn
happy_x_3 of { 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# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
forall p. HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_71
happyReduction_71 :: HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_71 HappyAbsSyn
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> TypeName
happyOut32 HappyAbsSyn
happy_x_2 of { 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 -> TypeName
happyOut32 HappyAbsSyn
happy_x_2 of { TypeName
happy_var_2 -> 
	case HappyAbsSyn -> TypeName
happyOut32 HappyAbsSyn
happy_x_4 of { TypeName
happy_var_4 -> 
	[APIChange] -> HappyAbsSyn
happyIn38
		 ([TypeName -> TypeName -> APIChange
ChRenameType TypeName
happy_var_2 TypeName
happy_var_4]
	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
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 -> TypeName
happyOut32 HappyAbsSyn
happy_x_3 of { TypeName
happy_var_3 -> 
	case HappyAbsSyn -> [FieldChange]
happyOut39 HappyAbsSyn
happy_x_4 of { [FieldChange]
happy_var_4 -> 
	[APIChange] -> HappyAbsSyn
happyIn38
		 ((FieldChange -> APIChange) -> [FieldChange] -> [APIChange]
forall a b. (a -> b) -> [a] -> [b]
map (TypeName -> FieldChange -> APIChange
fldChangeToAPIChange TypeName
happy_var_3)   ([FieldChange] -> [FieldChange]
forall a. [a] -> [a]
reverse [FieldChange]
happy_var_4)
	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
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 -> TypeName
happyOut32 HappyAbsSyn
happy_x_3 of { TypeName
happy_var_3 -> 
	case HappyAbsSyn -> [UnionChange]
happyOut43 HappyAbsSyn
happy_x_4 of { [UnionChange]
happy_var_4 -> 
	[APIChange] -> HappyAbsSyn
happyIn38
		 ((UnionChange -> APIChange) -> [UnionChange] -> [APIChange]
forall a b. (a -> b) -> [a] -> [b]
map (TypeName -> UnionChange -> APIChange
unionChangeToAPIChange TypeName
happy_var_3) ([UnionChange] -> [UnionChange]
forall a. [a] -> [a]
reverse [UnionChange]
happy_var_4)
	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
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 -> TypeName
happyOut32 HappyAbsSyn
happy_x_3 of { TypeName
happy_var_3 -> 
	case HappyAbsSyn -> [EnumChange]
happyOut45 HappyAbsSyn
happy_x_4 of { [EnumChange]
happy_var_4 -> 
	[APIChange] -> HappyAbsSyn
happyIn38
		 ((EnumChange -> APIChange) -> [EnumChange] -> [APIChange]
forall a b. (a -> b) -> [a] -> [b]
map (TypeName -> EnumChange -> APIChange
enumChangeToAPIChange TypeName
happy_var_3)  ([EnumChange] -> [EnumChange]
forall a. [a] -> [a]
reverse [EnumChange]
happy_var_4)
	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
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 -> TypeName
happyOut32 HappyAbsSyn
happy_x_3 of { TypeName
happy_var_3 -> 
	case HappyAbsSyn -> MDComment
happyOut47 HappyAbsSyn
happy_x_4 of { MDComment
happy_var_4 -> 
	[APIChange] -> HappyAbsSyn
happyIn38
		 ([TypeName -> MDComment -> APIChange
ChCustomType TypeName
happy_var_3 MDComment
happy_var_4]
	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
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# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
forall p. HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_77
happyReduction_77 :: HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_77 HappyAbsSyn
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> MDComment
happyOut47 HappyAbsSyn
happy_x_2 of { MDComment
happy_var_2 -> 
	[APIChange] -> HappyAbsSyn
happyIn38
		 ([MDComment -> APIChange
ChCustomAll MDComment
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# HappyAbsSyn -> HappyAbsSyn
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 -> [FieldChange]
happyOut39 HappyAbsSyn
happy_x_1 of { [FieldChange]
happy_var_1 -> 
	case HappyAbsSyn -> [FieldChange]
happyOut40 HappyAbsSyn
happy_x_2 of { [FieldChange]
happy_var_2 -> 
	[FieldChange] -> HappyAbsSyn
happyIn39
		 ([FieldChange]
happy_var_2 [FieldChange] -> [FieldChange] -> [FieldChange]
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 -> [FieldChange]
happyOut40 HappyAbsSyn
happy_x_1 of { [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 -> FieldName
happyOut30 HappyAbsSyn
happy_x_3 of { FieldName
happy_var_3 -> 
	case HappyAbsSyn -> APIType
happyOut27 HappyAbsSyn
happy_x_5 of { APIType
happy_var_5 -> 
	case HappyAbsSyn -> Maybe DefaultValue
happyOut41 HappyAbsSyn
happy_x_6 of { 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]
	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
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# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
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 -> FieldName
happyOut30 HappyAbsSyn
happy_x_3 of { 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 -> FieldName
happyOut30 HappyAbsSyn
happy_x_3 of { FieldName
happy_var_3 -> 
	case HappyAbsSyn -> FieldName
happyOut30 HappyAbsSyn
happy_x_5 of { FieldName
happy_var_5 -> 
	[FieldChange] -> HappyAbsSyn
happyIn40
		 ([FieldName -> FieldName -> FieldChange
FldChRename FieldName
happy_var_3 FieldName
happy_var_5]
	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
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 -> FieldName
happyOut30 HappyAbsSyn
happy_x_3 of { FieldName
happy_var_3 -> 
	case HappyAbsSyn -> APIType
happyOut27 HappyAbsSyn
happy_x_5 of { APIType
happy_var_5 -> 
	case HappyAbsSyn -> MDComment
happyOut47 HappyAbsSyn
happy_x_7 of { MDComment
happy_var_7 -> 
	[FieldChange] -> HappyAbsSyn
happyIn40
		 ([FieldName -> APIType -> MDComment -> FieldChange
FldChChange FieldName
happy_var_3 APIType
happy_var_5 MDComment
happy_var_7]
	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
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# HappyAbsSyn -> HappyAbsSyn
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# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
forall p. HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_86
happyReduction_86 :: HappyAbsSyn -> p -> HappyAbsSyn
happyReduction_86 HappyAbsSyn
happy_x_2
	p
happy_x_1
	 =  case HappyAbsSyn -> DefaultValue
happyOut42 HappyAbsSyn
happy_x_2 of { DefaultValue
happy_var_2 -> 
	Maybe DefaultValue -> HappyAbsSyn
happyIn41
		 (DefaultValue -> Maybe DefaultValue
forall k1. k1 -> Maybe k1
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
		 (Maybe DefaultValue
forall k1. Maybe k1
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# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
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# HappyAbsSyn -> HappyAbsSyn
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     MDComment
happy_var_1)) -> 
	DefaultValue -> HappyAbsSyn
happyIn42
		 (Text -> DefaultValue
DefValString (MDComment -> Text
T.pack MDComment
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# HappyAbsSyn -> HappyAbsSyn
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# HappyAbsSyn -> HappyAbsSyn
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 -> [UnionChange]
happyOut43 HappyAbsSyn
happy_x_1 of { [UnionChange]
happy_var_1 -> 
	case HappyAbsSyn -> [UnionChange]
happyOut44 HappyAbsSyn
happy_x_2 of { [UnionChange]
happy_var_2 -> 
	[UnionChange] -> HappyAbsSyn
happyIn43
		 ([UnionChange]
happy_var_2 [UnionChange] -> [UnionChange] -> [UnionChange]
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 -> [UnionChange]
happyOut44 HappyAbsSyn
happy_x_1 of { [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 -> FieldName
happyOut30 HappyAbsSyn
happy_x_3 of { FieldName
happy_var_3 -> 
	case HappyAbsSyn -> APIType
happyOut27 HappyAbsSyn
happy_x_5 of { APIType
happy_var_5 -> 
	[UnionChange] -> HappyAbsSyn
happyIn44
		 ([FieldName -> APIType -> UnionChange
UnChAdd FieldName
happy_var_3 APIType
happy_var_5]
	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
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# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
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 -> FieldName
happyOut30 HappyAbsSyn
happy_x_3 of { 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 -> FieldName
happyOut30 HappyAbsSyn
happy_x_3 of { FieldName
happy_var_3 -> 
	case HappyAbsSyn -> FieldName
happyOut30 HappyAbsSyn
happy_x_5 of { FieldName
happy_var_5 -> 
	[UnionChange] -> HappyAbsSyn
happyIn44
		 ([FieldName -> FieldName -> UnionChange
UnChRename FieldName
happy_var_3 FieldName
happy_var_5]
	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
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# HappyAbsSyn -> HappyAbsSyn
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 -> [EnumChange]
happyOut45 HappyAbsSyn
happy_x_1 of { [EnumChange]
happy_var_1 -> 
	case HappyAbsSyn -> [EnumChange]
happyOut46 HappyAbsSyn
happy_x_2 of { [EnumChange]
happy_var_2 -> 
	[EnumChange] -> HappyAbsSyn
happyIn45
		 ([EnumChange]
happy_var_2 [EnumChange] -> [EnumChange] -> [EnumChange]
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 -> [EnumChange]
happyOut46 HappyAbsSyn
happy_x_1 of { [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# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
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 -> FieldName
happyOut30 HappyAbsSyn
happy_x_3 of { 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# HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn -> HappyAbsSyn
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 -> FieldName
happyOut30 HappyAbsSyn
happy_x_3 of { 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 -> FieldName
happyOut30 HappyAbsSyn
happy_x_3 of { FieldName
happy_var_3 -> 
	case HappyAbsSyn -> FieldName
happyOut30 HappyAbsSyn
happy_x_5 of { FieldName
happy_var_5 -> 
	[EnumChange] -> HappyAbsSyn
happyIn46
		 ([FieldName -> FieldName -> EnumChange
EnChRename FieldName
happy_var_3 FieldName
happy_var_5]
	) HappyAbsSyn -> HappyStk HappyAbsSyn -> HappyStk HappyAbsSyn
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# HappyAbsSyn -> HappyAbsSyn
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 MDComment
happy_var_1)) -> 
	MDComment -> HappyAbsSyn
happyIn47
		 (MDComment
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# PToken
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  MDComment
happy_dollar_dollar) -> Int# -> ParseM HappyAbsSyn
cont Int#
35#;
	(,) AlexPosn
_ (TypeIden MDComment
happy_dollar_dollar) -> Int# -> ParseM HappyAbsSyn
cont Int#
36#;
	(,) AlexPosn
_ (VarIden  MDComment
happy_dollar_dollar) -> Int# -> ParseM HappyAbsSyn
cont Int#
37#;
	(,) AlexPosn
_ (Intg     Int
happy_dollar_dollar) -> Int# -> ParseM HappyAbsSyn
cont Int#
38#;
	(,) AlexPosn
_ (Strg     MDComment
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
_ -> ([PToken], [MDComment]) -> ParseM HappyAbsSyn
forall a. ([PToken], [MDComment]) -> ParseM a
happyError' ((PToken
tkPToken -> [PToken] -> [PToken]
forall k1. k1 -> [k1] -> [k1]
:[PToken]
tks), [])
	}

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

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

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

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


type ParseM = Either [PToken]

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

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

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

parseAPIWithChangelog :: String -> (Int, Int) -> String -> APIWithChangelog
parseAPIWithChangelog :: MDComment -> (Int, Int) -> MDComment -> APIWithChangelog
parseAPIWithChangelog = ([PToken] -> ParseM APIWithChangelog)
-> MDComment -> (Int, Int) -> MDComment -> APIWithChangelog
forall a.
([PToken] -> ParseM a) -> MDComment -> (Int, Int) -> MDComment -> 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 MDComment
m) = TypeName -> FieldName -> APIType -> MDComment -> APIChange
ChChangeField TypeName
t FieldName
f APIType
ty MDComment
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 :: MDComment -> Version
parseVer MDComment
x = case MDComment -> Maybe Version
simpleParseVersion MDComment
x of
                 Just Version
v -> Version
v
                 Maybe Version
Nothing -> MDComment -> Version
forall a. HasCallStack => MDComment -> a
error (MDComment -> Version) -> MDComment -> Version
forall a b. (a -> b) -> a -> b
$ MDComment
"Syntax error while parsing version " MDComment -> MDComment -> MDComment
forall a. [a] -> [a] -> [a]
++ MDComment
x

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


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

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

located :: ExpQ -> String -> ExpQ
located :: Q Exp -> MDComment -> Q Exp
located Q Exp
e MDComment
s = do
    Loc
l <- Q Loc
location
    let fn :: MDComment
fn = Loc -> MDComment
loc_filename Loc
l
        ls :: (Int, Int)
ls = Loc -> (Int, Int)
loc_start    Loc
l
    [|$(e) fn ls s|]
{-# LINE 1 "templates/GenericTemplate.hs" #-}
{-# LINE 1 "templates/GenericTemplate.hs" #-}
{-# LINE 1 "<built-in>" #-}
{-# LINE 1 "<command-line>" #-}
{-# LINE 10 "<command-line>" #-}
# 1 "/usr/include/stdc-predef.h" 1 3 4

# 17 "/usr/include/stdc-predef.h" 3 4














































{-# LINE 10 "<command-line>" #-}
{-# LINE 1 "/opt/ghc/8.6.3/lib/ghc-8.6.3/include/ghcversion.h" #-}















{-# LINE 10 "<command-line>" #-}
{-# LINE 1 "/tmp/ghc780_0/ghc_2.h" #-}






































































































































































































{-# LINE 10 "<command-line>" #-}
{-# 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)) :: Bool)
#define GTE(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.>=# m)) :: Bool)
#define EQ(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.==# m)) :: 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
{-# LINE 43 "templates/GenericTemplate.hs" #-}

data Happy_IntList = HappyCons Happy_GHC_Exts.Int# Happy_IntList







{-# LINE 65 "templates/GenericTemplate.hs" #-}

{-# LINE 75 "templates/GenericTemplate.hs" #-}

{-# LINE 84 "templates/GenericTemplate.hs" #-}

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 0#, 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)) :: 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 False
         action
          | check     = indexShortOffAddr happyTable off_i
          | 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 `mod` 16)
  where unbox_int (Happy_GHC_Exts.I# x) = x






data HappyAddr = HappyA# Happy_GHC_Exts.Addr#


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

{-# LINE 180 "templates/GenericTemplate.hs" #-}

-----------------------------------------------------------------------------
-- 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 (0# 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  0# tk old_st (HappyCons ((action)) (sts)) 
                                                (saved_tok `HappyStk` _ `HappyStk` stk) =
--      trace ("discarding state, depth " ++ show (length stk))  $
        happyDoAction 0# tk action 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 = 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 `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.