haskell-src-1.0.2.0/0000755000000000000000000000000012461020017012237 5ustar0000000000000000haskell-src-1.0.2.0/changelog.md0000644000000000000000000000024112461020017014505 0ustar0000000000000000# 1.0.2.0 - Add support for GHC 7.10 & base-4.8) - Add missing `Functor` & `Applicative` instances for `P` and `Lex` monads needed for AMP compatibility. haskell-src-1.0.2.0/haskell-src.cabal0000644000000000000000000000266212461020017015441 0ustar0000000000000000name: haskell-src -- don't forget to update the changelog.md! version: 1.0.2.0 license: BSD3 license-file: LICENSE author: Simon Marlow, Sven Panne and Noel Winstanley -- Maintained through https://github.com/haskell-pkg-janitors. Join us! maintainer: Herbert Valerio Riedel bug-reports: https://github.com/haskell-pkg-janitors/haskell-src/issues category: Language synopsis: Support for manipulating Haskell source code description: The 'haskell-src' package provides support for manipulating Haskell source code. The package provides a lexer, parser and pretty-printer, and a definition of a Haskell abstract syntax tree (AST). Common uses of this package are to parse or generate Haskell 98 code. build-type: Simple cabal-version: >=1.6 extra-source-files: changelog.md flag split-base source-repository head type: git location: https://github.com/haskell-pkg-janitors/haskell-src.git library exposed-modules: Language.Haskell.Lexer, Language.Haskell.Parser, Language.Haskell.ParseMonad, Language.Haskell.Pretty, Language.Haskell.Syntax, Language.Haskell.ParseUtils if flag(split-base) build-depends: base >= 4 && < 5, syb, pretty, array else build-depends: base < 3 build-tools: happy extensions: CPP nhc98-options: -K11M ghc-options: -Wall -O2 haskell-src-1.0.2.0/Setup.hs0000644000000000000000000000012712461020017013673 0ustar0000000000000000module Main (main) where import Distribution.Simple main :: IO () main = defaultMain haskell-src-1.0.2.0/LICENSE0000644000000000000000000000311312461020017013242 0ustar0000000000000000The Glasgow Haskell Compiler License Copyright 2004, The University Court of the University of Glasgow. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. - Neither name of the University nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW AND THE CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW OR THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. haskell-src-1.0.2.0/dist/0000755000000000000000000000000012461020017013202 5ustar0000000000000000haskell-src-1.0.2.0/dist/build/0000755000000000000000000000000012461020017014301 5ustar0000000000000000haskell-src-1.0.2.0/dist/build/Language/0000755000000000000000000000000012461020017016024 5ustar0000000000000000haskell-src-1.0.2.0/dist/build/Language/Haskell/0000755000000000000000000000000012461020017017407 5ustar0000000000000000haskell-src-1.0.2.0/dist/build/Language/Haskell/Parser.hs0000644000000000000000000057122412461020017021212 0ustar0000000000000000{-# OPTIONS_GHC -w #-} {-# OPTIONS -fglasgow-exts -cpp #-} ----------------------------------------------------------------------------- -- | -- Module : Language.Haskell.Parser -- Copyright : (c) Simon Marlow, Sven Panne 1997-2000 -- License : BSD-style (see the file libraries/base/LICENSE) -- -- Maintainer : libraries@haskell.org -- Stability : experimental -- Portability : portable -- -- Haskell parser. -- ----------------------------------------------------------------------------- module Language.Haskell.Parser ( parseModule, parseModuleWithMode, ParseMode(..), defaultParseMode, ParseResult(..)) where import Language.Haskell.Syntax import Language.Haskell.ParseMonad import Language.Haskell.Lexer import Language.Haskell.ParseUtils import qualified Data.Array as Happy_Data_Array import qualified GHC.Exts as Happy_GHC_Exts import Control.Applicative(Applicative(..)) import Control.Monad (ap) -- parser produced by Happy Version 1.19.5 newtype HappyAbsSyn = HappyAbsSyn HappyAny #if __GLASGOW_HASKELL__ >= 607 type HappyAny = Happy_GHC_Exts.Any #else type HappyAny = forall a . a #endif happyIn4 :: (HsModule) -> (HappyAbsSyn ) happyIn4 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn4 #-} happyOut4 :: (HappyAbsSyn ) -> (HsModule) happyOut4 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut4 #-} happyIn5 :: (([HsImportDecl],[HsDecl])) -> (HappyAbsSyn ) happyIn5 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn5 #-} happyOut5 :: (HappyAbsSyn ) -> (([HsImportDecl],[HsDecl])) happyOut5 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut5 #-} happyIn6 :: (([HsImportDecl],[HsDecl])) -> (HappyAbsSyn ) happyIn6 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn6 #-} happyOut6 :: (HappyAbsSyn ) -> (([HsImportDecl],[HsDecl])) happyOut6 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut6 #-} happyIn7 :: (()) -> (HappyAbsSyn ) happyIn7 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn7 #-} happyOut7 :: (HappyAbsSyn ) -> (()) happyOut7 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut7 #-} happyIn8 :: (()) -> (HappyAbsSyn ) happyIn8 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn8 #-} happyOut8 :: (HappyAbsSyn ) -> (()) happyOut8 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut8 #-} happyIn9 :: (Maybe [HsExportSpec]) -> (HappyAbsSyn ) happyIn9 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn9 #-} happyOut9 :: (HappyAbsSyn ) -> (Maybe [HsExportSpec]) happyOut9 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut9 #-} happyIn10 :: ([HsExportSpec]) -> (HappyAbsSyn ) happyIn10 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn10 #-} happyOut10 :: (HappyAbsSyn ) -> ([HsExportSpec]) happyOut10 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut10 #-} happyIn11 :: (()) -> (HappyAbsSyn ) happyIn11 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn11 #-} happyOut11 :: (HappyAbsSyn ) -> (()) happyOut11 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut11 #-} happyIn12 :: ([HsExportSpec]) -> (HappyAbsSyn ) happyIn12 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn12 #-} happyOut12 :: (HappyAbsSyn ) -> ([HsExportSpec]) happyOut12 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut12 #-} happyIn13 :: (HsExportSpec) -> (HappyAbsSyn ) happyIn13 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn13 #-} happyOut13 :: (HappyAbsSyn ) -> (HsExportSpec) happyOut13 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut13 #-} happyIn14 :: ([HsImportDecl]) -> (HappyAbsSyn ) happyIn14 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn14 #-} happyOut14 :: (HappyAbsSyn ) -> ([HsImportDecl]) happyOut14 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut14 #-} happyIn15 :: (HsImportDecl) -> (HappyAbsSyn ) happyIn15 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn15 #-} happyOut15 :: (HappyAbsSyn ) -> (HsImportDecl) happyOut15 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut15 #-} happyIn16 :: (Bool) -> (HappyAbsSyn ) happyIn16 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn16 #-} happyOut16 :: (HappyAbsSyn ) -> (Bool) happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut16 #-} happyIn17 :: (Maybe Module) -> (HappyAbsSyn ) happyIn17 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn17 #-} happyOut17 :: (HappyAbsSyn ) -> (Maybe Module) happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut17 #-} happyIn18 :: (Maybe (Bool, [HsImportSpec])) -> (HappyAbsSyn ) happyIn18 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn18 #-} happyOut18 :: (HappyAbsSyn ) -> (Maybe (Bool, [HsImportSpec])) happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut18 #-} happyIn19 :: ((Bool, [HsImportSpec])) -> (HappyAbsSyn ) happyIn19 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn19 #-} happyOut19 :: (HappyAbsSyn ) -> ((Bool, [HsImportSpec])) happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut19 #-} happyIn20 :: (Bool) -> (HappyAbsSyn ) happyIn20 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn20 #-} happyOut20 :: (HappyAbsSyn ) -> (Bool) happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut20 #-} happyIn21 :: ([HsImportSpec]) -> (HappyAbsSyn ) happyIn21 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn21 #-} happyOut21 :: (HappyAbsSyn ) -> ([HsImportSpec]) happyOut21 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut21 #-} happyIn22 :: (HsImportSpec) -> (HappyAbsSyn ) happyIn22 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn22 #-} happyOut22 :: (HappyAbsSyn ) -> (HsImportSpec) happyOut22 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut22 #-} happyIn23 :: ([HsCName]) -> (HappyAbsSyn ) happyIn23 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn23 #-} happyOut23 :: (HappyAbsSyn ) -> ([HsCName]) happyOut23 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut23 #-} happyIn24 :: (HsCName) -> (HappyAbsSyn ) happyIn24 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn24 #-} happyOut24 :: (HappyAbsSyn ) -> (HsCName) happyOut24 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut24 #-} happyIn25 :: (HsDecl) -> (HappyAbsSyn ) happyIn25 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn25 #-} happyOut25 :: (HappyAbsSyn ) -> (HsDecl) happyOut25 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut25 #-} happyIn26 :: (Int) -> (HappyAbsSyn ) happyIn26 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn26 #-} happyOut26 :: (HappyAbsSyn ) -> (Int) happyOut26 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut26 #-} happyIn27 :: (HsAssoc) -> (HappyAbsSyn ) happyIn27 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn27 #-} happyOut27 :: (HappyAbsSyn ) -> (HsAssoc) happyOut27 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut27 #-} happyIn28 :: ([HsOp]) -> (HappyAbsSyn ) happyIn28 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn28 #-} happyOut28 :: (HappyAbsSyn ) -> ([HsOp]) happyOut28 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut28 #-} happyIn29 :: ([HsDecl]) -> (HappyAbsSyn ) happyIn29 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn29 #-} happyOut29 :: (HappyAbsSyn ) -> ([HsDecl]) happyOut29 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut29 #-} happyIn30 :: ([HsDecl]) -> (HappyAbsSyn ) happyIn30 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn30 #-} happyOut30 :: (HappyAbsSyn ) -> ([HsDecl]) happyOut30 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut30 #-} happyIn31 :: (HsDecl) -> (HappyAbsSyn ) happyIn31 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn31 #-} happyOut31 :: (HappyAbsSyn ) -> (HsDecl) happyOut31 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut31 #-} happyIn32 :: ([HsType]) -> (HappyAbsSyn ) happyIn32 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn32 #-} happyOut32 :: (HappyAbsSyn ) -> ([HsType]) happyOut32 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut32 #-} happyIn33 :: ([HsDecl]) -> (HappyAbsSyn ) happyIn33 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn33 #-} happyOut33 :: (HappyAbsSyn ) -> ([HsDecl]) happyOut33 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut33 #-} happyIn34 :: ([HsDecl]) -> (HappyAbsSyn ) happyIn34 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn34 #-} happyOut34 :: (HappyAbsSyn ) -> ([HsDecl]) happyOut34 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut34 #-} happyIn35 :: (HsDecl) -> (HappyAbsSyn ) happyIn35 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn35 #-} happyOut35 :: (HappyAbsSyn ) -> (HsDecl) happyOut35 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut35 #-} happyIn36 :: ([HsDecl]) -> (HappyAbsSyn ) happyIn36 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn36 #-} happyOut36 :: (HappyAbsSyn ) -> ([HsDecl]) happyOut36 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut36 #-} happyIn37 :: (HsDecl) -> (HappyAbsSyn ) happyIn37 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn37 #-} happyOut37 :: (HappyAbsSyn ) -> (HsDecl) happyOut37 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut37 #-} happyIn38 :: ([HsName]) -> (HappyAbsSyn ) happyIn38 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn38 #-} happyOut38 :: (HappyAbsSyn ) -> ([HsName]) happyOut38 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut38 #-} happyIn39 :: (HsDecl) -> (HappyAbsSyn ) happyIn39 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn39 #-} happyOut39 :: (HappyAbsSyn ) -> (HsDecl) happyOut39 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut39 #-} happyIn40 :: (HsSafety) -> (HappyAbsSyn ) happyIn40 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn40 #-} happyOut40 :: (HappyAbsSyn ) -> (HsSafety) happyOut40 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut40 #-} happyIn41 :: (String) -> (HappyAbsSyn ) happyIn41 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn41 #-} happyOut41 :: (HappyAbsSyn ) -> (String) happyOut41 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut41 #-} happyIn42 :: (HsName) -> (HappyAbsSyn ) happyIn42 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn42 #-} happyOut42 :: (HappyAbsSyn ) -> (HsName) happyOut42 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut42 #-} happyIn43 :: (HsType) -> (HappyAbsSyn ) happyIn43 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn43 #-} happyOut43 :: (HappyAbsSyn ) -> (HsType) happyOut43 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut43 #-} happyIn44 :: (HsType) -> (HappyAbsSyn ) happyIn44 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn44 #-} happyOut44 :: (HappyAbsSyn ) -> (HsType) happyOut44 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut44 #-} happyIn45 :: (HsType) -> (HappyAbsSyn ) happyIn45 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn45 #-} happyOut45 :: (HappyAbsSyn ) -> (HsType) happyOut45 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut45 #-} happyIn46 :: (HsQName) -> (HappyAbsSyn ) happyIn46 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn46 #-} happyOut46 :: (HappyAbsSyn ) -> (HsQName) happyOut46 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut46 #-} happyIn47 :: (HsQualType) -> (HappyAbsSyn ) happyIn47 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn47 #-} happyOut47 :: (HappyAbsSyn ) -> (HsQualType) happyOut47 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut47 #-} happyIn48 :: (HsContext) -> (HappyAbsSyn ) happyIn48 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn48 #-} happyOut48 :: (HappyAbsSyn ) -> (HsContext) happyOut48 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut48 #-} happyIn49 :: ([HsType]) -> (HappyAbsSyn ) happyIn49 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn49 #-} happyOut49 :: (HappyAbsSyn ) -> ([HsType]) happyOut49 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut49 #-} happyIn50 :: ((HsName, [HsName])) -> (HappyAbsSyn ) happyIn50 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn50 #-} happyOut50 :: (HappyAbsSyn ) -> ((HsName, [HsName])) happyOut50 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut50 #-} happyIn51 :: ([HsName]) -> (HappyAbsSyn ) happyIn51 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn51 #-} happyOut51 :: (HappyAbsSyn ) -> ([HsName]) happyOut51 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut51 #-} happyIn52 :: ([HsConDecl]) -> (HappyAbsSyn ) happyIn52 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn52 #-} happyOut52 :: (HappyAbsSyn ) -> ([HsConDecl]) happyOut52 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut52 #-} happyIn53 :: (HsConDecl) -> (HappyAbsSyn ) happyIn53 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn53 #-} happyOut53 :: (HappyAbsSyn ) -> (HsConDecl) happyOut53 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut53 #-} happyIn54 :: ((HsName, [HsBangType])) -> (HappyAbsSyn ) happyIn54 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn54 #-} happyOut54 :: (HappyAbsSyn ) -> ((HsName, [HsBangType])) happyOut54 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut54 #-} happyIn55 :: ((HsName, [HsBangType])) -> (HappyAbsSyn ) happyIn55 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn55 #-} happyOut55 :: (HappyAbsSyn ) -> ((HsName, [HsBangType])) happyOut55 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut55 #-} happyIn56 :: (HsBangType) -> (HappyAbsSyn ) happyIn56 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn56 #-} happyOut56 :: (HappyAbsSyn ) -> (HsBangType) happyOut56 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut56 #-} happyIn57 :: (HsBangType) -> (HappyAbsSyn ) happyIn57 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn57 #-} happyOut57 :: (HappyAbsSyn ) -> (HsBangType) happyOut57 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut57 #-} happyIn58 :: ([([HsName],HsBangType)]) -> (HappyAbsSyn ) happyIn58 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn58 #-} happyOut58 :: (HappyAbsSyn ) -> ([([HsName],HsBangType)]) happyOut58 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut58 #-} happyIn59 :: (([HsName],HsBangType)) -> (HappyAbsSyn ) happyIn59 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn59 #-} happyOut59 :: (HappyAbsSyn ) -> (([HsName],HsBangType)) happyOut59 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut59 #-} happyIn60 :: (HsBangType) -> (HappyAbsSyn ) happyIn60 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn60 #-} happyOut60 :: (HappyAbsSyn ) -> (HsBangType) happyOut60 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut60 #-} happyIn61 :: ([HsQName]) -> (HappyAbsSyn ) happyIn61 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn61 #-} happyOut61 :: (HappyAbsSyn ) -> ([HsQName]) happyOut61 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut61 #-} happyIn62 :: ([HsQName]) -> (HappyAbsSyn ) happyIn62 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn62 #-} happyOut62 :: (HappyAbsSyn ) -> ([HsQName]) happyOut62 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut62 #-} happyIn63 :: ([HsDecl]) -> (HappyAbsSyn ) happyIn63 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn63 #-} happyOut63 :: (HappyAbsSyn ) -> ([HsDecl]) happyOut63 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut63 #-} happyIn64 :: ([HsDecl]) -> (HappyAbsSyn ) happyIn64 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn64 #-} happyOut64 :: (HappyAbsSyn ) -> ([HsDecl]) happyOut64 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut64 #-} happyIn65 :: ([HsDecl]) -> (HappyAbsSyn ) happyIn65 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn65 #-} happyOut65 :: (HappyAbsSyn ) -> ([HsDecl]) happyOut65 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut65 #-} happyIn66 :: ([HsDecl]) -> (HappyAbsSyn ) happyIn66 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn66 #-} happyOut66 :: (HappyAbsSyn ) -> ([HsDecl]) happyOut66 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut66 #-} happyIn67 :: (HsDecl) -> (HappyAbsSyn ) happyIn67 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn67 #-} happyOut67 :: (HappyAbsSyn ) -> (HsDecl) happyOut67 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut67 #-} happyIn68 :: ([HsDecl]) -> (HappyAbsSyn ) happyIn68 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn68 #-} happyOut68 :: (HappyAbsSyn ) -> ([HsDecl]) happyOut68 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut68 #-} happyIn69 :: (HsRhs) -> (HappyAbsSyn ) happyIn69 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn69 #-} happyOut69 :: (HappyAbsSyn ) -> (HsRhs) happyOut69 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut69 #-} happyIn70 :: ([HsGuardedRhs]) -> (HappyAbsSyn ) happyIn70 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn70 #-} happyOut70 :: (HappyAbsSyn ) -> ([HsGuardedRhs]) happyOut70 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut70 #-} happyIn71 :: (HsGuardedRhs) -> (HappyAbsSyn ) happyIn71 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn71 #-} happyOut71 :: (HappyAbsSyn ) -> (HsGuardedRhs) happyOut71 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut71 #-} happyIn72 :: (HsExp) -> (HappyAbsSyn ) happyIn72 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn72 #-} happyOut72 :: (HappyAbsSyn ) -> (HsExp) happyOut72 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut72 #-} happyIn73 :: (HsExp) -> (HappyAbsSyn ) happyIn73 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn73 #-} happyOut73 :: (HappyAbsSyn ) -> (HsExp) happyOut73 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut73 #-} happyIn74 :: (HsExp) -> (HappyAbsSyn ) happyIn74 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn74 #-} happyOut74 :: (HappyAbsSyn ) -> (HsExp) happyOut74 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut74 #-} happyIn75 :: (HsExp) -> (HappyAbsSyn ) happyIn75 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn75 #-} happyOut75 :: (HappyAbsSyn ) -> (HsExp) happyOut75 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut75 #-} happyIn76 :: (HsExp) -> (HappyAbsSyn ) happyIn76 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn76 #-} happyOut76 :: (HappyAbsSyn ) -> (HsExp) happyOut76 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut76 #-} happyIn77 :: (HsExp) -> (HappyAbsSyn ) happyIn77 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn77 #-} happyOut77 :: (HappyAbsSyn ) -> (HsExp) happyOut77 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut77 #-} happyIn78 :: (HsExp) -> (HappyAbsSyn ) happyIn78 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn78 #-} happyOut78 :: (HappyAbsSyn ) -> (HsExp) happyOut78 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut78 #-} happyIn79 :: ([HsPat]) -> (HappyAbsSyn ) happyIn79 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn79 #-} happyOut79 :: (HappyAbsSyn ) -> ([HsPat]) happyOut79 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut79 #-} happyIn80 :: (HsPat) -> (HappyAbsSyn ) happyIn80 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn80 #-} happyOut80 :: (HappyAbsSyn ) -> (HsPat) happyOut80 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut80 #-} happyIn81 :: (HsExp) -> (HappyAbsSyn ) happyIn81 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn81 #-} happyOut81 :: (HappyAbsSyn ) -> (HsExp) happyOut81 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut81 #-} happyIn82 :: (HsExp) -> (HappyAbsSyn ) happyIn82 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn82 #-} happyOut82 :: (HappyAbsSyn ) -> (HsExp) happyOut82 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut82 #-} happyIn83 :: (HsExp) -> (HappyAbsSyn ) happyIn83 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn83 #-} happyOut83 :: (HappyAbsSyn ) -> (HsExp) happyOut83 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut83 #-} happyIn84 :: (Int) -> (HappyAbsSyn ) happyIn84 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn84 #-} happyOut84 :: (HappyAbsSyn ) -> (Int) happyOut84 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut84 #-} happyIn85 :: ([HsExp]) -> (HappyAbsSyn ) happyIn85 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn85 #-} happyOut85 :: (HappyAbsSyn ) -> ([HsExp]) happyOut85 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut85 #-} happyIn86 :: (HsExp) -> (HappyAbsSyn ) happyIn86 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn86 #-} happyOut86 :: (HappyAbsSyn ) -> (HsExp) happyOut86 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut86 #-} happyIn87 :: ([HsExp]) -> (HappyAbsSyn ) happyIn87 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn87 #-} happyOut87 :: (HappyAbsSyn ) -> ([HsExp]) happyOut87 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut87 #-} happyIn88 :: ([HsStmt]) -> (HappyAbsSyn ) happyIn88 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn88 #-} happyOut88 :: (HappyAbsSyn ) -> ([HsStmt]) happyOut88 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut88 #-} happyIn89 :: (HsStmt) -> (HappyAbsSyn ) happyIn89 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn89 #-} happyOut89 :: (HappyAbsSyn ) -> (HsStmt) happyOut89 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut89 #-} happyIn90 :: ([HsAlt]) -> (HappyAbsSyn ) happyIn90 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn90 #-} happyOut90 :: (HappyAbsSyn ) -> ([HsAlt]) happyOut90 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut90 #-} happyIn91 :: ([HsAlt]) -> (HappyAbsSyn ) happyIn91 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn91 #-} happyOut91 :: (HappyAbsSyn ) -> ([HsAlt]) happyOut91 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut91 #-} happyIn92 :: ([HsAlt]) -> (HappyAbsSyn ) happyIn92 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn92 #-} happyOut92 :: (HappyAbsSyn ) -> ([HsAlt]) happyOut92 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut92 #-} happyIn93 :: (HsAlt) -> (HappyAbsSyn ) happyIn93 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn93 #-} happyOut93 :: (HappyAbsSyn ) -> (HsAlt) happyOut93 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut93 #-} happyIn94 :: (HsGuardedAlts) -> (HappyAbsSyn ) happyIn94 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn94 #-} happyOut94 :: (HappyAbsSyn ) -> (HsGuardedAlts) happyOut94 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut94 #-} happyIn95 :: ([HsGuardedAlt]) -> (HappyAbsSyn ) happyIn95 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn95 #-} happyOut95 :: (HappyAbsSyn ) -> ([HsGuardedAlt]) happyOut95 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut95 #-} happyIn96 :: (HsGuardedAlt) -> (HappyAbsSyn ) happyIn96 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn96 #-} happyOut96 :: (HappyAbsSyn ) -> (HsGuardedAlt) happyOut96 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut96 #-} happyIn97 :: (HsPat) -> (HappyAbsSyn ) happyIn97 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn97 #-} happyOut97 :: (HappyAbsSyn ) -> (HsPat) happyOut97 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut97 #-} happyIn98 :: ([HsStmt]) -> (HappyAbsSyn ) happyIn98 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn98 #-} happyOut98 :: (HappyAbsSyn ) -> ([HsStmt]) happyOut98 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut98 #-} happyIn99 :: ([HsStmt]) -> (HappyAbsSyn ) happyIn99 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn99 #-} happyOut99 :: (HappyAbsSyn ) -> ([HsStmt]) happyOut99 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut99 #-} happyIn100 :: ([HsFieldUpdate]) -> (HappyAbsSyn ) happyIn100 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn100 #-} happyOut100 :: (HappyAbsSyn ) -> ([HsFieldUpdate]) happyOut100 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut100 #-} happyIn101 :: (HsFieldUpdate) -> (HappyAbsSyn ) happyIn101 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn101 #-} happyOut101 :: (HappyAbsSyn ) -> (HsFieldUpdate) happyOut101 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut101 #-} happyIn102 :: (HsExp) -> (HappyAbsSyn ) happyIn102 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn102 #-} happyOut102 :: (HappyAbsSyn ) -> (HsExp) happyOut102 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut102 #-} happyIn103 :: (HsName) -> (HappyAbsSyn ) happyIn103 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn103 #-} happyOut103 :: (HappyAbsSyn ) -> (HsName) happyOut103 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut103 #-} happyIn104 :: (HsQName) -> (HappyAbsSyn ) happyIn104 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn104 #-} happyOut104 :: (HappyAbsSyn ) -> (HsQName) happyOut104 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut104 #-} happyIn105 :: (HsName) -> (HappyAbsSyn ) happyIn105 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn105 #-} happyOut105 :: (HappyAbsSyn ) -> (HsName) happyOut105 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut105 #-} happyIn106 :: (HsQName) -> (HappyAbsSyn ) happyIn106 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn106 #-} happyOut106 :: (HappyAbsSyn ) -> (HsQName) happyOut106 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut106 #-} happyIn107 :: (HsName) -> (HappyAbsSyn ) happyIn107 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn107 #-} happyOut107 :: (HappyAbsSyn ) -> (HsName) happyOut107 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut107 #-} happyIn108 :: (HsQName) -> (HappyAbsSyn ) happyIn108 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn108 #-} happyOut108 :: (HappyAbsSyn ) -> (HsQName) happyOut108 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut108 #-} happyIn109 :: (HsQName) -> (HappyAbsSyn ) happyIn109 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn109 #-} happyOut109 :: (HappyAbsSyn ) -> (HsQName) happyOut109 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut109 #-} happyIn110 :: (HsName) -> (HappyAbsSyn ) happyIn110 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn110 #-} happyOut110 :: (HappyAbsSyn ) -> (HsName) happyOut110 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut110 #-} happyIn111 :: (HsQName) -> (HappyAbsSyn ) happyIn111 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn111 #-} happyOut111 :: (HappyAbsSyn ) -> (HsQName) happyOut111 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut111 #-} happyIn112 :: (HsOp) -> (HappyAbsSyn ) happyIn112 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn112 #-} happyOut112 :: (HappyAbsSyn ) -> (HsOp) happyOut112 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut112 #-} happyIn113 :: (HsQOp) -> (HappyAbsSyn ) happyIn113 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn113 #-} happyOut113 :: (HappyAbsSyn ) -> (HsQOp) happyOut113 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut113 #-} happyIn114 :: (HsQOp) -> (HappyAbsSyn ) happyIn114 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn114 #-} happyOut114 :: (HappyAbsSyn ) -> (HsQOp) happyOut114 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut114 #-} happyIn115 :: (HsQName) -> (HappyAbsSyn ) happyIn115 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn115 #-} happyOut115 :: (HappyAbsSyn ) -> (HsQName) happyOut115 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut115 #-} happyIn116 :: (HsQName) -> (HappyAbsSyn ) happyIn116 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn116 #-} happyOut116 :: (HappyAbsSyn ) -> (HsQName) happyOut116 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut116 #-} happyIn117 :: (HsName) -> (HappyAbsSyn ) happyIn117 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn117 #-} happyOut117 :: (HappyAbsSyn ) -> (HsName) happyOut117 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut117 #-} happyIn118 :: (HsQName) -> (HappyAbsSyn ) happyIn118 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn118 #-} happyOut118 :: (HappyAbsSyn ) -> (HsQName) happyOut118 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut118 #-} happyIn119 :: (HsName) -> (HappyAbsSyn ) happyIn119 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn119 #-} happyOut119 :: (HappyAbsSyn ) -> (HsName) happyOut119 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut119 #-} happyIn120 :: (HsQName) -> (HappyAbsSyn ) happyIn120 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn120 #-} happyOut120 :: (HappyAbsSyn ) -> (HsQName) happyOut120 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut120 #-} happyIn121 :: (HsName) -> (HappyAbsSyn ) happyIn121 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn121 #-} happyOut121 :: (HappyAbsSyn ) -> (HsName) happyOut121 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut121 #-} happyIn122 :: (HsQName) -> (HappyAbsSyn ) happyIn122 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn122 #-} happyOut122 :: (HappyAbsSyn ) -> (HsQName) happyOut122 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut122 #-} happyIn123 :: (HsQName) -> (HappyAbsSyn ) happyIn123 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn123 #-} happyOut123 :: (HappyAbsSyn ) -> (HsQName) happyOut123 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut123 #-} happyIn124 :: (HsName) -> (HappyAbsSyn ) happyIn124 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn124 #-} happyOut124 :: (HappyAbsSyn ) -> (HsName) happyOut124 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut124 #-} happyIn125 :: (HsName) -> (HappyAbsSyn ) happyIn125 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn125 #-} happyOut125 :: (HappyAbsSyn ) -> (HsName) happyOut125 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut125 #-} happyIn126 :: (HsQName) -> (HappyAbsSyn ) happyIn126 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn126 #-} happyOut126 :: (HappyAbsSyn ) -> (HsQName) happyOut126 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut126 #-} happyIn127 :: (HsLiteral) -> (HappyAbsSyn ) happyIn127 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn127 #-} happyOut127 :: (HappyAbsSyn ) -> (HsLiteral) happyOut127 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut127 #-} happyIn128 :: (SrcLoc) -> (HappyAbsSyn ) happyIn128 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn128 #-} happyOut128 :: (HappyAbsSyn ) -> (SrcLoc) happyOut128 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut128 #-} happyIn129 :: (()) -> (HappyAbsSyn ) happyIn129 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn129 #-} happyOut129 :: (HappyAbsSyn ) -> (()) happyOut129 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut129 #-} happyIn130 :: (()) -> (HappyAbsSyn ) happyIn130 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn130 #-} happyOut130 :: (HappyAbsSyn ) -> (()) happyOut130 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut130 #-} happyIn131 :: (Module) -> (HappyAbsSyn ) happyIn131 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn131 #-} happyOut131 :: (HappyAbsSyn ) -> (Module) happyOut131 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut131 #-} happyIn132 :: (HsName) -> (HappyAbsSyn ) happyIn132 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn132 #-} happyOut132 :: (HappyAbsSyn ) -> (HsName) happyOut132 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut132 #-} happyIn133 :: (HsName) -> (HappyAbsSyn ) happyIn133 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn133 #-} happyOut133 :: (HappyAbsSyn ) -> (HsName) happyOut133 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut133 #-} happyIn134 :: (HsQName) -> (HappyAbsSyn ) happyIn134 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn134 #-} happyOut134 :: (HappyAbsSyn ) -> (HsQName) happyOut134 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut134 #-} happyIn135 :: (HsQName) -> (HappyAbsSyn ) happyIn135 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn135 #-} happyOut135 :: (HappyAbsSyn ) -> (HsQName) happyOut135 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut135 #-} happyIn136 :: (HsName) -> (HappyAbsSyn ) happyIn136 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyIn136 #-} happyOut136 :: (HappyAbsSyn ) -> (HsName) happyOut136 x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOut136 #-} happyInTok :: (Token) -> (HappyAbsSyn ) happyInTok x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyInTok #-} happyOutTok :: (HappyAbsSyn ) -> (Token) happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x {-# INLINE happyOutTok #-} happyActOffsets :: HappyAddr happyActOffsets = HappyA# "\x00\x00\x00\x00\xcb\x03\xbd\x03\x20\x00\x00\x00\x00\x00\x00\x00\xed\x02\xe6\x03\x00\x00\x00\x00\xe1\x03\x00\x00\x39\x02\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x02\x00\x00\x00\x00\xb2\x03\x00\x00\x15\x02\xd4\x03\xdc\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x03\x00\x00\x00\x00\x00\x00\x00\x00\x04\x02\x00\x00\xed\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x03\xd8\x03\x53\x02\x42\x05\x00\x00\xd2\x07\x00\x00\xd0\x03\x00\x00\x00\x00\xcf\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x01\xb9\x04\x00\x00\xd2\x07\xd2\x07\xb9\x06\x15\x03\x15\x03\xd2\x03\xcd\x03\xc3\x00\x9b\x03\x00\x00\x00\x00\x00\x00\x15\x03\x15\x03\xd5\x03\x39\x03\xcc\x03\x79\x02\xcc\x03\x00\x00\x00\x00\x00\x00\xf9\x02\xbc\x03\x00\x00\x00\x00\x00\x00\x29\x08\x00\x00\x00\x00\xbb\x03\xac\x03\x00\x00\x00\x00\x00\x00\x1b\x08\x95\x03\x93\x03\xed\x02\x00\x00\xca\x03\xc9\x03\x00\x00\x79\x04\x79\x04\x15\x03\xae\x03\x87\x03\x90\x03\x00\x00\x00\x00\x8b\x04\x00\x00\xa0\x03\x00\x00\xb9\x06\xaf\x03\xd2\x07\x00\x00\xc8\x01\x9d\x03\xa9\x03\x00\x00\x32\x02\x8b\x04\x17\x02\x16\x02\x00\x00\x00\x00\xb9\x06\xa5\x03\x00\x00\x00\x00\xa4\x03\x00\x00\x00\x00\x00\x00\xa2\x03\xa1\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xec\x03\x00\x00\xd2\x07\x9c\x03\xd2\x07\xd7\x06\x00\x00\x72\x03\x91\x03\x00\x00\x00\x00\x00\x00\x79\x07\x00\x00\x00\x00\x00\x00\x8e\x03\x00\x00\xf3\x01\xb9\x06\x00\x00\x00\x00\x71\x07\x15\x03\x7d\x01\x00\x00\x00\x00\x00\x00\x58\x07\x99\x03\x55\x02\x00\x00\x00\x00\x00\x00\xff\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcd\x01\x00\x00\x97\x03\x8b\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\x06\x00\x00\x00\x00\x03\x01\x00\x00\x8d\x03\x8a\x03\xb9\x06\x00\x00\x00\x00\x00\x00\x8f\x03\x86\x02\x00\x00\x82\x03\x00\x00\x00\x00\x84\x03\x00\x00\x00\x00\x89\x03\xcb\x04\x00\x00\xb9\x06\x00\x00\x00\x00\x39\x04\x00\x00\x00\x00\xb9\x06\xb9\x06\x00\x00\xb9\x06\xb9\x06\x79\x06\x5f\x03\x00\x00\x00\x00\x5c\x03\xd2\x07\x39\x06\x81\x03\x00\x00\x80\x03\x00\x00\x7f\x03\x7e\x03\xc2\x08\x7d\x03\x7c\x03\x4b\x04\x00\x00\x78\x03\xf9\x03\x7a\x03\x8f\x00\x7b\x03\x8e\x01\x45\x03\x00\x00\x71\x03\x6b\x03\x00\x00\xfc\x01\xd9\x01\xca\x01\x00\x00\x70\x03\xd5\x02\x00\x00\x00\x00\xd5\x02\x2d\x07\xd5\x02\x00\x00\x00\x00\x00\x00\x4a\x03\x82\x08\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x02\x00\x00\xd5\x02\x00\x00\x00\x00\x00\x00\x4e\x00\xea\x02\x65\x03\x00\x00\x00\x00\xbc\x01\x00\x00\x00\x00\x74\x00\x00\x00\x00\x00\x52\x03\xf9\x03\x00\x00\x6c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x07\x00\x00\x00\x00\x39\x06\xb9\x03\x5d\x03\x8f\x00\x39\x06\x00\x00\x58\x03\x00\x00\x00\x00\x56\x03\x00\x00\x4c\x03\x00\x00\x00\x00\xd5\x02\x00\x00\x00\x00\x00\x00\x00\x00\x39\x06\x00\x00\xb1\x05\x00\x00\x47\x03\x00\x00\x00\x00\x4f\x03\x37\x03\x33\x03\x7d\x01\x00\x00\x3b\x03\x00\x00\xa7\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x06\x00\x00\x00\x00\x00\x00\x39\x06\x12\x03\x22\x03\xf9\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x05\x1c\x03\x00\x00\x79\x05\x30\x03\x2d\x03\x8f\x00\x00\x00\x00\x00\x1c\x02\x00\x00\x79\x05\x79\x03\x19\x03\x00\x00\x03\x01\x28\x01\x00\x00\x00\x00\x00\x00\x24\x03\x00\x00\xf9\x06\x1f\x03\x8f\x00\x00\x00\x00\x00\x14\x08\x00\x00\x7b\x08\x5b\x01\x1e\x03\x1d\x03\x06\x08\xd5\x02\x00\x00\x00\x00\x97\x05\x5e\x08\x23\x03\x00\x00\x00\x00\xd5\x02\xd5\x02\x00\x00\x00\x00\x00\x00\x00\x00\x79\x07\x15\x05\x0d\x03\x16\x03\xd5\x02\x00\x00\x0e\x03\x00\x00\x00\x00\x3f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x07\x00\x00\x79\x05\x39\x05\x0c\x03\x00\x00\xf9\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcb\x04\xef\x02\x39\x07\x08\x03\xb6\x01\x00\x00\x00\x00\x79\x03\x00\x00\x00\x00\xd5\x02\xff\x02\xf6\x02\x00\x00\x00\x00\x00\x00\xfd\x02\x39\x07\xf2\x02\x00\x00\x00\x00\xd5\x02\x00\x00\x34\x02\x9a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x05\x3a\x08\x00\x00\x18\x07\xe5\x02\x9f\x08\x00\x00\x00\x00\x00\x00\x00\x00\xca\x02\x00\x00\xac\x02\xc7\x02\x00\x00\xc0\x02\xf9\x04\x00\x00\xf9\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf2\x00\x00\x00\xcd\x02\x00\x00\x00\x00\x95\x02\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x02\xf9\x04\x00\x00\x00\x00"# happyGotoOffsets :: HappyAddr happyGotoOffsets = HappyA# "\x04\x00\x4f\x02\x00\x00\x00\x00\x02\x00\x00\x00\x05\x03\xfc\x02\x48\x02\x7b\x01\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x35\x02\x00\x00\x00\x00\x00\x00\xad\x02\x00\x00\x00\x00\x00\x00\xaa\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\xff\x00\x00\x9f\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x02\x00\x00\x25\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x87\x02\x00\x00\xa3\x03\x00\x00\x11\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x08\x5c\x0a\x00\x00\x0c\x0e\xa3\x0d\xc0\x0c\xc0\x00\xba\x00\x00\x00\xcc\x00\x00\x00\x7c\x02\x00\x00\x00\x00\x00\x00\xb2\x00\xac\x00\xe1\xff\x1a\x00\x00\x00\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x00\x00\x3f\x02\x00\x00\x69\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x00\x36\x01\x37\x02\xe7\x01\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x0a\xfc\x09\x0a\x00\x00\x00\x29\x02\x00\x00\x00\x00\x00\x00\x1c\x08\x00\x00\x00\x00\xe1\x01\xae\x0c\x1c\x00\xf2\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x06\x00\x00\x00\x00\x00\x00\x00\x00\x30\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\x02\x00\x00\xa3\x0d\x00\x00\xd8\x0d\xf7\x02\x00\x00\x1b\x02\xd5\xff\x00\x00\x00\x00\x00\x00\x78\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0e\x02\x7e\x0c\x00\x00\x00\x00\x23\x00\x9e\x00\x38\x00\x00\x00\x00\x00\x00\x00\x3b\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc9\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x93\x00\x00\x00\x00\x00\xd3\x01\x00\x00\x00\x00\x00\x00\x01\x0d\x00\x00\x00\x00\x00\x00\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe3\x05\x00\x00\x6c\x0c\x00\x00\x00\x00\x71\x0d\xd1\x01\x00\x00\x3c\x0c\x2a\x0c\x00\x00\xfa\x0b\xe8\x0b\xdc\x08\x00\x00\x79\x01\x54\x01\x00\x00\xa9\x0d\x71\x0d\xf1\xff\x00\x00\xfc\xff\xe5\xff\x00\x00\x00\x00\x69\x01\x00\x00\x00\x00\xe3\x05\xc3\x01\x00\x00\xcc\x09\xf7\xff\xa3\x01\xf6\x01\xef\x01\xd4\x01\x00\x00\x8b\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x32\x01\x0d\x00\x00\x00\x2c\x01\x6e\x00\x27\x01\x00\x00\x00\x00\x00\x00\x7c\x01\x41\x01\x00\x00\x00\x00\x00\x00\x00\x00\x1e\x01\x00\x00\x13\x01\x00\x00\x0f\x01\x0f\x00\xba\x02\x1c\x01\x48\x01\x00\x00\x00\x00\x25\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x09\x00\x00\xfb\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x40\x00\x00\x00\xd3\x0d\x00\x00\x00\x00\xb8\x0b\x21\x00\x00\x00\xb0\x00\xa6\x0b\x00\x00\x00\x00\x00\x00\x92\x00\xea\xff\x00\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x0b\x00\x00\x82\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe1\x02\x00\x00\x00\x00\x00\x00\xf9\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x64\x0b\x00\x00\x00\x00\x00\x00\x34\x0b\x00\x00\x00\x00\x6c\x09\x00\x00\x00\x00\x00\x00\x8a\x02\x00\x00\x43\x00\x00\x00\x00\x00\x22\x0b\x77\x00\x00\x00\x1d\x00\x00\x00\xec\xff\x49\x01\x00\x00\xf2\x0a\x3c\x09\x00\x00\x00\x00\x5a\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\xff\x00\x00\x15\x00\x00\x00\x00\x00\x69\x01\x00\x00\x88\x00\x02\x01\x00\x00\x00\x00\x90\x00\x64\x01\x00\x00\x00\x00\x88\x01\x46\x01\xd6\xff\x00\x00\x00\x00\x5e\x01\x55\x01\x00\x00\x00\x00\x6d\x02\x00\x00\x5a\x09\xfa\xff\x00\x00\x00\x00\xf1\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf5\x00\x00\x00\x00\x00\x00\x00\x1d\x01\x00\x00\x42\x0d\x00\x00\xe0\x0a\x19\x00\x00\x00\x00\x00\xb0\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x05\x30\x01\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0c\x09\x00\x00\x00\x00\xce\x00\x00\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\xca\xff\x00\x00\x00\x00\x00\x00\x50\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x01\xc6\x00\x00\x00\x37\x00\x00\x00\xf3\xff\x00\x00\x00\x00\x00\x00\x00\x00\x8a\x00\x00\x00\x1f\x00\xd1\xff\x00\x00\x00\x00\x9e\x0a\x00\x00\xef\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x0a\x00\x00\x00\x00"# happyDefActions :: HappyAddr happyDefActions = HappyA# "\xdb\xfe\x00\x00\x00\x00\x00\x00\xda\xfe\xfd\xff\xf4\xff\xf4\xff\x00\x00\xf2\xff\xd7\xfe\xd6\xfe\x00\x00\xf5\xff\xf7\xff\x00\x00\xfb\xff\xd8\xfe\xd9\xfe\xf4\xff\xe4\xff\xb2\xff\xf9\xff\xf4\xff\xc3\xff\xbb\xff\xb3\xff\xbc\xff\xb1\xff\x00\x00\xf6\xff\xfc\xff\x00\x00\xf3\xff\xee\xff\x00\x00\xee\xff\xec\xff\xeb\xff\x10\xff\xf8\xfe\xd3\xfe\xef\xfe\xea\xff\xf6\xfe\xf7\xfe\xed\xfe\xee\xfe\x00\x00\xef\xff\x00\x00\xf5\xfe\xf4\xfe\xf3\xfe\xf2\xfe\xf1\xfe\xf0\xfe\xda\xfe\xcc\xff\x00\x00\xdb\xfe\x5b\xff\x54\xff\x52\xff\x4c\xff\x49\xff\x47\xff\x48\xff\x13\xff\x0c\xff\x46\xff\xdf\xfe\xdd\xfe\xde\xfe\xdc\xfe\x00\x00\x00\x00\x40\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\xfe\x00\x00\xe1\xff\xca\xff\xc9\xff\xc8\xff\x00\x00\x00\x00\x00\x00\xf5\xff\xc5\xff\xf5\xff\xf8\xff\xe5\xff\xfa\xff\xc4\xff\x00\x00\x00\x00\xd4\xfe\x8d\xff\x93\xff\xa1\xff\x9f\xff\x9e\xff\x00\x00\x00\x00\xd1\xfe\x99\xff\x9d\xff\x00\x00\x00\x00\x6f\xff\x00\x00\xe2\xff\x00\x00\x00\x00\x55\xff\x00\x00\x00\x00\xb8\xff\x00\x00\x72\xff\x00\x00\x61\xff\x60\xff\x5f\xff\x5d\xff\x48\xff\xdb\xfe\x00\x00\xda\xfe\x56\xff\x4d\xff\x3b\xff\x00\x00\x3a\xff\x15\xff\x00\x00\x5f\xff\x00\x00\x00\x00\xfc\xfe\xfb\xfe\x00\x00\x02\xff\xf9\xfe\xec\xfe\x00\x00\x06\xff\xe9\xfe\xe7\xfe\xe6\xfe\xe2\xfe\xea\xfe\xe0\xfe\xeb\xfe\x16\xff\x3e\xff\x00\x00\xfa\xfe\xe4\xfe\xe1\xfe\x00\x00\x00\x00\x53\xff\x68\xff\x66\xff\x64\xff\xfe\xfe\xfd\xfe\x00\x00\x02\xff\x08\xff\xe8\xfe\x00\x00\xe5\xfe\x00\x00\x00\x00\xe4\xfe\xe3\xfe\x00\x00\x00\x00\x00\x00\xcb\xff\xfe\xff\xe6\xff\x00\x00\x00\x00\xef\xff\xf0\xff\xed\xff\xf1\xff\x00\x00\xd0\xff\xcf\xff\xce\xff\x12\xff\x0e\xff\x00\x00\xe8\xff\x00\x00\xcd\xff\x00\xff\xff\xfe\xc6\xff\x04\xff\x0a\xff\x00\x00\xae\xff\xad\xff\x00\x00\x67\xff\x00\x00\x00\x00\x00\x00\x5c\xff\x65\xff\x6a\xff\xda\xfe\x00\x00\x18\xff\x00\x00\x4b\xff\x4e\xff\x00\x00\x0f\xff\x0b\xff\x00\x00\x5f\xff\x44\xff\x00\x00\x14\xff\x3f\xff\x00\x00\xdb\xfe\x45\xff\x00\x00\x00\x00\x43\xff\x00\x00\x39\xff\x00\x00\x00\x00\xf4\xff\xf4\xff\x00\x00\x00\x00\x00\x00\xda\xfe\xbf\xff\xda\xfe\xdb\xfe\x00\x00\xb9\xff\xa1\xff\xba\xff\x1a\xff\x5f\xff\xdb\xfe\x00\x00\x00\x00\xda\xfe\x00\x00\xa5\xff\xa7\xff\xdf\xff\xbe\xff\xda\xfe\x00\x00\x96\xff\x00\x00\x00\x00\x00\x00\x98\xff\x00\x00\x00\x00\xdb\xfe\xa0\xff\x00\x00\x8f\xff\x00\x00\xc2\xff\x8e\xff\xa2\xff\x79\xff\x00\x00\x94\xff\x97\xff\x95\xff\x9c\xff\x00\x00\x9a\xff\x00\x00\x9b\xff\xf4\xff\xf4\xff\xdd\xff\x00\x00\xa5\xff\xa9\xff\xa8\xff\x00\x00\xa6\xff\x20\xff\x00\x00\x1c\xff\x21\xff\x00\x00\x1b\xff\xbd\xff\x79\xff\x8b\xff\x73\xff\x57\xff\xf4\xff\xf4\xff\x5e\xff\x00\x00\x50\xff\x4f\xff\x00\x00\xb6\xff\x00\x00\x00\x00\x00\x00\x2f\xff\x35\xff\x31\xff\xdb\xfe\xda\xfe\x37\xff\x33\xff\x34\xff\x3c\xff\x00\x00\x42\xff\x3d\xff\x41\xff\x05\xff\x00\x00\x4a\xff\x00\x00\x69\xff\x00\x00\x01\xff\x07\xff\x00\x00\x00\x00\x00\x00\x00\x00\xe9\xff\x00\x00\xe7\xff\x00\x00\xd1\xff\x0d\xff\xc7\xff\x03\xff\x09\xff\x11\xff\x00\x00\x19\xff\x17\xff\x62\xff\x38\xff\x2e\xff\x00\x00\x00\x00\x59\xff\xaf\xff\xb0\xff\xf4\xff\xb4\xff\x00\x00\x00\x00\x51\xff\x00\x00\xdb\xfe\x00\x00\x00\x00\xc1\xff\xdb\xfe\x00\x00\x1d\xff\x00\x00\x00\x00\x00\x00\xa4\xff\x00\x00\x00\x00\xe0\xff\xe3\xff\xde\xff\x00\x00\xda\xff\x6d\xff\x00\x00\x00\x00\x90\xff\x91\xff\x86\xff\x8a\xff\x85\xff\x00\x00\x00\x00\xef\xfe\x00\x00\x00\x00\xc0\xff\x7f\xff\x00\x00\x00\x00\x00\x00\x82\xff\x83\xff\x00\x00\x00\x00\x70\xff\x71\xff\xf4\xff\x6b\xff\x00\x00\xee\xff\x00\x00\x00\x00\x00\x00\x1f\xff\x00\x00\xd2\xfe\x78\xff\x00\x00\x8c\xff\x2c\xff\x2d\xff\xf4\xff\x29\xff\x00\x00\x5a\xff\x00\x00\xf5\xff\xb7\xff\x32\xff\x00\x00\x36\xff\x63\xff\x30\xff\xb5\xff\x58\xff\x22\xff\xdb\xfe\xf5\xff\x2b\xff\x00\x00\x74\xff\x77\xff\x00\x00\xaa\xff\xa3\xff\x00\x00\x00\x00\xee\xff\xd7\xff\xd6\xff\xd5\xfe\xd5\xff\xf5\xff\x6e\xff\x84\xff\x81\xff\x80\xff\x89\xff\x00\x00\x00\x00\x7d\xff\xac\xff\x88\xff\x87\xff\x00\x00\x00\x00\x6c\xff\x00\x00\x00\x00\xef\xff\xdb\xff\xab\xff\x1e\xff\x76\xff\x00\x00\x2a\xff\x68\xff\x26\xff\x24\xff\x00\x00\x00\x00\x27\xff\x00\x00\x25\xff\x28\xff\x75\xff\xd8\xff\xdc\xff\x00\x00\xd3\xff\x00\x00\x7b\xff\x7c\xff\x00\x00\x7e\xff\x7a\xff\xd4\xff\xd2\xff\x00\x00\x00\x00\x23\xff"# happyCheck :: HappyAddr happyCheck = HappyA# "\xff\xff\x07\x00\x01\x00\x01\x00\x00\x00\x12\x00\x07\x00\x08\x00\x09\x00\x3f\x00\x20\x00\x11\x00\x12\x00\x14\x00\x09\x00\x2e\x00\x0a\x00\x0b\x00\x03\x00\x04\x00\x0b\x00\x30\x00\x31\x00\x20\x00\x43\x00\x3e\x00\x3f\x00\x15\x00\x20\x00\x31\x00\x15\x00\x19\x00\x1a\x00\x1b\x00\x19\x00\x1a\x00\x1b\x00\x1f\x00\x1c\x00\x21\x00\x1f\x00\x23\x00\x21\x00\x20\x00\x23\x00\x5c\x00\x15\x00\x15\x00\x10\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x1b\x00\x15\x00\x2d\x00\x1f\x00\x1f\x00\x21\x00\x21\x00\x20\x00\x23\x00\x31\x00\x1e\x00\x1f\x00\x07\x00\x21\x00\x03\x00\x04\x00\x3f\x00\x7c\x00\x56\x00\x3f\x00\x73\x00\x13\x00\x14\x00\x3d\x00\x7c\x00\x13\x00\x14\x00\x18\x00\x7c\x00\x03\x00\x04\x00\x73\x00\x35\x00\x63\x00\x7c\x00\x3f\x00\x3f\x00\x17\x00\x0d\x00\x63\x00\x63\x00\x65\x00\x40\x00\x3f\x00\x7c\x00\x81\x00\x64\x00\x71\x00\x22\x00\x73\x00\x7d\x00\x7c\x00\x64\x00\x71\x00\x71\x00\x73\x00\x73\x00\x7d\x00\x70\x00\x71\x00\x72\x00\x73\x00\x80\x00\x7d\x00\x70\x00\x71\x00\x72\x00\x73\x00\x7d\x00\x80\x00\x71\x00\x72\x00\x73\x00\x7d\x00\x7d\x00\x7c\x00\x82\x00\x7c\x00\x0f\x00\x26\x00\x7c\x00\x63\x00\x82\x00\x7d\x00\x7c\x00\x47\x00\x3d\x00\x49\x00\x4a\x00\x84\x00\x00\x00\x4d\x00\x4e\x00\x4f\x00\x7e\x00\x71\x00\x7c\x00\x7c\x00\x57\x00\x59\x00\x7d\x00\x63\x00\x7e\x00\x65\x00\x7c\x00\x63\x00\x67\x00\x65\x00\x12\x00\x6a\x00\x2f\x00\x6c\x00\x62\x00\x57\x00\x64\x00\x71\x00\x66\x00\x73\x00\x11\x00\x71\x00\x75\x00\x73\x00\x15\x00\x78\x00\x29\x00\x2a\x00\x70\x00\x71\x00\x72\x00\x73\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x7c\x00\x34\x00\x2d\x00\x7b\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x58\x00\x59\x00\x2d\x00\x78\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x71\x00\x50\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x2e\x00\x84\x00\x7c\x00\x50\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x71\x00\x72\x00\x73\x00\x72\x00\x73\x00\x38\x00\x3c\x00\x0e\x00\x71\x00\x72\x00\x73\x00\x71\x00\x75\x00\x73\x00\x15\x00\x05\x00\x71\x00\x72\x00\x73\x00\x84\x00\x83\x00\x7c\x00\x71\x00\x72\x00\x73\x00\x03\x00\x04\x00\x84\x00\x71\x00\x72\x00\x73\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x84\x00\x71\x00\x72\x00\x73\x00\x03\x00\x04\x00\x84\x00\x71\x00\x72\x00\x73\x00\x23\x00\x24\x00\x84\x00\x01\x00\x5e\x00\x71\x00\x72\x00\x73\x00\x7e\x00\x3a\x00\x84\x00\x71\x00\x72\x00\x73\x00\x39\x00\x0d\x00\x84\x00\x71\x00\x72\x00\x73\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x84\x00\x71\x00\x72\x00\x73\x00\x03\x00\x04\x00\x84\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x7d\x00\x84\x00\x26\x00\x3d\x00\x0e\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x84\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x03\x00\x04\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x27\x00\x28\x00\x29\x00\x2a\x00\x06\x00\x71\x00\x72\x00\x73\x00\x29\x00\x2a\x00\x72\x00\x73\x00\x28\x00\x29\x00\x2a\x00\x6a\x00\x25\x00\x28\x00\x29\x00\x2a\x00\x1d\x00\x17\x00\x32\x00\x33\x00\x84\x00\x35\x00\x75\x00\x83\x00\x29\x00\x2a\x00\x35\x00\x03\x00\x04\x00\x29\x00\x2a\x00\x05\x00\x06\x00\x05\x00\x06\x00\x71\x00\x72\x00\x73\x00\x29\x00\x2a\x00\x1d\x00\x5a\x00\x5b\x00\x5c\x00\x29\x00\x2a\x00\x71\x00\x72\x00\x73\x00\x29\x00\x2a\x00\x17\x00\x29\x00\x1d\x00\x84\x00\x71\x00\x72\x00\x73\x00\x7f\x00\x22\x00\x71\x00\x72\x00\x73\x00\x23\x00\x24\x00\x84\x00\x71\x00\x72\x00\x73\x00\x65\x00\x71\x00\x72\x00\x73\x00\x22\x00\x84\x00\x7c\x00\x71\x00\x72\x00\x73\x00\x84\x00\x37\x00\x71\x00\x72\x00\x73\x00\x39\x00\x84\x00\x71\x00\x72\x00\x73\x00\x84\x00\x72\x00\x73\x00\x01\x00\x36\x00\x37\x00\x84\x00\x71\x00\x72\x00\x73\x00\x0e\x00\x84\x00\x71\x00\x72\x00\x73\x00\x0d\x00\x84\x00\x15\x00\x83\x00\x3f\x00\x40\x00\x71\x00\x72\x00\x73\x00\x05\x00\x06\x00\x84\x00\x71\x00\x72\x00\x73\x00\x0e\x00\x84\x00\x71\x00\x72\x00\x73\x00\x15\x00\x64\x00\x15\x00\x18\x00\x0d\x00\x84\x00\x61\x00\x15\x00\x1d\x00\x64\x00\x0e\x00\x84\x00\x1a\x00\x70\x00\x71\x00\x64\x00\x84\x00\x15\x00\x20\x00\x23\x00\x24\x00\x70\x00\x71\x00\x01\x00\x02\x00\x03\x00\x04\x00\x70\x00\x71\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x7d\x00\x05\x00\x0e\x00\x07\x00\x13\x00\x0e\x00\x15\x00\x16\x00\x17\x00\x15\x00\x19\x00\x24\x00\x15\x00\x1c\x00\x01\x00\x02\x00\x03\x00\x04\x00\x21\x00\x25\x00\x23\x00\x24\x00\x25\x00\x03\x00\x04\x00\x7e\x00\x0d\x00\x2a\x00\x0e\x00\x0e\x00\x2d\x00\x23\x00\x24\x00\x0d\x00\x15\x00\x15\x00\x15\x00\x34\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\x04\x00\x75\x00\x7c\x00\x0e\x00\x78\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x15\x00\x0f\x00\x15\x00\x35\x00\x78\x00\x13\x00\x7c\x00\x1a\x00\x16\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\x04\x00\x21\x00\x40\x00\x23\x00\x7c\x00\x25\x00\x26\x00\x27\x00\x28\x00\x0d\x00\x2a\x00\x3b\x00\x2c\x00\x7f\x00\x2e\x00\x15\x00\x30\x00\x31\x00\x32\x00\x33\x00\x1a\x00\x2f\x00\x36\x00\x03\x00\x04\x00\x39\x00\x3c\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\x04\x00\x70\x00\x71\x00\x72\x00\x73\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x76\x00\x0c\x00\x78\x00\x35\x00\x7a\x00\x13\x00\x03\x00\x04\x00\x16\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x11\x00\x03\x00\x04\x00\x21\x00\x15\x00\x23\x00\x16\x00\x25\x00\x26\x00\x27\x00\x28\x00\x0d\x00\x2a\x00\x7f\x00\x2c\x00\x07\x00\x2e\x00\x13\x00\x30\x00\x31\x00\x32\x00\x33\x00\x03\x00\x04\x00\x36\x00\x03\x00\x04\x00\x39\x00\x7e\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\x04\x00\x70\x00\x71\x00\x72\x00\x73\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x7f\x00\x0e\x00\x0f\x00\x10\x00\x7c\x00\x13\x00\x03\x00\x04\x00\x16\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x1f\x00\x03\x00\x04\x00\x21\x00\x0e\x00\x23\x00\x1d\x00\x25\x00\x26\x00\x27\x00\x28\x00\x0d\x00\x2a\x00\x1d\x00\x2c\x00\x3a\x00\x2e\x00\x13\x00\x30\x00\x31\x00\x32\x00\x33\x00\x03\x00\x04\x00\x36\x00\x03\x00\x04\x00\x39\x00\x0e\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\x04\x00\x02\x00\x03\x00\x04\x00\x0f\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x02\x00\x03\x00\x04\x00\x0d\x00\x15\x00\x13\x00\x0e\x00\x1f\x00\x16\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x0f\x00\x03\x00\x04\x00\x21\x00\x0f\x00\x23\x00\x0f\x00\x25\x00\x26\x00\x27\x00\x28\x00\x0d\x00\x2a\x00\x0e\x00\x2c\x00\x03\x00\x1a\x00\x13\x00\x30\x00\x31\x00\x32\x00\x33\x00\x10\x00\x10\x00\x36\x00\x11\x00\x0d\x00\x39\x00\x1a\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\x04\x00\x11\x00\x0f\x00\x1e\x00\x2f\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x2b\x00\x67\x00\x0e\x00\x17\x00\x6a\x00\x13\x00\x6c\x00\x17\x00\x16\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x75\x00\x60\x00\x61\x00\x78\x00\x21\x00\x64\x00\x23\x00\x0e\x00\x25\x00\x26\x00\x27\x00\x28\x00\x1b\x00\x2a\x00\x18\x00\x2c\x00\x10\x00\x70\x00\x71\x00\x30\x00\x31\x00\x32\x00\x33\x00\x15\x00\x11\x00\x36\x00\x1e\x00\x0c\x00\x39\x00\x29\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\x04\x00\x0e\x00\x14\x00\x3b\x00\x10\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0c\x00\x0f\x00\x11\x00\x10\x00\x0f\x00\x13\x00\x0e\x00\x2f\x00\x16\x00\x10\x00\x10\x00\x15\x00\x15\x00\x38\x00\x1c\x00\x01\x00\x0e\x00\x03\x00\x04\x00\x21\x00\x17\x00\x23\x00\x1b\x00\x25\x00\x10\x00\x15\x00\x17\x00\x0d\x00\x2a\x00\x17\x00\x0e\x00\x2d\x00\x0e\x00\x13\x00\x14\x00\x0e\x00\x1d\x00\x3a\x00\x34\x00\x1d\x00\x0e\x00\x0e\x00\x14\x00\x0e\x00\x0e\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\x04\x00\x15\x00\x10\x00\x20\x00\x3a\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x37\x00\x0f\x00\x1b\x00\x01\x00\x01\x00\x13\x00\x3a\x00\x22\x00\x16\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x1b\x00\x1b\x00\x03\x00\x3e\x00\x21\x00\x0f\x00\x23\x00\x10\x00\x25\x00\x0d\x00\x10\x00\x09\x00\x0e\x00\x2a\x00\x41\x00\x42\x00\x43\x00\x10\x00\x0d\x00\x30\x00\x31\x00\x32\x00\x3a\x00\x01\x00\x02\x00\x03\x00\x04\x00\x15\x00\x11\x00\x0d\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\x04\x00\x41\x00\xff\xff\x35\x00\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x0f\x00\xff\xff\xff\xff\x68\x00\x13\x00\xff\xff\x6b\x00\x16\x00\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\x1c\x00\xff\xff\x74\x00\x75\x00\x76\x00\x21\x00\x78\x00\x23\x00\x7a\x00\x25\x00\x7c\x00\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\x2d\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\x16\x00\x05\x00\x06\x00\x07\x00\x08\x00\xff\xff\x1c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\xff\xff\x25\x00\xff\xff\xff\xff\xff\xff\x17\x00\x2a\x00\x19\x00\x1a\x00\x2d\x00\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\xff\xff\x34\x00\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x0f\x00\xff\xff\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\x16\x00\x05\x00\x06\x00\x07\x00\x08\x00\xff\xff\x1c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\xff\xff\x25\x00\xff\xff\xff\xff\xff\xff\x17\x00\x2a\x00\x19\x00\x1a\x00\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x34\x00\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x00\x14\x00\xff\xff\x16\x00\x05\x00\x06\x00\x07\x00\x08\x00\xff\xff\x1c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\xff\xff\x25\x00\xff\xff\xff\xff\xff\xff\x17\x00\x2a\x00\x19\x00\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x34\x00\x23\x00\x24\x00\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x01\x00\xff\xff\x03\x00\xff\xff\x21\x00\xff\xff\x23\x00\xff\xff\x25\x00\xff\xff\xff\xff\xff\xff\x0d\x00\x2a\x00\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\x15\x00\xff\xff\xff\xff\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\x04\x00\x0d\x00\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x05\x00\x06\x00\x07\x00\x08\x00\xff\xff\x13\x00\xff\xff\xff\xff\x16\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x17\x00\x21\x00\x19\x00\x23\x00\x1b\x00\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\x23\x00\x24\x00\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\x01\x00\x02\x00\x21\x00\xff\xff\x23\x00\xff\xff\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\x0d\x00\xff\xff\x2d\x00\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\xff\xff\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\x04\x00\x0d\x00\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\xff\xff\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x30\x00\x31\x00\x32\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\x13\x00\xff\xff\x6b\x00\x16\x00\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\x1c\x00\xff\xff\x74\x00\x75\x00\x76\x00\x21\x00\x78\x00\x23\x00\x7a\x00\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\x13\x00\xff\xff\x6b\x00\x16\x00\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\x1c\x00\xff\xff\x74\x00\x75\x00\x76\x00\x21\x00\x78\x00\x23\x00\x7a\x00\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\x13\x00\xff\xff\x6b\x00\x16\x00\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\x1c\x00\xff\xff\x74\x00\x75\x00\x76\x00\x21\x00\x78\x00\x23\x00\x7a\x00\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x34\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\x01\x00\x02\x00\x21\x00\xff\xff\x23\x00\xff\xff\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\x0d\x00\xff\xff\x2d\x00\xff\xff\x11\x00\xff\xff\xff\xff\xff\xff\xff\xff\x34\x00\x01\x00\xff\xff\x03\x00\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\x0f\x00\xff\xff\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x01\x00\x21\x00\x03\x00\x23\x00\xff\xff\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\x0d\x00\x0e\x00\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x21\x00\x03\x00\x23\x00\xff\xff\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\x0d\x00\x0e\x00\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\x18\x00\xff\xff\x01\x00\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\x04\x00\x0d\x00\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x21\x00\xff\xff\x23\x00\xff\xff\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\xff\xff\x1f\x00\xff\xff\x21\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\x03\x00\x04\x00\xff\xff\x06\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x0d\x00\x0e\x00\x01\x00\xff\xff\x03\x00\x04\x00\x13\x00\x06\x00\x15\x00\x01\x00\xff\xff\x03\x00\x04\x00\xff\xff\x0d\x00\xff\xff\xff\xff\xff\xff\x1f\x00\xff\xff\x13\x00\x0d\x00\x0e\x00\x01\x00\x17\x00\x03\x00\x04\x00\x13\x00\xff\xff\x15\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\xff\xff\x24\x00\xff\xff\x1f\x00\x01\x00\x13\x00\x03\x00\x04\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x0d\x00\x1f\x00\xff\xff\xff\xff\x22\x00\xff\xff\x13\x00\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\x24\x00\x01\x00\xff\xff\x03\x00\x04\x00\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x01\x00\xff\xff\x03\x00\x04\x00\xff\xff\xff\xff\x24\x00\x01\x00\x68\x00\x03\x00\x04\x00\x6b\x00\x0d\x00\x6d\x00\xff\xff\x6f\x00\xff\xff\xff\xff\x13\x00\x0d\x00\x74\x00\x75\x00\x76\x00\xff\xff\x78\x00\x13\x00\x7a\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x24\x00\x01\x00\xff\xff\x03\x00\xff\xff\xff\xff\xff\xff\x24\x00\xff\xff\x01\x00\xff\xff\x03\x00\xff\xff\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x01\x00\xff\xff\x03\x00\x04\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x1f\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\xff\xff\xff\xff\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\x69\x00\xff\xff\x6b\x00\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\xff\xff\xff\xff\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\x55\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x7b\x00\xff\xff\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\x5f\x00\xff\xff\xff\xff\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x7b\x00\xff\xff\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\x5f\x00\xff\xff\xff\xff\x62\x00\xff\xff\x64\x00\x47\x00\x66\x00\x49\x00\x4a\x00\xff\xff\xff\xff\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x7b\x00\xff\xff\x4d\x00\x4e\x00\x4f\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\x55\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\x70\x00\x71\x00\x72\x00\x73\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x7b\x00\xff\xff\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\x5f\x00\xff\xff\xff\xff\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x7b\x00\xff\xff\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\x5f\x00\xff\xff\xff\xff\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x7b\x00\xff\xff\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\x5f\x00\xff\xff\xff\xff\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x7b\x00\xff\xff\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\xff\xff\x5f\x00\xff\xff\xff\xff\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x7b\x00\xff\xff\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\x52\x00\x53\x00\xff\xff\xff\xff\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\xff\xff\xff\xff\x4d\x00\x4e\x00\x4f\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x7b\x00\xff\xff\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\xff\xff\xff\xff\x4d\x00\x4e\x00\x4f\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x7b\x00\xff\xff\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\xff\xff\xff\xff\x4d\x00\x4e\x00\x4f\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x7b\x00\xff\xff\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\xff\xff\xff\xff\x4d\x00\x4e\x00\x4f\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x7b\x00\xff\xff\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\xff\xff\xff\xff\x4d\x00\x4e\x00\x4f\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x7b\x00\xff\xff\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\xff\xff\xff\xff\x4d\x00\x4e\x00\x4f\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x7b\x00\xff\xff\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\xff\xff\xff\xff\x4d\x00\x4e\x00\x4f\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x7b\x00\xff\xff\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\xff\xff\xff\xff\x4d\x00\x4e\x00\x4f\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x7b\x00\xff\xff\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\xff\xff\xff\xff\x4d\x00\x4e\x00\x4f\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x7b\x00\xff\xff\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\xff\xff\xff\xff\x4d\x00\x4e\x00\x4f\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\xff\xff\x7b\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\xff\xff\xff\xff\x4d\x00\x4e\x00\x4f\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\xff\xff\x7b\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x47\x00\xff\xff\x49\x00\x4a\x00\xff\xff\xff\xff\x4d\x00\x4e\x00\x4f\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5d\x00\x70\x00\x71\x00\x72\x00\x73\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\xff\xff\x7b\x00\x4d\x00\x4e\x00\x4f\x00\x49\x00\x4a\x00\xff\xff\xff\xff\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\x7b\x00\x4a\x00\xff\xff\xff\xff\x4d\x00\x4e\x00\x4f\x00\x7b\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\xff\xff\x7b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\x7b\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\x4d\x00\x4e\x00\x4f\x00\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\x62\x00\xff\xff\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\xff\xff\x70\x00\x71\x00\x72\x00\x73\x00\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"# happyTable :: HappyAddr happyTable = HappyA# "\x00\x00\xcf\x01\xbc\x00\x05\x00\x03\x00\xf7\x01\x23\x00\x24\x00\x25\x00\xe3\x01\x71\x01\xd0\x01\xd1\x01\x66\x01\xc2\x00\x65\x00\x13\x00\x14\x00\x0d\x00\x8f\x01\x61\x00\x3a\x01\x3b\x01\x34\x01\xdc\x00\xa7\x01\xa8\x01\x15\x00\x3c\x01\xb3\x01\x15\x00\x16\x00\x17\x00\x18\x00\x62\x00\x17\x00\x18\x00\x19\x00\x00\x01\x1a\x00\x19\x00\x1b\x00\x1a\x00\x5a\x01\x1b\x00\xf4\x01\x15\x00\x15\x00\x08\x00\x01\x01\x02\x01\x6a\x00\x6b\x00\x63\x00\x15\x00\x03\x01\xc2\x01\x19\x00\x1a\x00\x1a\x00\xf6\x00\x1b\x00\x20\x01\x77\x01\x78\x01\xe5\x01\x1a\x00\x0d\x00\x7d\x01\x1c\x00\xa9\x01\x3d\x01\x1c\x00\x60\x01\xf9\x01\xc5\x00\x90\x01\xf0\x01\xc4\x00\xc5\x00\xcd\x00\xb2\x00\x0d\x00\x7d\x01\x66\x00\x09\x00\xd2\x01\xa9\x01\x1c\x00\x1c\x00\x3a\x00\xd9\xff\xc6\x00\xd2\x01\xc7\x00\xf5\x01\x1c\x00\x21\x01\x67\x00\x26\x00\xc8\x00\x3b\x00\xd3\x01\xf7\x00\x21\x01\x26\x00\xc8\x00\xc8\x00\xc9\x00\xd3\x01\x3e\x01\x27\x00\x28\x00\x29\x00\x2a\x00\xd4\x01\xf7\x00\x27\x00\x28\x00\x29\x00\x2a\x00\xf7\x00\xd4\x01\x6e\x00\x6f\x00\x2a\x00\x06\x00\x06\x00\x04\x00\x2b\x00\x1d\x00\x86\x01\xab\x01\x1d\x00\xd5\x00\x2b\x00\xf7\x00\x21\x01\x3c\x00\x8f\x01\x3d\x00\x3e\x00\x70\x00\x12\x00\x3f\x00\x40\x00\x41\x00\xa5\x01\xc8\x00\x79\x01\x64\x00\x7e\x01\xec\x01\xf7\x00\xc6\x00\xb4\x01\xc7\x00\x79\x01\xc6\x00\xce\x00\xc7\x00\x13\x00\xcf\x00\x49\x01\xd0\x00\x42\x00\x7f\x01\x43\x00\xc8\x00\x44\x00\xc9\x00\xe1\x01\xc8\x00\xd1\x00\xc9\x00\xe2\x01\xd2\x00\xa1\x01\x6b\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x12\x01\x02\x01\x6a\x00\x6b\x00\xb8\x01\xa2\x01\x13\x01\x46\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6f\x01\x6d\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\xd4\x00\x6d\x00\x12\x01\x02\x01\x6a\x00\x6b\x00\xb6\x01\xb7\x01\x13\x01\xac\x01\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x73\x00\x6d\x00\x6e\x00\x14\x01\x68\x00\x69\x00\x6a\x00\x6b\x00\x7c\x00\x6d\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x7d\x00\x6d\x00\xfc\x01\x02\x01\x6a\x00\x6b\x00\x77\x00\x1e\x01\xb8\x01\x14\x01\xe8\x01\x02\x01\x6a\x00\x6b\x00\x6e\x00\x6f\x00\x2a\x00\xb0\x01\x2a\x00\xfd\x01\x78\x00\x03\x02\x6e\x00\x6f\x00\x2a\x00\x5f\x01\x63\x01\x60\x01\x66\x01\xb4\x00\x6e\x00\x6f\x00\x2a\x00\x70\x00\xf6\x01\x72\x01\x6e\x00\x6f\x00\x2a\x00\x0d\x00\x8f\x01\x70\x00\x6e\x00\x6f\x00\x2a\x00\xcc\x01\x02\x01\x6a\x00\x6b\x00\x70\x00\x6e\x00\x6f\x00\x2a\x00\xc6\x01\xc7\x01\x70\x00\x6e\x00\x6f\x00\x2a\x00\xb7\x00\xb8\x00\x70\x00\x88\x01\x78\x00\x6e\x00\x6f\x00\x2a\x00\x75\x01\xc8\x01\x70\x00\x6e\x00\x6f\x00\x2a\x00\x80\x01\x89\x01\x70\x00\x6e\x00\x6f\x00\x2a\x00\x92\x01\x02\x01\x6a\x00\x6b\x00\x70\x00\x6e\x00\x6f\x00\x2a\x00\x2f\x00\x30\x00\x70\x00\x93\x01\x02\x01\x6a\x00\x6b\x00\x79\x00\x70\x00\x86\x01\x91\x01\xcb\x01\x1d\x01\x02\x01\x6a\x00\x6b\x00\x70\x00\x1f\x01\x02\x01\x6a\x00\x6b\x00\x0d\x00\x45\x01\x22\x01\x02\x01\x6a\x00\x6b\x00\x10\x01\x02\x01\x6a\x00\x6b\x00\x9e\x00\x6e\x00\x6f\x00\x2a\x00\x00\x02\x6b\x00\xb0\x01\x2a\x00\x94\x01\x6a\x00\x6b\x00\x9f\x01\x89\x01\xd9\x01\x6a\x00\x6b\x00\x46\x01\xa1\x01\x95\x01\x96\x01\x70\x00\x97\x01\xd1\x00\xc9\x01\x19\x01\x6b\x00\xda\x01\x0d\x00\x45\x01\xd7\x01\x6b\x00\x20\x00\x21\x00\xb4\x00\x9e\x00\x6e\x00\x6f\x00\x2a\x00\xd8\x01\x6b\x00\x82\x01\xed\x01\xee\x01\xef\x01\x9d\x01\x6b\x00\x6e\x00\x6f\x00\x2a\x00\x19\x01\x6b\x00\xd4\x00\x83\x01\x47\x01\x70\x00\x6e\x00\x6f\x00\x2a\x00\x8a\x01\xdb\x01\x6e\x00\x6f\x00\x2a\x00\xb7\x00\xb8\x00\x70\x00\x6e\x00\x6f\x00\x2a\x00\x98\x01\x6e\x00\x6f\x00\x2a\x00\xdb\x01\x70\x00\xf0\x01\x6e\x00\x6f\x00\x2a\x00\x70\x00\xff\x01\x6e\x00\x6f\x00\x99\x01\x9c\x01\x70\x00\x6e\x00\x6f\x00\x2a\x00\x70\x00\xb0\x01\x2a\x00\x88\x01\xdc\x01\xdd\x01\x70\x00\x6e\x00\x6f\x00\x2a\x00\xeb\x01\x70\x00\x6e\x00\x6f\x00\x2a\x00\x89\x01\x70\x00\xec\x01\xb1\x01\x30\x01\x31\x01\x6e\x00\x6f\x00\x2a\x00\xb4\x00\x9e\x00\x70\x00\x6e\x00\x6f\x00\x2a\x00\x25\x01\x70\x00\x6e\x00\x6f\x00\x2a\x00\xf4\x00\xde\x01\xed\x00\xf5\x00\x2c\x01\x70\x00\x6d\x01\xac\xff\xf6\x00\xe1\x00\x26\x01\x70\x00\xac\xff\x27\x00\x28\x00\xde\x01\x70\x00\x27\x01\xa7\x00\xb7\x00\xb8\x00\x27\x00\x28\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x27\x00\x28\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\xa1\x00\x2a\x01\xb4\x00\x28\x01\x9f\x00\x4d\x00\x65\x01\xa2\x00\x4e\x00\xa3\x00\x29\x01\xa4\x00\x2e\x01\x66\x01\x85\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x4f\x00\x31\x01\xa5\x00\xa6\x00\x51\x00\x2f\x00\x30\x00\x33\x01\x31\x00\x55\x00\xea\x00\xec\x00\x86\x00\xb7\x00\xb8\x00\xb3\x01\x32\x00\xeb\x00\xed\x00\x87\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\x63\x01\x37\x01\xf0\x00\x5e\x01\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xf1\x00\x1f\x00\xb9\x00\x33\x00\x5e\x01\xdb\xfe\x52\x01\xe3\x01\xdb\xfe\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\xdb\xfe\xdd\x00\xdb\xfe\xfa\x00\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\x31\x00\xdb\xfe\xfd\x00\xdb\xfe\x0d\x01\xdb\xfe\xb9\x00\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xba\x00\x1b\x01\xdb\xfe\xd5\x01\xd6\x01\xdb\xfe\x0e\x01\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xd8\x00\x28\x00\xd9\x00\x2a\x00\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\x97\x00\x74\x00\x99\x00\x33\x00\xb1\x00\xdb\xfe\xbb\x01\xbc\x01\xdb\xfe\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2d\x00\x59\x01\x2f\x00\x30\x00\xdb\xfe\x5a\x01\xdb\xfe\xba\x00\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\x72\x00\xdb\xfe\xbd\x00\xdb\xfe\xbf\x00\xdb\xfe\x73\x00\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\x5d\x00\x5e\x00\xdb\xfe\x5f\x00\x60\x00\xdb\xfe\x10\x00\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\x2d\x00\x2e\x00\x2f\x00\x30\x00\xe4\x00\x28\x00\xd9\x00\x2a\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x09\x00\x8b\x01\x8c\x01\x8d\x01\x02\x00\x4d\x00\x2f\x00\x30\x00\x4e\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2d\x00\x05\x02\x2f\x00\x30\x00\x4f\x00\x02\x02\x50\x00\xf4\x01\x51\x00\x52\x00\x53\x00\x54\x00\x72\x00\x55\x00\xdb\xfe\x56\x00\xdf\x00\x57\x00\x73\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x0b\x00\x0c\x00\x5c\x00\x0b\x00\x0c\x00\x5d\x00\xf9\x01\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x0c\x00\x0d\x00\x0e\x00\x1f\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x0f\x00\x0d\x00\x0e\x00\xe5\x01\xe7\x01\x4d\x00\xe8\x01\xf2\x01\x4e\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2d\x00\x1f\x00\x2f\x00\x30\x00\x4f\x00\x1f\x00\x50\x00\xcc\x01\x51\x00\x52\x00\x53\x00\x54\x00\x72\x00\x55\x00\xce\x01\x56\x00\x2f\x00\xcf\x01\x73\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x0e\xff\x9f\x01\x5c\x00\xa7\x01\xab\x01\x5d\x00\xae\x01\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xb6\x01\x1f\x00\xbf\x01\x49\x01\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xbb\x01\xce\x00\x68\x01\x6a\x01\xcf\x00\xdb\xfe\x68\x01\x6b\x01\xdb\xfe\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xd1\x00\xdf\x00\xe0\x00\xd2\x00\xdb\xfe\xe1\x00\xdb\xfe\x6c\x01\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\x6d\x01\xdb\xfe\x71\x01\xdb\xfe\xf9\x00\x27\x00\x28\x00\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\x74\x01\x77\x01\xdb\xfe\x85\x01\x33\x01\xdb\xfe\x83\x01\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\x2d\x00\x2e\x00\x2f\x00\x30\x00\x24\x01\x2a\x01\x2e\x01\x2c\x01\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x33\x01\x09\x01\x37\x01\xf9\x00\x39\x01\x4d\x00\x3a\x01\x49\x01\x4e\x00\xf9\x00\x40\x01\x27\x01\x29\x01\x45\x01\x85\x00\x2d\x00\x56\x01\x2f\x00\x30\x00\x4f\x00\x57\x01\x50\x00\x58\x01\x51\x00\xf9\x00\x62\x01\x5d\x01\x72\x00\x55\x00\x5e\x01\x63\x01\x86\x00\xc4\x00\x73\x00\x12\x01\xe3\xfe\xdb\x00\xdf\x00\x0a\x01\xdb\xfe\xe5\xfe\xe8\xfe\xf3\x00\xe6\x00\xe7\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xf2\x00\xf9\x00\xa7\x00\xff\x00\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xfd\x00\x1f\x00\x00\x01\x0c\x01\x0d\x01\xdb\xfe\x10\x01\x18\x01\xdb\xfe\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x19\x01\x1d\x01\x2f\x00\x76\x00\xdb\xfe\x1f\x00\xdb\xfe\x7b\x00\xdb\xfe\x7c\x00\xa8\x00\xbc\x00\xc2\x00\xdb\xfe\xa9\x00\xaa\x00\xab\x00\x08\x00\xbf\x00\xdb\xfe\xdb\xfe\xdb\xfe\x3a\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\xc1\x00\x20\x00\x23\x00\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\x2d\x00\x2e\x00\x2f\x00\x30\x00\xff\xff\x00\x00\x09\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x09\x01\x00\x00\x00\x00\xac\x00\x4d\x00\x00\x00\xad\x00\x4e\x00\xae\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x85\x00\x00\x00\x95\x00\x96\x00\xb0\x00\x4f\x00\x99\x00\x50\x00\xb1\x00\x51\x00\xb2\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x86\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x0a\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x54\x01\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x4e\x00\xb4\x00\x9e\x00\x9f\x00\xa0\x00\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x00\x00\x50\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x55\x00\xa4\x00\xef\x00\x86\x00\x00\x00\x00\x00\x22\xff\x00\x00\x00\x00\x00\x00\x87\x00\xb7\x00\xb8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x09\x01\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x4e\x00\xb4\x00\x9e\x00\x9f\x00\xa0\x00\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x00\x00\x50\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x55\x00\xa4\x00\xef\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x01\xb7\x00\xb8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x8d\x00\x00\x00\x4e\x00\xb4\x00\x9e\x00\x9f\x00\xa0\x00\x00\x00\x85\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x00\x00\x50\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x55\x00\xa4\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\xb7\x00\xb8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x00\x2d\x00\x00\x00\x2f\x00\x00\x00\x4f\x00\x00\x00\x50\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x55\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x32\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\x31\x00\x00\x00\x00\x00\x00\x00\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xb4\x00\x9e\x00\x9f\x00\xa0\x00\x00\x00\xdb\xfe\x00\x00\x00\x00\xdb\xfe\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x00\x00\xb5\x00\xdb\xfe\xa4\x00\xdb\xfe\xb6\x00\xdb\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xdb\xfe\x00\x00\xb7\x00\xb8\x00\x00\x00\x00\x00\xdb\xfe\xdb\xfe\xdb\xfe\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x4f\x00\x00\x00\x50\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x31\x00\x00\x00\x86\x00\x00\x00\xe0\x01\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x00\x00\x00\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x4e\x00\x00\x00\x00\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x4f\x00\x00\x00\x50\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x59\x00\x5a\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x4d\x00\x00\x00\xad\x00\x4e\x00\xae\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x85\x00\x00\x00\x95\x00\x96\x00\xb0\x00\x4f\x00\x99\x00\x50\x00\xb1\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x4d\x00\x00\x00\xad\x00\x4e\x00\xfb\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x85\x00\x00\x00\x95\x00\x96\x00\xb0\x00\x4f\x00\x99\x00\x50\x00\xb1\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x00\x4d\x00\x00\x00\xad\x00\x4e\x00\xed\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x85\x00\x00\x00\x95\x00\x96\x00\xb0\x00\x4f\x00\x99\x00\x50\x00\xb1\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x4f\x00\x00\x00\x50\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x31\x00\x00\x00\x86\x00\x00\x00\xe3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x2d\x00\x00\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\x00\x00\x1f\x00\x00\x00\x00\x00\x00\x00\xdb\xfe\x00\x00\x00\x00\xdb\xfe\x00\x00\x00\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x2d\x00\xdb\xfe\x2f\x00\xdb\xfe\x00\x00\xdb\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xdb\xfe\x00\x00\xcb\x00\xfb\x01\x00\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2d\x00\x00\x00\xfc\x01\x00\x00\x00\x00\x00\x00\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\xfe\x00\x00\x00\x00\xdb\xfe\x00\x00\x00\x00\x00\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2d\x00\xdb\xfe\x2f\x00\xdb\xfe\x00\x00\xdb\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xdb\xfe\x00\x00\xcb\x00\xcc\x00\x00\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\xcd\x00\x00\x00\x2d\x00\x00\x00\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\xdb\xfe\x2d\x00\x2e\x00\x2f\x00\x30\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x4f\x00\x00\x00\x50\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x7d\x01\x00\x00\x4f\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x4e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x00\x00\x2f\x00\x30\x00\x00\x00\x9e\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x72\x00\x16\x01\x2d\x00\x00\x00\x2f\x00\x30\x00\x73\x00\x80\xff\xa2\x00\x2d\x00\x00\x00\x2f\x00\x30\x00\x00\x00\x72\x00\x00\x00\x00\x00\x00\x00\x17\x01\x00\x00\x73\x00\x72\x00\x16\x01\x2d\x00\x80\xff\x2f\x00\x30\x00\x73\x00\x00\x00\xa2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x72\x00\x00\x00\xa5\x01\x00\x00\x17\x01\x2d\x00\x73\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x72\x00\x1b\x01\x00\x00\x00\x00\x92\xff\x00\x00\x73\x00\x00\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\xff\x01\x2d\x00\x00\x00\x2f\x00\x30\x00\x00\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x2d\x00\x00\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x9c\x01\x2d\x00\xac\x00\x2f\x00\x30\x00\xad\x00\x72\x00\xfb\x00\x00\x00\xaf\x00\x00\x00\x00\x00\x73\x00\x9b\x01\x95\x00\x96\x00\xb0\x00\x00\x00\x99\x00\x73\x00\xb1\x00\x00\x00\x00\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\xa4\x01\x2d\x00\x00\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x9c\x01\x00\x00\x2d\x00\x00\x00\x2f\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcb\x00\x00\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2d\x00\x00\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x1b\x01\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x8d\x00\x7f\x00\x80\x00\x8e\x00\x82\x00\x3d\x00\x3e\x00\x00\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x8f\x00\x90\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x91\x00\x00\x00\x92\x00\x00\x00\x00\x00\x93\x00\x94\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x46\x00\x49\x01\x7f\x00\x80\x00\x05\x01\x82\x00\x3d\x00\x3e\x00\x00\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x01\x4b\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x04\x01\x7f\x00\x80\x00\x05\x01\x82\x00\x3d\x00\x3e\x00\x46\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x01\x00\x00\xe9\x01\x00\x00\x00\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x04\x01\x7f\x00\x80\x00\x05\x01\x82\x00\x3d\x00\x3e\x00\x46\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x01\x00\x00\xae\x01\x00\x00\x00\x00\x42\x00\x00\x00\x83\x00\x3c\x00\x44\x00\x3d\x00\x3e\x00\x00\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x49\x01\x7f\x00\x80\x00\x05\x01\x82\x00\x3d\x00\x3e\x00\x46\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\xbd\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x01\x27\x00\x28\x00\x45\x00\x2a\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x04\x01\x7f\x00\x80\x00\x05\x01\x82\x00\x3d\x00\x3e\x00\x46\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x01\x00\x00\x83\x01\x00\x00\x00\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x04\x01\x7f\x00\x80\x00\x05\x01\x82\x00\x3d\x00\x3e\x00\x46\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x01\x00\x00\x35\x01\x00\x00\x00\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x04\x01\x7f\x00\x80\x00\x05\x01\x82\x00\x3d\x00\x3e\x00\x46\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x01\x00\x00\x07\x01\x00\x00\x00\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x04\x01\x7f\x00\x80\x00\x05\x01\x82\x00\x3d\x00\x3e\x00\x46\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x01\x00\x00\x0a\x01\x00\x00\x00\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x89\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x3d\x00\x3e\x00\x46\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x00\x00\x00\x00\x8a\x00\x8b\x00\x00\x00\x00\x00\x05\x02\x7f\x00\x80\x00\x81\x00\x82\x00\x3d\x00\x3e\x00\x00\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\xf2\x01\x7f\x00\x80\x00\x81\x00\x82\x00\x3d\x00\x3e\x00\x46\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\x01\x7f\x00\x80\x00\x81\x00\x82\x00\x3d\x00\x3e\x00\x00\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\xc3\x01\x7f\x00\x80\x00\x81\x00\x82\x00\x3d\x00\x3e\x00\x46\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x01\x7f\x00\x80\x00\x81\x00\x82\x00\x3d\x00\x3e\x00\x00\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\xb9\x01\x7f\x00\x80\x00\x81\x00\x82\x00\x3d\x00\x3e\x00\x46\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbf\x01\x7f\x00\x80\x00\x81\x00\x82\x00\x3d\x00\x3e\x00\x00\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\xc0\x01\x7f\x00\x80\x00\x81\x00\x82\x00\x3d\x00\x3e\x00\x46\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x01\x7f\x00\x80\x00\x81\x00\x82\x00\x3d\x00\x3e\x00\x00\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x74\x01\x7f\x00\x80\x00\x81\x00\x82\x00\x3d\x00\x3e\x00\x46\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x01\x7f\x00\x80\x00\x81\x00\x82\x00\x3d\x00\x3e\x00\x00\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x4e\x01\x7f\x00\x80\x00\x81\x00\x82\x00\x3d\x00\x3e\x00\x46\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x01\x7f\x00\x80\x00\x81\x00\x82\x00\x3d\x00\x3e\x00\x00\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x50\x01\x7f\x00\x80\x00\x81\x00\x82\x00\x3d\x00\x3e\x00\x46\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x01\x7f\x00\x80\x00\x81\x00\x82\x00\x3d\x00\x3e\x00\x00\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x54\x01\x7f\x00\x80\x00\x81\x00\x82\x00\x3d\x00\x3e\x00\x46\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x3d\x00\x3e\x00\x00\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\xf9\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x3d\x00\x3e\x00\x46\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x3d\x00\x3e\x00\x00\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x03\x02\x80\x00\xe8\x00\x82\x00\x3d\x00\x3e\x00\x00\x00\x46\x00\x3f\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x01\x80\x00\xe8\x00\x82\x00\x3d\x00\x3e\x00\x00\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\xe7\x00\x80\x00\xe8\x00\x82\x00\x3d\x00\x3e\x00\x00\x00\x46\x00\x3f\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc4\x01\x00\x00\x3d\x00\x3e\x00\x00\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc5\x01\x27\x00\x28\x00\x45\x00\x2a\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x40\x01\xdb\x00\x3e\x00\x00\x00\x46\x00\x3f\x00\x40\x00\x41\x00\xdb\x00\x3e\x00\x00\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x46\x00\x87\x00\x00\x00\x00\x00\x3f\x00\x40\x00\x41\x00\x46\x00\x41\x01\x42\x01\x43\x01\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x00\x00\x46\x00\x7b\x01\x43\x01\x40\x00\x41\x00\x00\x00\x46\x00\xe3\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\xa8\x00\x40\x00\x41\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x00\x00\x46\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x88\x00\x40\x00\x41\x00\x00\x00\x00\x00\xa8\x00\x40\x00\x41\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x46\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x42\x00\x00\x00\x83\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x00\x00\x27\x00\x28\x00\x45\x00\x2a\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"# happyReduceArr = Happy_Data_Array.array (1, 302) [ (1 , happyReduce_1), (2 , happyReduce_2), (3 , happyReduce_3), (4 , happyReduce_4), (5 , happyReduce_5), (6 , happyReduce_6), (7 , happyReduce_7), (8 , happyReduce_8), (9 , happyReduce_9), (10 , happyReduce_10), (11 , happyReduce_11), (12 , happyReduce_12), (13 , happyReduce_13), (14 , happyReduce_14), (15 , happyReduce_15), (16 , happyReduce_16), (17 , happyReduce_17), (18 , happyReduce_18), (19 , happyReduce_19), (20 , happyReduce_20), (21 , happyReduce_21), (22 , happyReduce_22), (23 , happyReduce_23), (24 , happyReduce_24), (25 , happyReduce_25), (26 , happyReduce_26), (27 , happyReduce_27), (28 , happyReduce_28), (29 , happyReduce_29), (30 , happyReduce_30), (31 , happyReduce_31), (32 , happyReduce_32), (33 , happyReduce_33), (34 , happyReduce_34), (35 , happyReduce_35), (36 , happyReduce_36), (37 , happyReduce_37), (38 , happyReduce_38), (39 , happyReduce_39), (40 , happyReduce_40), (41 , happyReduce_41), (42 , happyReduce_42), (43 , happyReduce_43), (44 , happyReduce_44), (45 , happyReduce_45), (46 , happyReduce_46), (47 , happyReduce_47), (48 , happyReduce_48), (49 , happyReduce_49), (50 , happyReduce_50), (51 , happyReduce_51), (52 , happyReduce_52), (53 , happyReduce_53), (54 , happyReduce_54), (55 , happyReduce_55), (56 , happyReduce_56), (57 , happyReduce_57), (58 , happyReduce_58), (59 , happyReduce_59), (60 , happyReduce_60), (61 , happyReduce_61), (62 , happyReduce_62), (63 , happyReduce_63), (64 , happyReduce_64), (65 , happyReduce_65), (66 , happyReduce_66), (67 , happyReduce_67), (68 , happyReduce_68), (69 , happyReduce_69), (70 , happyReduce_70), (71 , happyReduce_71), (72 , happyReduce_72), (73 , happyReduce_73), (74 , happyReduce_74), (75 , happyReduce_75), (76 , happyReduce_76), (77 , happyReduce_77), (78 , happyReduce_78), (79 , happyReduce_79), (80 , happyReduce_80), (81 , happyReduce_81), (82 , happyReduce_82), (83 , happyReduce_83), (84 , happyReduce_84), (85 , happyReduce_85), (86 , happyReduce_86), (87 , happyReduce_87), (88 , happyReduce_88), (89 , happyReduce_89), (90 , happyReduce_90), (91 , happyReduce_91), (92 , happyReduce_92), (93 , happyReduce_93), (94 , happyReduce_94), (95 , happyReduce_95), (96 , happyReduce_96), (97 , happyReduce_97), (98 , happyReduce_98), (99 , happyReduce_99), (100 , happyReduce_100), (101 , happyReduce_101), (102 , happyReduce_102), (103 , happyReduce_103), (104 , happyReduce_104), (105 , happyReduce_105), (106 , happyReduce_106), (107 , happyReduce_107), (108 , happyReduce_108), (109 , happyReduce_109), (110 , happyReduce_110), (111 , happyReduce_111), (112 , happyReduce_112), (113 , happyReduce_113), (114 , happyReduce_114), (115 , happyReduce_115), (116 , happyReduce_116), (117 , happyReduce_117), (118 , happyReduce_118), (119 , happyReduce_119), (120 , happyReduce_120), (121 , happyReduce_121), (122 , happyReduce_122), (123 , happyReduce_123), (124 , happyReduce_124), (125 , happyReduce_125), (126 , happyReduce_126), (127 , happyReduce_127), (128 , happyReduce_128), (129 , happyReduce_129), (130 , happyReduce_130), (131 , happyReduce_131), (132 , happyReduce_132), (133 , happyReduce_133), (134 , happyReduce_134), (135 , happyReduce_135), (136 , happyReduce_136), (137 , happyReduce_137), (138 , happyReduce_138), (139 , happyReduce_139), (140 , happyReduce_140), (141 , happyReduce_141), (142 , happyReduce_142), (143 , happyReduce_143), (144 , happyReduce_144), (145 , happyReduce_145), (146 , happyReduce_146), (147 , happyReduce_147), (148 , happyReduce_148), (149 , happyReduce_149), (150 , happyReduce_150), (151 , happyReduce_151), (152 , happyReduce_152), (153 , happyReduce_153), (154 , happyReduce_154), (155 , happyReduce_155), (156 , happyReduce_156), (157 , happyReduce_157), (158 , happyReduce_158), (159 , happyReduce_159), (160 , happyReduce_160), (161 , happyReduce_161), (162 , happyReduce_162), (163 , happyReduce_163), (164 , happyReduce_164), (165 , happyReduce_165), (166 , happyReduce_166), (167 , happyReduce_167), (168 , happyReduce_168), (169 , happyReduce_169), (170 , happyReduce_170), (171 , happyReduce_171), (172 , happyReduce_172), (173 , happyReduce_173), (174 , happyReduce_174), (175 , happyReduce_175), (176 , happyReduce_176), (177 , happyReduce_177), (178 , happyReduce_178), (179 , happyReduce_179), (180 , happyReduce_180), (181 , happyReduce_181), (182 , happyReduce_182), (183 , happyReduce_183), (184 , happyReduce_184), (185 , happyReduce_185), (186 , happyReduce_186), (187 , happyReduce_187), (188 , happyReduce_188), (189 , happyReduce_189), (190 , happyReduce_190), (191 , happyReduce_191), (192 , happyReduce_192), (193 , happyReduce_193), (194 , happyReduce_194), (195 , happyReduce_195), (196 , happyReduce_196), (197 , happyReduce_197), (198 , happyReduce_198), (199 , happyReduce_199), (200 , happyReduce_200), (201 , happyReduce_201), (202 , happyReduce_202), (203 , happyReduce_203), (204 , happyReduce_204), (205 , happyReduce_205), (206 , happyReduce_206), (207 , happyReduce_207), (208 , happyReduce_208), (209 , happyReduce_209), (210 , happyReduce_210), (211 , happyReduce_211), (212 , happyReduce_212), (213 , happyReduce_213), (214 , happyReduce_214), (215 , happyReduce_215), (216 , happyReduce_216), (217 , happyReduce_217), (218 , happyReduce_218), (219 , happyReduce_219), (220 , happyReduce_220), (221 , happyReduce_221), (222 , happyReduce_222), (223 , happyReduce_223), (224 , happyReduce_224), (225 , happyReduce_225), (226 , happyReduce_226), (227 , happyReduce_227), (228 , happyReduce_228), (229 , happyReduce_229), (230 , happyReduce_230), (231 , happyReduce_231), (232 , happyReduce_232), (233 , happyReduce_233), (234 , happyReduce_234), (235 , happyReduce_235), (236 , happyReduce_236), (237 , happyReduce_237), (238 , happyReduce_238), (239 , happyReduce_239), (240 , happyReduce_240), (241 , happyReduce_241), (242 , happyReduce_242), (243 , happyReduce_243), (244 , happyReduce_244), (245 , happyReduce_245), (246 , happyReduce_246), (247 , happyReduce_247), (248 , happyReduce_248), (249 , happyReduce_249), (250 , happyReduce_250), (251 , happyReduce_251), (252 , happyReduce_252), (253 , happyReduce_253), (254 , happyReduce_254), (255 , happyReduce_255), (256 , happyReduce_256), (257 , happyReduce_257), (258 , happyReduce_258), (259 , happyReduce_259), (260 , happyReduce_260), (261 , happyReduce_261), (262 , happyReduce_262), (263 , happyReduce_263), (264 , happyReduce_264), (265 , happyReduce_265), (266 , happyReduce_266), (267 , happyReduce_267), (268 , happyReduce_268), (269 , happyReduce_269), (270 , happyReduce_270), (271 , happyReduce_271), (272 , happyReduce_272), (273 , happyReduce_273), (274 , happyReduce_274), (275 , happyReduce_275), (276 , happyReduce_276), (277 , happyReduce_277), (278 , happyReduce_278), (279 , happyReduce_279), (280 , happyReduce_280), (281 , happyReduce_281), (282 , happyReduce_282), (283 , happyReduce_283), (284 , happyReduce_284), (285 , happyReduce_285), (286 , happyReduce_286), (287 , happyReduce_287), (288 , happyReduce_288), (289 , happyReduce_289), (290 , happyReduce_290), (291 , happyReduce_291), (292 , happyReduce_292), (293 , happyReduce_293), (294 , happyReduce_294), (295 , happyReduce_295), (296 , happyReduce_296), (297 , happyReduce_297), (298 , happyReduce_298), (299 , happyReduce_299), (300 , happyReduce_300), (301 , happyReduce_301), (302 , happyReduce_302) ] happy_n_terms = 66 :: Int happy_n_nonterms = 133 :: Int happyReduce_1 = happyReduce 6# 0# happyReduction_1 happyReduction_1 (happy_x_6 `HappyStk` happy_x_5 `HappyStk` happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut128 happy_x_1 of { happy_var_1 -> case happyOut131 happy_x_3 of { happy_var_3 -> case happyOut9 happy_x_4 of { happy_var_4 -> case happyOut5 happy_x_6 of { happy_var_6 -> happyIn4 (HsModule happy_var_1 happy_var_3 happy_var_4 (fst happy_var_6) (snd happy_var_6) ) `HappyStk` happyRest}}}} happyReduce_2 = happySpecReduce_2 0# happyReduction_2 happyReduction_2 happy_x_2 happy_x_1 = case happyOut128 happy_x_1 of { happy_var_1 -> case happyOut5 happy_x_2 of { happy_var_2 -> happyIn4 (HsModule happy_var_1 main_mod (Just [HsEVar (UnQual main_name)]) (fst happy_var_2) (snd happy_var_2) )}} happyReduce_3 = happySpecReduce_3 1# happyReduction_3 happyReduction_3 happy_x_3 happy_x_2 happy_x_1 = case happyOut6 happy_x_2 of { happy_var_2 -> happyIn5 (happy_var_2 )} happyReduce_4 = happySpecReduce_3 1# happyReduction_4 happyReduction_4 happy_x_3 happy_x_2 happy_x_1 = case happyOut6 happy_x_2 of { happy_var_2 -> happyIn5 (happy_var_2 )} happyReduce_5 = happyReduce 4# 2# happyReduction_5 happyReduction_5 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut14 happy_x_2 of { happy_var_2 -> case happyOut29 happy_x_4 of { happy_var_4 -> happyIn6 ((reverse happy_var_2, happy_var_4) ) `HappyStk` happyRest}} happyReduce_6 = happySpecReduce_2 2# happyReduction_6 happyReduction_6 happy_x_2 happy_x_1 = case happyOut29 happy_x_2 of { happy_var_2 -> happyIn6 (([], happy_var_2) )} happyReduce_7 = happySpecReduce_3 2# happyReduction_7 happyReduction_7 happy_x_3 happy_x_2 happy_x_1 = case happyOut14 happy_x_2 of { happy_var_2 -> happyIn6 ((reverse happy_var_2, []) )} happyReduce_8 = happySpecReduce_1 2# happyReduction_8 happyReduction_8 happy_x_1 = happyIn6 (([], []) ) happyReduce_9 = happySpecReduce_2 3# happyReduction_9 happyReduction_9 happy_x_2 happy_x_1 = happyIn7 (() ) happyReduce_10 = happySpecReduce_1 4# happyReduction_10 happyReduction_10 happy_x_1 = happyIn8 (() ) happyReduce_11 = happySpecReduce_0 4# happyReduction_11 happyReduction_11 = happyIn8 (() ) happyReduce_12 = happySpecReduce_1 5# happyReduction_12 happyReduction_12 happy_x_1 = case happyOut10 happy_x_1 of { happy_var_1 -> happyIn9 (Just happy_var_1 )} happyReduce_13 = happySpecReduce_0 5# happyReduction_13 happyReduction_13 = happyIn9 (Nothing ) happyReduce_14 = happyReduce 4# 6# happyReduction_14 happyReduction_14 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut12 happy_x_2 of { happy_var_2 -> happyIn10 (reverse happy_var_2 ) `HappyStk` happyRest} happyReduce_15 = happySpecReduce_3 6# happyReduction_15 happyReduction_15 happy_x_3 happy_x_2 happy_x_1 = happyIn10 ([] ) happyReduce_16 = happySpecReduce_1 7# happyReduction_16 happyReduction_16 happy_x_1 = happyIn11 (() ) happyReduce_17 = happySpecReduce_0 7# happyReduction_17 happyReduction_17 = happyIn11 (() ) happyReduce_18 = happySpecReduce_3 8# happyReduction_18 happyReduction_18 happy_x_3 happy_x_2 happy_x_1 = case happyOut12 happy_x_1 of { happy_var_1 -> case happyOut13 happy_x_3 of { happy_var_3 -> happyIn12 (happy_var_3 : happy_var_1 )}} happyReduce_19 = happySpecReduce_1 8# happyReduction_19 happyReduction_19 happy_x_1 = case happyOut13 happy_x_1 of { happy_var_1 -> happyIn12 ([happy_var_1] )} happyReduce_20 = happySpecReduce_1 9# happyReduction_20 happyReduction_20 happy_x_1 = case happyOut104 happy_x_1 of { happy_var_1 -> happyIn13 (HsEVar happy_var_1 )} happyReduce_21 = happySpecReduce_1 9# happyReduction_21 happyReduction_21 happy_x_1 = case happyOut134 happy_x_1 of { happy_var_1 -> happyIn13 (HsEAbs happy_var_1 )} happyReduce_22 = happyReduce 4# 9# happyReduction_22 happyReduction_22 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut134 happy_x_1 of { happy_var_1 -> happyIn13 (HsEThingAll happy_var_1 ) `HappyStk` happyRest} happyReduce_23 = happySpecReduce_3 9# happyReduction_23 happyReduction_23 happy_x_3 happy_x_2 happy_x_1 = case happyOut134 happy_x_1 of { happy_var_1 -> happyIn13 (HsEThingWith happy_var_1 [] )} happyReduce_24 = happyReduce 4# 9# happyReduction_24 happyReduction_24 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut134 happy_x_1 of { happy_var_1 -> case happyOut23 happy_x_3 of { happy_var_3 -> happyIn13 (HsEThingWith happy_var_1 (reverse happy_var_3) ) `HappyStk` happyRest}} happyReduce_25 = happySpecReduce_2 9# happyReduction_25 happyReduction_25 happy_x_2 happy_x_1 = case happyOut131 happy_x_2 of { happy_var_2 -> happyIn13 (HsEModuleContents happy_var_2 )} happyReduce_26 = happySpecReduce_3 10# happyReduction_26 happyReduction_26 happy_x_3 happy_x_2 happy_x_1 = case happyOut14 happy_x_1 of { happy_var_1 -> case happyOut15 happy_x_3 of { happy_var_3 -> happyIn14 (happy_var_3 : happy_var_1 )}} happyReduce_27 = happySpecReduce_1 10# happyReduction_27 happyReduction_27 happy_x_1 = case happyOut15 happy_x_1 of { happy_var_1 -> happyIn14 ([happy_var_1] )} happyReduce_28 = happyReduce 6# 11# happyReduction_28 happyReduction_28 (happy_x_6 `HappyStk` happy_x_5 `HappyStk` happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut128 happy_x_1 of { happy_var_1 -> case happyOut16 happy_x_3 of { happy_var_3 -> case happyOut131 happy_x_4 of { happy_var_4 -> case happyOut17 happy_x_5 of { happy_var_5 -> case happyOut18 happy_x_6 of { happy_var_6 -> happyIn15 (HsImportDecl happy_var_1 happy_var_4 happy_var_3 happy_var_5 happy_var_6 ) `HappyStk` happyRest}}}}} happyReduce_29 = happySpecReduce_1 12# happyReduction_29 happyReduction_29 happy_x_1 = happyIn16 (True ) happyReduce_30 = happySpecReduce_0 12# happyReduction_30 happyReduction_30 = happyIn16 (False ) happyReduce_31 = happySpecReduce_2 13# happyReduction_31 happyReduction_31 happy_x_2 happy_x_1 = case happyOut131 happy_x_2 of { happy_var_2 -> happyIn17 (Just happy_var_2 )} happyReduce_32 = happySpecReduce_0 13# happyReduction_32 happyReduction_32 = happyIn17 (Nothing ) happyReduce_33 = happySpecReduce_1 14# happyReduction_33 happyReduction_33 happy_x_1 = case happyOut19 happy_x_1 of { happy_var_1 -> happyIn18 (Just happy_var_1 )} happyReduce_34 = happySpecReduce_0 14# happyReduction_34 happyReduction_34 = happyIn18 (Nothing ) happyReduce_35 = happyReduce 5# 15# happyReduction_35 happyReduction_35 (happy_x_5 `HappyStk` happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut20 happy_x_1 of { happy_var_1 -> case happyOut21 happy_x_3 of { happy_var_3 -> happyIn19 ((happy_var_1, reverse happy_var_3) ) `HappyStk` happyRest}} happyReduce_36 = happyReduce 4# 15# happyReduction_36 happyReduction_36 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut20 happy_x_1 of { happy_var_1 -> happyIn19 ((happy_var_1, []) ) `HappyStk` happyRest} happyReduce_37 = happySpecReduce_1 16# happyReduction_37 happyReduction_37 happy_x_1 = happyIn20 (True ) happyReduce_38 = happySpecReduce_0 16# happyReduction_38 happyReduction_38 = happyIn20 (False ) happyReduce_39 = happySpecReduce_3 17# happyReduction_39 happyReduction_39 happy_x_3 happy_x_2 happy_x_1 = case happyOut21 happy_x_1 of { happy_var_1 -> case happyOut22 happy_x_3 of { happy_var_3 -> happyIn21 (happy_var_3 : happy_var_1 )}} happyReduce_40 = happySpecReduce_1 17# happyReduction_40 happyReduction_40 happy_x_1 = case happyOut22 happy_x_1 of { happy_var_1 -> happyIn21 ([happy_var_1] )} happyReduce_41 = happySpecReduce_1 18# happyReduction_41 happyReduction_41 happy_x_1 = case happyOut103 happy_x_1 of { happy_var_1 -> happyIn22 (HsIVar happy_var_1 )} happyReduce_42 = happySpecReduce_1 18# happyReduction_42 happyReduction_42 happy_x_1 = case happyOut132 happy_x_1 of { happy_var_1 -> happyIn22 (HsIAbs happy_var_1 )} happyReduce_43 = happyReduce 4# 18# happyReduction_43 happyReduction_43 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut132 happy_x_1 of { happy_var_1 -> happyIn22 (HsIThingAll happy_var_1 ) `HappyStk` happyRest} happyReduce_44 = happySpecReduce_3 18# happyReduction_44 happyReduction_44 happy_x_3 happy_x_2 happy_x_1 = case happyOut132 happy_x_1 of { happy_var_1 -> happyIn22 (HsIThingWith happy_var_1 [] )} happyReduce_45 = happyReduce 4# 18# happyReduction_45 happyReduction_45 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut132 happy_x_1 of { happy_var_1 -> case happyOut23 happy_x_3 of { happy_var_3 -> happyIn22 (HsIThingWith happy_var_1 (reverse happy_var_3) ) `HappyStk` happyRest}} happyReduce_46 = happySpecReduce_3 19# happyReduction_46 happyReduction_46 happy_x_3 happy_x_2 happy_x_1 = case happyOut23 happy_x_1 of { happy_var_1 -> case happyOut24 happy_x_3 of { happy_var_3 -> happyIn23 (happy_var_3 : happy_var_1 )}} happyReduce_47 = happySpecReduce_1 19# happyReduction_47 happyReduction_47 happy_x_1 = case happyOut24 happy_x_1 of { happy_var_1 -> happyIn23 ([happy_var_1] )} happyReduce_48 = happySpecReduce_1 20# happyReduction_48 happyReduction_48 happy_x_1 = case happyOut103 happy_x_1 of { happy_var_1 -> happyIn24 (HsVarName happy_var_1 )} happyReduce_49 = happySpecReduce_1 20# happyReduction_49 happyReduction_49 happy_x_1 = case happyOut105 happy_x_1 of { happy_var_1 -> happyIn24 (HsConName happy_var_1 )} happyReduce_50 = happyReduce 4# 21# happyReduction_50 happyReduction_50 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut128 happy_x_1 of { happy_var_1 -> case happyOut27 happy_x_2 of { happy_var_2 -> case happyOut26 happy_x_3 of { happy_var_3 -> case happyOut28 happy_x_4 of { happy_var_4 -> happyIn25 (HsInfixDecl happy_var_1 happy_var_2 happy_var_3 (reverse happy_var_4) ) `HappyStk` happyRest}}}} happyReduce_51 = happySpecReduce_0 22# happyReduction_51 happyReduction_51 = happyIn26 (9 ) happyReduce_52 = happyMonadReduce 1# 22# happyReduction_52 happyReduction_52 (happy_x_1 `HappyStk` happyRest) tk = happyThen (case happyOutTok happy_x_1 of { (IntTok happy_var_1) -> ( checkPrec happy_var_1)} ) (\r -> happyReturn (happyIn26 r)) happyReduce_53 = happySpecReduce_1 23# happyReduction_53 happyReduction_53 happy_x_1 = happyIn27 (HsAssocNone ) happyReduce_54 = happySpecReduce_1 23# happyReduction_54 happyReduction_54 happy_x_1 = happyIn27 (HsAssocLeft ) happyReduce_55 = happySpecReduce_1 23# happyReduction_55 happyReduction_55 happy_x_1 = happyIn27 (HsAssocRight ) happyReduce_56 = happySpecReduce_3 24# happyReduction_56 happyReduction_56 happy_x_3 happy_x_2 happy_x_1 = case happyOut28 happy_x_1 of { happy_var_1 -> case happyOut112 happy_x_3 of { happy_var_3 -> happyIn28 (happy_var_3 : happy_var_1 )}} happyReduce_57 = happySpecReduce_1 24# happyReduction_57 happyReduction_57 happy_x_1 = case happyOut112 happy_x_1 of { happy_var_1 -> happyIn28 ([happy_var_1] )} happyReduce_58 = happyMonadReduce 2# 25# happyReduction_58 happyReduction_58 (happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) tk = happyThen (case happyOut30 happy_x_1 of { happy_var_1 -> ( checkRevDecls happy_var_1)} ) (\r -> happyReturn (happyIn29 r)) happyReduce_59 = happySpecReduce_3 26# happyReduction_59 happyReduction_59 happy_x_3 happy_x_2 happy_x_1 = case happyOut30 happy_x_1 of { happy_var_1 -> case happyOut31 happy_x_3 of { happy_var_3 -> happyIn30 (happy_var_3 : happy_var_1 )}} happyReduce_60 = happySpecReduce_1 26# happyReduction_60 happyReduction_60 happy_x_1 = case happyOut31 happy_x_1 of { happy_var_1 -> happyIn30 ([happy_var_1] )} happyReduce_61 = happyReduce 5# 27# happyReduction_61 happyReduction_61 (happy_x_5 `HappyStk` happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut128 happy_x_1 of { happy_var_1 -> case happyOut50 happy_x_3 of { happy_var_3 -> case happyOut43 happy_x_5 of { happy_var_5 -> happyIn31 (HsTypeDecl happy_var_1 (fst happy_var_3) (snd happy_var_3) happy_var_5 ) `HappyStk` happyRest}}} happyReduce_62 = happyMonadReduce 6# 27# happyReduction_62 happyReduction_62 (happy_x_6 `HappyStk` happy_x_5 `HappyStk` happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) tk = happyThen (case happyOut128 happy_x_1 of { happy_var_1 -> case happyOut47 happy_x_3 of { happy_var_3 -> case happyOut52 happy_x_5 of { happy_var_5 -> case happyOut61 happy_x_6 of { happy_var_6 -> ( do { (cs,c,t) <- checkDataHeader happy_var_3; return (HsDataDecl happy_var_1 cs c t (reverse happy_var_5) happy_var_6) })}}}} ) (\r -> happyReturn (happyIn31 r)) happyReduce_63 = happyMonadReduce 6# 27# happyReduction_63 happyReduction_63 (happy_x_6 `HappyStk` happy_x_5 `HappyStk` happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) tk = happyThen (case happyOut128 happy_x_1 of { happy_var_1 -> case happyOut47 happy_x_3 of { happy_var_3 -> case happyOut53 happy_x_5 of { happy_var_5 -> case happyOut61 happy_x_6 of { happy_var_6 -> ( do { (cs,c,t) <- checkDataHeader happy_var_3; return (HsNewTypeDecl happy_var_1 cs c t happy_var_5 happy_var_6) })}}}} ) (\r -> happyReturn (happyIn31 r)) happyReduce_64 = happyMonadReduce 4# 27# happyReduction_64 happyReduction_64 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) tk = happyThen (case happyOut128 happy_x_1 of { happy_var_1 -> case happyOut47 happy_x_3 of { happy_var_3 -> case happyOut63 happy_x_4 of { happy_var_4 -> ( do { (cs,c,vs) <- checkClassHeader happy_var_3; return (HsClassDecl happy_var_1 cs c vs happy_var_4) })}}} ) (\r -> happyReturn (happyIn31 r)) happyReduce_65 = happyMonadReduce 4# 27# happyReduction_65 happyReduction_65 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) tk = happyThen (case happyOut128 happy_x_1 of { happy_var_1 -> case happyOut47 happy_x_3 of { happy_var_3 -> case happyOut64 happy_x_4 of { happy_var_4 -> ( do { (cs,c,ts) <- checkInstHeader happy_var_3; return (HsInstDecl happy_var_1 cs c ts happy_var_4) })}}} ) (\r -> happyReturn (happyIn31 r)) happyReduce_66 = happyReduce 5# 27# happyReduction_66 happyReduction_66 (happy_x_5 `HappyStk` happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut128 happy_x_1 of { happy_var_1 -> case happyOut32 happy_x_4 of { happy_var_4 -> happyIn31 (HsDefaultDecl happy_var_1 happy_var_4 ) `HappyStk` happyRest}} happyReduce_67 = happySpecReduce_1 27# happyReduction_67 happyReduction_67 happy_x_1 = case happyOut39 happy_x_1 of { happy_var_1 -> happyIn31 (happy_var_1 )} happyReduce_68 = happySpecReduce_1 27# happyReduction_68 happyReduction_68 happy_x_1 = case happyOut35 happy_x_1 of { happy_var_1 -> happyIn31 (happy_var_1 )} happyReduce_69 = happySpecReduce_1 28# happyReduction_69 happyReduction_69 happy_x_1 = case happyOut49 happy_x_1 of { happy_var_1 -> happyIn32 (reverse happy_var_1 )} happyReduce_70 = happySpecReduce_1 28# happyReduction_70 happyReduction_70 happy_x_1 = case happyOut43 happy_x_1 of { happy_var_1 -> happyIn32 ([happy_var_1] )} happyReduce_71 = happySpecReduce_0 28# happyReduction_71 happyReduction_71 = happyIn32 ([] ) happyReduce_72 = happyMonadReduce 3# 29# happyReduction_72 happyReduction_72 (happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) tk = happyThen (case happyOut34 happy_x_2 of { happy_var_2 -> ( checkRevDecls happy_var_2)} ) (\r -> happyReturn (happyIn33 r)) happyReduce_73 = happySpecReduce_1 29# happyReduction_73 happyReduction_73 happy_x_1 = happyIn33 ([] ) happyReduce_74 = happySpecReduce_3 30# happyReduction_74 happyReduction_74 happy_x_3 happy_x_2 happy_x_1 = case happyOut34 happy_x_1 of { happy_var_1 -> case happyOut35 happy_x_3 of { happy_var_3 -> happyIn34 (happy_var_3 : happy_var_1 )}} happyReduce_75 = happySpecReduce_1 30# happyReduction_75 happyReduction_75 happy_x_1 = case happyOut35 happy_x_1 of { happy_var_1 -> happyIn34 ([happy_var_1] )} happyReduce_76 = happySpecReduce_1 31# happyReduction_76 happyReduction_76 happy_x_1 = case happyOut37 happy_x_1 of { happy_var_1 -> happyIn35 (happy_var_1 )} happyReduce_77 = happySpecReduce_1 31# happyReduction_77 happyReduction_77 happy_x_1 = case happyOut25 happy_x_1 of { happy_var_1 -> happyIn35 (happy_var_1 )} happyReduce_78 = happySpecReduce_1 31# happyReduction_78 happyReduction_78 happy_x_1 = case happyOut67 happy_x_1 of { happy_var_1 -> happyIn35 (happy_var_1 )} happyReduce_79 = happySpecReduce_3 32# happyReduction_79 happyReduction_79 happy_x_3 happy_x_2 happy_x_1 = case happyOut33 happy_x_2 of { happy_var_2 -> happyIn36 (happy_var_2 )} happyReduce_80 = happySpecReduce_3 32# happyReduction_80 happyReduction_80 happy_x_3 happy_x_2 happy_x_1 = case happyOut33 happy_x_2 of { happy_var_2 -> happyIn36 (happy_var_2 )} happyReduce_81 = happyReduce 4# 33# happyReduction_81 happyReduction_81 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut128 happy_x_1 of { happy_var_1 -> case happyOut38 happy_x_2 of { happy_var_2 -> case happyOut47 happy_x_4 of { happy_var_4 -> happyIn37 (HsTypeSig happy_var_1 (reverse happy_var_2) happy_var_4 ) `HappyStk` happyRest}}} happyReduce_82 = happySpecReduce_3 34# happyReduction_82 happyReduction_82 happy_x_3 happy_x_2 happy_x_1 = case happyOut38 happy_x_1 of { happy_var_1 -> case happyOut103 happy_x_3 of { happy_var_3 -> happyIn38 (happy_var_3 : happy_var_1 )}} happyReduce_83 = happyMonadReduce 1# 34# happyReduction_83 happyReduction_83 (happy_x_1 `HappyStk` happyRest) tk = happyThen (case happyOut104 happy_x_1 of { happy_var_1 -> ( do { n <- checkUnQual happy_var_1; return [n] })} ) (\r -> happyReturn (happyIn38 r)) happyReduce_84 = happyReduce 9# 35# happyReduction_84 happyReduction_84 (happy_x_9 `HappyStk` happy_x_8 `HappyStk` happy_x_7 `HappyStk` happy_x_6 `HappyStk` happy_x_5 `HappyStk` happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut128 happy_x_1 of { happy_var_1 -> case happyOutTok happy_x_4 of { (VarId happy_var_4) -> case happyOut40 happy_x_5 of { happy_var_5 -> case happyOut41 happy_x_6 of { happy_var_6 -> case happyOut42 happy_x_7 of { happy_var_7 -> case happyOut43 happy_x_9 of { happy_var_9 -> happyIn39 (HsForeignImport happy_var_1 happy_var_4 happy_var_5 happy_var_6 happy_var_7 happy_var_9 ) `HappyStk` happyRest}}}}}} happyReduce_85 = happyReduce 8# 35# happyReduction_85 happyReduction_85 (happy_x_8 `HappyStk` happy_x_7 `HappyStk` happy_x_6 `HappyStk` happy_x_5 `HappyStk` happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut128 happy_x_1 of { happy_var_1 -> case happyOutTok happy_x_4 of { (VarId happy_var_4) -> case happyOut41 happy_x_5 of { happy_var_5 -> case happyOut42 happy_x_6 of { happy_var_6 -> case happyOut43 happy_x_8 of { happy_var_8 -> happyIn39 (HsForeignExport happy_var_1 happy_var_4 happy_var_5 happy_var_6 happy_var_8 ) `HappyStk` happyRest}}}}} happyReduce_86 = happySpecReduce_1 36# happyReduction_86 happyReduction_86 happy_x_1 = happyIn40 (HsSafe ) happyReduce_87 = happySpecReduce_1 36# happyReduction_87 happyReduction_87 happy_x_1 = happyIn40 (HsUnsafe ) happyReduce_88 = happySpecReduce_0 36# happyReduction_88 happyReduction_88 = happyIn40 (HsSafe ) happyReduce_89 = happySpecReduce_1 37# happyReduction_89 happyReduction_89 happy_x_1 = case happyOutTok happy_x_1 of { (StringTok happy_var_1) -> happyIn41 (happy_var_1 )} happyReduce_90 = happySpecReduce_0 37# happyReduction_90 happyReduction_90 = happyIn41 ("" ) happyReduce_91 = happySpecReduce_1 38# happyReduction_91 happyReduction_91 happy_x_1 = case happyOutTok happy_x_1 of { (VarId happy_var_1) -> happyIn42 (HsIdent happy_var_1 )} happyReduce_92 = happySpecReduce_3 38# happyReduction_92 happyReduction_92 happy_x_3 happy_x_2 happy_x_1 = case happyOut124 happy_x_2 of { happy_var_2 -> happyIn42 (happy_var_2 )} happyReduce_93 = happySpecReduce_3 39# happyReduction_93 happyReduction_93 happy_x_3 happy_x_2 happy_x_1 = case happyOut44 happy_x_1 of { happy_var_1 -> case happyOut43 happy_x_3 of { happy_var_3 -> happyIn43 (HsTyFun happy_var_1 happy_var_3 )}} happyReduce_94 = happySpecReduce_1 39# happyReduction_94 happyReduction_94 happy_x_1 = case happyOut44 happy_x_1 of { happy_var_1 -> happyIn43 (happy_var_1 )} happyReduce_95 = happySpecReduce_2 40# happyReduction_95 happyReduction_95 happy_x_2 happy_x_1 = case happyOut44 happy_x_1 of { happy_var_1 -> case happyOut45 happy_x_2 of { happy_var_2 -> happyIn44 (HsTyApp happy_var_1 happy_var_2 )}} happyReduce_96 = happySpecReduce_1 40# happyReduction_96 happyReduction_96 happy_x_1 = case happyOut45 happy_x_1 of { happy_var_1 -> happyIn44 (happy_var_1 )} happyReduce_97 = happySpecReduce_1 41# happyReduction_97 happyReduction_97 happy_x_1 = case happyOut46 happy_x_1 of { happy_var_1 -> happyIn45 (HsTyCon happy_var_1 )} happyReduce_98 = happySpecReduce_1 41# happyReduction_98 happyReduction_98 happy_x_1 = case happyOut136 happy_x_1 of { happy_var_1 -> happyIn45 (HsTyVar happy_var_1 )} happyReduce_99 = happySpecReduce_3 41# happyReduction_99 happyReduction_99 happy_x_3 happy_x_2 happy_x_1 = case happyOut49 happy_x_2 of { happy_var_2 -> happyIn45 (HsTyTuple (reverse happy_var_2) )} happyReduce_100 = happySpecReduce_3 41# happyReduction_100 happyReduction_100 happy_x_3 happy_x_2 happy_x_1 = case happyOut43 happy_x_2 of { happy_var_2 -> happyIn45 (HsTyApp list_tycon happy_var_2 )} happyReduce_101 = happySpecReduce_3 41# happyReduction_101 happyReduction_101 happy_x_3 happy_x_2 happy_x_1 = case happyOut43 happy_x_2 of { happy_var_2 -> happyIn45 (happy_var_2 )} happyReduce_102 = happySpecReduce_1 42# happyReduction_102 happyReduction_102 happy_x_1 = case happyOut118 happy_x_1 of { happy_var_1 -> happyIn46 (happy_var_1 )} happyReduce_103 = happySpecReduce_2 42# happyReduction_103 happyReduction_103 happy_x_2 happy_x_1 = happyIn46 (unit_tycon_name ) happyReduce_104 = happySpecReduce_3 42# happyReduction_104 happyReduction_104 happy_x_3 happy_x_2 happy_x_1 = happyIn46 (fun_tycon_name ) happyReduce_105 = happySpecReduce_2 42# happyReduction_105 happyReduction_105 happy_x_2 happy_x_1 = happyIn46 (list_tycon_name ) happyReduce_106 = happySpecReduce_3 42# happyReduction_106 happyReduction_106 happy_x_3 happy_x_2 happy_x_1 = case happyOut84 happy_x_2 of { happy_var_2 -> happyIn46 (tuple_tycon_name happy_var_2 )} happyReduce_107 = happySpecReduce_3 43# happyReduction_107 happyReduction_107 happy_x_3 happy_x_2 happy_x_1 = case happyOut48 happy_x_1 of { happy_var_1 -> case happyOut43 happy_x_3 of { happy_var_3 -> happyIn47 (HsQualType happy_var_1 happy_var_3 )}} happyReduce_108 = happySpecReduce_1 43# happyReduction_108 happyReduction_108 happy_x_1 = case happyOut43 happy_x_1 of { happy_var_1 -> happyIn47 (HsQualType [] happy_var_1 )} happyReduce_109 = happyMonadReduce 1# 44# happyReduction_109 happyReduction_109 (happy_x_1 `HappyStk` happyRest) tk = happyThen (case happyOut44 happy_x_1 of { happy_var_1 -> ( checkContext happy_var_1)} ) (\r -> happyReturn (happyIn48 r)) happyReduce_110 = happySpecReduce_3 45# happyReduction_110 happyReduction_110 happy_x_3 happy_x_2 happy_x_1 = case happyOut49 happy_x_1 of { happy_var_1 -> case happyOut43 happy_x_3 of { happy_var_3 -> happyIn49 (happy_var_3 : happy_var_1 )}} happyReduce_111 = happySpecReduce_3 45# happyReduction_111 happyReduction_111 happy_x_3 happy_x_2 happy_x_1 = case happyOut43 happy_x_1 of { happy_var_1 -> case happyOut43 happy_x_3 of { happy_var_3 -> happyIn49 ([happy_var_3, happy_var_1] )}} happyReduce_112 = happySpecReduce_2 46# happyReduction_112 happyReduction_112 happy_x_2 happy_x_1 = case happyOut133 happy_x_1 of { happy_var_1 -> case happyOut51 happy_x_2 of { happy_var_2 -> happyIn50 ((happy_var_1,reverse happy_var_2) )}} happyReduce_113 = happySpecReduce_2 47# happyReduction_113 happyReduction_113 happy_x_2 happy_x_1 = case happyOut51 happy_x_1 of { happy_var_1 -> case happyOut136 happy_x_2 of { happy_var_2 -> happyIn51 (happy_var_2 : happy_var_1 )}} happyReduce_114 = happySpecReduce_0 47# happyReduction_114 happyReduction_114 = happyIn51 ([] ) happyReduce_115 = happySpecReduce_3 48# happyReduction_115 happyReduction_115 happy_x_3 happy_x_2 happy_x_1 = case happyOut52 happy_x_1 of { happy_var_1 -> case happyOut53 happy_x_3 of { happy_var_3 -> happyIn52 (happy_var_3 : happy_var_1 )}} happyReduce_116 = happySpecReduce_1 48# happyReduction_116 happyReduction_116 happy_x_1 = case happyOut53 happy_x_1 of { happy_var_1 -> happyIn52 ([happy_var_1] )} happyReduce_117 = happySpecReduce_2 49# happyReduction_117 happyReduction_117 happy_x_2 happy_x_1 = case happyOut128 happy_x_1 of { happy_var_1 -> case happyOut54 happy_x_2 of { happy_var_2 -> happyIn53 (HsConDecl happy_var_1 (fst happy_var_2) (snd happy_var_2) )}} happyReduce_118 = happyReduce 4# 49# happyReduction_118 happyReduction_118 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut128 happy_x_1 of { happy_var_1 -> case happyOut57 happy_x_2 of { happy_var_2 -> case happyOut110 happy_x_3 of { happy_var_3 -> case happyOut57 happy_x_4 of { happy_var_4 -> happyIn53 (HsConDecl happy_var_1 happy_var_3 [happy_var_2,happy_var_4] ) `HappyStk` happyRest}}}} happyReduce_119 = happyReduce 4# 49# happyReduction_119 happyReduction_119 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut128 happy_x_1 of { happy_var_1 -> case happyOut105 happy_x_2 of { happy_var_2 -> happyIn53 (HsRecDecl happy_var_1 happy_var_2 [] ) `HappyStk` happyRest}} happyReduce_120 = happyReduce 5# 49# happyReduction_120 happyReduction_120 (happy_x_5 `HappyStk` happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut128 happy_x_1 of { happy_var_1 -> case happyOut105 happy_x_2 of { happy_var_2 -> case happyOut58 happy_x_4 of { happy_var_4 -> happyIn53 (HsRecDecl happy_var_1 happy_var_2 (reverse happy_var_4) ) `HappyStk` happyRest}}} happyReduce_121 = happyMonadReduce 1# 50# happyReduction_121 happyReduction_121 (happy_x_1 `HappyStk` happyRest) tk = happyThen (case happyOut44 happy_x_1 of { happy_var_1 -> ( do { (c,ts) <- splitTyConApp happy_var_1; return (c,map HsUnBangedTy ts) })} ) (\r -> happyReturn (happyIn54 r)) happyReduce_122 = happySpecReduce_1 50# happyReduction_122 happyReduction_122 happy_x_1 = case happyOut55 happy_x_1 of { happy_var_1 -> happyIn54 (happy_var_1 )} happyReduce_123 = happyMonadReduce 3# 51# happyReduction_123 happyReduction_123 (happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) tk = happyThen (case happyOut44 happy_x_1 of { happy_var_1 -> case happyOut45 happy_x_3 of { happy_var_3 -> ( do { (c,ts) <- splitTyConApp happy_var_1; return (c,map HsUnBangedTy ts++ [HsBangedTy happy_var_3]) })}} ) (\r -> happyReturn (happyIn55 r)) happyReduce_124 = happySpecReduce_2 51# happyReduction_124 happyReduction_124 happy_x_2 happy_x_1 = case happyOut55 happy_x_1 of { happy_var_1 -> case happyOut56 happy_x_2 of { happy_var_2 -> happyIn55 ((fst happy_var_1, snd happy_var_1 ++ [happy_var_2] ) )}} happyReduce_125 = happySpecReduce_1 52# happyReduction_125 happyReduction_125 happy_x_1 = case happyOut45 happy_x_1 of { happy_var_1 -> happyIn56 (HsUnBangedTy happy_var_1 )} happyReduce_126 = happySpecReduce_2 52# happyReduction_126 happyReduction_126 happy_x_2 happy_x_1 = case happyOut45 happy_x_2 of { happy_var_2 -> happyIn56 (HsBangedTy happy_var_2 )} happyReduce_127 = happySpecReduce_1 53# happyReduction_127 happyReduction_127 happy_x_1 = case happyOut44 happy_x_1 of { happy_var_1 -> happyIn57 (HsUnBangedTy happy_var_1 )} happyReduce_128 = happySpecReduce_2 53# happyReduction_128 happyReduction_128 happy_x_2 happy_x_1 = case happyOut45 happy_x_2 of { happy_var_2 -> happyIn57 (HsBangedTy happy_var_2 )} happyReduce_129 = happySpecReduce_3 54# happyReduction_129 happyReduction_129 happy_x_3 happy_x_2 happy_x_1 = case happyOut58 happy_x_1 of { happy_var_1 -> case happyOut59 happy_x_3 of { happy_var_3 -> happyIn58 (happy_var_3 : happy_var_1 )}} happyReduce_130 = happySpecReduce_1 54# happyReduction_130 happyReduction_130 happy_x_1 = case happyOut59 happy_x_1 of { happy_var_1 -> happyIn58 ([happy_var_1] )} happyReduce_131 = happySpecReduce_3 55# happyReduction_131 happyReduction_131 happy_x_3 happy_x_2 happy_x_1 = case happyOut38 happy_x_1 of { happy_var_1 -> case happyOut60 happy_x_3 of { happy_var_3 -> happyIn59 ((reverse happy_var_1, happy_var_3) )}} happyReduce_132 = happySpecReduce_1 56# happyReduction_132 happyReduction_132 happy_x_1 = case happyOut43 happy_x_1 of { happy_var_1 -> happyIn60 (HsUnBangedTy happy_var_1 )} happyReduce_133 = happySpecReduce_2 56# happyReduction_133 happyReduction_133 happy_x_2 happy_x_1 = case happyOut45 happy_x_2 of { happy_var_2 -> happyIn60 (HsBangedTy happy_var_2 )} happyReduce_134 = happySpecReduce_0 57# happyReduction_134 happyReduction_134 = happyIn61 ([] ) happyReduce_135 = happySpecReduce_2 57# happyReduction_135 happyReduction_135 happy_x_2 happy_x_1 = case happyOut135 happy_x_2 of { happy_var_2 -> happyIn61 ([happy_var_2] )} happyReduce_136 = happySpecReduce_3 57# happyReduction_136 happyReduction_136 happy_x_3 happy_x_2 happy_x_1 = happyIn61 ([] ) happyReduce_137 = happyReduce 4# 57# happyReduction_137 happyReduction_137 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut62 happy_x_3 of { happy_var_3 -> happyIn61 (reverse happy_var_3 ) `HappyStk` happyRest} happyReduce_138 = happySpecReduce_3 58# happyReduction_138 happyReduction_138 happy_x_3 happy_x_2 happy_x_1 = case happyOut62 happy_x_1 of { happy_var_1 -> case happyOut135 happy_x_3 of { happy_var_3 -> happyIn62 (happy_var_3 : happy_var_1 )}} happyReduce_139 = happySpecReduce_1 58# happyReduction_139 happyReduction_139 happy_x_1 = case happyOut135 happy_x_1 of { happy_var_1 -> happyIn62 ([happy_var_1] )} happyReduce_140 = happyMonadReduce 2# 59# happyReduction_140 happyReduction_140 (happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) tk = happyThen (case happyOut36 happy_x_2 of { happy_var_2 -> ( checkClassBody happy_var_2)} ) (\r -> happyReturn (happyIn63 r)) happyReduce_141 = happySpecReduce_0 59# happyReduction_141 happyReduction_141 = happyIn63 ([] ) happyReduce_142 = happyMonadReduce 4# 60# happyReduction_142 happyReduction_142 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) tk = happyThen (case happyOut65 happy_x_3 of { happy_var_3 -> ( checkClassBody happy_var_3)} ) (\r -> happyReturn (happyIn64 r)) happyReduce_143 = happyMonadReduce 4# 60# happyReduction_143 happyReduction_143 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) tk = happyThen (case happyOut65 happy_x_3 of { happy_var_3 -> ( checkClassBody happy_var_3)} ) (\r -> happyReturn (happyIn64 r)) happyReduce_144 = happySpecReduce_0 60# happyReduction_144 happyReduction_144 = happyIn64 ([] ) happyReduce_145 = happyMonadReduce 3# 61# happyReduction_145 happyReduction_145 (happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) tk = happyThen (case happyOut66 happy_x_2 of { happy_var_2 -> ( checkRevDecls happy_var_2)} ) (\r -> happyReturn (happyIn65 r)) happyReduce_146 = happySpecReduce_1 61# happyReduction_146 happyReduction_146 happy_x_1 = happyIn65 ([] ) happyReduce_147 = happySpecReduce_3 62# happyReduction_147 happyReduction_147 happy_x_3 happy_x_2 happy_x_1 = case happyOut66 happy_x_1 of { happy_var_1 -> case happyOut67 happy_x_3 of { happy_var_3 -> happyIn66 (happy_var_3 : happy_var_1 )}} happyReduce_148 = happySpecReduce_1 62# happyReduction_148 happyReduction_148 happy_x_1 = case happyOut67 happy_x_1 of { happy_var_1 -> happyIn66 ([happy_var_1] )} happyReduce_149 = happyMonadReduce 4# 63# happyReduction_149 happyReduction_149 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) tk = happyThen (case happyOut128 happy_x_1 of { happy_var_1 -> case happyOut75 happy_x_2 of { happy_var_2 -> case happyOut69 happy_x_3 of { happy_var_3 -> case happyOut68 happy_x_4 of { happy_var_4 -> ( checkValDef happy_var_1 happy_var_2 happy_var_3 happy_var_4)}}}} ) (\r -> happyReturn (happyIn67 r)) happyReduce_150 = happySpecReduce_2 64# happyReduction_150 happyReduction_150 happy_x_2 happy_x_1 = case happyOut36 happy_x_2 of { happy_var_2 -> happyIn68 (happy_var_2 )} happyReduce_151 = happySpecReduce_0 64# happyReduction_151 happyReduction_151 = happyIn68 ([] ) happyReduce_152 = happyMonadReduce 2# 65# happyReduction_152 happyReduction_152 (happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) tk = happyThen (case happyOut72 happy_x_2 of { happy_var_2 -> ( do { e <- checkExpr happy_var_2; return (HsUnGuardedRhs e) })} ) (\r -> happyReturn (happyIn69 r)) happyReduce_153 = happySpecReduce_1 65# happyReduction_153 happyReduction_153 happy_x_1 = case happyOut70 happy_x_1 of { happy_var_1 -> happyIn69 (HsGuardedRhss (reverse happy_var_1) )} happyReduce_154 = happySpecReduce_2 66# happyReduction_154 happyReduction_154 happy_x_2 happy_x_1 = case happyOut70 happy_x_1 of { happy_var_1 -> case happyOut71 happy_x_2 of { happy_var_2 -> happyIn70 (happy_var_2 : happy_var_1 )}} happyReduce_155 = happySpecReduce_1 66# happyReduction_155 happyReduction_155 happy_x_1 = case happyOut71 happy_x_1 of { happy_var_1 -> happyIn70 ([happy_var_1] )} happyReduce_156 = happyMonadReduce 5# 67# happyReduction_156 happyReduction_156 (happy_x_5 `HappyStk` happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) tk = happyThen (case happyOut128 happy_x_1 of { happy_var_1 -> case happyOut73 happy_x_3 of { happy_var_3 -> case happyOut72 happy_x_5 of { happy_var_5 -> ( do { g <- checkExpr happy_var_3; e <- checkExpr happy_var_5; return (HsGuardedRhs happy_var_1 g e) })}}} ) (\r -> happyReturn (happyIn71 r)) happyReduce_157 = happyReduce 4# 68# happyReduction_157 happyReduction_157 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut75 happy_x_1 of { happy_var_1 -> case happyOut128 happy_x_3 of { happy_var_3 -> case happyOut47 happy_x_4 of { happy_var_4 -> happyIn72 (HsExpTypeSig happy_var_3 happy_var_1 happy_var_4 ) `HappyStk` happyRest}}} happyReduce_158 = happySpecReduce_1 68# happyReduction_158 happyReduction_158 happy_x_1 = case happyOut73 happy_x_1 of { happy_var_1 -> happyIn72 (happy_var_1 )} happyReduce_159 = happySpecReduce_1 69# happyReduction_159 happyReduction_159 happy_x_1 = case happyOut74 happy_x_1 of { happy_var_1 -> happyIn73 (happy_var_1 )} happyReduce_160 = happySpecReduce_1 69# happyReduction_160 happyReduction_160 happy_x_1 = case happyOut75 happy_x_1 of { happy_var_1 -> happyIn73 (happy_var_1 )} happyReduce_161 = happySpecReduce_3 70# happyReduction_161 happyReduction_161 happy_x_3 happy_x_2 happy_x_1 = case happyOut75 happy_x_1 of { happy_var_1 -> case happyOut113 happy_x_2 of { happy_var_2 -> case happyOut76 happy_x_3 of { happy_var_3 -> happyIn74 (HsInfixApp happy_var_1 happy_var_2 happy_var_3 )}}} happyReduce_162 = happySpecReduce_1 70# happyReduction_162 happyReduction_162 happy_x_1 = case happyOut76 happy_x_1 of { happy_var_1 -> happyIn74 (happy_var_1 )} happyReduce_163 = happySpecReduce_3 71# happyReduction_163 happyReduction_163 happy_x_3 happy_x_2 happy_x_1 = case happyOut75 happy_x_1 of { happy_var_1 -> case happyOut113 happy_x_2 of { happy_var_2 -> case happyOut77 happy_x_3 of { happy_var_3 -> happyIn75 (HsInfixApp happy_var_1 happy_var_2 happy_var_3 )}}} happyReduce_164 = happySpecReduce_1 71# happyReduction_164 happyReduction_164 happy_x_1 = case happyOut77 happy_x_1 of { happy_var_1 -> happyIn75 (happy_var_1 )} happyReduce_165 = happyReduce 5# 72# happyReduction_165 happyReduction_165 (happy_x_5 `HappyStk` happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut128 happy_x_2 of { happy_var_2 -> case happyOut79 happy_x_3 of { happy_var_3 -> case happyOut72 happy_x_5 of { happy_var_5 -> happyIn76 (HsLambda happy_var_2 (reverse happy_var_3) happy_var_5 ) `HappyStk` happyRest}}} happyReduce_166 = happyReduce 4# 72# happyReduction_166 happyReduction_166 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut36 happy_x_2 of { happy_var_2 -> case happyOut72 happy_x_4 of { happy_var_4 -> happyIn76 (HsLet happy_var_2 happy_var_4 ) `HappyStk` happyRest}} happyReduce_167 = happyReduce 6# 72# happyReduction_167 happyReduction_167 (happy_x_6 `HappyStk` happy_x_5 `HappyStk` happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut72 happy_x_2 of { happy_var_2 -> case happyOut72 happy_x_4 of { happy_var_4 -> case happyOut72 happy_x_6 of { happy_var_6 -> happyIn76 (HsIf happy_var_2 happy_var_4 happy_var_6 ) `HappyStk` happyRest}}} happyReduce_168 = happyReduce 4# 73# happyReduction_168 happyReduction_168 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut72 happy_x_2 of { happy_var_2 -> case happyOut90 happy_x_4 of { happy_var_4 -> happyIn77 (HsCase happy_var_2 happy_var_4 ) `HappyStk` happyRest}} happyReduce_169 = happySpecReduce_2 73# happyReduction_169 happyReduction_169 happy_x_2 happy_x_1 = case happyOut78 happy_x_2 of { happy_var_2 -> happyIn77 (HsNegApp happy_var_2 )} happyReduce_170 = happySpecReduce_2 73# happyReduction_170 happyReduction_170 happy_x_2 happy_x_1 = case happyOut98 happy_x_2 of { happy_var_2 -> happyIn77 (HsDo happy_var_2 )} happyReduce_171 = happySpecReduce_1 73# happyReduction_171 happyReduction_171 happy_x_1 = case happyOut78 happy_x_1 of { happy_var_1 -> happyIn77 (happy_var_1 )} happyReduce_172 = happySpecReduce_2 74# happyReduction_172 happyReduction_172 happy_x_2 happy_x_1 = case happyOut78 happy_x_1 of { happy_var_1 -> case happyOut81 happy_x_2 of { happy_var_2 -> happyIn78 (HsApp happy_var_1 happy_var_2 )}} happyReduce_173 = happySpecReduce_1 74# happyReduction_173 happyReduction_173 happy_x_1 = case happyOut81 happy_x_1 of { happy_var_1 -> happyIn78 (happy_var_1 )} happyReduce_174 = happySpecReduce_2 75# happyReduction_174 happyReduction_174 happy_x_2 happy_x_1 = case happyOut79 happy_x_1 of { happy_var_1 -> case happyOut80 happy_x_2 of { happy_var_2 -> happyIn79 (happy_var_2 : happy_var_1 )}} happyReduce_175 = happySpecReduce_1 75# happyReduction_175 happyReduction_175 happy_x_1 = case happyOut80 happy_x_1 of { happy_var_1 -> happyIn79 ([happy_var_1] )} happyReduce_176 = happyMonadReduce 1# 76# happyReduction_176 happyReduction_176 (happy_x_1 `HappyStk` happyRest) tk = happyThen (case happyOut81 happy_x_1 of { happy_var_1 -> ( checkPattern happy_var_1)} ) (\r -> happyReturn (happyIn80 r)) happyReduce_177 = happyMonadReduce 3# 77# happyReduction_177 happyReduction_177 (happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) tk = happyThen (case happyOut104 happy_x_1 of { happy_var_1 -> case happyOut81 happy_x_3 of { happy_var_3 -> ( do { n <- checkUnQual happy_var_1; return (HsAsPat n happy_var_3) })}} ) (\r -> happyReturn (happyIn81 r)) happyReduce_178 = happySpecReduce_2 77# happyReduction_178 happyReduction_178 happy_x_2 happy_x_1 = case happyOut81 happy_x_2 of { happy_var_2 -> happyIn81 (HsIrrPat happy_var_2 )} happyReduce_179 = happySpecReduce_1 77# happyReduction_179 happyReduction_179 happy_x_1 = case happyOut82 happy_x_1 of { happy_var_1 -> happyIn81 (happy_var_1 )} happyReduce_180 = happyMonadReduce 3# 78# happyReduction_180 happyReduction_180 (happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) tk = happyThen (case happyOut82 happy_x_1 of { happy_var_1 -> ( mkRecConstrOrUpdate happy_var_1 [])} ) (\r -> happyReturn (happyIn82 r)) happyReduce_181 = happyMonadReduce 4# 78# happyReduction_181 happyReduction_181 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) tk = happyThen (case happyOut82 happy_x_1 of { happy_var_1 -> case happyOut100 happy_x_3 of { happy_var_3 -> ( mkRecConstrOrUpdate happy_var_1 (reverse happy_var_3))}} ) (\r -> happyReturn (happyIn82 r)) happyReduce_182 = happySpecReduce_1 78# happyReduction_182 happyReduction_182 happy_x_1 = case happyOut83 happy_x_1 of { happy_var_1 -> happyIn82 (happy_var_1 )} happyReduce_183 = happySpecReduce_1 79# happyReduction_183 happyReduction_183 happy_x_1 = case happyOut104 happy_x_1 of { happy_var_1 -> happyIn83 (HsVar happy_var_1 )} happyReduce_184 = happySpecReduce_1 79# happyReduction_184 happyReduction_184 happy_x_1 = case happyOut102 happy_x_1 of { happy_var_1 -> happyIn83 (happy_var_1 )} happyReduce_185 = happySpecReduce_1 79# happyReduction_185 happyReduction_185 happy_x_1 = case happyOut127 happy_x_1 of { happy_var_1 -> happyIn83 (HsLit happy_var_1 )} happyReduce_186 = happySpecReduce_3 79# happyReduction_186 happyReduction_186 happy_x_3 happy_x_2 happy_x_1 = case happyOut72 happy_x_2 of { happy_var_2 -> happyIn83 (HsParen happy_var_2 )} happyReduce_187 = happySpecReduce_3 79# happyReduction_187 happyReduction_187 happy_x_3 happy_x_2 happy_x_1 = case happyOut85 happy_x_2 of { happy_var_2 -> happyIn83 (HsTuple (reverse happy_var_2) )} happyReduce_188 = happySpecReduce_3 79# happyReduction_188 happyReduction_188 happy_x_3 happy_x_2 happy_x_1 = case happyOut86 happy_x_2 of { happy_var_2 -> happyIn83 (happy_var_2 )} happyReduce_189 = happyReduce 4# 79# happyReduction_189 happyReduction_189 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut75 happy_x_2 of { happy_var_2 -> case happyOut113 happy_x_3 of { happy_var_3 -> happyIn83 (HsLeftSection happy_var_2 happy_var_3 ) `HappyStk` happyRest}} happyReduce_190 = happyReduce 4# 79# happyReduction_190 happyReduction_190 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut114 happy_x_2 of { happy_var_2 -> case happyOut73 happy_x_3 of { happy_var_3 -> happyIn83 (HsRightSection happy_var_2 happy_var_3 ) `HappyStk` happyRest}} happyReduce_191 = happySpecReduce_1 79# happyReduction_191 happyReduction_191 happy_x_1 = happyIn83 (HsWildCard ) happyReduce_192 = happySpecReduce_2 80# happyReduction_192 happyReduction_192 happy_x_2 happy_x_1 = case happyOut84 happy_x_1 of { happy_var_1 -> happyIn84 (happy_var_1 + 1 )} happyReduce_193 = happySpecReduce_1 80# happyReduction_193 happyReduction_193 happy_x_1 = happyIn84 (1 ) happyReduce_194 = happySpecReduce_3 81# happyReduction_194 happyReduction_194 happy_x_3 happy_x_2 happy_x_1 = case happyOut85 happy_x_1 of { happy_var_1 -> case happyOut72 happy_x_3 of { happy_var_3 -> happyIn85 (happy_var_3 : happy_var_1 )}} happyReduce_195 = happySpecReduce_3 81# happyReduction_195 happyReduction_195 happy_x_3 happy_x_2 happy_x_1 = case happyOut72 happy_x_1 of { happy_var_1 -> case happyOut72 happy_x_3 of { happy_var_3 -> happyIn85 ([happy_var_3,happy_var_1] )}} happyReduce_196 = happySpecReduce_1 82# happyReduction_196 happyReduction_196 happy_x_1 = case happyOut72 happy_x_1 of { happy_var_1 -> happyIn86 (HsList [happy_var_1] )} happyReduce_197 = happySpecReduce_1 82# happyReduction_197 happyReduction_197 happy_x_1 = case happyOut87 happy_x_1 of { happy_var_1 -> happyIn86 (HsList (reverse happy_var_1) )} happyReduce_198 = happySpecReduce_2 82# happyReduction_198 happyReduction_198 happy_x_2 happy_x_1 = case happyOut72 happy_x_1 of { happy_var_1 -> happyIn86 (HsEnumFrom happy_var_1 )} happyReduce_199 = happyReduce 4# 82# happyReduction_199 happyReduction_199 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut72 happy_x_1 of { happy_var_1 -> case happyOut72 happy_x_3 of { happy_var_3 -> happyIn86 (HsEnumFromThen happy_var_1 happy_var_3 ) `HappyStk` happyRest}} happyReduce_200 = happySpecReduce_3 82# happyReduction_200 happyReduction_200 happy_x_3 happy_x_2 happy_x_1 = case happyOut72 happy_x_1 of { happy_var_1 -> case happyOut72 happy_x_3 of { happy_var_3 -> happyIn86 (HsEnumFromTo happy_var_1 happy_var_3 )}} happyReduce_201 = happyReduce 5# 82# happyReduction_201 happyReduction_201 (happy_x_5 `HappyStk` happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut72 happy_x_1 of { happy_var_1 -> case happyOut72 happy_x_3 of { happy_var_3 -> case happyOut72 happy_x_5 of { happy_var_5 -> happyIn86 (HsEnumFromThenTo happy_var_1 happy_var_3 happy_var_5 ) `HappyStk` happyRest}}} happyReduce_202 = happySpecReduce_3 82# happyReduction_202 happyReduction_202 happy_x_3 happy_x_2 happy_x_1 = case happyOut72 happy_x_1 of { happy_var_1 -> case happyOut88 happy_x_3 of { happy_var_3 -> happyIn86 (HsListComp happy_var_1 (reverse happy_var_3) )}} happyReduce_203 = happySpecReduce_3 83# happyReduction_203 happyReduction_203 happy_x_3 happy_x_2 happy_x_1 = case happyOut87 happy_x_1 of { happy_var_1 -> case happyOut72 happy_x_3 of { happy_var_3 -> happyIn87 (happy_var_3 : happy_var_1 )}} happyReduce_204 = happySpecReduce_3 83# happyReduction_204 happyReduction_204 happy_x_3 happy_x_2 happy_x_1 = case happyOut72 happy_x_1 of { happy_var_1 -> case happyOut72 happy_x_3 of { happy_var_3 -> happyIn87 ([happy_var_3,happy_var_1] )}} happyReduce_205 = happySpecReduce_3 84# happyReduction_205 happyReduction_205 happy_x_3 happy_x_2 happy_x_1 = case happyOut88 happy_x_1 of { happy_var_1 -> case happyOut89 happy_x_3 of { happy_var_3 -> happyIn88 (happy_var_3 : happy_var_1 )}} happyReduce_206 = happySpecReduce_1 84# happyReduction_206 happyReduction_206 happy_x_1 = case happyOut89 happy_x_1 of { happy_var_1 -> happyIn88 ([happy_var_1] )} happyReduce_207 = happyReduce 4# 85# happyReduction_207 happyReduction_207 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut97 happy_x_1 of { happy_var_1 -> case happyOut128 happy_x_2 of { happy_var_2 -> case happyOut72 happy_x_4 of { happy_var_4 -> happyIn89 (HsGenerator happy_var_2 happy_var_1 happy_var_4 ) `HappyStk` happyRest}}} happyReduce_208 = happySpecReduce_1 85# happyReduction_208 happyReduction_208 happy_x_1 = case happyOut72 happy_x_1 of { happy_var_1 -> happyIn89 (HsQualifier happy_var_1 )} happyReduce_209 = happySpecReduce_2 85# happyReduction_209 happyReduction_209 happy_x_2 happy_x_1 = case happyOut36 happy_x_2 of { happy_var_2 -> happyIn89 (HsLetStmt happy_var_2 )} happyReduce_210 = happySpecReduce_3 86# happyReduction_210 happyReduction_210 happy_x_3 happy_x_2 happy_x_1 = case happyOut91 happy_x_2 of { happy_var_2 -> happyIn90 (happy_var_2 )} happyReduce_211 = happySpecReduce_3 86# happyReduction_211 happyReduction_211 happy_x_3 happy_x_2 happy_x_1 = case happyOut91 happy_x_2 of { happy_var_2 -> happyIn90 (happy_var_2 )} happyReduce_212 = happySpecReduce_3 87# happyReduction_212 happyReduction_212 happy_x_3 happy_x_2 happy_x_1 = case happyOut92 happy_x_2 of { happy_var_2 -> happyIn91 (reverse happy_var_2 )} happyReduce_213 = happySpecReduce_3 88# happyReduction_213 happyReduction_213 happy_x_3 happy_x_2 happy_x_1 = case happyOut92 happy_x_1 of { happy_var_1 -> case happyOut93 happy_x_3 of { happy_var_3 -> happyIn92 (happy_var_3 : happy_var_1 )}} happyReduce_214 = happySpecReduce_1 88# happyReduction_214 happyReduction_214 happy_x_1 = case happyOut93 happy_x_1 of { happy_var_1 -> happyIn92 ([happy_var_1] )} happyReduce_215 = happyReduce 4# 89# happyReduction_215 happyReduction_215 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut128 happy_x_1 of { happy_var_1 -> case happyOut97 happy_x_2 of { happy_var_2 -> case happyOut94 happy_x_3 of { happy_var_3 -> case happyOut68 happy_x_4 of { happy_var_4 -> happyIn93 (HsAlt happy_var_1 happy_var_2 happy_var_3 happy_var_4 ) `HappyStk` happyRest}}}} happyReduce_216 = happySpecReduce_2 90# happyReduction_216 happyReduction_216 happy_x_2 happy_x_1 = case happyOut72 happy_x_2 of { happy_var_2 -> happyIn94 (HsUnGuardedAlt happy_var_2 )} happyReduce_217 = happySpecReduce_1 90# happyReduction_217 happyReduction_217 happy_x_1 = case happyOut95 happy_x_1 of { happy_var_1 -> happyIn94 (HsGuardedAlts (reverse happy_var_1) )} happyReduce_218 = happySpecReduce_2 91# happyReduction_218 happyReduction_218 happy_x_2 happy_x_1 = case happyOut95 happy_x_1 of { happy_var_1 -> case happyOut96 happy_x_2 of { happy_var_2 -> happyIn95 (happy_var_2 : happy_var_1 )}} happyReduce_219 = happySpecReduce_1 91# happyReduction_219 happyReduction_219 happy_x_1 = case happyOut96 happy_x_1 of { happy_var_1 -> happyIn95 ([happy_var_1] )} happyReduce_220 = happyReduce 5# 92# happyReduction_220 happyReduction_220 (happy_x_5 `HappyStk` happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut128 happy_x_1 of { happy_var_1 -> case happyOut73 happy_x_3 of { happy_var_3 -> case happyOut72 happy_x_5 of { happy_var_5 -> happyIn96 (HsGuardedAlt happy_var_1 happy_var_3 happy_var_5 ) `HappyStk` happyRest}}} happyReduce_221 = happyMonadReduce 1# 93# happyReduction_221 happyReduction_221 (happy_x_1 `HappyStk` happyRest) tk = happyThen (case happyOut75 happy_x_1 of { happy_var_1 -> ( checkPattern happy_var_1)} ) (\r -> happyReturn (happyIn97 r)) happyReduce_222 = happySpecReduce_3 94# happyReduction_222 happyReduction_222 happy_x_3 happy_x_2 happy_x_1 = case happyOut99 happy_x_2 of { happy_var_2 -> happyIn98 (happy_var_2 )} happyReduce_223 = happySpecReduce_3 94# happyReduction_223 happyReduction_223 happy_x_3 happy_x_2 happy_x_1 = case happyOut99 happy_x_2 of { happy_var_2 -> happyIn98 (happy_var_2 )} happyReduce_224 = happyReduce 4# 95# happyReduction_224 happyReduction_224 (happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut36 happy_x_2 of { happy_var_2 -> case happyOut99 happy_x_4 of { happy_var_4 -> happyIn99 (HsLetStmt happy_var_2 : happy_var_4 ) `HappyStk` happyRest}} happyReduce_225 = happyReduce 6# 95# happyReduction_225 happyReduction_225 (happy_x_6 `HappyStk` happy_x_5 `HappyStk` happy_x_4 `HappyStk` happy_x_3 `HappyStk` happy_x_2 `HappyStk` happy_x_1 `HappyStk` happyRest) = case happyOut97 happy_x_1 of { happy_var_1 -> case happyOut128 happy_x_2 of { happy_var_2 -> case happyOut72 happy_x_4 of { happy_var_4 -> case happyOut99 happy_x_6 of { happy_var_6 -> happyIn99 (HsGenerator happy_var_2 happy_var_1 happy_var_4 : happy_var_6 ) `HappyStk` happyRest}}}} happyReduce_226 = happySpecReduce_3 95# happyReduction_226 happyReduction_226 happy_x_3 happy_x_2 happy_x_1 = case happyOut72 happy_x_1 of { happy_var_1 -> case happyOut99 happy_x_3 of { happy_var_3 -> happyIn99 (HsQualifier happy_var_1 : happy_var_3 )}} happyReduce_227 = happySpecReduce_2 95# happyReduction_227 happyReduction_227 happy_x_2 happy_x_1 = case happyOut99 happy_x_2 of { happy_var_2 -> happyIn99 (happy_var_2 )} happyReduce_228 = happySpecReduce_2 95# happyReduction_228 happyReduction_228 happy_x_2 happy_x_1 = case happyOut72 happy_x_1 of { happy_var_1 -> happyIn99 ([HsQualifier happy_var_1] )} happyReduce_229 = happySpecReduce_1 95# happyReduction_229 happyReduction_229 happy_x_1 = case happyOut72 happy_x_1 of { happy_var_1 -> happyIn99 ([HsQualifier happy_var_1] )} happyReduce_230 = happySpecReduce_3 96# happyReduction_230 happyReduction_230 happy_x_3 happy_x_2 happy_x_1 = case happyOut100 happy_x_1 of { happy_var_1 -> case happyOut101 happy_x_3 of { happy_var_3 -> happyIn100 (happy_var_3 : happy_var_1 )}} happyReduce_231 = happySpecReduce_1 96# happyReduction_231 happyReduction_231 happy_x_1 = case happyOut101 happy_x_1 of { happy_var_1 -> happyIn100 ([happy_var_1] )} happyReduce_232 = happySpecReduce_3 97# happyReduction_232 happyReduction_232 happy_x_3 happy_x_2 happy_x_1 = case happyOut104 happy_x_1 of { happy_var_1 -> case happyOut72 happy_x_3 of { happy_var_3 -> happyIn101 (HsFieldUpdate happy_var_1 happy_var_3 )}} happyReduce_233 = happySpecReduce_2 98# happyReduction_233 happyReduction_233 happy_x_2 happy_x_1 = happyIn102 (unit_con ) happyReduce_234 = happySpecReduce_2 98# happyReduction_234 happyReduction_234 happy_x_2 happy_x_1 = happyIn102 (HsList [] ) happyReduce_235 = happySpecReduce_3 98# happyReduction_235 happyReduction_235 happy_x_3 happy_x_2 happy_x_1 = case happyOut84 happy_x_2 of { happy_var_2 -> happyIn102 (tuple_con happy_var_2 )} happyReduce_236 = happySpecReduce_1 98# happyReduction_236 happyReduction_236 happy_x_1 = case happyOut106 happy_x_1 of { happy_var_1 -> happyIn102 (HsCon happy_var_1 )} happyReduce_237 = happySpecReduce_1 99# happyReduction_237 happyReduction_237 happy_x_1 = case happyOut117 happy_x_1 of { happy_var_1 -> happyIn103 (happy_var_1 )} happyReduce_238 = happySpecReduce_3 99# happyReduction_238 happyReduction_238 happy_x_3 happy_x_2 happy_x_1 = case happyOut124 happy_x_2 of { happy_var_2 -> happyIn103 (happy_var_2 )} happyReduce_239 = happySpecReduce_1 100# happyReduction_239 happyReduction_239 happy_x_1 = case happyOut116 happy_x_1 of { happy_var_1 -> happyIn104 (happy_var_1 )} happyReduce_240 = happySpecReduce_3 100# happyReduction_240 happyReduction_240 happy_x_3 happy_x_2 happy_x_1 = case happyOut122 happy_x_2 of { happy_var_2 -> happyIn104 (happy_var_2 )} happyReduce_241 = happySpecReduce_1 101# happyReduction_241 happyReduction_241 happy_x_1 = case happyOut119 happy_x_1 of { happy_var_1 -> happyIn105 (happy_var_1 )} happyReduce_242 = happySpecReduce_3 101# happyReduction_242 happyReduction_242 happy_x_3 happy_x_2 happy_x_1 = case happyOut121 happy_x_2 of { happy_var_2 -> happyIn105 (happy_var_2 )} happyReduce_243 = happySpecReduce_1 102# happyReduction_243 happyReduction_243 happy_x_1 = case happyOut118 happy_x_1 of { happy_var_1 -> happyIn106 (happy_var_1 )} happyReduce_244 = happySpecReduce_3 102# happyReduction_244 happyReduction_244 happy_x_3 happy_x_2 happy_x_1 = case happyOut115 happy_x_2 of { happy_var_2 -> happyIn106 (happy_var_2 )} happyReduce_245 = happySpecReduce_1 103# happyReduction_245 happyReduction_245 happy_x_1 = case happyOut124 happy_x_1 of { happy_var_1 -> happyIn107 (happy_var_1 )} happyReduce_246 = happySpecReduce_3 103# happyReduction_246 happyReduction_246 happy_x_3 happy_x_2 happy_x_1 = case happyOut117 happy_x_2 of { happy_var_2 -> happyIn107 (happy_var_2 )} happyReduce_247 = happySpecReduce_1 104# happyReduction_247 happyReduction_247 happy_x_1 = case happyOut122 happy_x_1 of { happy_var_1 -> happyIn108 (happy_var_1 )} happyReduce_248 = happySpecReduce_3 104# happyReduction_248 happyReduction_248 happy_x_3 happy_x_2 happy_x_1 = case happyOut116 happy_x_2 of { happy_var_2 -> happyIn108 (happy_var_2 )} happyReduce_249 = happySpecReduce_1 105# happyReduction_249 happyReduction_249 happy_x_1 = case happyOut123 happy_x_1 of { happy_var_1 -> happyIn109 (happy_var_1 )} happyReduce_250 = happySpecReduce_3 105# happyReduction_250 happyReduction_250 happy_x_3 happy_x_2 happy_x_1 = case happyOut116 happy_x_2 of { happy_var_2 -> happyIn109 (happy_var_2 )} happyReduce_251 = happySpecReduce_1 106# happyReduction_251 happyReduction_251 happy_x_1 = case happyOut121 happy_x_1 of { happy_var_1 -> happyIn110 (happy_var_1 )} happyReduce_252 = happySpecReduce_3 106# happyReduction_252 happyReduction_252 happy_x_3 happy_x_2 happy_x_1 = case happyOut119 happy_x_2 of { happy_var_2 -> happyIn110 (happy_var_2 )} happyReduce_253 = happySpecReduce_1 107# happyReduction_253 happyReduction_253 happy_x_1 = case happyOut115 happy_x_1 of { happy_var_1 -> happyIn111 (happy_var_1 )} happyReduce_254 = happySpecReduce_3 107# happyReduction_254 happyReduction_254 happy_x_3 happy_x_2 happy_x_1 = case happyOut118 happy_x_2 of { happy_var_2 -> happyIn111 (happy_var_2 )} happyReduce_255 = happySpecReduce_1 108# happyReduction_255 happyReduction_255 happy_x_1 = case happyOut107 happy_x_1 of { happy_var_1 -> happyIn112 (HsVarOp happy_var_1 )} happyReduce_256 = happySpecReduce_1 108# happyReduction_256 happyReduction_256 happy_x_1 = case happyOut110 happy_x_1 of { happy_var_1 -> happyIn112 (HsConOp happy_var_1 )} happyReduce_257 = happySpecReduce_1 109# happyReduction_257 happyReduction_257 happy_x_1 = case happyOut108 happy_x_1 of { happy_var_1 -> happyIn113 (HsQVarOp happy_var_1 )} happyReduce_258 = happySpecReduce_1 109# happyReduction_258 happyReduction_258 happy_x_1 = case happyOut111 happy_x_1 of { happy_var_1 -> happyIn113 (HsQConOp happy_var_1 )} happyReduce_259 = happySpecReduce_1 110# happyReduction_259 happyReduction_259 happy_x_1 = case happyOut109 happy_x_1 of { happy_var_1 -> happyIn114 (HsQVarOp happy_var_1 )} happyReduce_260 = happySpecReduce_1 110# happyReduction_260 happyReduction_260 happy_x_1 = case happyOut111 happy_x_1 of { happy_var_1 -> happyIn114 (HsQConOp happy_var_1 )} happyReduce_261 = happySpecReduce_1 111# happyReduction_261 happyReduction_261 happy_x_1 = happyIn115 (list_cons_name ) happyReduce_262 = happySpecReduce_1 111# happyReduction_262 happyReduction_262 happy_x_1 = case happyOut120 happy_x_1 of { happy_var_1 -> happyIn115 (happy_var_1 )} happyReduce_263 = happySpecReduce_1 112# happyReduction_263 happyReduction_263 happy_x_1 = case happyOut117 happy_x_1 of { happy_var_1 -> happyIn116 (UnQual happy_var_1 )} happyReduce_264 = happySpecReduce_1 112# happyReduction_264 happyReduction_264 happy_x_1 = case happyOutTok happy_x_1 of { (QVarId happy_var_1) -> happyIn116 (Qual (Module (fst happy_var_1)) (HsIdent (snd happy_var_1)) )} happyReduce_265 = happySpecReduce_1 113# happyReduction_265 happyReduction_265 happy_x_1 = case happyOutTok happy_x_1 of { (VarId happy_var_1) -> happyIn117 (HsIdent happy_var_1 )} happyReduce_266 = happySpecReduce_1 113# happyReduction_266 happyReduction_266 happy_x_1 = happyIn117 (HsIdent "as" ) happyReduce_267 = happySpecReduce_1 113# happyReduction_267 happyReduction_267 happy_x_1 = happyIn117 (HsIdent "export" ) happyReduce_268 = happySpecReduce_1 113# happyReduction_268 happyReduction_268 happy_x_1 = happyIn117 (HsIdent "hiding" ) happyReduce_269 = happySpecReduce_1 113# happyReduction_269 happyReduction_269 happy_x_1 = happyIn117 (HsIdent "qualified" ) happyReduce_270 = happySpecReduce_1 113# happyReduction_270 happyReduction_270 happy_x_1 = happyIn117 (HsIdent "safe" ) happyReduce_271 = happySpecReduce_1 113# happyReduction_271 happyReduction_271 happy_x_1 = happyIn117 (HsIdent "unsafe" ) happyReduce_272 = happySpecReduce_1 114# happyReduction_272 happyReduction_272 happy_x_1 = case happyOut119 happy_x_1 of { happy_var_1 -> happyIn118 (UnQual happy_var_1 )} happyReduce_273 = happySpecReduce_1 114# happyReduction_273 happyReduction_273 happy_x_1 = case happyOutTok happy_x_1 of { (QConId happy_var_1) -> happyIn118 (Qual (Module (fst happy_var_1)) (HsIdent (snd happy_var_1)) )} happyReduce_274 = happySpecReduce_1 115# happyReduction_274 happyReduction_274 happy_x_1 = case happyOutTok happy_x_1 of { (ConId happy_var_1) -> happyIn119 (HsIdent happy_var_1 )} happyReduce_275 = happySpecReduce_1 116# happyReduction_275 happyReduction_275 happy_x_1 = case happyOut121 happy_x_1 of { happy_var_1 -> happyIn120 (UnQual happy_var_1 )} happyReduce_276 = happySpecReduce_1 116# happyReduction_276 happyReduction_276 happy_x_1 = case happyOutTok happy_x_1 of { (QConSym happy_var_1) -> happyIn120 (Qual (Module (fst happy_var_1)) (HsSymbol (snd happy_var_1)) )} happyReduce_277 = happySpecReduce_1 117# happyReduction_277 happyReduction_277 happy_x_1 = case happyOutTok happy_x_1 of { (ConSym happy_var_1) -> happyIn121 (HsSymbol happy_var_1 )} happyReduce_278 = happySpecReduce_1 118# happyReduction_278 happyReduction_278 happy_x_1 = case happyOut124 happy_x_1 of { happy_var_1 -> happyIn122 (UnQual happy_var_1 )} happyReduce_279 = happySpecReduce_1 118# happyReduction_279 happyReduction_279 happy_x_1 = case happyOut126 happy_x_1 of { happy_var_1 -> happyIn122 (happy_var_1 )} happyReduce_280 = happySpecReduce_1 119# happyReduction_280 happyReduction_280 happy_x_1 = case happyOut125 happy_x_1 of { happy_var_1 -> happyIn123 (UnQual happy_var_1 )} happyReduce_281 = happySpecReduce_1 119# happyReduction_281 happyReduction_281 happy_x_1 = case happyOut126 happy_x_1 of { happy_var_1 -> happyIn123 (happy_var_1 )} happyReduce_282 = happySpecReduce_1 120# happyReduction_282 happyReduction_282 happy_x_1 = case happyOutTok happy_x_1 of { (VarSym happy_var_1) -> happyIn124 (HsSymbol happy_var_1 )} happyReduce_283 = happySpecReduce_1 120# happyReduction_283 happyReduction_283 happy_x_1 = happyIn124 (HsSymbol "-" ) happyReduce_284 = happySpecReduce_1 120# happyReduction_284 happyReduction_284 happy_x_1 = happyIn124 (HsSymbol "!" ) happyReduce_285 = happySpecReduce_1 121# happyReduction_285 happyReduction_285 happy_x_1 = case happyOutTok happy_x_1 of { (VarSym happy_var_1) -> happyIn125 (HsSymbol happy_var_1 )} happyReduce_286 = happySpecReduce_1 121# happyReduction_286 happyReduction_286 happy_x_1 = happyIn125 (HsSymbol "!" ) happyReduce_287 = happySpecReduce_1 122# happyReduction_287 happyReduction_287 happy_x_1 = case happyOutTok happy_x_1 of { (QVarSym happy_var_1) -> happyIn126 (Qual (Module (fst happy_var_1)) (HsSymbol (snd happy_var_1)) )} happyReduce_288 = happySpecReduce_1 123# happyReduction_288 happyReduction_288 happy_x_1 = case happyOutTok happy_x_1 of { (IntTok happy_var_1) -> happyIn127 (HsInt happy_var_1 )} happyReduce_289 = happySpecReduce_1 123# happyReduction_289 happyReduction_289 happy_x_1 = case happyOutTok happy_x_1 of { (Character happy_var_1) -> happyIn127 (HsChar happy_var_1 )} happyReduce_290 = happySpecReduce_1 123# happyReduction_290 happyReduction_290 happy_x_1 = case happyOutTok happy_x_1 of { (FloatTok happy_var_1) -> happyIn127 (HsFrac happy_var_1 )} happyReduce_291 = happySpecReduce_1 123# happyReduction_291 happyReduction_291 happy_x_1 = case happyOutTok happy_x_1 of { (StringTok happy_var_1) -> happyIn127 (HsString happy_var_1 )} happyReduce_292 = happyMonadReduce 0# 124# happyReduction_292 happyReduction_292 (happyRest) tk = happyThen (( getSrcLoc) ) (\r -> happyReturn (happyIn128 r)) happyReduce_293 = happyMonadReduce 0# 125# happyReduction_293 happyReduction_293 (happyRest) tk = happyThen (( pushCurrentContext) ) (\r -> happyReturn (happyIn129 r)) happyReduce_294 = happySpecReduce_1 126# happyReduction_294 happyReduction_294 happy_x_1 = happyIn130 (() ) happyReduce_295 = happyMonadReduce 1# 126# happyReduction_295 happyReduction_295 (happy_x_1 `HappyStk` happyRest) tk = happyThen (( popContext) ) (\r -> happyReturn (happyIn130 r)) happyReduce_296 = happySpecReduce_1 127# happyReduction_296 happyReduction_296 happy_x_1 = case happyOutTok happy_x_1 of { (ConId happy_var_1) -> happyIn131 (Module happy_var_1 )} happyReduce_297 = happySpecReduce_1 127# happyReduction_297 happyReduction_297 happy_x_1 = case happyOutTok happy_x_1 of { (QConId happy_var_1) -> happyIn131 (Module (fst happy_var_1 ++ '.':snd happy_var_1) )} happyReduce_298 = happySpecReduce_1 128# happyReduction_298 happyReduction_298 happy_x_1 = case happyOut119 happy_x_1 of { happy_var_1 -> happyIn132 (happy_var_1 )} happyReduce_299 = happySpecReduce_1 129# happyReduction_299 happyReduction_299 happy_x_1 = case happyOut119 happy_x_1 of { happy_var_1 -> happyIn133 (happy_var_1 )} happyReduce_300 = happySpecReduce_1 130# happyReduction_300 happyReduction_300 happy_x_1 = case happyOut118 happy_x_1 of { happy_var_1 -> happyIn134 (happy_var_1 )} happyReduce_301 = happySpecReduce_1 131# happyReduction_301 happyReduction_301 happy_x_1 = case happyOut118 happy_x_1 of { happy_var_1 -> happyIn135 (happy_var_1 )} happyReduce_302 = happySpecReduce_1 132# happyReduction_302 happyReduction_302 happy_x_1 = case happyOut117 happy_x_1 of { happy_var_1 -> happyIn136 (happy_var_1 )} happyNewToken action sts stk = lexer(\tk -> let cont i = happyDoAction i tk action sts stk in case tk of { EOF -> happyDoAction 65# tk action sts stk; VarId happy_dollar_dollar -> cont 1#; QVarId happy_dollar_dollar -> cont 2#; ConId happy_dollar_dollar -> cont 3#; QConId happy_dollar_dollar -> cont 4#; VarSym happy_dollar_dollar -> cont 5#; ConSym happy_dollar_dollar -> cont 6#; QVarSym happy_dollar_dollar -> cont 7#; QConSym happy_dollar_dollar -> cont 8#; IntTok happy_dollar_dollar -> cont 9#; FloatTok happy_dollar_dollar -> cont 10#; Character happy_dollar_dollar -> cont 11#; StringTok happy_dollar_dollar -> cont 12#; LeftParen -> cont 13#; RightParen -> cont 14#; SemiColon -> cont 15#; LeftCurly -> cont 16#; RightCurly -> cont 17#; VRightCurly -> cont 18#; LeftSquare -> cont 19#; RightSquare -> cont 20#; Comma -> cont 21#; Underscore -> cont 22#; BackQuote -> cont 23#; DotDot -> cont 24#; Colon -> cont 25#; DoubleColon -> cont 26#; Equals -> cont 27#; Backslash -> cont 28#; Bar -> cont 29#; LeftArrow -> cont 30#; RightArrow -> cont 31#; At -> cont 32#; Tilde -> cont 33#; DoubleArrow -> cont 34#; Minus -> cont 35#; Exclamation -> cont 36#; KW_Case -> cont 37#; KW_Class -> cont 38#; KW_Data -> cont 39#; KW_Default -> cont 40#; KW_Deriving -> cont 41#; KW_Do -> cont 42#; KW_Else -> cont 43#; KW_Foreign -> cont 44#; KW_If -> cont 45#; KW_Import -> cont 46#; KW_In -> cont 47#; KW_Infix -> cont 48#; KW_InfixL -> cont 49#; KW_InfixR -> cont 50#; KW_Instance -> cont 51#; KW_Let -> cont 52#; KW_Module -> cont 53#; KW_NewType -> cont 54#; KW_Of -> cont 55#; KW_Then -> cont 56#; KW_Type -> cont 57#; KW_Where -> cont 58#; KW_As -> cont 59#; KW_Export -> cont 60#; KW_Hiding -> cont 61#; KW_Qualified -> cont 62#; KW_Safe -> cont 63#; KW_Unsafe -> cont 64#; _ -> happyError' tk }) happyError_ 65# tk = happyError' tk happyError_ _ tk = happyError' tk happyThen :: () => P a -> (a -> P b) -> P b happyThen = (>>=) happyReturn :: () => a -> P a happyReturn = (return) happyThen1 = happyThen happyReturn1 :: () => a -> P a happyReturn1 = happyReturn happyError' :: () => (Token) -> P a happyError' tk = (\token -> happyError) tk parse = happySomeParser where happySomeParser = happyThen (happyParse 0#) (\x -> happyReturn (happyOut4 x)) happySeq = happyDontSeq happyError :: P a happyError = fail "Parse error" -- | Parse of a string, which should contain a complete Haskell 98 module. parseModule :: String -> ParseResult HsModule parseModule = runParser parse -- | Parse of a string, which should contain a complete Haskell 98 module. parseModuleWithMode :: ParseMode -> String -> ParseResult HsModule parseModuleWithMode mode = runParserWithMode mode parse {-# LINE 1 "templates/GenericTemplate.hs" #-} {-# LINE 1 "templates/GenericTemplate.hs" #-} {-# LINE 1 "" #-} {-# LINE 1 "" #-} {-# LINE 11 "" #-} # 1 "/usr/include/stdc-predef.h" 1 3 4 # 17 "/usr/include/stdc-predef.h" 3 4 {-# LINE 11 "" #-} {-# LINE 1 "/opt/ghc/7.10.1/lib/ghc-7.10.0.20150123/include/ghcversion.h" #-} {-# LINE 11 "" #-} {-# LINE 1 "templates/GenericTemplate.hs" #-} -- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp {-# LINE 13 "templates/GenericTemplate.hs" #-} -- Do not remove this comment. Required to fix CPP parsing when using GCC and a clang-compiled alex. #if __GLASGOW_HASKELL__ > 706 #define LT(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.<# m)) :: Bool) #define GTE(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.>=# m)) :: Bool) #define EQ(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.==# m)) :: Bool) #else #define LT(n,m) (n Happy_GHC_Exts.<# m) #define GTE(n,m) (n Happy_GHC_Exts.>=# m) #define EQ(n,m) (n Happy_GHC_Exts.==# m) #endif {-# LINE 46 "templates/GenericTemplate.hs" #-} data Happy_IntList = HappyCons Happy_GHC_Exts.Int# Happy_IntList {-# LINE 67 "templates/GenericTemplate.hs" #-} {-# LINE 77 "templates/GenericTemplate.hs" #-} {-# LINE 86 "templates/GenericTemplate.hs" #-} infixr 9 `HappyStk` data HappyStk a = HappyStk a (HappyStk a) ----------------------------------------------------------------------------- -- starting the parse happyParse start_state = happyNewToken start_state notHappyAtAll notHappyAtAll ----------------------------------------------------------------------------- -- Accepting the parse -- If the current token is 0#, it means we've just accepted a partial -- parse (a %partial parser). We must ignore the saved token on the top of -- the stack in this case. happyAccept 0# tk st sts (_ `HappyStk` ans `HappyStk` _) = happyReturn1 ans happyAccept j tk st sts (HappyStk ans _) = (happyTcHack j (happyTcHack st)) (happyReturn1 ans) ----------------------------------------------------------------------------- -- Arrays only: do the next action happyDoAction i tk st = {- nothing -} case action of 0# -> {- nothing -} happyFail i tk st -1# -> {- nothing -} happyAccept i tk st n | LT(n,(0# :: Happy_GHC_Exts.Int#)) -> {- nothing -} (happyReduceArr Happy_Data_Array.! rule) i tk st where rule = (Happy_GHC_Exts.I# ((Happy_GHC_Exts.negateInt# ((n Happy_GHC_Exts.+# (1# :: Happy_GHC_Exts.Int#)))))) n -> {- nothing -} happyShift new_state i tk st where new_state = (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) where off = indexShortOffAddr happyActOffsets st off_i = (off Happy_GHC_Exts.+# i) check = if GTE(off_i,(0# :: Happy_GHC_Exts.Int#)) then EQ(indexShortOffAddr happyCheck off_i, i) else False action | check = indexShortOffAddr happyTable off_i | otherwise = indexShortOffAddr happyDefActions st indexShortOffAddr (HappyA# arr) off = Happy_GHC_Exts.narrow16Int# i where i = Happy_GHC_Exts.word2Int# (Happy_GHC_Exts.or# (Happy_GHC_Exts.uncheckedShiftL# high 8#) low) high = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr (off' Happy_GHC_Exts.+# 1#))) low = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr off')) off' = off Happy_GHC_Exts.*# 2# data HappyAddr = HappyA# Happy_GHC_Exts.Addr# ----------------------------------------------------------------------------- -- HappyState data type (not arrays) {-# LINE 170 "templates/GenericTemplate.hs" #-} ----------------------------------------------------------------------------- -- Shifting a token happyShift new_state 0# tk st sts stk@(x `HappyStk` _) = let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in -- trace "shifting the error token" $ happyDoAction i tk new_state (HappyCons (st) (sts)) (stk) happyShift new_state i tk st sts stk = happyNewToken new_state (HappyCons (st) (sts)) ((happyInTok (tk))`HappyStk`stk) -- happyReduce is specialised for the common cases. happySpecReduce_0 i fn 0# tk st sts stk = happyFail 0# tk st sts stk happySpecReduce_0 nt fn j tk st@((action)) sts stk = happyGoto nt j tk st (HappyCons (st) (sts)) (fn `HappyStk` stk) happySpecReduce_1 i fn 0# tk st sts stk = happyFail 0# tk st sts stk happySpecReduce_1 nt fn j tk _ sts@((HappyCons (st@(action)) (_))) (v1`HappyStk`stk') = let r = fn v1 in happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) happySpecReduce_2 i fn 0# tk st sts stk = happyFail 0# tk st sts stk happySpecReduce_2 nt fn j tk _ (HappyCons (_) (sts@((HappyCons (st@(action)) (_))))) (v1`HappyStk`v2`HappyStk`stk') = let r = fn v1 v2 in happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) happySpecReduce_3 i fn 0# tk st sts stk = happyFail 0# tk st sts stk happySpecReduce_3 nt fn j tk _ (HappyCons (_) ((HappyCons (_) (sts@((HappyCons (st@(action)) (_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk') = let r = fn v1 v2 v3 in happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) happyReduce k i fn 0# tk st sts stk = happyFail 0# tk st sts stk happyReduce k nt fn j tk st sts stk = case happyDrop (k Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) sts of sts1@((HappyCons (st1@(action)) (_))) -> let r = fn stk in -- it doesn't hurt to always seq here... happyDoSeq r (happyGoto nt j tk st1 sts1 r) happyMonadReduce k nt fn 0# tk st sts stk = happyFail 0# tk st sts stk happyMonadReduce k nt fn j tk st sts stk = case happyDrop k (HappyCons (st) (sts)) of sts1@((HappyCons (st1@(action)) (_))) -> let drop_stk = happyDropStk k stk in happyThen1 (fn stk tk) (\r -> happyGoto nt j tk st1 sts1 (r `HappyStk` drop_stk)) happyMonad2Reduce k nt fn 0# tk st sts stk = happyFail 0# tk st sts stk happyMonad2Reduce k nt fn j tk st sts stk = case happyDrop k (HappyCons (st) (sts)) of sts1@((HappyCons (st1@(action)) (_))) -> let drop_stk = happyDropStk k stk off = indexShortOffAddr happyGotoOffsets st1 off_i = (off Happy_GHC_Exts.+# nt) new_state = indexShortOffAddr happyTable off_i in happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk)) happyDrop 0# l = l happyDrop n (HappyCons (_) (t)) = happyDrop (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) t happyDropStk 0# l = l happyDropStk n (x `HappyStk` xs) = happyDropStk (n Happy_GHC_Exts.-# (1#::Happy_GHC_Exts.Int#)) xs ----------------------------------------------------------------------------- -- Moving to a new state after a reduction happyGoto nt j tk st = {- nothing -} happyDoAction j tk new_state where off = indexShortOffAddr happyGotoOffsets st off_i = (off Happy_GHC_Exts.+# nt) new_state = indexShortOffAddr happyTable off_i ----------------------------------------------------------------------------- -- Error recovery (0# is the error token) -- parse error if we are in recovery and we fail again happyFail 0# tk old_st _ stk@(x `HappyStk` _) = let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in -- trace "failing" $ happyError_ i tk {- We don't need state discarding for our restricted implementation of "error". In fact, it can cause some bogus parses, so I've disabled it for now --SDM -- discard a state happyFail 0# tk old_st (HappyCons ((action)) (sts)) (saved_tok `HappyStk` _ `HappyStk` stk) = -- trace ("discarding state, depth " ++ show (length stk)) $ happyDoAction 0# tk action sts ((saved_tok`HappyStk`stk)) -} -- Enter error recovery: generate an error token, -- save the old token and carry on. happyFail i tk (action) sts stk = -- trace "entering error recovery" $ happyDoAction 0# tk action sts ( (Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# (i))) `HappyStk` stk) -- Internal happy errors: notHappyAtAll :: a notHappyAtAll = error "Internal Happy error\n" ----------------------------------------------------------------------------- -- Hack to get the typechecker to accept our action functions happyTcHack :: Happy_GHC_Exts.Int# -> a -> a happyTcHack x y = y {-# INLINE happyTcHack #-} ----------------------------------------------------------------------------- -- Seq-ing. If the --strict flag is given, then Happy emits -- happySeq = happyDoSeq -- otherwise it emits -- happySeq = happyDontSeq happyDoSeq, happyDontSeq :: a -> b -> b happyDoSeq a b = a `seq` b happyDontSeq a b = b ----------------------------------------------------------------------------- -- Don't inline any functions from the template. GHC has a nasty habit -- of deciding to inline happyGoto everywhere, which increases the size of -- the generated parser quite a bit. {-# NOINLINE happyDoAction #-} {-# NOINLINE happyTable #-} {-# NOINLINE happyCheck #-} {-# NOINLINE happyActOffsets #-} {-# NOINLINE happyGotoOffsets #-} {-# NOINLINE happyDefActions #-} {-# NOINLINE happyShift #-} {-# NOINLINE happySpecReduce_0 #-} {-# NOINLINE happySpecReduce_1 #-} {-# NOINLINE happySpecReduce_2 #-} {-# NOINLINE happySpecReduce_3 #-} {-# NOINLINE happyReduce #-} {-# NOINLINE happyMonadReduce #-} {-# NOINLINE happyGoto #-} {-# NOINLINE happyFail #-} -- end of Happy Template. haskell-src-1.0.2.0/Language/0000755000000000000000000000000012461020017013762 5ustar0000000000000000haskell-src-1.0.2.0/Language/Haskell/0000755000000000000000000000000012461020017015345 5ustar0000000000000000haskell-src-1.0.2.0/Language/Haskell/Pretty.hs0000644000000000000000000007077212461020017017205 0ustar0000000000000000{-# OPTIONS_GHC -w #-} ----------------------------------------------------------------------------- -- | -- Module : Language.Haskell.Pretty -- Copyright : (c) The GHC Team, Noel Winstanley 1997-2000 -- License : BSD-style (see the file libraries/base/LICENSE) -- -- Maintainer : libraries@haskell.org -- Stability : experimental -- Portability : portable -- -- Pretty printer for Haskell. -- ----------------------------------------------------------------------------- module Language.Haskell.Pretty ( -- * Pretty printing Pretty, prettyPrintStyleMode, prettyPrintWithMode, prettyPrint, -- * Pretty-printing styles (from "Text.PrettyPrint.HughesPJ") P.Style(..), P.style, P.Mode(..), -- * Haskell formatting modes PPHsMode(..), Indent, PPLayout(..), defaultMode) where import Language.Haskell.Syntax import Control.Applicative (Applicative(..)) import Control.Monad (ap) import qualified Text.PrettyPrint as P infixl 5 $$$ ----------------------------------------------------------------------------- -- | Varieties of layout we can use. data PPLayout = PPOffsideRule -- ^ classical layout | PPSemiColon -- ^ classical layout made explicit | PPInLine -- ^ inline decls, with newlines between them | PPNoLayout -- ^ everything on a single line deriving Eq type Indent = Int -- | Pretty-printing parameters. -- -- /Note:/ the 'onsideIndent' must be positive and less than all other indents. data PPHsMode = PPHsMode { -- | indentation of a class or instance classIndent :: Indent, -- | indentation of a @do@-expression doIndent :: Indent, -- | indentation of the body of a -- @case@ expression caseIndent :: Indent, -- | indentation of the declarations in a -- @let@ expression letIndent :: Indent, -- | indentation of the declarations in a -- @where@ clause whereIndent :: Indent, -- | indentation added for continuation -- lines that would otherwise be offside onsideIndent :: Indent, -- | blank lines between statements? spacing :: Bool, -- | Pretty-printing style to use layout :: PPLayout, -- | add GHC-style @LINE@ pragmas to output? linePragmas :: Bool, -- | not implemented yet comments :: Bool } -- | The default mode: pretty-print using the offside rule and sensible -- defaults. defaultMode :: PPHsMode defaultMode = PPHsMode{ classIndent = 8, doIndent = 3, caseIndent = 4, letIndent = 4, whereIndent = 6, onsideIndent = 2, spacing = True, layout = PPOffsideRule, linePragmas = False, comments = True } -- | Pretty printing monad newtype DocM s a = DocM (s -> a) instance Functor (DocM s) where fmap f xs = do x <- xs; return (f x) instance Applicative (DocM s) where pure = return (<*>) = ap instance Monad (DocM s) where (>>=) = thenDocM (>>) = then_DocM return = retDocM {-# INLINE thenDocM #-} {-# INLINE then_DocM #-} {-# INLINE retDocM #-} {-# INLINE unDocM #-} {-# INLINE getPPEnv #-} thenDocM :: DocM s a -> (a -> DocM s b) -> DocM s b thenDocM m k = DocM $ (\s -> case unDocM m $ s of a -> unDocM (k a) $ s) then_DocM :: DocM s a -> DocM s b -> DocM s b then_DocM m k = DocM $ (\s -> case unDocM m $ s of _ -> unDocM k $ s) retDocM :: a -> DocM s a retDocM a = DocM (\_s -> a) unDocM :: DocM s a -> (s -> a) unDocM (DocM f) = f -- all this extra stuff, just for this one function. getPPEnv :: DocM s s getPPEnv = DocM id -- So that pp code still looks the same -- this means we lose some generality though -- | The document type produced by these pretty printers uses a 'PPHsMode' -- environment. type Doc = DocM PPHsMode P.Doc -- | Things that can be pretty-printed, including all the syntactic objects -- in "Language.Haskell.Syntax". class Pretty a where -- | Pretty-print something in isolation. pretty :: a -> Doc -- | Pretty-print something in a precedence context. prettyPrec :: Int -> a -> Doc pretty = prettyPrec 0 prettyPrec _ = pretty -- The pretty printing combinators empty :: Doc empty = return P.empty nest :: Int -> Doc -> Doc nest i m = m >>= return . P.nest i -- Literals text, ptext :: String -> Doc text = return . P.text ptext = return . P.text char :: Char -> Doc char = return . P.char int :: Int -> Doc int = return . P.int integer :: Integer -> Doc integer = return . P.integer float :: Float -> Doc float = return . P.float double :: Double -> Doc double = return . P.double rational :: Rational -> Doc rational = return . P.rational -- Simple Combining Forms parens, brackets, braces,quotes,doubleQuotes :: Doc -> Doc parens d = d >>= return . P.parens brackets d = d >>= return . P.brackets braces d = d >>= return . P.braces quotes d = d >>= return . P.quotes doubleQuotes d = d >>= return . P.doubleQuotes parensIf :: Bool -> Doc -> Doc parensIf True = parens parensIf False = id -- Constants semi,comma,colon,space,equals :: Doc semi = return P.semi comma = return P.comma colon = return P.colon space = return P.space equals = return P.equals lparen,rparen,lbrack,rbrack,lbrace,rbrace :: Doc lparen = return P.lparen rparen = return P.rparen lbrack = return P.lbrack rbrack = return P.rbrack lbrace = return P.lbrace rbrace = return P.rbrace -- Combinators (<>),(<+>),($$),($+$) :: Doc -> Doc -> Doc aM <> bM = do{a<-aM;b<-bM;return (a P.<> b)} aM <+> bM = do{a<-aM;b<-bM;return (a P.<+> b)} aM $$ bM = do{a<-aM;b<-bM;return (a P.$$ b)} aM $+$ bM = do{a<-aM;b<-bM;return (a P.$+$ b)} hcat,hsep,vcat,sep,cat,fsep,fcat :: [Doc] -> Doc hcat dl = sequence dl >>= return . P.hcat hsep dl = sequence dl >>= return . P.hsep vcat dl = sequence dl >>= return . P.vcat sep dl = sequence dl >>= return . P.sep cat dl = sequence dl >>= return . P.cat fsep dl = sequence dl >>= return . P.fsep fcat dl = sequence dl >>= return . P.fcat -- Some More hang :: Doc -> Int -> Doc -> Doc hang dM i rM = do{d<-dM;r<-rM;return $ P.hang d i r} -- Yuk, had to cut-n-paste this one from Pretty.hs punctuate :: Doc -> [Doc] -> [Doc] punctuate _ [] = [] punctuate p (d1:ds) = go d1 ds where go d [] = [d] go d (e:es) = (d <> p) : go e es -- | render the document with a given style and mode. renderStyleMode :: P.Style -> PPHsMode -> Doc -> String renderStyleMode ppStyle ppMode d = P.renderStyle ppStyle . unDocM d $ ppMode -- | render the document with a given mode. renderWithMode :: PPHsMode -> Doc -> String renderWithMode = renderStyleMode P.style -- | render the document with 'defaultMode'. render :: Doc -> String render = renderWithMode defaultMode -- | pretty-print with a given style and mode. prettyPrintStyleMode :: Pretty a => P.Style -> PPHsMode -> a -> String prettyPrintStyleMode ppStyle ppMode = renderStyleMode ppStyle ppMode . pretty -- | pretty-print with the default style and a given mode. prettyPrintWithMode :: Pretty a => PPHsMode -> a -> String prettyPrintWithMode = prettyPrintStyleMode P.style -- | pretty-print with the default style and 'defaultMode'. prettyPrint :: Pretty a => a -> String prettyPrint = prettyPrintWithMode defaultMode fullRenderWithMode :: PPHsMode -> P.Mode -> Int -> Float -> (P.TextDetails -> a -> a) -> a -> Doc -> a fullRenderWithMode ppMode m i f fn e mD = P.fullRender m i f fn e $ (unDocM mD) ppMode fullRender :: P.Mode -> Int -> Float -> (P.TextDetails -> a -> a) -> a -> Doc -> a fullRender = fullRenderWithMode defaultMode ------------------------- Pretty-Print a Module -------------------- instance Pretty HsModule where pretty (HsModule pos m mbExports imp decls) = markLine pos $ topLevel (ppHsModuleHeader m mbExports) (map pretty imp ++ map pretty decls) -------------------------- Module Header ------------------------------ ppHsModuleHeader :: Module -> Maybe [HsExportSpec] -> Doc ppHsModuleHeader m mbExportList = mySep [ text "module", pretty m, maybePP (parenList . map pretty) mbExportList, text "where"] instance Pretty Module where pretty (Module modName) = text modName instance Pretty HsExportSpec where pretty (HsEVar name) = pretty name pretty (HsEAbs name) = pretty name pretty (HsEThingAll name) = pretty name <> text "(..)" pretty (HsEThingWith name nameList) = pretty name <> (parenList . map pretty $ nameList) pretty (HsEModuleContents m) = text "module" <+> pretty m instance Pretty HsImportDecl where pretty (HsImportDecl pos m qual mbName mbSpecs) = markLine pos $ mySep [text "import", if qual then text "qualified" else empty, pretty m, maybePP (\m' -> text "as" <+> pretty m') mbName, maybePP exports mbSpecs] where exports (b,specList) = if b then text "hiding" <+> specs else specs where specs = parenList . map pretty $ specList instance Pretty HsImportSpec where pretty (HsIVar name) = pretty name pretty (HsIAbs name) = pretty name pretty (HsIThingAll name) = pretty name <> text "(..)" pretty (HsIThingWith name nameList) = pretty name <> (parenList . map pretty $ nameList) ------------------------- Declarations ------------------------------ instance Pretty HsDecl where pretty (HsTypeDecl loc name nameList htype) = blankline $ markLine loc $ mySep ( [text "type", pretty name] ++ map pretty nameList ++ [equals, pretty htype]) pretty (HsDataDecl loc context name nameList constrList derives) = blankline $ markLine loc $ mySep ( [text "data", ppHsContext context, pretty name] ++ map pretty nameList) <+> (myVcat (zipWith (<+>) (equals : repeat (char '|')) (map pretty constrList)) $$$ ppHsDeriving derives) pretty (HsNewTypeDecl pos context name nameList constr derives) = blankline $ markLine pos $ mySep ( [text "newtype", ppHsContext context, pretty name] ++ map pretty nameList) <+> equals <+> (pretty constr $$$ ppHsDeriving derives) --m{spacing=False} -- special case for empty class declaration pretty (HsClassDecl pos context name nameList []) = blankline $ markLine pos $ mySep ( [text "class", ppHsContext context, pretty name] ++ map pretty nameList) pretty (HsClassDecl pos context name nameList declList) = blankline $ markLine pos $ mySep ( [text "class", ppHsContext context, pretty name] ++ map pretty nameList ++ [text "where"]) $$$ ppBody classIndent (map pretty declList) -- m{spacing=False} -- special case for empty instance declaration pretty (HsInstDecl pos context name args []) = blankline $ markLine pos $ mySep ( [text "instance", ppHsContext context, pretty name] ++ map ppHsAType args) pretty (HsInstDecl pos context name args declList) = blankline $ markLine pos $ mySep ( [text "instance", ppHsContext context, pretty name] ++ map ppHsAType args ++ [text "where"]) $$$ ppBody classIndent (map pretty declList) pretty (HsDefaultDecl pos htypes) = blankline $ markLine pos $ text "default" <+> parenList (map pretty htypes) pretty (HsTypeSig pos nameList qualType) = blankline $ markLine pos $ mySep ((punctuate comma . map pretty $ nameList) ++ [text "::", pretty qualType]) pretty (HsForeignImport pos conv safety entity name ty) = blankline $ markLine pos $ mySep $ [text "foreign", text "import", text conv, pretty safety] ++ (if null entity then [] else [text (show entity)]) ++ [pretty name, text "::", pretty ty] pretty (HsForeignExport pos conv entity name ty) = blankline $ markLine pos $ mySep $ [text "foreign", text "export", text conv] ++ (if null entity then [] else [text (show entity)]) ++ [pretty name, text "::", pretty ty] pretty (HsFunBind matches) = ppBindings (map pretty matches) pretty (HsPatBind pos pat rhs whereDecls) = markLine pos $ myFsep [pretty pat, pretty rhs] $$$ ppWhere whereDecls pretty (HsInfixDecl pos assoc prec opList) = blankline $ markLine pos $ mySep ([pretty assoc, int prec] ++ (punctuate comma . map pretty $ opList)) instance Pretty HsAssoc where pretty HsAssocNone = text "infix" pretty HsAssocLeft = text "infixl" pretty HsAssocRight = text "infixr" instance Pretty HsSafety where pretty HsSafe = text "safe" pretty HsUnsafe = text "unsafe" instance Pretty HsMatch where pretty (HsMatch pos f ps rhs whereDecls) = markLine pos $ myFsep (lhs ++ [pretty rhs]) $$$ ppWhere whereDecls where lhs = case ps of l:r:ps' | isSymbolName f -> let hd = [pretty l, ppHsName f, pretty r] in if null ps' then hd else parens (myFsep hd) : map (prettyPrec 2) ps' _ -> pretty f : map (prettyPrec 2) ps ppWhere :: [HsDecl] -> Doc ppWhere [] = empty ppWhere l = nest 2 (text "where" $$$ ppBody whereIndent (map pretty l)) ------------------------- Data & Newtype Bodies ------------------------- instance Pretty HsConDecl where pretty (HsRecDecl _pos name fieldList) = pretty name <> (braceList . map ppField $ fieldList) pretty (HsConDecl _pos name@(HsSymbol _) [l, r]) = myFsep [prettyPrec prec_btype l, ppHsName name, prettyPrec prec_btype r] pretty (HsConDecl _pos name typeList) = mySep $ ppHsName name : map (prettyPrec prec_atype) typeList ppField :: ([HsName],HsBangType) -> Doc ppField (names, ty) = myFsepSimple $ (punctuate comma . map pretty $ names) ++ [text "::", pretty ty] instance Pretty HsBangType where prettyPrec _ (HsBangedTy ty) = char '!' <> ppHsAType ty prettyPrec p (HsUnBangedTy ty) = prettyPrec p ty ppHsDeriving :: [HsQName] -> Doc ppHsDeriving [] = empty ppHsDeriving [d] = text "deriving" <+> ppHsQName d ppHsDeriving ds = text "deriving" <+> parenList (map ppHsQName ds) ------------------------- Types ------------------------- instance Pretty HsQualType where pretty (HsQualType context htype) = myFsep [ppHsContext context, pretty htype] ppHsBType :: HsType -> Doc ppHsBType = prettyPrec prec_btype ppHsAType :: HsType -> Doc ppHsAType = prettyPrec prec_atype -- precedences for types prec_btype, prec_atype :: Int prec_btype = 1 -- left argument of ->, -- or either argument of an infix data constructor prec_atype = 2 -- argument of type or data constructor, or of a class instance Pretty HsType where prettyPrec p (HsTyFun a b) = parensIf (p > 0) $ myFsep [ppHsBType a, text "->", pretty b] prettyPrec _ (HsTyTuple l) = parenList . map pretty $ l prettyPrec p (HsTyApp a b) | a == list_tycon = brackets $ pretty b -- special case | otherwise = parensIf (p > prec_btype) $ myFsep [pretty a, ppHsAType b] prettyPrec _ (HsTyVar name) = pretty name prettyPrec _ (HsTyCon name) = pretty name ------------------------- Expressions ------------------------- instance Pretty HsRhs where pretty (HsUnGuardedRhs e) = equals <+> pretty e pretty (HsGuardedRhss guardList) = myVcat . map pretty $ guardList instance Pretty HsGuardedRhs where pretty (HsGuardedRhs _pos guard body) = myFsep [char '|', pretty guard, equals, pretty body] instance Pretty HsLiteral where pretty (HsInt i) = integer i pretty (HsChar c) = text (show c) pretty (HsString s) = text (show s) pretty (HsFrac r) = double (fromRational r) -- GHC unboxed literals: pretty (HsCharPrim c) = text (show c) <> char '#' pretty (HsStringPrim s) = text (show s) <> char '#' pretty (HsIntPrim i) = integer i <> char '#' pretty (HsFloatPrim r) = float (fromRational r) <> char '#' pretty (HsDoublePrim r) = double (fromRational r) <> text "##" instance Pretty HsExp where pretty (HsLit l) = pretty l -- lambda stuff pretty (HsInfixApp a op b) = myFsep [pretty a, pretty op, pretty b] pretty (HsNegApp e) = myFsep [char '-', pretty e] pretty (HsApp a b) = myFsep [pretty a, pretty b] pretty (HsLambda _loc expList body) = myFsep $ char '\\' : map pretty expList ++ [text "->", pretty body] -- keywords pretty (HsLet expList letBody) = myFsep [text "let" <+> ppBody letIndent (map pretty expList), text "in", pretty letBody] pretty (HsIf cond thenexp elsexp) = myFsep [text "if", pretty cond, text "then", pretty thenexp, text "else", pretty elsexp] pretty (HsCase cond altList) = myFsep [text "case", pretty cond, text "of"] $$$ ppBody caseIndent (map pretty altList) pretty (HsDo stmtList) = text "do" $$$ ppBody doIndent (map pretty stmtList) -- Constructors & Vars pretty (HsVar name) = pretty name pretty (HsCon name) = pretty name pretty (HsTuple expList) = parenList . map pretty $ expList -- weird stuff pretty (HsParen e) = parens . pretty $ e pretty (HsLeftSection e op) = parens (pretty e <+> pretty op) pretty (HsRightSection op e) = parens (pretty op <+> pretty e) pretty (HsRecConstr c fieldList) = pretty c <> (braceList . map pretty $ fieldList) pretty (HsRecUpdate e fieldList) = pretty e <> (braceList . map pretty $ fieldList) -- patterns -- special case that would otherwise be buggy pretty (HsAsPat name (HsIrrPat e)) = myFsep [pretty name <> char '@', char '~' <> pretty e] pretty (HsAsPat name e) = hcat [pretty name, char '@', pretty e] pretty HsWildCard = char '_' pretty (HsIrrPat e) = char '~' <> pretty e -- Lists pretty (HsList list) = bracketList . punctuate comma . map pretty $ list pretty (HsEnumFrom e) = bracketList [pretty e, text ".."] pretty (HsEnumFromTo from to) = bracketList [pretty from, text "..", pretty to] pretty (HsEnumFromThen from thenE) = bracketList [pretty from <> comma, pretty thenE, text ".."] pretty (HsEnumFromThenTo from thenE to) = bracketList [pretty from <> comma, pretty thenE, text "..", pretty to] pretty (HsListComp e stmtList) = bracketList ([pretty e, char '|'] ++ (punctuate comma . map pretty $ stmtList)) pretty (HsExpTypeSig _pos e ty) = myFsep [pretty e, text "::", pretty ty] ------------------------- Patterns ----------------------------- instance Pretty HsPat where prettyPrec _ (HsPVar name) = pretty name prettyPrec _ (HsPLit lit) = pretty lit prettyPrec _ (HsPNeg p) = myFsep [char '-', pretty p] prettyPrec p (HsPInfixApp a op b) = parensIf (p > 0) $ myFsep [pretty a, pretty (HsQConOp op), pretty b] prettyPrec p (HsPApp n ps) = parensIf (p > 1) $ myFsep (pretty n : map pretty ps) prettyPrec _ (HsPTuple ps) = parenList . map pretty $ ps prettyPrec _ (HsPList ps) = bracketList . punctuate comma . map pretty $ ps prettyPrec _ (HsPParen p) = parens . pretty $ p prettyPrec _ (HsPRec c fields) = pretty c <> (braceList . map pretty $ fields) -- special case that would otherwise be buggy prettyPrec _ (HsPAsPat name (HsPIrrPat pat)) = myFsep [pretty name <> char '@', char '~' <> pretty pat] prettyPrec _ (HsPAsPat name pat) = hcat [pretty name, char '@', pretty pat] prettyPrec _ HsPWildCard = char '_' prettyPrec _ (HsPIrrPat pat) = char '~' <> pretty pat instance Pretty HsPatField where pretty (HsPFieldPat name pat) = myFsep [pretty name, equals, pretty pat] ------------------------- Case bodies ------------------------- instance Pretty HsAlt where pretty (HsAlt _pos e gAlts decls) = myFsep [pretty e, pretty gAlts] $$$ ppWhere decls instance Pretty HsGuardedAlts where pretty (HsUnGuardedAlt e) = text "->" <+> pretty e pretty (HsGuardedAlts altList) = myVcat . map pretty $ altList instance Pretty HsGuardedAlt where pretty (HsGuardedAlt _pos e body) = myFsep [char '|', pretty e, text "->", pretty body] ------------------------- Statements in monads & list comprehensions ----- instance Pretty HsStmt where pretty (HsGenerator _loc e from) = pretty e <+> text "<-" <+> pretty from pretty (HsQualifier e) = pretty e pretty (HsLetStmt declList) = text "let" $$$ ppBody letIndent (map pretty declList) ------------------------- Record updates instance Pretty HsFieldUpdate where pretty (HsFieldUpdate name e) = myFsep [pretty name, equals, pretty e] ------------------------- Names ------------------------- instance Pretty HsQOp where pretty (HsQVarOp n) = ppHsQNameInfix n pretty (HsQConOp n) = ppHsQNameInfix n ppHsQNameInfix :: HsQName -> Doc ppHsQNameInfix name | isSymbolName (getName name) = ppHsQName name | otherwise = char '`' <> ppHsQName name <> char '`' instance Pretty HsQName where pretty name = parensIf (isSymbolName (getName name)) (ppHsQName name) ppHsQName :: HsQName -> Doc ppHsQName (UnQual name) = ppHsName name ppHsQName (Qual m name) = pretty m <> char '.' <> ppHsName name ppHsQName (Special sym) = text (specialName sym) instance Pretty HsOp where pretty (HsVarOp n) = ppHsNameInfix n pretty (HsConOp n) = ppHsNameInfix n ppHsNameInfix :: HsName -> Doc ppHsNameInfix name | isSymbolName name = ppHsName name | otherwise = char '`' <> ppHsName name <> char '`' instance Pretty HsName where pretty name = parensIf (isSymbolName name) (ppHsName name) ppHsName :: HsName -> Doc ppHsName (HsIdent s) = text s ppHsName (HsSymbol s) = text s instance Pretty HsCName where pretty (HsVarName n) = pretty n pretty (HsConName n) = pretty n isSymbolName :: HsName -> Bool isSymbolName (HsSymbol _) = True isSymbolName _ = False getName :: HsQName -> HsName getName (UnQual s) = s getName (Qual _ s) = s getName (Special HsCons) = HsSymbol ":" getName (Special HsFunCon) = HsSymbol "->" getName (Special s) = HsIdent (specialName s) specialName :: HsSpecialCon -> String specialName HsUnitCon = "()" specialName HsListCon = "[]" specialName HsFunCon = "->" specialName (HsTupleCon n) = "(" ++ replicate (n-1) ',' ++ ")" specialName HsCons = ":" ppHsContext :: HsContext -> Doc ppHsContext [] = empty ppHsContext context = mySep [parenList (map ppHsAsst context), text "=>"] -- hacked for multi-parameter type classes ppHsAsst :: HsAsst -> Doc ppHsAsst (a,ts) = myFsep (ppHsQName a : map ppHsAType ts) ------------------------- pp utils ------------------------- maybePP :: (a -> Doc) -> Maybe a -> Doc maybePP _ Nothing = empty maybePP pp (Just a) = pp a parenList :: [Doc] -> Doc parenList = parens . myFsepSimple . punctuate comma braceList :: [Doc] -> Doc braceList = braces . myFsepSimple . punctuate comma bracketList :: [Doc] -> Doc bracketList = brackets . myFsepSimple -- Wrap in braces and semicolons, with an extra space at the start in -- case the first doc begins with "-", which would be scanned as {- flatBlock :: [Doc] -> Doc flatBlock = braces . (space <>) . hsep . punctuate semi -- Same, but put each thing on a separate line prettyBlock :: [Doc] -> Doc prettyBlock = braces . (space <>) . vcat . punctuate semi -- Monadic PP Combinators -- these examine the env blankline :: Doc -> Doc blankline dl = do{e<-getPPEnv;if spacing e && layout e /= PPNoLayout then space $$ dl else dl} topLevel :: Doc -> [Doc] -> Doc topLevel header dl = do e <- fmap layout getPPEnv case e of PPOffsideRule -> header $$ vcat dl PPSemiColon -> header $$ prettyBlock dl PPInLine -> header $$ prettyBlock dl PPNoLayout -> header <+> flatBlock dl ppBody :: (PPHsMode -> Int) -> [Doc] -> Doc ppBody f dl = do e <- fmap layout getPPEnv i <- fmap f getPPEnv case e of PPOffsideRule -> nest i . vcat $ dl PPSemiColon -> nest i . prettyBlock $ dl _ -> flatBlock dl ppBindings :: [Doc] -> Doc ppBindings dl = do e <- fmap layout getPPEnv case e of PPOffsideRule -> vcat dl PPSemiColon -> vcat . punctuate semi $ dl _ -> hsep . punctuate semi $ dl ($$$) :: Doc -> Doc -> Doc a $$$ b = layoutChoice (a $$) (a <+>) b mySep :: [Doc] -> Doc mySep = layoutChoice mySep' hsep where -- ensure paragraph fills with indentation. mySep' [x] = x mySep' (x:xs) = x <+> fsep xs mySep' [] = error "Internal error: mySep" myVcat :: [Doc] -> Doc myVcat = layoutChoice vcat hsep myFsepSimple :: [Doc] -> Doc myFsepSimple = layoutChoice fsep hsep -- same, except that continuation lines are indented, -- which is necessary to avoid triggering the offside rule. myFsep :: [Doc] -> Doc myFsep = layoutChoice fsep' hsep where fsep' [] = empty fsep' (d:ds) = do e <- getPPEnv let n = onsideIndent e nest n (fsep (nest (-n) d:ds)) layoutChoice :: (a -> Doc) -> (a -> Doc) -> a -> Doc layoutChoice a b dl = do e <- getPPEnv if layout e == PPOffsideRule || layout e == PPSemiColon then a dl else b dl -- Prefix something with a LINE pragma, if requested. -- GHC's LINE pragma actually sets the current line number to n-1, so -- that the following line is line n. But if there's no newline before -- the line we're talking about, we need to compensate by adding 1. markLine :: SrcLoc -> Doc -> Doc markLine loc doc = do e <- getPPEnv let y = srcLine loc let line l = text ("{-# LINE " ++ show l ++ " \"" ++ srcFilename loc ++ "\" #-}") if linePragmas e then layoutChoice (line y $$) (line (y+1) <+>) doc else doc haskell-src-1.0.2.0/Language/Haskell/Parser.ly0000644000000000000000000007442612461020017017164 0ustar0000000000000000> { > ----------------------------------------------------------------------------- > -- | > -- Module : Language.Haskell.Parser > -- Copyright : (c) Simon Marlow, Sven Panne 1997-2000 > -- License : BSD-style (see the file libraries/base/LICENSE) > -- > -- Maintainer : libraries@haskell.org > -- Stability : experimental > -- Portability : portable > -- > -- Haskell parser. > -- > ----------------------------------------------------------------------------- > > module Language.Haskell.Parser ( > parseModule, parseModuleWithMode, > ParseMode(..), defaultParseMode, ParseResult(..)) where > > import Language.Haskell.Syntax > import Language.Haskell.ParseMonad > import Language.Haskell.Lexer > import Language.Haskell.ParseUtils > } ToDo: Check exactly which names must be qualified with Prelude (commas and friends) ToDo: Inst (MPCs?) ToDo: Polish constr a bit ToDo: Ugly: exp0b is used for lhs, pat, exp0, ... ToDo: Differentiate between record updates and labeled construction. ----------------------------------------------------------------------------- Conflicts: 2 shift/reduce 2 for ambiguity in 'case x of y | let z = y in z :: Bool -> b' (don't know whether to reduce 'Bool' as a btype or shift the '->'. Similarly lambda and if. The default resolution in favour of the shift means that a guard can never end with a type signature. In mitigation: it's a rare case and no Haskell implementation allows these, because it would require unbounded lookahead.) There are 2 conflicts rather than one because contexts are parsed as btypes (cf ctype). ----------------------------------------------------------------------------- > %token > VARID { VarId $$ } > QVARID { QVarId $$ } > CONID { ConId $$ } > QCONID { QConId $$ } > VARSYM { VarSym $$ } > CONSYM { ConSym $$ } > QVARSYM { QVarSym $$ } > QCONSYM { QConSym $$ } > INT { IntTok $$ } > RATIONAL { FloatTok $$ } > CHAR { Character $$ } > STRING { StringTok $$ } Symbols > '(' { LeftParen } > ')' { RightParen } > ';' { SemiColon } > '{' { LeftCurly } > '}' { RightCurly } > vccurly { VRightCurly } -- a virtual close brace > '[' { LeftSquare } > ']' { RightSquare } > ',' { Comma } > '_' { Underscore } > '`' { BackQuote } Reserved operators > '..' { DotDot } > ':' { Colon } > '::' { DoubleColon } > '=' { Equals } > '\\' { Backslash } > '|' { Bar } > '<-' { LeftArrow } > '->' { RightArrow } > '@' { At } > '~' { Tilde } > '=>' { DoubleArrow } > '-' { Minus } > '!' { Exclamation } Reserved Ids > 'case' { KW_Case } > 'class' { KW_Class } > 'data' { KW_Data } > 'default' { KW_Default } > 'deriving' { KW_Deriving } > 'do' { KW_Do } > 'else' { KW_Else } > 'foreign' { KW_Foreign } > 'if' { KW_If } > 'import' { KW_Import } > 'in' { KW_In } > 'infix' { KW_Infix } > 'infixl' { KW_InfixL } > 'infixr' { KW_InfixR } > 'instance' { KW_Instance } > 'let' { KW_Let } > 'module' { KW_Module } > 'newtype' { KW_NewType } > 'of' { KW_Of } > 'then' { KW_Then } > 'type' { KW_Type } > 'where' { KW_Where } Special Ids > 'as' { KW_As } > 'export' { KW_Export } > 'hiding' { KW_Hiding } > 'qualified' { KW_Qualified } > 'safe' { KW_Safe } > 'unsafe' { KW_Unsafe } > %monad { P } > %lexer { lexer } { EOF } > %name parse > %tokentype { Token } > %% ----------------------------------------------------------------------------- Module Header > module :: { HsModule } > : srcloc 'module' modid maybeexports 'where' body > { HsModule $1 $3 $4 (fst $6) (snd $6) } > | srcloc body > { HsModule $1 main_mod (Just [HsEVar (UnQual main_name)]) > (fst $2) (snd $2) } > body :: { ([HsImportDecl],[HsDecl]) } > : '{' bodyaux '}' { $2 } > | open bodyaux close { $2 } > bodyaux :: { ([HsImportDecl],[HsDecl]) } > : optsemis impdecls semis topdecls { (reverse $2, $4) } > | optsemis topdecls { ([], $2) } > | optsemis impdecls optsemis { (reverse $2, []) } > | optsemis { ([], []) } > semis :: { () } > : optsemis ';' { () } > optsemis :: { () } > : semis { () } > | {- empty -} { () } ----------------------------------------------------------------------------- The Export List > maybeexports :: { Maybe [HsExportSpec] } > : exports { Just $1 } > | {- empty -} { Nothing } > exports :: { [HsExportSpec] } > : '(' exportlist optcomma ')' { reverse $2 } > | '(' optcomma ')' { [] } > optcomma :: { () } > : ',' { () } > | {- empty -} { () } > exportlist :: { [HsExportSpec] } > : exportlist ',' export { $3 : $1 } > | export { [$1] } > export :: { HsExportSpec } > : qvar { HsEVar $1 } > | qtyconorcls { HsEAbs $1 } > | qtyconorcls '(' '..' ')' { HsEThingAll $1 } > | qtyconorcls '(' ')' { HsEThingWith $1 [] } > | qtyconorcls '(' cnames ')' { HsEThingWith $1 (reverse $3) } > | 'module' modid { HsEModuleContents $2 } ----------------------------------------------------------------------------- Import Declarations > impdecls :: { [HsImportDecl] } > : impdecls semis impdecl { $3 : $1 } > | impdecl { [$1] } > impdecl :: { HsImportDecl } > : srcloc 'import' optqualified modid maybeas maybeimpspec > { HsImportDecl $1 $4 $3 $5 $6 } > optqualified :: { Bool } > : 'qualified' { True } > | {- empty -} { False } > maybeas :: { Maybe Module } > : 'as' modid { Just $2 } > | {- empty -} { Nothing } > maybeimpspec :: { Maybe (Bool, [HsImportSpec]) } > : impspec { Just $1 } > | {- empty -} { Nothing } > impspec :: { (Bool, [HsImportSpec]) } > : opthiding '(' importlist optcomma ')' { ($1, reverse $3) } > | opthiding '(' optcomma ')' { ($1, []) } > opthiding :: { Bool } > : 'hiding' { True } > | {- empty -} { False } > importlist :: { [HsImportSpec] } > : importlist ',' importspec { $3 : $1 } > | importspec { [$1] } > importspec :: { HsImportSpec } > : var { HsIVar $1 } > | tyconorcls { HsIAbs $1 } > | tyconorcls '(' '..' ')' { HsIThingAll $1 } > | tyconorcls '(' ')' { HsIThingWith $1 [] } > | tyconorcls '(' cnames ')' { HsIThingWith $1 (reverse $3) } > cnames :: { [HsCName] } > : cnames ',' cname { $3 : $1 } > | cname { [$1] } > cname :: { HsCName } > : var { HsVarName $1 } > | con { HsConName $1 } ----------------------------------------------------------------------------- Fixity Declarations > fixdecl :: { HsDecl } > : srcloc infix prec ops { HsInfixDecl $1 $2 $3 (reverse $4) } > prec :: { Int } > : {- empty -} { 9 } > | INT {% checkPrec $1 } > infix :: { HsAssoc } > : 'infix' { HsAssocNone } > | 'infixl' { HsAssocLeft } > | 'infixr' { HsAssocRight } > ops :: { [HsOp] } > : ops ',' op { $3 : $1 } > | op { [$1] } ----------------------------------------------------------------------------- Top-Level Declarations Note: The report allows topdecls to be empty. This would result in another shift/reduce-conflict, so we don't handle this case here, but in bodyaux. > topdecls :: { [HsDecl] } > : topdecls1 optsemis {% checkRevDecls $1 } > topdecls1 :: { [HsDecl] } > : topdecls1 semis topdecl { $3 : $1 } > | topdecl { [$1] } > topdecl :: { HsDecl } > : srcloc 'type' simpletype '=' type > { HsTypeDecl $1 (fst $3) (snd $3) $5 } > | srcloc 'data' ctype '=' constrs deriving > {% do { (cs,c,t) <- checkDataHeader $3; > return (HsDataDecl $1 cs c t (reverse $5) $6) } } > | srcloc 'newtype' ctype '=' constr deriving > {% do { (cs,c,t) <- checkDataHeader $3; > return (HsNewTypeDecl $1 cs c t $5 $6) } } > | srcloc 'class' ctype optcbody > {% do { (cs,c,vs) <- checkClassHeader $3; > return (HsClassDecl $1 cs c vs $4) } } > | srcloc 'instance' ctype optvaldefs > {% do { (cs,c,ts) <- checkInstHeader $3; > return (HsInstDecl $1 cs c ts $4) } } > | srcloc 'default' '(' typelist ')' > { HsDefaultDecl $1 $4 } > | foreigndecl { $1 } > | decl { $1 } > typelist :: { [HsType] } > : types { reverse $1 } > | type { [$1] } > | {- empty -} { [] } > decls :: { [HsDecl] } > : optsemis decls1 optsemis {% checkRevDecls $2 } > | optsemis { [] } > decls1 :: { [HsDecl] } > : decls1 semis decl { $3 : $1 } > | decl { [$1] } > decl :: { HsDecl } > : signdecl { $1 } > | fixdecl { $1 } > | valdef { $1 } > decllist :: { [HsDecl] } > : '{' decls '}' { $2 } > | open decls close { $2 } > signdecl :: { HsDecl } > : srcloc vars '::' ctype { HsTypeSig $1 (reverse $2) $4 } ATTENTION: Dirty Hackery Ahead! If the second alternative of vars is var instead of qvar, we get another shift/reduce-conflict. Consider the following programs: { (+) :: ... } only var { (+) x y = ... } could (incorrectly) be qvar We re-use expressions for patterns, so a qvar would be allowed in patterns instead of a var only (which would be correct). But deciding what the + is, would require more lookahead. So let's check for ourselves... > vars :: { [HsName] } > : vars ',' var { $3 : $1 } > | qvar {% do { n <- checkUnQual $1; > return [n] } } Foreign declarations - calling conventions are uninterpreted - external entities are not parsed - special ids are not allowed as internal names > foreigndecl :: { HsDecl } > : srcloc 'foreign' 'import' VARID optsafety optentity fvar '::' type > { HsForeignImport $1 $4 $5 $6 $7 $9 } > | srcloc 'foreign' 'export' VARID optentity fvar '::' type > { HsForeignExport $1 $4 $5 $6 $8 } > optsafety :: { HsSafety } > : 'safe' { HsSafe } > | 'unsafe' { HsUnsafe } > | {- empty -} { HsSafe } > optentity :: { String } > : STRING { $1 } > | {- empty -} { "" } > fvar :: { HsName } > : VARID { HsIdent $1 } > | '(' varsym ')' { $2 } ----------------------------------------------------------------------------- Types > type :: { HsType } > : btype '->' type { HsTyFun $1 $3 } > | btype { $1 } > btype :: { HsType } > : btype atype { HsTyApp $1 $2 } > | atype { $1 } > atype :: { HsType } > : gtycon { HsTyCon $1 } > | tyvar { HsTyVar $1 } > | '(' types ')' { HsTyTuple (reverse $2) } > | '[' type ']' { HsTyApp list_tycon $2 } > | '(' type ')' { $2 } > gtycon :: { HsQName } > : qconid { $1 } > | '(' ')' { unit_tycon_name } > | '(' '->' ')' { fun_tycon_name } > | '[' ']' { list_tycon_name } > | '(' commas ')' { tuple_tycon_name $2 } (Slightly edited) Comment from GHC's hsparser.y: "context => type" vs "type" is a problem, because you can't distinguish between foo :: (Baz a, Baz a) bar :: (Baz a, Baz a) => [a] -> [a] -> [a] with one token of lookahead. The HACK is to parse the context as a btype (more specifically as a tuple type), then check that it has the right form C a, or (C1 a, C2 b, ... Cn z) and convert it into a context. Blaach! > ctype :: { HsQualType } > : context '=>' type { HsQualType $1 $3 } > | type { HsQualType [] $1 } > context :: { HsContext } > : btype {% checkContext $1 } > types :: { [HsType] } > : types ',' type { $3 : $1 } > | type ',' type { [$3, $1] } > simpletype :: { (HsName, [HsName]) } > : tycon tyvars { ($1,reverse $2) } > tyvars :: { [HsName] } > : tyvars tyvar { $2 : $1 } > | {- empty -} { [] } ----------------------------------------------------------------------------- Datatype declarations > constrs :: { [HsConDecl] } > : constrs '|' constr { $3 : $1 } > | constr { [$1] } > constr :: { HsConDecl } > : srcloc scontype { HsConDecl $1 (fst $2) (snd $2) } > | srcloc sbtype conop sbtype { HsConDecl $1 $3 [$2,$4] } > | srcloc con '{' '}' { HsRecDecl $1 $2 [] } > | srcloc con '{' fielddecls '}' { HsRecDecl $1 $2 (reverse $4) } > scontype :: { (HsName, [HsBangType]) } > : btype {% do { (c,ts) <- splitTyConApp $1; > return (c,map HsUnBangedTy ts) } } > | scontype1 { $1 } > scontype1 :: { (HsName, [HsBangType]) } > : btype '!' atype {% do { (c,ts) <- splitTyConApp $1; > return (c,map HsUnBangedTy ts++ > [HsBangedTy $3]) } } > | scontype1 satype { (fst $1, snd $1 ++ [$2] ) } > satype :: { HsBangType } > : atype { HsUnBangedTy $1 } > | '!' atype { HsBangedTy $2 } > sbtype :: { HsBangType } > : btype { HsUnBangedTy $1 } > | '!' atype { HsBangedTy $2 } > fielddecls :: { [([HsName],HsBangType)] } > : fielddecls ',' fielddecl { $3 : $1 } > | fielddecl { [$1] } > fielddecl :: { ([HsName],HsBangType) } > : vars '::' stype { (reverse $1, $3) } > stype :: { HsBangType } > : type { HsUnBangedTy $1 } > | '!' atype { HsBangedTy $2 } > deriving :: { [HsQName] } > : {- empty -} { [] } > | 'deriving' qtycls { [$2] } > | 'deriving' '(' ')' { [] } > | 'deriving' '(' dclasses ')' { reverse $3 } > dclasses :: { [HsQName] } > : dclasses ',' qtycls { $3 : $1 } > | qtycls { [$1] } ----------------------------------------------------------------------------- Class declarations > optcbody :: { [HsDecl] } > : 'where' decllist {% checkClassBody $2 } > | {- empty -} { [] } ----------------------------------------------------------------------------- Instance declarations > optvaldefs :: { [HsDecl] } > : 'where' '{' valdefs '}' {% checkClassBody $3 } > | 'where' open valdefs close {% checkClassBody $3 } > | {- empty -} { [] } > valdefs :: { [HsDecl] } > : optsemis valdefs1 optsemis {% checkRevDecls $2 } > | optsemis { [] } > valdefs1 :: { [HsDecl] } > : valdefs1 semis valdef { $3 : $1 } > | valdef { [$1] } ----------------------------------------------------------------------------- Value definitions > valdef :: { HsDecl } > : srcloc exp0b rhs optwhere {% checkValDef $1 $2 $3 $4 } > optwhere :: { [HsDecl] } > : 'where' decllist { $2 } > | {- empty -} { [] } > rhs :: { HsRhs } > : '=' exp {% do { e <- checkExpr $2; > return (HsUnGuardedRhs e) } } > | gdrhs { HsGuardedRhss (reverse $1) } > gdrhs :: { [HsGuardedRhs] } > : gdrhs gdrh { $2 : $1 } > | gdrh { [$1] } > gdrh :: { HsGuardedRhs } > : srcloc '|' exp0 '=' exp {% do { g <- checkExpr $3; > e <- checkExpr $5; > return (HsGuardedRhs $1 g e) } } ----------------------------------------------------------------------------- Expressions Note: The Report specifies a meta-rule for lambda, let and if expressions (the exp's that end with a subordinate exp): they extend as far to the right as possible. That means they cannot be followed by a type signature or infix application. To implement this without shift/reduce conflicts, we split exp10 into these expressions (exp10a) and the others (exp10b). That also means that only an exp0 ending in an exp10b (an exp0b) can followed by a type signature or infix application. So we duplicate the exp0 productions to distinguish these from the others (exp0a). > exp :: { HsExp } > : exp0b '::' srcloc ctype { HsExpTypeSig $3 $1 $4 } > | exp0 { $1 } > exp0 :: { HsExp } > : exp0a { $1 } > | exp0b { $1 } > exp0a :: { HsExp } > : exp0b qop exp10a { HsInfixApp $1 $2 $3 } > | exp10a { $1 } > exp0b :: { HsExp } > : exp0b qop exp10b { HsInfixApp $1 $2 $3 } > | exp10b { $1 } > exp10a :: { HsExp } > : '\\' srcloc apats '->' exp { HsLambda $2 (reverse $3) $5 } > | 'let' decllist 'in' exp { HsLet $2 $4 } > | 'if' exp 'then' exp 'else' exp { HsIf $2 $4 $6 } > exp10b :: { HsExp } > : 'case' exp 'of' altslist { HsCase $2 $4 } > | '-' fexp { HsNegApp $2 } > | 'do' stmtlist { HsDo $2 } > | fexp { $1 } > fexp :: { HsExp } > : fexp aexp { HsApp $1 $2 } > | aexp { $1 } > apats :: { [HsPat] } > : apats apat { $2 : $1 } > | apat { [$1] } > apat :: { HsPat } > : aexp {% checkPattern $1 } UGLY: Because patterns and expressions are mixed, aexp has to be split into two rules: One right-recursive and one left-recursive. Otherwise we get two reduce/reduce-errors (for as-patterns and irrefutable patters). Even though the variable in an as-pattern cannot be qualified, we use qvar here to avoid a shift/reduce conflict, and then check it ourselves (as for vars above). > aexp :: { HsExp } > : qvar '@' aexp {% do { n <- checkUnQual $1; > return (HsAsPat n $3) } } > | '~' aexp { HsIrrPat $2 } > | aexp1 { $1 } Note: The first two alternatives of aexp1 are not necessarily record updates: they could be labeled constructions. > aexp1 :: { HsExp } > : aexp1 '{' '}' {% mkRecConstrOrUpdate $1 [] } > | aexp1 '{' fbinds '}' {% mkRecConstrOrUpdate $1 (reverse $3) } > | aexp2 { $1 } According to the Report, the left section (e op) is legal iff (e op x) parses equivalently to ((e) op x). Thus e must be an exp0b. > aexp2 :: { HsExp } > : qvar { HsVar $1 } > | gcon { $1 } > | literal { HsLit $1 } > | '(' exp ')' { HsParen $2 } > | '(' texps ')' { HsTuple (reverse $2) } > | '[' list ']' { $2 } > | '(' exp0b qop ')' { HsLeftSection $2 $3 } > | '(' qopm exp0 ')' { HsRightSection $2 $3 } > | '_' { HsWildCard } > commas :: { Int } > : commas ',' { $1 + 1 } > | ',' { 1 } > texps :: { [HsExp] } > : texps ',' exp { $3 : $1 } > | exp ',' exp { [$3,$1] } ----------------------------------------------------------------------------- List expressions The rules below are little bit contorted to keep lexps left-recursive while avoiding another shift/reduce-conflict. > list :: { HsExp } > : exp { HsList [$1] } > | lexps { HsList (reverse $1) } > | exp '..' { HsEnumFrom $1 } > | exp ',' exp '..' { HsEnumFromThen $1 $3 } > | exp '..' exp { HsEnumFromTo $1 $3 } > | exp ',' exp '..' exp { HsEnumFromThenTo $1 $3 $5 } > | exp '|' quals { HsListComp $1 (reverse $3) } > lexps :: { [HsExp] } > : lexps ',' exp { $3 : $1 } > | exp ',' exp { [$3,$1] } ----------------------------------------------------------------------------- List comprehensions > quals :: { [HsStmt] } > : quals ',' qual { $3 : $1 } > | qual { [$1] } > qual :: { HsStmt } > : pat srcloc '<-' exp { HsGenerator $2 $1 $4 } > | exp { HsQualifier $1 } > | 'let' decllist { HsLetStmt $2 } ----------------------------------------------------------------------------- Case alternatives > altslist :: { [HsAlt] } > : '{' alts '}' { $2 } > | open alts close { $2 } > alts :: { [HsAlt] } > : optsemis alts1 optsemis { reverse $2 } > alts1 :: { [HsAlt] } > : alts1 semis alt { $3 : $1 } > | alt { [$1] } > alt :: { HsAlt } > : srcloc pat ralt optwhere { HsAlt $1 $2 $3 $4 } > ralt :: { HsGuardedAlts } > : '->' exp { HsUnGuardedAlt $2 } > | gdpats { HsGuardedAlts (reverse $1) } > gdpats :: { [HsGuardedAlt] } > : gdpats gdpat { $2 : $1 } > | gdpat { [$1] } > gdpat :: { HsGuardedAlt } > : srcloc '|' exp0 '->' exp { HsGuardedAlt $1 $3 $5 } > pat :: { HsPat } > : exp0b {% checkPattern $1 } ----------------------------------------------------------------------------- Statement sequences As per the Report, but with stmt expanded to simplify building the list without introducing conflicts. This also ensures that the last stmt is an expression. > stmtlist :: { [HsStmt] } > : '{' stmts '}' { $2 } > | open stmts close { $2 } > stmts :: { [HsStmt] } > : 'let' decllist ';' stmts { HsLetStmt $2 : $4 } > | pat srcloc '<-' exp ';' stmts { HsGenerator $2 $1 $4 : $6 } > | exp ';' stmts { HsQualifier $1 : $3 } > | ';' stmts { $2 } > | exp ';' { [HsQualifier $1] } > | exp { [HsQualifier $1] } ----------------------------------------------------------------------------- Record Field Update/Construction > fbinds :: { [HsFieldUpdate] } > : fbinds ',' fbind { $3 : $1 } > | fbind { [$1] } > fbind :: { HsFieldUpdate } > : qvar '=' exp { HsFieldUpdate $1 $3 } ----------------------------------------------------------------------------- Variables, Constructors and Operators. > gcon :: { HsExp } > : '(' ')' { unit_con } > | '[' ']' { HsList [] } > | '(' commas ')' { tuple_con $2 } > | qcon { HsCon $1 } > var :: { HsName } > : varid { $1 } > | '(' varsym ')' { $2 } > qvar :: { HsQName } > : qvarid { $1 } > | '(' qvarsym ')' { $2 } > con :: { HsName } > : conid { $1 } > | '(' consym ')' { $2 } > qcon :: { HsQName } > : qconid { $1 } > | '(' gconsym ')' { $2 } > varop :: { HsName } > : varsym { $1 } > | '`' varid '`' { $2 } > qvarop :: { HsQName } > : qvarsym { $1 } > | '`' qvarid '`' { $2 } > qvaropm :: { HsQName } > : qvarsymm { $1 } > | '`' qvarid '`' { $2 } > conop :: { HsName } > : consym { $1 } > | '`' conid '`' { $2 } > qconop :: { HsQName } > : gconsym { $1 } > | '`' qconid '`' { $2 } > op :: { HsOp } > : varop { HsVarOp $1 } > | conop { HsConOp $1 } > qop :: { HsQOp } > : qvarop { HsQVarOp $1 } > | qconop { HsQConOp $1 } > qopm :: { HsQOp } > : qvaropm { HsQVarOp $1 } > | qconop { HsQConOp $1 } > gconsym :: { HsQName } > : ':' { list_cons_name } > | qconsym { $1 } ----------------------------------------------------------------------------- Identifiers and Symbols > qvarid :: { HsQName } > : varid { UnQual $1 } > | QVARID { Qual (Module (fst $1)) (HsIdent (snd $1)) } > varid :: { HsName } > : VARID { HsIdent $1 } > | 'as' { HsIdent "as" } > | 'export' { HsIdent "export" } > | 'hiding' { HsIdent "hiding" } > | 'qualified' { HsIdent "qualified" } > | 'safe' { HsIdent "safe" } > | 'unsafe' { HsIdent "unsafe" } > qconid :: { HsQName } > : conid { UnQual $1 } > | QCONID { Qual (Module (fst $1)) (HsIdent (snd $1)) } > conid :: { HsName } > : CONID { HsIdent $1 } > qconsym :: { HsQName } > : consym { UnQual $1 } > | QCONSYM { Qual (Module (fst $1)) (HsSymbol (snd $1)) } > consym :: { HsName } > : CONSYM { HsSymbol $1 } > qvarsym :: { HsQName } > : varsym { UnQual $1 } > | qvarsym1 { $1 } > qvarsymm :: { HsQName } > : varsymm { UnQual $1 } > | qvarsym1 { $1 } > varsym :: { HsName } > : VARSYM { HsSymbol $1 } > | '-' { HsSymbol "-" } > | '!' { HsSymbol "!" } > varsymm :: { HsName } -- varsym not including '-' > : VARSYM { HsSymbol $1 } > | '!' { HsSymbol "!" } > qvarsym1 :: { HsQName } > : QVARSYM { Qual (Module (fst $1)) (HsSymbol (snd $1)) } > literal :: { HsLiteral } > : INT { HsInt $1 } > | CHAR { HsChar $1 } > | RATIONAL { HsFrac $1 } > | STRING { HsString $1 } > srcloc :: { SrcLoc } : {% getSrcLoc } ----------------------------------------------------------------------------- Layout > open :: { () } : {% pushCurrentContext } > close :: { () } > : vccurly { () } -- context popped in lexer. > | error {% popContext } ----------------------------------------------------------------------------- Miscellaneous (mostly renamings) > modid :: { Module } > : CONID { Module $1 } > | QCONID { Module (fst $1 ++ '.':snd $1) } > tyconorcls :: { HsName } > : conid { $1 } > tycon :: { HsName } > : conid { $1 } > qtyconorcls :: { HsQName } > : qconid { $1 } > qtycls :: { HsQName } > : qconid { $1 } > tyvar :: { HsName } > : varid { $1 } ----------------------------------------------------------------------------- > { > happyError :: P a > happyError = fail "Parse error" > -- | Parse of a string, which should contain a complete Haskell 98 module. > parseModule :: String -> ParseResult HsModule > parseModule = runParser parse > -- | Parse of a string, which should contain a complete Haskell 98 module. > parseModuleWithMode :: ParseMode -> String -> ParseResult HsModule > parseModuleWithMode mode = runParserWithMode mode parse > } haskell-src-1.0.2.0/Language/Haskell/Lexer.hs0000644000000000000000000004313212461020017016763 0ustar0000000000000000-- #hide ----------------------------------------------------------------------------- -- | -- Module : Language.Haskell.Lexer -- Copyright : (c) The GHC Team, 1997-2000 -- License : BSD-style (see the file libraries/base/LICENSE) -- -- Maintainer : libraries@haskell.org -- Stability : experimental -- Portability : portable -- -- Lexer for Haskell. -- ----------------------------------------------------------------------------- -- ToDo: Introduce different tokens for decimal, octal and hexadecimal (?) -- ToDo: FloatTok should have three parts (integer part, fraction, exponent) (?) -- ToDo: Use a lexical analyser generator (lx?) module Language.Haskell.Lexer (Token(..), lexer) where import Language.Haskell.ParseMonad import Data.Char (isAlpha, isLower, isUpper, toLower, isDigit, isHexDigit, isOctDigit, isSpace, ord, chr, digitToInt) import qualified Data.Char (isSymbol) import Data.Ratio data Token = VarId String | QVarId (String,String) | ConId String | QConId (String,String) | VarSym String | ConSym String | QVarSym (String,String) | QConSym (String,String) | IntTok Integer | FloatTok Rational | Character Char | StringTok String -- Symbols | LeftParen | RightParen | SemiColon | LeftCurly | RightCurly | VRightCurly -- a virtual close brace | LeftSquare | RightSquare | Comma | Underscore | BackQuote -- Reserved operators | DotDot | Colon | DoubleColon | Equals | Backslash | Bar | LeftArrow | RightArrow | At | Tilde | DoubleArrow | Minus | Exclamation -- Reserved Ids | KW_Case | KW_Class | KW_Data | KW_Default | KW_Deriving | KW_Do | KW_Else | KW_Foreign | KW_If | KW_Import | KW_In | KW_Infix | KW_InfixL | KW_InfixR | KW_Instance | KW_Let | KW_Module | KW_NewType | KW_Of | KW_Then | KW_Type | KW_Where -- Special Ids | KW_As | KW_Export | KW_Hiding | KW_Qualified | KW_Safe | KW_Unsafe | EOF deriving (Eq,Show) reserved_ops :: [(String,Token)] reserved_ops = [ ( "..", DotDot ), ( ":", Colon ), ( "::", DoubleColon ), ( "=", Equals ), ( "\\", Backslash ), ( "|", Bar ), ( "<-", LeftArrow ), ( "->", RightArrow ), ( "@", At ), ( "~", Tilde ), ( "=>", DoubleArrow ) ] special_varops :: [(String,Token)] special_varops = [ ( "-", Minus ), --ToDo: shouldn't be here ( "!", Exclamation ) --ditto ] reserved_ids :: [(String,Token)] reserved_ids = [ ( "_", Underscore ), ( "case", KW_Case ), ( "class", KW_Class ), ( "data", KW_Data ), ( "default", KW_Default ), ( "deriving", KW_Deriving ), ( "do", KW_Do ), ( "else", KW_Else ), ( "foreign", KW_Foreign ), ( "if", KW_If ), ( "import", KW_Import ), ( "in", KW_In ), ( "infix", KW_Infix ), ( "infixl", KW_InfixL ), ( "infixr", KW_InfixR ), ( "instance", KW_Instance ), ( "let", KW_Let ), ( "module", KW_Module ), ( "newtype", KW_NewType ), ( "of", KW_Of ), ( "then", KW_Then ), ( "type", KW_Type ), ( "where", KW_Where ) ] special_varids :: [(String,Token)] special_varids = [ ( "as", KW_As ), ( "export", KW_Export ), ( "hiding", KW_Hiding ), ( "qualified", KW_Qualified ), ( "safe", KW_Safe ), ( "unsafe", KW_Unsafe ) ] isIdent, isSymbol :: Char -> Bool isIdent c = isAlpha c || isDigit c || c == '\'' || c == '_' isSymbol c = c `elem` ":!#%&*./?@\\-" || (Data.Char.isSymbol c && not (c `elem` "(),;[]`{}_\"'")) matchChar :: Char -> String -> Lex a () matchChar c msg = do s <- getInput if null s || head s /= c then fail msg else discard 1 -- The top-level lexer. -- We need to know whether we are at the beginning of the line to decide -- whether to insert layout tokens. lexer :: (Token -> P a) -> P a lexer = runL $ do bol <- checkBOL bol' <- lexWhiteSpace bol startToken if bol' then lexBOL else lexToken lexWhiteSpace :: Bool -> Lex a Bool lexWhiteSpace bol = do s <- getInput case s of '{':'-':_ -> do discard 2 bol' <- lexNestedComment bol lexWhiteSpace bol' '-':'-':rest | all (== '-') (takeWhile isSymbol rest) -> do _ <- lexWhile (== '-') _ <- lexWhile (/= '\n') s' <- getInput case s' of [] -> fail "Unterminated end-of-line comment" _ -> do lexNewline lexWhiteSpace True '\n':_ -> do lexNewline lexWhiteSpace True '\t':_ -> do lexTab lexWhiteSpace bol c:_ | isSpace c -> do discard 1 lexWhiteSpace bol _ -> return bol lexNestedComment :: Bool -> Lex a Bool lexNestedComment bol = do s <- getInput case s of '-':'}':_ -> discard 2 >> return bol '{':'-':_ -> do discard 2 bol' <- lexNestedComment bol -- rest of the subcomment lexNestedComment bol' -- rest of this comment '\t':_ -> lexTab >> lexNestedComment bol '\n':_ -> lexNewline >> lexNestedComment True _:_ -> discard 1 >> lexNestedComment bol [] -> fail "Unterminated nested comment" -- When we are lexing the first token of a line, check whether we need to -- insert virtual semicolons or close braces due to layout. lexBOL :: Lex a Token lexBOL = do pos <- getOffside case pos of LT -> do -- trace "layout: inserting '}'\n" $ -- Set col to 0, indicating that we're still at the -- beginning of the line, in case we need a semi-colon too. -- Also pop the context here, so that we don't insert -- another close brace before the parser can pop it. setBOL popContextL "lexBOL" return VRightCurly EQ -> -- trace "layout: inserting ';'\n" $ return SemiColon GT -> lexToken lexToken :: Lex a Token lexToken = do s <- getInput case s of [] -> return EOF '0':c:d:_ | toLower c == 'o' && isOctDigit d -> do discard 2 n <- lexOctal return (IntTok n) | toLower c == 'x' && isHexDigit d -> do discard 2 n <- lexHexadecimal return (IntTok n) c:_ | isDigit c -> lexDecimalOrFloat | isUpper c -> lexConIdOrQual "" | isLower c || c == '_' -> do ident <- lexWhile isIdent return $ case lookup ident (reserved_ids ++ special_varids) of Just keyword -> keyword Nothing -> VarId ident | isSymbol c -> do sym <- lexWhile isSymbol return $ case lookup sym (reserved_ops ++ special_varops) of Just t -> t Nothing -> case c of ':' -> ConSym sym _ -> VarSym sym | otherwise -> do discard 1 case c of -- First the special symbols '(' -> return LeftParen ')' -> return RightParen ',' -> return Comma ';' -> return SemiColon '[' -> return LeftSquare ']' -> return RightSquare '`' -> return BackQuote '{' -> do pushContextL NoLayout return LeftCurly '}' -> do popContextL "lexToken" return RightCurly '\'' -> do c2 <- lexChar matchChar '\'' "Improperly terminated character constant" return (Character c2) '"' -> lexString _ -> fail ("Illegal character \'" ++ show c ++ "\'\n") lexDecimalOrFloat :: Lex a Token lexDecimalOrFloat = do ds <- lexWhile isDigit rest <- getInput case rest of ('.':d:_) | isDigit d -> do discard 1 frac <- lexWhile isDigit let num = parseInteger 10 (ds ++ frac) decimals = toInteger (length frac) exponent' <- do rest2 <- getInput case rest2 of 'e':_ -> lexExponent 'E':_ -> lexExponent _ -> return 0 return (FloatTok ((num%1) * 10^^(exponent' - decimals))) e:_ | toLower e == 'e' -> do exponent' <- lexExponent return (FloatTok ((parseInteger 10 ds%1) * 10^^exponent')) _ -> return (IntTok (parseInteger 10 ds)) where lexExponent :: Lex a Integer lexExponent = do discard 1 -- 'e' or 'E' r <- getInput case r of '+':d:_ | isDigit d -> do discard 1 lexDecimal '-':d:_ | isDigit d -> do discard 1 n <- lexDecimal return (negate n) d:_ | isDigit d -> lexDecimal _ -> fail "Float with missing exponent" lexConIdOrQual :: String -> Lex a Token lexConIdOrQual qual = do con <- lexWhile isIdent let conid | null qual = ConId con | otherwise = QConId (qual,con) qual' | null qual = con | otherwise = qual ++ '.':con just_a_conid <- alternative (return conid) rest <- getInput case rest of '.':c:_ | isLower c || c == '_' -> do -- qualified varid? discard 1 ident <- lexWhile isIdent case lookup ident reserved_ids of -- cannot qualify a reserved word Just _ -> just_a_conid Nothing -> return (QVarId (qual', ident)) | isUpper c -> do -- qualified conid? discard 1 lexConIdOrQual qual' | isSymbol c -> do -- qualified symbol? discard 1 sym <- lexWhile isSymbol case lookup sym reserved_ops of -- cannot qualify a reserved operator Just _ -> just_a_conid Nothing -> return $ case c of ':' -> QConSym (qual', sym) _ -> QVarSym (qual', sym) _ -> return conid -- not a qualified thing lexChar :: Lex a Char lexChar = do r <- getInput case r of '\\':_ -> lexEscape c:_ -> discard 1 >> return c [] -> fail "Incomplete character constant" lexString :: Lex a Token lexString = loop "" where loop s = do r <- getInput case r of '\\':'&':_ -> do discard 2 loop s '\\':c:_ | isSpace c -> do discard 1 lexWhiteChars matchChar '\\' "Illegal character in string gap" loop s | otherwise -> do ce <- lexEscape loop (ce:s) '"':_ -> do discard 1 return (StringTok (reverse s)) c:_ -> do discard 1 loop (c:s) [] -> fail "Improperly terminated string" lexWhiteChars :: Lex a () lexWhiteChars = do s <- getInput case s of '\n':_ -> do lexNewline lexWhiteChars '\t':_ -> do lexTab lexWhiteChars c:_ | isSpace c -> do discard 1 lexWhiteChars _ -> return () lexEscape :: Lex a Char lexEscape = do discard 1 r <- getInput case r of -- Production charesc from section B.2 (Note: \& is handled by caller) 'a':_ -> discard 1 >> return '\a' 'b':_ -> discard 1 >> return '\b' 'f':_ -> discard 1 >> return '\f' 'n':_ -> discard 1 >> return '\n' 'r':_ -> discard 1 >> return '\r' 't':_ -> discard 1 >> return '\t' 'v':_ -> discard 1 >> return '\v' '\\':_ -> discard 1 >> return '\\' '"':_ -> discard 1 >> return '\"' '\'':_ -> discard 1 >> return '\'' -- Production ascii from section B.2 '^':c:_ -> discard 2 >> cntrl c 'N':'U':'L':_ -> discard 3 >> return '\NUL' 'S':'O':'H':_ -> discard 3 >> return '\SOH' 'S':'T':'X':_ -> discard 3 >> return '\STX' 'E':'T':'X':_ -> discard 3 >> return '\ETX' 'E':'O':'T':_ -> discard 3 >> return '\EOT' 'E':'N':'Q':_ -> discard 3 >> return '\ENQ' 'A':'C':'K':_ -> discard 3 >> return '\ACK' 'B':'E':'L':_ -> discard 3 >> return '\BEL' 'B':'S':_ -> discard 2 >> return '\BS' 'H':'T':_ -> discard 2 >> return '\HT' 'L':'F':_ -> discard 2 >> return '\LF' 'V':'T':_ -> discard 2 >> return '\VT' 'F':'F':_ -> discard 2 >> return '\FF' 'C':'R':_ -> discard 2 >> return '\CR' 'S':'O':_ -> discard 2 >> return '\SO' 'S':'I':_ -> discard 2 >> return '\SI' 'D':'L':'E':_ -> discard 3 >> return '\DLE' 'D':'C':'1':_ -> discard 3 >> return '\DC1' 'D':'C':'2':_ -> discard 3 >> return '\DC2' 'D':'C':'3':_ -> discard 3 >> return '\DC3' 'D':'C':'4':_ -> discard 3 >> return '\DC4' 'N':'A':'K':_ -> discard 3 >> return '\NAK' 'S':'Y':'N':_ -> discard 3 >> return '\SYN' 'E':'T':'B':_ -> discard 3 >> return '\ETB' 'C':'A':'N':_ -> discard 3 >> return '\CAN' 'E':'M':_ -> discard 2 >> return '\EM' 'S':'U':'B':_ -> discard 3 >> return '\SUB' 'E':'S':'C':_ -> discard 3 >> return '\ESC' 'F':'S':_ -> discard 2 >> return '\FS' 'G':'S':_ -> discard 2 >> return '\GS' 'R':'S':_ -> discard 2 >> return '\RS' 'U':'S':_ -> discard 2 >> return '\US' 'S':'P':_ -> discard 2 >> return '\SP' 'D':'E':'L':_ -> discard 3 >> return '\DEL' -- Escaped numbers 'o':c:_ | isOctDigit c -> do discard 1 n <- lexOctal checkChar n 'x':c:_ | isHexDigit c -> do discard 1 n <- lexHexadecimal checkChar n c:_ | isDigit c -> do n <- lexDecimal checkChar n _ -> fail "Illegal escape sequence" where checkChar n | n <= 0x10FFFF = return (chr (fromInteger n)) checkChar _ = fail "Character constant out of range" -- Production cntrl from section B.2 cntrl :: Char -> Lex a Char cntrl c | c >= '@' && c <= '_' = return (chr (ord c - ord '@')) cntrl _ = fail "Illegal control character" -- assumes at least one octal digit lexOctal :: Lex a Integer lexOctal = do ds <- lexWhile isOctDigit return (parseInteger 8 ds) -- assumes at least one hexadecimal digit lexHexadecimal :: Lex a Integer lexHexadecimal = do ds <- lexWhile isHexDigit return (parseInteger 16 ds) -- assumes at least one decimal digit lexDecimal :: Lex a Integer lexDecimal = do ds <- lexWhile isDigit return (parseInteger 10 ds) -- Stolen from Hugs's Prelude parseInteger :: Integer -> String -> Integer parseInteger radix ds = foldl1 (\n d -> n * radix + d) (map (toInteger . digitToInt) ds) haskell-src-1.0.2.0/Language/Haskell/ParseMonad.hs0000644000000000000000000002174112461020017017737 0ustar0000000000000000-- #hide ----------------------------------------------------------------------------- -- | -- Module : Language.Haskell.ParseMonad -- Copyright : (c) The GHC Team, 1997-2000 -- License : BSD-style (see the file libraries/base/LICENSE) -- -- Maintainer : libraries@haskell.org -- Stability : experimental -- Portability : portable -- -- Monads for the Haskell parser and lexer. -- ----------------------------------------------------------------------------- module Language.Haskell.ParseMonad( -- * Parsing P, ParseResult(..), atSrcLoc, LexContext(..), ParseMode(..), defaultParseMode, runParserWithMode, runParser, getSrcLoc, pushCurrentContext, popContext, -- * Lexing Lex(runL), getInput, discard, lexNewline, lexTab, lexWhile, alternative, checkBOL, setBOL, startToken, getOffside, pushContextL, popContextL ) where import Language.Haskell.Syntax(SrcLoc(..)) import Control.Applicative import Control.Monad (ap, liftM) import Data.Monoid import Prelude -- | The result of a parse. data ParseResult a = ParseOk a -- ^ The parse succeeded, yielding a value. | ParseFailed SrcLoc String -- ^ The parse failed at the specified -- source location, with an error message. deriving Show instance Functor ParseResult where fmap f (ParseOk x) = ParseOk $ f x fmap _ (ParseFailed loc msg) = ParseFailed loc msg instance Applicative ParseResult where pure = ParseOk ParseOk f <*> x = f <$> x ParseFailed loc msg <*> _ = ParseFailed loc msg instance Monad ParseResult where return = ParseOk ParseOk x >>= f = f x ParseFailed loc msg >>= _ = ParseFailed loc msg instance Monoid m => Monoid (ParseResult m) where mempty = ParseOk mempty ParseOk x `mappend` ParseOk y = ParseOk $ x `mappend` y ParseOk _ `mappend` err = err err `mappend` _ = err -- left-biased -- internal version data ParseStatus a = Ok ParseState a | Failed SrcLoc String deriving Show data LexContext = NoLayout | Layout Int deriving (Eq,Ord,Show) type ParseState = [LexContext] indentOfParseState :: ParseState -> Int indentOfParseState (Layout n:_) = n indentOfParseState _ = 0 -- | Static parameters governing a parse. -- More to come later, e.g. literate mode, language extensions. data ParseMode = ParseMode { -- | original name of the file being parsed parseFilename :: String } -- | Default parameters for a parse, -- currently just a marker for an unknown filename. defaultParseMode :: ParseMode defaultParseMode = ParseMode { parseFilename = "" } -- | Monad for parsing newtype P a = P { runP :: String -- input string -> Int -- current column -> Int -- current line -> SrcLoc -- location of last token read -> ParseState -- layout info. -> ParseMode -- parse parameters -> ParseStatus a } runParserWithMode :: ParseMode -> P a -> String -> ParseResult a runParserWithMode mode (P m) s = case m s 0 1 start [] mode of Ok _ a -> ParseOk a Failed loc msg -> ParseFailed loc msg where start = SrcLoc { srcFilename = parseFilename mode, srcLine = 1, srcColumn = 1 } runParser :: P a -> String -> ParseResult a runParser = runParserWithMode defaultParseMode instance Functor P where fmap = liftM instance Applicative P where pure = return (<*>) = ap instance Monad P where return a = P $ \_i _x _y _l s _m -> Ok s a P m >>= k = P $ \i x y l s mode -> case m i x y l s mode of Failed loc msg -> Failed loc msg Ok s' a -> runP (k a) i x y l s' mode fail s = P $ \_r _col _line loc _stk _m -> Failed loc s atSrcLoc :: P a -> SrcLoc -> P a P m `atSrcLoc` loc = P $ \i x y _l -> m i x y loc getSrcLoc :: P SrcLoc getSrcLoc = P $ \_i _x _y l s _m -> Ok s l -- Enter a new layout context. If we are already in a layout context, -- ensure that the new indent is greater than the indent of that context. -- (So if the source loc is not to the right of the current indent, an -- empty list {} will be inserted.) pushCurrentContext :: P () pushCurrentContext = do loc <- getSrcLoc indent <- currentIndent pushContext (Layout (max (indent+1) (srcColumn loc))) currentIndent :: P Int currentIndent = P $ \_r _x _y _loc stk _mode -> Ok stk (indentOfParseState stk) pushContext :: LexContext -> P () pushContext ctxt = --trace ("pushing lexical scope: " ++ show ctxt ++"\n") $ P $ \_i _x _y _l s _m -> Ok (ctxt:s) () popContext :: P () popContext = P $ \_i _x _y _l stk _m -> case stk of (_:s) -> --trace ("popping lexical scope, context now "++show s ++ "\n") $ Ok s () [] -> error "Internal error: empty context in popContext" -- Monad for lexical analysis: -- a continuation-passing version of the parsing monad newtype Lex r a = Lex { runL :: (a -> P r) -> P r } instance Functor (Lex r) where fmap = liftM instance Applicative (Lex r) where pure = return (<*>) = ap instance Monad (Lex r) where return a = Lex $ \k -> k a Lex v >>= f = Lex $ \k -> v (\a -> runL (f a) k) Lex v >> Lex w = Lex $ \k -> v (\_ -> w k) fail s = Lex $ \_ -> fail s -- Operations on this monad getInput :: Lex r String getInput = Lex $ \cont -> P $ \r -> runP (cont r) r -- | Discard some input characters (these must not include tabs or newlines). discard :: Int -> Lex r () discard n = Lex $ \cont -> P $ \r x -> runP (cont ()) (drop n r) (x+n) -- | Discard the next character, which must be a newline. lexNewline :: Lex a () lexNewline = Lex $ \cont -> P $ \(_:r) _x y -> runP (cont ()) r 1 (y+1) -- | Discard the next character, which must be a tab. lexTab :: Lex a () lexTab = Lex $ \cont -> P $ \(_:r) x -> runP (cont ()) r (nextTab x) nextTab :: Int -> Int nextTab x = x + (tAB_LENGTH - (x-1) `mod` tAB_LENGTH) tAB_LENGTH :: Int tAB_LENGTH = 8 -- Consume and return the largest string of characters satisfying p lexWhile :: (Char -> Bool) -> Lex a String lexWhile p = Lex $ \cont -> P $ \r x -> let (cs,rest) = span p r in runP (cont cs) rest (x + length cs) -- An alternative scan, to which we can return if subsequent scanning -- is unsuccessful. alternative :: Lex a v -> Lex a (Lex a v) alternative (Lex v) = Lex $ \cont -> P $ \r x y -> runP (cont (Lex $ \cont' -> P $ \_r _x _y -> runP (v cont') r x y)) r x y -- The source location is the coordinates of the previous token, -- or, while scanning a token, the start of the current token. -- col is the current column in the source file. -- We also need to remember between scanning tokens whether we are -- somewhere at the beginning of the line before the first token. -- This could be done with an extra Bool argument to the P monad, -- but as a hack we use a col value of 0 to indicate this situation. -- Setting col to 0 is used in two places: just after emitting a virtual -- close brace due to layout, so that next time through we check whether -- we also need to emit a semi-colon, and at the beginning of the file, -- by runParser, to kick off the lexer. -- Thus when col is zero, the true column can be taken from the loc. checkBOL :: Lex a Bool checkBOL = Lex $ \cont -> P $ \r x y loc -> if x == 0 then runP (cont True) r (srcColumn loc) y loc else runP (cont False) r x y loc setBOL :: Lex a () setBOL = Lex $ \cont -> P $ \r _ -> runP (cont ()) r 0 -- Set the loc to the current position startToken :: Lex a () startToken = Lex $ \cont -> P $ \s x y _ stk mode -> let loc = SrcLoc { srcFilename = parseFilename mode, srcLine = y, srcColumn = x } in runP (cont ()) s x y loc stk mode -- Current status with respect to the offside (layout) rule: -- LT: we are to the left of the current indent (if any) -- EQ: we are at the current indent (if any) -- GT: we are to the right of the current indent, or not subject to layout getOffside :: Lex a Ordering getOffside = Lex $ \cont -> P $ \r x y loc stk -> runP (cont (compare x (indentOfParseState stk))) r x y loc stk pushContextL :: LexContext -> Lex a () pushContextL ctxt = Lex $ \cont -> P $ \r x y loc stk -> runP (cont ()) r x y loc (ctxt:stk) popContextL :: String -> Lex a () popContextL fn = Lex $ \cont -> P $ \r x y loc stk -> case stk of (_:ctxt) -> runP (cont ()) r x y loc ctxt [] -> error ("Internal error: empty context in " ++ fn) haskell-src-1.0.2.0/Language/Haskell/Syntax.hs0000644000000000000000000004610212461020017017172 0ustar0000000000000000{-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} ----------------------------------------------------------------------------- -- | -- Module : Language.Haskell.Syntax -- Copyright : (c) The GHC Team, 1997-2000 -- License : BSD-style (see the file libraries/base/LICENSE) -- -- Maintainer : libraries@haskell.org -- Stability : experimental -- Portability : portable -- -- A suite of datatypes describing the abstract syntax of Haskell 98 -- plus a few extensions: -- -- * multi-parameter type classes -- -- * parameters of type class assertions are unrestricted -- -- This module has been changed so that show is a real show. -- For GHC, we also derive Typeable and Data for all types. ----------------------------------------------------------------------------- module Language.Haskell.Syntax ( -- * Modules HsModule(..), HsExportSpec(..), HsImportDecl(..), HsImportSpec(..), HsAssoc(..), -- * Declarations HsDecl(..), HsConDecl(..), HsBangType(..), HsMatch(..), HsRhs(..), HsGuardedRhs(..), HsSafety(..), -- * Class Assertions and Contexts HsQualType(..), HsContext, HsAsst, -- * Types HsType(..), -- * Expressions HsExp(..), HsStmt(..), HsFieldUpdate(..), HsAlt(..), HsGuardedAlts(..), HsGuardedAlt(..), -- * Patterns HsPat(..), HsPatField(..), -- * Literals HsLiteral(..), -- * Variables, Constructors and Operators Module(..), HsQName(..), HsName(..), HsQOp(..), HsOp(..), HsSpecialCon(..), HsCName(..), -- * Builtin names -- ** Modules prelude_mod, main_mod, -- ** Main function of a program main_name, -- ** Constructors unit_con_name, tuple_con_name, list_cons_name, unit_con, tuple_con, -- ** Type constructors unit_tycon_name, fun_tycon_name, list_tycon_name, tuple_tycon_name, unit_tycon, fun_tycon, list_tycon, tuple_tycon, -- * Source coordinates SrcLoc(..), ) where #ifdef __GLASGOW_HASKELL__ import Data.Generics.Basics import Data.Generics.Instances() #endif -- | A position in the source. data SrcLoc = SrcLoc { srcFilename :: String, srcLine :: Int, srcColumn :: Int } #ifdef __GLASGOW_HASKELL__ deriving (Eq,Ord,Show,Typeable,Data) #else deriving (Eq,Ord,Show) #endif -- | The name of a Haskell module. newtype Module = Module String #ifdef __GLASGOW_HASKELL__ deriving (Eq,Ord,Show,Typeable,Data) #else deriving (Eq,Ord,Show) #endif -- | Constructors with special syntax. -- These names are never qualified, and always refer to builtin type or -- data constructors. data HsSpecialCon = HsUnitCon -- ^ unit type and data constructor @()@ | HsListCon -- ^ list type constructor @[]@ | HsFunCon -- ^ function type constructor @->@ | HsTupleCon Int -- ^ /n/-ary tuple type and data -- constructors @(,)@ etc | HsCons -- ^ list data constructor @(:)@ #ifdef __GLASGOW_HASKELL__ deriving (Eq,Ord,Show,Typeable,Data) #else deriving (Eq,Ord,Show) #endif -- | This type is used to represent qualified variables, and also -- qualified constructors. data HsQName = Qual Module HsName -- ^ name qualified with a module name | UnQual HsName -- ^ unqualified name | Special HsSpecialCon -- ^ built-in constructor with special syntax #ifdef __GLASGOW_HASKELL__ deriving (Eq,Ord,Show,Typeable,Data) #else deriving (Eq,Ord,Show) #endif -- | This type is used to represent variables, and also constructors. data HsName = HsIdent String -- ^ /varid/ or /conid/ | HsSymbol String -- ^ /varsym/ or /consym/ #ifdef __GLASGOW_HASKELL__ deriving (Eq,Ord,Show,Typeable,Data) #else deriving (Eq,Ord,Show) #endif -- | Possibly qualified infix operators (/qop/), appearing in expressions. data HsQOp = HsQVarOp HsQName -- ^ variable operator (/qvarop/) | HsQConOp HsQName -- ^ constructor operator (/qconop/) #ifdef __GLASGOW_HASKELL__ deriving (Eq,Ord,Show,Typeable,Data) #else deriving (Eq,Ord,Show) #endif -- | Operators, appearing in @infix@ declarations. data HsOp = HsVarOp HsName -- ^ variable operator (/varop/) | HsConOp HsName -- ^ constructor operator (/conop/) #ifdef __GLASGOW_HASKELL__ deriving (Eq,Ord,Show,Typeable,Data) #else deriving (Eq,Ord,Show) #endif -- | A name (/cname/) of a component of a class or data type in an @import@ -- or export specification. data HsCName = HsVarName HsName -- ^ name of a method or field | HsConName HsName -- ^ name of a data constructor #ifdef __GLASGOW_HASKELL__ deriving (Eq,Ord,Show,Typeable,Data) #else deriving (Eq,Ord,Show) #endif -- | A Haskell source module. data HsModule = HsModule SrcLoc Module (Maybe [HsExportSpec]) [HsImportDecl] [HsDecl] #ifdef __GLASGOW_HASKELL__ deriving (Show,Typeable,Data) #else deriving (Show) #endif -- | Export specification. data HsExportSpec = HsEVar HsQName -- ^ variable | HsEAbs HsQName -- ^ @T@: -- a class or datatype exported abstractly, -- or a type synonym. | HsEThingAll HsQName -- ^ @T(..)@: -- a class exported with all of its methods, or -- a datatype exported with all of its constructors. | HsEThingWith HsQName [HsCName] -- ^ @T(C_1,...,C_n)@: -- a class exported with some of its methods, or -- a datatype exported with some of its constructors. | HsEModuleContents Module -- ^ @module M@: -- re-export a module. #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif -- | Import declaration. data HsImportDecl = HsImportDecl { importLoc :: SrcLoc -- ^ position of the @import@ keyword. , importModule :: Module -- ^ name of the module imported. , importQualified :: Bool -- ^ imported @qualified@? , importAs :: Maybe Module -- ^ optional alias name in an -- @as@ clause. , importSpecs :: Maybe (Bool,[HsImportSpec]) -- ^ optional list of import specifications. -- The 'Bool' is 'True' if the names are excluded -- by @hiding@. } #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif -- | Import specification. data HsImportSpec = HsIVar HsName -- ^ variable | HsIAbs HsName -- ^ @T@: -- the name of a class, datatype or type synonym. | HsIThingAll HsName -- ^ @T(..)@: -- a class imported with all of its methods, or -- a datatype imported with all of its constructors. | HsIThingWith HsName [HsCName] -- ^ @T(C_1,...,C_n)@: -- a class imported with some of its methods, or -- a datatype imported with some of its constructors. #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif -- | Associativity of an operator. data HsAssoc = HsAssocNone -- ^ non-associative operator (declared with @infix@) | HsAssocLeft -- ^ left-associative operator (declared with @infixl@). | HsAssocRight -- ^ right-associative operator (declared with @infixr@) #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif data HsDecl = HsTypeDecl SrcLoc HsName [HsName] HsType | HsDataDecl SrcLoc HsContext HsName [HsName] [HsConDecl] [HsQName] | HsInfixDecl SrcLoc HsAssoc Int [HsOp] | HsNewTypeDecl SrcLoc HsContext HsName [HsName] HsConDecl [HsQName] | HsClassDecl SrcLoc HsContext HsName [HsName] [HsDecl] | HsInstDecl SrcLoc HsContext HsQName [HsType] [HsDecl] | HsDefaultDecl SrcLoc [HsType] | HsTypeSig SrcLoc [HsName] HsQualType | HsFunBind [HsMatch] | HsPatBind SrcLoc HsPat HsRhs {-where-} [HsDecl] | HsForeignImport SrcLoc String HsSafety String HsName HsType | HsForeignExport SrcLoc String String HsName HsType #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif -- | Clauses of a function binding. data HsMatch = HsMatch SrcLoc HsName [HsPat] HsRhs {-where-} [HsDecl] #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif -- | Declaration of a data constructor. data HsConDecl = HsConDecl SrcLoc HsName [HsBangType] -- ^ ordinary data constructor | HsRecDecl SrcLoc HsName [([HsName],HsBangType)] -- ^ record constructor #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif -- | The type of a constructor argument or field, optionally including -- a strictness annotation. data HsBangType = HsBangedTy HsType -- ^ strict component, marked with \"@!@\" | HsUnBangedTy HsType -- ^ non-strict component #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif -- | The right hand side of a function or pattern binding. data HsRhs = HsUnGuardedRhs HsExp -- ^ unguarded right hand side (/exp/) | HsGuardedRhss [HsGuardedRhs] -- ^ guarded right hand side (/gdrhs/) #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif -- | A guarded right hand side @|@ /exp/ @=@ /exp/. -- The first expression will be Boolean-valued. data HsGuardedRhs = HsGuardedRhs SrcLoc HsExp HsExp #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif -- | Safety level for invoking a foreign entity data HsSafety = HsSafe -- ^ call may generate callbacks | HsUnsafe -- ^ call will not generate callbacks #ifdef __GLASGOW_HASKELL__ deriving (Eq,Ord,Show,Typeable,Data) #else deriving (Eq,Ord,Show) #endif -- | A type qualified with a context. -- An unqualified type has an empty context. data HsQualType = HsQualType HsContext HsType #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif -- | Haskell types and type constructors. data HsType = HsTyFun HsType HsType -- ^ function type | HsTyTuple [HsType] -- ^ tuple type | HsTyApp HsType HsType -- ^ application of a type constructor | HsTyVar HsName -- ^ type variable | HsTyCon HsQName -- ^ named type or type constructor #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif type HsContext = [HsAsst] -- | Class assertions. -- In Haskell 98, the argument would be a /tyvar/, but this definition -- allows multiple parameters, and allows them to be /type/s. type HsAsst = (HsQName,[HsType]) -- | /literal/. -- Values of this type hold the abstract value of the literal, not the -- precise string representation used. For example, @10@, @0o12@ and @0xa@ -- have the same representation. data HsLiteral = HsChar Char -- ^ character literal | HsString String -- ^ string literal | HsInt Integer -- ^ integer literal | HsFrac Rational -- ^ floating point literal | HsCharPrim Char -- ^ GHC unboxed character literal | HsStringPrim String -- ^ GHC unboxed string literal | HsIntPrim Integer -- ^ GHC unboxed integer literal | HsFloatPrim Rational -- ^ GHC unboxed float literal | HsDoublePrim Rational -- ^ GHC unboxed double literal #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif -- | Haskell expressions. -- -- /Notes:/ -- -- * Because it is difficult for parsers to distinguish patterns from -- expressions, they typically parse them in the same way and then check -- that they have the appropriate form. Hence the expression type -- includes some forms that are found only in patterns. After these -- checks, these constructors should not be used. -- -- * The parser does not take precedence and associativity into account, -- so it will leave 'HsInfixApp's associated to the left. -- -- * The 'Language.Haskell.Pretty.Pretty' instance for 'HsExp' does not -- add parentheses in printing. data HsExp = HsVar HsQName -- ^ variable | HsCon HsQName -- ^ data constructor | HsLit HsLiteral -- ^ literal constant | HsInfixApp HsExp HsQOp HsExp -- ^ infix application | HsApp HsExp HsExp -- ^ ordinary application | HsNegApp HsExp -- ^ negation expression @-@ /exp/ | HsLambda SrcLoc [HsPat] HsExp -- ^ lambda expression | HsLet [HsDecl] HsExp -- ^ local declarations with @let@ | HsIf HsExp HsExp HsExp -- ^ @if@ /exp/ @then@ /exp/ @else@ /exp/ | HsCase HsExp [HsAlt] -- ^ @case@ /exp/ @of@ /alts/ | HsDo [HsStmt] -- ^ @do@-expression: -- the last statement in the list -- should be an expression. | HsTuple [HsExp] -- ^ tuple expression | HsList [HsExp] -- ^ list expression | HsParen HsExp -- ^ parenthesized expression | HsLeftSection HsExp HsQOp -- ^ left section @(@/exp/ /qop/@)@ | HsRightSection HsQOp HsExp -- ^ right section @(@/qop/ /exp/@)@ | HsRecConstr HsQName [HsFieldUpdate] -- ^ record construction expression | HsRecUpdate HsExp [HsFieldUpdate] -- ^ record update expression | HsEnumFrom HsExp -- ^ unbounded arithmetic sequence, -- incrementing by 1 | HsEnumFromTo HsExp HsExp -- ^ bounded arithmetic sequence, -- incrementing by 1 | HsEnumFromThen HsExp HsExp -- ^ unbounded arithmetic sequence, -- with first two elements given | HsEnumFromThenTo HsExp HsExp HsExp -- ^ bounded arithmetic sequence, -- with first two elements given | HsListComp HsExp [HsStmt] -- ^ list comprehension | HsExpTypeSig SrcLoc HsExp HsQualType -- ^ expression type signature | HsAsPat HsName HsExp -- ^ patterns only | HsWildCard -- ^ patterns only | HsIrrPat HsExp -- ^ patterns only #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif -- | A pattern, to be matched against a value. data HsPat = HsPVar HsName -- ^ variable | HsPLit HsLiteral -- ^ literal constant | HsPNeg HsPat -- ^ negated pattern | HsPInfixApp HsPat HsQName HsPat -- ^ pattern with infix data constructor | HsPApp HsQName [HsPat] -- ^ data constructor and argument -- patterns | HsPTuple [HsPat] -- ^ tuple pattern | HsPList [HsPat] -- ^ list pattern | HsPParen HsPat -- ^ parenthesized pattern | HsPRec HsQName [HsPatField] -- ^ labelled pattern | HsPAsPat HsName HsPat -- ^ @\@@-pattern | HsPWildCard -- ^ wildcard pattern (@_@) | HsPIrrPat HsPat -- ^ irrefutable pattern (@~@) #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif -- | An /fpat/ in a labeled record pattern. data HsPatField = HsPFieldPat HsQName HsPat #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif -- | This type represents both /stmt/ in a @do@-expression, -- and /qual/ in a list comprehension. data HsStmt = HsGenerator SrcLoc HsPat HsExp -- ^ a generator /pat/ @<-@ /exp/ | HsQualifier HsExp -- ^ an /exp/ by itself: in a @do@-expression, -- an action whose result is discarded; -- in a list comprehension, a guard expression | HsLetStmt [HsDecl] -- ^ local bindings #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif -- | An /fbind/ in a labeled record construction or update expression. data HsFieldUpdate = HsFieldUpdate HsQName HsExp #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif -- | An /alt/ in a @case@ expression. data HsAlt = HsAlt SrcLoc HsPat HsGuardedAlts [HsDecl] #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif data HsGuardedAlts = HsUnGuardedAlt HsExp -- ^ @->@ /exp/ | HsGuardedAlts [HsGuardedAlt] -- ^ /gdpat/ #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif -- | A guarded alternative @|@ /exp/ @->@ /exp/. -- The first expression will be Boolean-valued. data HsGuardedAlt = HsGuardedAlt SrcLoc HsExp HsExp #ifdef __GLASGOW_HASKELL__ deriving (Eq,Show,Typeable,Data) #else deriving (Eq,Show) #endif ----------------------------------------------------------------------------- -- Builtin names. prelude_mod, main_mod :: Module prelude_mod = Module "Prelude" main_mod = Module "Main" main_name :: HsName main_name = HsIdent "main" unit_con_name :: HsQName unit_con_name = Special HsUnitCon tuple_con_name :: Int -> HsQName tuple_con_name i = Special (HsTupleCon (i+1)) list_cons_name :: HsQName list_cons_name = Special HsCons unit_con :: HsExp unit_con = HsCon unit_con_name tuple_con :: Int -> HsExp tuple_con i = HsCon (tuple_con_name i) unit_tycon_name, fun_tycon_name, list_tycon_name :: HsQName unit_tycon_name = unit_con_name fun_tycon_name = Special HsFunCon list_tycon_name = Special HsListCon tuple_tycon_name :: Int -> HsQName tuple_tycon_name i = tuple_con_name i unit_tycon, fun_tycon, list_tycon :: HsType unit_tycon = HsTyCon unit_tycon_name fun_tycon = HsTyCon fun_tycon_name list_tycon = HsTyCon list_tycon_name tuple_tycon :: Int -> HsType tuple_tycon i = HsTyCon (tuple_tycon_name i) haskell-src-1.0.2.0/Language/Haskell/ParseUtils.hs0000644000000000000000000003104712461020017020001 0ustar0000000000000000-- #hide ----------------------------------------------------------------------------- -- | -- Module : Language.Haskell.ParseUtils -- Copyright : (c) The GHC Team, 1997-2000 -- License : BSD-style (see the file libraries/base/LICENSE) -- -- Maintainer : libraries@haskell.org -- Stability : experimental -- Portability : portable -- -- Utilities for the Haskell parser. -- ----------------------------------------------------------------------------- module Language.Haskell.ParseUtils ( splitTyConApp -- HsType -> P (HsName,[HsType]) , mkRecConstrOrUpdate -- HsExp -> [HsFieldUpdate] -> P HsExp , checkPrec -- Integer -> P Int , checkContext -- HsType -> P HsContext , checkAssertion -- HsType -> P HsAsst , checkDataHeader -- HsQualType -> P (HsContext,HsName,[HsName]) , checkClassHeader -- HsQualType -> P (HsContext,HsName,[HsName]) , checkInstHeader -- HsQualType -> P (HsContext,HsQName,[HsType]) , checkPattern -- HsExp -> P HsPat , checkExpr -- HsExp -> P HsExp , checkValDef -- SrcLoc -> HsExp -> HsRhs -> [HsDecl] -> P HsDecl , checkClassBody -- [HsDecl] -> P [HsDecl] , checkUnQual -- HsQName -> P HsName , checkRevDecls -- [HsDecl] -> P [HsDecl] ) where import Language.Haskell.Syntax import Language.Haskell.ParseMonad import Language.Haskell.Pretty splitTyConApp :: HsType -> P (HsName,[HsType]) splitTyConApp t0 = split t0 [] where split :: HsType -> [HsType] -> P (HsName,[HsType]) split (HsTyApp t u) ts = split t (u:ts) split (HsTyCon (UnQual t)) ts = return (t,ts) split _ _ = fail "Illegal data/newtype declaration" ----------------------------------------------------------------------------- -- Various Syntactic Checks checkContext :: HsType -> P HsContext checkContext (HsTyTuple ts) = mapM checkAssertion ts checkContext t = do c <- checkAssertion t return [c] -- Changed for multi-parameter type classes checkAssertion :: HsType -> P HsAsst checkAssertion = checkAssertion' [] where checkAssertion' ts (HsTyCon c) = return (c,ts) checkAssertion' ts (HsTyApp a t) = checkAssertion' (t:ts) a checkAssertion' _ _ = fail "Illegal class assertion" checkDataHeader :: HsQualType -> P (HsContext,HsName,[HsName]) checkDataHeader (HsQualType cs t) = do (c,ts) <- checkSimple "data/newtype" t [] return (cs,c,ts) checkClassHeader :: HsQualType -> P (HsContext,HsName,[HsName]) checkClassHeader (HsQualType cs t) = do (c,ts) <- checkSimple "class" t [] return (cs,c,ts) checkSimple :: String -> HsType -> [HsName] -> P ((HsName,[HsName])) checkSimple kw (HsTyApp l (HsTyVar a)) xs = checkSimple kw l (a:xs) checkSimple _kw (HsTyCon (UnQual t)) xs = return (t,xs) checkSimple kw _ _ = fail ("Illegal " ++ kw ++ " declaration") checkInstHeader :: HsQualType -> P (HsContext,HsQName,[HsType]) checkInstHeader (HsQualType cs t) = do (c,ts) <- checkInsts t [] return (cs,c,ts) checkInsts :: HsType -> [HsType] -> P ((HsQName,[HsType])) checkInsts (HsTyApp l t) ts = checkInsts l (t:ts) checkInsts (HsTyCon c) ts = return (c,ts) checkInsts _ _ = fail "Illegal instance declaration" ----------------------------------------------------------------------------- -- Checking Patterns. -- We parse patterns as expressions and check for valid patterns below, -- converting the expression into a pattern at the same time. checkPattern :: HsExp -> P HsPat checkPattern e = checkPat e [] checkPat :: HsExp -> [HsPat] -> P HsPat checkPat (HsCon c) args = return (HsPApp c args) checkPat (HsApp f x) args = do x' <- checkPat x [] checkPat f (x':args) checkPat e [] = case e of HsVar (UnQual x) -> return (HsPVar x) HsLit l -> return (HsPLit l) HsInfixApp l op r -> do l' <- checkPat l [] r' <- checkPat r [] case op of HsQConOp c -> return (HsPInfixApp l' c r') _ -> patFail HsTuple es -> do ps <- mapM (\e' -> checkPat e' []) es return (HsPTuple ps) HsList es -> do ps <- mapM (\e' -> checkPat e' []) es return (HsPList ps) HsParen e' -> do p <- checkPat e' [] return (HsPParen p) HsAsPat n e' -> do p <- checkPat e' [] return (HsPAsPat n p) HsWildCard -> return HsPWildCard HsIrrPat e' -> do p <- checkPat e' [] return (HsPIrrPat p) HsRecConstr c fs -> do fs' <- mapM checkPatField fs return (HsPRec c fs') HsNegApp (HsLit l) -> return (HsPNeg (HsPLit l)) _ -> patFail checkPat _ _ = patFail checkPatField :: HsFieldUpdate -> P HsPatField checkPatField (HsFieldUpdate n e) = do p <- checkPat e [] return (HsPFieldPat n p) patFail :: P a patFail = fail "Parse error in pattern" ----------------------------------------------------------------------------- -- Check Expression Syntax checkExpr :: HsExp -> P HsExp checkExpr e = case e of HsVar _ -> return e HsCon _ -> return e HsLit _ -> return e HsInfixApp e1 op e2 -> check2Exprs e1 e2 (flip HsInfixApp op) HsApp e1 e2 -> check2Exprs e1 e2 HsApp HsNegApp e1 -> check1Expr e1 HsNegApp HsLambda loc ps e1 -> check1Expr e1 (HsLambda loc ps) HsLet bs e1 -> check1Expr e1 (HsLet bs) HsIf e1 e2 e3 -> check3Exprs e1 e2 e3 HsIf HsCase e1 alts -> do alts' <- mapM checkAlt alts e1' <- checkExpr e1 return (HsCase e1' alts') HsDo stmts -> do stmts' <- mapM checkStmt stmts return (HsDo stmts') HsTuple es -> checkManyExprs es HsTuple HsList es -> checkManyExprs es HsList HsParen e1 -> check1Expr e1 HsParen HsLeftSection e1 op -> check1Expr e1 (flip HsLeftSection op) HsRightSection op e1 -> check1Expr e1 (HsRightSection op) HsRecConstr c fields -> do fields' <- mapM checkField fields return (HsRecConstr c fields') HsRecUpdate e1 fields -> do fields' <- mapM checkField fields e1' <- checkExpr e1 return (HsRecUpdate e1' fields') HsEnumFrom e1 -> check1Expr e1 HsEnumFrom HsEnumFromTo e1 e2 -> check2Exprs e1 e2 HsEnumFromTo HsEnumFromThen e1 e2 -> check2Exprs e1 e2 HsEnumFromThen HsEnumFromThenTo e1 e2 e3 -> check3Exprs e1 e2 e3 HsEnumFromThenTo HsListComp e1 stmts -> do stmts' <- mapM checkStmt stmts e1' <- checkExpr e1 return (HsListComp e1' stmts') HsExpTypeSig loc e1 ty -> do e1' <- checkExpr e1 return (HsExpTypeSig loc e1' ty) _ -> fail "Parse error in expression" -- type signature for polymorphic recursion!! check1Expr :: HsExp -> (HsExp -> a) -> P a check1Expr e1 f = do e1' <- checkExpr e1 return (f e1') check2Exprs :: HsExp -> HsExp -> (HsExp -> HsExp -> a) -> P a check2Exprs e1 e2 f = do e1' <- checkExpr e1 e2' <- checkExpr e2 return (f e1' e2') check3Exprs :: HsExp -> HsExp -> HsExp -> (HsExp -> HsExp -> HsExp -> a) -> P a check3Exprs e1 e2 e3 f = do e1' <- checkExpr e1 e2' <- checkExpr e2 e3' <- checkExpr e3 return (f e1' e2' e3') checkManyExprs :: [HsExp] -> ([HsExp] -> a) -> P a checkManyExprs es f = do es' <- mapM checkExpr es return (f es') checkAlt :: HsAlt -> P HsAlt checkAlt (HsAlt loc p galts bs) = do galts' <- checkGAlts galts return (HsAlt loc p galts' bs) checkGAlts :: HsGuardedAlts -> P HsGuardedAlts checkGAlts (HsUnGuardedAlt e) = check1Expr e HsUnGuardedAlt checkGAlts (HsGuardedAlts galts) = do galts' <- mapM checkGAlt galts return (HsGuardedAlts galts') checkGAlt :: HsGuardedAlt -> P HsGuardedAlt checkGAlt (HsGuardedAlt loc e1 e2) = check2Exprs e1 e2 (HsGuardedAlt loc) checkStmt :: HsStmt -> P HsStmt checkStmt (HsGenerator loc p e) = check1Expr e (HsGenerator loc p) checkStmt (HsQualifier e) = check1Expr e HsQualifier checkStmt s@(HsLetStmt _) = return s checkField :: HsFieldUpdate -> P HsFieldUpdate checkField (HsFieldUpdate n e) = check1Expr e (HsFieldUpdate n) ----------------------------------------------------------------------------- -- Check Equation Syntax checkValDef :: SrcLoc -> HsExp -> HsRhs -> [HsDecl] -> P HsDecl checkValDef srcloc lhs rhs whereBinds = case isFunLhs lhs [] of Just (f,es) -> do ps <- mapM checkPattern es return (HsFunBind [HsMatch srcloc f ps rhs whereBinds]) Nothing -> do lhs' <- checkPattern lhs return (HsPatBind srcloc lhs' rhs whereBinds) -- A variable binding is parsed as an HsPatBind. isFunLhs :: HsExp -> [HsExp] -> Maybe (HsName, [HsExp]) isFunLhs (HsInfixApp l (HsQVarOp (UnQual op)) r) es = Just (op, l:r:es) isFunLhs (HsApp (HsVar (UnQual f)) e) es = Just (f, e:es) isFunLhs (HsApp (HsParen f) e) es = isFunLhs f (e:es) isFunLhs (HsApp f e) es = isFunLhs f (e:es) isFunLhs _ _ = Nothing ----------------------------------------------------------------------------- -- In a class or instance body, a pattern binding must be of a variable. checkClassBody :: [HsDecl] -> P [HsDecl] checkClassBody decls = do mapM_ checkMethodDef decls return decls checkMethodDef :: HsDecl -> P () checkMethodDef (HsPatBind _ (HsPVar _) _ _) = return () checkMethodDef (HsPatBind loc _ _ _) = fail "illegal method definition" `atSrcLoc` loc checkMethodDef _ = return () ----------------------------------------------------------------------------- -- Check that an identifier or symbol is unqualified. -- For occasions when doing this in the grammar would cause conflicts. checkUnQual :: HsQName -> P HsName checkUnQual (Qual _ _) = fail "Illegal qualified name" checkUnQual (UnQual n) = return n checkUnQual (Special _) = fail "Illegal special name" ----------------------------------------------------------------------------- -- Miscellaneous utilities checkPrec :: Integer -> P Int checkPrec i | 0 <= i && i <= 9 = return (fromInteger i) checkPrec i | otherwise = fail ("Illegal precedence " ++ show i) mkRecConstrOrUpdate :: HsExp -> [HsFieldUpdate] -> P HsExp mkRecConstrOrUpdate (HsCon c) fs = return (HsRecConstr c fs) mkRecConstrOrUpdate e fs@(_:_) = return (HsRecUpdate e fs) mkRecConstrOrUpdate _ _ = fail "Empty record update" ----------------------------------------------------------------------------- -- Reverse a list of declarations, merging adjacent HsFunBinds of the -- same name and checking that their arities match. checkRevDecls :: [HsDecl] -> P [HsDecl] checkRevDecls = mergeFunBinds [] where mergeFunBinds revDs [] = return revDs mergeFunBinds revDs (HsFunBind ms1@(HsMatch _ name ps _ _:_):ds1) = mergeMatches ms1 ds1 where arity = length ps mergeMatches ms' (HsFunBind ms@(HsMatch loc name' ps' _ _:_):ds) | name' == name = if length ps' /= arity then fail ("arity mismatch for '" ++ prettyPrint name ++ "'") `atSrcLoc` loc else mergeMatches (ms++ms') ds mergeMatches ms' ds = mergeFunBinds (HsFunBind ms':revDs) ds mergeFunBinds revDs (d:ds) = mergeFunBinds (d:revDs) ds