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

-- | This module provides the generated Happy parser for Haskell. It exports
-- a number of parsers which may be used in any library that uses the GHC API.
-- A common usage pattern is to initialize the parser state with a given string
-- and then parse that string:
--
-- @
--     runParser :: DynFlags -> String -> P a -> ParseResult a
--     runParser flags str parser = unP parser parseState
--     where
--       filename = "\<interactive\>"
--       location = mkRealSrcLoc (mkFastString filename) 1 1
--       buffer = stringToStringBuffer str
--       parseState = mkPState flags buffer location
-- @
module Parser (parseModule, parseSignature, parseImport, parseStatement, parseBackpack,
               parseDeclaration, parseExpression, parsePattern,
               parseTypeSignature,
               parseStmt, parseIdentifier,
               parseType, parseHeader) where

-- base
import Control.Monad    ( unless, liftM, when )
import GHC.Exts
import Data.Char
import Control.Monad    ( mplus )
import Control.Applicative ((<$))

-- compiler/hsSyn
import HsSyn

-- compiler/main
import HscTypes         ( IsBootInterface, WarningTxt(..) )
import DynFlags
import BkpSyn
import PackageConfig

-- compiler/utils
import OrdList
import BooleanFormula   ( BooleanFormula(..), LBooleanFormula(..), mkTrue )
import FastString
import Maybes           ( isJust, orElse )
import Outputable

-- compiler/basicTypes
import RdrName
import OccName          ( varName, dataName, tcClsName, tvName, startsWithUnderscore )
import DataCon          ( DataCon, dataConName )
import SrcLoc
import Module
import BasicTypes

-- compiler/types
import Type             ( funTyCon )
import Kind             ( Kind )
import Class            ( FunDep )

-- compiler/parser
import RdrHsSyn
import Lexer
import HaddockUtils
import ApiAnnotation

-- compiler/typecheck
import TcEvidence       ( emptyTcEvBinds )

-- compiler/prelude
import ForeignCall
import TysPrim          ( eqPrimTyCon )
import TysWiredIn       ( unitTyCon, unitDataCon, tupleTyCon, tupleDataCon, nilDataCon,
                          unboxedUnitTyCon, unboxedUnitDataCon,
                          listTyCon_RDR, consDataCon_RDR, eqTyCon_RDR )

-- compiler/utils
import Util             ( looksLikePackageName, fstOf3, sndOf3, thdOf3 )
import GhcPrelude
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.11

newtype HappyAbsSyn  = HappyAbsSyn HappyAny
#if __GLASGOW_HASKELL__ >= 607
type HappyAny = Happy_GHC_Exts.Any
#else
type HappyAny = forall a . a
#endif
newtype HappyWrap16 = HappyWrap16 (Located RdrName)
happyIn16 :: (Located RdrName) -> (HappyAbsSyn )
happyIn16 :: Located RdrName -> HappyAbsSyn
happyIn16 x :: Located RdrName
x = HappyWrap16 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located RdrName -> HappyWrap16
HappyWrap16 Located RdrName
x)
{-# INLINE happyIn16 #-}
happyOut16 :: (HappyAbsSyn ) -> HappyWrap16
happyOut16 :: HappyAbsSyn -> HappyWrap16
happyOut16 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap16
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut16 #-}
newtype HappyWrap17 = HappyWrap17 ([LHsUnit PackageName])
happyIn17 :: ([LHsUnit PackageName]) -> (HappyAbsSyn )
happyIn17 :: [LHsUnit PackageName] -> HappyAbsSyn
happyIn17 x :: [LHsUnit PackageName]
x = HappyWrap17 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LHsUnit PackageName] -> HappyWrap17
HappyWrap17 [LHsUnit PackageName]
x)
{-# INLINE happyIn17 #-}
happyOut17 :: (HappyAbsSyn ) -> HappyWrap17
happyOut17 :: HappyAbsSyn -> HappyWrap17
happyOut17 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap17
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut17 #-}
newtype HappyWrap18 = HappyWrap18 (OrdList (LHsUnit PackageName))
happyIn18 :: (OrdList (LHsUnit PackageName)) -> (HappyAbsSyn )
happyIn18 :: OrdList (LHsUnit PackageName) -> HappyAbsSyn
happyIn18 x :: OrdList (LHsUnit PackageName)
x = HappyWrap18 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList (LHsUnit PackageName) -> HappyWrap18
HappyWrap18 OrdList (LHsUnit PackageName)
x)
{-# INLINE happyIn18 #-}
happyOut18 :: (HappyAbsSyn ) -> HappyWrap18
happyOut18 :: HappyAbsSyn -> HappyWrap18
happyOut18 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap18
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut18 #-}
newtype HappyWrap19 = HappyWrap19 (LHsUnit PackageName)
happyIn19 :: (LHsUnit PackageName) -> (HappyAbsSyn )
happyIn19 :: LHsUnit PackageName -> HappyAbsSyn
happyIn19 x :: LHsUnit PackageName
x = HappyWrap19 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsUnit PackageName -> HappyWrap19
HappyWrap19 LHsUnit PackageName
x)
{-# INLINE happyIn19 #-}
happyOut19 :: (HappyAbsSyn ) -> HappyWrap19
happyOut19 :: HappyAbsSyn -> HappyWrap19
happyOut19 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap19
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut19 #-}
newtype HappyWrap20 = HappyWrap20 (LHsUnitId PackageName)
happyIn20 :: (LHsUnitId PackageName) -> (HappyAbsSyn )
happyIn20 :: LHsUnitId PackageName -> HappyAbsSyn
happyIn20 x :: LHsUnitId PackageName
x = HappyWrap20 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsUnitId PackageName -> HappyWrap20
HappyWrap20 LHsUnitId PackageName
x)
{-# INLINE happyIn20 #-}
happyOut20 :: (HappyAbsSyn ) -> HappyWrap20
happyOut20 :: HappyAbsSyn -> HappyWrap20
happyOut20 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap20
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut20 #-}
newtype HappyWrap21 = HappyWrap21 (OrdList (LHsModuleSubst PackageName))
happyIn21 :: (OrdList (LHsModuleSubst PackageName)) -> (HappyAbsSyn )
happyIn21 :: OrdList (LHsModuleSubst PackageName) -> HappyAbsSyn
happyIn21 x :: OrdList (LHsModuleSubst PackageName)
x = HappyWrap21 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList (LHsModuleSubst PackageName) -> HappyWrap21
HappyWrap21 OrdList (LHsModuleSubst PackageName)
x)
{-# INLINE happyIn21 #-}
happyOut21 :: (HappyAbsSyn ) -> HappyWrap21
happyOut21 :: HappyAbsSyn -> HappyWrap21
happyOut21 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap21
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut21 #-}
newtype HappyWrap22 = HappyWrap22 (LHsModuleSubst PackageName)
happyIn22 :: (LHsModuleSubst PackageName) -> (HappyAbsSyn )
happyIn22 :: LHsModuleSubst PackageName -> HappyAbsSyn
happyIn22 x :: LHsModuleSubst PackageName
x = HappyWrap22 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsModuleSubst PackageName -> HappyWrap22
HappyWrap22 LHsModuleSubst PackageName
x)
{-# INLINE happyIn22 #-}
happyOut22 :: (HappyAbsSyn ) -> HappyWrap22
happyOut22 :: HappyAbsSyn -> HappyWrap22
happyOut22 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap22
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut22 #-}
newtype HappyWrap23 = HappyWrap23 (LHsModuleId PackageName)
happyIn23 :: (LHsModuleId PackageName) -> (HappyAbsSyn )
happyIn23 :: LHsModuleId PackageName -> HappyAbsSyn
happyIn23 x :: LHsModuleId PackageName
x = HappyWrap23 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsModuleId PackageName -> HappyWrap23
HappyWrap23 LHsModuleId PackageName
x)
{-# INLINE happyIn23 #-}
happyOut23 :: (HappyAbsSyn ) -> HappyWrap23
happyOut23 :: HappyAbsSyn -> HappyWrap23
happyOut23 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap23
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut23 #-}
newtype HappyWrap24 = HappyWrap24 (Located PackageName)
happyIn24 :: (Located PackageName) -> (HappyAbsSyn )
happyIn24 :: Located PackageName -> HappyAbsSyn
happyIn24 x :: Located PackageName
x = HappyWrap24 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located PackageName -> HappyWrap24
HappyWrap24 Located PackageName
x)
{-# INLINE happyIn24 #-}
happyOut24 :: (HappyAbsSyn ) -> HappyWrap24
happyOut24 :: HappyAbsSyn -> HappyWrap24
happyOut24 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap24
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut24 #-}
newtype HappyWrap25 = HappyWrap25 (Located FastString)
happyIn25 :: (Located FastString) -> (HappyAbsSyn )
happyIn25 :: Located FastString -> HappyAbsSyn
happyIn25 x :: Located FastString
x = HappyWrap25 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located FastString -> HappyWrap25
HappyWrap25 Located FastString
x)
{-# INLINE happyIn25 #-}
happyOut25 :: (HappyAbsSyn ) -> HappyWrap25
happyOut25 :: HappyAbsSyn -> HappyWrap25
happyOut25 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap25
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut25 #-}
newtype HappyWrap26 = HappyWrap26 (Located FastString)
happyIn26 :: (Located FastString) -> (HappyAbsSyn )
happyIn26 :: Located FastString -> HappyAbsSyn
happyIn26 x :: Located FastString
x = HappyWrap26 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located FastString -> HappyWrap26
HappyWrap26 Located FastString
x)
{-# INLINE happyIn26 #-}
happyOut26 :: (HappyAbsSyn ) -> HappyWrap26
happyOut26 :: HappyAbsSyn -> HappyWrap26
happyOut26 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap26
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut26 #-}
newtype HappyWrap27 = HappyWrap27 (Maybe [LRenaming])
happyIn27 :: (Maybe [LRenaming]) -> (HappyAbsSyn )
happyIn27 :: Maybe [LRenaming] -> HappyAbsSyn
happyIn27 x :: Maybe [LRenaming]
x = HappyWrap27 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Maybe [LRenaming] -> HappyWrap27
HappyWrap27 Maybe [LRenaming]
x)
{-# INLINE happyIn27 #-}
happyOut27 :: (HappyAbsSyn ) -> HappyWrap27
happyOut27 :: HappyAbsSyn -> HappyWrap27
happyOut27 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap27
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut27 #-}
newtype HappyWrap28 = HappyWrap28 (OrdList LRenaming)
happyIn28 :: (OrdList LRenaming) -> (HappyAbsSyn )
happyIn28 :: OrdList LRenaming -> HappyAbsSyn
happyIn28 x :: OrdList LRenaming
x = HappyWrap28 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList LRenaming -> HappyWrap28
HappyWrap28 OrdList LRenaming
x)
{-# INLINE happyIn28 #-}
happyOut28 :: (HappyAbsSyn ) -> HappyWrap28
happyOut28 :: HappyAbsSyn -> HappyWrap28
happyOut28 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap28
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut28 #-}
newtype HappyWrap29 = HappyWrap29 (LRenaming)
happyIn29 :: (LRenaming) -> (HappyAbsSyn )
happyIn29 :: LRenaming -> HappyAbsSyn
happyIn29 x :: LRenaming
x = HappyWrap29 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LRenaming -> HappyWrap29
HappyWrap29 LRenaming
x)
{-# INLINE happyIn29 #-}
happyOut29 :: (HappyAbsSyn ) -> HappyWrap29
happyOut29 :: HappyAbsSyn -> HappyWrap29
happyOut29 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap29
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut29 #-}
newtype HappyWrap30 = HappyWrap30 (OrdList (LHsUnitDecl PackageName))
happyIn30 :: (OrdList (LHsUnitDecl PackageName)) -> (HappyAbsSyn )
happyIn30 :: OrdList (LHsUnitDecl PackageName) -> HappyAbsSyn
happyIn30 x :: OrdList (LHsUnitDecl PackageName)
x = HappyWrap30 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList (LHsUnitDecl PackageName) -> HappyWrap30
HappyWrap30 OrdList (LHsUnitDecl PackageName)
x)
{-# INLINE happyIn30 #-}
happyOut30 :: (HappyAbsSyn ) -> HappyWrap30
happyOut30 :: HappyAbsSyn -> HappyWrap30
happyOut30 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap30
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut30 #-}
newtype HappyWrap31 = HappyWrap31 (OrdList (LHsUnitDecl PackageName))
happyIn31 :: (OrdList (LHsUnitDecl PackageName)) -> (HappyAbsSyn )
happyIn31 :: OrdList (LHsUnitDecl PackageName) -> HappyAbsSyn
happyIn31 x :: OrdList (LHsUnitDecl PackageName)
x = HappyWrap31 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList (LHsUnitDecl PackageName) -> HappyWrap31
HappyWrap31 OrdList (LHsUnitDecl PackageName)
x)
{-# INLINE happyIn31 #-}
happyOut31 :: (HappyAbsSyn ) -> HappyWrap31
happyOut31 :: HappyAbsSyn -> HappyWrap31
happyOut31 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap31
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut31 #-}
newtype HappyWrap32 = HappyWrap32 (LHsUnitDecl PackageName)
happyIn32 :: (LHsUnitDecl PackageName) -> (HappyAbsSyn )
happyIn32 :: LHsUnitDecl PackageName -> HappyAbsSyn
happyIn32 x :: LHsUnitDecl PackageName
x = HappyWrap32 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsUnitDecl PackageName -> HappyWrap32
HappyWrap32 LHsUnitDecl PackageName
x)
{-# INLINE happyIn32 #-}
happyOut32 :: (HappyAbsSyn ) -> HappyWrap32
happyOut32 :: HappyAbsSyn -> HappyWrap32
happyOut32 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap32
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut32 #-}
newtype HappyWrap33 = HappyWrap33 (Located (HsModule GhcPs))
happyIn33 :: (Located (HsModule GhcPs)) -> (HappyAbsSyn )
happyIn33 :: Located (HsModule GhcPs) -> HappyAbsSyn
happyIn33 x :: Located (HsModule GhcPs)
x = HappyWrap33 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (HsModule GhcPs) -> HappyWrap33
HappyWrap33 Located (HsModule GhcPs)
x)
{-# INLINE happyIn33 #-}
happyOut33 :: (HappyAbsSyn ) -> HappyWrap33
happyOut33 :: HappyAbsSyn -> HappyWrap33
happyOut33 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap33
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut33 #-}
newtype HappyWrap34 = HappyWrap34 (Located (HsModule GhcPs))
happyIn34 :: (Located (HsModule GhcPs)) -> (HappyAbsSyn )
happyIn34 :: Located (HsModule GhcPs) -> HappyAbsSyn
happyIn34 x :: Located (HsModule GhcPs)
x = HappyWrap34 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (HsModule GhcPs) -> HappyWrap34
HappyWrap34 Located (HsModule GhcPs)
x)
{-# INLINE happyIn34 #-}
happyOut34 :: (HappyAbsSyn ) -> HappyWrap34
happyOut34 :: HappyAbsSyn -> HappyWrap34
happyOut34 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap34
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut34 #-}
newtype HappyWrap35 = HappyWrap35 (Maybe LHsDocString)
happyIn35 :: (Maybe LHsDocString) -> (HappyAbsSyn )
happyIn35 :: Maybe LHsDocString -> HappyAbsSyn
happyIn35 x :: Maybe LHsDocString
x = HappyWrap35 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Maybe LHsDocString -> HappyWrap35
HappyWrap35 Maybe LHsDocString
x)
{-# INLINE happyIn35 #-}
happyOut35 :: (HappyAbsSyn ) -> HappyWrap35
happyOut35 :: HappyAbsSyn -> HappyWrap35
happyOut35 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap35
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut35 #-}
newtype HappyWrap36 = HappyWrap36 (())
happyIn36 :: (()) -> (HappyAbsSyn )
happyIn36 :: () -> HappyAbsSyn
happyIn36 x :: ()
x = HappyWrap36 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (() -> HappyWrap36
HappyWrap36 ()
x)
{-# INLINE happyIn36 #-}
happyOut36 :: (HappyAbsSyn ) -> HappyWrap36
happyOut36 :: HappyAbsSyn -> HappyWrap36
happyOut36 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap36
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut36 #-}
newtype HappyWrap37 = HappyWrap37 (())
happyIn37 :: (()) -> (HappyAbsSyn )
happyIn37 :: () -> HappyAbsSyn
happyIn37 x :: ()
x = HappyWrap37 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (() -> HappyWrap37
HappyWrap37 ()
x)
{-# INLINE happyIn37 #-}
happyOut37 :: (HappyAbsSyn ) -> HappyWrap37
happyOut37 :: HappyAbsSyn -> HappyWrap37
happyOut37 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap37
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut37 #-}
newtype HappyWrap38 = HappyWrap38 (Maybe (Located WarningTxt))
happyIn38 :: (Maybe (Located WarningTxt)) -> (HappyAbsSyn )
happyIn38 :: Maybe (Located WarningTxt) -> HappyAbsSyn
happyIn38 x :: Maybe (Located WarningTxt)
x = HappyWrap38 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Maybe (Located WarningTxt) -> HappyWrap38
HappyWrap38 Maybe (Located WarningTxt)
x)
{-# INLINE happyIn38 #-}
happyOut38 :: (HappyAbsSyn ) -> HappyWrap38
happyOut38 :: HappyAbsSyn -> HappyWrap38
happyOut38 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap38
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut38 #-}
newtype HappyWrap39 = HappyWrap39 (([AddAnn]
             ,([LImportDecl GhcPs], [LHsDecl GhcPs])))
happyIn39 :: (([AddAnn]
             ,([LImportDecl GhcPs], [LHsDecl GhcPs]))) -> (HappyAbsSyn )
happyIn39 :: ([AddAnn], ([LImportDecl GhcPs], [LHsDecl GhcPs])) -> HappyAbsSyn
happyIn39 x :: ([AddAnn], ([LImportDecl GhcPs], [LHsDecl GhcPs]))
x = HappyWrap39 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], ([LImportDecl GhcPs], [LHsDecl GhcPs])) -> HappyWrap39
HappyWrap39 ([AddAnn], ([LImportDecl GhcPs], [LHsDecl GhcPs]))
x)
{-# INLINE happyIn39 #-}
happyOut39 :: (HappyAbsSyn ) -> HappyWrap39
happyOut39 :: HappyAbsSyn -> HappyWrap39
happyOut39 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap39
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut39 #-}
newtype HappyWrap40 = HappyWrap40 (([AddAnn]
             ,([LImportDecl GhcPs], [LHsDecl GhcPs])))
happyIn40 :: (([AddAnn]
             ,([LImportDecl GhcPs], [LHsDecl GhcPs]))) -> (HappyAbsSyn )
happyIn40 :: ([AddAnn], ([LImportDecl GhcPs], [LHsDecl GhcPs])) -> HappyAbsSyn
happyIn40 x :: ([AddAnn], ([LImportDecl GhcPs], [LHsDecl GhcPs]))
x = HappyWrap40 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], ([LImportDecl GhcPs], [LHsDecl GhcPs])) -> HappyWrap40
HappyWrap40 ([AddAnn], ([LImportDecl GhcPs], [LHsDecl GhcPs]))
x)
{-# INLINE happyIn40 #-}
happyOut40 :: (HappyAbsSyn ) -> HappyWrap40
happyOut40 :: HappyAbsSyn -> HappyWrap40
happyOut40 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap40
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut40 #-}
newtype HappyWrap41 = HappyWrap41 (([AddAnn]
             ,([LImportDecl GhcPs], [LHsDecl GhcPs])))
happyIn41 :: (([AddAnn]
             ,([LImportDecl GhcPs], [LHsDecl GhcPs]))) -> (HappyAbsSyn )
happyIn41 :: ([AddAnn], ([LImportDecl GhcPs], [LHsDecl GhcPs])) -> HappyAbsSyn
happyIn41 x :: ([AddAnn], ([LImportDecl GhcPs], [LHsDecl GhcPs]))
x = HappyWrap41 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], ([LImportDecl GhcPs], [LHsDecl GhcPs])) -> HappyWrap41
HappyWrap41 ([AddAnn], ([LImportDecl GhcPs], [LHsDecl GhcPs]))
x)
{-# INLINE happyIn41 #-}
happyOut41 :: (HappyAbsSyn ) -> HappyWrap41
happyOut41 :: HappyAbsSyn -> HappyWrap41
happyOut41 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap41
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut41 #-}
newtype HappyWrap42 = HappyWrap42 (([LImportDecl GhcPs], [LHsDecl GhcPs]))
happyIn42 :: (([LImportDecl GhcPs], [LHsDecl GhcPs])) -> (HappyAbsSyn )
happyIn42 :: ([LImportDecl GhcPs], [LHsDecl GhcPs]) -> HappyAbsSyn
happyIn42 x :: ([LImportDecl GhcPs], [LHsDecl GhcPs])
x = HappyWrap42 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([LImportDecl GhcPs], [LHsDecl GhcPs]) -> HappyWrap42
HappyWrap42 ([LImportDecl GhcPs], [LHsDecl GhcPs])
x)
{-# INLINE happyIn42 #-}
happyOut42 :: (HappyAbsSyn ) -> HappyWrap42
happyOut42 :: HappyAbsSyn -> HappyWrap42
happyOut42 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap42
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut42 #-}
newtype HappyWrap43 = HappyWrap43 (Located (HsModule GhcPs))
happyIn43 :: (Located (HsModule GhcPs)) -> (HappyAbsSyn )
happyIn43 :: Located (HsModule GhcPs) -> HappyAbsSyn
happyIn43 x :: Located (HsModule GhcPs)
x = HappyWrap43 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (HsModule GhcPs) -> HappyWrap43
HappyWrap43 Located (HsModule GhcPs)
x)
{-# INLINE happyIn43 #-}
happyOut43 :: (HappyAbsSyn ) -> HappyWrap43
happyOut43 :: HappyAbsSyn -> HappyWrap43
happyOut43 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap43
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut43 #-}
newtype HappyWrap44 = HappyWrap44 ([LImportDecl GhcPs])
happyIn44 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )
happyIn44 :: [LImportDecl GhcPs] -> HappyAbsSyn
happyIn44 x :: [LImportDecl GhcPs]
x = HappyWrap44 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LImportDecl GhcPs] -> HappyWrap44
HappyWrap44 [LImportDecl GhcPs]
x)
{-# INLINE happyIn44 #-}
happyOut44 :: (HappyAbsSyn ) -> HappyWrap44
happyOut44 :: HappyAbsSyn -> HappyWrap44
happyOut44 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap44
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut44 #-}
newtype HappyWrap45 = HappyWrap45 ([LImportDecl GhcPs])
happyIn45 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )
happyIn45 :: [LImportDecl GhcPs] -> HappyAbsSyn
happyIn45 x :: [LImportDecl GhcPs]
x = HappyWrap45 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LImportDecl GhcPs] -> HappyWrap45
HappyWrap45 [LImportDecl GhcPs]
x)
{-# INLINE happyIn45 #-}
happyOut45 :: (HappyAbsSyn ) -> HappyWrap45
happyOut45 :: HappyAbsSyn -> HappyWrap45
happyOut45 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap45
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut45 #-}
newtype HappyWrap46 = HappyWrap46 ([LImportDecl GhcPs])
happyIn46 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )
happyIn46 :: [LImportDecl GhcPs] -> HappyAbsSyn
happyIn46 x :: [LImportDecl GhcPs]
x = HappyWrap46 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LImportDecl GhcPs] -> HappyWrap46
HappyWrap46 [LImportDecl GhcPs]
x)
{-# INLINE happyIn46 #-}
happyOut46 :: (HappyAbsSyn ) -> HappyWrap46
happyOut46 :: HappyAbsSyn -> HappyWrap46
happyOut46 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap46
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut46 #-}
newtype HappyWrap47 = HappyWrap47 ([LImportDecl GhcPs])
happyIn47 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )
happyIn47 :: [LImportDecl GhcPs] -> HappyAbsSyn
happyIn47 x :: [LImportDecl GhcPs]
x = HappyWrap47 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LImportDecl GhcPs] -> HappyWrap47
HappyWrap47 [LImportDecl GhcPs]
x)
{-# INLINE happyIn47 #-}
happyOut47 :: (HappyAbsSyn ) -> HappyWrap47
happyOut47 :: HappyAbsSyn -> HappyWrap47
happyOut47 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap47
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut47 #-}
newtype HappyWrap48 = HappyWrap48 ((Maybe (Located [LIE GhcPs])))
happyIn48 :: ((Maybe (Located [LIE GhcPs]))) -> (HappyAbsSyn )
happyIn48 :: Maybe (Located [LIE GhcPs]) -> HappyAbsSyn
happyIn48 x :: Maybe (Located [LIE GhcPs])
x = HappyWrap48 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Maybe (Located [LIE GhcPs]) -> HappyWrap48
HappyWrap48 Maybe (Located [LIE GhcPs])
x)
{-# INLINE happyIn48 #-}
happyOut48 :: (HappyAbsSyn ) -> HappyWrap48
happyOut48 :: HappyAbsSyn -> HappyWrap48
happyOut48 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap48
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut48 #-}
newtype HappyWrap49 = HappyWrap49 (OrdList (LIE GhcPs))
happyIn49 :: (OrdList (LIE GhcPs)) -> (HappyAbsSyn )
happyIn49 :: OrdList (LIE GhcPs) -> HappyAbsSyn
happyIn49 x :: OrdList (LIE GhcPs)
x = HappyWrap49 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList (LIE GhcPs) -> HappyWrap49
HappyWrap49 OrdList (LIE GhcPs)
x)
{-# INLINE happyIn49 #-}
happyOut49 :: (HappyAbsSyn ) -> HappyWrap49
happyOut49 :: HappyAbsSyn -> HappyWrap49
happyOut49 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap49
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut49 #-}
newtype HappyWrap50 = HappyWrap50 (OrdList (LIE GhcPs))
happyIn50 :: (OrdList (LIE GhcPs)) -> (HappyAbsSyn )
happyIn50 :: OrdList (LIE GhcPs) -> HappyAbsSyn
happyIn50 x :: OrdList (LIE GhcPs)
x = HappyWrap50 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList (LIE GhcPs) -> HappyWrap50
HappyWrap50 OrdList (LIE GhcPs)
x)
{-# INLINE happyIn50 #-}
happyOut50 :: (HappyAbsSyn ) -> HappyWrap50
happyOut50 :: HappyAbsSyn -> HappyWrap50
happyOut50 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap50
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut50 #-}
newtype HappyWrap51 = HappyWrap51 (OrdList (LIE GhcPs))
happyIn51 :: (OrdList (LIE GhcPs)) -> (HappyAbsSyn )
happyIn51 :: OrdList (LIE GhcPs) -> HappyAbsSyn
happyIn51 x :: OrdList (LIE GhcPs)
x = HappyWrap51 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList (LIE GhcPs) -> HappyWrap51
HappyWrap51 OrdList (LIE GhcPs)
x)
{-# INLINE happyIn51 #-}
happyOut51 :: (HappyAbsSyn ) -> HappyWrap51
happyOut51 :: HappyAbsSyn -> HappyWrap51
happyOut51 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap51
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut51 #-}
newtype HappyWrap52 = HappyWrap52 (OrdList (LIE GhcPs))
happyIn52 :: (OrdList (LIE GhcPs)) -> (HappyAbsSyn )
happyIn52 :: OrdList (LIE GhcPs) -> HappyAbsSyn
happyIn52 x :: OrdList (LIE GhcPs)
x = HappyWrap52 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList (LIE GhcPs) -> HappyWrap52
HappyWrap52 OrdList (LIE GhcPs)
x)
{-# INLINE happyIn52 #-}
happyOut52 :: (HappyAbsSyn ) -> HappyWrap52
happyOut52 :: HappyAbsSyn -> HappyWrap52
happyOut52 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap52
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut52 #-}
newtype HappyWrap53 = HappyWrap53 (OrdList (LIE GhcPs))
happyIn53 :: (OrdList (LIE GhcPs)) -> (HappyAbsSyn )
happyIn53 :: OrdList (LIE GhcPs) -> HappyAbsSyn
happyIn53 x :: OrdList (LIE GhcPs)
x = HappyWrap53 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList (LIE GhcPs) -> HappyWrap53
HappyWrap53 OrdList (LIE GhcPs)
x)
{-# INLINE happyIn53 #-}
happyOut53 :: (HappyAbsSyn ) -> HappyWrap53
happyOut53 :: HappyAbsSyn -> HappyWrap53
happyOut53 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap53
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut53 #-}
newtype HappyWrap54 = HappyWrap54 (Located ([AddAnn],ImpExpSubSpec))
happyIn54 :: (Located ([AddAnn],ImpExpSubSpec)) -> (HappyAbsSyn )
happyIn54 :: Located ([AddAnn], ImpExpSubSpec) -> HappyAbsSyn
happyIn54 x :: Located ([AddAnn], ImpExpSubSpec)
x = HappyWrap54 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], ImpExpSubSpec) -> HappyWrap54
HappyWrap54 Located ([AddAnn], ImpExpSubSpec)
x)
{-# INLINE happyIn54 #-}
happyOut54 :: (HappyAbsSyn ) -> HappyWrap54
happyOut54 :: HappyAbsSyn -> HappyWrap54
happyOut54 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap54
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut54 #-}
newtype HappyWrap55 = HappyWrap55 (([AddAnn], [Located ImpExpQcSpec]))
happyIn55 :: (([AddAnn], [Located ImpExpQcSpec])) -> (HappyAbsSyn )
happyIn55 :: ([AddAnn], [Located ImpExpQcSpec]) -> HappyAbsSyn
happyIn55 x :: ([AddAnn], [Located ImpExpQcSpec])
x = HappyWrap55 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], [Located ImpExpQcSpec]) -> HappyWrap55
HappyWrap55 ([AddAnn], [Located ImpExpQcSpec])
x)
{-# INLINE happyIn55 #-}
happyOut55 :: (HappyAbsSyn ) -> HappyWrap55
happyOut55 :: HappyAbsSyn -> HappyWrap55
happyOut55 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap55
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut55 #-}
newtype HappyWrap56 = HappyWrap56 (([AddAnn], [Located ImpExpQcSpec]))
happyIn56 :: (([AddAnn], [Located ImpExpQcSpec])) -> (HappyAbsSyn )
happyIn56 :: ([AddAnn], [Located ImpExpQcSpec]) -> HappyAbsSyn
happyIn56 x :: ([AddAnn], [Located ImpExpQcSpec])
x = HappyWrap56 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], [Located ImpExpQcSpec]) -> HappyWrap56
HappyWrap56 ([AddAnn], [Located ImpExpQcSpec])
x)
{-# INLINE happyIn56 #-}
happyOut56 :: (HappyAbsSyn ) -> HappyWrap56
happyOut56 :: HappyAbsSyn -> HappyWrap56
happyOut56 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap56
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut56 #-}
newtype HappyWrap57 = HappyWrap57 (Located ([AddAnn], Located ImpExpQcSpec))
happyIn57 :: (Located ([AddAnn], Located ImpExpQcSpec)) -> (HappyAbsSyn )
happyIn57 :: Located ([AddAnn], Located ImpExpQcSpec) -> HappyAbsSyn
happyIn57 x :: Located ([AddAnn], Located ImpExpQcSpec)
x = HappyWrap57 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], Located ImpExpQcSpec) -> HappyWrap57
HappyWrap57 Located ([AddAnn], Located ImpExpQcSpec)
x)
{-# INLINE happyIn57 #-}
happyOut57 :: (HappyAbsSyn ) -> HappyWrap57
happyOut57 :: HappyAbsSyn -> HappyWrap57
happyOut57 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap57
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut57 #-}
newtype HappyWrap58 = HappyWrap58 (Located ImpExpQcSpec)
happyIn58 :: (Located ImpExpQcSpec) -> (HappyAbsSyn )
happyIn58 :: Located ImpExpQcSpec -> HappyAbsSyn
happyIn58 x :: Located ImpExpQcSpec
x = HappyWrap58 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ImpExpQcSpec -> HappyWrap58
HappyWrap58 Located ImpExpQcSpec
x)
{-# INLINE happyIn58 #-}
happyOut58 :: (HappyAbsSyn ) -> HappyWrap58
happyOut58 :: HappyAbsSyn -> HappyWrap58
happyOut58 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap58
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut58 #-}
newtype HappyWrap59 = HappyWrap59 (Located RdrName)
happyIn59 :: (Located RdrName) -> (HappyAbsSyn )
happyIn59 :: Located RdrName -> HappyAbsSyn
happyIn59 x :: Located RdrName
x = HappyWrap59 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located RdrName -> HappyWrap59
HappyWrap59 Located RdrName
x)
{-# INLINE happyIn59 #-}
happyOut59 :: (HappyAbsSyn ) -> HappyWrap59
happyOut59 :: HappyAbsSyn -> HappyWrap59
happyOut59 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap59
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut59 #-}
newtype HappyWrap60 = HappyWrap60 ([AddAnn])
happyIn60 :: ([AddAnn]) -> (HappyAbsSyn )
happyIn60 :: [AddAnn] -> HappyAbsSyn
happyIn60 x :: [AddAnn]
x = HappyWrap60 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([AddAnn] -> HappyWrap60
HappyWrap60 [AddAnn]
x)
{-# INLINE happyIn60 #-}
happyOut60 :: (HappyAbsSyn ) -> HappyWrap60
happyOut60 :: HappyAbsSyn -> HappyWrap60
happyOut60 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap60
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut60 #-}
newtype HappyWrap61 = HappyWrap61 ([AddAnn])
happyIn61 :: ([AddAnn]) -> (HappyAbsSyn )
happyIn61 :: [AddAnn] -> HappyAbsSyn
happyIn61 x :: [AddAnn]
x = HappyWrap61 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([AddAnn] -> HappyWrap61
HappyWrap61 [AddAnn]
x)
{-# INLINE happyIn61 #-}
happyOut61 :: (HappyAbsSyn ) -> HappyWrap61
happyOut61 :: HappyAbsSyn -> HappyWrap61
happyOut61 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap61
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut61 #-}
newtype HappyWrap62 = HappyWrap62 ([LImportDecl GhcPs])
happyIn62 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )
happyIn62 :: [LImportDecl GhcPs] -> HappyAbsSyn
happyIn62 x :: [LImportDecl GhcPs]
x = HappyWrap62 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LImportDecl GhcPs] -> HappyWrap62
HappyWrap62 [LImportDecl GhcPs]
x)
{-# INLINE happyIn62 #-}
happyOut62 :: (HappyAbsSyn ) -> HappyWrap62
happyOut62 :: HappyAbsSyn -> HappyWrap62
happyOut62 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap62
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut62 #-}
newtype HappyWrap63 = HappyWrap63 ([LImportDecl GhcPs])
happyIn63 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )
happyIn63 :: [LImportDecl GhcPs] -> HappyAbsSyn
happyIn63 x :: [LImportDecl GhcPs]
x = HappyWrap63 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LImportDecl GhcPs] -> HappyWrap63
HappyWrap63 [LImportDecl GhcPs]
x)
{-# INLINE happyIn63 #-}
happyOut63 :: (HappyAbsSyn ) -> HappyWrap63
happyOut63 :: HappyAbsSyn -> HappyWrap63
happyOut63 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap63
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut63 #-}
newtype HappyWrap64 = HappyWrap64 (LImportDecl GhcPs)
happyIn64 :: (LImportDecl GhcPs) -> (HappyAbsSyn )
happyIn64 :: LImportDecl GhcPs -> HappyAbsSyn
happyIn64 x :: LImportDecl GhcPs
x = HappyWrap64 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LImportDecl GhcPs -> HappyWrap64
HappyWrap64 LImportDecl GhcPs
x)
{-# INLINE happyIn64 #-}
happyOut64 :: (HappyAbsSyn ) -> HappyWrap64
happyOut64 :: HappyAbsSyn -> HappyWrap64
happyOut64 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap64
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut64 #-}
newtype HappyWrap65 = HappyWrap65 ((([AddAnn],SourceText),IsBootInterface))
happyIn65 :: ((([AddAnn],SourceText),IsBootInterface)) -> (HappyAbsSyn )
happyIn65 :: (([AddAnn], SourceText), IsBootInterface) -> HappyAbsSyn
happyIn65 x :: (([AddAnn], SourceText), IsBootInterface)
x = HappyWrap65 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ((([AddAnn], SourceText), IsBootInterface) -> HappyWrap65
HappyWrap65 (([AddAnn], SourceText), IsBootInterface)
x)
{-# INLINE happyIn65 #-}
happyOut65 :: (HappyAbsSyn ) -> HappyWrap65
happyOut65 :: HappyAbsSyn -> HappyWrap65
happyOut65 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap65
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut65 #-}
newtype HappyWrap66 = HappyWrap66 (([AddAnn],Bool))
happyIn66 :: (([AddAnn],Bool)) -> (HappyAbsSyn )
happyIn66 :: ([AddAnn], IsBootInterface) -> HappyAbsSyn
happyIn66 x :: ([AddAnn], IsBootInterface)
x = HappyWrap66 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], IsBootInterface) -> HappyWrap66
HappyWrap66 ([AddAnn], IsBootInterface)
x)
{-# INLINE happyIn66 #-}
happyOut66 :: (HappyAbsSyn ) -> HappyWrap66
happyOut66 :: HappyAbsSyn -> HappyWrap66
happyOut66 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap66
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut66 #-}
newtype HappyWrap67 = HappyWrap67 (([AddAnn],Maybe StringLiteral))
happyIn67 :: (([AddAnn],Maybe StringLiteral)) -> (HappyAbsSyn )
happyIn67 :: ([AddAnn], Maybe StringLiteral) -> HappyAbsSyn
happyIn67 x :: ([AddAnn], Maybe StringLiteral)
x = HappyWrap67 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], Maybe StringLiteral) -> HappyWrap67
HappyWrap67 ([AddAnn], Maybe StringLiteral)
x)
{-# INLINE happyIn67 #-}
happyOut67 :: (HappyAbsSyn ) -> HappyWrap67
happyOut67 :: HappyAbsSyn -> HappyWrap67
happyOut67 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap67
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut67 #-}
newtype HappyWrap68 = HappyWrap68 (([AddAnn],Bool))
happyIn68 :: (([AddAnn],Bool)) -> (HappyAbsSyn )
happyIn68 :: ([AddAnn], IsBootInterface) -> HappyAbsSyn
happyIn68 x :: ([AddAnn], IsBootInterface)
x = HappyWrap68 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], IsBootInterface) -> HappyWrap68
HappyWrap68 ([AddAnn], IsBootInterface)
x)
{-# INLINE happyIn68 #-}
happyOut68 :: (HappyAbsSyn ) -> HappyWrap68
happyOut68 :: HappyAbsSyn -> HappyWrap68
happyOut68 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap68
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut68 #-}
newtype HappyWrap69 = HappyWrap69 (([AddAnn],Located (Maybe (Located ModuleName))))
happyIn69 :: (([AddAnn],Located (Maybe (Located ModuleName)))) -> (HappyAbsSyn )
happyIn69 :: ([AddAnn], Located (Maybe (Located ModuleName))) -> HappyAbsSyn
happyIn69 x :: ([AddAnn], Located (Maybe (Located ModuleName)))
x = HappyWrap69 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], Located (Maybe (Located ModuleName))) -> HappyWrap69
HappyWrap69 ([AddAnn], Located (Maybe (Located ModuleName)))
x)
{-# INLINE happyIn69 #-}
happyOut69 :: (HappyAbsSyn ) -> HappyWrap69
happyOut69 :: HappyAbsSyn -> HappyWrap69
happyOut69 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap69
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut69 #-}
newtype HappyWrap70 = HappyWrap70 (Located (Maybe (Bool, Located [LIE GhcPs])))
happyIn70 :: (Located (Maybe (Bool, Located [LIE GhcPs]))) -> (HappyAbsSyn )
happyIn70 :: Located (Maybe (IsBootInterface, Located [LIE GhcPs]))
-> HappyAbsSyn
happyIn70 x :: Located (Maybe (IsBootInterface, Located [LIE GhcPs]))
x = HappyWrap70 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (Maybe (IsBootInterface, Located [LIE GhcPs]))
-> HappyWrap70
HappyWrap70 Located (Maybe (IsBootInterface, Located [LIE GhcPs]))
x)
{-# INLINE happyIn70 #-}
happyOut70 :: (HappyAbsSyn ) -> HappyWrap70
happyOut70 :: HappyAbsSyn -> HappyWrap70
happyOut70 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap70
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut70 #-}
newtype HappyWrap71 = HappyWrap71 (Located (Bool, Located [LIE GhcPs]))
happyIn71 :: (Located (Bool, Located [LIE GhcPs])) -> (HappyAbsSyn )
happyIn71 :: Located (IsBootInterface, Located [LIE GhcPs]) -> HappyAbsSyn
happyIn71 x :: Located (IsBootInterface, Located [LIE GhcPs])
x = HappyWrap71 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (IsBootInterface, Located [LIE GhcPs]) -> HappyWrap71
HappyWrap71 Located (IsBootInterface, Located [LIE GhcPs])
x)
{-# INLINE happyIn71 #-}
happyOut71 :: (HappyAbsSyn ) -> HappyWrap71
happyOut71 :: HappyAbsSyn -> HappyWrap71
happyOut71 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap71
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut71 #-}
newtype HappyWrap72 = HappyWrap72 (Located (SourceText,Int))
happyIn72 :: (Located (SourceText,Int)) -> (HappyAbsSyn )
happyIn72 :: Located (SourceText, Int) -> HappyAbsSyn
happyIn72 x :: Located (SourceText, Int)
x = HappyWrap72 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (SourceText, Int) -> HappyWrap72
HappyWrap72 Located (SourceText, Int)
x)
{-# INLINE happyIn72 #-}
happyOut72 :: (HappyAbsSyn ) -> HappyWrap72
happyOut72 :: HappyAbsSyn -> HappyWrap72
happyOut72 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap72
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut72 #-}
newtype HappyWrap73 = HappyWrap73 (Located FixityDirection)
happyIn73 :: (Located FixityDirection) -> (HappyAbsSyn )
happyIn73 :: Located FixityDirection -> HappyAbsSyn
happyIn73 x :: Located FixityDirection
x = HappyWrap73 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located FixityDirection -> HappyWrap73
HappyWrap73 Located FixityDirection
x)
{-# INLINE happyIn73 #-}
happyOut73 :: (HappyAbsSyn ) -> HappyWrap73
happyOut73 :: HappyAbsSyn -> HappyWrap73
happyOut73 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap73
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut73 #-}
newtype HappyWrap74 = HappyWrap74 (Located (OrdList (Located RdrName)))
happyIn74 :: (Located (OrdList (Located RdrName))) -> (HappyAbsSyn )
happyIn74 :: Located (OrdList (Located RdrName)) -> HappyAbsSyn
happyIn74 x :: Located (OrdList (Located RdrName))
x = HappyWrap74 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (OrdList (Located RdrName)) -> HappyWrap74
HappyWrap74 Located (OrdList (Located RdrName))
x)
{-# INLINE happyIn74 #-}
happyOut74 :: (HappyAbsSyn ) -> HappyWrap74
happyOut74 :: HappyAbsSyn -> HappyWrap74
happyOut74 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap74
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut74 #-}
newtype HappyWrap75 = HappyWrap75 (OrdList (LHsDecl GhcPs))
happyIn75 :: (OrdList (LHsDecl GhcPs)) -> (HappyAbsSyn )
happyIn75 :: OrdList (LHsDecl GhcPs) -> HappyAbsSyn
happyIn75 x :: OrdList (LHsDecl GhcPs)
x = HappyWrap75 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList (LHsDecl GhcPs) -> HappyWrap75
HappyWrap75 OrdList (LHsDecl GhcPs)
x)
{-# INLINE happyIn75 #-}
happyOut75 :: (HappyAbsSyn ) -> HappyWrap75
happyOut75 :: HappyAbsSyn -> HappyWrap75
happyOut75 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap75
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut75 #-}
newtype HappyWrap76 = HappyWrap76 (OrdList (LHsDecl GhcPs))
happyIn76 :: (OrdList (LHsDecl GhcPs)) -> (HappyAbsSyn )
happyIn76 :: OrdList (LHsDecl GhcPs) -> HappyAbsSyn
happyIn76 x :: OrdList (LHsDecl GhcPs)
x = HappyWrap76 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList (LHsDecl GhcPs) -> HappyWrap76
HappyWrap76 OrdList (LHsDecl GhcPs)
x)
{-# INLINE happyIn76 #-}
happyOut76 :: (HappyAbsSyn ) -> HappyWrap76
happyOut76 :: HappyAbsSyn -> HappyWrap76
happyOut76 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap76
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut76 #-}
newtype HappyWrap77 = HappyWrap77 (LHsDecl GhcPs)
happyIn77 :: (LHsDecl GhcPs) -> (HappyAbsSyn )
happyIn77 :: LHsDecl GhcPs -> HappyAbsSyn
happyIn77 x :: LHsDecl GhcPs
x = HappyWrap77 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsDecl GhcPs -> HappyWrap77
HappyWrap77 LHsDecl GhcPs
x)
{-# INLINE happyIn77 #-}
happyOut77 :: (HappyAbsSyn ) -> HappyWrap77
happyOut77 :: HappyAbsSyn -> HappyWrap77
happyOut77 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap77
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut77 #-}
newtype HappyWrap78 = HappyWrap78 (LTyClDecl GhcPs)
happyIn78 :: (LTyClDecl GhcPs) -> (HappyAbsSyn )
happyIn78 :: LTyClDecl GhcPs -> HappyAbsSyn
happyIn78 x :: LTyClDecl GhcPs
x = HappyWrap78 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LTyClDecl GhcPs -> HappyWrap78
HappyWrap78 LTyClDecl GhcPs
x)
{-# INLINE happyIn78 #-}
happyOut78 :: (HappyAbsSyn ) -> HappyWrap78
happyOut78 :: HappyAbsSyn -> HappyWrap78
happyOut78 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap78
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut78 #-}
newtype HappyWrap79 = HappyWrap79 (LTyClDecl GhcPs)
happyIn79 :: (LTyClDecl GhcPs) -> (HappyAbsSyn )
happyIn79 :: LTyClDecl GhcPs -> HappyAbsSyn
happyIn79 x :: LTyClDecl GhcPs
x = HappyWrap79 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LTyClDecl GhcPs -> HappyWrap79
HappyWrap79 LTyClDecl GhcPs
x)
{-# INLINE happyIn79 #-}
happyOut79 :: (HappyAbsSyn ) -> HappyWrap79
happyOut79 :: HappyAbsSyn -> HappyWrap79
happyOut79 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap79
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut79 #-}
newtype HappyWrap80 = HappyWrap80 (LInstDecl GhcPs)
happyIn80 :: (LInstDecl GhcPs) -> (HappyAbsSyn )
happyIn80 :: LInstDecl GhcPs -> HappyAbsSyn
happyIn80 x :: LInstDecl GhcPs
x = HappyWrap80 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LInstDecl GhcPs -> HappyWrap80
HappyWrap80 LInstDecl GhcPs
x)
{-# INLINE happyIn80 #-}
happyOut80 :: (HappyAbsSyn ) -> HappyWrap80
happyOut80 :: HappyAbsSyn -> HappyWrap80
happyOut80 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap80
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut80 #-}
newtype HappyWrap81 = HappyWrap81 (Maybe (Located OverlapMode))
happyIn81 :: (Maybe (Located OverlapMode)) -> (HappyAbsSyn )
happyIn81 :: Maybe (Located OverlapMode) -> HappyAbsSyn
happyIn81 x :: Maybe (Located OverlapMode)
x = HappyWrap81 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Maybe (Located OverlapMode) -> HappyWrap81
HappyWrap81 Maybe (Located OverlapMode)
x)
{-# INLINE happyIn81 #-}
happyOut81 :: (HappyAbsSyn ) -> HappyWrap81
happyOut81 :: HappyAbsSyn -> HappyWrap81
happyOut81 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap81
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut81 #-}
newtype HappyWrap82 = HappyWrap82 (LDerivStrategy GhcPs)
happyIn82 :: (LDerivStrategy GhcPs) -> (HappyAbsSyn )
happyIn82 :: LDerivStrategy GhcPs -> HappyAbsSyn
happyIn82 x :: LDerivStrategy GhcPs
x = HappyWrap82 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LDerivStrategy GhcPs -> HappyWrap82
HappyWrap82 LDerivStrategy GhcPs
x)
{-# INLINE happyIn82 #-}
happyOut82 :: (HappyAbsSyn ) -> HappyWrap82
happyOut82 :: HappyAbsSyn -> HappyWrap82
happyOut82 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap82
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut82 #-}
newtype HappyWrap83 = HappyWrap83 (LDerivStrategy GhcPs)
happyIn83 :: (LDerivStrategy GhcPs) -> (HappyAbsSyn )
happyIn83 :: LDerivStrategy GhcPs -> HappyAbsSyn
happyIn83 x :: LDerivStrategy GhcPs
x = HappyWrap83 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LDerivStrategy GhcPs -> HappyWrap83
HappyWrap83 LDerivStrategy GhcPs
x)
{-# INLINE happyIn83 #-}
happyOut83 :: (HappyAbsSyn ) -> HappyWrap83
happyOut83 :: HappyAbsSyn -> HappyWrap83
happyOut83 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap83
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut83 #-}
newtype HappyWrap84 = HappyWrap84 (Maybe (LDerivStrategy GhcPs))
happyIn84 :: (Maybe (LDerivStrategy GhcPs)) -> (HappyAbsSyn )
happyIn84 :: Maybe (LDerivStrategy GhcPs) -> HappyAbsSyn
happyIn84 x :: Maybe (LDerivStrategy GhcPs)
x = HappyWrap84 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Maybe (LDerivStrategy GhcPs) -> HappyWrap84
HappyWrap84 Maybe (LDerivStrategy GhcPs)
x)
{-# INLINE happyIn84 #-}
happyOut84 :: (HappyAbsSyn ) -> HappyWrap84
happyOut84 :: HappyAbsSyn -> HappyWrap84
happyOut84 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap84
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut84 #-}
newtype HappyWrap85 = HappyWrap85 (Located ([AddAnn], Maybe (LInjectivityAnn GhcPs)))
happyIn85 :: (Located ([AddAnn], Maybe (LInjectivityAnn GhcPs))) -> (HappyAbsSyn )
happyIn85 :: Located ([AddAnn], Maybe (LInjectivityAnn GhcPs)) -> HappyAbsSyn
happyIn85 x :: Located ([AddAnn], Maybe (LInjectivityAnn GhcPs))
x = HappyWrap85 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], Maybe (LInjectivityAnn GhcPs)) -> HappyWrap85
HappyWrap85 Located ([AddAnn], Maybe (LInjectivityAnn GhcPs))
x)
{-# INLINE happyIn85 #-}
happyOut85 :: (HappyAbsSyn ) -> HappyWrap85
happyOut85 :: HappyAbsSyn -> HappyWrap85
happyOut85 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap85
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut85 #-}
newtype HappyWrap86 = HappyWrap86 (LInjectivityAnn GhcPs)
happyIn86 :: (LInjectivityAnn GhcPs) -> (HappyAbsSyn )
happyIn86 :: LInjectivityAnn GhcPs -> HappyAbsSyn
happyIn86 x :: LInjectivityAnn GhcPs
x = HappyWrap86 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LInjectivityAnn GhcPs -> HappyWrap86
HappyWrap86 LInjectivityAnn GhcPs
x)
{-# INLINE happyIn86 #-}
happyOut86 :: (HappyAbsSyn ) -> HappyWrap86
happyOut86 :: HappyAbsSyn -> HappyWrap86
happyOut86 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap86
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut86 #-}
newtype HappyWrap87 = HappyWrap87 (Located [Located RdrName])
happyIn87 :: (Located [Located RdrName]) -> (HappyAbsSyn )
happyIn87 :: Located [Located RdrName] -> HappyAbsSyn
happyIn87 x :: Located [Located RdrName]
x = HappyWrap87 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [Located RdrName] -> HappyWrap87
HappyWrap87 Located [Located RdrName]
x)
{-# INLINE happyIn87 #-}
happyOut87 :: (HappyAbsSyn ) -> HappyWrap87
happyOut87 :: HappyAbsSyn -> HappyWrap87
happyOut87 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap87
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut87 #-}
newtype HappyWrap88 = HappyWrap88 (Located ([AddAnn],FamilyInfo GhcPs))
happyIn88 :: (Located ([AddAnn],FamilyInfo GhcPs)) -> (HappyAbsSyn )
happyIn88 :: Located ([AddAnn], FamilyInfo GhcPs) -> HappyAbsSyn
happyIn88 x :: Located ([AddAnn], FamilyInfo GhcPs)
x = HappyWrap88 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], FamilyInfo GhcPs) -> HappyWrap88
HappyWrap88 Located ([AddAnn], FamilyInfo GhcPs)
x)
{-# INLINE happyIn88 #-}
happyOut88 :: (HappyAbsSyn ) -> HappyWrap88
happyOut88 :: HappyAbsSyn -> HappyWrap88
happyOut88 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap88
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut88 #-}
newtype HappyWrap89 = HappyWrap89 (Located ([AddAnn],Maybe [LTyFamInstEqn GhcPs]))
happyIn89 :: (Located ([AddAnn],Maybe [LTyFamInstEqn GhcPs])) -> (HappyAbsSyn )
happyIn89 :: Located ([AddAnn], Maybe [LTyFamInstEqn GhcPs]) -> HappyAbsSyn
happyIn89 x :: Located ([AddAnn], Maybe [LTyFamInstEqn GhcPs])
x = HappyWrap89 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], Maybe [LTyFamInstEqn GhcPs]) -> HappyWrap89
HappyWrap89 Located ([AddAnn], Maybe [LTyFamInstEqn GhcPs])
x)
{-# INLINE happyIn89 #-}
happyOut89 :: (HappyAbsSyn ) -> HappyWrap89
happyOut89 :: HappyAbsSyn -> HappyWrap89
happyOut89 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap89
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut89 #-}
newtype HappyWrap90 = HappyWrap90 (Located [LTyFamInstEqn GhcPs])
happyIn90 :: (Located [LTyFamInstEqn GhcPs]) -> (HappyAbsSyn )
happyIn90 :: Located [LTyFamInstEqn GhcPs] -> HappyAbsSyn
happyIn90 x :: Located [LTyFamInstEqn GhcPs]
x = HappyWrap90 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [LTyFamInstEqn GhcPs] -> HappyWrap90
HappyWrap90 Located [LTyFamInstEqn GhcPs]
x)
{-# INLINE happyIn90 #-}
happyOut90 :: (HappyAbsSyn ) -> HappyWrap90
happyOut90 :: HappyAbsSyn -> HappyWrap90
happyOut90 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap90
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut90 #-}
newtype HappyWrap91 = HappyWrap91 (Located ([AddAnn],TyFamInstEqn GhcPs))
happyIn91 :: (Located ([AddAnn],TyFamInstEqn GhcPs)) -> (HappyAbsSyn )
happyIn91 :: Located ([AddAnn], TyFamInstEqn GhcPs) -> HappyAbsSyn
happyIn91 x :: Located ([AddAnn], TyFamInstEqn GhcPs)
x = HappyWrap91 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], TyFamInstEqn GhcPs) -> HappyWrap91
HappyWrap91 Located ([AddAnn], TyFamInstEqn GhcPs)
x)
{-# INLINE happyIn91 #-}
happyOut91 :: (HappyAbsSyn ) -> HappyWrap91
happyOut91 :: HappyAbsSyn -> HappyWrap91
happyOut91 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap91
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut91 #-}
newtype HappyWrap92 = HappyWrap92 (LHsDecl GhcPs)
happyIn92 :: (LHsDecl GhcPs) -> (HappyAbsSyn )
happyIn92 :: LHsDecl GhcPs -> HappyAbsSyn
happyIn92 x :: LHsDecl GhcPs
x = HappyWrap92 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsDecl GhcPs -> HappyWrap92
HappyWrap92 LHsDecl GhcPs
x)
{-# INLINE happyIn92 #-}
happyOut92 :: (HappyAbsSyn ) -> HappyWrap92
happyOut92 :: HappyAbsSyn -> HappyWrap92
happyOut92 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap92
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut92 #-}
newtype HappyWrap93 = HappyWrap93 ([AddAnn])
happyIn93 :: ([AddAnn]) -> (HappyAbsSyn )
happyIn93 :: [AddAnn] -> HappyAbsSyn
happyIn93 x :: [AddAnn]
x = HappyWrap93 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([AddAnn] -> HappyWrap93
HappyWrap93 [AddAnn]
x)
{-# INLINE happyIn93 #-}
happyOut93 :: (HappyAbsSyn ) -> HappyWrap93
happyOut93 :: HappyAbsSyn -> HappyWrap93
happyOut93 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap93
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut93 #-}
newtype HappyWrap94 = HappyWrap94 ([AddAnn])
happyIn94 :: ([AddAnn]) -> (HappyAbsSyn )
happyIn94 :: [AddAnn] -> HappyAbsSyn
happyIn94 x :: [AddAnn]
x = HappyWrap94 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([AddAnn] -> HappyWrap94
HappyWrap94 [AddAnn]
x)
{-# INLINE happyIn94 #-}
happyOut94 :: (HappyAbsSyn ) -> HappyWrap94
happyOut94 :: HappyAbsSyn -> HappyWrap94
happyOut94 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap94
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut94 #-}
newtype HappyWrap95 = HappyWrap95 (LInstDecl GhcPs)
happyIn95 :: (LInstDecl GhcPs) -> (HappyAbsSyn )
happyIn95 :: LInstDecl GhcPs -> HappyAbsSyn
happyIn95 x :: LInstDecl GhcPs
x = HappyWrap95 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LInstDecl GhcPs -> HappyWrap95
HappyWrap95 LInstDecl GhcPs
x)
{-# INLINE happyIn95 #-}
happyOut95 :: (HappyAbsSyn ) -> HappyWrap95
happyOut95 :: HappyAbsSyn -> HappyWrap95
happyOut95 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap95
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut95 #-}
newtype HappyWrap96 = HappyWrap96 (Located (AddAnn, NewOrData))
happyIn96 :: (Located (AddAnn, NewOrData)) -> (HappyAbsSyn )
happyIn96 :: Located (AddAnn, NewOrData) -> HappyAbsSyn
happyIn96 x :: Located (AddAnn, NewOrData)
x = HappyWrap96 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (AddAnn, NewOrData) -> HappyWrap96
HappyWrap96 Located (AddAnn, NewOrData)
x)
{-# INLINE happyIn96 #-}
happyOut96 :: (HappyAbsSyn ) -> HappyWrap96
happyOut96 :: HappyAbsSyn -> HappyWrap96
happyOut96 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap96
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut96 #-}
newtype HappyWrap97 = HappyWrap97 (Located ([AddAnn], Maybe (LHsKind GhcPs)))
happyIn97 :: (Located ([AddAnn], Maybe (LHsKind GhcPs))) -> (HappyAbsSyn )
happyIn97 :: Located ([AddAnn], Maybe (LHsKind GhcPs)) -> HappyAbsSyn
happyIn97 x :: Located ([AddAnn], Maybe (LHsKind GhcPs))
x = HappyWrap97 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], Maybe (LHsKind GhcPs)) -> HappyWrap97
HappyWrap97 Located ([AddAnn], Maybe (LHsKind GhcPs))
x)
{-# INLINE happyIn97 #-}
happyOut97 :: (HappyAbsSyn ) -> HappyWrap97
happyOut97 :: HappyAbsSyn -> HappyWrap97
happyOut97 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap97
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut97 #-}
newtype HappyWrap98 = HappyWrap98 (Located ([AddAnn], LFamilyResultSig GhcPs))
happyIn98 :: (Located ([AddAnn], LFamilyResultSig GhcPs)) -> (HappyAbsSyn )
happyIn98 :: Located ([AddAnn], LFamilyResultSig GhcPs) -> HappyAbsSyn
happyIn98 x :: Located ([AddAnn], LFamilyResultSig GhcPs)
x = HappyWrap98 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], LFamilyResultSig GhcPs) -> HappyWrap98
HappyWrap98 Located ([AddAnn], LFamilyResultSig GhcPs)
x)
{-# INLINE happyIn98 #-}
happyOut98 :: (HappyAbsSyn ) -> HappyWrap98
happyOut98 :: HappyAbsSyn -> HappyWrap98
happyOut98 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap98
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut98 #-}
newtype HappyWrap99 = HappyWrap99 (Located ([AddAnn], LFamilyResultSig GhcPs))
happyIn99 :: (Located ([AddAnn], LFamilyResultSig GhcPs)) -> (HappyAbsSyn )
happyIn99 :: Located ([AddAnn], LFamilyResultSig GhcPs) -> HappyAbsSyn
happyIn99 x :: Located ([AddAnn], LFamilyResultSig GhcPs)
x = HappyWrap99 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], LFamilyResultSig GhcPs) -> HappyWrap99
HappyWrap99 Located ([AddAnn], LFamilyResultSig GhcPs)
x)
{-# INLINE happyIn99 #-}
happyOut99 :: (HappyAbsSyn ) -> HappyWrap99
happyOut99 :: HappyAbsSyn -> HappyWrap99
happyOut99 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap99
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut99 #-}
newtype HappyWrap100 = HappyWrap100 (Located ([AddAnn], ( LFamilyResultSig GhcPs
                                            , Maybe (LInjectivityAnn GhcPs))))
happyIn100 :: (Located ([AddAnn], ( LFamilyResultSig GhcPs
                                            , Maybe (LInjectivityAnn GhcPs)))) -> (HappyAbsSyn )
happyIn100 :: Located
  ([AddAnn], (LFamilyResultSig GhcPs, Maybe (LInjectivityAnn GhcPs)))
-> HappyAbsSyn
happyIn100 x :: Located
  ([AddAnn], (LFamilyResultSig GhcPs, Maybe (LInjectivityAnn GhcPs)))
x = HappyWrap100 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located
  ([AddAnn], (LFamilyResultSig GhcPs, Maybe (LInjectivityAnn GhcPs)))
-> HappyWrap100
HappyWrap100 Located
  ([AddAnn], (LFamilyResultSig GhcPs, Maybe (LInjectivityAnn GhcPs)))
x)
{-# INLINE happyIn100 #-}
happyOut100 :: (HappyAbsSyn ) -> HappyWrap100
happyOut100 :: HappyAbsSyn -> HappyWrap100
happyOut100 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap100
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut100 #-}
newtype HappyWrap101 = HappyWrap101 (Located (Maybe (LHsContext GhcPs), LHsType GhcPs))
happyIn101 :: (Located (Maybe (LHsContext GhcPs), LHsType GhcPs)) -> (HappyAbsSyn )
happyIn101 :: Located (Maybe (LHsContext GhcPs), LHsKind GhcPs) -> HappyAbsSyn
happyIn101 x :: Located (Maybe (LHsContext GhcPs), LHsKind GhcPs)
x = HappyWrap101 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (Maybe (LHsContext GhcPs), LHsKind GhcPs) -> HappyWrap101
HappyWrap101 Located (Maybe (LHsContext GhcPs), LHsKind GhcPs)
x)
{-# INLINE happyIn101 #-}
happyOut101 :: (HappyAbsSyn ) -> HappyWrap101
happyOut101 :: HappyAbsSyn -> HappyWrap101
happyOut101 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap101
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut101 #-}
newtype HappyWrap102 = HappyWrap102 (Located ([AddAnn],(Maybe (LHsContext GhcPs), Maybe [LHsTyVarBndr GhcPs], LHsType GhcPs)))
happyIn102 :: (Located ([AddAnn],(Maybe (LHsContext GhcPs), Maybe [LHsTyVarBndr GhcPs], LHsType GhcPs))) -> (HappyAbsSyn )
happyIn102 :: Located
  ([AddAnn],
   (Maybe (LHsContext GhcPs), Maybe [LHsTyVarBndr GhcPs],
    LHsKind GhcPs))
-> HappyAbsSyn
happyIn102 x :: Located
  ([AddAnn],
   (Maybe (LHsContext GhcPs), Maybe [LHsTyVarBndr GhcPs],
    LHsKind GhcPs))
x = HappyWrap102 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located
  ([AddAnn],
   (Maybe (LHsContext GhcPs), Maybe [LHsTyVarBndr GhcPs],
    LHsKind GhcPs))
-> HappyWrap102
HappyWrap102 Located
  ([AddAnn],
   (Maybe (LHsContext GhcPs), Maybe [LHsTyVarBndr GhcPs],
    LHsKind GhcPs))
x)
{-# INLINE happyIn102 #-}
happyOut102 :: (HappyAbsSyn ) -> HappyWrap102
happyOut102 :: HappyAbsSyn -> HappyWrap102
happyOut102 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap102
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut102 #-}
newtype HappyWrap103 = HappyWrap103 (Maybe (Located CType))
happyIn103 :: (Maybe (Located CType)) -> (HappyAbsSyn )
happyIn103 :: Maybe (Located CType) -> HappyAbsSyn
happyIn103 x :: Maybe (Located CType)
x = HappyWrap103 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Maybe (Located CType) -> HappyWrap103
HappyWrap103 Maybe (Located CType)
x)
{-# INLINE happyIn103 #-}
happyOut103 :: (HappyAbsSyn ) -> HappyWrap103
happyOut103 :: HappyAbsSyn -> HappyWrap103
happyOut103 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap103
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut103 #-}
newtype HappyWrap104 = HappyWrap104 (LDerivDecl GhcPs)
happyIn104 :: (LDerivDecl GhcPs) -> (HappyAbsSyn )
happyIn104 :: LDerivDecl GhcPs -> HappyAbsSyn
happyIn104 x :: LDerivDecl GhcPs
x = HappyWrap104 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LDerivDecl GhcPs -> HappyWrap104
HappyWrap104 LDerivDecl GhcPs
x)
{-# INLINE happyIn104 #-}
happyOut104 :: (HappyAbsSyn ) -> HappyWrap104
happyOut104 :: HappyAbsSyn -> HappyWrap104
happyOut104 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap104
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut104 #-}
newtype HappyWrap105 = HappyWrap105 (LRoleAnnotDecl GhcPs)
happyIn105 :: (LRoleAnnotDecl GhcPs) -> (HappyAbsSyn )
happyIn105 :: LRoleAnnotDecl GhcPs -> HappyAbsSyn
happyIn105 x :: LRoleAnnotDecl GhcPs
x = HappyWrap105 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LRoleAnnotDecl GhcPs -> HappyWrap105
HappyWrap105 LRoleAnnotDecl GhcPs
x)
{-# INLINE happyIn105 #-}
happyOut105 :: (HappyAbsSyn ) -> HappyWrap105
happyOut105 :: HappyAbsSyn -> HappyWrap105
happyOut105 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap105
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut105 #-}
newtype HappyWrap106 = HappyWrap106 (Located [Located (Maybe FastString)])
happyIn106 :: (Located [Located (Maybe FastString)]) -> (HappyAbsSyn )
happyIn106 :: Located [Located (Maybe FastString)] -> HappyAbsSyn
happyIn106 x :: Located [Located (Maybe FastString)]
x = HappyWrap106 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [Located (Maybe FastString)] -> HappyWrap106
HappyWrap106 Located [Located (Maybe FastString)]
x)
{-# INLINE happyIn106 #-}
happyOut106 :: (HappyAbsSyn ) -> HappyWrap106
happyOut106 :: HappyAbsSyn -> HappyWrap106
happyOut106 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap106
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut106 #-}
newtype HappyWrap107 = HappyWrap107 (Located [Located (Maybe FastString)])
happyIn107 :: (Located [Located (Maybe FastString)]) -> (HappyAbsSyn )
happyIn107 :: Located [Located (Maybe FastString)] -> HappyAbsSyn
happyIn107 x :: Located [Located (Maybe FastString)]
x = HappyWrap107 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [Located (Maybe FastString)] -> HappyWrap107
HappyWrap107 Located [Located (Maybe FastString)]
x)
{-# INLINE happyIn107 #-}
happyOut107 :: (HappyAbsSyn ) -> HappyWrap107
happyOut107 :: HappyAbsSyn -> HappyWrap107
happyOut107 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap107
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut107 #-}
newtype HappyWrap108 = HappyWrap108 (Located (Maybe FastString))
happyIn108 :: (Located (Maybe FastString)) -> (HappyAbsSyn )
happyIn108 :: Located (Maybe FastString) -> HappyAbsSyn
happyIn108 x :: Located (Maybe FastString)
x = HappyWrap108 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (Maybe FastString) -> HappyWrap108
HappyWrap108 Located (Maybe FastString)
x)
{-# INLINE happyIn108 #-}
happyOut108 :: (HappyAbsSyn ) -> HappyWrap108
happyOut108 :: HappyAbsSyn -> HappyWrap108
happyOut108 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap108
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut108 #-}
newtype HappyWrap109 = HappyWrap109 (LHsDecl GhcPs)
happyIn109 :: (LHsDecl GhcPs) -> (HappyAbsSyn )
happyIn109 :: LHsDecl GhcPs -> HappyAbsSyn
happyIn109 x :: LHsDecl GhcPs
x = HappyWrap109 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsDecl GhcPs -> HappyWrap109
HappyWrap109 LHsDecl GhcPs
x)
{-# INLINE happyIn109 #-}
happyOut109 :: (HappyAbsSyn ) -> HappyWrap109
happyOut109 :: HappyAbsSyn -> HappyWrap109
happyOut109 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap109
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut109 #-}
newtype HappyWrap110 = HappyWrap110 ((Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn]))
happyIn110 :: ((Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn])) -> (HappyAbsSyn )
happyIn110 :: (Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn])
-> HappyAbsSyn
happyIn110 x :: (Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn])
x = HappyWrap110 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ((Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn])
-> HappyWrap110
HappyWrap110 (Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn])
x)
{-# INLINE happyIn110 #-}
happyOut110 :: (HappyAbsSyn ) -> HappyWrap110
happyOut110 :: HappyAbsSyn -> HappyWrap110
happyOut110 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap110
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut110 #-}
newtype HappyWrap111 = HappyWrap111 ([Located RdrName])
happyIn111 :: ([Located RdrName]) -> (HappyAbsSyn )
happyIn111 :: [Located RdrName] -> HappyAbsSyn
happyIn111 x :: [Located RdrName]
x = HappyWrap111 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([Located RdrName] -> HappyWrap111
HappyWrap111 [Located RdrName]
x)
{-# INLINE happyIn111 #-}
happyOut111 :: (HappyAbsSyn ) -> HappyWrap111
happyOut111 :: HappyAbsSyn -> HappyWrap111
happyOut111 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap111
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut111 #-}
newtype HappyWrap112 = HappyWrap112 ([RecordPatSynField (Located RdrName)])
happyIn112 :: ([RecordPatSynField (Located RdrName)]) -> (HappyAbsSyn )
happyIn112 :: [RecordPatSynField (Located RdrName)] -> HappyAbsSyn
happyIn112 x :: [RecordPatSynField (Located RdrName)]
x = HappyWrap112 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([RecordPatSynField (Located RdrName)] -> HappyWrap112
HappyWrap112 [RecordPatSynField (Located RdrName)]
x)
{-# INLINE happyIn112 #-}
happyOut112 :: (HappyAbsSyn ) -> HappyWrap112
happyOut112 :: HappyAbsSyn -> HappyWrap112
happyOut112 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap112
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut112 #-}
newtype HappyWrap113 = HappyWrap113 (Located ([AddAnn]
                         , Located (OrdList (LHsDecl GhcPs))))
happyIn113 :: (Located ([AddAnn]
                         , Located (OrdList (LHsDecl GhcPs)))) -> (HappyAbsSyn )
happyIn113 :: Located ([AddAnn], Located (OrdList (LHsDecl GhcPs)))
-> HappyAbsSyn
happyIn113 x :: Located ([AddAnn], Located (OrdList (LHsDecl GhcPs)))
x = HappyWrap113 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], Located (OrdList (LHsDecl GhcPs)))
-> HappyWrap113
HappyWrap113 Located ([AddAnn], Located (OrdList (LHsDecl GhcPs)))
x)
{-# INLINE happyIn113 #-}
happyOut113 :: (HappyAbsSyn ) -> HappyWrap113
happyOut113 :: HappyAbsSyn -> HappyWrap113
happyOut113 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap113
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut113 #-}
newtype HappyWrap114 = HappyWrap114 (LSig GhcPs)
happyIn114 :: (LSig GhcPs) -> (HappyAbsSyn )
happyIn114 :: LSig GhcPs -> HappyAbsSyn
happyIn114 x :: LSig GhcPs
x = HappyWrap114 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LSig GhcPs -> HappyWrap114
HappyWrap114 LSig GhcPs
x)
{-# INLINE happyIn114 #-}
happyOut114 :: (HappyAbsSyn ) -> HappyWrap114
happyOut114 :: HappyAbsSyn -> HappyWrap114
happyOut114 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap114
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut114 #-}
newtype HappyWrap115 = HappyWrap115 (LHsDecl GhcPs)
happyIn115 :: (LHsDecl GhcPs) -> (HappyAbsSyn )
happyIn115 :: LHsDecl GhcPs -> HappyAbsSyn
happyIn115 x :: LHsDecl GhcPs
x = HappyWrap115 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsDecl GhcPs -> HappyWrap115
HappyWrap115 LHsDecl GhcPs
x)
{-# INLINE happyIn115 #-}
happyOut115 :: (HappyAbsSyn ) -> HappyWrap115
happyOut115 :: HappyAbsSyn -> HappyWrap115
happyOut115 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap115
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut115 #-}
newtype HappyWrap116 = HappyWrap116 (Located ([AddAnn],OrdList (LHsDecl GhcPs)))
happyIn116 :: (Located ([AddAnn],OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )
happyIn116 :: Located ([AddAnn], OrdList (LHsDecl GhcPs)) -> HappyAbsSyn
happyIn116 x :: Located ([AddAnn], OrdList (LHsDecl GhcPs))
x = HappyWrap116 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], OrdList (LHsDecl GhcPs)) -> HappyWrap116
HappyWrap116 Located ([AddAnn], OrdList (LHsDecl GhcPs))
x)
{-# INLINE happyIn116 #-}
happyOut116 :: (HappyAbsSyn ) -> HappyWrap116
happyOut116 :: HappyAbsSyn -> HappyWrap116
happyOut116 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap116
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut116 #-}
newtype HappyWrap117 = HappyWrap117 (Located ([AddAnn]
                     , OrdList (LHsDecl GhcPs)))
happyIn117 :: (Located ([AddAnn]
                     , OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )
happyIn117 :: Located ([AddAnn], OrdList (LHsDecl GhcPs)) -> HappyAbsSyn
happyIn117 x :: Located ([AddAnn], OrdList (LHsDecl GhcPs))
x = HappyWrap117 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], OrdList (LHsDecl GhcPs)) -> HappyWrap117
HappyWrap117 Located ([AddAnn], OrdList (LHsDecl GhcPs))
x)
{-# INLINE happyIn117 #-}
happyOut117 :: (HappyAbsSyn ) -> HappyWrap117
happyOut117 :: HappyAbsSyn -> HappyWrap117
happyOut117 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap117
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut117 #-}
newtype HappyWrap118 = HappyWrap118 (Located ([AddAnn]
                       ,(OrdList (LHsDecl GhcPs))))
happyIn118 :: (Located ([AddAnn]
                       ,(OrdList (LHsDecl GhcPs)))) -> (HappyAbsSyn )
happyIn118 :: Located ([AddAnn], OrdList (LHsDecl GhcPs)) -> HappyAbsSyn
happyIn118 x :: Located ([AddAnn], OrdList (LHsDecl GhcPs))
x = HappyWrap118 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], OrdList (LHsDecl GhcPs)) -> HappyWrap118
HappyWrap118 Located ([AddAnn], OrdList (LHsDecl GhcPs))
x)
{-# INLINE happyIn118 #-}
happyOut118 :: (HappyAbsSyn ) -> HappyWrap118
happyOut118 :: HappyAbsSyn -> HappyWrap118
happyOut118 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap118
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut118 #-}
newtype HappyWrap119 = HappyWrap119 (Located (OrdList (LHsDecl GhcPs)))
happyIn119 :: (Located (OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )
happyIn119 :: Located (OrdList (LHsDecl GhcPs)) -> HappyAbsSyn
happyIn119 x :: Located (OrdList (LHsDecl GhcPs))
x = HappyWrap119 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (OrdList (LHsDecl GhcPs)) -> HappyWrap119
HappyWrap119 Located (OrdList (LHsDecl GhcPs))
x)
{-# INLINE happyIn119 #-}
happyOut119 :: (HappyAbsSyn ) -> HappyWrap119
happyOut119 :: HappyAbsSyn -> HappyWrap119
happyOut119 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap119
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut119 #-}
newtype HappyWrap120 = HappyWrap120 (Located ([AddAnn],OrdList (LHsDecl GhcPs)))
happyIn120 :: (Located ([AddAnn],OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )
happyIn120 :: Located ([AddAnn], OrdList (LHsDecl GhcPs)) -> HappyAbsSyn
happyIn120 x :: Located ([AddAnn], OrdList (LHsDecl GhcPs))
x = HappyWrap120 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], OrdList (LHsDecl GhcPs)) -> HappyWrap120
HappyWrap120 Located ([AddAnn], OrdList (LHsDecl GhcPs))
x)
{-# INLINE happyIn120 #-}
happyOut120 :: (HappyAbsSyn ) -> HappyWrap120
happyOut120 :: HappyAbsSyn -> HappyWrap120
happyOut120 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap120
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut120 #-}
newtype HappyWrap121 = HappyWrap121 (Located ([AddAnn]
                     , OrdList (LHsDecl GhcPs)))
happyIn121 :: (Located ([AddAnn]
                     , OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )
happyIn121 :: Located ([AddAnn], OrdList (LHsDecl GhcPs)) -> HappyAbsSyn
happyIn121 x :: Located ([AddAnn], OrdList (LHsDecl GhcPs))
x = HappyWrap121 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], OrdList (LHsDecl GhcPs)) -> HappyWrap121
HappyWrap121 Located ([AddAnn], OrdList (LHsDecl GhcPs))
x)
{-# INLINE happyIn121 #-}
happyOut121 :: (HappyAbsSyn ) -> HappyWrap121
happyOut121 :: HappyAbsSyn -> HappyWrap121
happyOut121 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap121
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut121 #-}
newtype HappyWrap122 = HappyWrap122 (Located ([AddAnn]
                        , OrdList (LHsDecl GhcPs)))
happyIn122 :: (Located ([AddAnn]
                        , OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )
happyIn122 :: Located ([AddAnn], OrdList (LHsDecl GhcPs)) -> HappyAbsSyn
happyIn122 x :: Located ([AddAnn], OrdList (LHsDecl GhcPs))
x = HappyWrap122 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], OrdList (LHsDecl GhcPs)) -> HappyWrap122
HappyWrap122 Located ([AddAnn], OrdList (LHsDecl GhcPs))
x)
{-# INLINE happyIn122 #-}
happyOut122 :: (HappyAbsSyn ) -> HappyWrap122
happyOut122 :: HappyAbsSyn -> HappyWrap122
happyOut122 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap122
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut122 #-}
newtype HappyWrap123 = HappyWrap123 (Located ([AddAnn],OrdList (LHsDecl GhcPs)))
happyIn123 :: (Located ([AddAnn],OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )
happyIn123 :: Located ([AddAnn], OrdList (LHsDecl GhcPs)) -> HappyAbsSyn
happyIn123 x :: Located ([AddAnn], OrdList (LHsDecl GhcPs))
x = HappyWrap123 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], OrdList (LHsDecl GhcPs)) -> HappyWrap123
HappyWrap123 Located ([AddAnn], OrdList (LHsDecl GhcPs))
x)
{-# INLINE happyIn123 #-}
happyOut123 :: (HappyAbsSyn ) -> HappyWrap123
happyOut123 :: HappyAbsSyn -> HappyWrap123
happyOut123 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap123
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut123 #-}
newtype HappyWrap124 = HappyWrap124 (Located ([AddAnn],Located (OrdList (LHsDecl GhcPs))))
happyIn124 :: (Located ([AddAnn],Located (OrdList (LHsDecl GhcPs)))) -> (HappyAbsSyn )
happyIn124 :: Located ([AddAnn], Located (OrdList (LHsDecl GhcPs)))
-> HappyAbsSyn
happyIn124 x :: Located ([AddAnn], Located (OrdList (LHsDecl GhcPs)))
x = HappyWrap124 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], Located (OrdList (LHsDecl GhcPs)))
-> HappyWrap124
HappyWrap124 Located ([AddAnn], Located (OrdList (LHsDecl GhcPs)))
x)
{-# INLINE happyIn124 #-}
happyOut124 :: (HappyAbsSyn ) -> HappyWrap124
happyOut124 :: HappyAbsSyn -> HappyWrap124
happyOut124 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap124
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut124 #-}
newtype HappyWrap125 = HappyWrap125 (Located ([AddAnn],Located (HsLocalBinds GhcPs)))
happyIn125 :: (Located ([AddAnn],Located (HsLocalBinds GhcPs))) -> (HappyAbsSyn )
happyIn125 :: Located ([AddAnn], Located (HsLocalBinds GhcPs)) -> HappyAbsSyn
happyIn125 x :: Located ([AddAnn], Located (HsLocalBinds GhcPs))
x = HappyWrap125 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], Located (HsLocalBinds GhcPs)) -> HappyWrap125
HappyWrap125 Located ([AddAnn], Located (HsLocalBinds GhcPs))
x)
{-# INLINE happyIn125 #-}
happyOut125 :: (HappyAbsSyn ) -> HappyWrap125
happyOut125 :: HappyAbsSyn -> HappyWrap125
happyOut125 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap125
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut125 #-}
newtype HappyWrap126 = HappyWrap126 (Located ([AddAnn],Located (HsLocalBinds GhcPs)))
happyIn126 :: (Located ([AddAnn],Located (HsLocalBinds GhcPs))) -> (HappyAbsSyn )
happyIn126 :: Located ([AddAnn], Located (HsLocalBinds GhcPs)) -> HappyAbsSyn
happyIn126 x :: Located ([AddAnn], Located (HsLocalBinds GhcPs))
x = HappyWrap126 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], Located (HsLocalBinds GhcPs)) -> HappyWrap126
HappyWrap126 Located ([AddAnn], Located (HsLocalBinds GhcPs))
x)
{-# INLINE happyIn126 #-}
happyOut126 :: (HappyAbsSyn ) -> HappyWrap126
happyOut126 :: HappyAbsSyn -> HappyWrap126
happyOut126 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap126
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut126 #-}
newtype HappyWrap127 = HappyWrap127 (OrdList (LRuleDecl GhcPs))
happyIn127 :: (OrdList (LRuleDecl GhcPs)) -> (HappyAbsSyn )
happyIn127 :: OrdList (LRuleDecl GhcPs) -> HappyAbsSyn
happyIn127 x :: OrdList (LRuleDecl GhcPs)
x = HappyWrap127 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList (LRuleDecl GhcPs) -> HappyWrap127
HappyWrap127 OrdList (LRuleDecl GhcPs)
x)
{-# INLINE happyIn127 #-}
happyOut127 :: (HappyAbsSyn ) -> HappyWrap127
happyOut127 :: HappyAbsSyn -> HappyWrap127
happyOut127 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap127
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut127 #-}
newtype HappyWrap128 = HappyWrap128 (LRuleDecl GhcPs)
happyIn128 :: (LRuleDecl GhcPs) -> (HappyAbsSyn )
happyIn128 :: LRuleDecl GhcPs -> HappyAbsSyn
happyIn128 x :: LRuleDecl GhcPs
x = HappyWrap128 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LRuleDecl GhcPs -> HappyWrap128
HappyWrap128 LRuleDecl GhcPs
x)
{-# INLINE happyIn128 #-}
happyOut128 :: (HappyAbsSyn ) -> HappyWrap128
happyOut128 :: HappyAbsSyn -> HappyWrap128
happyOut128 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap128
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut128 #-}
newtype HappyWrap129 = HappyWrap129 (([AddAnn],Maybe Activation))
happyIn129 :: (([AddAnn],Maybe Activation)) -> (HappyAbsSyn )
happyIn129 :: ([AddAnn], Maybe Activation) -> HappyAbsSyn
happyIn129 x :: ([AddAnn], Maybe Activation)
x = HappyWrap129 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], Maybe Activation) -> HappyWrap129
HappyWrap129 ([AddAnn], Maybe Activation)
x)
{-# INLINE happyIn129 #-}
happyOut129 :: (HappyAbsSyn ) -> HappyWrap129
happyOut129 :: HappyAbsSyn -> HappyWrap129
happyOut129 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap129
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut129 #-}
newtype HappyWrap130 = HappyWrap130 (([AddAnn]
                              ,Activation))
happyIn130 :: (([AddAnn]
                              ,Activation)) -> (HappyAbsSyn )
happyIn130 :: ([AddAnn], Activation) -> HappyAbsSyn
happyIn130 x :: ([AddAnn], Activation)
x = HappyWrap130 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], Activation) -> HappyWrap130
HappyWrap130 ([AddAnn], Activation)
x)
{-# INLINE happyIn130 #-}
happyOut130 :: (HappyAbsSyn ) -> HappyWrap130
happyOut130 :: HappyAbsSyn -> HappyWrap130
happyOut130 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap130
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut130 #-}
newtype HappyWrap131 = HappyWrap131 (([AddAnn], Maybe [LHsTyVarBndr GhcPs], [LRuleBndr GhcPs]))
happyIn131 :: (([AddAnn], Maybe [LHsTyVarBndr GhcPs], [LRuleBndr GhcPs])) -> (HappyAbsSyn )
happyIn131 :: ([AddAnn], Maybe [LHsTyVarBndr GhcPs], [LRuleBndr GhcPs])
-> HappyAbsSyn
happyIn131 x :: ([AddAnn], Maybe [LHsTyVarBndr GhcPs], [LRuleBndr GhcPs])
x = HappyWrap131 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], Maybe [LHsTyVarBndr GhcPs], [LRuleBndr GhcPs])
-> HappyWrap131
HappyWrap131 ([AddAnn], Maybe [LHsTyVarBndr GhcPs], [LRuleBndr GhcPs])
x)
{-# INLINE happyIn131 #-}
happyOut131 :: (HappyAbsSyn ) -> HappyWrap131
happyOut131 :: HappyAbsSyn -> HappyWrap131
happyOut131 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap131
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut131 #-}
newtype HappyWrap132 = HappyWrap132 ([LRuleTyTmVar])
happyIn132 :: ([LRuleTyTmVar]) -> (HappyAbsSyn )
happyIn132 :: [LRuleTyTmVar] -> HappyAbsSyn
happyIn132 x :: [LRuleTyTmVar]
x = HappyWrap132 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LRuleTyTmVar] -> HappyWrap132
HappyWrap132 [LRuleTyTmVar]
x)
{-# INLINE happyIn132 #-}
happyOut132 :: (HappyAbsSyn ) -> HappyWrap132
happyOut132 :: HappyAbsSyn -> HappyWrap132
happyOut132 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap132
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut132 #-}
newtype HappyWrap133 = HappyWrap133 (LRuleTyTmVar)
happyIn133 :: (LRuleTyTmVar) -> (HappyAbsSyn )
happyIn133 :: LRuleTyTmVar -> HappyAbsSyn
happyIn133 x :: LRuleTyTmVar
x = HappyWrap133 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LRuleTyTmVar -> HappyWrap133
HappyWrap133 LRuleTyTmVar
x)
{-# INLINE happyIn133 #-}
happyOut133 :: (HappyAbsSyn ) -> HappyWrap133
happyOut133 :: HappyAbsSyn -> HappyWrap133
happyOut133 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap133
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut133 #-}
newtype HappyWrap134 = HappyWrap134 (OrdList (LWarnDecl GhcPs))
happyIn134 :: (OrdList (LWarnDecl GhcPs)) -> (HappyAbsSyn )
happyIn134 :: OrdList (LWarnDecl GhcPs) -> HappyAbsSyn
happyIn134 x :: OrdList (LWarnDecl GhcPs)
x = HappyWrap134 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList (LWarnDecl GhcPs) -> HappyWrap134
HappyWrap134 OrdList (LWarnDecl GhcPs)
x)
{-# INLINE happyIn134 #-}
happyOut134 :: (HappyAbsSyn ) -> HappyWrap134
happyOut134 :: HappyAbsSyn -> HappyWrap134
happyOut134 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap134
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut134 #-}
newtype HappyWrap135 = HappyWrap135 (OrdList (LWarnDecl GhcPs))
happyIn135 :: (OrdList (LWarnDecl GhcPs)) -> (HappyAbsSyn )
happyIn135 :: OrdList (LWarnDecl GhcPs) -> HappyAbsSyn
happyIn135 x :: OrdList (LWarnDecl GhcPs)
x = HappyWrap135 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList (LWarnDecl GhcPs) -> HappyWrap135
HappyWrap135 OrdList (LWarnDecl GhcPs)
x)
{-# INLINE happyIn135 #-}
happyOut135 :: (HappyAbsSyn ) -> HappyWrap135
happyOut135 :: HappyAbsSyn -> HappyWrap135
happyOut135 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap135
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut135 #-}
newtype HappyWrap136 = HappyWrap136 (OrdList (LWarnDecl GhcPs))
happyIn136 :: (OrdList (LWarnDecl GhcPs)) -> (HappyAbsSyn )
happyIn136 :: OrdList (LWarnDecl GhcPs) -> HappyAbsSyn
happyIn136 x :: OrdList (LWarnDecl GhcPs)
x = HappyWrap136 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList (LWarnDecl GhcPs) -> HappyWrap136
HappyWrap136 OrdList (LWarnDecl GhcPs)
x)
{-# INLINE happyIn136 #-}
happyOut136 :: (HappyAbsSyn ) -> HappyWrap136
happyOut136 :: HappyAbsSyn -> HappyWrap136
happyOut136 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap136
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut136 #-}
newtype HappyWrap137 = HappyWrap137 (OrdList (LWarnDecl GhcPs))
happyIn137 :: (OrdList (LWarnDecl GhcPs)) -> (HappyAbsSyn )
happyIn137 :: OrdList (LWarnDecl GhcPs) -> HappyAbsSyn
happyIn137 x :: OrdList (LWarnDecl GhcPs)
x = HappyWrap137 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList (LWarnDecl GhcPs) -> HappyWrap137
HappyWrap137 OrdList (LWarnDecl GhcPs)
x)
{-# INLINE happyIn137 #-}
happyOut137 :: (HappyAbsSyn ) -> HappyWrap137
happyOut137 :: HappyAbsSyn -> HappyWrap137
happyOut137 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap137
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut137 #-}
newtype HappyWrap138 = HappyWrap138 (Located ([AddAnn],[Located StringLiteral]))
happyIn138 :: (Located ([AddAnn],[Located StringLiteral])) -> (HappyAbsSyn )
happyIn138 :: Located ([AddAnn], [Located StringLiteral]) -> HappyAbsSyn
happyIn138 x :: Located ([AddAnn], [Located StringLiteral])
x = HappyWrap138 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], [Located StringLiteral]) -> HappyWrap138
HappyWrap138 Located ([AddAnn], [Located StringLiteral])
x)
{-# INLINE happyIn138 #-}
happyOut138 :: (HappyAbsSyn ) -> HappyWrap138
happyOut138 :: HappyAbsSyn -> HappyWrap138
happyOut138 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap138
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut138 #-}
newtype HappyWrap139 = HappyWrap139 (Located (OrdList (Located StringLiteral)))
happyIn139 :: (Located (OrdList (Located StringLiteral))) -> (HappyAbsSyn )
happyIn139 :: Located (OrdList (Located StringLiteral)) -> HappyAbsSyn
happyIn139 x :: Located (OrdList (Located StringLiteral))
x = HappyWrap139 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (OrdList (Located StringLiteral)) -> HappyWrap139
HappyWrap139 Located (OrdList (Located StringLiteral))
x)
{-# INLINE happyIn139 #-}
happyOut139 :: (HappyAbsSyn ) -> HappyWrap139
happyOut139 :: HappyAbsSyn -> HappyWrap139
happyOut139 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap139
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut139 #-}
newtype HappyWrap140 = HappyWrap140 (LHsDecl GhcPs)
happyIn140 :: (LHsDecl GhcPs) -> (HappyAbsSyn )
happyIn140 :: LHsDecl GhcPs -> HappyAbsSyn
happyIn140 x :: LHsDecl GhcPs
x = HappyWrap140 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsDecl GhcPs -> HappyWrap140
HappyWrap140 LHsDecl GhcPs
x)
{-# INLINE happyIn140 #-}
happyOut140 :: (HappyAbsSyn ) -> HappyWrap140
happyOut140 :: HappyAbsSyn -> HappyWrap140
happyOut140 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap140
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut140 #-}
newtype HappyWrap141 = HappyWrap141 (Located ([AddAnn],HsDecl GhcPs))
happyIn141 :: (Located ([AddAnn],HsDecl GhcPs)) -> (HappyAbsSyn )
happyIn141 :: Located ([AddAnn], HsDecl GhcPs) -> HappyAbsSyn
happyIn141 x :: Located ([AddAnn], HsDecl GhcPs)
x = HappyWrap141 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], HsDecl GhcPs) -> HappyWrap141
HappyWrap141 Located ([AddAnn], HsDecl GhcPs)
x)
{-# INLINE happyIn141 #-}
happyOut141 :: (HappyAbsSyn ) -> HappyWrap141
happyOut141 :: HappyAbsSyn -> HappyWrap141
happyOut141 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap141
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut141 #-}
newtype HappyWrap142 = HappyWrap142 (Located CCallConv)
happyIn142 :: (Located CCallConv) -> (HappyAbsSyn )
happyIn142 :: Located CCallConv -> HappyAbsSyn
happyIn142 x :: Located CCallConv
x = HappyWrap142 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located CCallConv -> HappyWrap142
HappyWrap142 Located CCallConv
x)
{-# INLINE happyIn142 #-}
happyOut142 :: (HappyAbsSyn ) -> HappyWrap142
happyOut142 :: HappyAbsSyn -> HappyWrap142
happyOut142 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap142
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut142 #-}
newtype HappyWrap143 = HappyWrap143 (Located Safety)
happyIn143 :: (Located Safety) -> (HappyAbsSyn )
happyIn143 :: Located Safety -> HappyAbsSyn
happyIn143 x :: Located Safety
x = HappyWrap143 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located Safety -> HappyWrap143
HappyWrap143 Located Safety
x)
{-# INLINE happyIn143 #-}
happyOut143 :: (HappyAbsSyn ) -> HappyWrap143
happyOut143 :: HappyAbsSyn -> HappyWrap143
happyOut143 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap143
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut143 #-}
newtype HappyWrap144 = HappyWrap144 (Located ([AddAnn]
                    ,(Located StringLiteral, Located RdrName, LHsSigType GhcPs)))
happyIn144 :: (Located ([AddAnn]
                    ,(Located StringLiteral, Located RdrName, LHsSigType GhcPs))) -> (HappyAbsSyn )
happyIn144 :: Located
  ([AddAnn],
   (Located StringLiteral, Located RdrName, LHsSigType GhcPs))
-> HappyAbsSyn
happyIn144 x :: Located
  ([AddAnn],
   (Located StringLiteral, Located RdrName, LHsSigType GhcPs))
x = HappyWrap144 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located
  ([AddAnn],
   (Located StringLiteral, Located RdrName, LHsSigType GhcPs))
-> HappyWrap144
HappyWrap144 Located
  ([AddAnn],
   (Located StringLiteral, Located RdrName, LHsSigType GhcPs))
x)
{-# INLINE happyIn144 #-}
happyOut144 :: (HappyAbsSyn ) -> HappyWrap144
happyOut144 :: HappyAbsSyn -> HappyWrap144
happyOut144 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap144
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut144 #-}
newtype HappyWrap145 = HappyWrap145 (([AddAnn], Maybe (LHsType GhcPs)))
happyIn145 :: (([AddAnn], Maybe (LHsType GhcPs))) -> (HappyAbsSyn )
happyIn145 :: ([AddAnn], Maybe (LHsKind GhcPs)) -> HappyAbsSyn
happyIn145 x :: ([AddAnn], Maybe (LHsKind GhcPs))
x = HappyWrap145 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], Maybe (LHsKind GhcPs)) -> HappyWrap145
HappyWrap145 ([AddAnn], Maybe (LHsKind GhcPs))
x)
{-# INLINE happyIn145 #-}
happyOut145 :: (HappyAbsSyn ) -> HappyWrap145
happyOut145 :: HappyAbsSyn -> HappyWrap145
happyOut145 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap145
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut145 #-}
newtype HappyWrap146 = HappyWrap146 (([AddAnn], Maybe (Located RdrName)))
happyIn146 :: (([AddAnn], Maybe (Located RdrName))) -> (HappyAbsSyn )
happyIn146 :: ([AddAnn], Maybe (Located RdrName)) -> HappyAbsSyn
happyIn146 x :: ([AddAnn], Maybe (Located RdrName))
x = HappyWrap146 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], Maybe (Located RdrName)) -> HappyWrap146
HappyWrap146 ([AddAnn], Maybe (Located RdrName))
x)
{-# INLINE happyIn146 #-}
happyOut146 :: (HappyAbsSyn ) -> HappyWrap146
happyOut146 :: HappyAbsSyn -> HappyWrap146
happyOut146 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap146
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut146 #-}
newtype HappyWrap147 = HappyWrap147 (LHsType GhcPs)
happyIn147 :: (LHsType GhcPs) -> (HappyAbsSyn )
happyIn147 :: LHsKind GhcPs -> HappyAbsSyn
happyIn147 x :: LHsKind GhcPs
x = HappyWrap147 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsKind GhcPs -> HappyWrap147
HappyWrap147 LHsKind GhcPs
x)
{-# INLINE happyIn147 #-}
happyOut147 :: (HappyAbsSyn ) -> HappyWrap147
happyOut147 :: HappyAbsSyn -> HappyWrap147
happyOut147 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap147
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut147 #-}
newtype HappyWrap148 = HappyWrap148 (LHsType GhcPs)
happyIn148 :: (LHsType GhcPs) -> (HappyAbsSyn )
happyIn148 :: LHsKind GhcPs -> HappyAbsSyn
happyIn148 x :: LHsKind GhcPs
x = HappyWrap148 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsKind GhcPs -> HappyWrap148
HappyWrap148 LHsKind GhcPs
x)
{-# INLINE happyIn148 #-}
happyOut148 :: (HappyAbsSyn ) -> HappyWrap148
happyOut148 :: HappyAbsSyn -> HappyWrap148
happyOut148 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap148
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut148 #-}
newtype HappyWrap149 = HappyWrap149 (Located [Located RdrName])
happyIn149 :: (Located [Located RdrName]) -> (HappyAbsSyn )
happyIn149 :: Located [Located RdrName] -> HappyAbsSyn
happyIn149 x :: Located [Located RdrName]
x = HappyWrap149 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [Located RdrName] -> HappyWrap149
HappyWrap149 Located [Located RdrName]
x)
{-# INLINE happyIn149 #-}
happyOut149 :: (HappyAbsSyn ) -> HappyWrap149
happyOut149 :: HappyAbsSyn -> HappyWrap149
happyOut149 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap149
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut149 #-}
newtype HappyWrap150 = HappyWrap150 ((OrdList (LHsSigType GhcPs)))
happyIn150 :: ((OrdList (LHsSigType GhcPs))) -> (HappyAbsSyn )
happyIn150 :: OrdList (LHsSigType GhcPs) -> HappyAbsSyn
happyIn150 x :: OrdList (LHsSigType GhcPs)
x = HappyWrap150 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList (LHsSigType GhcPs) -> HappyWrap150
HappyWrap150 OrdList (LHsSigType GhcPs)
x)
{-# INLINE happyIn150 #-}
happyOut150 :: (HappyAbsSyn ) -> HappyWrap150
happyOut150 :: HappyAbsSyn -> HappyWrap150
happyOut150 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap150
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut150 #-}
newtype HappyWrap151 = HappyWrap151 (Located ([AddAnn], SourceText, SrcUnpackedness))
happyIn151 :: (Located ([AddAnn], SourceText, SrcUnpackedness)) -> (HappyAbsSyn )
happyIn151 :: Located ([AddAnn], SourceText, SrcUnpackedness) -> HappyAbsSyn
happyIn151 x :: Located ([AddAnn], SourceText, SrcUnpackedness)
x = HappyWrap151 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], SourceText, SrcUnpackedness) -> HappyWrap151
HappyWrap151 Located ([AddAnn], SourceText, SrcUnpackedness)
x)
{-# INLINE happyIn151 #-}
happyOut151 :: (HappyAbsSyn ) -> HappyWrap151
happyOut151 :: HappyAbsSyn -> HappyWrap151
happyOut151 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap151
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut151 #-}
newtype HappyWrap152 = HappyWrap152 (LHsType GhcPs)
happyIn152 :: (LHsType GhcPs) -> (HappyAbsSyn )
happyIn152 :: LHsKind GhcPs -> HappyAbsSyn
happyIn152 x :: LHsKind GhcPs
x = HappyWrap152 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsKind GhcPs -> HappyWrap152
HappyWrap152 LHsKind GhcPs
x)
{-# INLINE happyIn152 #-}
happyOut152 :: (HappyAbsSyn ) -> HappyWrap152
happyOut152 :: HappyAbsSyn -> HappyWrap152
happyOut152 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap152
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut152 #-}
newtype HappyWrap153 = HappyWrap153 (LHsType GhcPs)
happyIn153 :: (LHsType GhcPs) -> (HappyAbsSyn )
happyIn153 :: LHsKind GhcPs -> HappyAbsSyn
happyIn153 x :: LHsKind GhcPs
x = HappyWrap153 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsKind GhcPs -> HappyWrap153
HappyWrap153 LHsKind GhcPs
x)
{-# INLINE happyIn153 #-}
happyOut153 :: (HappyAbsSyn ) -> HappyWrap153
happyOut153 :: HappyAbsSyn -> HappyWrap153
happyOut153 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap153
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut153 #-}
newtype HappyWrap154 = HappyWrap154 (LHsType GhcPs)
happyIn154 :: (LHsType GhcPs) -> (HappyAbsSyn )
happyIn154 :: LHsKind GhcPs -> HappyAbsSyn
happyIn154 x :: LHsKind GhcPs
x = HappyWrap154 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsKind GhcPs -> HappyWrap154
HappyWrap154 LHsKind GhcPs
x)
{-# INLINE happyIn154 #-}
happyOut154 :: (HappyAbsSyn ) -> HappyWrap154
happyOut154 :: HappyAbsSyn -> HappyWrap154
happyOut154 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap154
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut154 #-}
newtype HappyWrap155 = HappyWrap155 (LHsType GhcPs)
happyIn155 :: (LHsType GhcPs) -> (HappyAbsSyn )
happyIn155 :: LHsKind GhcPs -> HappyAbsSyn
happyIn155 x :: LHsKind GhcPs
x = HappyWrap155 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsKind GhcPs -> HappyWrap155
HappyWrap155 LHsKind GhcPs
x)
{-# INLINE happyIn155 #-}
happyOut155 :: (HappyAbsSyn ) -> HappyWrap155
happyOut155 :: HappyAbsSyn -> HappyWrap155
happyOut155 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap155
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut155 #-}
newtype HappyWrap156 = HappyWrap156 (LHsContext GhcPs)
happyIn156 :: (LHsContext GhcPs) -> (HappyAbsSyn )
happyIn156 :: LHsContext GhcPs -> HappyAbsSyn
happyIn156 x :: LHsContext GhcPs
x = HappyWrap156 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsContext GhcPs -> HappyWrap156
HappyWrap156 LHsContext GhcPs
x)
{-# INLINE happyIn156 #-}
happyOut156 :: (HappyAbsSyn ) -> HappyWrap156
happyOut156 :: HappyAbsSyn -> HappyWrap156
happyOut156 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap156
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut156 #-}
newtype HappyWrap157 = HappyWrap157 (LHsContext GhcPs)
happyIn157 :: (LHsContext GhcPs) -> (HappyAbsSyn )
happyIn157 :: LHsContext GhcPs -> HappyAbsSyn
happyIn157 x :: LHsContext GhcPs
x = HappyWrap157 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsContext GhcPs -> HappyWrap157
HappyWrap157 LHsContext GhcPs
x)
{-# INLINE happyIn157 #-}
happyOut157 :: (HappyAbsSyn ) -> HappyWrap157
happyOut157 :: HappyAbsSyn -> HappyWrap157
happyOut157 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap157
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut157 #-}
newtype HappyWrap158 = HappyWrap158 (LHsType GhcPs)
happyIn158 :: (LHsType GhcPs) -> (HappyAbsSyn )
happyIn158 :: LHsKind GhcPs -> HappyAbsSyn
happyIn158 x :: LHsKind GhcPs
x = HappyWrap158 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsKind GhcPs -> HappyWrap158
HappyWrap158 LHsKind GhcPs
x)
{-# INLINE happyIn158 #-}
happyOut158 :: (HappyAbsSyn ) -> HappyWrap158
happyOut158 :: HappyAbsSyn -> HappyWrap158
happyOut158 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap158
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut158 #-}
newtype HappyWrap159 = HappyWrap159 (LHsType GhcPs)
happyIn159 :: (LHsType GhcPs) -> (HappyAbsSyn )
happyIn159 :: LHsKind GhcPs -> HappyAbsSyn
happyIn159 x :: LHsKind GhcPs
x = HappyWrap159 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsKind GhcPs -> HappyWrap159
HappyWrap159 LHsKind GhcPs
x)
{-# INLINE happyIn159 #-}
happyOut159 :: (HappyAbsSyn ) -> HappyWrap159
happyOut159 :: HappyAbsSyn -> HappyWrap159
happyOut159 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap159
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut159 #-}
newtype HappyWrap160 = HappyWrap160 (LHsType GhcPs)
happyIn160 :: (LHsType GhcPs) -> (HappyAbsSyn )
happyIn160 :: LHsKind GhcPs -> HappyAbsSyn
happyIn160 x :: LHsKind GhcPs
x = HappyWrap160 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsKind GhcPs -> HappyWrap160
HappyWrap160 LHsKind GhcPs
x)
{-# INLINE happyIn160 #-}
happyOut160 :: (HappyAbsSyn ) -> HappyWrap160
happyOut160 :: HappyAbsSyn -> HappyWrap160
happyOut160 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap160
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut160 #-}
newtype HappyWrap161 = HappyWrap161 (Located [Located TyEl])
happyIn161 :: (Located [Located TyEl]) -> (HappyAbsSyn )
happyIn161 :: Located [Located TyEl] -> HappyAbsSyn
happyIn161 x :: Located [Located TyEl]
x = HappyWrap161 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [Located TyEl] -> HappyWrap161
HappyWrap161 Located [Located TyEl]
x)
{-# INLINE happyIn161 #-}
happyOut161 :: (HappyAbsSyn ) -> HappyWrap161
happyOut161 :: HappyAbsSyn -> HappyWrap161
happyOut161 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap161
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut161 #-}
newtype HappyWrap162 = HappyWrap162 (Located TyEl)
happyIn162 :: (Located TyEl) -> (HappyAbsSyn )
happyIn162 :: Located TyEl -> HappyAbsSyn
happyIn162 x :: Located TyEl
x = HappyWrap162 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located TyEl -> HappyWrap162
HappyWrap162 Located TyEl
x)
{-# INLINE happyIn162 #-}
happyOut162 :: (HappyAbsSyn ) -> HappyWrap162
happyOut162 :: HappyAbsSyn -> HappyWrap162
happyOut162 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap162
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut162 #-}
newtype HappyWrap163 = HappyWrap163 (LHsType GhcPs)
happyIn163 :: (LHsType GhcPs) -> (HappyAbsSyn )
happyIn163 :: LHsKind GhcPs -> HappyAbsSyn
happyIn163 x :: LHsKind GhcPs
x = HappyWrap163 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsKind GhcPs -> HappyWrap163
HappyWrap163 LHsKind GhcPs
x)
{-# INLINE happyIn163 #-}
happyOut163 :: (HappyAbsSyn ) -> HappyWrap163
happyOut163 :: HappyAbsSyn -> HappyWrap163
happyOut163 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap163
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut163 #-}
newtype HappyWrap164 = HappyWrap164 ([Located TyEl])
happyIn164 :: ([Located TyEl]) -> (HappyAbsSyn )
happyIn164 :: [Located TyEl] -> HappyAbsSyn
happyIn164 x :: [Located TyEl]
x = HappyWrap164 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([Located TyEl] -> HappyWrap164
HappyWrap164 [Located TyEl]
x)
{-# INLINE happyIn164 #-}
happyOut164 :: (HappyAbsSyn ) -> HappyWrap164
happyOut164 :: HappyAbsSyn -> HappyWrap164
happyOut164 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap164
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut164 #-}
newtype HappyWrap165 = HappyWrap165 (Located TyEl)
happyIn165 :: (Located TyEl) -> (HappyAbsSyn )
happyIn165 :: Located TyEl -> HappyAbsSyn
happyIn165 x :: Located TyEl
x = HappyWrap165 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located TyEl -> HappyWrap165
HappyWrap165 Located TyEl
x)
{-# INLINE happyIn165 #-}
happyOut165 :: (HappyAbsSyn ) -> HappyWrap165
happyOut165 :: HappyAbsSyn -> HappyWrap165
happyOut165 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap165
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut165 #-}
newtype HappyWrap166 = HappyWrap166 (LHsType GhcPs)
happyIn166 :: (LHsType GhcPs) -> (HappyAbsSyn )
happyIn166 :: LHsKind GhcPs -> HappyAbsSyn
happyIn166 x :: LHsKind GhcPs
x = HappyWrap166 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsKind GhcPs -> HappyWrap166
HappyWrap166 LHsKind GhcPs
x)
{-# INLINE happyIn166 #-}
happyOut166 :: (HappyAbsSyn ) -> HappyWrap166
happyOut166 :: HappyAbsSyn -> HappyWrap166
happyOut166 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap166
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut166 #-}
newtype HappyWrap167 = HappyWrap167 (LHsSigType GhcPs)
happyIn167 :: (LHsSigType GhcPs) -> (HappyAbsSyn )
happyIn167 :: LHsSigType GhcPs -> HappyAbsSyn
happyIn167 x :: LHsSigType GhcPs
x = HappyWrap167 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsSigType GhcPs -> HappyWrap167
HappyWrap167 LHsSigType GhcPs
x)
{-# INLINE happyIn167 #-}
happyOut167 :: (HappyAbsSyn ) -> HappyWrap167
happyOut167 :: HappyAbsSyn -> HappyWrap167
happyOut167 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap167
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut167 #-}
newtype HappyWrap168 = HappyWrap168 ([LHsSigType GhcPs])
happyIn168 :: ([LHsSigType GhcPs]) -> (HappyAbsSyn )
happyIn168 :: [LHsSigType GhcPs] -> HappyAbsSyn
happyIn168 x :: [LHsSigType GhcPs]
x = HappyWrap168 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LHsSigType GhcPs] -> HappyWrap168
HappyWrap168 [LHsSigType GhcPs]
x)
{-# INLINE happyIn168 #-}
happyOut168 :: (HappyAbsSyn ) -> HappyWrap168
happyOut168 :: HappyAbsSyn -> HappyWrap168
happyOut168 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap168
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut168 #-}
newtype HappyWrap169 = HappyWrap169 ([LHsType GhcPs])
happyIn169 :: ([LHsType GhcPs]) -> (HappyAbsSyn )
happyIn169 :: [LHsKind GhcPs] -> HappyAbsSyn
happyIn169 x :: [LHsKind GhcPs]
x = HappyWrap169 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LHsKind GhcPs] -> HappyWrap169
HappyWrap169 [LHsKind GhcPs]
x)
{-# INLINE happyIn169 #-}
happyOut169 :: (HappyAbsSyn ) -> HappyWrap169
happyOut169 :: HappyAbsSyn -> HappyWrap169
happyOut169 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap169
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut169 #-}
newtype HappyWrap170 = HappyWrap170 ([LHsType GhcPs])
happyIn170 :: ([LHsType GhcPs]) -> (HappyAbsSyn )
happyIn170 :: [LHsKind GhcPs] -> HappyAbsSyn
happyIn170 x :: [LHsKind GhcPs]
x = HappyWrap170 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LHsKind GhcPs] -> HappyWrap170
HappyWrap170 [LHsKind GhcPs]
x)
{-# INLINE happyIn170 #-}
happyOut170 :: (HappyAbsSyn ) -> HappyWrap170
happyOut170 :: HappyAbsSyn -> HappyWrap170
happyOut170 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap170
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut170 #-}
newtype HappyWrap171 = HappyWrap171 ([LHsType GhcPs])
happyIn171 :: ([LHsType GhcPs]) -> (HappyAbsSyn )
happyIn171 :: [LHsKind GhcPs] -> HappyAbsSyn
happyIn171 x :: [LHsKind GhcPs]
x = HappyWrap171 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LHsKind GhcPs] -> HappyWrap171
HappyWrap171 [LHsKind GhcPs]
x)
{-# INLINE happyIn171 #-}
happyOut171 :: (HappyAbsSyn ) -> HappyWrap171
happyOut171 :: HappyAbsSyn -> HappyWrap171
happyOut171 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap171
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut171 #-}
newtype HappyWrap172 = HappyWrap172 ([LHsTyVarBndr GhcPs])
happyIn172 :: ([LHsTyVarBndr GhcPs]) -> (HappyAbsSyn )
happyIn172 :: [LHsTyVarBndr GhcPs] -> HappyAbsSyn
happyIn172 x :: [LHsTyVarBndr GhcPs]
x = HappyWrap172 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LHsTyVarBndr GhcPs] -> HappyWrap172
HappyWrap172 [LHsTyVarBndr GhcPs]
x)
{-# INLINE happyIn172 #-}
happyOut172 :: (HappyAbsSyn ) -> HappyWrap172
happyOut172 :: HappyAbsSyn -> HappyWrap172
happyOut172 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap172
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut172 #-}
newtype HappyWrap173 = HappyWrap173 (LHsTyVarBndr GhcPs)
happyIn173 :: (LHsTyVarBndr GhcPs) -> (HappyAbsSyn )
happyIn173 :: LHsTyVarBndr GhcPs -> HappyAbsSyn
happyIn173 x :: LHsTyVarBndr GhcPs
x = HappyWrap173 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsTyVarBndr GhcPs -> HappyWrap173
HappyWrap173 LHsTyVarBndr GhcPs
x)
{-# INLINE happyIn173 #-}
happyOut173 :: (HappyAbsSyn ) -> HappyWrap173
happyOut173 :: HappyAbsSyn -> HappyWrap173
happyOut173 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap173
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut173 #-}
newtype HappyWrap174 = HappyWrap174 (Located ([AddAnn],[Located (FunDep (Located RdrName))]))
happyIn174 :: (Located ([AddAnn],[Located (FunDep (Located RdrName))])) -> (HappyAbsSyn )
happyIn174 :: Located ([AddAnn], [Located (FunDep (Located RdrName))])
-> HappyAbsSyn
happyIn174 x :: Located ([AddAnn], [Located (FunDep (Located RdrName))])
x = HappyWrap174 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], [Located (FunDep (Located RdrName))])
-> HappyWrap174
HappyWrap174 Located ([AddAnn], [Located (FunDep (Located RdrName))])
x)
{-# INLINE happyIn174 #-}
happyOut174 :: (HappyAbsSyn ) -> HappyWrap174
happyOut174 :: HappyAbsSyn -> HappyWrap174
happyOut174 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap174
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut174 #-}
newtype HappyWrap175 = HappyWrap175 (Located [Located (FunDep (Located RdrName))])
happyIn175 :: (Located [Located (FunDep (Located RdrName))]) -> (HappyAbsSyn )
happyIn175 :: Located [Located (FunDep (Located RdrName))] -> HappyAbsSyn
happyIn175 x :: Located [Located (FunDep (Located RdrName))]
x = HappyWrap175 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [Located (FunDep (Located RdrName))] -> HappyWrap175
HappyWrap175 Located [Located (FunDep (Located RdrName))]
x)
{-# INLINE happyIn175 #-}
happyOut175 :: (HappyAbsSyn ) -> HappyWrap175
happyOut175 :: HappyAbsSyn -> HappyWrap175
happyOut175 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap175
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut175 #-}
newtype HappyWrap176 = HappyWrap176 (Located (FunDep (Located RdrName)))
happyIn176 :: (Located (FunDep (Located RdrName))) -> (HappyAbsSyn )
happyIn176 :: Located (FunDep (Located RdrName)) -> HappyAbsSyn
happyIn176 x :: Located (FunDep (Located RdrName))
x = HappyWrap176 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (FunDep (Located RdrName)) -> HappyWrap176
HappyWrap176 Located (FunDep (Located RdrName))
x)
{-# INLINE happyIn176 #-}
happyOut176 :: (HappyAbsSyn ) -> HappyWrap176
happyOut176 :: HappyAbsSyn -> HappyWrap176
happyOut176 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap176
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut176 #-}
newtype HappyWrap177 = HappyWrap177 (Located [Located RdrName])
happyIn177 :: (Located [Located RdrName]) -> (HappyAbsSyn )
happyIn177 :: Located [Located RdrName] -> HappyAbsSyn
happyIn177 x :: Located [Located RdrName]
x = HappyWrap177 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [Located RdrName] -> HappyWrap177
HappyWrap177 Located [Located RdrName]
x)
{-# INLINE happyIn177 #-}
happyOut177 :: (HappyAbsSyn ) -> HappyWrap177
happyOut177 :: HappyAbsSyn -> HappyWrap177
happyOut177 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap177
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut177 #-}
newtype HappyWrap178 = HappyWrap178 (LHsKind GhcPs)
happyIn178 :: (LHsKind GhcPs) -> (HappyAbsSyn )
happyIn178 :: LHsKind GhcPs -> HappyAbsSyn
happyIn178 x :: LHsKind GhcPs
x = HappyWrap178 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsKind GhcPs -> HappyWrap178
HappyWrap178 LHsKind GhcPs
x)
{-# INLINE happyIn178 #-}
happyOut178 :: (HappyAbsSyn ) -> HappyWrap178
happyOut178 :: HappyAbsSyn -> HappyWrap178
happyOut178 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap178
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut178 #-}
newtype HappyWrap179 = HappyWrap179 (Located ([AddAnn]
                          ,[LConDecl GhcPs]))
happyIn179 :: (Located ([AddAnn]
                          ,[LConDecl GhcPs])) -> (HappyAbsSyn )
happyIn179 :: Located ([AddAnn], [LConDecl GhcPs]) -> HappyAbsSyn
happyIn179 x :: Located ([AddAnn], [LConDecl GhcPs])
x = HappyWrap179 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], [LConDecl GhcPs]) -> HappyWrap179
HappyWrap179 Located ([AddAnn], [LConDecl GhcPs])
x)
{-# INLINE happyIn179 #-}
happyOut179 :: (HappyAbsSyn ) -> HappyWrap179
happyOut179 :: HappyAbsSyn -> HappyWrap179
happyOut179 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap179
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut179 #-}
newtype HappyWrap180 = HappyWrap180 (Located [LConDecl GhcPs])
happyIn180 :: (Located [LConDecl GhcPs]) -> (HappyAbsSyn )
happyIn180 :: Located [LConDecl GhcPs] -> HappyAbsSyn
happyIn180 x :: Located [LConDecl GhcPs]
x = HappyWrap180 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [LConDecl GhcPs] -> HappyWrap180
HappyWrap180 Located [LConDecl GhcPs]
x)
{-# INLINE happyIn180 #-}
happyOut180 :: (HappyAbsSyn ) -> HappyWrap180
happyOut180 :: HappyAbsSyn -> HappyWrap180
happyOut180 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap180
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut180 #-}
newtype HappyWrap181 = HappyWrap181 (LConDecl GhcPs)
happyIn181 :: (LConDecl GhcPs) -> (HappyAbsSyn )
happyIn181 :: LConDecl GhcPs -> HappyAbsSyn
happyIn181 x :: LConDecl GhcPs
x = HappyWrap181 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LConDecl GhcPs -> HappyWrap181
HappyWrap181 LConDecl GhcPs
x)
{-# INLINE happyIn181 #-}
happyOut181 :: (HappyAbsSyn ) -> HappyWrap181
happyOut181 :: HappyAbsSyn -> HappyWrap181
happyOut181 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap181
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut181 #-}
newtype HappyWrap182 = HappyWrap182 (LConDecl GhcPs)
happyIn182 :: (LConDecl GhcPs) -> (HappyAbsSyn )
happyIn182 :: LConDecl GhcPs -> HappyAbsSyn
happyIn182 x :: LConDecl GhcPs
x = HappyWrap182 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LConDecl GhcPs -> HappyWrap182
HappyWrap182 LConDecl GhcPs
x)
{-# INLINE happyIn182 #-}
happyOut182 :: (HappyAbsSyn ) -> HappyWrap182
happyOut182 :: HappyAbsSyn -> HappyWrap182
happyOut182 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap182
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut182 #-}
newtype HappyWrap183 = HappyWrap183 (Located ([AddAnn],[LConDecl GhcPs]))
happyIn183 :: (Located ([AddAnn],[LConDecl GhcPs])) -> (HappyAbsSyn )
happyIn183 :: Located ([AddAnn], [LConDecl GhcPs]) -> HappyAbsSyn
happyIn183 x :: Located ([AddAnn], [LConDecl GhcPs])
x = HappyWrap183 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], [LConDecl GhcPs]) -> HappyWrap183
HappyWrap183 Located ([AddAnn], [LConDecl GhcPs])
x)
{-# INLINE happyIn183 #-}
happyOut183 :: (HappyAbsSyn ) -> HappyWrap183
happyOut183 :: HappyAbsSyn -> HappyWrap183
happyOut183 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap183
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut183 #-}
newtype HappyWrap184 = HappyWrap184 (Located [LConDecl GhcPs])
happyIn184 :: (Located [LConDecl GhcPs]) -> (HappyAbsSyn )
happyIn184 :: Located [LConDecl GhcPs] -> HappyAbsSyn
happyIn184 x :: Located [LConDecl GhcPs]
x = HappyWrap184 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [LConDecl GhcPs] -> HappyWrap184
HappyWrap184 Located [LConDecl GhcPs]
x)
{-# INLINE happyIn184 #-}
happyOut184 :: (HappyAbsSyn ) -> HappyWrap184
happyOut184 :: HappyAbsSyn -> HappyWrap184
happyOut184 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap184
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut184 #-}
newtype HappyWrap185 = HappyWrap185 (LConDecl GhcPs)
happyIn185 :: (LConDecl GhcPs) -> (HappyAbsSyn )
happyIn185 :: LConDecl GhcPs -> HappyAbsSyn
happyIn185 x :: LConDecl GhcPs
x = HappyWrap185 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LConDecl GhcPs -> HappyWrap185
HappyWrap185 LConDecl GhcPs
x)
{-# INLINE happyIn185 #-}
happyOut185 :: (HappyAbsSyn ) -> HappyWrap185
happyOut185 :: HappyAbsSyn -> HappyWrap185
happyOut185 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap185
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut185 #-}
newtype HappyWrap186 = HappyWrap186 (Located ([AddAnn], Maybe [LHsTyVarBndr GhcPs]))
happyIn186 :: (Located ([AddAnn], Maybe [LHsTyVarBndr GhcPs])) -> (HappyAbsSyn )
happyIn186 :: Located ([AddAnn], Maybe [LHsTyVarBndr GhcPs]) -> HappyAbsSyn
happyIn186 x :: Located ([AddAnn], Maybe [LHsTyVarBndr GhcPs])
x = HappyWrap186 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], Maybe [LHsTyVarBndr GhcPs]) -> HappyWrap186
HappyWrap186 Located ([AddAnn], Maybe [LHsTyVarBndr GhcPs])
x)
{-# INLINE happyIn186 #-}
happyOut186 :: (HappyAbsSyn ) -> HappyWrap186
happyOut186 :: HappyAbsSyn -> HappyWrap186
happyOut186 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap186
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut186 #-}
newtype HappyWrap187 = HappyWrap187 (Located (Located RdrName, HsConDeclDetails GhcPs, Maybe LHsDocString))
happyIn187 :: (Located (Located RdrName, HsConDeclDetails GhcPs, Maybe LHsDocString)) -> (HappyAbsSyn )
happyIn187 :: Located
  (Located RdrName, HsConDeclDetails GhcPs, Maybe LHsDocString)
-> HappyAbsSyn
happyIn187 x :: Located
  (Located RdrName, HsConDeclDetails GhcPs, Maybe LHsDocString)
x = HappyWrap187 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located
  (Located RdrName, HsConDeclDetails GhcPs, Maybe LHsDocString)
-> HappyWrap187
HappyWrap187 Located
  (Located RdrName, HsConDeclDetails GhcPs, Maybe LHsDocString)
x)
{-# INLINE happyIn187 #-}
happyOut187 :: (HappyAbsSyn ) -> HappyWrap187
happyOut187 :: HappyAbsSyn -> HappyWrap187
happyOut187 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap187
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut187 #-}
newtype HappyWrap188 = HappyWrap188 ([LConDeclField GhcPs])
happyIn188 :: ([LConDeclField GhcPs]) -> (HappyAbsSyn )
happyIn188 :: [LConDeclField GhcPs] -> HappyAbsSyn
happyIn188 x :: [LConDeclField GhcPs]
x = HappyWrap188 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LConDeclField GhcPs] -> HappyWrap188
HappyWrap188 [LConDeclField GhcPs]
x)
{-# INLINE happyIn188 #-}
happyOut188 :: (HappyAbsSyn ) -> HappyWrap188
happyOut188 :: HappyAbsSyn -> HappyWrap188
happyOut188 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap188
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut188 #-}
newtype HappyWrap189 = HappyWrap189 ([LConDeclField GhcPs])
happyIn189 :: ([LConDeclField GhcPs]) -> (HappyAbsSyn )
happyIn189 :: [LConDeclField GhcPs] -> HappyAbsSyn
happyIn189 x :: [LConDeclField GhcPs]
x = HappyWrap189 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LConDeclField GhcPs] -> HappyWrap189
HappyWrap189 [LConDeclField GhcPs]
x)
{-# INLINE happyIn189 #-}
happyOut189 :: (HappyAbsSyn ) -> HappyWrap189
happyOut189 :: HappyAbsSyn -> HappyWrap189
happyOut189 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap189
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut189 #-}
newtype HappyWrap190 = HappyWrap190 (LConDeclField GhcPs)
happyIn190 :: (LConDeclField GhcPs) -> (HappyAbsSyn )
happyIn190 :: LConDeclField GhcPs -> HappyAbsSyn
happyIn190 x :: LConDeclField GhcPs
x = HappyWrap190 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LConDeclField GhcPs -> HappyWrap190
HappyWrap190 LConDeclField GhcPs
x)
{-# INLINE happyIn190 #-}
happyOut190 :: (HappyAbsSyn ) -> HappyWrap190
happyOut190 :: HappyAbsSyn -> HappyWrap190
happyOut190 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap190
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut190 #-}
newtype HappyWrap191 = HappyWrap191 (HsDeriving GhcPs)
happyIn191 :: (HsDeriving GhcPs) -> (HappyAbsSyn )
happyIn191 :: HsDeriving GhcPs -> HappyAbsSyn
happyIn191 x :: HsDeriving GhcPs
x = HappyWrap191 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (HsDeriving GhcPs -> HappyWrap191
HappyWrap191 HsDeriving GhcPs
x)
{-# INLINE happyIn191 #-}
happyOut191 :: (HappyAbsSyn ) -> HappyWrap191
happyOut191 :: HappyAbsSyn -> HappyWrap191
happyOut191 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap191
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut191 #-}
newtype HappyWrap192 = HappyWrap192 (HsDeriving GhcPs)
happyIn192 :: (HsDeriving GhcPs) -> (HappyAbsSyn )
happyIn192 :: HsDeriving GhcPs -> HappyAbsSyn
happyIn192 x :: HsDeriving GhcPs
x = HappyWrap192 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (HsDeriving GhcPs -> HappyWrap192
HappyWrap192 HsDeriving GhcPs
x)
{-# INLINE happyIn192 #-}
happyOut192 :: (HappyAbsSyn ) -> HappyWrap192
happyOut192 :: HappyAbsSyn -> HappyWrap192
happyOut192 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap192
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut192 #-}
newtype HappyWrap193 = HappyWrap193 (LHsDerivingClause GhcPs)
happyIn193 :: (LHsDerivingClause GhcPs) -> (HappyAbsSyn )
happyIn193 :: LHsDerivingClause GhcPs -> HappyAbsSyn
happyIn193 x :: LHsDerivingClause GhcPs
x = HappyWrap193 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsDerivingClause GhcPs -> HappyWrap193
HappyWrap193 LHsDerivingClause GhcPs
x)
{-# INLINE happyIn193 #-}
happyOut193 :: (HappyAbsSyn ) -> HappyWrap193
happyOut193 :: HappyAbsSyn -> HappyWrap193
happyOut193 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap193
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut193 #-}
newtype HappyWrap194 = HappyWrap194 (Located [LHsSigType GhcPs])
happyIn194 :: (Located [LHsSigType GhcPs]) -> (HappyAbsSyn )
happyIn194 :: Located [LHsSigType GhcPs] -> HappyAbsSyn
happyIn194 x :: Located [LHsSigType GhcPs]
x = HappyWrap194 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [LHsSigType GhcPs] -> HappyWrap194
HappyWrap194 Located [LHsSigType GhcPs]
x)
{-# INLINE happyIn194 #-}
happyOut194 :: (HappyAbsSyn ) -> HappyWrap194
happyOut194 :: HappyAbsSyn -> HappyWrap194
happyOut194 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap194
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut194 #-}
newtype HappyWrap195 = HappyWrap195 (LHsDecl GhcPs)
happyIn195 :: (LHsDecl GhcPs) -> (HappyAbsSyn )
happyIn195 :: LHsDecl GhcPs -> HappyAbsSyn
happyIn195 x :: LHsDecl GhcPs
x = HappyWrap195 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsDecl GhcPs -> HappyWrap195
HappyWrap195 LHsDecl GhcPs
x)
{-# INLINE happyIn195 #-}
happyOut195 :: (HappyAbsSyn ) -> HappyWrap195
happyOut195 :: HappyAbsSyn -> HappyWrap195
happyOut195 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap195
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut195 #-}
newtype HappyWrap196 = HappyWrap196 (LDocDecl)
happyIn196 :: (LDocDecl) -> (HappyAbsSyn )
happyIn196 :: LDocDecl -> HappyAbsSyn
happyIn196 x :: LDocDecl
x = HappyWrap196 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LDocDecl -> HappyWrap196
HappyWrap196 LDocDecl
x)
{-# INLINE happyIn196 #-}
happyOut196 :: (HappyAbsSyn ) -> HappyWrap196
happyOut196 :: HappyAbsSyn -> HappyWrap196
happyOut196 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap196
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut196 #-}
newtype HappyWrap197 = HappyWrap197 (LHsDecl GhcPs)
happyIn197 :: (LHsDecl GhcPs) -> (HappyAbsSyn )
happyIn197 :: LHsDecl GhcPs -> HappyAbsSyn
happyIn197 x :: LHsDecl GhcPs
x = HappyWrap197 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsDecl GhcPs -> HappyWrap197
HappyWrap197 LHsDecl GhcPs
x)
{-# INLINE happyIn197 #-}
happyOut197 :: (HappyAbsSyn ) -> HappyWrap197
happyOut197 :: HappyAbsSyn -> HappyWrap197
happyOut197 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap197
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut197 #-}
newtype HappyWrap198 = HappyWrap198 (LHsDecl GhcPs)
happyIn198 :: (LHsDecl GhcPs) -> (HappyAbsSyn )
happyIn198 :: LHsDecl GhcPs -> HappyAbsSyn
happyIn198 x :: LHsDecl GhcPs
x = HappyWrap198 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsDecl GhcPs -> HappyWrap198
HappyWrap198 LHsDecl GhcPs
x)
{-# INLINE happyIn198 #-}
happyOut198 :: (HappyAbsSyn ) -> HappyWrap198
happyOut198 :: HappyAbsSyn -> HappyWrap198
happyOut198 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap198
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut198 #-}
newtype HappyWrap199 = HappyWrap199 (Located ([AddAnn],GRHSs GhcPs (LHsExpr GhcPs)))
happyIn199 :: (Located ([AddAnn],GRHSs GhcPs (LHsExpr GhcPs))) -> (HappyAbsSyn )
happyIn199 :: Located ([AddAnn], GRHSs GhcPs (LHsExpr GhcPs)) -> HappyAbsSyn
happyIn199 x :: Located ([AddAnn], GRHSs GhcPs (LHsExpr GhcPs))
x = HappyWrap199 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], GRHSs GhcPs (LHsExpr GhcPs)) -> HappyWrap199
HappyWrap199 Located ([AddAnn], GRHSs GhcPs (LHsExpr GhcPs))
x)
{-# INLINE happyIn199 #-}
happyOut199 :: (HappyAbsSyn ) -> HappyWrap199
happyOut199 :: HappyAbsSyn -> HappyWrap199
happyOut199 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap199
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut199 #-}
newtype HappyWrap200 = HappyWrap200 (Located [LGRHS GhcPs (LHsExpr GhcPs)])
happyIn200 :: (Located [LGRHS GhcPs (LHsExpr GhcPs)]) -> (HappyAbsSyn )
happyIn200 :: Located [LGRHS GhcPs (LHsExpr GhcPs)] -> HappyAbsSyn
happyIn200 x :: Located [LGRHS GhcPs (LHsExpr GhcPs)]
x = HappyWrap200 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [LGRHS GhcPs (LHsExpr GhcPs)] -> HappyWrap200
HappyWrap200 Located [LGRHS GhcPs (LHsExpr GhcPs)]
x)
{-# INLINE happyIn200 #-}
happyOut200 :: (HappyAbsSyn ) -> HappyWrap200
happyOut200 :: HappyAbsSyn -> HappyWrap200
happyOut200 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap200
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut200 #-}
newtype HappyWrap201 = HappyWrap201 (LGRHS GhcPs (LHsExpr GhcPs))
happyIn201 :: (LGRHS GhcPs (LHsExpr GhcPs)) -> (HappyAbsSyn )
happyIn201 :: LGRHS GhcPs (LHsExpr GhcPs) -> HappyAbsSyn
happyIn201 x :: LGRHS GhcPs (LHsExpr GhcPs)
x = HappyWrap201 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LGRHS GhcPs (LHsExpr GhcPs) -> HappyWrap201
HappyWrap201 LGRHS GhcPs (LHsExpr GhcPs)
x)
{-# INLINE happyIn201 #-}
happyOut201 :: (HappyAbsSyn ) -> HappyWrap201
happyOut201 :: HappyAbsSyn -> HappyWrap201
happyOut201 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap201
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut201 #-}
newtype HappyWrap202 = HappyWrap202 (LHsDecl GhcPs)
happyIn202 :: (LHsDecl GhcPs) -> (HappyAbsSyn )
happyIn202 :: LHsDecl GhcPs -> HappyAbsSyn
happyIn202 x :: LHsDecl GhcPs
x = HappyWrap202 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsDecl GhcPs -> HappyWrap202
HappyWrap202 LHsDecl GhcPs
x)
{-# INLINE happyIn202 #-}
happyOut202 :: (HappyAbsSyn ) -> HappyWrap202
happyOut202 :: HappyAbsSyn -> HappyWrap202
happyOut202 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap202
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut202 #-}
newtype HappyWrap203 = HappyWrap203 (([AddAnn],Maybe Activation))
happyIn203 :: (([AddAnn],Maybe Activation)) -> (HappyAbsSyn )
happyIn203 :: ([AddAnn], Maybe Activation) -> HappyAbsSyn
happyIn203 x :: ([AddAnn], Maybe Activation)
x = HappyWrap203 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], Maybe Activation) -> HappyWrap203
HappyWrap203 ([AddAnn], Maybe Activation)
x)
{-# INLINE happyIn203 #-}
happyOut203 :: (HappyAbsSyn ) -> HappyWrap203
happyOut203 :: HappyAbsSyn -> HappyWrap203
happyOut203 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap203
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut203 #-}
newtype HappyWrap204 = HappyWrap204 (([AddAnn],Activation))
happyIn204 :: (([AddAnn],Activation)) -> (HappyAbsSyn )
happyIn204 :: ([AddAnn], Activation) -> HappyAbsSyn
happyIn204 x :: ([AddAnn], Activation)
x = HappyWrap204 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], Activation) -> HappyWrap204
HappyWrap204 ([AddAnn], Activation)
x)
{-# INLINE happyIn204 #-}
happyOut204 :: (HappyAbsSyn ) -> HappyWrap204
happyOut204 :: HappyAbsSyn -> HappyWrap204
happyOut204 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap204
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut204 #-}
newtype HappyWrap205 = HappyWrap205 (Located (HsSplice GhcPs))
happyIn205 :: (Located (HsSplice GhcPs)) -> (HappyAbsSyn )
happyIn205 :: Located (HsSplice GhcPs) -> HappyAbsSyn
happyIn205 x :: Located (HsSplice GhcPs)
x = HappyWrap205 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (HsSplice GhcPs) -> HappyWrap205
HappyWrap205 Located (HsSplice GhcPs)
x)
{-# INLINE happyIn205 #-}
happyOut205 :: (HappyAbsSyn ) -> HappyWrap205
happyOut205 :: HappyAbsSyn -> HappyWrap205
happyOut205 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap205
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut205 #-}
newtype HappyWrap206 = HappyWrap206 (LHsExpr GhcPs)
happyIn206 :: (LHsExpr GhcPs) -> (HappyAbsSyn )
happyIn206 :: LHsExpr GhcPs -> HappyAbsSyn
happyIn206 x :: LHsExpr GhcPs
x = HappyWrap206 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsExpr GhcPs -> HappyWrap206
HappyWrap206 LHsExpr GhcPs
x)
{-# INLINE happyIn206 #-}
happyOut206 :: (HappyAbsSyn ) -> HappyWrap206
happyOut206 :: HappyAbsSyn -> HappyWrap206
happyOut206 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap206
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut206 #-}
newtype HappyWrap207 = HappyWrap207 (LHsExpr GhcPs)
happyIn207 :: (LHsExpr GhcPs) -> (HappyAbsSyn )
happyIn207 :: LHsExpr GhcPs -> HappyAbsSyn
happyIn207 x :: LHsExpr GhcPs
x = HappyWrap207 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsExpr GhcPs -> HappyWrap207
HappyWrap207 LHsExpr GhcPs
x)
{-# INLINE happyIn207 #-}
happyOut207 :: (HappyAbsSyn ) -> HappyWrap207
happyOut207 :: HappyAbsSyn -> HappyWrap207
happyOut207 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap207
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut207 #-}
newtype HappyWrap208 = HappyWrap208 (LHsExpr GhcPs)
happyIn208 :: (LHsExpr GhcPs) -> (HappyAbsSyn )
happyIn208 :: LHsExpr GhcPs -> HappyAbsSyn
happyIn208 x :: LHsExpr GhcPs
x = HappyWrap208 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsExpr GhcPs -> HappyWrap208
HappyWrap208 LHsExpr GhcPs
x)
{-# INLINE happyIn208 #-}
happyOut208 :: (HappyAbsSyn ) -> HappyWrap208
happyOut208 :: HappyAbsSyn -> HappyWrap208
happyOut208 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap208
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut208 #-}
newtype HappyWrap209 = HappyWrap209 (LHsExpr GhcPs)
happyIn209 :: (LHsExpr GhcPs) -> (HappyAbsSyn )
happyIn209 :: LHsExpr GhcPs -> HappyAbsSyn
happyIn209 x :: LHsExpr GhcPs
x = HappyWrap209 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsExpr GhcPs -> HappyWrap209
HappyWrap209 LHsExpr GhcPs
x)
{-# INLINE happyIn209 #-}
happyOut209 :: (HappyAbsSyn ) -> HappyWrap209
happyOut209 :: HappyAbsSyn -> HappyWrap209
happyOut209 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap209
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut209 #-}
newtype HappyWrap210 = HappyWrap210 (LHsExpr GhcPs)
happyIn210 :: (LHsExpr GhcPs) -> (HappyAbsSyn )
happyIn210 :: LHsExpr GhcPs -> HappyAbsSyn
happyIn210 x :: LHsExpr GhcPs
x = HappyWrap210 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsExpr GhcPs -> HappyWrap210
HappyWrap210 LHsExpr GhcPs
x)
{-# INLINE happyIn210 #-}
happyOut210 :: (HappyAbsSyn ) -> HappyWrap210
happyOut210 :: HappyAbsSyn -> HappyWrap210
happyOut210 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap210
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut210 #-}
newtype HappyWrap211 = HappyWrap211 (([Located Token],Bool))
happyIn211 :: (([Located Token],Bool)) -> (HappyAbsSyn )
happyIn211 :: ([Located Token], IsBootInterface) -> HappyAbsSyn
happyIn211 x :: ([Located Token], IsBootInterface)
x = HappyWrap211 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([Located Token], IsBootInterface) -> HappyWrap211
HappyWrap211 ([Located Token], IsBootInterface)
x)
{-# INLINE happyIn211 #-}
happyOut211 :: (HappyAbsSyn ) -> HappyWrap211
happyOut211 :: HappyAbsSyn -> HappyWrap211
happyOut211 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap211
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut211 #-}
newtype HappyWrap212 = HappyWrap212 (Located (([AddAnn],SourceText),StringLiteral))
happyIn212 :: (Located (([AddAnn],SourceText),StringLiteral)) -> (HappyAbsSyn )
happyIn212 :: Located (([AddAnn], SourceText), StringLiteral) -> HappyAbsSyn
happyIn212 x :: Located (([AddAnn], SourceText), StringLiteral)
x = HappyWrap212 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (([AddAnn], SourceText), StringLiteral) -> HappyWrap212
HappyWrap212 Located (([AddAnn], SourceText), StringLiteral)
x)
{-# INLINE happyIn212 #-}
happyOut212 :: (HappyAbsSyn ) -> HappyWrap212
happyOut212 :: HappyAbsSyn -> HappyWrap212
happyOut212 x :: HappyAbsSyn
x = HappyAbsSyn -> HappyWrap212
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut212 #-}
newtype HappyWrap213 = HappyWrap213 (Located ( (([AddAnn],SourceText),(StringLiteral,(Int,Int),(Int,Int))),
                         ((SourceText,SourceText),(SourceText,SourceText))
                       ))
happyIn213 :: (Located ( (([AddAnn],SourceText),(StringLiteral,(Int,Int),(Int,Int))),
                         ((SourceText,SourceText),(SourceText,SourceText))
                       )) -> (HappyAbsSyn )
happyIn213 :: Located
  ((([AddAnn], Source