{-# 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 GHC.Parser
   ( parseModule, parseSignature, parseImport, parseStatement, parseBackpack
   , parseDeclaration, parseExpression, parsePattern
   , parseTypeSignature
   , parseStmt, parseIdentifier
   , parseType, parseHeader
   , parseModuleNoHaddock
   )
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 -- for happy-generated code

-- compiler
import GHC.Hs

import GHC.Driver.Phases  ( HscSource(..) )
import GHC.Driver.Types   ( IsBootInterface(..), WarningTxt(..) )
import GHC.Driver.Session
import GHC.Driver.Backpack.Syntax
import GHC.Unit.Info

-- compiler/utils
import GHC.Data.OrdList
import GHC.Data.BooleanFormula ( BooleanFormula(..), LBooleanFormula(..), mkTrue )
import GHC.Data.FastString
import GHC.Data.Maybe          ( isJust, orElse )
import GHC.Utils.Outputable
import GHC.Utils.Misc          ( looksLikePackageName, fstOf3, sndOf3, thdOf3 )
import GHC.Prelude

-- compiler/basicTypes
import GHC.Types.Name.Reader
import GHC.Types.Name.Occurrence ( varName, dataName, tcClsName, tvName, startsWithUnderscore )
import GHC.Core.DataCon          ( DataCon, dataConName )
import GHC.Types.SrcLoc
import GHC.Unit.Module
import GHC.Types.Basic
import GHC.Types.ForeignCall
import GHC.Hs.Doc

import GHC.Core.Type    ( unrestrictedFunTyCon, Mult(..), Specificity(..) )
import GHC.Core.Class   ( FunDep )

-- compiler/parser
import GHC.Parser.PostProcess
import GHC.Parser.PostProcess.Haddock
import GHC.Parser.Lexer
import GHC.Parser.Annotation

import GHC.Tc.Types.Evidence  ( emptyTcEvBinds )

-- compiler/prelude
import GHC.Builtin.Types.Prim ( eqPrimTyCon )
import GHC.Builtin.Types ( unitTyCon, unitDataCon, tupleTyCon, tupleDataCon, nilDataCon,
                           unboxedUnitTyCon, unboxedUnitDataCon,
                           listTyCon_RDR, consDataCon_RDR, eqTyCon_RDR,
                           manyDataConTyCon)
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 ([AddAnn])
happyIn26 :: ([AddAnn]) -> (HappyAbsSyn )
happyIn26 :: [AddAnn] -> HappyAbsSyn
happyIn26 [AddAnn]
x = HappyWrap26 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([AddAnn] -> HappyWrap26
HappyWrap26 [AddAnn]
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 (Located FastString)
happyIn27 :: (Located FastString) -> (HappyAbsSyn )
happyIn27 :: Located FastString -> HappyAbsSyn
happyIn27 Located FastString
x = HappyWrap27 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located FastString -> HappyWrap27
HappyWrap27 Located FastString
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 (Maybe [LRenaming])
happyIn28 :: (Maybe [LRenaming]) -> (HappyAbsSyn )
happyIn28 :: Maybe [LRenaming] -> HappyAbsSyn
happyIn28 Maybe [LRenaming]
x = HappyWrap28 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Maybe [LRenaming] -> HappyWrap28
HappyWrap28 Maybe [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 (OrdList LRenaming)
happyIn29 :: (OrdList LRenaming) -> (HappyAbsSyn )
happyIn29 :: OrdList LRenaming -> HappyAbsSyn
happyIn29 OrdList LRenaming
x = HappyWrap29 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList LRenaming -> HappyWrap29
HappyWrap29 OrdList 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 (LRenaming)
happyIn30 :: (LRenaming) -> (HappyAbsSyn )
happyIn30 :: LRenaming -> HappyAbsSyn
happyIn30 LRenaming
x = HappyWrap30 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LRenaming -> HappyWrap30
HappyWrap30 LRenaming
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 (OrdList (LHsUnitDecl PackageName))
happyIn32 :: (OrdList (LHsUnitDecl PackageName)) -> (HappyAbsSyn )
happyIn32 :: OrdList (LHsUnitDecl PackageName) -> HappyAbsSyn
happyIn32 OrdList (LHsUnitDecl PackageName)
x = HappyWrap32 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList (LHsUnitDecl PackageName) -> HappyWrap32
HappyWrap32 OrdList (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 (LHsUnitDecl PackageName)
happyIn33 :: (LHsUnitDecl PackageName) -> (HappyAbsSyn )
happyIn33 :: LHsUnitDecl PackageName -> HappyAbsSyn
happyIn33 LHsUnitDecl PackageName
x = HappyWrap33 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsUnitDecl PackageName -> HappyWrap33
HappyWrap33 LHsUnitDecl PackageName
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)
happyIn34 :: (Located HsModule) -> (HappyAbsSyn )
happyIn34 :: Located HsModule -> HappyAbsSyn
happyIn34 Located HsModule
x = HappyWrap34 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located HsModule -> HappyWrap34
HappyWrap34 Located HsModule
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 (Located HsModule)
happyIn35 :: (Located HsModule) -> (HappyAbsSyn )
happyIn35 :: Located HsModule -> HappyAbsSyn
happyIn35 Located HsModule
x = HappyWrap35 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located HsModule -> HappyWrap35
HappyWrap35 Located HsModule
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])
             ,LayoutInfo))
happyIn39 :: (([AddAnn]
             ,([LImportDecl GhcPs], [LHsDecl GhcPs])
             ,LayoutInfo)) -> (HappyAbsSyn )
happyIn39 :: ([AddAnn], ([LImportDecl GhcPs], [LHsDecl GhcPs]), LayoutInfo)
-> HappyAbsSyn
happyIn39 ([AddAnn], ([LImportDecl GhcPs], [LHsDecl GhcPs]), LayoutInfo)
x = HappyWrap39 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], ([LImportDecl GhcPs], [LHsDecl GhcPs]), LayoutInfo)
-> HappyWrap39
HappyWrap39 ([AddAnn], ([LImportDecl GhcPs], [LHsDecl GhcPs]), LayoutInfo)
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])
             ,LayoutInfo))
happyIn40 :: (([AddAnn]
             ,([LImportDecl GhcPs], [LHsDecl GhcPs])
             ,LayoutInfo)) -> (HappyAbsSyn )
happyIn40 :: ([AddAnn], ([LImportDecl GhcPs], [LHsDecl GhcPs]), LayoutInfo)
-> HappyAbsSyn
happyIn40 ([AddAnn], ([LImportDecl GhcPs], [LHsDecl GhcPs]), LayoutInfo)
x = HappyWrap40 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], ([LImportDecl GhcPs], [LHsDecl GhcPs]), LayoutInfo)
-> HappyWrap40
HappyWrap40 ([AddAnn], ([LImportDecl GhcPs], [LHsDecl GhcPs]), LayoutInfo)
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)
happyIn43 :: (Located HsModule) -> (HappyAbsSyn )
happyIn43 :: Located HsModule -> HappyAbsSyn
happyIn43 Located HsModule
x = HappyWrap43 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located HsModule -> HappyWrap43
HappyWrap43 Located HsModule
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 (([AddAnn], OrdList (LIE GhcPs)))
happyIn49 :: (([AddAnn], OrdList (LIE GhcPs))) -> (HappyAbsSyn )
happyIn49 :: ([AddAnn], OrdList (LIE GhcPs)) -> HappyAbsSyn
happyIn49 ([AddAnn], OrdList (LIE GhcPs))
x = HappyWrap49 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], OrdList (LIE GhcPs)) -> HappyWrap49
HappyWrap49 ([AddAnn], 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 (Located ([AddAnn],ImpExpSubSpec))
happyIn52 :: (Located ([AddAnn],ImpExpSubSpec)) -> (HappyAbsSyn )
happyIn52 :: Located ([AddAnn], ImpExpSubSpec) -> HappyAbsSyn
happyIn52 Located ([AddAnn], ImpExpSubSpec)
x = HappyWrap52 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], ImpExpSubSpec) -> HappyWrap52
HappyWrap52 Located ([AddAnn], ImpExpSubSpec)
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 (([AddAnn], [Located ImpExpQcSpec]))
happyIn53 :: (([AddAnn], [Located ImpExpQcSpec])) -> (HappyAbsSyn )
happyIn53 :: ([AddAnn], [Located ImpExpQcSpec]) -> HappyAbsSyn
happyIn53 ([AddAnn], [Located ImpExpQcSpec])
x = HappyWrap53 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], [Located ImpExpQcSpec]) -> HappyWrap53
HappyWrap53 ([AddAnn], [Located ImpExpQcSpec])
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 (([AddAnn], [Located ImpExpQcSpec]))
happyIn54 :: (([AddAnn], [Located ImpExpQcSpec])) -> (HappyAbsSyn )
happyIn54 :: ([AddAnn], [Located ImpExpQcSpec]) -> HappyAbsSyn
happyIn54 ([AddAnn], [Located ImpExpQcSpec])
x = HappyWrap54 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], [Located ImpExpQcSpec]) -> HappyWrap54
HappyWrap54 ([AddAnn], [Located ImpExpQcSpec])
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 (Located ([AddAnn], Located ImpExpQcSpec))
happyIn55 :: (Located ([AddAnn], Located ImpExpQcSpec)) -> (HappyAbsSyn )
happyIn55 :: Located ([AddAnn], Located ImpExpQcSpec) -> HappyAbsSyn
happyIn55 Located ([AddAnn], Located ImpExpQcSpec)
x = HappyWrap55 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], Located ImpExpQcSpec) -> HappyWrap55
HappyWrap55 Located ([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 (Located ImpExpQcSpec)
happyIn56 :: (Located ImpExpQcSpec) -> (HappyAbsSyn )
happyIn56 :: Located ImpExpQcSpec -> HappyAbsSyn
happyIn56 Located ImpExpQcSpec
x = HappyWrap56 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ImpExpQcSpec -> HappyWrap56
HappyWrap56 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 RdrName)
happyIn57 :: (Located RdrName) -> (HappyAbsSyn )
happyIn57 :: Located RdrName -> HappyAbsSyn
happyIn57 Located RdrName
x = HappyWrap57 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located RdrName -> HappyWrap57
HappyWrap57 Located RdrName
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 ([AddAnn])
happyIn58 :: ([AddAnn]) -> (HappyAbsSyn )
happyIn58 :: [AddAnn] -> HappyAbsSyn
happyIn58 [AddAnn]
x = HappyWrap58 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([AddAnn] -> HappyWrap58
HappyWrap58 [AddAnn]
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 ([AddAnn])
happyIn59 :: ([AddAnn]) -> (HappyAbsSyn )
happyIn59 :: [AddAnn] -> HappyAbsSyn
happyIn59 [AddAnn]
x = HappyWrap59 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([AddAnn] -> HappyWrap59
HappyWrap59 [AddAnn]
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 ([LImportDecl GhcPs])
happyIn60 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )
happyIn60 :: [LImportDecl GhcPs] -> HappyAbsSyn
happyIn60 [LImportDecl GhcPs]
x = HappyWrap60 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LImportDecl GhcPs] -> HappyWrap60
HappyWrap60 [LImportDecl GhcPs]
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 ([LImportDecl GhcPs])
happyIn61 :: ([LImportDecl GhcPs]) -> (HappyAbsSyn )
happyIn61 :: [LImportDecl GhcPs] -> HappyAbsSyn
happyIn61 [LImportDecl GhcPs]
x = HappyWrap61 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LImportDecl GhcPs] -> HappyWrap61
HappyWrap61 [LImportDecl GhcPs]
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 ((([AddAnn],SourceText),IsBootInterface))
happyIn63 :: ((([AddAnn],SourceText),IsBootInterface)) -> (HappyAbsSyn )
happyIn63 :: (([AddAnn], SourceText), IsBootInterface) -> HappyAbsSyn
happyIn63 (([AddAnn], SourceText), IsBootInterface)
x = HappyWrap63 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ((([AddAnn], SourceText), IsBootInterface) -> HappyWrap63
HappyWrap63 (([AddAnn], SourceText), IsBootInterface)
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 (([AddAnn],Bool))
happyIn64 :: (([AddAnn],Bool)) -> (HappyAbsSyn )
happyIn64 :: ([AddAnn], Bool) -> HappyAbsSyn
happyIn64 ([AddAnn], Bool)
x = HappyWrap64 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], Bool) -> HappyWrap64
HappyWrap64 ([AddAnn], Bool)
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],Maybe StringLiteral))
happyIn65 :: (([AddAnn],Maybe StringLiteral)) -> (HappyAbsSyn )
happyIn65 :: ([AddAnn], Maybe StringLiteral) -> HappyAbsSyn
happyIn65 ([AddAnn], Maybe StringLiteral)
x = HappyWrap65 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], Maybe StringLiteral) -> HappyWrap65
HappyWrap65 ([AddAnn], Maybe StringLiteral)
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 (Located (Maybe (Located Token)))
happyIn66 :: (Located (Maybe (Located Token))) -> (HappyAbsSyn )
happyIn66 :: Located (Maybe (Located Token)) -> HappyAbsSyn
happyIn66 Located (Maybe (Located Token))
x = HappyWrap66 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (Maybe (Located Token)) -> HappyWrap66
HappyWrap66 Located (Maybe (Located Token))
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],Located (Maybe (Located ModuleName))))
happyIn67 :: (([AddAnn],Located (Maybe (Located ModuleName)))) -> (HappyAbsSyn )
happyIn67 :: ([AddAnn], Located (Maybe (Located ModuleName))) -> HappyAbsSyn
happyIn67 ([AddAnn], Located (Maybe (Located ModuleName)))
x = HappyWrap67 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], Located (Maybe (Located ModuleName))) -> HappyWrap67
HappyWrap67 ([AddAnn], Located (Maybe (Located ModuleName)))
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 (Located (Maybe (Bool, Located [LIE GhcPs])))
happyIn68 :: (Located (Maybe (Bool, Located [LIE GhcPs]))) -> (HappyAbsSyn )
happyIn68 :: Located (Maybe (Bool, Located [LIE GhcPs])) -> HappyAbsSyn
happyIn68 Located (Maybe (Bool, Located [LIE GhcPs]))
x = HappyWrap68 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (Maybe (Bool, Located [LIE GhcPs])) -> HappyWrap68
HappyWrap68 Located (Maybe (Bool, Located [LIE GhcPs]))
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 (Located (Bool, Located [LIE GhcPs]))
happyIn69 :: (Located (Bool, Located [LIE GhcPs])) -> (HappyAbsSyn )
happyIn69 :: Located (Bool, Located [LIE GhcPs]) -> HappyAbsSyn
happyIn69 Located (Bool, Located [LIE GhcPs])
x = HappyWrap69 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (Bool, Located [LIE GhcPs]) -> HappyWrap69
HappyWrap69 Located (Bool, Located [LIE GhcPs])
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 (SourceText,Int))
happyIn70 :: (Located (SourceText,Int)) -> (HappyAbsSyn )
happyIn70 :: Located (SourceText, Int) -> HappyAbsSyn
happyIn70 Located (SourceText, Int)
x = HappyWrap70 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (SourceText, Int) -> HappyWrap70
HappyWrap70 Located (SourceText, Int)
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 FixityDirection)
happyIn71 :: (Located FixityDirection) -> (HappyAbsSyn )
happyIn71 :: Located FixityDirection -> HappyAbsSyn
happyIn71 Located FixityDirection
x = HappyWrap71 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located FixityDirection -> HappyWrap71
HappyWrap71 Located FixityDirection
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 (OrdList (Located RdrName)))
happyIn72 :: (Located (OrdList (Located RdrName))) -> (HappyAbsSyn )
happyIn72 :: Located (OrdList (Located RdrName)) -> HappyAbsSyn
happyIn72 Located (OrdList (Located RdrName))
x = HappyWrap72 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (OrdList (Located RdrName)) -> HappyWrap72
HappyWrap72 Located (OrdList (Located RdrName))
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 (OrdList (LHsDecl GhcPs))
happyIn73 :: (OrdList (LHsDecl GhcPs)) -> (HappyAbsSyn )
happyIn73 :: OrdList (LHsDecl GhcPs) -> HappyAbsSyn
happyIn73 OrdList (LHsDecl GhcPs)
x = HappyWrap73 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList (LHsDecl GhcPs) -> HappyWrap73
HappyWrap73 OrdList (LHsDecl GhcPs)
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 (OrdList (LHsDecl GhcPs))
happyIn74 :: (OrdList (LHsDecl GhcPs)) -> (HappyAbsSyn )
happyIn74 :: OrdList (LHsDecl GhcPs) -> HappyAbsSyn
happyIn74 OrdList (LHsDecl GhcPs)
x = HappyWrap74 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList (LHsDecl GhcPs) -> HappyWrap74
HappyWrap74 OrdList (LHsDecl GhcPs)
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 (LHsDecl GhcPs)
happyIn75 :: (LHsDecl GhcPs) -> (HappyAbsSyn )
happyIn75 :: LHsDecl GhcPs -> HappyAbsSyn
happyIn75 LHsDecl GhcPs
x = HappyWrap75 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsDecl GhcPs -> HappyWrap75
HappyWrap75 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 (LTyClDecl GhcPs)
happyIn76 :: (LTyClDecl GhcPs) -> (HappyAbsSyn )
happyIn76 :: LTyClDecl GhcPs -> HappyAbsSyn
happyIn76 LTyClDecl GhcPs
x = HappyWrap76 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LTyClDecl GhcPs -> HappyWrap76
HappyWrap76 LTyClDecl 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 (LTyClDecl GhcPs)
happyIn77 :: (LTyClDecl GhcPs) -> (HappyAbsSyn )
happyIn77 :: LTyClDecl GhcPs -> HappyAbsSyn
happyIn77 LTyClDecl GhcPs
x = HappyWrap77 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LTyClDecl GhcPs -> HappyWrap77
HappyWrap77 LTyClDecl 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 (LStandaloneKindSig GhcPs)
happyIn78 :: (LStandaloneKindSig GhcPs) -> (HappyAbsSyn )
happyIn78 :: LStandaloneKindSig GhcPs -> HappyAbsSyn
happyIn78 LStandaloneKindSig GhcPs
x = HappyWrap78 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LStandaloneKindSig GhcPs -> HappyWrap78
HappyWrap78 LStandaloneKindSig 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 (Located [Located RdrName])
happyIn79 :: (Located [Located RdrName]) -> (HappyAbsSyn )
happyIn79 :: Located [Located RdrName] -> HappyAbsSyn
happyIn79 Located [Located RdrName]
x = HappyWrap79 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [Located RdrName] -> HappyWrap79
HappyWrap79 Located [Located RdrName]
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 (LInstDecl GhcPs)
happyIn80 :: (LInstDecl GhcPs) -> (HappyAbsSyn )
happyIn80 :: LInstDecl GhcPs -> HappyAbsSyn
happyIn80 LInstDecl GhcPs
x = HappyWrap80 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LInstDecl GhcPs -> HappyWrap80
HappyWrap80 LInstDecl GhcPs
x)
{-# INLINE happyIn80 #-}
happyOut80 :: (HappyAbsSyn ) -> HappyWrap80
happyOut80 :: HappyAbsSyn -> HappyWrap80
happyOut80 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap80
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut80 #-}
newtype HappyWrap81 = HappyWrap81 (Maybe (Located OverlapMode))
happyIn81 :: (Maybe (Located OverlapMode)) -> (HappyAbsSyn )
happyIn81 :: Maybe (Located OverlapMode) -> HappyAbsSyn
happyIn81 Maybe (Located OverlapMode)
x = HappyWrap81 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Maybe (Located OverlapMode) -> HappyWrap81
HappyWrap81 Maybe (Located OverlapMode)
x)
{-# INLINE happyIn81 #-}
happyOut81 :: (HappyAbsSyn ) -> HappyWrap81
happyOut81 :: HappyAbsSyn -> HappyWrap81
happyOut81 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap81
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut81 #-}
newtype HappyWrap82 = HappyWrap82 (LDerivStrategy GhcPs)
happyIn82 :: (LDerivStrategy GhcPs) -> (HappyAbsSyn )
happyIn82 :: LDerivStrategy GhcPs -> HappyAbsSyn
happyIn82 LDerivStrategy GhcPs
x = HappyWrap82 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LDerivStrategy GhcPs -> HappyWrap82
HappyWrap82 LDerivStrategy GhcPs
x)
{-# INLINE happyIn82 #-}
happyOut82 :: (HappyAbsSyn ) -> HappyWrap82
happyOut82 :: HappyAbsSyn -> HappyWrap82
happyOut82 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap82
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut82 #-}
newtype HappyWrap83 = HappyWrap83 (LDerivStrategy GhcPs)
happyIn83 :: (LDerivStrategy GhcPs) -> (HappyAbsSyn )
happyIn83 :: LDerivStrategy GhcPs -> HappyAbsSyn
happyIn83 LDerivStrategy GhcPs
x = HappyWrap83 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LDerivStrategy GhcPs -> HappyWrap83
HappyWrap83 LDerivStrategy GhcPs
x)
{-# INLINE happyIn83 #-}
happyOut83 :: (HappyAbsSyn ) -> HappyWrap83
happyOut83 :: HappyAbsSyn -> HappyWrap83
happyOut83 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap83
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut83 #-}
newtype HappyWrap84 = HappyWrap84 (Maybe (LDerivStrategy GhcPs))
happyIn84 :: (Maybe (LDerivStrategy GhcPs)) -> (HappyAbsSyn )
happyIn84 :: Maybe (LDerivStrategy GhcPs) -> HappyAbsSyn
happyIn84 Maybe (LDerivStrategy GhcPs)
x = HappyWrap84 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Maybe (LDerivStrategy GhcPs) -> HappyWrap84
HappyWrap84 Maybe (LDerivStrategy GhcPs)
x)
{-# INLINE happyIn84 #-}
happyOut84 :: (HappyAbsSyn ) -> HappyWrap84
happyOut84 :: HappyAbsSyn -> HappyWrap84
happyOut84 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap84
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut84 #-}
newtype HappyWrap85 = HappyWrap85 (Located ([AddAnn], Maybe (LInjectivityAnn GhcPs)))
happyIn85 :: (Located ([AddAnn], Maybe (LInjectivityAnn GhcPs))) -> (HappyAbsSyn )
happyIn85 :: Located ([AddAnn], Maybe (LInjectivityAnn GhcPs)) -> HappyAbsSyn
happyIn85 Located ([AddAnn], Maybe (LInjectivityAnn GhcPs))
x = HappyWrap85 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], Maybe (LInjectivityAnn GhcPs)) -> HappyWrap85
HappyWrap85 Located ([AddAnn], Maybe (LInjectivityAnn GhcPs))
x)
{-# INLINE happyIn85 #-}
happyOut85 :: (HappyAbsSyn ) -> HappyWrap85
happyOut85 :: HappyAbsSyn -> HappyWrap85
happyOut85 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap85
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut85 #-}
newtype HappyWrap86 = HappyWrap86 (LInjectivityAnn GhcPs)
happyIn86 :: (LInjectivityAnn GhcPs) -> (HappyAbsSyn )
happyIn86 :: LInjectivityAnn GhcPs -> HappyAbsSyn
happyIn86 LInjectivityAnn GhcPs
x = HappyWrap86 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LInjectivityAnn GhcPs -> HappyWrap86
HappyWrap86 LInjectivityAnn GhcPs
x)
{-# INLINE happyIn86 #-}
happyOut86 :: (HappyAbsSyn ) -> HappyWrap86
happyOut86 :: HappyAbsSyn -> HappyWrap86
happyOut86 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap86
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut86 #-}
newtype HappyWrap87 = HappyWrap87 (Located [Located RdrName])
happyIn87 :: (Located [Located RdrName]) -> (HappyAbsSyn )
happyIn87 :: Located [Located RdrName] -> HappyAbsSyn
happyIn87 Located [Located RdrName]
x = HappyWrap87 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [Located RdrName] -> HappyWrap87
HappyWrap87 Located [Located RdrName]
x)
{-# INLINE happyIn87 #-}
happyOut87 :: (HappyAbsSyn ) -> HappyWrap87
happyOut87 :: HappyAbsSyn -> HappyWrap87
happyOut87 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap87
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut87 #-}
newtype HappyWrap88 = HappyWrap88 (Located ([AddAnn],FamilyInfo GhcPs))
happyIn88 :: (Located ([AddAnn],FamilyInfo GhcPs)) -> (HappyAbsSyn )
happyIn88 :: Located ([AddAnn], FamilyInfo GhcPs) -> HappyAbsSyn
happyIn88 Located ([AddAnn], FamilyInfo GhcPs)
x = HappyWrap88 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], FamilyInfo GhcPs) -> HappyWrap88
HappyWrap88 Located ([AddAnn], FamilyInfo GhcPs)
x)
{-# INLINE happyIn88 #-}
happyOut88 :: (HappyAbsSyn ) -> HappyWrap88
happyOut88 :: HappyAbsSyn -> HappyWrap88
happyOut88 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap88
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut88 #-}
newtype HappyWrap89 = HappyWrap89 (Located ([AddAnn],Maybe [LTyFamInstEqn GhcPs]))
happyIn89 :: (Located ([AddAnn],Maybe [LTyFamInstEqn GhcPs])) -> (HappyAbsSyn )
happyIn89 :: Located ([AddAnn], Maybe [LTyFamInstEqn GhcPs]) -> HappyAbsSyn
happyIn89 Located ([AddAnn], Maybe [LTyFamInstEqn GhcPs])
x = HappyWrap89 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], Maybe [LTyFamInstEqn GhcPs]) -> HappyWrap89
HappyWrap89 Located ([AddAnn], Maybe [LTyFamInstEqn GhcPs])
x)
{-# INLINE happyIn89 #-}
happyOut89 :: (HappyAbsSyn ) -> HappyWrap89
happyOut89 :: HappyAbsSyn -> HappyWrap89
happyOut89 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap89
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut89 #-}
newtype HappyWrap90 = HappyWrap90 (Located [LTyFamInstEqn GhcPs])
happyIn90 :: (Located [LTyFamInstEqn GhcPs]) -> (HappyAbsSyn )
happyIn90 :: Located [LTyFamInstEqn GhcPs] -> HappyAbsSyn
happyIn90 Located [LTyFamInstEqn GhcPs]
x = HappyWrap90 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [LTyFamInstEqn GhcPs] -> HappyWrap90
HappyWrap90 Located [LTyFamInstEqn GhcPs]
x)
{-# INLINE happyIn90 #-}
happyOut90 :: (HappyAbsSyn ) -> HappyWrap90
happyOut90 :: HappyAbsSyn -> HappyWrap90
happyOut90 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap90
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut90 #-}
newtype HappyWrap91 = HappyWrap91 (Located ([AddAnn],TyFamInstEqn GhcPs))
happyIn91 :: (Located ([AddAnn],TyFamInstEqn GhcPs)) -> (HappyAbsSyn )
happyIn91 :: Located ([AddAnn], TyFamInstEqn GhcPs) -> HappyAbsSyn
happyIn91 Located ([AddAnn], TyFamInstEqn GhcPs)
x = HappyWrap91 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], TyFamInstEqn GhcPs) -> HappyWrap91
HappyWrap91 Located ([AddAnn], TyFamInstEqn GhcPs)
x)
{-# INLINE happyIn91 #-}
happyOut91 :: (HappyAbsSyn ) -> HappyWrap91
happyOut91 :: HappyAbsSyn -> HappyWrap91
happyOut91 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap91
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut91 #-}
newtype HappyWrap92 = HappyWrap92 (LHsDecl GhcPs)
happyIn92 :: (LHsDecl GhcPs) -> (HappyAbsSyn )
happyIn92 :: LHsDecl GhcPs -> HappyAbsSyn
happyIn92 LHsDecl GhcPs
x = HappyWrap92 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsDecl GhcPs -> HappyWrap92
HappyWrap92 LHsDecl GhcPs
x)
{-# INLINE happyIn92 #-}
happyOut92 :: (HappyAbsSyn ) -> HappyWrap92
happyOut92 :: HappyAbsSyn -> HappyWrap92
happyOut92 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap92
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut92 #-}
newtype HappyWrap93 = HappyWrap93 ([AddAnn])
happyIn93 :: ([AddAnn]) -> (HappyAbsSyn )
happyIn93 :: [AddAnn] -> HappyAbsSyn
happyIn93 [AddAnn]
x = HappyWrap93 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([AddAnn] -> HappyWrap93
HappyWrap93 [AddAnn]
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 ([AddAnn])
happyIn94 :: ([AddAnn]) -> (HappyAbsSyn )
happyIn94 :: [AddAnn] -> HappyAbsSyn
happyIn94 [AddAnn]
x = HappyWrap94 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([AddAnn] -> HappyWrap94
HappyWrap94 [AddAnn]
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 (LInstDecl GhcPs)
happyIn95 :: (LInstDecl GhcPs) -> (HappyAbsSyn )
happyIn95 :: LInstDecl GhcPs -> HappyAbsSyn
happyIn95 LInstDecl GhcPs
x = HappyWrap95 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LInstDecl GhcPs -> HappyWrap95
HappyWrap95 LInstDecl GhcPs
x)
{-# INLINE happyIn95 #-}
happyOut95 :: (HappyAbsSyn ) -> HappyWrap95
happyOut95 :: HappyAbsSyn -> HappyWrap95
happyOut95 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap95
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut95 #-}
newtype HappyWrap96 = HappyWrap96 (Located (AddAnn, NewOrData))
happyIn96 :: (Located (AddAnn, NewOrData)) -> (HappyAbsSyn )
happyIn96 :: Located (AddAnn, NewOrData) -> HappyAbsSyn
happyIn96 Located (AddAnn, NewOrData)
x = HappyWrap96 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (AddAnn, NewOrData) -> HappyWrap96
HappyWrap96 Located (AddAnn, NewOrData)
x)
{-# INLINE happyIn96 #-}
happyOut96 :: (HappyAbsSyn ) -> HappyWrap96
happyOut96 :: HappyAbsSyn -> HappyWrap96
happyOut96 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap96
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut96 #-}
newtype HappyWrap97 = HappyWrap97 (Located ([AddAnn], Maybe (LHsKind GhcPs)))
happyIn97 :: (Located ([AddAnn], Maybe (LHsKind GhcPs))) -> (HappyAbsSyn )
happyIn97 :: Located ([AddAnn], Maybe (LHsKind GhcPs)) -> HappyAbsSyn
happyIn97 Located ([AddAnn], Maybe (LHsKind GhcPs))
x = HappyWrap97 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], Maybe (LHsKind GhcPs)) -> HappyWrap97
HappyWrap97 Located ([AddAnn], Maybe (LHsKind GhcPs))
x)
{-# INLINE happyIn97 #-}
happyOut97 :: (HappyAbsSyn ) -> HappyWrap97
happyOut97 :: HappyAbsSyn -> HappyWrap97
happyOut97 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap97
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut97 #-}
newtype HappyWrap98 = HappyWrap98 (Located ([AddAnn], LFamilyResultSig GhcPs))
happyIn98 :: (Located ([AddAnn], LFamilyResultSig GhcPs)) -> (HappyAbsSyn )
happyIn98 :: Located ([AddAnn], LFamilyResultSig GhcPs) -> HappyAbsSyn
happyIn98 Located ([AddAnn], LFamilyResultSig GhcPs)
x = HappyWrap98 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], LFamilyResultSig GhcPs) -> HappyWrap98
HappyWrap98 Located ([AddAnn], LFamilyResultSig GhcPs)
x)
{-# INLINE happyIn98 #-}
happyOut98 :: (HappyAbsSyn ) -> HappyWrap98
happyOut98 :: HappyAbsSyn -> HappyWrap98
happyOut98 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap98
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut98 #-}
newtype HappyWrap99 = HappyWrap99 (Located ([AddAnn], LFamilyResultSig GhcPs))
happyIn99 :: (Located ([AddAnn], LFamilyResultSig GhcPs)) -> (HappyAbsSyn )
happyIn99 :: Located ([AddAnn], LFamilyResultSig GhcPs) -> HappyAbsSyn
happyIn99 Located ([AddAnn], LFamilyResultSig GhcPs)
x = HappyWrap99 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], LFamilyResultSig GhcPs) -> HappyWrap99
HappyWrap99 Located ([AddAnn], LFamilyResultSig GhcPs)
x)
{-# INLINE happyIn99 #-}
happyOut99 :: (HappyAbsSyn ) -> HappyWrap99
happyOut99 :: HappyAbsSyn -> HappyWrap99
happyOut99 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap99
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut99 #-}
newtype HappyWrap100 = HappyWrap100 (Located ([AddAnn], ( LFamilyResultSig GhcPs
                                            , Maybe (LInjectivityAnn GhcPs))))
happyIn100 :: (Located ([AddAnn], ( LFamilyResultSig GhcPs
                                            , Maybe (LInjectivityAnn GhcPs)))) -> (HappyAbsSyn )
happyIn100 :: Located
  ([AddAnn], (LFamilyResultSig GhcPs, Maybe (LInjectivityAnn GhcPs)))
-> HappyAbsSyn
happyIn100 Located
  ([AddAnn], (LFamilyResultSig GhcPs, Maybe (LInjectivityAnn GhcPs)))
x = HappyWrap100 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located
  ([AddAnn], (LFamilyResultSig GhcPs, Maybe (LInjectivityAnn GhcPs)))
-> HappyWrap100
HappyWrap100 Located
  ([AddAnn], (LFamilyResultSig GhcPs, Maybe (LInjectivityAnn GhcPs)))
x)
{-# INLINE happyIn100 #-}
happyOut100 :: (HappyAbsSyn ) -> HappyWrap100
happyOut100 :: HappyAbsSyn -> HappyWrap100
happyOut100 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap100
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut100 #-}
newtype HappyWrap101 = HappyWrap101 (Located (Maybe (LHsContext GhcPs), LHsType GhcPs))
happyIn101 :: (Located (Maybe (LHsContext GhcPs), LHsType GhcPs)) -> (HappyAbsSyn )
happyIn101 :: Located (Maybe (LHsContext GhcPs), LHsKind GhcPs) -> HappyAbsSyn
happyIn101 Located (Maybe (LHsContext GhcPs), LHsKind GhcPs)
x = HappyWrap101 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (Maybe (LHsContext GhcPs), LHsKind GhcPs) -> HappyWrap101
HappyWrap101 Located (Maybe (LHsContext GhcPs), LHsKind GhcPs)
x)
{-# INLINE happyIn101 #-}
happyOut101 :: (HappyAbsSyn ) -> HappyWrap101
happyOut101 :: HappyAbsSyn -> HappyWrap101
happyOut101 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap101
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut101 #-}
newtype HappyWrap102 = HappyWrap102 (Located ([AddAnn],(Maybe (LHsContext GhcPs), Maybe [LHsTyVarBndr () GhcPs], LHsType GhcPs)))
happyIn102 :: (Located ([AddAnn],(Maybe (LHsContext GhcPs), Maybe [LHsTyVarBndr () GhcPs], LHsType GhcPs))) -> (HappyAbsSyn )
happyIn102 :: Located
  ([AddAnn],
   (Maybe (LHsContext GhcPs), Maybe [LHsTyVarBndr () GhcPs],
    LHsKind GhcPs))
-> HappyAbsSyn
happyIn102 Located
  ([AddAnn],
   (Maybe (LHsContext GhcPs), Maybe [LHsTyVarBndr () GhcPs],
    LHsKind GhcPs))
x = HappyWrap102 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located
  ([AddAnn],
   (Maybe (LHsContext GhcPs), Maybe [LHsTyVarBndr () GhcPs],
    LHsKind GhcPs))
-> HappyWrap102
HappyWrap102 Located
  ([AddAnn],
   (Maybe (LHsContext GhcPs), Maybe [LHsTyVarBndr () GhcPs],
    LHsKind GhcPs))
x)
{-# INLINE happyIn102 #-}
happyOut102 :: (HappyAbsSyn ) -> HappyWrap102
happyOut102 :: HappyAbsSyn -> HappyWrap102
happyOut102 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap102
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut102 #-}
newtype HappyWrap103 = HappyWrap103 (Maybe (Located CType))
happyIn103 :: (Maybe (Located CType)) -> (HappyAbsSyn )
happyIn103 :: Maybe (Located CType) -> HappyAbsSyn
happyIn103 Maybe (Located CType)
x = HappyWrap103 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Maybe (Located CType) -> HappyWrap103
HappyWrap103 Maybe (Located CType)
x)
{-# INLINE happyIn103 #-}
happyOut103 :: (HappyAbsSyn ) -> HappyWrap103
happyOut103 :: HappyAbsSyn -> HappyWrap103
happyOut103 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap103
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut103 #-}
newtype HappyWrap104 = HappyWrap104 (LDerivDecl GhcPs)
happyIn104 :: (LDerivDecl GhcPs) -> (HappyAbsSyn )
happyIn104 :: LDerivDecl GhcPs -> HappyAbsSyn
happyIn104 LDerivDecl GhcPs
x = HappyWrap104 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LDerivDecl GhcPs -> HappyWrap104
HappyWrap104 LDerivDecl GhcPs
x)
{-# INLINE happyIn104 #-}
happyOut104 :: (HappyAbsSyn ) -> HappyWrap104
happyOut104 :: HappyAbsSyn -> HappyWrap104
happyOut104 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap104
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut104 #-}
newtype HappyWrap105 = HappyWrap105 (LRoleAnnotDecl GhcPs)
happyIn105 :: (LRoleAnnotDecl GhcPs) -> (HappyAbsSyn )
happyIn105 :: LRoleAnnotDecl GhcPs -> HappyAbsSyn
happyIn105 LRoleAnnotDecl GhcPs
x = HappyWrap105 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LRoleAnnotDecl GhcPs -> HappyWrap105
HappyWrap105 LRoleAnnotDecl GhcPs
x)
{-# INLINE happyIn105 #-}
happyOut105 :: (HappyAbsSyn ) -> HappyWrap105
happyOut105 :: HappyAbsSyn -> HappyWrap105
happyOut105 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap105
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut105 #-}
newtype HappyWrap106 = HappyWrap106 (Located [Located (Maybe FastString)])
happyIn106 :: (Located [Located (Maybe FastString)]) -> (HappyAbsSyn )
happyIn106 :: Located [Located (Maybe FastString)] -> HappyAbsSyn
happyIn106 Located [Located (Maybe FastString)]
x = HappyWrap106 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [Located (Maybe FastString)] -> HappyWrap106
HappyWrap106 Located [Located (Maybe FastString)]
x)
{-# INLINE happyIn106 #-}
happyOut106 :: (HappyAbsSyn ) -> HappyWrap106
happyOut106 :: HappyAbsSyn -> HappyWrap106
happyOut106 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap106
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut106 #-}
newtype HappyWrap107 = HappyWrap107 (Located [Located (Maybe FastString)])
happyIn107 :: (Located [Located (Maybe FastString)]) -> (HappyAbsSyn )
happyIn107 :: Located [Located (Maybe FastString)] -> HappyAbsSyn
happyIn107 Located [Located (Maybe FastString)]
x = HappyWrap107 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [Located (Maybe FastString)] -> HappyWrap107
HappyWrap107 Located [Located (Maybe FastString)]
x)
{-# INLINE happyIn107 #-}
happyOut107 :: (HappyAbsSyn ) -> HappyWrap107
happyOut107 :: HappyAbsSyn -> HappyWrap107
happyOut107 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap107
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut107 #-}
newtype HappyWrap108 = HappyWrap108 (Located (Maybe FastString))
happyIn108 :: (Located (Maybe FastString)) -> (HappyAbsSyn )
happyIn108 :: Located (Maybe FastString) -> HappyAbsSyn
happyIn108 Located (Maybe FastString)
x = HappyWrap108 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (Maybe FastString) -> HappyWrap108
HappyWrap108 Located (Maybe FastString)
x)
{-# INLINE happyIn108 #-}
happyOut108 :: (HappyAbsSyn ) -> HappyWrap108
happyOut108 :: HappyAbsSyn -> HappyWrap108
happyOut108 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap108
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut108 #-}
newtype HappyWrap109 = HappyWrap109 (LHsDecl GhcPs)
happyIn109 :: (LHsDecl GhcPs) -> (HappyAbsSyn )
happyIn109 :: LHsDecl GhcPs -> HappyAbsSyn
happyIn109 LHsDecl GhcPs
x = HappyWrap109 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsDecl GhcPs -> HappyWrap109
HappyWrap109 LHsDecl GhcPs
x)
{-# INLINE happyIn109 #-}
happyOut109 :: (HappyAbsSyn ) -> HappyWrap109
happyOut109 :: HappyAbsSyn -> HappyWrap109
happyOut109 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap109
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut109 #-}
newtype HappyWrap110 = HappyWrap110 ((Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn]))
happyIn110 :: ((Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn])) -> (HappyAbsSyn )
happyIn110 :: (Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn])
-> HappyAbsSyn
happyIn110 (Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn])
x = HappyWrap110 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ((Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn])
-> HappyWrap110
HappyWrap110 (Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn])
x)
{-# INLINE happyIn110 #-}
happyOut110 :: (HappyAbsSyn ) -> HappyWrap110
happyOut110 :: HappyAbsSyn -> HappyWrap110
happyOut110 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap110
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut110 #-}
newtype HappyWrap111 = HappyWrap111 ([Located RdrName])
happyIn111 :: ([Located RdrName]) -> (HappyAbsSyn )
happyIn111 :: [Located RdrName] -> HappyAbsSyn
happyIn111 [Located RdrName]
x = HappyWrap111 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([Located RdrName] -> HappyWrap111
HappyWrap111 [Located RdrName]
x)
{-# INLINE happyIn111 #-}
happyOut111 :: (HappyAbsSyn ) -> HappyWrap111
happyOut111 :: HappyAbsSyn -> HappyWrap111
happyOut111 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap111
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut111 #-}
newtype HappyWrap112 = HappyWrap112 ([RecordPatSynField (Located RdrName)])
happyIn112 :: ([RecordPatSynField (Located RdrName)]) -> (HappyAbsSyn )
happyIn112 :: [RecordPatSynField (Located RdrName)] -> HappyAbsSyn
happyIn112 [RecordPatSynField (Located RdrName)]
x = HappyWrap112 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([RecordPatSynField (Located RdrName)] -> HappyWrap112
HappyWrap112 [RecordPatSynField (Located RdrName)]
x)
{-# INLINE happyIn112 #-}
happyOut112 :: (HappyAbsSyn ) -> HappyWrap112
happyOut112 :: HappyAbsSyn -> HappyWrap112
happyOut112 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap112
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut112 #-}
newtype HappyWrap113 = HappyWrap113 (Located ([AddAnn]
                         , Located (OrdList (LHsDecl GhcPs))))
happyIn113 :: (Located ([AddAnn]
                         , Located (OrdList (LHsDecl GhcPs)))) -> (HappyAbsSyn )
happyIn113 :: Located ([AddAnn], Located (OrdList (LHsDecl GhcPs)))
-> HappyAbsSyn
happyIn113 Located ([AddAnn], Located (OrdList (LHsDecl GhcPs)))
x = HappyWrap113 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], Located (OrdList (LHsDecl GhcPs)))
-> HappyWrap113
HappyWrap113 Located ([AddAnn], Located (OrdList (LHsDecl GhcPs)))
x)
{-# INLINE happyIn113 #-}
happyOut113 :: (HappyAbsSyn ) -> HappyWrap113
happyOut113 :: HappyAbsSyn -> HappyWrap113
happyOut113 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap113
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut113 #-}
newtype HappyWrap114 = HappyWrap114 (LSig GhcPs)
happyIn114 :: (LSig GhcPs) -> (HappyAbsSyn )
happyIn114 :: LSig GhcPs -> HappyAbsSyn
happyIn114 LSig GhcPs
x = HappyWrap114 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LSig GhcPs -> HappyWrap114
HappyWrap114 LSig GhcPs
x)
{-# INLINE happyIn114 #-}
happyOut114 :: (HappyAbsSyn ) -> HappyWrap114
happyOut114 :: HappyAbsSyn -> HappyWrap114
happyOut114 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap114
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut114 #-}
newtype HappyWrap115 = HappyWrap115 (LHsDecl GhcPs)
happyIn115 :: (LHsDecl GhcPs) -> (HappyAbsSyn )
happyIn115 :: LHsDecl GhcPs -> HappyAbsSyn
happyIn115 LHsDecl GhcPs
x = HappyWrap115 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsDecl GhcPs -> HappyWrap115
HappyWrap115 LHsDecl GhcPs
x)
{-# INLINE happyIn115 #-}
happyOut115 :: (HappyAbsSyn ) -> HappyWrap115
happyOut115 :: HappyAbsSyn -> HappyWrap115
happyOut115 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap115
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut115 #-}
newtype HappyWrap116 = HappyWrap116 (Located ([AddAnn],OrdList (LHsDecl GhcPs)))
happyIn116 :: (Located ([AddAnn],OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )
happyIn116 :: Located ([AddAnn], OrdList (LHsDecl GhcPs)) -> HappyAbsSyn
happyIn116 Located ([AddAnn], OrdList (LHsDecl GhcPs))
x = HappyWrap116 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], OrdList (LHsDecl GhcPs)) -> HappyWrap116
HappyWrap116 Located ([AddAnn], OrdList (LHsDecl GhcPs))
x)
{-# INLINE happyIn116 #-}
happyOut116 :: (HappyAbsSyn ) -> HappyWrap116
happyOut116 :: HappyAbsSyn -> HappyWrap116
happyOut116 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap116
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut116 #-}
newtype HappyWrap117 = HappyWrap117 (Located ([AddAnn]
                     , OrdList (LHsDecl GhcPs)
                     , LayoutInfo))
happyIn117 :: (Located ([AddAnn]
                     , OrdList (LHsDecl GhcPs)
                     , LayoutInfo)) -> (HappyAbsSyn )
happyIn117 :: Located ([AddAnn], OrdList (LHsDecl GhcPs), LayoutInfo)
-> HappyAbsSyn
happyIn117 Located ([AddAnn], OrdList (LHsDecl GhcPs), LayoutInfo)
x = HappyWrap117 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], OrdList (LHsDecl GhcPs), LayoutInfo)
-> HappyWrap117
HappyWrap117 Located ([AddAnn], OrdList (LHsDecl GhcPs), LayoutInfo)
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))    -- Reversed
                       ,LayoutInfo))
happyIn118 :: (Located ([AddAnn]
                       ,(OrdList (LHsDecl GhcPs))    -- Reversed
                       ,LayoutInfo)) -> (HappyAbsSyn )
happyIn118 :: Located ([AddAnn], OrdList (LHsDecl GhcPs), LayoutInfo)
-> HappyAbsSyn
happyIn118 Located ([AddAnn], OrdList (LHsDecl GhcPs), LayoutInfo)
x = HappyWrap118 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], OrdList (LHsDecl GhcPs), LayoutInfo)
-> HappyWrap118
HappyWrap118 Located ([AddAnn], OrdList (LHsDecl GhcPs), LayoutInfo)
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 (OrdList (LHsDecl GhcPs)))
happyIn119 :: (Located (OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )
happyIn119 :: Located (OrdList (LHsDecl GhcPs)) -> HappyAbsSyn
happyIn119 Located (OrdList (LHsDecl GhcPs))
x = HappyWrap119 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (OrdList (LHsDecl GhcPs)) -> HappyWrap119
HappyWrap119 Located (OrdList (LHsDecl GhcPs))
x)
{-# INLINE happyIn119 #-}
happyOut119 :: (HappyAbsSyn ) -> HappyWrap119
happyOut119 :: HappyAbsSyn -> HappyWrap119
happyOut119 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 ([AddAnn]
                     , OrdList (LHsDecl GhcPs)))
happyIn121 :: (Located ([AddAnn]
                     , OrdList (LHsDecl GhcPs))) -> (HappyAbsSyn )
happyIn121 :: Located ([AddAnn], OrdList (LHsDecl GhcPs)) -> HappyAbsSyn
happyIn121 Located ([AddAnn], OrdList (LHsDecl GhcPs))
x = HappyWrap121 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], OrdList (LHsDecl GhcPs)) -> HappyWrap121
HappyWrap121 Located ([AddAnn], OrdList (LHsDecl GhcPs))
x)
{-# INLINE happyIn121 #-}
happyOut121 :: (HappyAbsSyn ) -> HappyWrap121
happyOut121 :: HappyAbsSyn -> HappyWrap121
happyOut121 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],Located (OrdList (LHsDecl GhcPs))))
happyIn124 :: (Located ([AddAnn],Located (OrdList (LHsDecl GhcPs)))) -> (HappyAbsSyn )
happyIn124 :: Located ([AddAnn], Located (OrdList (LHsDecl GhcPs)))
-> HappyAbsSyn
happyIn124 Located ([AddAnn], Located (OrdList (LHsDecl GhcPs)))
x = HappyWrap124 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], Located (OrdList (LHsDecl GhcPs)))
-> HappyWrap124
HappyWrap124 Located ([AddAnn], Located (OrdList (LHsDecl GhcPs)))
x)
{-# INLINE happyIn124 #-}
happyOut124 :: (HappyAbsSyn ) -> HappyWrap124
happyOut124 :: HappyAbsSyn -> HappyWrap124
happyOut124 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap124
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut124 #-}
newtype HappyWrap125 = HappyWrap125 (Located ([AddAnn],Located (HsLocalBinds GhcPs)))
happyIn125 :: (Located ([AddAnn],Located (HsLocalBinds GhcPs))) -> (HappyAbsSyn )
happyIn125 :: Located ([AddAnn], Located (HsLocalBinds GhcPs)) -> HappyAbsSyn
happyIn125 Located ([AddAnn], Located (HsLocalBinds GhcPs))
x = HappyWrap125 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], Located (HsLocalBinds GhcPs)) -> HappyWrap125
HappyWrap125 Located ([AddAnn], Located (HsLocalBinds GhcPs))
x)
{-# INLINE happyIn125 #-}
happyOut125 :: (HappyAbsSyn ) -> HappyWrap125
happyOut125 :: HappyAbsSyn -> HappyWrap125
happyOut125 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap125
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut125 #-}
newtype HappyWrap126 = HappyWrap126 (Located ([AddAnn],Located (HsLocalBinds GhcPs)))
happyIn126 :: (Located ([AddAnn],Located (HsLocalBinds GhcPs))) -> (HappyAbsSyn )
happyIn126 :: Located ([AddAnn], Located (HsLocalBinds GhcPs)) -> HappyAbsSyn
happyIn126 Located ([AddAnn], Located (HsLocalBinds GhcPs))
x = HappyWrap126 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], Located (HsLocalBinds GhcPs)) -> HappyWrap126
HappyWrap126 Located ([AddAnn], Located (HsLocalBinds GhcPs))
x)
{-# INLINE happyIn126 #-}
happyOut126 :: (HappyAbsSyn ) -> HappyWrap126
happyOut126 :: HappyAbsSyn -> HappyWrap126
happyOut126 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap126
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut126 #-}
newtype HappyWrap127 = HappyWrap127 (OrdList (LRuleDecl GhcPs))
happyIn127 :: (OrdList (LRuleDecl GhcPs)) -> (HappyAbsSyn )
happyIn127 :: OrdList (LRuleDecl GhcPs) -> HappyAbsSyn
happyIn127 OrdList (LRuleDecl GhcPs)
x = HappyWrap127 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList (LRuleDecl GhcPs) -> HappyWrap127
HappyWrap127 OrdList (LRuleDecl GhcPs)
x)
{-# INLINE happyIn127 #-}
happyOut127 :: (HappyAbsSyn ) -> HappyWrap127
happyOut127 :: HappyAbsSyn -> HappyWrap127
happyOut127 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap127
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut127 #-}
newtype HappyWrap128 = HappyWrap128 (LRuleDecl GhcPs)
happyIn128 :: (LRuleDecl GhcPs) -> (HappyAbsSyn )
happyIn128 :: LRuleDecl GhcPs -> HappyAbsSyn
happyIn128 LRuleDecl GhcPs
x = HappyWrap128 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LRuleDecl GhcPs -> HappyWrap128
HappyWrap128 LRuleDecl GhcPs
x)
{-# INLINE happyIn128 #-}
happyOut128 :: (HappyAbsSyn ) -> HappyWrap128
happyOut128 :: HappyAbsSyn -> HappyWrap128
happyOut128 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap128
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut128 #-}
newtype HappyWrap129 = HappyWrap129 (([AddAnn],Maybe Activation))
happyIn129 :: (([AddAnn],Maybe Activation)) -> (HappyAbsSyn )
happyIn129 :: ([AddAnn], Maybe Activation) -> HappyAbsSyn
happyIn129 ([AddAnn], Maybe Activation)
x = HappyWrap129 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], Maybe Activation) -> HappyWrap129
HappyWrap129 ([AddAnn], Maybe Activation)
x)
{-# INLINE happyIn129 #-}
happyOut129 :: (HappyAbsSyn ) -> HappyWrap129
happyOut129 :: HappyAbsSyn -> HappyWrap129
happyOut129 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap129
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut129 #-}
newtype HappyWrap130 = HappyWrap130 ([AddAnn])
happyIn130 :: ([AddAnn]) -> (HappyAbsSyn )
happyIn130 :: [AddAnn] -> HappyAbsSyn
happyIn130 [AddAnn]
x = HappyWrap130 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([AddAnn] -> HappyWrap130
HappyWrap130 [AddAnn]
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]
                              ,Activation))
happyIn131 :: (([AddAnn]
                              ,Activation)) -> (HappyAbsSyn )
happyIn131 :: ([AddAnn], Activation) -> HappyAbsSyn
happyIn131 ([AddAnn], Activation)
x = HappyWrap131 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], Activation) -> HappyWrap131
HappyWrap131 ([AddAnn], 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], Maybe [LHsTyVarBndr () GhcPs], [LRuleBndr GhcPs]))
happyIn132 :: (([AddAnn], Maybe [LHsTyVarBndr () GhcPs], [LRuleBndr GhcPs])) -> (HappyAbsSyn )
happyIn132 :: ([AddAnn], Maybe [LHsTyVarBndr () GhcPs], [LRuleBndr GhcPs])
-> HappyAbsSyn
happyIn132 ([AddAnn], Maybe [LHsTyVarBndr () GhcPs], [LRuleBndr GhcPs])
x = HappyWrap132 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], Maybe [LHsTyVarBndr () GhcPs], [LRuleBndr GhcPs])
-> HappyWrap132
HappyWrap132 ([AddAnn], Maybe [LHsTyVarBndr () GhcPs], [LRuleBndr GhcPs])
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 ([LRuleTyTmVar])
happyIn133 :: ([LRuleTyTmVar]) -> (HappyAbsSyn )
happyIn133 :: [LRuleTyTmVar] -> HappyAbsSyn
happyIn133 [LRuleTyTmVar]
x = HappyWrap133 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LRuleTyTmVar] -> HappyWrap133
HappyWrap133 [LRuleTyTmVar]
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 (OrdList (LWarnDecl GhcPs))
happyIn135 :: (OrdList (LWarnDecl GhcPs)) -> (HappyAbsSyn )
happyIn135 :: OrdList (LWarnDecl GhcPs) -> HappyAbsSyn
happyIn135 OrdList (LWarnDecl GhcPs)
x = HappyWrap135 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList (LWarnDecl GhcPs) -> HappyWrap135
HappyWrap135 OrdList (LWarnDecl GhcPs)
x)
{-# INLINE happyIn135 #-}
happyOut135 :: (HappyAbsSyn ) -> HappyWrap135
happyOut135 :: HappyAbsSyn -> HappyWrap135
happyOut135 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 (Located ([AddAnn],[Located StringLiteral]))
happyIn139 :: (Located ([AddAnn],[Located StringLiteral])) -> (HappyAbsSyn )
happyIn139 :: Located ([AddAnn], [Located StringLiteral]) -> HappyAbsSyn
happyIn139 Located ([AddAnn], [Located StringLiteral])
x = HappyWrap139 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], [Located StringLiteral]) -> HappyWrap139
HappyWrap139 Located ([AddAnn], [Located StringLiteral])
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 (OrdList (Located StringLiteral)))
happyIn140 :: (Located (OrdList (Located StringLiteral))) -> (HappyAbsSyn )
happyIn140 :: Located (OrdList (Located StringLiteral)) -> HappyAbsSyn
happyIn140 Located (OrdList (Located StringLiteral))
x = HappyWrap140 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (OrdList (Located StringLiteral)) -> HappyWrap140
HappyWrap140 Located (OrdList (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 (LHsDecl GhcPs)
happyIn141 :: (LHsDecl GhcPs) -> (HappyAbsSyn )
happyIn141 :: LHsDecl GhcPs -> HappyAbsSyn
happyIn141 LHsDecl GhcPs
x = HappyWrap141 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsDecl GhcPs -> HappyWrap141
HappyWrap141 LHsDecl GhcPs
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 (Located ([AddAnn],HsDecl GhcPs))
happyIn142 :: (Located ([AddAnn],HsDecl GhcPs)) -> (HappyAbsSyn )
happyIn142 :: Located ([AddAnn], HsDecl GhcPs) -> HappyAbsSyn
happyIn142 Located ([AddAnn], HsDecl GhcPs)
x = HappyWrap142 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], HsDecl GhcPs) -> HappyWrap142
HappyWrap142 Located ([AddAnn], HsDecl 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 CCallConv)
happyIn143 :: (Located CCallConv) -> (HappyAbsSyn )
happyIn143 :: Located CCallConv -> HappyAbsSyn
happyIn143 Located CCallConv
x = HappyWrap143 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located CCallConv -> HappyWrap143
HappyWrap143 Located CCallConv
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 Safety)
happyIn144 :: (Located Safety) -> (HappyAbsSyn )
happyIn144 :: Located Safety -> HappyAbsSyn
happyIn144 Located Safety
x = HappyWrap144 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located Safety -> HappyWrap144
HappyWrap144 Located Safety
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 ([AddAnn]
                    ,(Located StringLiteral, Located RdrName, LHsSigType GhcPs)))
happyIn145 :: (Located ([AddAnn]
                    ,(Located StringLiteral, Located RdrName, LHsSigType GhcPs))) -> (HappyAbsSyn )
happyIn145 :: Located
  ([AddAnn],
   (Located StringLiteral, Located RdrName, LHsSigType GhcPs))
-> HappyAbsSyn
happyIn145 Located
  ([AddAnn],
   (Located StringLiteral, Located RdrName, LHsSigType GhcPs))
x = HappyWrap145 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located
  ([AddAnn],
   (Located StringLiteral, Located RdrName, LHsSigType GhcPs))
-> HappyWrap145
HappyWrap145 Located
  ([AddAnn],
   (Located StringLiteral, Located RdrName, LHsSigType GhcPs))
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 (([AddAnn], Maybe (LHsType GhcPs)))
happyIn146 :: (([AddAnn], Maybe (LHsType GhcPs))) -> (HappyAbsSyn )
happyIn146 :: ([AddAnn], Maybe (LHsKind GhcPs)) -> HappyAbsSyn
happyIn146 ([AddAnn], Maybe (LHsKind GhcPs))
x = HappyWrap146 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], Maybe (LHsKind GhcPs)) -> HappyWrap146
HappyWrap146 ([AddAnn], Maybe (LHsKind 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 (Located RdrName)))
happyIn147 :: (([AddAnn], Maybe (Located RdrName))) -> (HappyAbsSyn )
happyIn147 :: ([AddAnn], Maybe (Located RdrName)) -> HappyAbsSyn
happyIn147 ([AddAnn], Maybe (Located RdrName))
x = HappyWrap147 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], Maybe (Located RdrName)) -> HappyWrap147
HappyWrap147 ([AddAnn], Maybe (Located RdrName))
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 (LHsType GhcPs)
happyIn148 :: (LHsType GhcPs) -> (HappyAbsSyn )
happyIn148 :: LHsKind GhcPs -> HappyAbsSyn
happyIn148 LHsKind GhcPs
x = HappyWrap148 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsKind GhcPs -> HappyWrap148
HappyWrap148 LHsKind GhcPs
x)
{-# INLINE happyIn148 #-}
happyOut148 :: (HappyAbsSyn ) -> HappyWrap148
happyOut148 :: HappyAbsSyn -> HappyWrap148
happyOut148 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap148
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut148 #-}
newtype HappyWrap149 = HappyWrap149 (Located [Located RdrName])
happyIn149 :: (Located [Located RdrName]) -> (HappyAbsSyn )
happyIn149 :: Located [Located RdrName] -> HappyAbsSyn
happyIn149 Located [Located RdrName]
x = HappyWrap149 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [Located RdrName] -> HappyWrap149
HappyWrap149 Located [Located RdrName]
x)
{-# INLINE happyIn149 #-}
happyOut149 :: (HappyAbsSyn ) -> HappyWrap149
happyOut149 :: HappyAbsSyn -> HappyWrap149
happyOut149 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap149
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut149 #-}
newtype HappyWrap150 = HappyWrap150 ((OrdList (LHsSigType GhcPs)))
happyIn150 :: ((OrdList (LHsSigType GhcPs))) -> (HappyAbsSyn )
happyIn150 :: OrdList (LHsSigType GhcPs) -> HappyAbsSyn
happyIn150 OrdList (LHsSigType GhcPs)
x = HappyWrap150 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (OrdList (LHsSigType GhcPs) -> HappyWrap150
HappyWrap150 OrdList (LHsSigType GhcPs)
x)
{-# INLINE happyIn150 #-}
happyOut150 :: (HappyAbsSyn ) -> HappyWrap150
happyOut150 :: HappyAbsSyn -> HappyWrap150
happyOut150 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap150
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut150 #-}
newtype HappyWrap151 = HappyWrap151 (Located ([AddAnn], SourceText, SrcUnpackedness))
happyIn151 :: (Located ([AddAnn], SourceText, SrcUnpackedness)) -> (HappyAbsSyn )
happyIn151 :: Located ([AddAnn], SourceText, SrcUnpackedness) -> HappyAbsSyn
happyIn151 Located ([AddAnn], SourceText, SrcUnpackedness)
x = HappyWrap151 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], SourceText, SrcUnpackedness) -> HappyWrap151
HappyWrap151 Located ([AddAnn], SourceText, SrcUnpackedness)
x)
{-# INLINE happyIn151 #-}
happyOut151 :: (HappyAbsSyn ) -> HappyWrap151
happyOut151 :: HappyAbsSyn -> HappyWrap151
happyOut151 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap151
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut151 #-}
newtype HappyWrap152 = HappyWrap152 (Located ([AddAnn], HsForAllTelescope GhcPs))
happyIn152 :: (Located ([AddAnn], HsForAllTelescope GhcPs)) -> (HappyAbsSyn )
happyIn152 :: Located ([AddAnn], HsForAllTelescope GhcPs) -> HappyAbsSyn
happyIn152 Located ([AddAnn], HsForAllTelescope GhcPs)
x = HappyWrap152 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], HsForAllTelescope GhcPs) -> HappyWrap152
HappyWrap152 Located ([AddAnn], HsForAllTelescope 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 (LHsType GhcPs)
happyIn153 :: (LHsType GhcPs) -> (HappyAbsSyn )
happyIn153 :: LHsKind GhcPs -> HappyAbsSyn
happyIn153 LHsKind GhcPs
x = HappyWrap153 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsKind GhcPs -> HappyWrap153
HappyWrap153 LHsKind GhcPs
x)
{-# INLINE happyIn153 #-}
happyOut153 :: (HappyAbsSyn ) -> HappyWrap153
happyOut153 :: HappyAbsSyn -> HappyWrap153
happyOut153 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap153
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut153 #-}
newtype HappyWrap154 = HappyWrap154 (LHsType GhcPs)
happyIn154 :: (LHsType GhcPs) -> (HappyAbsSyn )
happyIn154 :: LHsKind GhcPs -> HappyAbsSyn
happyIn154 LHsKind GhcPs
x = HappyWrap154 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsKind GhcPs -> HappyWrap154
HappyWrap154 LHsKind GhcPs
x)
{-# INLINE happyIn154 #-}
happyOut154 :: (HappyAbsSyn ) -> HappyWrap154
happyOut154 :: HappyAbsSyn -> HappyWrap154
happyOut154 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap154
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut154 #-}
newtype HappyWrap155 = HappyWrap155 (LHsContext GhcPs)
happyIn155 :: (LHsContext GhcPs) -> (HappyAbsSyn )
happyIn155 :: LHsContext GhcPs -> HappyAbsSyn
happyIn155 LHsContext GhcPs
x = HappyWrap155 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsContext GhcPs -> HappyWrap155
HappyWrap155 LHsContext 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 (Located (IsUnicodeSyntax -> (HsArrow GhcPs, AddAnn)))
happyIn157 :: (Located (IsUnicodeSyntax -> (HsArrow GhcPs, AddAnn))) -> (HappyAbsSyn )
happyIn157 :: Located (IsUnicodeSyntax -> (HsArrow GhcPs, AddAnn)) -> HappyAbsSyn
happyIn157 Located (IsUnicodeSyntax -> (HsArrow GhcPs, AddAnn))
x = HappyWrap157 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (IsUnicodeSyntax -> (HsArrow GhcPs, AddAnn))
-> HappyWrap157
HappyWrap157 Located (IsUnicodeSyntax -> (HsArrow GhcPs, AddAnn))
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 (Located [Located TyEl])
happyIn159 :: (Located [Located TyEl]) -> (HappyAbsSyn )
happyIn159 :: Located [Located TyEl] -> HappyAbsSyn
happyIn159 Located [Located TyEl]
x = HappyWrap159 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [Located TyEl] -> HappyWrap159
HappyWrap159 Located [Located TyEl]
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 (Located TyEl)
happyIn160 :: (Located TyEl) -> (HappyAbsSyn )
happyIn160 :: Located TyEl -> HappyAbsSyn
happyIn160 Located TyEl
x = HappyWrap160 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located TyEl -> HappyWrap160
HappyWrap160 Located TyEl
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 (LHsSigType GhcPs)
happyIn162 :: (LHsSigType GhcPs) -> (HappyAbsSyn )
happyIn162 :: LHsSigType GhcPs -> HappyAbsSyn
happyIn162 LHsSigType GhcPs
x = HappyWrap162 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsSigType GhcPs -> HappyWrap162
HappyWrap162 LHsSigType 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 ([LHsSigType GhcPs])
happyIn163 :: ([LHsSigType GhcPs]) -> (HappyAbsSyn )
happyIn163 :: [LHsSigType GhcPs] -> HappyAbsSyn
happyIn163 [LHsSigType GhcPs]
x = HappyWrap163 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LHsSigType GhcPs] -> HappyWrap163
HappyWrap163 [LHsSigType 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 ([LHsType GhcPs])
happyIn164 :: ([LHsType GhcPs]) -> (HappyAbsSyn )
happyIn164 :: [LHsKind GhcPs] -> HappyAbsSyn
happyIn164 [LHsKind GhcPs]
x = HappyWrap164 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LHsKind GhcPs] -> HappyWrap164
HappyWrap164 [LHsKind GhcPs]
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 ([LHsType GhcPs])
happyIn165 :: ([LHsType GhcPs]) -> (HappyAbsSyn )
happyIn165 :: [LHsKind GhcPs] -> HappyAbsSyn
happyIn165 [LHsKind GhcPs]
x = HappyWrap165 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LHsKind GhcPs] -> HappyWrap165
HappyWrap165 [LHsKind GhcPs]
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 ([LHsTyVarBndr Specificity GhcPs])
happyIn167 :: ([LHsTyVarBndr Specificity GhcPs]) -> (HappyAbsSyn )
happyIn167 :: [LHsTyVarBndr Specificity GhcPs] -> HappyAbsSyn
happyIn167 [LHsTyVarBndr Specificity GhcPs]
x = HappyWrap167 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LHsTyVarBndr Specificity GhcPs] -> HappyWrap167
HappyWrap167 [LHsTyVarBndr Specificity GhcPs]
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 (LHsTyVarBndr Specificity GhcPs)
happyIn168 :: (LHsTyVarBndr Specificity GhcPs) -> (HappyAbsSyn )
happyIn168 :: LHsTyVarBndr Specificity GhcPs -> HappyAbsSyn
happyIn168 LHsTyVarBndr Specificity GhcPs
x = HappyWrap168 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsTyVarBndr Specificity GhcPs -> HappyWrap168
HappyWrap168 LHsTyVarBndr Specificity GhcPs
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 (LHsTyVarBndr Specificity GhcPs)
happyIn169 :: (LHsTyVarBndr Specificity GhcPs) -> (HappyAbsSyn )
happyIn169 :: LHsTyVarBndr Specificity GhcPs -> HappyAbsSyn
happyIn169 LHsTyVarBndr Specificity GhcPs
x = HappyWrap169 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsTyVarBndr Specificity GhcPs -> HappyWrap169
HappyWrap169 LHsTyVarBndr Specificity 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 (Located ([AddAnn],[Located (FunDep (Located RdrName))]))
happyIn170 :: (Located ([AddAnn],[Located (FunDep (Located RdrName))])) -> (HappyAbsSyn )
happyIn170 :: Located ([AddAnn], [Located (FunDep (Located RdrName))])
-> HappyAbsSyn
happyIn170 Located ([AddAnn], [Located (FunDep (Located RdrName))])
x = HappyWrap170 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], [Located (FunDep (Located RdrName))])
-> HappyWrap170
HappyWrap170 Located ([AddAnn], [Located (FunDep (Located RdrName))])
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 (Located [Located (FunDep (Located RdrName))])
happyIn171 :: (Located [Located (FunDep (Located RdrName))]) -> (HappyAbsSyn )
happyIn171 :: Located [Located (FunDep (Located RdrName))] -> HappyAbsSyn
happyIn171 Located [Located (FunDep (Located RdrName))]
x = HappyWrap171 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [Located (FunDep (Located RdrName))] -> HappyWrap171
HappyWrap171 Located [Located (FunDep (Located RdrName))]
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 (Located (FunDep (Located RdrName)))
happyIn172 :: (Located (FunDep (Located RdrName))) -> (HappyAbsSyn )
happyIn172 :: Located (FunDep (Located RdrName)) -> HappyAbsSyn
happyIn172 Located (FunDep (Located RdrName))
x = HappyWrap172 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (FunDep (Located RdrName)) -> HappyWrap172
HappyWrap172 Located (FunDep (Located RdrName))
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 (Located [Located RdrName])
happyIn173 :: (Located [Located RdrName]) -> (HappyAbsSyn )
happyIn173 :: Located [Located RdrName] -> HappyAbsSyn
happyIn173 Located [Located RdrName]
x = HappyWrap173 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [Located RdrName] -> HappyWrap173
HappyWrap173 Located [Located RdrName]
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 (LHsKind GhcPs)
happyIn174 :: (LHsKind 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 (Located ([AddAnn]
                          ,[LConDecl GhcPs]))
happyIn175 :: (Located ([AddAnn]
                          ,[LConDecl GhcPs])) -> (HappyAbsSyn )
happyIn175 :: Located ([AddAnn], [LConDecl GhcPs]) -> HappyAbsSyn
happyIn175 Located ([AddAnn], [LConDecl GhcPs])
x = HappyWrap175 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], [LConDecl GhcPs]) -> HappyWrap175
HappyWrap175 Located ([AddAnn], [LConDecl 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 (Located [LConDecl GhcPs])
happyIn176 :: (Located [LConDecl GhcPs]) -> (HappyAbsSyn )
happyIn176 :: Located [LConDecl GhcPs] -> HappyAbsSyn
happyIn176 Located [LConDecl GhcPs]
x = HappyWrap176 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [LConDecl GhcPs] -> HappyWrap176
HappyWrap176 Located [LConDecl 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 (LConDecl GhcPs)
happyIn177 :: (LConDecl GhcPs) -> (HappyAbsSyn )
happyIn177 :: LConDecl GhcPs -> HappyAbsSyn
happyIn177 LConDecl GhcPs
x = HappyWrap177 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LConDecl GhcPs -> HappyWrap177
HappyWrap177 LConDecl GhcPs
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 ([AddAnn],[LConDecl GhcPs]))
happyIn178 :: (Located ([AddAnn],[LConDecl GhcPs])) -> (HappyAbsSyn )
happyIn178 :: Located ([AddAnn], [LConDecl GhcPs]) -> HappyAbsSyn
happyIn178 Located ([AddAnn], [LConDecl GhcPs])
x = HappyWrap178 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], [LConDecl GhcPs]) -> HappyWrap178
HappyWrap178 Located ([AddAnn], [LConDecl GhcPs])
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 [LConDecl GhcPs])
happyIn179 :: (Located [LConDecl GhcPs]) -> (HappyAbsSyn )
happyIn179 :: Located [LConDecl GhcPs] -> HappyAbsSyn
happyIn179 Located [LConDecl GhcPs]
x = HappyWrap179 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [LConDecl GhcPs] -> HappyWrap179
HappyWrap179 Located [LConDecl GhcPs]
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 (LConDecl GhcPs)
happyIn180 :: (LConDecl GhcPs) -> (HappyAbsSyn )
happyIn180 :: LConDecl GhcPs -> HappyAbsSyn
happyIn180 LConDecl GhcPs
x = HappyWrap180 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LConDecl GhcPs -> HappyWrap180
HappyWrap180 LConDecl GhcPs
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 (Located ([AddAnn], Maybe [LHsTyVarBndr Specificity GhcPs]))
happyIn181 :: (Located ([AddAnn], Maybe [LHsTyVarBndr Specificity GhcPs])) -> (HappyAbsSyn )
happyIn181 :: Located ([AddAnn], Maybe [LHsTyVarBndr Specificity GhcPs])
-> HappyAbsSyn
happyIn181 Located ([AddAnn], Maybe [LHsTyVarBndr Specificity GhcPs])
x = HappyWrap181 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], Maybe [LHsTyVarBndr Specificity GhcPs])
-> HappyWrap181
HappyWrap181 Located ([AddAnn], Maybe [LHsTyVarBndr Specificity 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 (Located RdrName, HsConDeclDetails GhcPs))
happyIn182 :: (Located (Located RdrName, HsConDeclDetails GhcPs)) -> (HappyAbsSyn )
happyIn182 :: Located (Located RdrName, HsConDeclDetails GhcPs) -> HappyAbsSyn
happyIn182 Located (Located RdrName, HsConDeclDetails GhcPs)
x = HappyWrap182 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (Located RdrName, HsConDeclDetails GhcPs) -> HappyWrap182
HappyWrap182 Located (Located RdrName, HsConDeclDetails 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 ([LConDeclField GhcPs])
happyIn183 :: ([LConDeclField GhcPs]) -> (HappyAbsSyn )
happyIn183 :: [LConDeclField GhcPs] -> HappyAbsSyn
happyIn183 [LConDeclField GhcPs]
x = HappyWrap183 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LConDeclField GhcPs] -> HappyWrap183
HappyWrap183 [LConDeclField 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 ([LConDeclField GhcPs])
happyIn184 :: ([LConDeclField GhcPs]) -> (HappyAbsSyn )
happyIn184 :: [LConDeclField GhcPs] -> HappyAbsSyn
happyIn184 [LConDeclField GhcPs]
x = HappyWrap184 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# ([LConDeclField GhcPs] -> HappyWrap184
HappyWrap184 [LConDeclField 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 (LConDeclField GhcPs)
happyIn185 :: (LConDeclField GhcPs) -> (HappyAbsSyn )
happyIn185 :: LConDeclField GhcPs -> HappyAbsSyn
happyIn185 LConDeclField GhcPs
x = HappyWrap185 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LConDeclField GhcPs -> HappyWrap185
HappyWrap185 LConDeclField 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 (HsDeriving GhcPs)
happyIn186 :: (HsDeriving GhcPs) -> (HappyAbsSyn )
happyIn186 :: HsDeriving GhcPs -> HappyAbsSyn
happyIn186 HsDeriving GhcPs
x = HappyWrap186 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (HsDeriving GhcPs -> HappyWrap186
HappyWrap186 HsDeriving 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 (HsDeriving GhcPs)
happyIn187 :: (HsDeriving GhcPs) -> (HappyAbsSyn )
happyIn187 :: HsDeriving GhcPs -> HappyAbsSyn
happyIn187 HsDeriving GhcPs
x = HappyWrap187 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (HsDeriving GhcPs -> HappyWrap187
HappyWrap187 HsDeriving 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 (LHsDerivingClause GhcPs)
happyIn188 :: (LHsDerivingClause GhcPs) -> (HappyAbsSyn )
happyIn188 :: LHsDerivingClause GhcPs -> HappyAbsSyn
happyIn188 LHsDerivingClause GhcPs
x = HappyWrap188 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsDerivingClause GhcPs -> HappyWrap188
HappyWrap188 LHsDerivingClause 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 [LHsSigType GhcPs])
happyIn189 :: (Located [LHsSigType GhcPs]) -> (HappyAbsSyn )
happyIn189 :: Located [LHsSigType GhcPs] -> HappyAbsSyn
happyIn189 Located [LHsSigType GhcPs]
x = HappyWrap189 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [LHsSigType GhcPs] -> HappyWrap189
HappyWrap189 Located [LHsSigType 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 (LHsDecl GhcPs)
happyIn190 :: (LHsDecl GhcPs) -> (HappyAbsSyn )
happyIn190 :: LHsDecl GhcPs -> HappyAbsSyn
happyIn190 LHsDecl GhcPs
x = HappyWrap190 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsDecl GhcPs -> HappyWrap190
HappyWrap190 LHsDecl GhcPs
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 (LHsDecl GhcPs)
happyIn191 :: (LHsDecl GhcPs) -> (HappyAbsSyn )
happyIn191 :: LHsDecl GhcPs -> HappyAbsSyn
happyIn191 LHsDecl GhcPs
x = HappyWrap191 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsDecl GhcPs -> HappyWrap191
HappyWrap191 LHsDecl 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 (Located ([AddAnn],GRHSs GhcPs (LHsExpr GhcPs)))
happyIn192 :: (Located ([AddAnn],GRHSs GhcPs (LHsExpr GhcPs))) -> (HappyAbsSyn )
happyIn192 :: Located ([AddAnn], GRHSs GhcPs (LHsExpr GhcPs)) -> HappyAbsSyn
happyIn192 Located ([AddAnn], GRHSs GhcPs (LHsExpr GhcPs))
x = HappyWrap192 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located ([AddAnn], GRHSs GhcPs (LHsExpr GhcPs)) -> HappyWrap192
HappyWrap192 Located ([AddAnn], GRHSs GhcPs (LHsExpr 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 (Located [LGRHS GhcPs (LHsExpr GhcPs)])
happyIn193 :: (Located [LGRHS GhcPs (LHsExpr GhcPs)]) -> (HappyAbsSyn )
happyIn193 :: Located [LGRHS GhcPs (LHsExpr GhcPs)] -> HappyAbsSyn
happyIn193 Located [LGRHS GhcPs (LHsExpr GhcPs)]
x = HappyWrap193 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located [LGRHS GhcPs (LHsExpr GhcPs)] -> HappyWrap193
HappyWrap193 Located [LGRHS GhcPs (LHsExpr 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 (LGRHS GhcPs (LHsExpr GhcPs))
happyIn194 :: (LGRHS GhcPs (LHsExpr GhcPs)) -> (HappyAbsSyn )
happyIn194 :: LGRHS GhcPs (LHsExpr GhcPs) -> HappyAbsSyn
happyIn194 LGRHS GhcPs (LHsExpr GhcPs)
x = HappyWrap194 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LGRHS GhcPs (LHsExpr GhcPs) -> HappyWrap194
HappyWrap194 LGRHS GhcPs (LHsExpr 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 (LHsDecl GhcPs)
happyIn195 :: (LHsDecl GhcPs) -> (HappyAbsSyn )
happyIn195 :: LHsDecl GhcPs -> HappyAbsSyn
happyIn195 LHsDecl GhcPs
x = HappyWrap195 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (LHsDecl GhcPs -> HappyWrap195
HappyWrap195 LHsDecl GhcPs
x)
{-# INLINE happyIn195 #-}
happyOut195 :: (HappyAbsSyn ) -> HappyWrap195
happyOut195 :: HappyAbsSyn -> HappyWrap195
happyOut195 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap195
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut195 #-}
newtype HappyWrap196 = HappyWrap196 (([AddAnn],Maybe Activation))
happyIn196 :: (([AddAnn],Maybe Activation)) -> (HappyAbsSyn )
happyIn196 :: ([AddAnn], Maybe Activation) -> HappyAbsSyn
happyIn196 ([AddAnn], Maybe Activation)
x = HappyWrap196 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], Maybe Activation) -> HappyWrap196
HappyWrap196 ([AddAnn], Maybe Activation)
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 (([AddAnn],Activation))
happyIn197 :: (([AddAnn],Activation)) -> (HappyAbsSyn )
happyIn197 :: ([AddAnn], Activation) -> HappyAbsSyn
happyIn197 ([AddAnn], Activation)
x = HappyWrap197 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (([AddAnn], Activation) -> HappyWrap197
HappyWrap197 ([AddAnn], Activation)
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 (Located (HsSplice GhcPs))
happyIn198 :: (Located (HsSplice GhcPs)) -> (HappyAbsSyn )
happyIn198 :: Located (HsSplice GhcPs) -> HappyAbsSyn
happyIn198 Located (HsSplice GhcPs)
x = HappyWrap198 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (Located (HsSplice GhcPs) -> HappyWrap198
HappyWrap198 Located (HsSplice 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 (ECP)
happyIn199 :: (ECP) -> (HappyAbsSyn )
happyIn199 :: ECP -> HappyAbsSyn
happyIn199 ECP
x = HappyWrap199 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (ECP -> HappyWrap199
HappyWrap199 ECP
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 (ECP)
happyIn200 :: (ECP) -> (HappyAbsSyn )
happyIn200 :: ECP -> HappyAbsSyn
happyIn200 ECP
x = HappyWrap200 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (ECP -> HappyWrap200
HappyWrap200 ECP
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 (ECP)
happyIn201 :: (ECP) -> (HappyAbsSyn )
happyIn201 :: ECP -> HappyAbsSyn
happyIn201 ECP
x = HappyWrap201 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (ECP -> HappyWrap201
HappyWrap201 ECP
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 (ECP)
happyIn202 :: (ECP) -> (HappyAbsSyn )
happyIn202 :: ECP -> HappyAbsSyn
happyIn202 ECP
x = HappyWrap202 -> HappyAbsSyn
Happy_GHC_Exts.unsafeCoerce# (ECP -> HappyWrap202
HappyWrap202 ECP
x)
{-# INLINE happyIn202 #-}
happyOut202 :: (HappyAbsSyn ) -> HappyWrap202
happyOut202 :: HappyAbsSyn -> HappyWrap202
happyOut202 HappyAbsSyn
x = HappyAbsSyn -> HappyWrap202
Happy_GHC_Exts.unsafeCoerce# HappyAbsSyn
x
{-# INLINE happyOut202 #-}
newtype HappyWrap203 =