{-# 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 :: ParserOpts -> String -> P a -> ParseResult a
--     runParser opts str parser = unP parser parseState
--     where
--       filename = "\<interactive\>"
--       location = mkRealSrcLoc (mkFastString filename) 1 1
--       buffer = stringToStringBuffer str
--       parseState = initParserState opts 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.Maybe       ( maybeToList )
import Data.List.NonEmpty ( NonEmpty((:|)) )
import qualified Data.List.NonEmpty as NE
import qualified Prelude -- for happy-generated code

import GHC.Prelude

import GHC.Hs

import GHC.Driver.Backpack.Syntax

import GHC.Unit.Info
import GHC.Unit.Module
import GHC.Unit.Module.Warnings

import GHC.Data.OrdList
import GHC.Data.BooleanFormula ( BooleanFormula(..), LBooleanFormula, mkTrue )
import GHC.Data.FastString
import GHC.Data.Maybe          ( orElse )

import GHC.Utils.Outputable
import GHC.Utils.Misc          ( looksLikePackageName, fstOf3, sndOf3, thdOf3 )
import GHC.Utils.Panic
import GHC.Prelude

import GHC.Types.Name.Reader
import GHC.Types.Name.Occurrence ( varName, dataName, tcClsName, tvName, occNameFS, mkVarOcc, occNameString)
import GHC.Types.SrcLoc
import GHC.Types.Basic
import GHC.Types.Fixity
import GHC.Types.ForeignCall
import GHC.Types.SourceFile
import GHC.Types.SourceText

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

import GHC.Parser.PostProcess
import GHC.Parser.PostProcess.Haddock
import GHC.Parser.Lexer
import GHC.Parser.Annotation
import GHC.Parser.Errors

import GHC.Builtin.Types ( unitTyCon, unitDataCon, tupleTyCon, tupleDataCon, nilDataCon,
                           unboxedUnitTyCon, unboxedUnitDataCon,
                           listTyCon_RDR, consDataCon_RDR, eqTyCon_RDR)

import qualified Data.Semigroup as Semi
import qualified Data.Array as Happy_Data_Array
import qualified Data.Bits as Bits
import qualified GHC.Exts as Happy_GHC_Exts
import Control.Applicative(Applicative(..))
import Control.Monad (ap)

-- parser produced by Happy Version 1.20.0

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