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

-- | 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 Data.Maybe       ( maybeToList )
import Control.Monad    ( mplus )
import Control.Applicative ((<$))
import qualified Prelude

-- compiler/hsSyn
import GHC.Hs

-- compiler/main
import DriverPhases     ( HscSource(..) )
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 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.12

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 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 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 [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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap28
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut28 #-}
newtype HappyWrap29 = HappyWrap29 (LRenaming)
happyIn29 :: (LRenaming) -> (HappyAbsSyn )
happyIn29 :: LRenaming -> HappyAbsSyn
happyIn29 LRenaming
x = HappyWrap29 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LRenaming -> HappyWrap29
HappyWrap29 LRenaming
x)
{-# INLINE happyIn29 #-}
happyOut29 :: (HappyAbsSyn ) -> HappyWrap29
happyOut29 :: HappyAbsSyn -> HappyWrap29
happyOut29 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 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 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 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 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 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 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 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 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 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 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 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 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap35
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut35 #-}
newtype HappyWrap36 = HappyWrap36 (())
happyIn36 :: (()) -> (HappyAbsSyn )
happyIn36 :: () -> HappyAbsSyn
happyIn36 ()
x = HappyWrap36 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (() -> HappyWrap36
HappyWrap36 ()
x)
{-# INLINE happyIn36 #-}
happyOut36 :: (HappyAbsSyn ) -> HappyWrap36
happyOut36 :: HappyAbsSyn -> HappyWrap36
happyOut36 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap36
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut36 #-}
newtype HappyWrap37 = HappyWrap37 (())
happyIn37 :: (()) -> (HappyAbsSyn )
happyIn37 :: () -> HappyAbsSyn
happyIn37 ()
x = HappyWrap37 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (() -> HappyWrap37
HappyWrap37 ()
x)
{-# INLINE happyIn37 #-}
happyOut37 :: (HappyAbsSyn ) -> HappyWrap37
happyOut37 :: HappyAbsSyn -> HappyWrap37
happyOut37 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 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 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 ([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 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 ([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 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 ([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 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 ([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 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 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 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 [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 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 [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 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 [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 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 [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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 ([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 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 ([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 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 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 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 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 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 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 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap59
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut59 #-}
newtype HappyWrap60 = HappyWrap60 ([AddAnn])
happyIn60 :: ([AddAnn]) -> (HappyAbsSyn )
happyIn60 :: [AddAnn] -> HappyAbsSyn
happyIn60 [AddAnn]
x = HappyWrap60 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([AddAnn] -> HappyWrap60
HappyWrap60 [AddAnn]
x)
{-# INLINE happyIn60 #-}
happyOut60 :: (HappyAbsSyn ) -> HappyWrap60
happyOut60 :: HappyAbsSyn -> HappyWrap60
happyOut60 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap60
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut60 #-}
newtype HappyWrap61 = HappyWrap61 ([AddAnn])
happyIn61 :: ([AddAnn]) -> (HappyAbsSyn )
happyIn61 :: [AddAnn] -> HappyAbsSyn
happyIn61 [AddAnn]
x = HappyWrap61 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([AddAnn] -> HappyWrap61
HappyWrap61 [AddAnn]
x)
{-# INLINE happyIn61 #-}
happyOut61 :: (HappyAbsSyn ) -> HappyWrap61
happyOut61 :: HappyAbsSyn -> HappyWrap61
happyOut61 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 [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 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 [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 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 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 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 (([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 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 ([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 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 ([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 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap67
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut67 #-}
newtype HappyWrap68 = HappyWrap68 (Maybe (Located Token))
happyIn68 :: (Maybe (Located Token)) -> (HappyAbsSyn )
happyIn68 :: Maybe (Located Token) -> HappyAbsSyn
happyIn68 Maybe (Located Token)
x = HappyWrap68 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Maybe (Located Token) -> HappyWrap68
HappyWrap68 Maybe (Located Token)
x)
{-# INLINE happyIn68 #-}
happyOut68 :: (HappyAbsSyn ) -> HappyWrap68
happyOut68 :: HappyAbsSyn -> HappyWrap68
happyOut68 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 ([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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap79
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut79 #-}
newtype HappyWrap80 = HappyWrap80 (LStandaloneKindSig GhcPs)
happyIn80 :: (LStandaloneKindSig GhcPs) -> (HappyAbsSyn )
happyIn80 :: LStandaloneKindSig GhcPs -> HappyAbsSyn
happyIn80 LStandaloneKindSig GhcPs
x = HappyWrap80 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LStandaloneKindSig GhcPs -> HappyWrap80
HappyWrap80 LStandaloneKindSig GhcPs
x)
{-# INLINE happyIn80 #-}
happyOut80 :: (HappyAbsSyn ) -> HappyWrap80
happyOut80 :: HappyAbsSyn -> HappyWrap80
happyOut80 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap80
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut80 #-}
newtype HappyWrap81 = HappyWrap81 (Located [Located RdrName])
happyIn81 :: (Located [Located RdrName]) -> (HappyAbsSyn )
happyIn81 :: Located [Located RdrName] -> HappyAbsSyn
happyIn81 Located [Located RdrName]
x = HappyWrap81 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [Located RdrName] -> HappyWrap81
HappyWrap81 Located [Located RdrName]
x)
{-# INLINE happyIn81 #-}
happyOut81 :: (HappyAbsSyn ) -> HappyWrap81
happyOut81 :: HappyAbsSyn -> HappyWrap81
happyOut81 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap81
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut81 #-}
newtype HappyWrap82 = HappyWrap82 (LInstDecl GhcPs)
happyIn82 :: (LInstDecl GhcPs) -> (HappyAbsSyn )
happyIn82 :: LInstDecl GhcPs -> HappyAbsSyn
happyIn82 LInstDecl GhcPs
x = HappyWrap82 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LInstDecl GhcPs -> HappyWrap82
HappyWrap82 LInstDecl GhcPs
x)
{-# INLINE happyIn82 #-}
happyOut82 :: (HappyAbsSyn ) -> HappyWrap82
happyOut82 :: HappyAbsSyn -> HappyWrap82
happyOut82 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap82
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut82 #-}
newtype HappyWrap83 = HappyWrap83 (Maybe (Located OverlapMode))
happyIn83 :: (Maybe (Located OverlapMode)) -> (HappyAbsSyn )
happyIn83 :: Maybe (Located OverlapMode) -> HappyAbsSyn
happyIn83 Maybe (Located OverlapMode)
x = HappyWrap83 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Maybe (Located OverlapMode) -> HappyWrap83
HappyWrap83 Maybe (Located OverlapMode)
x)
{-# INLINE happyIn83 #-}
happyOut83 :: (HappyAbsSyn ) -> HappyWrap83
happyOut83 :: HappyAbsSyn -> HappyWrap83
happyOut83 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap83
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut83 #-}
newtype HappyWrap84 = HappyWrap84 (LDerivStrategy GhcPs)
happyIn84 :: (LDerivStrategy GhcPs) -> (HappyAbsSyn )
happyIn84 :: LDerivStrategy GhcPs -> HappyAbsSyn
happyIn84 LDerivStrategy GhcPs
x = HappyWrap84 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LDerivStrategy GhcPs -> HappyWrap84
HappyWrap84 LDerivStrategy GhcPs
x)
{-# INLINE happyIn84 #-}
happyOut84 :: (HappyAbsSyn ) -> HappyWrap84
happyOut84 :: HappyAbsSyn -> HappyWrap84
happyOut84 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap84
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut84 #-}
newtype HappyWrap85 = HappyWrap85 (LDerivStrategy GhcPs)
happyIn85 :: (LDerivStrategy GhcPs) -> (HappyAbsSyn )
happyIn85 :: LDerivStrategy GhcPs -> HappyAbsSyn
happyIn85 LDerivStrategy GhcPs
x = HappyWrap85 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LDerivStrategy GhcPs -> HappyWrap85
HappyWrap85 LDerivStrategy GhcPs
x)
{-# INLINE happyIn85 #-}
happyOut85 :: (HappyAbsSyn ) -> HappyWrap85
happyOut85 :: HappyAbsSyn -> HappyWrap85
happyOut85 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap85
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut85 #-}
newtype HappyWrap86 = HappyWrap86 (Maybe (LDerivStrategy GhcPs))
happyIn86 :: (Maybe (LDerivStrategy GhcPs)) -> (HappyAbsSyn )
happyIn86 :: Maybe (LDerivStrategy GhcPs) -> HappyAbsSyn
happyIn86 Maybe (LDerivStrategy GhcPs)
x = HappyWrap86 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Maybe (LDerivStrategy GhcPs) -> HappyWrap86
HappyWrap86 Maybe (LDerivStrategy GhcPs)
x)
{-# INLINE happyIn86 #-}
happyOut86 :: (HappyAbsSyn ) -> HappyWrap86
happyOut86 :: HappyAbsSyn -> HappyWrap86
happyOut86 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap86
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut86 #-}
newtype HappyWrap87 = HappyWrap87 (Located ([AddAnn], Maybe (LInjectivityAnn GhcPs)))
happyIn87 :: (Located ([AddAnn], Maybe (LInjectivityAnn GhcPs))) -> (HappyAbsSyn )
happyIn87 :: Located ([AddAnn], Maybe (LInjectivityAnn GhcPs)) -> HappyAbsSyn
happyIn87 Located ([AddAnn], Maybe (LInjectivityAnn GhcPs))
x = HappyWrap87 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], Maybe (LInjectivityAnn GhcPs)) -> HappyWrap87
HappyWrap87 Located ([AddAnn], Maybe (LInjectivityAnn GhcPs))
x)
{-# INLINE happyIn87 #-}
happyOut87 :: (HappyAbsSyn ) -> HappyWrap87
happyOut87 :: HappyAbsSyn -> HappyWrap87
happyOut87 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap87
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut87 #-}
newtype HappyWrap88 = HappyWrap88 (LInjectivityAnn GhcPs)
happyIn88 :: (LInjectivityAnn GhcPs) -> (HappyAbsSyn )
happyIn88 :: LInjectivityAnn GhcPs -> HappyAbsSyn
happyIn88 LInjectivityAnn GhcPs
x = HappyWrap88 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LInjectivityAnn GhcPs -> HappyWrap88
HappyWrap88 LInjectivityAnn GhcPs
x)
{-# INLINE happyIn88 #-}
happyOut88 :: (HappyAbsSyn ) -> HappyWrap88
happyOut88 :: HappyAbsSyn -> HappyWrap88
happyOut88 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap88
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut88 #-}
newtype HappyWrap89 = HappyWrap89 (Located [Located RdrName])
happyIn89 :: (Located [Located RdrName]) -> (HappyAbsSyn )
happyIn89 :: Located [Located RdrName] -> HappyAbsSyn
happyIn89 Located [Located RdrName]
x = HappyWrap89 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [Located RdrName] -> HappyWrap89
HappyWrap89 Located [Located RdrName]
x)
{-# INLINE happyIn89 #-}
happyOut89 :: (HappyAbsSyn ) -> HappyWrap89
happyOut89 :: HappyAbsSyn -> HappyWrap89
happyOut89 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap89
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut89 #-}
newtype HappyWrap90 = HappyWrap90 (Located ([AddAnn],FamilyInfo GhcPs))
happyIn90 :: (Located ([AddAnn],FamilyInfo GhcPs)) -> (HappyAbsSyn )
happyIn90 :: Located ([AddAnn], FamilyInfo GhcPs) -> HappyAbsSyn
happyIn90 Located ([AddAnn], FamilyInfo GhcPs)
x = HappyWrap90 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], FamilyInfo GhcPs) -> HappyWrap90
HappyWrap90 Located ([AddAnn], FamilyInfo GhcPs)
x)
{-# INLINE happyIn90 #-}
happyOut90 :: (HappyAbsSyn ) -> HappyWrap90
happyOut90 :: HappyAbsSyn -> HappyWrap90
happyOut90 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap90
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut90 #-}
newtype HappyWrap91 = HappyWrap91 (Located ([AddAnn],Maybe [LTyFamInstEqn GhcPs]))
happyIn91 :: (Located ([AddAnn],Maybe [LTyFamInstEqn GhcPs])) -> (HappyAbsSyn )
happyIn91 :: Located ([AddAnn], Maybe [LTyFamInstEqn GhcPs]) -> HappyAbsSyn
happyIn91 Located ([AddAnn], Maybe [LTyFamInstEqn GhcPs])
x = HappyWrap91 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], Maybe [LTyFamInstEqn GhcPs]) -> HappyWrap91
HappyWrap91 Located ([AddAnn], Maybe [LTyFamInstEqn GhcPs])
x)
{-# INLINE happyIn91 #-}
happyOut91 :: (HappyAbsSyn ) -> HappyWrap91
happyOut91 :: HappyAbsSyn -> HappyWrap91
happyOut91 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap91
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut91 #-}
newtype HappyWrap92 = HappyWrap92 (Located [LTyFamInstEqn GhcPs])
happyIn92 :: (Located [LTyFamInstEqn GhcPs]) -> (HappyAbsSyn )
happyIn92 :: Located [LTyFamInstEqn GhcPs] -> HappyAbsSyn
happyIn92 Located [LTyFamInstEqn GhcPs]
x = HappyWrap92 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [LTyFamInstEqn GhcPs] -> HappyWrap92
HappyWrap92 Located [LTyFamInstEqn GhcPs]
x)
{-# INLINE happyIn92 #-}
happyOut92 :: (HappyAbsSyn ) -> HappyWrap92
happyOut92 :: HappyAbsSyn -> HappyWrap92
happyOut92 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap92
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut92 #-}
newtype HappyWrap93 = HappyWrap93 (Located ([AddAnn],TyFamInstEqn GhcPs))
happyIn93 :: (Located ([AddAnn],TyFamInstEqn GhcPs)) -> (HappyAbsSyn )
happyIn93 :: Located ([AddAnn], TyFamInstEqn GhcPs) -> HappyAbsSyn
happyIn93 Located ([AddAnn], TyFamInstEqn GhcPs)
x = HappyWrap93 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], TyFamInstEqn GhcPs) -> HappyWrap93
HappyWrap93 Located ([AddAnn], TyFamInstEqn GhcPs)
x)
{-# INLINE happyIn93 #-}
happyOut93 :: (HappyAbsSyn ) -> HappyWrap93
happyOut93 :: HappyAbsSyn -> HappyWrap93
happyOut93 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap93
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut93 #-}
newtype HappyWrap94 = HappyWrap94 (LHsDecl GhcPs)
happyIn94 :: (LHsDecl GhcPs) -> (HappyAbsSyn )
happyIn94 :: LHsDecl GhcPs -> HappyAbsSyn
happyIn94 LHsDecl GhcPs
x = HappyWrap94 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsDecl GhcPs -> HappyWrap94
HappyWrap94 LHsDecl GhcPs
x)
{-# INLINE happyIn94 #-}
happyOut94 :: (HappyAbsSyn ) -> HappyWrap94
happyOut94 :: HappyAbsSyn -> HappyWrap94
happyOut94 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap94
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut94 #-}
newtype HappyWrap95 = HappyWrap95 ([AddAnn])
happyIn95 :: ([AddAnn]) -> (HappyAbsSyn )
happyIn95 :: [AddAnn] -> HappyAbsSyn
happyIn95 [AddAnn]
x = HappyWrap95 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([AddAnn] -> HappyWrap95
HappyWrap95 [AddAnn]
x)
{-# INLINE happyIn95 #-}
happyOut95 :: (HappyAbsSyn ) -> HappyWrap95
happyOut95 :: HappyAbsSyn -> HappyWrap95
happyOut95 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap95
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut95 #-}
newtype HappyWrap96 = HappyWrap96 ([AddAnn])
happyIn96 :: ([AddAnn]) -> (HappyAbsSyn )
happyIn96 :: [AddAnn] -> HappyAbsSyn
happyIn96 [AddAnn]
x = HappyWrap96 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([AddAnn] -> HappyWrap96
HappyWrap96 [AddAnn]
x)
{-# INLINE happyIn96 #-}
happyOut96 :: (HappyAbsSyn ) -> HappyWrap96
happyOut96 :: HappyAbsSyn -> HappyWrap96
happyOut96 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap96
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut96 #-}
newtype HappyWrap97 = HappyWrap97 (LInstDecl GhcPs)
happyIn97 :: (LInstDecl GhcPs) -> (HappyAbsSyn )
happyIn97 :: LInstDecl GhcPs -> HappyAbsSyn
happyIn97 LInstDecl GhcPs
x = HappyWrap97 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LInstDecl GhcPs -> HappyWrap97
HappyWrap97 LInstDecl GhcPs
x)
{-# INLINE happyIn97 #-}
happyOut97 :: (HappyAbsSyn ) -> HappyWrap97
happyOut97 :: HappyAbsSyn -> HappyWrap97
happyOut97 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap97
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut97 #-}
newtype HappyWrap98 = HappyWrap98 (Located (AddAnn, NewOrData))
happyIn98 :: (Located (AddAnn, NewOrData)) -> (HappyAbsSyn )
happyIn98 :: Located (AddAnn, NewOrData) -> HappyAbsSyn
happyIn98 Located (AddAnn, NewOrData)
x = HappyWrap98 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (AddAnn, NewOrData) -> HappyWrap98
HappyWrap98 Located (AddAnn, NewOrData)
x)
{-# INLINE happyIn98 #-}
happyOut98 :: (HappyAbsSyn ) -> HappyWrap98
happyOut98 :: HappyAbsSyn -> HappyWrap98
happyOut98 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap98
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut98 #-}
newtype HappyWrap99 = HappyWrap99 (Located ([AddAnn], Maybe (LHsKind GhcPs)))
happyIn99 :: (Located ([AddAnn], Maybe (LHsKind GhcPs))) -> (HappyAbsSyn )
happyIn99 :: Located ([AddAnn], Maybe (LHsKind GhcPs)) -> HappyAbsSyn
happyIn99 Located ([AddAnn], Maybe (LHsKind GhcPs))
x = HappyWrap99 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], Maybe (LHsKind GhcPs)) -> HappyWrap99
HappyWrap99 Located ([AddAnn], Maybe (LHsKind GhcPs))
x)
{-# INLINE happyIn99 #-}
happyOut99 :: (HappyAbsSyn ) -> HappyWrap99
happyOut99 :: HappyAbsSyn -> HappyWrap99
happyOut99 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap99
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut99 #-}
newtype HappyWrap100 = HappyWrap100 (Located ([AddAnn], LFamilyResultSig GhcPs))
happyIn100 :: (Located ([AddAnn], LFamilyResultSig GhcPs)) -> (HappyAbsSyn )
happyIn100 :: Located ([AddAnn], LFamilyResultSig GhcPs) -> HappyAbsSyn
happyIn100 Located ([AddAnn], LFamilyResultSig GhcPs)
x = HappyWrap100 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], LFamilyResultSig GhcPs) -> HappyWrap100
HappyWrap100 Located ([AddAnn], LFamilyResultSig GhcPs)
x)
{-# INLINE happyIn100 #-}
happyOut100 :: (HappyAbsSyn ) -> HappyWrap100
happyOut100 :: HappyAbsSyn -> HappyWrap100
happyOut100 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap100
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut100 #-}
newtype HappyWrap101 = HappyWrap101 (Located ([AddAnn], LFamilyResultSig GhcPs))
happyIn101 :: (Located ([AddAnn], LFamilyResultSig GhcPs)) -> (HappyAbsSyn )
happyIn101 :: Located ([AddAnn], LFamilyResultSig GhcPs) -> HappyAbsSyn
happyIn101 Located ([AddAnn], LFamilyResultSig GhcPs)
x = HappyWrap101 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], LFamilyResultSig GhcPs) -> HappyWrap101
HappyWrap101 Located ([AddAnn], LFamilyResultSig GhcPs)
x)
{-# INLINE happyIn101 #-}
happyOut101 :: (HappyAbsSyn ) -> HappyWrap101
happyOut101 :: HappyAbsSyn -> HappyWrap101
happyOut101 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap101
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut101 #-}
newtype HappyWrap102 = HappyWrap102 (Located ([AddAnn], ( LFamilyResultSig GhcPs
                                            , Maybe (LInjectivityAnn GhcPs))))
happyIn102 :: (Located ([AddAnn], ( LFamilyResultSig GhcPs
                                            , Maybe (LInjectivityAnn GhcPs)))) -> (HappyAbsSyn )
happyIn102 :: Located
  ([AddAnn], (LFamilyResultSig GhcPs, Maybe (LInjectivityAnn GhcPs)))
-> HappyAbsSyn
happyIn102 Located
  ([AddAnn], (LFamilyResultSig GhcPs, Maybe (LInjectivityAnn GhcPs)))
x = HappyWrap102 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located
  ([AddAnn], (LFamilyResultSig GhcPs, Maybe (LInjectivityAnn GhcPs)))
-> HappyWrap102
HappyWrap102 Located
  ([AddAnn], (LFamilyResultSig GhcPs, Maybe (LInjectivityAnn GhcPs)))
x)
{-# INLINE happyIn102 #-}
happyOut102 :: (HappyAbsSyn ) -> HappyWrap102
happyOut102 :: HappyAbsSyn -> HappyWrap102
happyOut102 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap102
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut102 #-}
newtype HappyWrap103 = HappyWrap103 (Located (Maybe (LHsContext GhcPs), LHsType GhcPs))
happyIn103 :: (Located (Maybe (LHsContext GhcPs), LHsType GhcPs)) -> (HappyAbsSyn )
happyIn103 :: Located (Maybe (LHsContext GhcPs), LHsKind GhcPs) -> HappyAbsSyn
happyIn103 Located (Maybe (LHsContext GhcPs), LHsKind GhcPs)
x = HappyWrap103 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (Maybe (LHsContext GhcPs), LHsKind GhcPs) -> HappyWrap103
HappyWrap103 Located (Maybe (LHsContext GhcPs), LHsKind GhcPs)
x)
{-# INLINE happyIn103 #-}
happyOut103 :: (HappyAbsSyn ) -> HappyWrap103
happyOut103 :: HappyAbsSyn -> HappyWrap103
happyOut103 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap103
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut103 #-}
newtype HappyWrap104 = HappyWrap104 (Located ([AddAnn],(Maybe (LHsContext GhcPs), Maybe [LHsTyVarBndr GhcPs], LHsType GhcPs)))
happyIn104 :: (Located ([AddAnn],(Maybe (LHsContext GhcPs), Maybe [LHsTyVarBndr GhcPs], LHsType GhcPs))) -> (HappyAbsSyn )
happyIn104 :: Located
  ([AddAnn],
   (Maybe (LHsContext GhcPs), Maybe [LHsTyVarBndr GhcPs],
    LHsKind GhcPs))
-> HappyAbsSyn
happyIn104 Located
  ([AddAnn],
   (Maybe (LHsContext GhcPs), Maybe [LHsTyVarBndr GhcPs],
    LHsKind GhcPs))
x = HappyWrap104 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located
  ([AddAnn],
   (Maybe (LHsContext GhcPs), Maybe [LHsTyVarBndr GhcPs],
    LHsKind GhcPs))
-> HappyWrap104
HappyWrap104 Located
  ([AddAnn],
   (Maybe (LHsContext GhcPs), Maybe [LHsTyVarBndr GhcPs],
    LHsKind GhcPs))
x)
{-# INLINE happyIn104 #-}
happyOut104 :: (HappyAbsSyn ) -> HappyWrap104
happyOut104 :: HappyAbsSyn -> HappyWrap104
happyOut104 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap104
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut104 #-}
newtype HappyWrap105 = HappyWrap105 (Maybe (Located CType))
happyIn105 :: (Maybe (Located CType)) -> (HappyAbsSyn )
happyIn105 :: Maybe (Located CType) -> HappyAbsSyn
happyIn105 Maybe (Located CType)
x = HappyWrap105 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Maybe (Located CType) -> HappyWrap105
HappyWrap105 Maybe (Located CType)
x)
{-# INLINE happyIn105 #-}
happyOut105 :: (HappyAbsSyn ) -> HappyWrap105
happyOut105 :: HappyAbsSyn -> HappyWrap105
happyOut105 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap105
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut105 #-}
newtype HappyWrap106 = HappyWrap106 (LDerivDecl GhcPs)
happyIn106 :: (LDerivDecl GhcPs) -> (HappyAbsSyn )
happyIn106 :: LDerivDecl GhcPs -> HappyAbsSyn
happyIn106 LDerivDecl GhcPs
x = HappyWrap106 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LDerivDecl GhcPs -> HappyWrap106
HappyWrap106 LDerivDecl GhcPs
x)
{-# INLINE happyIn106 #-}
happyOut106 :: (HappyAbsSyn ) -> HappyWrap106
happyOut106 :: HappyAbsSyn -> HappyWrap106
happyOut106 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap106
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut106 #-}
newtype HappyWrap107 = HappyWrap107 (LRoleAnnotDecl GhcPs)
happyIn107 :: (LRoleAnnotDecl GhcPs) -> (HappyAbsSyn )
happyIn107 :: LRoleAnnotDecl GhcPs -> HappyAbsSyn
happyIn107 LRoleAnnotDecl GhcPs
x = HappyWrap107 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LRoleAnnotDecl GhcPs -> HappyWrap107
HappyWrap107 LRoleAnnotDecl GhcPs
x)
{-# INLINE happyIn107 #-}
happyOut107 :: (HappyAbsSyn ) -> HappyWrap107
happyOut107 :: HappyAbsSyn -> HappyWrap107
happyOut107 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap107
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut107 #-}
newtype HappyWrap108 = HappyWrap108 (Located [Located (Maybe FastString)])
happyIn108 :: (Located [Located (Maybe FastString)]) -> (HappyAbsSyn )
happyIn108 :: Located [Located (Maybe FastString)] -> HappyAbsSyn
happyIn108 Located [Located (Maybe FastString)]
x = HappyWrap108 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [Located (Maybe FastString)] -> HappyWrap108
HappyWrap108 Located [Located (Maybe FastString)]
x)
{-# INLINE happyIn108 #-}
happyOut108 :: (HappyAbsSyn ) -> HappyWrap108
happyOut108 :: HappyAbsSyn -> HappyWrap108
happyOut108 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap108
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut108 #-}
newtype HappyWrap109 = HappyWrap109 (Located [Located (Maybe FastString)])
happyIn109 :: (Located [Located (Maybe FastString)]) -> (HappyAbsSyn )
happyIn109 :: Located [Located (Maybe FastString)] -> HappyAbsSyn
happyIn109 Located [Located (Maybe FastString)]
x = HappyWrap109 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [Located (Maybe FastString)] -> HappyWrap109
HappyWrap109 Located [Located (Maybe FastString)]
x)
{-# INLINE happyIn109 #-}
happyOut109 :: (HappyAbsSyn ) -> HappyWrap109
happyOut109 :: HappyAbsSyn -> HappyWrap109
happyOut109 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap109
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut109 #-}
newtype HappyWrap110 = HappyWrap110 (Located (Maybe FastString))
happyIn110 :: (Located (Maybe FastString)) -> (HappyAbsSyn )
happyIn110 :: Located (Maybe FastString) -> HappyAbsSyn
happyIn110 Located (Maybe FastString)
x = HappyWrap110 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (Maybe FastString) -> HappyWrap110
HappyWrap110 Located (Maybe FastString)
x)
{-# INLINE happyIn110 #-}
happyOut110 :: (HappyAbsSyn ) -> HappyWrap110
happyOut110 :: HappyAbsSyn -> HappyWrap110
happyOut110 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap110
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut110 #-}
newtype HappyWrap111 = HappyWrap111 (LHsDecl GhcPs)
happyIn111 :: (LHsDecl GhcPs) -> (HappyAbsSyn )
happyIn111 :: LHsDecl GhcPs -> HappyAbsSyn
happyIn111 LHsDecl GhcPs
x = HappyWrap111 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsDecl GhcPs -> HappyWrap111
HappyWrap111 LHsDecl GhcPs
x)
{-# INLINE happyIn111 #-}
happyOut111 :: (HappyAbsSyn ) -> HappyWrap111
happyOut111 :: HappyAbsSyn -> HappyWrap111
happyOut111 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap111
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut111 #-}
newtype HappyWrap112 = HappyWrap112 ((Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn]))
happyIn112 :: ((Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn])) -> (HappyAbsSyn )
happyIn112 :: (Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn])
-> HappyAbsSyn
happyIn112 (Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn])
x = HappyWrap112 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ((Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn])
-> HappyWrap112
HappyWrap112 (Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn])
x)
{-# INLINE happyIn112 #-}
happyOut112 :: (HappyAbsSyn ) -> HappyWrap112
happyOut112 :: HappyAbsSyn -> HappyWrap112
happyOut112 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap112
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut112 #-}
newtype HappyWrap113 = HappyWrap113 ([Located RdrName])
happyIn113 :: ([Located RdrName]) -> (HappyAbsSyn )
happyIn113 :: [Located RdrName] -> HappyAbsSyn
happyIn113 [Located RdrName]
x = HappyWrap113 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([Located RdrName] -> HappyWrap113
HappyWrap113 [Located RdrName]
x)
{-# INLINE happyIn113 #-}
happyOut113 :: (HappyAbsSyn ) -> HappyWrap113
happyOut113 :: HappyAbsSyn -> HappyWrap113
happyOut113 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap113
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut113 #-}
newtype HappyWrap114 = HappyWrap114 ([RecordPatSynField (Located RdrName)])
happyIn114 :: ([RecordPatSynField (Located RdrName)]) -> (HappyAbsSyn )
happyIn114 :: [RecordPatSynField (Located RdrName)] -> HappyAbsSyn
happyIn114 [RecordPatSynField (Located RdrName)]
x = HappyWrap114 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([RecordPatSynField (Located RdrName)] -> HappyWrap114
HappyWrap114 [RecordPatSynField (Located RdrName)]
x)
{-# INLINE happyIn114 #-}
happyOut114 :: (HappyAbsSyn ) -> HappyWrap114
happyOut114 :: HappyAbsSyn -> HappyWrap114
happyOut114 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap114
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut114 #-}
newtype HappyWrap115 = HappyWrap115 (Located ([AddAnn]
                         , Located (OrdList (LHsDecl GhcPs))))
happyIn115 :: (Located ([AddAnn]
                         , Located (OrdList (LHsDecl GhcPs)))) -> (HappyAbsSyn )
happyIn115 :: Located ([AddAnn], Located (OrdList (LHsDecl GhcPs)))
-> HappyAbsSyn
happyIn115 Located ([AddAnn], Located (OrdList (LHsDecl GhcPs)))
x = HappyWrap115 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], Located (OrdList (LHsDecl GhcPs)))
-> HappyWrap115
HappyWrap115 Located ([AddAnn], Located (OrdList (LHsDecl GhcPs)))
x)
{-# INLINE happyIn115 #-}
happyOut115 :: (HappyAbsSyn ) -> HappyWrap115
happyOut115 :: HappyAbsSyn -> HappyWrap115
happyOut115 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap115
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut115 #-}
newtype HappyWrap116 = HappyWrap116 (LSig GhcPs)
happyIn116 :: (LSig GhcPs) -> (HappyAbsSyn )
happyIn116 :: LSig GhcPs -> HappyAbsSyn
happyIn116 LSig GhcPs
x = HappyWrap116 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LSig GhcPs -> HappyWrap116
HappyWrap116 LSig GhcPs
x)
{-# INLINE happyIn116 #-}
happyOut116 :: (HappyAbsSyn ) -> HappyWrap116
happyOut116 :: HappyAbsSyn -> HappyWrap116
happyOut116 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap116
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut116 #-}
newtype HappyWrap117 = HappyWrap117 (LHsDecl GhcPs)
happyIn117 :: (LHsDecl GhcPs) -> (HappyAbsSyn )
happyIn117 :: LHsDecl GhcPs -> HappyAbsSyn
happyIn117 LHsDecl GhcPs
x = HappyWrap117 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsDecl GhcPs -> HappyWrap117
HappyWrap117 LHsDecl GhcPs
x)
{-# INLINE happyIn117 #-}
happyOut117 :: (HappyAbsSyn ) -> HappyWrap117
happyOut117 :: HappyAbsSyn -> HappyWrap117
happyOut117 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 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 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap118
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut118 #-}
newtype HappyWrap119 = HappyWrap119 (Located ([AddAnn]
                     , OrdList (LHsDecl GhcPs)))
happyIn119 :: (Located ([AddAnn]
                     , OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )
happyIn119 :: Located ([AddAnn], OrdList (LHsDecl GhcPs)) -> HappyAbsSyn
happyIn119 Located ([AddAnn], OrdList (LHsDecl GhcPs))
x = HappyWrap119 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], OrdList (LHsDecl GhcPs)) -> HappyWrap119
HappyWrap119 Located ([AddAnn], OrdList (LHsDecl GhcPs))
x)
{-# INLINE happyIn119 #-}
happyOut119 :: (HappyAbsSyn ) -> HappyWrap119
happyOut119 :: HappyAbsSyn -> HappyWrap119
happyOut119 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 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 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap120
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut120 #-}
newtype HappyWrap121 = HappyWrap121 (Located (OrdList (LHsDecl GhcPs)))
happyIn121 :: (Located (OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )
happyIn121 :: Located (OrdList (LHsDecl GhcPs)) -> HappyAbsSyn
happyIn121 Located (OrdList (LHsDecl GhcPs))
x = HappyWrap121 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (OrdList (LHsDecl GhcPs)) -> HappyWrap121
HappyWrap121 Located (OrdList (LHsDecl GhcPs))
x)
{-# INLINE happyIn121 #-}
happyOut121 :: (HappyAbsSyn ) -> HappyWrap121
happyOut121 :: HappyAbsSyn -> HappyWrap121
happyOut121 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 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 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 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 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap123
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut123 #-}
newtype HappyWrap124 = HappyWrap124 (Located ([AddAnn]
                        , OrdList (LHsDecl GhcPs)))
happyIn124 :: (Located ([AddAnn]
                        , OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )
happyIn124 :: Located ([AddAnn], OrdList (LHsDecl GhcPs)) -> HappyAbsSyn
happyIn124 Located ([AddAnn], OrdList (LHsDecl GhcPs))
x = HappyWrap124 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], OrdList (LHsDecl GhcPs)) -> HappyWrap124
HappyWrap124 Located ([AddAnn], OrdList (LHsDecl GhcPs))
x)
{-# INLINE happyIn124 #-}
happyOut124 :: (HappyAbsSyn ) -> HappyWrap124
happyOut124 :: HappyAbsSyn -> HappyWrap124
happyOut124 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap124
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut124 #-}
newtype HappyWrap125 = HappyWrap125 (Located ([AddAnn],OrdList (LHsDecl GhcPs)))
happyIn125 :: (Located ([AddAnn],OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )
happyIn125 :: Located ([AddAnn], OrdList (LHsDecl GhcPs)) -> HappyAbsSyn
happyIn125 Located ([AddAnn], OrdList (LHsDecl GhcPs))
x = HappyWrap125 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], OrdList (LHsDecl GhcPs)) -> HappyWrap125
HappyWrap125 Located ([AddAnn], OrdList (LHsDecl GhcPs))
x)
{-# INLINE happyIn125 #-}
happyOut125 :: (HappyAbsSyn ) -> HappyWrap125
happyOut125 :: HappyAbsSyn -> HappyWrap125
happyOut125 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap125
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut125 #-}
newtype HappyWrap126 = HappyWrap126 (Located ([AddAnn],Located (OrdList (LHsDecl GhcPs))))
happyIn126 :: (Located ([AddAnn],Located (OrdList (LHsDecl GhcPs)))) -> (HappyAbsSyn )
happyIn126 :: Located ([AddAnn], Located (OrdList (LHsDecl GhcPs)))
-> HappyAbsSyn
happyIn126 Located ([AddAnn], Located (OrdList (LHsDecl GhcPs)))
x = HappyWrap126 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], Located (OrdList (LHsDecl GhcPs)))
-> HappyWrap126
HappyWrap126 Located ([AddAnn], Located (OrdList (LHsDecl GhcPs)))
x)
{-# INLINE happyIn126 #-}
happyOut126 :: (HappyAbsSyn ) -> HappyWrap126
happyOut126 :: HappyAbsSyn -> HappyWrap126
happyOut126 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap126
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut126 #-}
newtype HappyWrap127 = HappyWrap127 (Located ([AddAnn],Located (HsLocalBinds GhcPs)))
happyIn127 :: (Located ([AddAnn],Located (HsLocalBinds GhcPs))) -> (HappyAbsSyn )
happyIn127 :: Located ([AddAnn], Located (HsLocalBinds GhcPs)) -> HappyAbsSyn
happyIn127 Located ([AddAnn], Located (HsLocalBinds GhcPs))
x = HappyWrap127 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], Located (HsLocalBinds GhcPs)) -> HappyWrap127
HappyWrap127 Located ([AddAnn], Located (HsLocalBinds GhcPs))
x)
{-# INLINE happyIn127 #-}
happyOut127 :: (HappyAbsSyn ) -> HappyWrap127
happyOut127 :: HappyAbsSyn -> HappyWrap127
happyOut127 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap127
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut127 #-}
newtype HappyWrap128 = HappyWrap128 (Located ([AddAnn],Located (HsLocalBinds GhcPs)))
happyIn128 :: (Located ([AddAnn],Located (HsLocalBinds GhcPs))) -> (HappyAbsSyn )
happyIn128 :: Located ([AddAnn], Located (HsLocalBinds GhcPs)) -> HappyAbsSyn
happyIn128 Located ([AddAnn], Located (HsLocalBinds GhcPs))
x = HappyWrap128 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], Located (HsLocalBinds GhcPs)) -> HappyWrap128
HappyWrap128 Located ([AddAnn], Located (HsLocalBinds GhcPs))
x)
{-# INLINE happyIn128 #-}
happyOut128 :: (HappyAbsSyn ) -> HappyWrap128
happyOut128 :: HappyAbsSyn -> HappyWrap128
happyOut128 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap128
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut128 #-}
newtype HappyWrap129 = HappyWrap129 (OrdList (LRuleDecl GhcPs))
happyIn129 :: (OrdList (LRuleDecl GhcPs)) -> (HappyAbsSyn )
happyIn129 :: OrdList (LRuleDecl GhcPs) -> HappyAbsSyn
happyIn129 OrdList (LRuleDecl GhcPs)
x = HappyWrap129 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList (LRuleDecl GhcPs) -> HappyWrap129
HappyWrap129 OrdList (LRuleDecl GhcPs)
x)
{-# INLINE happyIn129 #-}
happyOut129 :: (HappyAbsSyn ) -> HappyWrap129
happyOut129 :: HappyAbsSyn -> HappyWrap129
happyOut129 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap129
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut129 #-}
newtype HappyWrap130 = HappyWrap130 (LRuleDecl GhcPs)
happyIn130 :: (LRuleDecl GhcPs) -> (HappyAbsSyn )
happyIn130 :: LRuleDecl GhcPs -> HappyAbsSyn
happyIn130 LRuleDecl GhcPs
x = HappyWrap130 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LRuleDecl GhcPs -> HappyWrap130
HappyWrap130 LRuleDecl GhcPs
x)
{-# INLINE happyIn130 #-}
happyOut130 :: (HappyAbsSyn ) -> HappyWrap130
happyOut130 :: HappyAbsSyn -> HappyWrap130
happyOut130 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap130
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut130 #-}
newtype HappyWrap131 = HappyWrap131 (([AddAnn],Maybe Activation))
happyIn131 :: (([AddAnn],Maybe Activation)) -> (HappyAbsSyn )
happyIn131 :: ([AddAnn], Maybe Activation) -> HappyAbsSyn
happyIn131 ([AddAnn], Maybe Activation)
x = HappyWrap131 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], Maybe Activation) -> HappyWrap131
HappyWrap131 ([AddAnn], Maybe Activation)
x)
{-# INLINE happyIn131 #-}
happyOut131 :: (HappyAbsSyn ) -> HappyWrap131
happyOut131 :: HappyAbsSyn -> HappyWrap131
happyOut131 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap131
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut131 #-}
newtype HappyWrap132 = HappyWrap132 (([AddAnn]
                              ,Activation))
happyIn132 :: (([AddAnn]
                              ,Activation)) -> (HappyAbsSyn )
happyIn132 :: ([AddAnn], Activation) -> HappyAbsSyn
happyIn132 ([AddAnn], Activation)
x = HappyWrap132 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], Activation) -> HappyWrap132
HappyWrap132 ([AddAnn], Activation)
x)
{-# INLINE happyIn132 #-}
happyOut132 :: (HappyAbsSyn ) -> HappyWrap132
happyOut132 :: HappyAbsSyn -> HappyWrap132
happyOut132 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap132
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut132 #-}
newtype HappyWrap133 = HappyWrap133 (([AddAnn], Maybe [LHsTyVarBndr GhcPs], [LRuleBndr GhcPs]))
happyIn133 :: (([AddAnn], Maybe [LHsTyVarBndr GhcPs], [LRuleBndr GhcPs])) -> (HappyAbsSyn )
happyIn133 :: ([AddAnn], Maybe [LHsTyVarBndr GhcPs], [LRuleBndr GhcPs])
-> HappyAbsSyn
happyIn133 ([AddAnn], Maybe [LHsTyVarBndr GhcPs], [LRuleBndr GhcPs])
x = HappyWrap133 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], Maybe [LHsTyVarBndr GhcPs], [LRuleBndr GhcPs])
-> HappyWrap133
HappyWrap133 ([AddAnn], Maybe [LHsTyVarBndr GhcPs], [LRuleBndr GhcPs])
x)
{-# INLINE happyIn133 #-}
happyOut133 :: (HappyAbsSyn ) -> HappyWrap133
happyOut133 :: HappyAbsSyn -> HappyWrap133
happyOut133 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap133
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut133 #-}
newtype HappyWrap134 = HappyWrap134 ([LRuleTyTmVar])
happyIn134 :: ([LRuleTyTmVar]) -> (HappyAbsSyn )
happyIn134 :: [LRuleTyTmVar] -> HappyAbsSyn
happyIn134 [LRuleTyTmVar]
x = HappyWrap134 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LRuleTyTmVar] -> HappyWrap134
HappyWrap134 [LRuleTyTmVar]
x)
{-# INLINE happyIn134 #-}
happyOut134 :: (HappyAbsSyn ) -> HappyWrap134
happyOut134 :: HappyAbsSyn -> HappyWrap134
happyOut134 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap134
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut134 #-}
newtype HappyWrap135 = HappyWrap135 (LRuleTyTmVar)
happyIn135 :: (LRuleTyTmVar) -> (HappyAbsSyn )
happyIn135 :: LRuleTyTmVar -> HappyAbsSyn
happyIn135 LRuleTyTmVar
x = HappyWrap135 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LRuleTyTmVar -> HappyWrap135
HappyWrap135 LRuleTyTmVar
x)
{-# INLINE happyIn135 #-}
happyOut135 :: (HappyAbsSyn ) -> HappyWrap135
happyOut135 :: HappyAbsSyn -> HappyWrap135
happyOut135 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 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 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 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 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap137
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut137 #-}
newtype HappyWrap138 = HappyWrap138 (OrdList (LWarnDecl GhcPs))
happyIn138 :: (OrdList (LWarnDecl GhcPs)) -> (HappyAbsSyn )
happyIn138 :: OrdList (LWarnDecl GhcPs) -> HappyAbsSyn
happyIn138 OrdList (LWarnDecl GhcPs)
x = HappyWrap138 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList (LWarnDecl GhcPs) -> HappyWrap138
HappyWrap138 OrdList (LWarnDecl GhcPs)
x)
{-# INLINE happyIn138 #-}
happyOut138 :: (HappyAbsSyn ) -> HappyWrap138
happyOut138 :: HappyAbsSyn -> HappyWrap138
happyOut138 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap138
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut138 #-}
newtype HappyWrap139 = HappyWrap139 (OrdList (LWarnDecl GhcPs))
happyIn139 :: (OrdList (LWarnDecl GhcPs)) -> (HappyAbsSyn )
happyIn139 :: OrdList (LWarnDecl GhcPs) -> HappyAbsSyn
happyIn139 OrdList (LWarnDecl GhcPs)
x = HappyWrap139 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList (LWarnDecl GhcPs) -> HappyWrap139
HappyWrap139 OrdList (LWarnDecl GhcPs)
x)
{-# INLINE happyIn139 #-}
happyOut139 :: (HappyAbsSyn ) -> HappyWrap139
happyOut139 :: HappyAbsSyn -> HappyWrap139
happyOut139 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap139
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut139 #-}
newtype HappyWrap140 = HappyWrap140 (Located ([AddAnn],[Located StringLiteral]))
happyIn140 :: (Located ([AddAnn],[Located StringLiteral])) -> (HappyAbsSyn )
happyIn140 :: Located ([AddAnn], [Located StringLiteral]) -> HappyAbsSyn
happyIn140 Located ([AddAnn], [Located StringLiteral])
x = HappyWrap140 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], [Located StringLiteral]) -> HappyWrap140
HappyWrap140 Located ([AddAnn], [Located StringLiteral])
x)
{-# INLINE happyIn140 #-}
happyOut140 :: (HappyAbsSyn ) -> HappyWrap140
happyOut140 :: HappyAbsSyn -> HappyWrap140
happyOut140 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap140
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut140 #-}
newtype HappyWrap141 = HappyWrap141 (Located (OrdList (Located StringLiteral)))
happyIn141 :: (Located (OrdList (Located StringLiteral))) -> (HappyAbsSyn )
happyIn141 :: Located (OrdList (Located StringLiteral)) -> HappyAbsSyn
happyIn141 Located (OrdList (Located StringLiteral))
x = HappyWrap141 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (OrdList (Located StringLiteral)) -> HappyWrap141
HappyWrap141 Located (OrdList (Located StringLiteral))
x)
{-# INLINE happyIn141 #-}
happyOut141 :: (HappyAbsSyn ) -> HappyWrap141
happyOut141 :: HappyAbsSyn -> HappyWrap141
happyOut141 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap141
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut141 #-}
newtype HappyWrap142 = HappyWrap142 (LHsDecl GhcPs)
happyIn142 :: (LHsDecl GhcPs) -> (HappyAbsSyn )
happyIn142 :: LHsDecl GhcPs -> HappyAbsSyn
happyIn142 LHsDecl GhcPs
x = HappyWrap142 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsDecl GhcPs -> HappyWrap142
HappyWrap142 LHsDecl GhcPs
x)
{-# INLINE happyIn142 #-}
happyOut142 :: (HappyAbsSyn ) -> HappyWrap142
happyOut142 :: HappyAbsSyn -> HappyWrap142
happyOut142 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap142
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut142 #-}
newtype HappyWrap143 = HappyWrap143 (Located ([AddAnn],HsDecl GhcPs))
happyIn143 :: (Located ([AddAnn],HsDecl GhcPs)) -> (HappyAbsSyn )
happyIn143 :: Located ([AddAnn], HsDecl GhcPs) -> HappyAbsSyn
happyIn143 Located ([AddAnn], HsDecl GhcPs)
x = HappyWrap143 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], HsDecl GhcPs) -> HappyWrap143
HappyWrap143 Located ([AddAnn], HsDecl GhcPs)
x)
{-# INLINE happyIn143 #-}
happyOut143 :: (HappyAbsSyn ) -> HappyWrap143
happyOut143 :: HappyAbsSyn -> HappyWrap143
happyOut143 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap143
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut143 #-}
newtype HappyWrap144 = HappyWrap144 (Located CCallConv)
happyIn144 :: (Located CCallConv) -> (HappyAbsSyn )
happyIn144 :: Located CCallConv -> HappyAbsSyn
happyIn144 Located CCallConv
x = HappyWrap144 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located CCallConv -> HappyWrap144
HappyWrap144 Located CCallConv
x)
{-# INLINE happyIn144 #-}
happyOut144 :: (HappyAbsSyn ) -> HappyWrap144
happyOut144 :: HappyAbsSyn -> HappyWrap144
happyOut144 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap144
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut144 #-}
newtype HappyWrap145 = HappyWrap145 (Located Safety)
happyIn145 :: (Located Safety) -> (HappyAbsSyn )
happyIn145 :: Located Safety -> HappyAbsSyn
happyIn145 Located Safety
x = HappyWrap145 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located Safety -> HappyWrap145
HappyWrap145 Located Safety
x)
{-# INLINE happyIn145 #-}
happyOut145 :: (HappyAbsSyn ) -> HappyWrap145
happyOut145 :: HappyAbsSyn -> HappyWrap145
happyOut145 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap145
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut145 #-}
newtype HappyWrap146 = HappyWrap146 (Located ([AddAnn]
                    ,(Located StringLiteral, Located RdrName, LHsSigType GhcPs)))
happyIn146 :: (Located ([AddAnn]
                    ,(Located StringLiteral, Located RdrName, LHsSigType GhcPs))) -> (HappyAbsSyn )
happyIn146 :: Located
  ([AddAnn],
   (Located StringLiteral, Located RdrName, LHsSigType GhcPs))
-> HappyAbsSyn
happyIn146 Located
  ([AddAnn],
   (Located StringLiteral, Located RdrName, LHsSigType GhcPs))
x = HappyWrap146 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located
  ([AddAnn],
   (Located StringLiteral, Located RdrName, LHsSigType GhcPs))
-> HappyWrap146
HappyWrap146 Located
  ([AddAnn],
   (Located StringLiteral, Located RdrName, LHsSigType GhcPs))
x)
{-# INLINE happyIn146 #-}
happyOut146 :: (HappyAbsSyn ) -> HappyWrap146
happyOut146 :: HappyAbsSyn -> HappyWrap146
happyOut146 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap146
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut146 #-}
newtype HappyWrap147 = HappyWrap147 (([AddAnn], Maybe (LHsType GhcPs)))
happyIn147 :: (([AddAnn], Maybe (LHsType GhcPs))) -> (HappyAbsSyn )
happyIn147 :: ([AddAnn], Maybe (LHsKind GhcPs)) -> HappyAbsSyn
happyIn147 ([AddAnn], Maybe (LHsKind GhcPs))
x = HappyWrap147 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], Maybe (LHsKind GhcPs)) -> HappyWrap147
HappyWrap147 ([AddAnn], Maybe (LHsKind GhcPs))
x)
{-# INLINE happyIn147 #-}
happyOut147 :: (HappyAbsSyn ) -> HappyWrap147
happyOut147 :: HappyAbsSyn -> HappyWrap147
happyOut147 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap147
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut147 #-}
newtype HappyWrap148 = HappyWrap148 (([AddAnn], Maybe (Located RdrName)))
happyIn148 :: (([AddAnn], Maybe (Located RdrName))) -> (HappyAbsSyn )
happyIn148 :: ([AddAnn], Maybe (Located RdrName)) -> HappyAbsSyn
happyIn148 ([AddAnn], Maybe (Located RdrName))
x = HappyWrap148 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], Maybe (Located RdrName)) -> HappyWrap148
HappyWrap148 ([AddAnn], Maybe (Located RdrName))
x)
{-# INLINE happyIn148 #-}
happyOut148 :: (HappyAbsSyn ) -> HappyWrap148
happyOut148 :: HappyAbsSyn -> HappyWrap148
happyOut148 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap148
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut148 #-}
newtype HappyWrap149 = HappyWrap149 (LHsType GhcPs)
happyIn149 :: (LHsType GhcPs) -> (HappyAbsSyn )
happyIn149 :: LHsKind GhcPs -> HappyAbsSyn
happyIn149 LHsKind GhcPs
x = HappyWrap149 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsKind GhcPs -> HappyWrap149
HappyWrap149 LHsKind GhcPs
x)
{-# INLINE happyIn149 #-}
happyOut149 :: (HappyAbsSyn ) -> HappyWrap149
happyOut149 :: HappyAbsSyn -> HappyWrap149
happyOut149 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap149
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut149 #-}
newtype HappyWrap150 = HappyWrap150 (LHsType GhcPs)
happyIn150 :: (LHsType GhcPs) -> (HappyAbsSyn )
happyIn150 :: LHsKind GhcPs -> HappyAbsSyn
happyIn150 LHsKind GhcPs
x = HappyWrap150 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsKind GhcPs -> HappyWrap150
HappyWrap150 LHsKind GhcPs
x)
{-# INLINE happyIn150 #-}
happyOut150 :: (HappyAbsSyn ) -> HappyWrap150
happyOut150 :: HappyAbsSyn -> HappyWrap150
happyOut150 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap150
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut150 #-}
newtype HappyWrap151 = HappyWrap151 (Located [Located RdrName])
happyIn151 :: (Located [Located RdrName]) -> (HappyAbsSyn )
happyIn151 :: Located [Located RdrName] -> HappyAbsSyn
happyIn151 Located [Located RdrName]
x = HappyWrap151 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [Located RdrName] -> HappyWrap151
HappyWrap151 Located [Located RdrName]
x)
{-# INLINE happyIn151 #-}
happyOut151 :: (HappyAbsSyn ) -> HappyWrap151
happyOut151 :: HappyAbsSyn -> HappyWrap151
happyOut151 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap151
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut151 #-}
newtype HappyWrap152 = HappyWrap152 ((OrdList (LHsSigType GhcPs)))
happyIn152 :: ((OrdList (LHsSigType GhcPs))) -> (HappyAbsSyn )
happyIn152 :: OrdList (LHsSigType GhcPs) -> HappyAbsSyn
happyIn152 OrdList (LHsSigType GhcPs)
x = HappyWrap152 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList (LHsSigType GhcPs) -> HappyWrap152
HappyWrap152 OrdList (LHsSigType GhcPs)
x)
{-# INLINE happyIn152 #-}
happyOut152 :: (HappyAbsSyn ) -> HappyWrap152
happyOut152 :: HappyAbsSyn -> HappyWrap152
happyOut152 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap152
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut152 #-}
newtype HappyWrap153 = HappyWrap153 (Located ([AddAnn], SourceText, SrcUnpackedness))
happyIn153 :: (Located ([AddAnn], SourceText, SrcUnpackedness)) -> (HappyAbsSyn )
happyIn153 :: Located ([AddAnn], SourceText, SrcUnpackedness) -> HappyAbsSyn
happyIn153 Located ([AddAnn], SourceText, SrcUnpackedness)
x = HappyWrap153 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], SourceText, SrcUnpackedness) -> HappyWrap153
HappyWrap153 Located ([AddAnn], SourceText, SrcUnpackedness)
x)
{-# INLINE happyIn153 #-}
happyOut153 :: (HappyAbsSyn ) -> HappyWrap153
happyOut153 :: HappyAbsSyn -> HappyWrap153
happyOut153 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap153
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut153 #-}
newtype HappyWrap154 = HappyWrap154 ((AddAnn, ForallVisFlag))
happyIn154 :: ((AddAnn, ForallVisFlag)) -> (HappyAbsSyn )
happyIn154 :: (AddAnn, ForallVisFlag) -> HappyAbsSyn
happyIn154 (AddAnn, ForallVisFlag)
x = HappyWrap154 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ((AddAnn, ForallVisFlag) -> HappyWrap154
HappyWrap154 (AddAnn, ForallVisFlag)
x)
{-# INLINE happyIn154 #-}
happyOut154 :: (HappyAbsSyn ) -> HappyWrap154
happyOut154 :: HappyAbsSyn -> HappyWrap154
happyOut154 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 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 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap155
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut155 #-}
newtype HappyWrap156 = HappyWrap156 (LHsType GhcPs)
happyIn156 :: (LHsType GhcPs) -> (HappyAbsSyn )
happyIn156 :: LHsKind GhcPs -> HappyAbsSyn
happyIn156 LHsKind GhcPs
x = HappyWrap156 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsKind GhcPs -> HappyWrap156
HappyWrap156 LHsKind GhcPs
x)
{-# INLINE happyIn156 #-}
happyOut156 :: (HappyAbsSyn ) -> HappyWrap156
happyOut156 :: HappyAbsSyn -> HappyWrap156
happyOut156 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap156
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut156 #-}
newtype HappyWrap157 = HappyWrap157 (LHsType GhcPs)
happyIn157 :: (LHsType GhcPs) -> (HappyAbsSyn )
happyIn157 :: LHsKind GhcPs -> HappyAbsSyn
happyIn157 LHsKind GhcPs
x = HappyWrap157 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsKind GhcPs -> HappyWrap157
HappyWrap157 LHsKind GhcPs
x)
{-# INLINE happyIn157 #-}
happyOut157 :: (HappyAbsSyn ) -> HappyWrap157
happyOut157 :: HappyAbsSyn -> HappyWrap157
happyOut157 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 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 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap158
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut158 #-}
newtype HappyWrap159 = HappyWrap159 (LHsContext GhcPs)
happyIn159 :: (LHsContext GhcPs) -> (HappyAbsSyn )
happyIn159 :: LHsContext GhcPs -> HappyAbsSyn
happyIn159 LHsContext GhcPs
x = HappyWrap159 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsContext GhcPs -> HappyWrap159
HappyWrap159 LHsContext GhcPs
x)
{-# INLINE happyIn159 #-}
happyOut159 :: (HappyAbsSyn ) -> HappyWrap159
happyOut159 :: HappyAbsSyn -> HappyWrap159
happyOut159 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap159
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut159 #-}
newtype HappyWrap160 = HappyWrap160 (LHsContext GhcPs)
happyIn160 :: (LHsContext GhcPs) -> (HappyAbsSyn )
happyIn160 :: LHsContext GhcPs -> HappyAbsSyn
happyIn160 LHsContext GhcPs
x = HappyWrap160 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsContext GhcPs -> HappyWrap160
HappyWrap160 LHsContext GhcPs
x)
{-# INLINE happyIn160 #-}
happyOut160 :: (HappyAbsSyn ) -> HappyWrap160
happyOut160 :: HappyAbsSyn -> HappyWrap160
happyOut160 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap160
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut160 #-}
newtype HappyWrap161 = HappyWrap161 (LHsType GhcPs)
happyIn161 :: (LHsType GhcPs) -> (HappyAbsSyn )
happyIn161 :: LHsKind GhcPs -> HappyAbsSyn
happyIn161 LHsKind GhcPs
x = HappyWrap161 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsKind GhcPs -> HappyWrap161
HappyWrap161 LHsKind GhcPs
x)
{-# INLINE happyIn161 #-}
happyOut161 :: (HappyAbsSyn ) -> HappyWrap161
happyOut161 :: HappyAbsSyn -> HappyWrap161
happyOut161 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap161
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut161 #-}
newtype HappyWrap162 = HappyWrap162 (LHsType GhcPs)
happyIn162 :: (LHsType GhcPs) -> (HappyAbsSyn )
happyIn162 :: LHsKind GhcPs -> HappyAbsSyn
happyIn162 LHsKind GhcPs
x = HappyWrap162 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsKind GhcPs -> HappyWrap162
HappyWrap162 LHsKind GhcPs
x)
{-# INLINE happyIn162 #-}
happyOut162 :: (HappyAbsSyn ) -> HappyWrap162
happyOut162 :: HappyAbsSyn -> HappyWrap162
happyOut162 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 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 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap163
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut163 #-}
newtype HappyWrap164 = HappyWrap164 (Located [Located TyEl])
happyIn164 :: (Located [Located TyEl]) -> (HappyAbsSyn )
happyIn164 :: Located [Located TyEl] -> HappyAbsSyn
happyIn164 Located [Located TyEl]
x = HappyWrap164 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [Located TyEl] -> HappyWrap164
HappyWrap164 Located [Located TyEl]
x)
{-# INLINE happyIn164 #-}
happyOut164 :: (HappyAbsSyn ) -> HappyWrap164
happyOut164 :: HappyAbsSyn -> HappyWrap164
happyOut164 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 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 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 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 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap166
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut166 #-}
newtype HappyWrap167 = HappyWrap167 ([Located TyEl])
happyIn167 :: ([Located TyEl]) -> (HappyAbsSyn )
happyIn167 :: [Located TyEl] -> HappyAbsSyn
happyIn167 [Located TyEl]
x = HappyWrap167 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([Located TyEl] -> HappyWrap167
HappyWrap167 [Located TyEl]
x)
{-# INLINE happyIn167 #-}
happyOut167 :: (HappyAbsSyn ) -> HappyWrap167
happyOut167 :: HappyAbsSyn -> HappyWrap167
happyOut167 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap167
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut167 #-}
newtype HappyWrap168 = HappyWrap168 (Located TyEl)
happyIn168 :: (Located TyEl) -> (HappyAbsSyn )
happyIn168 :: Located TyEl -> HappyAbsSyn
happyIn168 Located TyEl
x = HappyWrap168 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located TyEl -> HappyWrap168
HappyWrap168 Located TyEl
x)
{-# INLINE happyIn168 #-}
happyOut168 :: (HappyAbsSyn ) -> HappyWrap168
happyOut168 :: HappyAbsSyn -> HappyWrap168
happyOut168 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 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 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap169
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut169 #-}
newtype HappyWrap170 = HappyWrap170 (LHsSigType GhcPs)
happyIn170 :: (LHsSigType GhcPs) -> (HappyAbsSyn )
happyIn170 :: LHsSigType GhcPs -> HappyAbsSyn
happyIn170 LHsSigType GhcPs
x = HappyWrap170 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsSigType GhcPs -> HappyWrap170
HappyWrap170 LHsSigType GhcPs
x)
{-# INLINE happyIn170 #-}
happyOut170 :: (HappyAbsSyn ) -> HappyWrap170
happyOut170 :: HappyAbsSyn -> HappyWrap170
happyOut170 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap170
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut170 #-}
newtype HappyWrap171 = HappyWrap171 ([LHsSigType GhcPs])
happyIn171 :: ([LHsSigType GhcPs]) -> (HappyAbsSyn )
happyIn171 :: [LHsSigType GhcPs] -> HappyAbsSyn
happyIn171 [LHsSigType GhcPs]
x = HappyWrap171 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LHsSigType GhcPs] -> HappyWrap171
HappyWrap171 [LHsSigType GhcPs]
x)
{-# INLINE happyIn171 #-}
happyOut171 :: (HappyAbsSyn ) -> HappyWrap171
happyOut171 :: HappyAbsSyn -> HappyWrap171
happyOut171 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap171
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut171 #-}
newtype HappyWrap172 = HappyWrap172 ([LHsType GhcPs])
happyIn172 :: ([LHsType GhcPs]) -> (HappyAbsSyn )
happyIn172 :: [LHsKind GhcPs] -> HappyAbsSyn
happyIn172 [LHsKind GhcPs]
x = HappyWrap172 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LHsKind GhcPs] -> HappyWrap172
HappyWrap172 [LHsKind GhcPs]
x)
{-# INLINE happyIn172 #-}
happyOut172 :: (HappyAbsSyn ) -> HappyWrap172
happyOut172 :: HappyAbsSyn -> HappyWrap172
happyOut172 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap172
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut172 #-}
newtype HappyWrap173 = HappyWrap173 ([LHsType GhcPs])
happyIn173 :: ([LHsType GhcPs]) -> (HappyAbsSyn )
happyIn173 :: [LHsKind GhcPs] -> HappyAbsSyn
happyIn173 [LHsKind GhcPs]
x = HappyWrap173 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LHsKind GhcPs] -> HappyWrap173
HappyWrap173 [LHsKind GhcPs]
x)
{-# INLINE happyIn173 #-}
happyOut173 :: (HappyAbsSyn ) -> HappyWrap173
happyOut173 :: HappyAbsSyn -> HappyWrap173
happyOut173 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap173
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut173 #-}
newtype HappyWrap174 = HappyWrap174 ([LHsType GhcPs])
happyIn174 :: ([LHsType GhcPs]) -> (HappyAbsSyn )
happyIn174 :: [LHsKind GhcPs] -> HappyAbsSyn
happyIn174 [LHsKind GhcPs]
x = HappyWrap174 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LHsKind GhcPs] -> HappyWrap174
HappyWrap174 [LHsKind GhcPs]
x)
{-# INLINE happyIn174 #-}
happyOut174 :: (HappyAbsSyn ) -> HappyWrap174
happyOut174 :: HappyAbsSyn -> HappyWrap174
happyOut174 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap174
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut174 #-}
newtype HappyWrap175 = HappyWrap175 ([LHsTyVarBndr GhcPs])
happyIn175 :: ([LHsTyVarBndr GhcPs]) -> (HappyAbsSyn )
happyIn175 :: [LHsTyVarBndr GhcPs] -> HappyAbsSyn
happyIn175 [LHsTyVarBndr GhcPs]
x = HappyWrap175 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LHsTyVarBndr GhcPs] -> HappyWrap175
HappyWrap175 [LHsTyVarBndr GhcPs]
x)
{-# INLINE happyIn175 #-}
happyOut175 :: (HappyAbsSyn ) -> HappyWrap175
happyOut175 :: HappyAbsSyn -> HappyWrap175
happyOut175 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap175
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut175 #-}
newtype HappyWrap176 = HappyWrap176 (LHsTyVarBndr GhcPs)
happyIn176 :: (LHsTyVarBndr GhcPs) -> (HappyAbsSyn )
happyIn176 :: LHsTyVarBndr GhcPs -> HappyAbsSyn
happyIn176 LHsTyVarBndr GhcPs
x = HappyWrap176 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsTyVarBndr GhcPs -> HappyWrap176
HappyWrap176 LHsTyVarBndr GhcPs
x)
{-# INLINE happyIn176 #-}
happyOut176 :: (HappyAbsSyn ) -> HappyWrap176
happyOut176 :: HappyAbsSyn -> HappyWrap176
happyOut176 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap176
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut176 #-}
newtype HappyWrap177 = HappyWrap177 (Located ([AddAnn],[Located (FunDep (Located RdrName))]))
happyIn177 :: (Located ([AddAnn],[Located (FunDep (Located RdrName))])) -> (HappyAbsSyn )
happyIn177 :: Located ([AddAnn], [Located (FunDep (Located RdrName))])
-> HappyAbsSyn
happyIn177 Located ([AddAnn], [Located (FunDep (Located RdrName))])
x = HappyWrap177 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], [Located (FunDep (Located RdrName))])
-> HappyWrap177
HappyWrap177 Located ([AddAnn], [Located (FunDep (Located RdrName))])
x)
{-# INLINE happyIn177 #-}
happyOut177 :: (HappyAbsSyn ) -> HappyWrap177
happyOut177 :: HappyAbsSyn -> HappyWrap177
happyOut177 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap177
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut177 #-}
newtype HappyWrap178 = HappyWrap178 (Located [Located (FunDep (Located RdrName))])
happyIn178 :: (Located [Located (FunDep (Located RdrName))]) -> (HappyAbsSyn )
happyIn178 :: Located [Located (FunDep (Located RdrName))] -> HappyAbsSyn
happyIn178 Located [Located (FunDep (Located RdrName))]
x = HappyWrap178 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [Located (FunDep (Located RdrName))] -> HappyWrap178
HappyWrap178 Located [Located (FunDep (Located RdrName))]
x)
{-# INLINE happyIn178 #-}
happyOut178 :: (HappyAbsSyn ) -> HappyWrap178
happyOut178 :: HappyAbsSyn -> HappyWrap178
happyOut178 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap178
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut178 #-}
newtype HappyWrap179 = HappyWrap179 (Located (FunDep (Located RdrName)))
happyIn179 :: (Located (FunDep (Located RdrName))) -> (HappyAbsSyn )
happyIn179 :: Located (FunDep (Located RdrName)) -> HappyAbsSyn
happyIn179 Located (FunDep (Located RdrName))
x = HappyWrap179 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (FunDep (Located RdrName)) -> HappyWrap179
HappyWrap179 Located (FunDep (Located RdrName))
x)
{-# INLINE happyIn179 #-}
happyOut179 :: (HappyAbsSyn ) -> HappyWrap179
happyOut179 :: HappyAbsSyn -> HappyWrap179
happyOut179 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap179
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut179 #-}
newtype HappyWrap180 = HappyWrap180 (Located [Located RdrName])
happyIn180 :: (Located [Located RdrName]) -> (HappyAbsSyn )
happyIn180 :: Located [Located RdrName] -> HappyAbsSyn
happyIn180 Located [Located RdrName]
x = HappyWrap180 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [Located RdrName] -> HappyWrap180
HappyWrap180 Located [Located RdrName]
x)
{-# INLINE happyIn180 #-}
happyOut180 :: (HappyAbsSyn ) -> HappyWrap180
happyOut180 :: HappyAbsSyn -> HappyWrap180
happyOut180 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap180
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut180 #-}
newtype HappyWrap181 = HappyWrap181 (LHsKind GhcPs)
happyIn181 :: (LHsKind GhcPs) -> (HappyAbsSyn )
happyIn181 :: LHsKind GhcPs -> HappyAbsSyn
happyIn181 LHsKind GhcPs
x = HappyWrap181 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsKind GhcPs -> HappyWrap181
HappyWrap181 LHsKind GhcPs
x)
{-# INLINE happyIn181 #-}
happyOut181 :: (HappyAbsSyn ) -> HappyWrap181
happyOut181 :: HappyAbsSyn -> HappyWrap181
happyOut181 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap181
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut181 #-}
newtype HappyWrap182 = HappyWrap182 (Located ([AddAnn]
                          ,[LConDecl GhcPs]))
happyIn182 :: (Located ([AddAnn]
                          ,[LConDecl GhcPs])) -> (HappyAbsSyn )
happyIn182 :: Located ([AddAnn], [LConDecl GhcPs]) -> HappyAbsSyn
happyIn182 Located ([AddAnn], [LConDecl GhcPs])
x = HappyWrap182 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], [LConDecl GhcPs]) -> HappyWrap182
HappyWrap182 Located ([AddAnn], [LConDecl GhcPs])
x)
{-# INLINE happyIn182 #-}
happyOut182 :: (HappyAbsSyn ) -> HappyWrap182
happyOut182 :: HappyAbsSyn -> HappyWrap182
happyOut182 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap182
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut182 #-}
newtype HappyWrap183 = HappyWrap183 (Located [LConDecl GhcPs])
happyIn183 :: (Located [LConDecl GhcPs]) -> (HappyAbsSyn )
happyIn183 :: Located [LConDecl GhcPs] -> HappyAbsSyn
happyIn183 Located [LConDecl GhcPs]
x = HappyWrap183 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [LConDecl GhcPs] -> HappyWrap183
HappyWrap183 Located [LConDecl GhcPs]
x)
{-# INLINE happyIn183 #-}
happyOut183 :: (HappyAbsSyn ) -> HappyWrap183
happyOut183 :: HappyAbsSyn -> HappyWrap183
happyOut183 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap183
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut183 #-}
newtype HappyWrap184 = HappyWrap184 (LConDecl GhcPs)
happyIn184 :: (LConDecl GhcPs) -> (HappyAbsSyn )
happyIn184 :: LConDecl GhcPs -> HappyAbsSyn
happyIn184 LConDecl GhcPs
x = HappyWrap184 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LConDecl GhcPs -> HappyWrap184
HappyWrap184 LConDecl GhcPs
x)
{-# INLINE happyIn184 #-}
happyOut184 :: (HappyAbsSyn ) -> HappyWrap184
happyOut184 :: HappyAbsSyn -> HappyWrap184
happyOut184 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 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 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap185
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut185 #-}
newtype HappyWrap186 = HappyWrap186 (Located ([AddAnn],[LConDecl GhcPs]))
happyIn186 :: (Located ([AddAnn],[LConDecl GhcPs])) -> (HappyAbsSyn )
happyIn186 :: Located ([AddAnn], [LConDecl GhcPs]) -> HappyAbsSyn
happyIn186 Located ([AddAnn], [LConDecl GhcPs])
x = HappyWrap186 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], [LConDecl GhcPs]) -> HappyWrap186
HappyWrap186 Located ([AddAnn], [LConDecl GhcPs])
x)
{-# INLINE happyIn186 #-}
happyOut186 :: (HappyAbsSyn ) -> HappyWrap186
happyOut186 :: HappyAbsSyn -> HappyWrap186
happyOut186 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap186
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut186 #-}
newtype HappyWrap187 = HappyWrap187 (Located [LConDecl GhcPs])
happyIn187 :: (Located [LConDecl GhcPs]) -> (HappyAbsSyn )
happyIn187 :: Located [LConDecl GhcPs] -> HappyAbsSyn
happyIn187 Located [LConDecl GhcPs]
x = HappyWrap187 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [LConDecl GhcPs] -> HappyWrap187
HappyWrap187 Located [LConDecl GhcPs]
x)
{-# INLINE happyIn187 #-}
happyOut187 :: (HappyAbsSyn ) -> HappyWrap187
happyOut187 :: HappyAbsSyn -> HappyWrap187
happyOut187 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap187
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut187 #-}
newtype HappyWrap188 = HappyWrap188 (LConDecl GhcPs)
happyIn188 :: (LConDecl GhcPs) -> (HappyAbsSyn )
happyIn188 :: LConDecl GhcPs -> HappyAbsSyn
happyIn188 LConDecl GhcPs
x = HappyWrap188 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LConDecl GhcPs -> HappyWrap188
HappyWrap188 LConDecl GhcPs
x)
{-# INLINE happyIn188 #-}
happyOut188 :: (HappyAbsSyn ) -> HappyWrap188
happyOut188 :: HappyAbsSyn -> HappyWrap188
happyOut188 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap188
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut188 #-}
newtype HappyWrap189 = HappyWrap189 (Located ([AddAnn], Maybe [LHsTyVarBndr GhcPs]))
happyIn189 :: (Located ([AddAnn], Maybe [LHsTyVarBndr GhcPs])) -> (HappyAbsSyn )
happyIn189 :: Located ([AddAnn], Maybe [LHsTyVarBndr GhcPs]) -> HappyAbsSyn
happyIn189 Located ([AddAnn], Maybe [LHsTyVarBndr GhcPs])
x = HappyWrap189 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], Maybe [LHsTyVarBndr GhcPs]) -> HappyWrap189
HappyWrap189 Located ([AddAnn], Maybe [LHsTyVarBndr GhcPs])
x)
{-# INLINE happyIn189 #-}
happyOut189 :: (HappyAbsSyn ) -> HappyWrap189
happyOut189 :: HappyAbsSyn -> HappyWrap189
happyOut189 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap189
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut189 #-}
newtype HappyWrap190 = HappyWrap190 (Located (Located RdrName, HsConDeclDetails GhcPs, Maybe LHsDocString))
happyIn190 :: (Located (Located RdrName, HsConDeclDetails GhcPs, Maybe LHsDocString)) -> (HappyAbsSyn )
happyIn190 :: Located
  (Located RdrName, HsConDeclDetails GhcPs, Maybe LHsDocString)
-> HappyAbsSyn
happyIn190 Located
  (Located RdrName, HsConDeclDetails GhcPs, Maybe LHsDocString)
x = HappyWrap190 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located
  (Located RdrName, HsConDeclDetails GhcPs, Maybe LHsDocString)
-> HappyWrap190
HappyWrap190 Located
  (Located RdrName, HsConDeclDetails GhcPs, Maybe LHsDocString)
x)
{-# INLINE happyIn190 #-}
happyOut190 :: (HappyAbsSyn ) -> HappyWrap190
happyOut190 :: HappyAbsSyn -> HappyWrap190
happyOut190 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap190
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut190 #-}
newtype HappyWrap191 = HappyWrap191 ([LConDeclField GhcPs])
happyIn191 :: ([LConDeclField GhcPs]) -> (HappyAbsSyn )
happyIn191 :: [LConDeclField GhcPs] -> HappyAbsSyn
happyIn191 [LConDeclField GhcPs]
x = HappyWrap191 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LConDeclField GhcPs] -> HappyWrap191
HappyWrap191 [LConDeclField GhcPs]
x)
{-# INLINE happyIn191 #-}
happyOut191 :: (HappyAbsSyn ) -> HappyWrap191
happyOut191 :: HappyAbsSyn -> HappyWrap191
happyOut191 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap191
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut191 #-}
newtype HappyWrap192 = HappyWrap192 ([LConDeclField GhcPs])
happyIn192 :: ([LConDeclField GhcPs]) -> (HappyAbsSyn )
happyIn192 :: [LConDeclField GhcPs] -> HappyAbsSyn
happyIn192 [LConDeclField GhcPs]
x = HappyWrap192 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LConDeclField GhcPs] -> HappyWrap192
HappyWrap192 [LConDeclField GhcPs]
x)
{-# INLINE happyIn192 #-}
happyOut192 :: (HappyAbsSyn ) -> HappyWrap192
happyOut192 :: HappyAbsSyn -> HappyWrap192
happyOut192 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap192
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut192 #-}
newtype HappyWrap193 = HappyWrap193 (LConDeclField GhcPs)
happyIn193 :: (LConDeclField GhcPs) -> (HappyAbsSyn )
happyIn193 :: LConDeclField GhcPs -> HappyAbsSyn
happyIn193 LConDeclField GhcPs
x = HappyWrap193 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LConDeclField GhcPs -> HappyWrap193
HappyWrap193 LConDeclField GhcPs
x)
{-# INLINE happyIn193 #-}
happyOut193 :: (HappyAbsSyn ) -> HappyWrap193
happyOut193 :: HappyAbsSyn -> HappyWrap193
happyOut193 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap193
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut193 #-}
newtype HappyWrap194 = HappyWrap194 (HsDeriving GhcPs)
happyIn194 :: (HsDeriving GhcPs) -> (HappyAbsSyn )
happyIn194 :: HsDeriving GhcPs -> HappyAbsSyn
happyIn194 HsDeriving GhcPs
x = HappyWrap194 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (HsDeriving GhcPs -> HappyWrap194
HappyWrap194 HsDeriving GhcPs
x)
{-# INLINE happyIn194 #-}
happyOut194 :: (HappyAbsSyn ) -> HappyWrap194
happyOut194 :: HappyAbsSyn -> HappyWrap194
happyOut194 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap194
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut194 #-}
newtype HappyWrap195 = HappyWrap195 (HsDeriving GhcPs)
happyIn195 :: (HsDeriving GhcPs) -> (HappyAbsSyn )
happyIn195 :: HsDeriving GhcPs -> HappyAbsSyn
happyIn195 HsDeriving GhcPs
x = HappyWrap195 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (HsDeriving GhcPs -> HappyWrap195
HappyWrap195 HsDeriving GhcPs
x)
{-# INLINE happyIn195 #-}
happyOut195 :: (HappyAbsSyn ) -> HappyWrap195
happyOut195 :: HappyAbsSyn -> HappyWrap195
happyOut195 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap195
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut195 #-}
newtype HappyWrap196 = HappyWrap196 (LHsDerivingClause GhcPs)
happyIn196 :: (LHsDerivingClause GhcPs) -> (HappyAbsSyn )
happyIn196 :: LHsDerivingClause GhcPs -> HappyAbsSyn
happyIn196 LHsDerivingClause GhcPs
x = HappyWrap196 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsDerivingClause GhcPs -> HappyWrap196
HappyWrap196 LHsDerivingClause GhcPs
x)
{-# INLINE happyIn196 #-}
happyOut196 :: (HappyAbsSyn ) -> HappyWrap196
happyOut196 :: HappyAbsSyn -> HappyWrap196
happyOut196 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap196
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut196 #-}
newtype HappyWrap197 = HappyWrap197 (Located [LHsSigType GhcPs])
happyIn197 :: (Located [LHsSigType GhcPs]) -> (HappyAbsSyn )
happyIn197 :: Located [LHsSigType GhcPs] -> HappyAbsSyn
happyIn197 Located [LHsSigType GhcPs]
x = HappyWrap197 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [LHsSigType GhcPs] -> HappyWrap197
HappyWrap197 Located [LHsSigType GhcPs]
x)
{-# INLINE happyIn197 #-}
happyOut197 :: (HappyAbsSyn ) -> HappyWrap197
happyOut197 :: HappyAbsSyn -> HappyWrap197
happyOut197 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 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 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap198
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut198 #-}
newtype HappyWrap199 = HappyWrap199 (LDocDecl)
happyIn199 :: (LDocDecl) -> (HappyAbsSyn )
happyIn199 :: LDocDecl -> HappyAbsSyn
happyIn199 LDocDecl
x = HappyWrap199 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LDocDecl -> HappyWrap199
HappyWrap199 LDocDecl
x)
{-# INLINE happyIn199 #-}
happyOut199 :: (HappyAbsSyn ) -> HappyWrap199
happyOut199 :: HappyAbsSyn -> HappyWrap199
happyOut199 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap199
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut199 #-}
newtype HappyWrap200 = HappyWrap200 (LHsDecl GhcPs)
happyIn200 :: (LHsDecl GhcPs) -> (HappyAbsSyn )
happyIn200 :: LHsDecl GhcPs -> HappyAbsSyn
happyIn200 LHsDecl GhcPs
x = HappyWrap200 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsDecl GhcPs -> HappyWrap200
HappyWrap200 LHsDecl GhcPs
x)
{-# INLINE happyIn200 #-}
happyOut200 :: (HappyAbsSyn ) -> HappyWrap200
happyOut200 :: HappyAbsSyn -> HappyWrap200
happyOut200 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap200
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut200 #-}
newtype HappyWrap201 = HappyWrap201 (LHsDecl GhcPs)
happyIn201 :: (LHsDecl GhcPs) -> (HappyAbsSyn )
happyIn201 :: LHsDecl GhcPs -> HappyAbsSyn
happyIn201 LHsDecl GhcPs
x = HappyWrap201 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsDecl GhcPs -> HappyWrap201
HappyWrap201 LHsDecl GhcPs
x)
{-# INLINE happyIn201 #-}
happyOut201 :: (HappyAbsSyn ) -> HappyWrap201
happyOut201 :: HappyAbsSyn -> HappyWrap201
happyOut201 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap201
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut201 #-}
newtype HappyWrap202 = HappyWrap202 (Located ([AddAnn],GRHSs GhcPs (LHsExpr GhcPs)))
happyIn202 :: (Located ([AddAnn],GRHSs GhcPs (LHsExpr GhcPs))) -> (HappyAbsSyn )
happyIn202 :: Located ([AddAnn], GRHSs GhcPs (LHsExpr GhcPs)) -> HappyAbsSyn
happyIn202 Located ([AddAnn], GRHSs GhcPs (LHsExpr GhcPs))
x = HappyWrap202 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], GRHSs GhcPs (LHsExpr GhcPs)) -> HappyWrap202
HappyWrap202 Located ([AddAnn], GRHSs GhcPs (LHsExpr GhcPs))
x)
{-# INLINE happyIn202 #-}
happyOut202 :: (HappyAbsSyn ) -> HappyWrap202
happyOut202 :: HappyAbsSyn -> HappyWrap202
happyOut202 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap202
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut202 #-}
newtype HappyWrap203 = HappyWrap203 (Located [LGRHS GhcPs (LHsExpr GhcPs)])
happyIn203 :: (Located [LGRHS GhcPs (LHsExpr GhcPs)]) -> (HappyAbsSyn )
happyIn203 :: Located [LGRHS GhcPs (LHsExpr GhcPs)] -> HappyAbsSyn
happyIn203 Located [LGRHS GhcPs (LHsExpr GhcPs)]
x = HappyWrap203 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [LGRHS GhcPs (LHsExpr GhcPs)] -> HappyWrap203
HappyWrap203 Located [LGRHS GhcPs (LHsExpr GhcPs)]
x)
{-# INLINE happyIn203 #-}
happyOut203 :: (HappyAbsSyn ) -> HappyWrap203
happyOut203 :: HappyAbsSyn -> HappyWrap203
happyOut203 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap203
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut203 #-}
newtype HappyWrap204 = HappyWrap204 (LGRHS GhcPs (LHsExpr GhcPs))
happyIn204 :: (LGRHS GhcPs (LHsExpr GhcPs)) -> (HappyAbsSyn )
happyIn204 :: LGRHS GhcPs (LHsExpr GhcPs) -> HappyAbsSyn
happyIn204 LGRHS GhcPs (LHsExpr GhcPs)
x = HappyWrap204 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LGRHS GhcPs (LHsExpr GhcPs) -> HappyWrap204
HappyWrap204 LGRHS GhcPs (LHsExpr GhcPs)
x)
{-# INLINE happyIn204 #-}
happyOut204 :: (HappyAbsSyn ) -> HappyWrap204
happyOut204 :: HappyAbsSyn -> HappyWrap204
happyOut204 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap204
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut204 #-}
newtype HappyWrap205 = HappyWrap205 (LHsDecl GhcPs)
happyIn205 :: (LHsDecl GhcPs) -> (HappyAbsSyn )
happyIn205 :: LHsDecl GhcPs -> HappyAbsSyn
happyIn205 LHsDecl GhcPs
x = HappyWrap205 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsDecl GhcPs -> HappyWrap205
HappyWrap205 LHsDecl GhcPs
x)
{-# INLINE happyIn205 #-}
happyOut205 :: (HappyAbsSyn ) -> HappyWrap205
happyOut205 :: HappyAbsSyn -> HappyWrap205
happyOut205 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap205
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut205 #-}
newtype HappyWrap206 = HappyWrap206 (([AddAnn],Maybe Activation))
happyIn206 :: (([AddAnn],Maybe Activation)) -> (HappyAbsSyn )
happyIn206 :: ([AddAnn], Maybe Activation) -> HappyAbsSyn
happyIn206 ([AddAnn], Maybe Activation)
x = HappyWrap206 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], Maybe Activation) -> HappyWrap206
HappyWrap206 ([AddAnn], Maybe Activation)
x)
{-# INLINE happyIn206 #-}
happyOut206 :: (HappyAbsSyn ) -> HappyWrap206
happyOut206 :: HappyAbsSyn -> HappyWrap206
happyOut206 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap206
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut206 #-}
newtype HappyWrap207 = HappyWrap207 (([AddAnn],Activation))
happyIn207 :: (([AddAnn],Activation)) -> (HappyAbsSyn )
happyIn207 :: ([AddAnn], Activation) -> HappyAbsSyn
happyIn207 ([AddAnn], Activation)
x = HappyWrap207 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], Activation) -> HappyWrap207
HappyWrap207 ([AddAnn], Activation)
x)
{-# INLINE happyIn207 #-}
happyOut207 :: (HappyAbsSyn ) -> HappyWrap207
happyOut207 :: HappyAbsSyn -> HappyWrap207
happyOut207 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap207
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut207 #-}
newtype HappyWrap208 = HappyWrap208 (Located (HsSplice GhcPs))
happyIn208 :: (Located (HsSplice GhcPs)) -> (HappyAbsSyn )
happyIn208 :: Located (HsSplice GhcPs) -> HappyAbsSyn
happyIn208 Located (HsSplice GhcPs)
x = HappyWrap208 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (HsSplice GhcPs) -> HappyWrap208
HappyWrap208 Located (HsSplice GhcPs)
x)
{-# INLINE happyIn208 #-}
happyOut208 :: (HappyAbsSyn ) -> HappyWrap208
happyOut208 :: HappyAbsSyn -> HappyWrap208
happyOut208 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap208
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut208 #-}
newtype HappyWrap209 = HappyWrap209 (ECP)
happyIn209 :: (ECP) -> (HappyAbsSyn )
happyIn209 :: ECP -> HappyAbsSyn
happyIn209 ECP
x = HappyWrap209 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (ECP -> HappyWrap209
HappyWrap209 ECP
x)
{-# INLINE happyIn209 #-}
happyOut209 :: (HappyAbsSyn ) -> HappyWrap209
happyOut209 :: HappyAbsSyn -> HappyWrap209
happyOut209 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap209
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut209 #-}
newtype HappyWrap210 = HappyWrap210 (ECP)
happyIn210 :: (ECP) -> (HappyAbsSyn )
happyIn210 :: ECP -> HappyAbsSyn
happyIn210 ECP
x = HappyWrap210 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (ECP -> HappyWrap210
HappyWrap210 ECP
x)
{-# INLINE happyIn210 #-}
happyOut210 :: (HappyAbsSyn ) -> HappyWrap210
happyOut210 :: HappyAbsSyn -> HappyWrap210
happyOut210 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap210
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut210 #-}
newtype HappyWrap211 = HappyWrap211 (ECP)
happyIn211 :: (ECP) -> (HappyAbsSyn )
happyIn211 :: ECP -> HappyAbsSyn
happyIn211 ECP
x = HappyWrap211 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (ECP -> HappyWrap211
HappyWrap211 ECP
x)
{-# INLINE happyIn211 #-}
happyOut211 :: (HappyAbsSyn ) -> HappyWrap211
happyOut211 :: HappyAbsSyn -> HappyWrap211
happyOut211 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap211
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut211 #-}
newtype HappyWrap212 = HappyWrap212 (ECP)
happyIn212 :: (ECP) -> (HappyAbsSyn )
happyIn212 :: ECP -> HappyAbsSyn
happyIn212 ECP
x = HappyWrap212 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (ECP -> HappyWrap212
HappyWrap212 ECP
x)
{-# INLINE happyIn212 #-}
happyOut212 :: (HappyAbsSyn ) -> HappyWrap212
happyOut212 :: HappyAbsSyn -> HappyWrap212
happyOut212 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap212
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut212 #-}
newtype HappyWrap213 = HappyWrap213 (ECP)
happyIn213 :: (ECP) -> (HappyAbsSyn )
happyIn213 :: ECP -> HappyAbsSyn
happyIn213 ECP
x = HappyWrap213 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (ECP -> HappyWrap213
HappyWrap213 ECP
x)
{-# INLINE happyIn213 #-}
happyOut213 :: (HappyAbsSyn ) -> HappyWrap213
happyOut213 :: HappyAbsSyn -> HappyWrap213
happyOut213 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap213
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut213 #-}
newtype HappyWrap214 = HappyWrap214 (([Located Token],Bool))
happyIn214 :: (([Located Token],Bool)) -> (