diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,77 @@ + [1]Return to the main page + +Licence document for the haskell-harp package + + -------------------------------------------------------------------------- + + Copyright 2004, Niklas Broberg. 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. + + This software is provided by the copyright holders "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 copyright holders 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. + + -------------------------------------------------------------------------- + + This library is based on code from the Glasgow Haskell Compiler, which is + usable and redistributable under the following licence: + + The Glasgow Haskell Compiler License + + Copyright 2002, 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. + + -------------------------------------------------------------------------- + + [2]Return to the main page + +References + + Visible links + 1. http://www.cs.chalmers.se/~d00nibro/harp/index.html + 2. http://www.cs.chalmers.se/~d00nibro/harp/index.html diff --git a/Language/Haskell/Hsx.hs b/Language/Haskell/Hsx.hs new file mode 100644 --- /dev/null +++ b/Language/Haskell/Hsx.hs @@ -0,0 +1,27 @@ +module Language.Haskell.Hsx ( + module Language.Haskell.Hsx.Syntax + , module Language.Haskell.Hsx.Build + , module Language.Haskell.Hsx.Parser + , module Language.Haskell.Hsx.Pretty + , module Language.Haskell.Hsx.Transform + , parseFileContents + , parseFileContentsWithMode + , parseFile + ) where + +import Language.Haskell.Hsx.Build +import Language.Haskell.Hsx.Syntax +import Language.Haskell.Hsx.Parser +import Language.Haskell.Hsx.Pretty +import Language.Haskell.Hsx.Transform + +parseFile :: FilePath -> IO (ParseResult HsModule) +parseFile fp = readFile fp >>= (return . parseFileContentsWithMode (ParseMode fp)) + +parseFileContents :: String -> ParseResult HsModule +parseFileContents = parseFileContentsWithMode defaultParseMode + +parseFileContentsWithMode :: ParseMode -> String -> ParseResult HsModule +parseFileContentsWithMode p rawStr = + let cleanStr = unlines [ s | s@(c:_) <- lines rawStr, c /= '#' ] + in parseModuleWithMode p cleanStr diff --git a/Language/Haskell/Hsx/Build.hs b/Language/Haskell/Hsx/Build.hs new file mode 100644 --- /dev/null +++ b/Language/Haskell/Hsx/Build.hs @@ -0,0 +1,235 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Language.Haskell.Hsx.Build +-- Original : Language.Haskell.Syntax +-- Copyright : (c) The GHC Team, 1997-2000, +-- (c) Niklas Broberg 2004 +-- License : BSD-style (see the file LICENSE.txt) +-- +-- Maintainer : Niklas Broberg, d00nibro@dtek.chalmers.se +-- Stability : experimental +-- Portability : portable +-- +----------------------------------------------------------------------------- + +module Language.Haskell.Hsx.Build ( + + -- * Syntax building functions + name, -- :: String -> HsName + sym, -- :: String -> HsName + var, -- :: HsName -> HsExp + op, -- :: HsName -> HsQOp + qvar, -- :: Module -> HsName -> HsExp + pvar, -- :: HsName -> HsPat + app, -- :: HsExp -> HsExp -> HsExp + infixApp, -- :: HsExp -> HsQOp -> HsExp -> HsExp + appFun, -- :: HsExp -> [HsExp] -> HsExp + pApp, -- :: HsName -> [HsPat] -> HsPat + tuple, -- :: [HsExp] -> HsExp + pTuple, -- :: [HsPat] -> HsPat + varTuple, -- :: [HsName] -> HsExp + pvarTuple, -- :: [HsName] -> HsPat + function, -- :: String -> HsExp + strE, -- :: String -> HsExp + charE, -- :: Char -> HsExp + intE, -- :: Integer -> HsExp + strP, -- :: String -> HsPat + charP, -- :: Char -> HsPat + intP, -- :: Integer -> HsPat + doE, -- :: [HsStmt] -> HsExp + lamE, -- :: SrcLoc -> [HsPat] -> HsExp -> HsExp + letE, -- :: [HsDecl] -> HsExp -> HsExp + caseE, -- :: HsExp -> [HsAlt] -> HsExp + alt, -- :: SrcLoc -> HsPat -> HsExp -> HsAlt + altGW, -- :: SrcLoc -> HsPat -> [HsStmt] -> HsExp -> HsBinds -> HsAlt + listE, -- :: [HsExp] -> HsExp + eList, -- :: HsExp + peList, -- :: HsPat + paren, -- :: HsExp -> HsExp + pParen, -- :: HsPat -> HsPat + qualStmt, -- :: HsExp -> HsStmt + genStmt, -- :: SrcLoc -> HsPat -> HsExp -> HsStmt + letStmt, -- :: [HsDecl] -> HsStmt + binds, -- :: [HsDecl] -> HsBinds + noBinds, -- :: HsBinds + wildcard, -- :: HsPat + genNames, -- :: String -> Int -> [HsName] + + -- * More advanced building + sfun, -- :: SrcLoc -> HsName -> [HsName] -> HsRhs -> HsBinds -> HsDecl + simpleFun, -- :: SrcLoc -> HsName -> HsName -> HsExp -> HsDecl + patBind, -- :: SrcLoc -> HsPat -> HsExp -> HsDecl + patBindWhere, -- :: SrcLoc -> HsPat -> HsExp -> [HsDecl] -> HsDecl + nameBind, -- :: SrcLoc -> HsName -> HsExp -> HsDecl + metaFunction, -- :: String -> [HsExp] -> HsExp + metaConPat -- :: String -> [HsPat] -> HsPat + ) where + +import Language.Haskell.Hsx.Syntax + +----------------------------------------------------------------------------- +-- Help functions for Abstract syntax + +name :: String -> HsName +name = HsIdent + +sym :: String -> HsName +sym = HsSymbol + +var :: HsName -> HsExp +var = HsVar . UnQual + +op :: HsName -> HsQOp +op = HsQVarOp . UnQual + +qvar :: Module -> HsName -> HsExp +qvar m n = HsVar $ Qual m n + +pvar :: HsName -> HsPat +pvar = HsPVar + +app :: HsExp -> HsExp -> HsExp +app = HsApp + +infixApp :: HsExp -> HsQOp -> HsExp -> HsExp +infixApp = HsInfixApp + +appFun :: HsExp -> [HsExp] -> HsExp +appFun f [] = f +appFun f (a:as) = appFun (app f a) as + +pApp :: HsName -> [HsPat] -> HsPat +pApp n ps = HsPApp (UnQual n) ps + +tuple :: [HsExp] -> HsExp +tuple = HsTuple + +pTuple :: [HsPat] -> HsPat +pTuple = HsPTuple + +varTuple :: [HsName] -> HsExp +varTuple ns = tuple $ map var ns + +pvarTuple :: [HsName] -> HsPat +pvarTuple ns = pTuple $ map pvar ns + +function :: String -> HsExp +function = var . HsIdent + +strE :: String -> HsExp +strE = HsLit . HsString + +charE :: Char -> HsExp +charE = HsLit . HsChar + +intE :: Integer -> HsExp +intE = HsLit . HsInt + +strP :: String -> HsPat +strP = HsPLit . HsString + +charP :: Char -> HsPat +charP = HsPLit . HsChar + +intP :: Integer -> HsPat +intP = HsPLit . HsInt + +doE :: [HsStmt] -> HsExp +doE = HsDo + +lamE :: SrcLoc -> [HsPat] -> HsExp -> HsExp +lamE = HsLambda + +letE :: [HsDecl] -> HsExp -> HsExp +letE ds e = HsLet (binds ds) e + +caseE :: HsExp -> [HsAlt] -> HsExp +caseE = HsCase + +alt :: SrcLoc -> HsPat -> HsExp -> HsAlt +alt s p e = HsAlt s p (HsUnGuardedAlt e) noBinds + +altGW :: SrcLoc -> HsPat -> [HsStmt] -> HsExp -> HsBinds -> HsAlt +altGW s p gs e w = HsAlt s p (gAlt s gs e) w + +unGAlt :: HsExp -> HsGuardedAlts +unGAlt = HsUnGuardedAlt + +gAlts :: SrcLoc -> [([HsStmt],HsExp)] -> HsGuardedAlts +gAlts s as = HsGuardedAlts $ map (\(gs,e) -> HsGuardedAlt s gs e) as + +gAlt :: SrcLoc -> [HsStmt] -> HsExp -> HsGuardedAlts +gAlt s gs e = gAlts s [(gs,e)] + +listE :: [HsExp] -> HsExp +listE = HsList + +eList :: HsExp +eList = HsList [] + +peList :: HsPat +peList = HsPList [] + +paren :: HsExp -> HsExp +paren = HsParen + +pParen :: HsPat -> HsPat +pParen = HsPParen + +qualStmt :: HsExp -> HsStmt +qualStmt = HsQualifier + +genStmt :: SrcLoc -> HsPat -> HsExp -> HsStmt +genStmt = HsGenerator + +letStmt :: [HsDecl] -> HsStmt +letStmt ds = HsLetStmt $ binds ds + +binds :: [HsDecl] -> HsBinds +binds = HsBDecls + +noBinds :: HsBinds +noBinds = binds [] + +wildcard :: HsPat +wildcard = HsPWildCard + +genNames :: String -> Int -> [HsName] +genNames s k = [ HsIdent $ s ++ show i | i <- [1..k] ] + +------------------------------------------------------------------------------- +-- Some more specialised help functions + +-- | A function with a single "match" +sfun :: SrcLoc -> HsName -> [HsName] -> HsRhs -> HsBinds -> HsDecl +sfun s f pvs rhs bs = HsFunBind [HsMatch s f (map pvar pvs) rhs bs] + +-- | A function with a single "match", a single argument, no guards +-- and no where declarations +simpleFun :: SrcLoc -> HsName -> HsName -> HsExp -> HsDecl +simpleFun s f a e = let rhs = HsUnGuardedRhs e + in sfun s f [a] rhs noBinds + +-- | A pattern bind where the pattern is a variable, and where +-- there are no guards and no 'where' clause. +patBind :: SrcLoc -> HsPat -> HsExp -> HsDecl +patBind s p e = let rhs = HsUnGuardedRhs e + in HsPatBind s p rhs noBinds + +patBindWhere :: SrcLoc -> HsPat -> HsExp -> [HsDecl] -> HsDecl +patBindWhere s p e ds = let rhs = HsUnGuardedRhs e + in HsPatBind s p rhs (binds ds) + +nameBind :: SrcLoc -> HsName -> HsExp -> HsDecl +nameBind s n e = patBind s (pvar n) e + +-- meta-level functions, i.e. functions that represent functions, +-- and that take arguments representing arguments... whew! +metaFunction :: String -> [HsExp] -> HsExp +metaFunction s es = mf s (reverse es) + where mf s [] = var $ name s + mf s (e:es) = app (mf s es) e + + +metaConPat :: String -> [HsPat] -> HsPat +metaConPat s ps = pApp (name s) ps diff --git a/Language/Haskell/Hsx/Lexer.hs b/Language/Haskell/Hsx/Lexer.hs new file mode 100644 --- /dev/null +++ b/Language/Haskell/Hsx/Lexer.hs @@ -0,0 +1,808 @@ +-- #hide +----------------------------------------------------------------------------- +-- | +-- Module : Language.Haskell.Hsx.Lexer +-- Original : Language.Haskell.Lexer +-- Copyright : (c) The GHC Team, 1997-2000 +-- (c) Niklas Broberg, 2004 +-- License : BSD-style (see the file LICENSE.txt) +-- +-- Maintainer : Niklas Broberg, d00nibro@dtek.chalmers.se +-- Stability : experimental +-- Portability : portable +-- +-- Lexer for Haskell, with some extensions. +-- +----------------------------------------------------------------------------- + +-- 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.Hsx.Lexer (Token(..), lexer) where + +import Language.Haskell.Hsx.ParseMonad + +import Data.Char +import Data.Ratio + +data Token + = VarId String + | QVarId (String,String) + | IDupVarId (String) -- duplicable implicit parameter + | ILinVarId (String) -- linear implicit parameter + | ConId String + | QConId (String,String) + | DVarId [String] -- to enable varid's with '-' in them + | VarSym String + | ConSym String + | QVarSym (String,String) + | QConSym (String,String) + | IntTok Integer + | FloatTok Rational + | Character Char + | StringTok String + +-- Symbols + + | LeftParen + | RightParen + | LeftHashParen + | RightHashParen + | SemiColon + | LeftCurly + | RightCurly + | VRightCurly -- a virtual close brace + | LeftSquare + | RightSquare + | Comma + | Underscore + | BackQuote + +-- Reserved operators + + | Dot -- reserved for use with 'forall x . x' + | DotDot + | Colon + | DoubleColon + | Equals + | Backslash + | Bar + | LeftArrow + | RightArrow + | At + | Tilde + | DoubleArrow + | Minus + | Exclamation + +-- Template Haskell + | THExpQuote -- [| or [e| + | THPatQuote -- [p| + | THDecQuote -- [d| + | THTypQuote -- [t| + | THCloseQuote -- |] + | THIdEscape (String) -- $x + | THParenEscape -- $( + | THReifyType + | THReifyDecl + | THReifyFixity + +-- HaRP + | RPOpen -- [/ + | RPClose -- /] + | RPSeqOpen -- (/ + | RPSeqClose -- /) + | RPStar -- * + | RPStarG -- *! + | RPOpt -- ? + | RPOptG -- ?! + | RPPlus -- + + | RPPlusG -- +! + | RPEither -- | + | RPCAt -- @: + +-- Hsx + | XCodeTagOpen -- <% + | XCodeTagClose -- %> + | XStdTagOpen -- < + | XStdTagClose -- > + | XCloseTagOpen -- + | XPcdata String + +-- Reserved Ids + + | KW_As + | KW_Case + | KW_Class + | KW_Data + | KW_Default + | KW_Deriving + | KW_DLet -- implictit parameter binding + | KW_Do + | KW_MDo + | KW_Else + | KW_Forall -- universal/existential types + | KW_Hiding + | 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 + | KW_With -- implicit parameter binding + | KW_Qualified + + -- FFI + | KW_Foreign + | KW_Export + | KW_Safe + | KW_Unsafe + | KW_Threadsafe + | KW_StdCall + | KW_CCall + + | EOF + deriving (Eq,Show) + +reserved_ops :: [(String,Token)] +reserved_ops = [ + ( ".", Dot ), + ( "..", 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 ), + ( "dlet", KW_DLet ), -- implicit parameters (hugs) + ( "do", KW_Do ), + ( "else", KW_Else ), + ( "forall", KW_Forall ), -- universal/existential quantification + ( "if", KW_If ), + ( "import", KW_Import ), + ( "in", KW_In ), + ( "infix", KW_Infix ), + ( "infixl", KW_InfixL ), + ( "infixr", KW_InfixR ), + ( "instance", KW_Instance ), + ( "let", KW_Let ), + ( "mdo", KW_MDo ), + ( "module", KW_Module ), + ( "newtype", KW_NewType ), + ( "of", KW_Of ), + ( "then", KW_Then ), + ( "type", KW_Type ), + ( "where", KW_Where ), + ( "with", KW_With ), -- implicit parameters + +-- Template Haskell + ( "reifyDecl", THReifyDecl ), + ( "reifyType", THReifyType ), + ( "reifyFixity", THReifyFixity ), + +-- FFI + ( "foreign", KW_Foreign ) + ] + + +special_varids :: [(String,Token)] +special_varids = [ + ( "as", KW_As ), + ( "qualified", KW_Qualified ), + ( "hiding", KW_Hiding ), + +-- FFI + ( "export", KW_Export), + ( "safe", KW_Safe), + ( "unsafe", KW_Unsafe), + ( "threadsafe", KW_Threadsafe), + ( "stdcall", KW_StdCall), + ( "ccall", KW_CCall) + ] + +isIdent, isHSymbol :: Char -> Bool +isIdent c = isAlpha c || isDigit c || c == '\'' || c == '_' +isHSymbol c = elem c ":!#$%&*+./<=>?@\\^|-~" + +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, ws) <- lexWhiteSpace bol + -- take care of whitespace in PCDATA + ec <- getExtContext + case ec of + -- if there was no linebreak, and we are lexing PCDATA, + -- then we want to care about the whitespace + Just ChildCtxt | not bol && ws -> return $ XPcdata " " + _ -> do startToken + if bol then lexBOL else lexToken + +lexWhiteSpace :: Bool -> Lex a (Bool, Bool) +lexWhiteSpace bol = do + s <- getInput + case s of + '{':'-':_ -> do + discard 2 + bol <- lexNestedComment bol + (bol, _) <- lexWhiteSpace bol + return (bol, True) + '-':'-':s | all (== '-') (takeWhile isHSymbol s) -> do + lexWhile (== '-') + lexWhile (/= '\n') + lexNewline + lexWhiteSpace True + return (True, True) + '\n':_ -> do + lexNewline + lexWhiteSpace True + return (True, True) + '\t':_ -> do + lexTab + (bol, _) <- lexWhiteSpace bol + return (bol, True) + c:_ | isSpace c -> do + discard 1 + (bol, _) <- lexWhiteSpace bol + return (bol, True) + _ -> return (bol, False) + +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 + ec <- getExtContext + case ec of + Just HarpCtxt -> lexHarpToken + Just TagCtxt -> lexTagCtxt + Just CloseTagCtxt -> lexCloseTagCtxt + Just ChildCtxt -> lexChildCtxt + Just CodeTagCtxt -> lexCodeTagCtxt + _ -> lexStdToken + + +lexChildCtxt :: Lex a Token +lexChildCtxt = do + s <- getInput + case s of + '<':'%':_ -> do discard 2 + pushExtContextL CodeTagCtxt + return XCodeTagOpen + '<':'/':_ -> do discard 2 + popExtContextL "lexChildCtxt" + pushExtContextL CloseTagCtxt + return XCloseTagOpen + '<':_ -> do discard 1 + pushExtContextL TagCtxt + return XStdTagOpen + '[':'/':_ -> do discard 2 + pushExtContextL HarpCtxt + return RPOpen + _ -> lexPCDATA + + +lexPCDATA :: Lex a Token +lexPCDATA = do + s <- getInput + case s of + [] -> return EOF + _ -> case s of + '\n':_ -> do + x <- lexNewline >> lexPCDATA + case x of + XPcdata p -> return $ XPcdata $ '\n':p + EOF -> return EOF + '<':_ -> return $ XPcdata "" + '[':'/':_ -> return $ XPcdata "" + '[':s' -> do discard 1 + pcd <- lexPCDATA + case pcd of + XPcdata pcd' -> return $ XPcdata $ '[':pcd' + EOF -> return EOF + _ -> do let pcd = takeWhile (\c -> not $ elem c "<[\n") s + l = length pcd + discard l + x <- lexPCDATA + case x of + XPcdata pcd' -> return $ XPcdata $ pcd ++ pcd' + EOF -> return EOF + + +lexCodeTagCtxt :: Lex a Token +lexCodeTagCtxt = do + s <- getInput + case s of + '%':'>':_ -> do discard 2 + popExtContextL "lexCodeTagContext" + return XCodeTagClose + _ -> lexStdToken + +lexCloseTagCtxt :: Lex a Token +lexCloseTagCtxt = do + s <- getInput + case s of + '>':_ -> do discard 1 + popExtContextL "lexCloseTagCtxt" + return XStdTagClose + _ -> lexStdToken + +lexTagCtxt :: Lex a Token +lexTagCtxt = do + s <- getInput + case s of + '/':'>':_ -> do discard 2 + popExtContextL "lexTagCtxt: Empty tag" + return XEmptyTagClose + '>':_ -> do discard 1 + popExtContextL "lexTagCtxt: Standard tag" + pushExtContextL ChildCtxt + return XStdTagClose + _ -> lexStdToken + +lexHarpToken :: Lex a Token +lexHarpToken = do + s <- getInput + case s of + '[':'/':_ -> do discard 2 + pushExtContextL HarpCtxt + return RPOpen + '/':']':_ -> do discard 2 + popExtContextL "lexHarpToken" + return RPClose + '(':'/':_ -> do discard 2 + return RPSeqOpen + '/':')':_ -> do discard 2 + return RPSeqClose + '*':'!':_ -> do discard 2 + return RPStarG + '*':_ -> do discard 1 + return RPStar + '+':'!':_ -> do discard 2 + return RPPlusG + '+':_ -> do discard 1 + return RPPlus + '|':_ -> do discard 1 + return RPEither + '?':'!':_ -> do discard 2 + return RPOptG + '?':_ -> do discard 1 + return RPOpt + '@':':':_ -> do discard 2 + return RPCAt + _ -> lexStdToken + +lexStdToken :: Lex a Token +lexStdToken = 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) + + -- implicit parameters + '?':c:_ | isLower c -> do + discard 1 + id <- lexWhile isIdent + return $ IDupVarId id + + '%':c:_ | isLower c -> do + discard 1 + id <- lexWhile isIdent + return $ ILinVarId id + -- end implicit parameters + + -- harp + '[':'/':_ -> do + discard 2 + pushExtContextL HarpCtxt + return RPOpen + + -- template haskell + '[':'|':_ -> do + discard 2 + return $ THExpQuote + + '[':c:'|':_ | c == 'e' -> do + discard 3 + return $ THExpQuote + | c == 'p' -> do + discard 3 + return THPatQuote + | c == 'd' -> do + discard 3 + return THDecQuote + | c == 't' -> do + discard 3 + return THTypQuote + + '|':']':_ -> do discard 2 + return THCloseQuote + + '$':c:_ | isLower c -> do + discard 1 + id <- lexWhile isIdent + return $ THIdEscape id + | c == '(' -> do + discard 2 + return THParenEscape + -- end template haskell + + -- hsx + '<':'%':_ -> do discard 2 + pushExtContextL CodeTagCtxt + return XCodeTagOpen + '<':c:_ | isAlpha c -> do discard 1 + pushExtContextL TagCtxt + return XStdTagOpen + -- end hsx + + '(':'#':_ -> do discard 2 >> return LeftHashParen + + '#':')':_ -> do discard 2 >> return RightHashParen + + c:_ | isDigit c -> lexDecimalOrFloat + + | isUpper c -> lexConIdOrQual "" + + | isLower c || c == '_' -> do + idents <- lexIdents + case idents of + [ident] -> return $ case lookup ident (reserved_ids ++ special_varids) of + Just keyword -> keyword + Nothing -> VarId ident + _ -> return $ DVarId idents + + | isHSymbol c -> do + sym <- lexWhile isHSymbol + 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 "lexStdToken" + return RightCurly + + '\'' -> do + c2 <- lexChar + matchChar '\'' "Improperly terminated character constant" + return (Character c2) + + '"' -> lexString + + _ -> fail ("Illegal character \'" ++ show c ++ "\'\n") + + where lexIdents :: Lex a [String] + lexIdents = do + ident <- lexWhile isIdent + s <- getInput + case s of + '-':c:_ | isIdent c -> do + discard 1 + idents <- lexIdents + return $ ident : idents + _ -> return [ident] + + + +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' + + | isHSymbol c -> do -- qualified symbol? + discard 1 + sym <- lexWhile isHSymbol + 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 <= 0x01FFFF = 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) diff --git a/Language/Haskell/Hsx/ParseMonad.hs b/Language/Haskell/Hsx/ParseMonad.hs new file mode 100644 --- /dev/null +++ b/Language/Haskell/Hsx/ParseMonad.hs @@ -0,0 +1,292 @@ +-- #hide +----------------------------------------------------------------------------- +-- | +-- Module : Language.Haskell.Hsx.ParseMonad +-- Original : 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.Hsx.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, + -- * Harp/Hsx + ExtContext(..), + pushExtContextL, popExtContextL, getExtContext, + getModuleName + ) where + +import Language.Haskell.Hsx.Syntax(SrcLoc(..)) + +import Data.List ( intersperse ) + +-- | 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 + +-- internal version +data ParseStatus a = Ok ParseState a | Failed SrcLoc String + deriving Show + +data LexContext = NoLayout | Layout Int + deriving (Eq,Ord,Show) + +data ExtContext = CodeCtxt | HarpCtxt | TagCtxt | ChildCtxt + | CloseTagCtxt | CodeTagCtxt + deriving (Eq,Ord,Show) + +type ParseState = ([LexContext],[ExtContext]) + +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 = ".hs" + } + +-- | 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 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 + +getModuleName :: P String +getModuleName = P $ \_i _x _y _l s m -> + let fn = parseFilename m + mn = concat $ intersperse "." $ splitPath fn + + splitPath :: String -> [String] + splitPath "" = [] + splitPath str = let (l,str') = break ('\\'==) str + in case str' of + [] -> [removeSuffix l] + (_:str'') -> l : splitPath str'' + + removeSuffix l = reverse $ tail $ dropWhile ('.'/=) $ reverse l + + in Ok s mn + +-- 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 (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, e) _m -> Ok (ctxt:s, e) () + +popContext :: P () +popContext = P $ \_i _x _y _l stk _m -> + case stk of + (_:s, e) -> --trace ("popping lexical scope, context now "++show s ++ "\n") $ + Ok (s, e) () + ([],_) -> error "Internal error: empty context in popContext" + + +-- HaRP/Hsx +pushExtContext :: ExtContext -> P () +pushExtContext ctxt = P $ \_i _x _y _l (s, e) _m -> Ok (s, ctxt:e) () + +popExtContext :: P () +popExtContext = P $ \_i _x _y _l (s, e) _m -> + case e of + (_:e') -> + Ok (s, e') () + [] -> error "Internal error: empty context in popExtContext" + + +-- Monad for lexical analysis: +-- a continuation-passing version of the parsing monad + +newtype Lex r a = Lex { runL :: (a -> P r) -> P r } + +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 :: Int + +-- 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, e) -> + runP (cont ()) r x y loc (ctxt:stk, e) + +popContextL :: String -> Lex a () +popContextL fn = Lex $ \cont -> P $ \r x y loc stk -> case stk of + (_:ctxt, e) -> runP (cont ()) r x y loc (ctxt, e) + ([], _) -> error ("Internal error: empty context in " ++ fn) + +-- Harp/Hsx + +getExtContext :: Lex a (Maybe ExtContext) +getExtContext = Lex $ \cont -> P $ \r x y loc stk@(_, e) -> + let me = case e of + [] -> Nothing + (c:_) -> Just c + in runP (cont me) r x y loc stk + +pushExtContextL :: ExtContext -> Lex a () +pushExtContextL ec = Lex $ \cont -> P $ \r x y loc (s, e) -> + runP (cont ()) r x y loc (s, ec:e) + +popExtContextL :: String -> Lex a () +popExtContextL fn = Lex $ \cont -> P $ \r x y loc stk@(s,e) -> case e of + (_:ec) -> runP (cont ()) r x y loc (s,ec) + [] -> error ("Internal error: empty tag context in " ++ fn) diff --git a/Language/Haskell/Hsx/ParseUtils.hs b/Language/Haskell/Hsx/ParseUtils.hs new file mode 100644 --- /dev/null +++ b/Language/Haskell/Hsx/ParseUtils.hs @@ -0,0 +1,542 @@ +-- #hide +----------------------------------------------------------------------------- +-- | +-- Module : Language.Haskell.Hsx.ParseUtils +-- Original : Language.Haskell.ParseUtils +-- Copyright : (c) Niklas Broberg 2004, +-- (c) The GHC Team, 1997-2000 +-- License : BSD-style (see the file LICENSE.txt) +-- +-- Maintainer : Niklas Broberg, d00nibro@dtek.chalmers.se +-- Stability : experimental +-- Portability : portable +-- +-- Utilities for the Haskell-exts parser. +-- +----------------------------------------------------------------------------- + +module Language.Haskell.Hsx.ParseUtils ( + splitTyConApp -- HsType -> P (HsName,[HsType]) + , mkRecConstrOrUpdate -- HsExp -> [HsFieldUpdate] -> P HsExp + , checkPrec -- Integer -> P Int + , checkContext -- HsType -> P HsContext + , checkAssertion -- HsType -> P HsAsst + , checkDataHeader -- HsType -> P (HsContext,HsName,[HsName]) + , checkClassHeader -- HsType -> P (HsContext,HsName,[HsName]) + , checkInstHeader -- HsType -> 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] + , getGConName -- HsExp -> P HsQName + , mkHsTyForall -- Maybe [HsName] -> HsContext -> HsType -> HsType + -- HaRP + , checkRPattern -- HsExp -> P HsRPat + -- Hsx + , checkEqNames -- HsXName -> HsXName -> P HsXName + , mkPageModule -- HsExp -> P HsModule + , mkPage -- HsModule -> SrcLoc -> HsExp -> P HsModule + , mkDVar -- [String] -> String + , mkDVarExpr -- [String] -> HsExp + ) where + +import Language.Haskell.Hsx.Syntax +import Language.Haskell.Hsx.ParseMonad +import Language.Haskell.Hsx.Pretty +import Language.Haskell.Hsx.Build + +import Data.List (intersperse) + +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 (HsTyInfix a op b) ts = split (HsTyCon op) (a:b:ts) + split _ _ = fail "Illegal data/newtype declaration" + +----------------------------------------------------------------------------- +-- Various Syntactic Checks + +checkContext :: HsType -> P HsContext +checkContext (HsTyTuple Boxed ts) = + mapM checkAssertion ts +checkContext t = do + c <- checkAssertion t + return [c] + +-- Changed for multi-parameter type classes. +-- Further changed for implicit parameters. + +checkAssertion :: HsType -> P HsAsst +checkAssertion (HsTyPred p@(HsIParam n t)) = return p +checkAssertion t = checkAssertion' [] t + where checkAssertion' ts (HsTyCon c) = return $ HsClassA c ts + checkAssertion' ts (HsTyApp a t) = checkAssertion' (t:ts) a + checkAssertion' ts (HsTyInfix a op b) = checkAssertion' (a:b:ts) (HsTyCon op) + checkAssertion' _ _ = fail "Illegal class assertion" + + +checkDataHeader :: HsType -> P (HsContext,HsName,[HsName]) +checkDataHeader (HsTyForall Nothing cs t) = do + (c,ts) <- checkSimple "data/newtype" t [] + return (cs,c,ts) +checkDataHeader t = do + (c,ts) <- checkSimple "data/newtype" t [] + return ([],c,ts) + +checkClassHeader :: HsType -> P (HsContext,HsName,[HsName]) +checkClassHeader (HsTyForall Nothing cs t) = do + (c,ts) <- checkSimple "class" t [] + return (cs,c,ts) +checkClassHeader t = do + (c,ts) <- checkSimple "class" t [] + return ([],c,ts) + +checkSimple :: String -> HsType -> [HsName] -> P (HsName,[HsName]) +checkSimple kw (HsTyApp l (HsTyVar a)) xs = checkSimple kw l (a:xs) +checkSimple _ (HsTyInfix (HsTyVar a) (UnQual t) (HsTyVar b)) xs = return (t,a:b:xs) +checkSimple _kw (HsTyCon (UnQual t)) xs = return (t,xs) +checkSimple kw _ _ = fail ("Illegal " ++ kw ++ " declaration") + +checkInstHeader :: HsType -> P (HsContext,HsQName,[HsType]) +checkInstHeader (HsTyForall Nothing cs t) = do + (c,ts) <- checkInsts t [] + return (cs,c,ts) +checkInstHeader t = do + (c,ts) <- checkInsts t [] + return ([],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" + +{- +checkInst :: HsType -> P () +checkInst (HsTyApp l _) = checkInst l +checkInst (HsTyVar _) = fail "Illegal instance declaration" +checkInst _ = return () +-} + +----------------------------------------------------------------------------- +-- 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)) + HsRPats s es -> do + rps <- mapM checkRPattern es + return (HsPRPat s rps) + HsExpTypeSig s e t -> do + p <- checkPat e [] + return (HsPatTypeSig s p t) + + -- Hsx + HsXTag s n attrs mattr cs -> do + pattrs <- mapM checkPAttr attrs + pcs <- mapM (\c -> checkPat c []) cs + mpattr <- maybe (return Nothing) + (\e -> do p <- checkPat e [] + return $ Just p) + mattr + let cp = mkChildrenPat pcs + return $ HsPXTag s n pattrs mpattr cp + HsXETag s n attrs mattr -> do + pattrs <- mapM checkPAttr attrs + mpattr <- maybe (return Nothing) + (\e -> do p <- checkPat e [] + return $ Just p) + mattr + return $ HsPXETag s n pattrs mpattr + HsXPcdata pcdata -> return $ HsPXPcdata pcdata + HsXExpTag e -> do + p <- checkPat e [] + return $ HsPXPatTag p + e -> patFail $ show e + +checkPat e _ = patFail $ show e + +checkPatField :: HsFieldUpdate -> P HsPatField +checkPatField (HsFieldUpdate n e) = do + p <- checkPat e [] + return (HsPFieldPat n p) + +checkPAttr :: HsXAttr -> P HsPXAttr +checkPAttr (HsXAttr n v) = do p <- checkPat v [] + return $ HsPXAttr n p + +patFail :: String -> P a +patFail s = fail $ "Parse error in pattern: " ++ s + +checkRPattern :: HsExp -> P HsRPat +checkRPattern e = case e of + HsSeqRP es -> do + rps <- mapM checkRPattern es + return $ HsRPSeq rps + HsStarRP e -> do + rp <- checkRPattern e + return $ HsRPStar rp + HsPlusRP e -> do + rp <- checkRPattern e + return $ HsRPPlus rp + HsOptRP e -> do + rp <- checkRPattern e + return $ HsRPOpt rp + HsStarGRP e -> do + rp <- checkRPattern e + return $ HsRPStarG rp + HsPlusGRP e -> do + rp <- checkRPattern e + return $ HsRPPlusG rp + HsOptGRP e -> do + rp <- checkRPattern e + return $ HsRPOptG rp + HsEitherRP e1 e2 -> do + rp1 <- checkRPattern e1 + rp2 <- checkRPattern e2 + return $ HsRPEither rp1 rp2 + HsCAsRP n e -> do + rp <- checkRPattern e + return $ HsRPCAs n rp + HsAsPat n e -> do + rp <- checkRPattern e + return $ HsRPAs n rp + HsParen e -> do + rp <- checkRPattern e + return $ HsRPParen rp + _ -> do + p <- checkPattern e + return $ HsRPPat p + + +mkChildrenPat :: [HsPat] -> HsPat +mkChildrenPat ps = mkCPAux ps [] + where mkCPAux :: [HsPat] -> [HsPat] -> HsPat + mkCPAux [] qs = HsPList $ reverse qs + mkCPAux (p:ps) qs = case p of + (HsPRPat s rps) -> mkCRP s ps (reverse rps ++ map HsRPPat qs) + _ -> mkCPAux ps (p:qs) + + mkCRP :: SrcLoc -> [HsPat] -> [HsRPat] -> HsPat + mkCRP s [] rps = HsPRPat s $ reverse rps + mkCRP s (p:ps) rps = case p of + (HsPRPat _ rqs) -> mkCRP s ps (reverse rqs ++ rps) + _ -> mkCRP s ps (HsRPPat p : rps) + +----------------------------------------------------------------------------- +-- Check Expression Syntax + +checkExpr :: HsExp -> P HsExp +checkExpr e = case e of + HsVar _ -> return e + HsIPVar _ -> 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 e -> check1Expr e HsNegApp + HsLambda loc ps e -> check1Expr e (HsLambda loc ps) + HsLet bs e -> check1Expr e (HsLet bs) + HsDLet bs e -> check1Expr e (HsDLet bs) + HsWith e bs -> check1Expr e (flip HsWith bs) + HsIf e1 e2 e3 -> check3Exprs e1 e2 e3 HsIf + HsCase e alts -> do + alts <- mapM checkAlt alts + e <- checkExpr e + return (HsCase e alts) + HsDo stmts -> do + stmts <- mapM checkStmt stmts + return (HsDo stmts) + HsMDo stmts -> do + stmts <- mapM checkStmt stmts + return (HsMDo stmts) + HsTuple es -> checkManyExprs es HsTuple + HsList es -> checkManyExprs es HsList + HsParen e -> check1Expr e HsParen + HsLeftSection e op -> check1Expr e (flip HsLeftSection op) + HsRightSection op e -> check1Expr e (HsRightSection op) + HsRecConstr c fields -> do + fields <- mapM checkField fields + return (HsRecConstr c fields) + HsRecUpdate e fields -> do + fields <- mapM checkField fields + e <- checkExpr e + return (HsRecUpdate e fields) + HsEnumFrom e -> check1Expr e 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 e stmts -> do + stmts <- mapM checkStmt stmts + e <- checkExpr e + return (HsListComp e stmts) + HsExpTypeSig loc e ty -> do + e <- checkExpr e + return (HsExpTypeSig loc e ty) + + --Template Haskell + HsReifyExp _ -> return e + HsBracketExp _ -> return e + HsSpliceExp _ -> return e + + -- Hsx + HsXTag s n attrs mattr cs -> do attrs <- mapM checkAttr attrs + cs <- mapM checkExpr cs + mattr <- maybe (return Nothing) + (\e -> checkExpr e >>= return . Just) + mattr + return $ HsXTag s n attrs mattr cs + HsXETag s n attrs mattr -> do attrs <- mapM checkAttr attrs + mattr <- maybe (return Nothing) + (\e -> checkExpr e >>= return . Just) + mattr + return $ HsXETag s n attrs mattr + HsXPcdata _ -> return e + HsXExpTag e -> do e <- checkExpr e + return $ HsXExpTag e + _ -> fail $ "Parse error in expression: " ++ show e + +checkAttr :: HsXAttr -> P HsXAttr +checkAttr (HsXAttr n v) = do v <- checkExpr v + return $ HsXAttr n v + +-- 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 g e) = check1Expr e (HsGuardedAlt loc g) + +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) + +getGConName :: HsExp -> P HsQName +getGConName (HsCon n) = return n +getGConName (HsList []) = return list_cons_name +getGConName _ = fail "Expression in reification is not a name" + +----------------------------------------------------------------------------- +-- Check Equation Syntax + +checkValDef :: SrcLoc -> HsExp -> HsRhs -> HsBinds -> 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" + +----------------------------------------------------------------------------- +-- Check that two xml tag names are equal +-- Could use Eq directly, but I am not sure whether ... +-- would be valid, in that case Eq won't work. TODO + +checkEqNames :: HsXName -> HsXName -> P HsXName +checkEqNames n@(HsXName n1) (HsXName n2) + | n1 == n2 = return n + | otherwise = fail "names in matching xml tags are not equal" +checkEqNames n@(HsXDomName d1 n1) (HsXDomName d2 n2) + | n1 == n2 && d1 == d2 = return n + | otherwise = fail "names in matching xml tags are not equal" +checkEqNames _ _ = fail "names in matching xml tags are not equal" + + +----------------------------------------------------------------------------- +-- 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 + + +--------------------------------------- +-- Converting a complete page + +pageFun :: SrcLoc -> HsExp -> HsDecl +pageFun loc e = HsPatBind loc namePat rhs (HsBDecls []) + where namePat = HsPVar $ HsIdent "page" + rhs = HsUnGuardedRhs e + +mkPage :: HsModule -> SrcLoc -> HsExp -> P HsModule +mkPage (HsModule src md exps imps decls) loc xml = do + let page = pageFun loc xml + return $ HsModule src md exps imps (decls ++ [page]) + +mkPageModule :: HsExp -> P HsModule +mkPageModule xml = do + do loc <- case xml of + HsXTag l _ _ _ _ -> return l + HsXETag l _ _ _ -> return l + _ -> fail "Will not happen since mkPageModule is only called on XML expressions" + mod <- getModuleName + return $ (HsModule + loc + (Module mod) + (Just [HsEVar $ UnQual $ HsIdent "page"]) + [] + [pageFun loc xml]) + +--------------------------------------- +-- Handle dash-identifiers + +mkDVar :: [String] -> String +mkDVar = concat . intersperse "-" + +mkDVarExpr :: [String] -> HsExp +mkDVarExpr = foldl1 (\x y -> infixApp x (op $ sym "-") y) . map (var . name) + +--------------------------------------- +-- Combine adjacent for-alls. +-- +-- A valid type must have one for-all at the top of the type, or of the fn arg types + +mkHsTyForall :: Maybe [HsName] -> HsContext -> HsType -> HsType +mkHsTyForall mtvs [] ty = mk_forall_ty mtvs ty +mkHsTyForall mtvs ctxt ty = HsTyForall mtvs ctxt ty + +-- mk_forall_ty makes a pure for-all type (no context) +mk_forall_ty (Just []) ty = ty -- Explicit for-all with no tyvars +mk_forall_ty mtvs1 (HsTyForall mtvs2 ctxt ty) = mkHsTyForall (mtvs1 `plus` mtvs2) ctxt ty +mk_forall_ty mtvs1 ty = HsTyForall mtvs1 [] ty + +mtvs1 `plus` Nothing = mtvs1 +Nothing `plus` mtvs2 = mtvs2 +(Just tvs1) `plus` (Just tvs2) = Just (tvs1 ++ tvs2) diff --git a/Language/Haskell/Hsx/Parser.hs b/Language/Haskell/Hsx/Parser.hs new file mode 100644 --- /dev/null +++ b/Language/Haskell/Hsx/Parser.hs @@ -0,0 +1,5426 @@ +{-# OPTIONS -fglasgow-exts -cpp #-} +----------------------------------------------------------------------------- +-- | +-- Module : Language.Haskell.Hsx.Parser +-- Original : Language.Haskell.Parser +-- Copyright : (c) Niklas Broberg 2004, +-- Original (c) Simon Marlow, Sven Panne 1997-2000 +-- License : BSD-style (see the file LICENSE.txt) +-- +-- Maintainer : Niklas Broberg, d00nibro@dtek.chalmers.se +-- Stability : experimental +-- Portability : portable +-- +-- +----------------------------------------------------------------------------- +module Language.Haskell.Hsx.Parser ( + parseModule, parseModuleWithMode, + ParseMode(..), defaultParseMode, ParseResult(..)) where + +import Language.Haskell.Hsx.Syntax +import Language.Haskell.Hsx.ParseMonad +import Language.Haskell.Hsx.Lexer +import Language.Haskell.Hsx.ParseUtils +#if __GLASGOW_HASKELL__ >= 503 +import Data.Array +#else +import Array +#endif +#if __GLASGOW_HASKELL__ >= 503 +import GHC.Exts +#else +import GlaExts +#endif + +-- parser produced by Happy Version 1.17 + +newtype HappyAbsSyn = HappyAbsSyn HappyAny +#if __GLASGOW_HASKELL__ >= 607 +type HappyAny = GHC.Exts.Any +#else +type HappyAny = forall a . a +#endif +happyIn4 :: (HsModule) -> (HappyAbsSyn ) +happyIn4 x = unsafeCoerce# x +{-# INLINE happyIn4 #-} +happyOut4 :: (HappyAbsSyn ) -> (HsModule) +happyOut4 x = unsafeCoerce# x +{-# INLINE happyOut4 #-} +happyIn5 :: (HsExp) -> (HappyAbsSyn ) +happyIn5 x = unsafeCoerce# x +{-# INLINE happyIn5 #-} +happyOut5 :: (HappyAbsSyn ) -> (HsExp) +happyOut5 x = unsafeCoerce# x +{-# INLINE happyOut5 #-} +happyIn6 :: (HsModule) -> (HappyAbsSyn ) +happyIn6 x = unsafeCoerce# x +{-# INLINE happyIn6 #-} +happyOut6 :: (HappyAbsSyn ) -> (HsModule) +happyOut6 x = unsafeCoerce# x +{-# INLINE happyOut6 #-} +happyIn7 :: (([HsImportDecl],[HsDecl])) -> (HappyAbsSyn ) +happyIn7 x = unsafeCoerce# x +{-# INLINE happyIn7 #-} +happyOut7 :: (HappyAbsSyn ) -> (([HsImportDecl],[HsDecl])) +happyOut7 x = unsafeCoerce# x +{-# INLINE happyOut7 #-} +happyIn8 :: (([HsImportDecl],[HsDecl])) -> (HappyAbsSyn ) +happyIn8 x = unsafeCoerce# x +{-# INLINE happyIn8 #-} +happyOut8 :: (HappyAbsSyn ) -> (([HsImportDecl],[HsDecl])) +happyOut8 x = unsafeCoerce# x +{-# INLINE happyOut8 #-} +happyIn9 :: (()) -> (HappyAbsSyn ) +happyIn9 x = unsafeCoerce# x +{-# INLINE happyIn9 #-} +happyOut9 :: (HappyAbsSyn ) -> (()) +happyOut9 x = unsafeCoerce# x +{-# INLINE happyOut9 #-} +happyIn10 :: (()) -> (HappyAbsSyn ) +happyIn10 x = unsafeCoerce# x +{-# INLINE happyIn10 #-} +happyOut10 :: (HappyAbsSyn ) -> (()) +happyOut10 x = unsafeCoerce# x +{-# INLINE happyOut10 #-} +happyIn11 :: (Maybe [HsExportSpec]) -> (HappyAbsSyn ) +happyIn11 x = unsafeCoerce# x +{-# INLINE happyIn11 #-} +happyOut11 :: (HappyAbsSyn ) -> (Maybe [HsExportSpec]) +happyOut11 x = unsafeCoerce# x +{-# INLINE happyOut11 #-} +happyIn12 :: ([HsExportSpec]) -> (HappyAbsSyn ) +happyIn12 x = unsafeCoerce# x +{-# INLINE happyIn12 #-} +happyOut12 :: (HappyAbsSyn ) -> ([HsExportSpec]) +happyOut12 x = unsafeCoerce# x +{-# INLINE happyOut12 #-} +happyIn13 :: (()) -> (HappyAbsSyn ) +happyIn13 x = unsafeCoerce# x +{-# INLINE happyIn13 #-} +happyOut13 :: (HappyAbsSyn ) -> (()) +happyOut13 x = unsafeCoerce# x +{-# INLINE happyOut13 #-} +happyIn14 :: ([HsExportSpec]) -> (HappyAbsSyn ) +happyIn14 x = unsafeCoerce# x +{-# INLINE happyIn14 #-} +happyOut14 :: (HappyAbsSyn ) -> ([HsExportSpec]) +happyOut14 x = unsafeCoerce# x +{-# INLINE happyOut14 #-} +happyIn15 :: (HsExportSpec) -> (HappyAbsSyn ) +happyIn15 x = unsafeCoerce# x +{-# INLINE happyIn15 #-} +happyOut15 :: (HappyAbsSyn ) -> (HsExportSpec) +happyOut15 x = unsafeCoerce# x +{-# INLINE happyOut15 #-} +happyIn16 :: ([HsImportDecl]) -> (HappyAbsSyn ) +happyIn16 x = unsafeCoerce# x +{-# INLINE happyIn16 #-} +happyOut16 :: (HappyAbsSyn ) -> ([HsImportDecl]) +happyOut16 x = unsafeCoerce# x +{-# INLINE happyOut16 #-} +happyIn17 :: (HsImportDecl) -> (HappyAbsSyn ) +happyIn17 x = unsafeCoerce# x +{-# INLINE happyIn17 #-} +happyOut17 :: (HappyAbsSyn ) -> (HsImportDecl) +happyOut17 x = unsafeCoerce# x +{-# INLINE happyOut17 #-} +happyIn18 :: (Bool) -> (HappyAbsSyn ) +happyIn18 x = unsafeCoerce# x +{-# INLINE happyIn18 #-} +happyOut18 :: (HappyAbsSyn ) -> (Bool) +happyOut18 x = unsafeCoerce# x +{-# INLINE happyOut18 #-} +happyIn19 :: (Maybe Module) -> (HappyAbsSyn ) +happyIn19 x = unsafeCoerce# x +{-# INLINE happyIn19 #-} +happyOut19 :: (HappyAbsSyn ) -> (Maybe Module) +happyOut19 x = unsafeCoerce# x +{-# INLINE happyOut19 #-} +happyIn20 :: (Maybe (Bool, [HsImportSpec])) -> (HappyAbsSyn ) +happyIn20 x = unsafeCoerce# x +{-# INLINE happyIn20 #-} +happyOut20 :: (HappyAbsSyn ) -> (Maybe (Bool, [HsImportSpec])) +happyOut20 x = unsafeCoerce# x +{-# INLINE happyOut20 #-} +happyIn21 :: ((Bool, [HsImportSpec])) -> (HappyAbsSyn ) +happyIn21 x = unsafeCoerce# x +{-# INLINE happyIn21 #-} +happyOut21 :: (HappyAbsSyn ) -> ((Bool, [HsImportSpec])) +happyOut21 x = unsafeCoerce# x +{-# INLINE happyOut21 #-} +happyIn22 :: (Bool) -> (HappyAbsSyn ) +happyIn22 x = unsafeCoerce# x +{-# INLINE happyIn22 #-} +happyOut22 :: (HappyAbsSyn ) -> (Bool) +happyOut22 x = unsafeCoerce# x +{-# INLINE happyOut22 #-} +happyIn23 :: ([HsImportSpec]) -> (HappyAbsSyn ) +happyIn23 x = unsafeCoerce# x +{-# INLINE happyIn23 #-} +happyOut23 :: (HappyAbsSyn ) -> ([HsImportSpec]) +happyOut23 x = unsafeCoerce# x +{-# INLINE happyOut23 #-} +happyIn24 :: (HsImportSpec) -> (HappyAbsSyn ) +happyIn24 x = unsafeCoerce# x +{-# INLINE happyIn24 #-} +happyOut24 :: (HappyAbsSyn ) -> (HsImportSpec) +happyOut24 x = unsafeCoerce# x +{-# INLINE happyOut24 #-} +happyIn25 :: ([HsCName]) -> (HappyAbsSyn ) +happyIn25 x = unsafeCoerce# x +{-# INLINE happyIn25 #-} +happyOut25 :: (HappyAbsSyn ) -> ([HsCName]) +happyOut25 x = unsafeCoerce# x +{-# INLINE happyOut25 #-} +happyIn26 :: (HsCName) -> (HappyAbsSyn ) +happyIn26 x = unsafeCoerce# x +{-# INLINE happyIn26 #-} +happyOut26 :: (HappyAbsSyn ) -> (HsCName) +happyOut26 x = unsafeCoerce# x +{-# INLINE happyOut26 #-} +happyIn27 :: (HsDecl) -> (HappyAbsSyn ) +happyIn27 x = unsafeCoerce# x +{-# INLINE happyIn27 #-} +happyOut27 :: (HappyAbsSyn ) -> (HsDecl) +happyOut27 x = unsafeCoerce# x +{-# INLINE happyOut27 #-} +happyIn28 :: (Int) -> (HappyAbsSyn ) +happyIn28 x = unsafeCoerce# x +{-# INLINE happyIn28 #-} +happyOut28 :: (HappyAbsSyn ) -> (Int) +happyOut28 x = unsafeCoerce# x +{-# INLINE happyOut28 #-} +happyIn29 :: (HsAssoc) -> (HappyAbsSyn ) +happyIn29 x = unsafeCoerce# x +{-# INLINE happyIn29 #-} +happyOut29 :: (HappyAbsSyn ) -> (HsAssoc) +happyOut29 x = unsafeCoerce# x +{-# INLINE happyOut29 #-} +happyIn30 :: ([HsOp]) -> (HappyAbsSyn ) +happyIn30 x = unsafeCoerce# x +{-# INLINE happyIn30 #-} +happyOut30 :: (HappyAbsSyn ) -> ([HsOp]) +happyOut30 x = unsafeCoerce# x +{-# INLINE happyOut30 #-} +happyIn31 :: ([HsDecl]) -> (HappyAbsSyn ) +happyIn31 x = unsafeCoerce# x +{-# INLINE happyIn31 #-} +happyOut31 :: (HappyAbsSyn ) -> ([HsDecl]) +happyOut31 x = unsafeCoerce# x +{-# INLINE happyOut31 #-} +happyIn32 :: ([HsDecl]) -> (HappyAbsSyn ) +happyIn32 x = unsafeCoerce# x +{-# INLINE happyIn32 #-} +happyOut32 :: (HappyAbsSyn ) -> ([HsDecl]) +happyOut32 x = unsafeCoerce# x +{-# INLINE happyOut32 #-} +happyIn33 :: (HsDecl) -> (HappyAbsSyn ) +happyIn33 x = unsafeCoerce# x +{-# INLINE happyIn33 #-} +happyOut33 :: (HappyAbsSyn ) -> (HsDecl) +happyOut33 x = unsafeCoerce# x +{-# INLINE happyOut33 #-} +happyIn34 :: ([HsType]) -> (HappyAbsSyn ) +happyIn34 x = unsafeCoerce# x +{-# INLINE happyIn34 #-} +happyOut34 :: (HappyAbsSyn ) -> ([HsType]) +happyOut34 x = unsafeCoerce# x +{-# INLINE happyOut34 #-} +happyIn35 :: ([HsDecl]) -> (HappyAbsSyn ) +happyIn35 x = unsafeCoerce# x +{-# INLINE happyIn35 #-} +happyOut35 :: (HappyAbsSyn ) -> ([HsDecl]) +happyOut35 x = unsafeCoerce# x +{-# INLINE happyOut35 #-} +happyIn36 :: ([HsDecl]) -> (HappyAbsSyn ) +happyIn36 x = unsafeCoerce# x +{-# INLINE happyIn36 #-} +happyOut36 :: (HappyAbsSyn ) -> ([HsDecl]) +happyOut36 x = unsafeCoerce# x +{-# INLINE happyOut36 #-} +happyIn37 :: (HsDecl) -> (HappyAbsSyn ) +happyIn37 x = unsafeCoerce# x +{-# INLINE happyIn37 #-} +happyOut37 :: (HappyAbsSyn ) -> (HsDecl) +happyOut37 x = unsafeCoerce# x +{-# INLINE happyOut37 #-} +happyIn38 :: ([HsDecl]) -> (HappyAbsSyn ) +happyIn38 x = unsafeCoerce# x +{-# INLINE happyIn38 #-} +happyOut38 :: (HappyAbsSyn ) -> ([HsDecl]) +happyOut38 x = unsafeCoerce# x +{-# INLINE happyOut38 #-} +happyIn39 :: (HsDecl) -> (HappyAbsSyn ) +happyIn39 x = unsafeCoerce# x +{-# INLINE happyIn39 #-} +happyOut39 :: (HappyAbsSyn ) -> (HsDecl) +happyOut39 x = unsafeCoerce# x +{-# INLINE happyOut39 #-} +happyIn40 :: (HsBinds) -> (HappyAbsSyn ) +happyIn40 x = unsafeCoerce# x +{-# INLINE happyIn40 #-} +happyOut40 :: (HappyAbsSyn ) -> (HsBinds) +happyOut40 x = unsafeCoerce# x +{-# INLINE happyOut40 #-} +happyIn41 :: ([HsName]) -> (HappyAbsSyn ) +happyIn41 x = unsafeCoerce# x +{-# INLINE happyIn41 #-} +happyOut41 :: (HappyAbsSyn ) -> ([HsName]) +happyOut41 x = unsafeCoerce# x +{-# INLINE happyOut41 #-} +happyIn42 :: (HsCallConv) -> (HappyAbsSyn ) +happyIn42 x = unsafeCoerce# x +{-# INLINE happyIn42 #-} +happyOut42 :: (HappyAbsSyn ) -> (HsCallConv) +happyOut42 x = unsafeCoerce# x +{-# INLINE happyOut42 #-} +happyIn43 :: (HsSafety) -> (HappyAbsSyn ) +happyIn43 x = unsafeCoerce# x +{-# INLINE happyIn43 #-} +happyOut43 :: (HappyAbsSyn ) -> (HsSafety) +happyOut43 x = unsafeCoerce# x +{-# INLINE happyOut43 #-} +happyIn44 :: ((String, HsName, HsType)) -> (HappyAbsSyn ) +happyIn44 x = unsafeCoerce# x +{-# INLINE happyIn44 #-} +happyOut44 :: (HappyAbsSyn ) -> ((String, HsName, HsType)) +happyOut44 x = unsafeCoerce# x +{-# INLINE happyOut44 #-} +happyIn45 :: (HsType) -> (HappyAbsSyn ) +happyIn45 x = unsafeCoerce# x +{-# INLINE happyIn45 #-} +happyOut45 :: (HappyAbsSyn ) -> (HsType) +happyOut45 x = unsafeCoerce# x +{-# INLINE happyOut45 #-} +happyIn46 :: (HsType) -> (HappyAbsSyn ) +happyIn46 x = unsafeCoerce# x +{-# INLINE happyIn46 #-} +happyOut46 :: (HappyAbsSyn ) -> (HsType) +happyOut46 x = unsafeCoerce# x +{-# INLINE happyOut46 #-} +happyIn47 :: (HsType) -> (HappyAbsSyn ) +happyIn47 x = unsafeCoerce# x +{-# INLINE happyIn47 #-} +happyOut47 :: (HappyAbsSyn ) -> (HsType) +happyOut47 x = unsafeCoerce# x +{-# INLINE happyOut47 #-} +happyIn48 :: (HsType) -> (HappyAbsSyn ) +happyIn48 x = unsafeCoerce# x +{-# INLINE happyIn48 #-} +happyOut48 :: (HappyAbsSyn ) -> (HsType) +happyOut48 x = unsafeCoerce# x +{-# INLINE happyOut48 #-} +happyIn49 :: (HsQName) -> (HappyAbsSyn ) +happyIn49 x = unsafeCoerce# x +{-# INLINE happyIn49 #-} +happyOut49 :: (HappyAbsSyn ) -> (HsQName) +happyOut49 x = unsafeCoerce# x +{-# INLINE happyOut49 #-} +happyIn50 :: (HsQName) -> (HappyAbsSyn ) +happyIn50 x = unsafeCoerce# x +{-# INLINE happyIn50 #-} +happyOut50 :: (HappyAbsSyn ) -> (HsQName) +happyOut50 x = unsafeCoerce# x +{-# INLINE happyOut50 #-} +happyIn51 :: (HsType) -> (HappyAbsSyn ) +happyIn51 x = unsafeCoerce# x +{-# INLINE happyIn51 #-} +happyOut51 :: (HappyAbsSyn ) -> (HsType) +happyOut51 x = unsafeCoerce# x +{-# INLINE happyOut51 #-} +happyIn52 :: (HsContext) -> (HappyAbsSyn ) +happyIn52 x = unsafeCoerce# x +{-# INLINE happyIn52 #-} +happyOut52 :: (HappyAbsSyn ) -> (HsContext) +happyOut52 x = unsafeCoerce# x +{-# INLINE happyOut52 #-} +happyIn53 :: ([HsType]) -> (HappyAbsSyn ) +happyIn53 x = unsafeCoerce# x +{-# INLINE happyIn53 #-} +happyOut53 :: (HappyAbsSyn ) -> ([HsType]) +happyOut53 x = unsafeCoerce# x +{-# INLINE happyOut53 #-} +happyIn54 :: ([HsType]) -> (HappyAbsSyn ) +happyIn54 x = unsafeCoerce# x +{-# INLINE happyIn54 #-} +happyOut54 :: (HappyAbsSyn ) -> ([HsType]) +happyOut54 x = unsafeCoerce# x +{-# INLINE happyOut54 #-} +happyIn55 :: ((HsName, [HsName])) -> (HappyAbsSyn ) +happyIn55 x = unsafeCoerce# x +{-# INLINE happyIn55 #-} +happyOut55 :: (HappyAbsSyn ) -> ((HsName, [HsName])) +happyOut55 x = unsafeCoerce# x +{-# INLINE happyOut55 #-} +happyIn56 :: ([HsName]) -> (HappyAbsSyn ) +happyIn56 x = unsafeCoerce# x +{-# INLINE happyIn56 #-} +happyOut56 :: (HappyAbsSyn ) -> ([HsName]) +happyOut56 x = unsafeCoerce# x +{-# INLINE happyOut56 #-} +happyIn57 :: ([HsFunDep]) -> (HappyAbsSyn ) +happyIn57 x = unsafeCoerce# x +{-# INLINE happyIn57 #-} +happyOut57 :: (HappyAbsSyn ) -> ([HsFunDep]) +happyOut57 x = unsafeCoerce# x +{-# INLINE happyOut57 #-} +happyIn58 :: ([HsFunDep]) -> (HappyAbsSyn ) +happyIn58 x = unsafeCoerce# x +{-# INLINE happyIn58 #-} +happyOut58 :: (HappyAbsSyn ) -> ([HsFunDep]) +happyOut58 x = unsafeCoerce# x +{-# INLINE happyOut58 #-} +happyIn59 :: (HsFunDep) -> (HappyAbsSyn ) +happyIn59 x = unsafeCoerce# x +{-# INLINE happyIn59 #-} +happyOut59 :: (HappyAbsSyn ) -> (HsFunDep) +happyOut59 x = unsafeCoerce# x +{-# INLINE happyOut59 #-} +happyIn60 :: ([HsGadtDecl]) -> (HappyAbsSyn ) +happyIn60 x = unsafeCoerce# x +{-# INLINE happyIn60 #-} +happyOut60 :: (HappyAbsSyn ) -> ([HsGadtDecl]) +happyOut60 x = unsafeCoerce# x +{-# INLINE happyOut60 #-} +happyIn61 :: ([HsGadtDecl]) -> (HappyAbsSyn ) +happyIn61 x = unsafeCoerce# x +{-# INLINE happyIn61 #-} +happyOut61 :: (HappyAbsSyn ) -> ([HsGadtDecl]) +happyOut61 x = unsafeCoerce# x +{-# INLINE happyOut61 #-} +happyIn62 :: ([HsGadtDecl]) -> (HappyAbsSyn ) +happyIn62 x = unsafeCoerce# x +{-# INLINE happyIn62 #-} +happyOut62 :: (HappyAbsSyn ) -> ([HsGadtDecl]) +happyOut62 x = unsafeCoerce# x +{-# INLINE happyOut62 #-} +happyIn63 :: (HsGadtDecl) -> (HappyAbsSyn ) +happyIn63 x = unsafeCoerce# x +{-# INLINE happyIn63 #-} +happyOut63 :: (HappyAbsSyn ) -> (HsGadtDecl) +happyOut63 x = unsafeCoerce# x +{-# INLINE happyOut63 #-} +happyIn64 :: ([HsQualConDecl]) -> (HappyAbsSyn ) +happyIn64 x = unsafeCoerce# x +{-# INLINE happyIn64 #-} +happyOut64 :: (HappyAbsSyn ) -> ([HsQualConDecl]) +happyOut64 x = unsafeCoerce# x +{-# INLINE happyOut64 #-} +happyIn65 :: ([HsQualConDecl]) -> (HappyAbsSyn ) +happyIn65 x = unsafeCoerce# x +{-# INLINE happyIn65 #-} +happyOut65 :: (HappyAbsSyn ) -> ([HsQualConDecl]) +happyOut65 x = unsafeCoerce# x +{-# INLINE happyOut65 #-} +happyIn66 :: (HsQualConDecl) -> (HappyAbsSyn ) +happyIn66 x = unsafeCoerce# x +{-# INLINE happyIn66 #-} +happyOut66 :: (HappyAbsSyn ) -> (HsQualConDecl) +happyOut66 x = unsafeCoerce# x +{-# INLINE happyOut66 #-} +happyIn67 :: ([HsName]) -> (HappyAbsSyn ) +happyIn67 x = unsafeCoerce# x +{-# INLINE happyIn67 #-} +happyOut67 :: (HappyAbsSyn ) -> ([HsName]) +happyOut67 x = unsafeCoerce# x +{-# INLINE happyOut67 #-} +happyIn68 :: (HsConDecl) -> (HappyAbsSyn ) +happyIn68 x = unsafeCoerce# x +{-# INLINE happyIn68 #-} +happyOut68 :: (HappyAbsSyn ) -> (HsConDecl) +happyOut68 x = unsafeCoerce# x +{-# INLINE happyOut68 #-} +happyIn69 :: ((HsName, [HsBangType])) -> (HappyAbsSyn ) +happyIn69 x = unsafeCoerce# x +{-# INLINE happyIn69 #-} +happyOut69 :: (HappyAbsSyn ) -> ((HsName, [HsBangType])) +happyOut69 x = unsafeCoerce# x +{-# INLINE happyOut69 #-} +happyIn70 :: ((HsName, [HsBangType])) -> (HappyAbsSyn ) +happyIn70 x = unsafeCoerce# x +{-# INLINE happyIn70 #-} +happyOut70 :: (HappyAbsSyn ) -> ((HsName, [HsBangType])) +happyOut70 x = unsafeCoerce# x +{-# INLINE happyOut70 #-} +happyIn71 :: (HsBangType) -> (HappyAbsSyn ) +happyIn71 x = unsafeCoerce# x +{-# INLINE happyIn71 #-} +happyOut71 :: (HappyAbsSyn ) -> (HsBangType) +happyOut71 x = unsafeCoerce# x +{-# INLINE happyOut71 #-} +happyIn72 :: (HsBangType) -> (HappyAbsSyn ) +happyIn72 x = unsafeCoerce# x +{-# INLINE happyIn72 #-} +happyOut72 :: (HappyAbsSyn ) -> (HsBangType) +happyOut72 x = unsafeCoerce# x +{-# INLINE happyOut72 #-} +happyIn73 :: ([([HsName],HsBangType)]) -> (HappyAbsSyn ) +happyIn73 x = unsafeCoerce# x +{-# INLINE happyIn73 #-} +happyOut73 :: (HappyAbsSyn ) -> ([([HsName],HsBangType)]) +happyOut73 x = unsafeCoerce# x +{-# INLINE happyOut73 #-} +happyIn74 :: (([HsName],HsBangType)) -> (HappyAbsSyn ) +happyIn74 x = unsafeCoerce# x +{-# INLINE happyIn74 #-} +happyOut74 :: (HappyAbsSyn ) -> (([HsName],HsBangType)) +happyOut74 x = unsafeCoerce# x +{-# INLINE happyOut74 #-} +happyIn75 :: (HsBangType) -> (HappyAbsSyn ) +happyIn75 x = unsafeCoerce# x +{-# INLINE happyIn75 #-} +happyOut75 :: (HappyAbsSyn ) -> (HsBangType) +happyOut75 x = unsafeCoerce# x +{-# INLINE happyOut75 #-} +happyIn76 :: ([HsQName]) -> (HappyAbsSyn ) +happyIn76 x = unsafeCoerce# x +{-# INLINE happyIn76 #-} +happyOut76 :: (HappyAbsSyn ) -> ([HsQName]) +happyOut76 x = unsafeCoerce# x +{-# INLINE happyOut76 #-} +happyIn77 :: ([HsQName]) -> (HappyAbsSyn ) +happyIn77 x = unsafeCoerce# x +{-# INLINE happyIn77 #-} +happyOut77 :: (HappyAbsSyn ) -> ([HsQName]) +happyOut77 x = unsafeCoerce# x +{-# INLINE happyOut77 #-} +happyIn78 :: ([HsDecl]) -> (HappyAbsSyn ) +happyIn78 x = unsafeCoerce# x +{-# INLINE happyIn78 #-} +happyOut78 :: (HappyAbsSyn ) -> ([HsDecl]) +happyOut78 x = unsafeCoerce# x +{-# INLINE happyOut78 #-} +happyIn79 :: ([HsDecl]) -> (HappyAbsSyn ) +happyIn79 x = unsafeCoerce# x +{-# INLINE happyIn79 #-} +happyOut79 :: (HappyAbsSyn ) -> ([HsDecl]) +happyOut79 x = unsafeCoerce# x +{-# INLINE happyOut79 #-} +happyIn80 :: ([HsDecl]) -> (HappyAbsSyn ) +happyIn80 x = unsafeCoerce# x +{-# INLINE happyIn80 #-} +happyOut80 :: (HappyAbsSyn ) -> ([HsDecl]) +happyOut80 x = unsafeCoerce# x +{-# INLINE happyOut80 #-} +happyIn81 :: ([HsDecl]) -> (HappyAbsSyn ) +happyIn81 x = unsafeCoerce# x +{-# INLINE happyIn81 #-} +happyOut81 :: (HappyAbsSyn ) -> ([HsDecl]) +happyOut81 x = unsafeCoerce# x +{-# INLINE happyOut81 #-} +happyIn82 :: (HsDecl) -> (HappyAbsSyn ) +happyIn82 x = unsafeCoerce# x +{-# INLINE happyIn82 #-} +happyOut82 :: (HappyAbsSyn ) -> (HsDecl) +happyOut82 x = unsafeCoerce# x +{-# INLINE happyOut82 #-} +happyIn83 :: (HsBinds) -> (HappyAbsSyn ) +happyIn83 x = unsafeCoerce# x +{-# INLINE happyIn83 #-} +happyOut83 :: (HappyAbsSyn ) -> (HsBinds) +happyOut83 x = unsafeCoerce# x +{-# INLINE happyOut83 #-} +happyIn84 :: (HsRhs) -> (HappyAbsSyn ) +happyIn84 x = unsafeCoerce# x +{-# INLINE happyIn84 #-} +happyOut84 :: (HappyAbsSyn ) -> (HsRhs) +happyOut84 x = unsafeCoerce# x +{-# INLINE happyOut84 #-} +happyIn85 :: ([HsGuardedRhs]) -> (HappyAbsSyn ) +happyIn85 x = unsafeCoerce# x +{-# INLINE happyIn85 #-} +happyOut85 :: (HappyAbsSyn ) -> ([HsGuardedRhs]) +happyOut85 x = unsafeCoerce# x +{-# INLINE happyOut85 #-} +happyIn86 :: (HsGuardedRhs) -> (HappyAbsSyn ) +happyIn86 x = unsafeCoerce# x +{-# INLINE happyIn86 #-} +happyOut86 :: (HappyAbsSyn ) -> (HsGuardedRhs) +happyOut86 x = unsafeCoerce# x +{-# INLINE happyOut86 #-} +happyIn87 :: (HsExp) -> (HappyAbsSyn ) +happyIn87 x = unsafeCoerce# x +{-# INLINE happyIn87 #-} +happyOut87 :: (HappyAbsSyn ) -> (HsExp) +happyOut87 x = unsafeCoerce# x +{-# INLINE happyOut87 #-} +happyIn88 :: (HsExp) -> (HappyAbsSyn ) +happyIn88 x = unsafeCoerce# x +{-# INLINE happyIn88 #-} +happyOut88 :: (HappyAbsSyn ) -> (HsExp) +happyOut88 x = unsafeCoerce# x +{-# INLINE happyOut88 #-} +happyIn89 :: (HsExp) -> (HappyAbsSyn ) +happyIn89 x = unsafeCoerce# x +{-# INLINE happyIn89 #-} +happyOut89 :: (HappyAbsSyn ) -> (HsExp) +happyOut89 x = unsafeCoerce# x +{-# INLINE happyOut89 #-} +happyIn90 :: (HsExp) -> (HappyAbsSyn ) +happyIn90 x = unsafeCoerce# x +{-# INLINE happyIn90 #-} +happyOut90 :: (HappyAbsSyn ) -> (HsExp) +happyOut90 x = unsafeCoerce# x +{-# INLINE happyOut90 #-} +happyIn91 :: (HsExp) -> (HappyAbsSyn ) +happyIn91 x = unsafeCoerce# x +{-# INLINE happyIn91 #-} +happyOut91 :: (HappyAbsSyn ) -> (HsExp) +happyOut91 x = unsafeCoerce# x +{-# INLINE happyOut91 #-} +happyIn92 :: (HsExp) -> (HappyAbsSyn ) +happyIn92 x = unsafeCoerce# x +{-# INLINE happyIn92 #-} +happyOut92 :: (HappyAbsSyn ) -> (HsExp) +happyOut92 x = unsafeCoerce# x +{-# INLINE happyOut92 #-} +happyIn93 :: (HsExp) -> (HappyAbsSyn ) +happyIn93 x = unsafeCoerce# x +{-# INLINE happyIn93 #-} +happyOut93 :: (HappyAbsSyn ) -> (HsExp) +happyOut93 x = unsafeCoerce# x +{-# INLINE happyOut93 #-} +happyIn94 :: ([HsPat]) -> (HappyAbsSyn ) +happyIn94 x = unsafeCoerce# x +{-# INLINE happyIn94 #-} +happyOut94 :: (HappyAbsSyn ) -> ([HsPat]) +happyOut94 x = unsafeCoerce# x +{-# INLINE happyOut94 #-} +happyIn95 :: (HsPat) -> (HappyAbsSyn ) +happyIn95 x = unsafeCoerce# x +{-# INLINE happyIn95 #-} +happyOut95 :: (HappyAbsSyn ) -> (HsPat) +happyOut95 x = unsafeCoerce# x +{-# INLINE happyOut95 #-} +happyIn96 :: (HsExp) -> (HappyAbsSyn ) +happyIn96 x = unsafeCoerce# x +{-# INLINE happyIn96 #-} +happyOut96 :: (HappyAbsSyn ) -> (HsExp) +happyOut96 x = unsafeCoerce# x +{-# INLINE happyOut96 #-} +happyIn97 :: (HsExp) -> (HappyAbsSyn ) +happyIn97 x = unsafeCoerce# x +{-# INLINE happyIn97 #-} +happyOut97 :: (HappyAbsSyn ) -> (HsExp) +happyOut97 x = unsafeCoerce# x +{-# INLINE happyOut97 #-} +happyIn98 :: (HsExp) -> (HappyAbsSyn ) +happyIn98 x = unsafeCoerce# x +{-# INLINE happyIn98 #-} +happyOut98 :: (HappyAbsSyn ) -> (HsExp) +happyOut98 x = unsafeCoerce# x +{-# INLINE happyOut98 #-} +happyIn99 :: (HsReify) -> (HappyAbsSyn ) +happyIn99 x = unsafeCoerce# x +{-# INLINE happyIn99 #-} +happyOut99 :: (HappyAbsSyn ) -> (HsReify) +happyOut99 x = unsafeCoerce# x +{-# INLINE happyOut99 #-} +happyIn100 :: (HsQName) -> (HappyAbsSyn ) +happyIn100 x = unsafeCoerce# x +{-# INLINE happyIn100 #-} +happyOut100 :: (HappyAbsSyn ) -> (HsQName) +happyOut100 x = unsafeCoerce# x +{-# INLINE happyOut100 #-} +happyIn101 :: (Int) -> (HappyAbsSyn ) +happyIn101 x = unsafeCoerce# x +{-# INLINE happyIn101 #-} +happyOut101 :: (HappyAbsSyn ) -> (Int) +happyOut101 x = unsafeCoerce# x +{-# INLINE happyOut101 #-} +happyIn102 :: ([HsExp]) -> (HappyAbsSyn ) +happyIn102 x = unsafeCoerce# x +{-# INLINE happyIn102 #-} +happyOut102 :: (HappyAbsSyn ) -> ([HsExp]) +happyOut102 x = unsafeCoerce# x +{-# INLINE happyOut102 #-} +happyIn103 :: ([HsExp]) -> (HappyAbsSyn ) +happyIn103 x = unsafeCoerce# x +{-# INLINE happyIn103 #-} +happyOut103 :: (HappyAbsSyn ) -> ([HsExp]) +happyOut103 x = unsafeCoerce# x +{-# INLINE happyOut103 #-} +happyIn104 :: (HsExp) -> (HappyAbsSyn ) +happyIn104 x = unsafeCoerce# x +{-# INLINE happyIn104 #-} +happyOut104 :: (HappyAbsSyn ) -> (HsExp) +happyOut104 x = unsafeCoerce# x +{-# INLINE happyOut104 #-} +happyIn105 :: (HsExp) -> (HappyAbsSyn ) +happyIn105 x = unsafeCoerce# x +{-# INLINE happyIn105 #-} +happyOut105 :: (HappyAbsSyn ) -> (HsExp) +happyOut105 x = unsafeCoerce# x +{-# INLINE happyOut105 #-} +happyIn106 :: (HsExp) -> (HappyAbsSyn ) +happyIn106 x = unsafeCoerce# x +{-# INLINE happyIn106 #-} +happyOut106 :: (HappyAbsSyn ) -> (HsExp) +happyOut106 x = unsafeCoerce# x +{-# INLINE happyOut106 #-} +happyIn107 :: ([HsExp]) -> (HappyAbsSyn ) +happyIn107 x = unsafeCoerce# x +{-# INLINE happyIn107 #-} +happyOut107 :: (HappyAbsSyn ) -> ([HsExp]) +happyOut107 x = unsafeCoerce# x +{-# INLINE happyOut107 #-} +happyIn108 :: (HsExp) -> (HappyAbsSyn ) +happyIn108 x = unsafeCoerce# x +{-# INLINE happyIn108 #-} +happyOut108 :: (HappyAbsSyn ) -> (HsExp) +happyOut108 x = unsafeCoerce# x +{-# INLINE happyOut108 #-} +happyIn109 :: (HsXName) -> (HappyAbsSyn ) +happyIn109 x = unsafeCoerce# x +{-# INLINE happyIn109 #-} +happyOut109 :: (HappyAbsSyn ) -> (HsXName) +happyOut109 x = unsafeCoerce# x +{-# INLINE happyOut109 #-} +happyIn110 :: (String) -> (HappyAbsSyn ) +happyIn110 x = unsafeCoerce# x +{-# INLINE happyIn110 #-} +happyOut110 :: (HappyAbsSyn ) -> (String) +happyOut110 x = unsafeCoerce# x +{-# INLINE happyOut110 #-} +happyIn111 :: ([HsXAttr]) -> (HappyAbsSyn ) +happyIn111 x = unsafeCoerce# x +{-# INLINE happyIn111 #-} +happyOut111 :: (HappyAbsSyn ) -> ([HsXAttr]) +happyOut111 x = unsafeCoerce# x +{-# INLINE happyOut111 #-} +happyIn112 :: (HsXAttr) -> (HappyAbsSyn ) +happyIn112 x = unsafeCoerce# x +{-# INLINE happyIn112 #-} +happyOut112 :: (HappyAbsSyn ) -> (HsXAttr) +happyOut112 x = unsafeCoerce# x +{-# INLINE happyOut112 #-} +happyIn113 :: (Maybe HsExp) -> (HappyAbsSyn ) +happyIn113 x = unsafeCoerce# x +{-# INLINE happyIn113 #-} +happyOut113 :: (HappyAbsSyn ) -> (Maybe HsExp) +happyOut113 x = unsafeCoerce# x +{-# INLINE happyOut113 #-} +happyIn114 :: (HsExp) -> (HappyAbsSyn ) +happyIn114 x = unsafeCoerce# x +{-# INLINE happyIn114 #-} +happyOut114 :: (HappyAbsSyn ) -> (HsExp) +happyOut114 x = unsafeCoerce# x +{-# INLINE happyOut114 #-} +happyIn115 :: (HsExp) -> (HappyAbsSyn ) +happyIn115 x = unsafeCoerce# x +{-# INLINE happyIn115 #-} +happyOut115 :: (HappyAbsSyn ) -> (HsExp) +happyOut115 x = unsafeCoerce# x +{-# INLINE happyOut115 #-} +happyIn116 :: ([HsExp]) -> (HappyAbsSyn ) +happyIn116 x = unsafeCoerce# x +{-# INLINE happyIn116 #-} +happyOut116 :: (HappyAbsSyn ) -> ([HsExp]) +happyOut116 x = unsafeCoerce# x +{-# INLINE happyOut116 #-} +happyIn117 :: ([HsStmt]) -> (HappyAbsSyn ) +happyIn117 x = unsafeCoerce# x +{-# INLINE happyIn117 #-} +happyOut117 :: (HappyAbsSyn ) -> ([HsStmt]) +happyOut117 x = unsafeCoerce# x +{-# INLINE happyOut117 #-} +happyIn118 :: (HsStmt) -> (HappyAbsSyn ) +happyIn118 x = unsafeCoerce# x +{-# INLINE happyIn118 #-} +happyOut118 :: (HappyAbsSyn ) -> (HsStmt) +happyOut118 x = unsafeCoerce# x +{-# INLINE happyOut118 #-} +happyIn119 :: ([HsAlt]) -> (HappyAbsSyn ) +happyIn119 x = unsafeCoerce# x +{-# INLINE happyIn119 #-} +happyOut119 :: (HappyAbsSyn ) -> ([HsAlt]) +happyOut119 x = unsafeCoerce# x +{-# INLINE happyOut119 #-} +happyIn120 :: ([HsAlt]) -> (HappyAbsSyn ) +happyIn120 x = unsafeCoerce# x +{-# INLINE happyIn120 #-} +happyOut120 :: (HappyAbsSyn ) -> ([HsAlt]) +happyOut120 x = unsafeCoerce# x +{-# INLINE happyOut120 #-} +happyIn121 :: ([HsAlt]) -> (HappyAbsSyn ) +happyIn121 x = unsafeCoerce# x +{-# INLINE happyIn121 #-} +happyOut121 :: (HappyAbsSyn ) -> ([HsAlt]) +happyOut121 x = unsafeCoerce# x +{-# INLINE happyOut121 #-} +happyIn122 :: (HsAlt) -> (HappyAbsSyn ) +happyIn122 x = unsafeCoerce# x +{-# INLINE happyIn122 #-} +happyOut122 :: (HappyAbsSyn ) -> (HsAlt) +happyOut122 x = unsafeCoerce# x +{-# INLINE happyOut122 #-} +happyIn123 :: (HsGuardedAlts) -> (HappyAbsSyn ) +happyIn123 x = unsafeCoerce# x +{-# INLINE happyIn123 #-} +happyOut123 :: (HappyAbsSyn ) -> (HsGuardedAlts) +happyOut123 x = unsafeCoerce# x +{-# INLINE happyOut123 #-} +happyIn124 :: ([HsGuardedAlt]) -> (HappyAbsSyn ) +happyIn124 x = unsafeCoerce# x +{-# INLINE happyIn124 #-} +happyOut124 :: (HappyAbsSyn ) -> ([HsGuardedAlt]) +happyOut124 x = unsafeCoerce# x +{-# INLINE happyOut124 #-} +happyIn125 :: (HsGuardedAlt) -> (HappyAbsSyn ) +happyIn125 x = unsafeCoerce# x +{-# INLINE happyIn125 #-} +happyOut125 :: (HappyAbsSyn ) -> (HsGuardedAlt) +happyOut125 x = unsafeCoerce# x +{-# INLINE happyOut125 #-} +happyIn126 :: (HsPat) -> (HappyAbsSyn ) +happyIn126 x = unsafeCoerce# x +{-# INLINE happyIn126 #-} +happyOut126 :: (HappyAbsSyn ) -> (HsPat) +happyOut126 x = unsafeCoerce# x +{-# INLINE happyOut126 #-} +happyIn127 :: ([HsStmt]) -> (HappyAbsSyn ) +happyIn127 x = unsafeCoerce# x +{-# INLINE happyIn127 #-} +happyOut127 :: (HappyAbsSyn ) -> ([HsStmt]) +happyOut127 x = unsafeCoerce# x +{-# INLINE happyOut127 #-} +happyIn128 :: ([HsStmt]) -> (HappyAbsSyn ) +happyIn128 x = unsafeCoerce# x +{-# INLINE happyIn128 #-} +happyOut128 :: (HappyAbsSyn ) -> ([HsStmt]) +happyOut128 x = unsafeCoerce# x +{-# INLINE happyOut128 #-} +happyIn129 :: ([HsFieldUpdate]) -> (HappyAbsSyn ) +happyIn129 x = unsafeCoerce# x +{-# INLINE happyIn129 #-} +happyOut129 :: (HappyAbsSyn ) -> ([HsFieldUpdate]) +happyOut129 x = unsafeCoerce# x +{-# INLINE happyOut129 #-} +happyIn130 :: (HsFieldUpdate) -> (HappyAbsSyn ) +happyIn130 x = unsafeCoerce# x +{-# INLINE happyIn130 #-} +happyOut130 :: (HappyAbsSyn ) -> (HsFieldUpdate) +happyOut130 x = unsafeCoerce# x +{-# INLINE happyOut130 #-} +happyIn131 :: ([HsIPBind]) -> (HappyAbsSyn ) +happyIn131 x = unsafeCoerce# x +{-# INLINE happyIn131 #-} +happyOut131 :: (HappyAbsSyn ) -> ([HsIPBind]) +happyOut131 x = unsafeCoerce# x +{-# INLINE happyOut131 #-} +happyIn132 :: ([HsIPBind]) -> (HappyAbsSyn ) +happyIn132 x = unsafeCoerce# x +{-# INLINE happyIn132 #-} +happyOut132 :: (HappyAbsSyn ) -> ([HsIPBind]) +happyOut132 x = unsafeCoerce# x +{-# INLINE happyOut132 #-} +happyIn133 :: ([HsIPBind]) -> (HappyAbsSyn ) +happyIn133 x = unsafeCoerce# x +{-# INLINE happyIn133 #-} +happyOut133 :: (HappyAbsSyn ) -> ([HsIPBind]) +happyOut133 x = unsafeCoerce# x +{-# INLINE happyOut133 #-} +happyIn134 :: (HsIPBind) -> (HappyAbsSyn ) +happyIn134 x = unsafeCoerce# x +{-# INLINE happyIn134 #-} +happyOut134 :: (HappyAbsSyn ) -> (HsIPBind) +happyOut134 x = unsafeCoerce# x +{-# INLINE happyOut134 #-} +happyIn135 :: (HsExp) -> (HappyAbsSyn ) +happyIn135 x = unsafeCoerce# x +{-# INLINE happyIn135 #-} +happyOut135 :: (HappyAbsSyn ) -> (HsExp) +happyOut135 x = unsafeCoerce# x +{-# INLINE happyOut135 #-} +happyIn136 :: (HsName) -> (HappyAbsSyn ) +happyIn136 x = unsafeCoerce# x +{-# INLINE happyIn136 #-} +happyOut136 :: (HappyAbsSyn ) -> (HsName) +happyOut136 x = unsafeCoerce# x +{-# INLINE happyOut136 #-} +happyIn137 :: (HsName) -> (HappyAbsSyn ) +happyIn137 x = unsafeCoerce# x +{-# INLINE happyIn137 #-} +happyOut137 :: (HappyAbsSyn ) -> (HsName) +happyOut137 x = unsafeCoerce# x +{-# INLINE happyOut137 #-} +happyIn138 :: (HsQName) -> (HappyAbsSyn ) +happyIn138 x = unsafeCoerce# x +{-# INLINE happyIn138 #-} +happyOut138 :: (HappyAbsSyn ) -> (HsQName) +happyOut138 x = unsafeCoerce# x +{-# INLINE happyOut138 #-} +happyIn139 :: (HsIPName) -> (HappyAbsSyn ) +happyIn139 x = unsafeCoerce# x +{-# INLINE happyIn139 #-} +happyOut139 :: (HappyAbsSyn ) -> (HsIPName) +happyOut139 x = unsafeCoerce# x +{-# INLINE happyOut139 #-} +happyIn140 :: (HsName) -> (HappyAbsSyn ) +happyIn140 x = unsafeCoerce# x +{-# INLINE happyIn140 #-} +happyOut140 :: (HappyAbsSyn ) -> (HsName) +happyOut140 x = unsafeCoerce# x +{-# INLINE happyOut140 #-} +happyIn141 :: (HsQName) -> (HappyAbsSyn ) +happyIn141 x = unsafeCoerce# x +{-# INLINE happyIn141 #-} +happyOut141 :: (HappyAbsSyn ) -> (HsQName) +happyOut141 x = unsafeCoerce# x +{-# INLINE happyOut141 #-} +happyIn142 :: (HsName) -> (HappyAbsSyn ) +happyIn142 x = unsafeCoerce# x +{-# INLINE happyIn142 #-} +happyOut142 :: (HappyAbsSyn ) -> (HsName) +happyOut142 x = unsafeCoerce# x +{-# INLINE happyOut142 #-} +happyIn143 :: (HsQName) -> (HappyAbsSyn ) +happyIn143 x = unsafeCoerce# x +{-# INLINE happyIn143 #-} +happyOut143 :: (HappyAbsSyn ) -> (HsQName) +happyOut143 x = unsafeCoerce# x +{-# INLINE happyOut143 #-} +happyIn144 :: (HsQName) -> (HappyAbsSyn ) +happyIn144 x = unsafeCoerce# x +{-# INLINE happyIn144 #-} +happyOut144 :: (HappyAbsSyn ) -> (HsQName) +happyOut144 x = unsafeCoerce# x +{-# INLINE happyOut144 #-} +happyIn145 :: (HsName) -> (HappyAbsSyn ) +happyIn145 x = unsafeCoerce# x +{-# INLINE happyIn145 #-} +happyOut145 :: (HappyAbsSyn ) -> (HsName) +happyOut145 x = unsafeCoerce# x +{-# INLINE happyOut145 #-} +happyIn146 :: (HsQName) -> (HappyAbsSyn ) +happyIn146 x = unsafeCoerce# x +{-# INLINE happyIn146 #-} +happyOut146 :: (HappyAbsSyn ) -> (HsQName) +happyOut146 x = unsafeCoerce# x +{-# INLINE happyOut146 #-} +happyIn147 :: (HsOp) -> (HappyAbsSyn ) +happyIn147 x = unsafeCoerce# x +{-# INLINE happyIn147 #-} +happyOut147 :: (HappyAbsSyn ) -> (HsOp) +happyOut147 x = unsafeCoerce# x +{-# INLINE happyOut147 #-} +happyIn148 :: (HsQOp) -> (HappyAbsSyn ) +happyIn148 x = unsafeCoerce# x +{-# INLINE happyIn148 #-} +happyOut148 :: (HappyAbsSyn ) -> (HsQOp) +happyOut148 x = unsafeCoerce# x +{-# INLINE happyOut148 #-} +happyIn149 :: (HsQOp) -> (HappyAbsSyn ) +happyIn149 x = unsafeCoerce# x +{-# INLINE happyIn149 #-} +happyOut149 :: (HappyAbsSyn ) -> (HsQOp) +happyOut149 x = unsafeCoerce# x +{-# INLINE happyOut149 #-} +happyIn150 :: (HsQName) -> (HappyAbsSyn ) +happyIn150 x = unsafeCoerce# x +{-# INLINE happyIn150 #-} +happyOut150 :: (HappyAbsSyn ) -> (HsQName) +happyOut150 x = unsafeCoerce# x +{-# INLINE happyOut150 #-} +happyIn151 :: (HsQName) -> (HappyAbsSyn ) +happyIn151 x = unsafeCoerce# x +{-# INLINE happyIn151 #-} +happyOut151 :: (HappyAbsSyn ) -> (HsQName) +happyOut151 x = unsafeCoerce# x +{-# INLINE happyOut151 #-} +happyIn152 :: (HsName) -> (HappyAbsSyn ) +happyIn152 x = unsafeCoerce# x +{-# INLINE happyIn152 #-} +happyOut152 :: (HappyAbsSyn ) -> (HsName) +happyOut152 x = unsafeCoerce# x +{-# INLINE happyOut152 #-} +happyIn153 :: (HsName) -> (HappyAbsSyn ) +happyIn153 x = unsafeCoerce# x +{-# INLINE happyIn153 #-} +happyOut153 :: (HappyAbsSyn ) -> (HsName) +happyOut153 x = unsafeCoerce# x +{-# INLINE happyOut153 #-} +happyIn154 :: (HsIPName) -> (HappyAbsSyn ) +happyIn154 x = unsafeCoerce# x +{-# INLINE happyIn154 #-} +happyOut154 :: (HappyAbsSyn ) -> (HsIPName) +happyOut154 x = unsafeCoerce# x +{-# INLINE happyOut154 #-} +happyIn155 :: (HsQName) -> (HappyAbsSyn ) +happyIn155 x = unsafeCoerce# x +{-# INLINE happyIn155 #-} +happyOut155 :: (HappyAbsSyn ) -> (HsQName) +happyOut155 x = unsafeCoerce# x +{-# INLINE happyOut155 #-} +happyIn156 :: (HsName) -> (HappyAbsSyn ) +happyIn156 x = unsafeCoerce# x +{-# INLINE happyIn156 #-} +happyOut156 :: (HappyAbsSyn ) -> (HsName) +happyOut156 x = unsafeCoerce# x +{-# INLINE happyOut156 #-} +happyIn157 :: (HsQName) -> (HappyAbsSyn ) +happyIn157 x = unsafeCoerce# x +{-# INLINE happyIn157 #-} +happyOut157 :: (HappyAbsSyn ) -> (HsQName) +happyOut157 x = unsafeCoerce# x +{-# INLINE happyOut157 #-} +happyIn158 :: (HsName) -> (HappyAbsSyn ) +happyIn158 x = unsafeCoerce# x +{-# INLINE happyIn158 #-} +happyOut158 :: (HappyAbsSyn ) -> (HsName) +happyOut158 x = unsafeCoerce# x +{-# INLINE happyOut158 #-} +happyIn159 :: (HsQName) -> (HappyAbsSyn ) +happyIn159 x = unsafeCoerce# x +{-# INLINE happyIn159 #-} +happyOut159 :: (HappyAbsSyn ) -> (HsQName) +happyOut159 x = unsafeCoerce# x +{-# INLINE happyOut159 #-} +happyIn160 :: (HsQName) -> (HappyAbsSyn ) +happyIn160 x = unsafeCoerce# x +{-# INLINE happyIn160 #-} +happyOut160 :: (HappyAbsSyn ) -> (HsQName) +happyOut160 x = unsafeCoerce# x +{-# INLINE happyOut160 #-} +happyIn161 :: (HsName) -> (HappyAbsSyn ) +happyIn161 x = unsafeCoerce# x +{-# INLINE happyIn161 #-} +happyOut161 :: (HappyAbsSyn ) -> (HsName) +happyOut161 x = unsafeCoerce# x +{-# INLINE happyOut161 #-} +happyIn162 :: (HsName) -> (HappyAbsSyn ) +happyIn162 x = unsafeCoerce# x +{-# INLINE happyIn162 #-} +happyOut162 :: (HappyAbsSyn ) -> (HsName) +happyOut162 x = unsafeCoerce# x +{-# INLINE happyOut162 #-} +happyIn163 :: (HsQName) -> (HappyAbsSyn ) +happyIn163 x = unsafeCoerce# x +{-# INLINE happyIn163 #-} +happyOut163 :: (HappyAbsSyn ) -> (HsQName) +happyOut163 x = unsafeCoerce# x +{-# INLINE happyOut163 #-} +happyIn164 :: (HsLiteral) -> (HappyAbsSyn ) +happyIn164 x = unsafeCoerce# x +{-# INLINE happyIn164 #-} +happyOut164 :: (HappyAbsSyn ) -> (HsLiteral) +happyOut164 x = unsafeCoerce# x +{-# INLINE happyOut164 #-} +happyIn165 :: (SrcLoc) -> (HappyAbsSyn ) +happyIn165 x = unsafeCoerce# x +{-# INLINE happyIn165 #-} +happyOut165 :: (HappyAbsSyn ) -> (SrcLoc) +happyOut165 x = unsafeCoerce# x +{-# INLINE happyOut165 #-} +happyIn166 :: (()) -> (HappyAbsSyn ) +happyIn166 x = unsafeCoerce# x +{-# INLINE happyIn166 #-} +happyOut166 :: (HappyAbsSyn ) -> (()) +happyOut166 x = unsafeCoerce# x +{-# INLINE happyOut166 #-} +happyIn167 :: (()) -> (HappyAbsSyn ) +happyIn167 x = unsafeCoerce# x +{-# INLINE happyIn167 #-} +happyOut167 :: (HappyAbsSyn ) -> (()) +happyOut167 x = unsafeCoerce# x +{-# INLINE happyOut167 #-} +happyIn168 :: (Module) -> (HappyAbsSyn ) +happyIn168 x = unsafeCoerce# x +{-# INLINE happyIn168 #-} +happyOut168 :: (HappyAbsSyn ) -> (Module) +happyOut168 x = unsafeCoerce# x +{-# INLINE happyOut168 #-} +happyIn169 :: (HsName) -> (HappyAbsSyn ) +happyIn169 x = unsafeCoerce# x +{-# INLINE happyIn169 #-} +happyOut169 :: (HappyAbsSyn ) -> (HsName) +happyOut169 x = unsafeCoerce# x +{-# INLINE happyOut169 #-} +happyIn170 :: (HsName) -> (HappyAbsSyn ) +happyIn170 x = unsafeCoerce# x +{-# INLINE happyIn170 #-} +happyOut170 :: (HappyAbsSyn ) -> (HsName) +happyOut170 x = unsafeCoerce# x +{-# INLINE happyOut170 #-} +happyIn171 :: (HsQName) -> (HappyAbsSyn ) +happyIn171 x = unsafeCoerce# x +{-# INLINE happyIn171 #-} +happyOut171 :: (HappyAbsSyn ) -> (HsQName) +happyOut171 x = unsafeCoerce# x +{-# INLINE happyOut171 #-} +happyIn172 :: (HsQName) -> (HappyAbsSyn ) +happyIn172 x = unsafeCoerce# x +{-# INLINE happyIn172 #-} +happyOut172 :: (HappyAbsSyn ) -> (HsQName) +happyOut172 x = unsafeCoerce# x +{-# INLINE happyOut172 #-} +happyIn173 :: (HsName) -> (HappyAbsSyn ) +happyIn173 x = unsafeCoerce# x +{-# INLINE happyIn173 #-} +happyOut173 :: (HappyAbsSyn ) -> (HsName) +happyOut173 x = unsafeCoerce# x +{-# INLINE happyOut173 #-} +happyIn174 :: (HsQName) -> (HappyAbsSyn ) +happyIn174 x = unsafeCoerce# x +{-# INLINE happyIn174 #-} +happyOut174 :: (HappyAbsSyn ) -> (HsQName) +happyOut174 x = unsafeCoerce# x +{-# INLINE happyOut174 #-} +happyIn175 :: (HsName) -> (HappyAbsSyn ) +happyIn175 x = unsafeCoerce# x +{-# INLINE happyIn175 #-} +happyOut175 :: (HappyAbsSyn ) -> (HsName) +happyOut175 x = unsafeCoerce# x +{-# INLINE happyOut175 #-} +happyInTok :: Token -> (HappyAbsSyn ) +happyInTok x = unsafeCoerce# x +{-# INLINE happyInTok #-} +happyOutTok :: (HappyAbsSyn ) -> Token +happyOutTok x = unsafeCoerce# x +{-# INLINE happyOutTok #-} + + +happyActOffsets :: HappyAddr +happyActOffsets = HappyA# "\xab\x05\x00\x00\x00\x00\xac\x05\x81\x05\x00\x00\xbc\x00\x00\x00\x9e\x05\x7d\x00\x00\x00\x00\x00\x00\x00\xa7\x01\x83\x04\xd4\x05\x00\x00\x00\x00\x00\x00\xc4\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xca\x05\x00\x00\x65\x04\x11\x02\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\xf3\x05\x00\x00\x00\x00\xa7\x01\xf9\x10\x79\x05\x00\x00\x1d\x11\xcd\x05\xb6\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbf\x05\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x04\x00\x00\xc8\x05\x00\x00\x9e\x03\x00\x00\x00\x00\xad\x05\x00\x00\x39\x04\x00\x00\xcc\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x01\xc0\x01\x00\x00\x00\x00\x7a\x01\x00\x00\x00\x00\x00\x00\x00\x00\x03\x04\xd7\x09\x00\x00\xea\x11\x0d\x0e\x00\x00\x0d\x0e\x0d\x0e\x0d\x0e\xbd\x13\x00\x00\x0d\x0e\x00\x00\xc0\x05\xf5\x02\x58\x08\x00\x00\x4a\x11\x00\x00\x00\x00\x00\x00\xa3\x01\x00\x00\xea\x11\x0d\x0e\xb2\x14\x86\x14\x86\x14\xf5\x01\x0d\x0e\xbd\x13\xbd\x13\xba\x05\xb1\x05\x55\x05\x00\x00\x00\x00\x00\x00\xbd\x13\xa9\x05\xbd\x13\xb5\x05\x89\x05\xa5\x05\xcf\x04\xa5\x05\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x06\x9c\x05\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x12\x00\x00\x00\x00\x97\x05\x8f\x05\x95\x05\x00\x00\x00\x00\x00\x00\x98\x12\xdf\x13\x90\x13\x00\x00\x00\x00\x75\x09\x75\x09\x45\x05\x75\x04\x00\x00\x00\x00\xdf\x13\xa6\x00\x90\x05\x4c\x05\x00\x00\x00\x00\x0f\x11\x00\x00\x00\x00\x9a\x05\x0d\x0e\x99\x05\x29\x04\x29\x04\x00\x00\x00\x00\x00\x00\x94\x07\x93\x05\x00\x00\x00\x00\x00\x00\xf6\x07\x92\x05\x98\x05\x4a\x11\xea\x11\xea\x11\x00\x00\x40\x05\x83\x05\x00\x00\x00\x00\x00\x00\xa0\x10\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x05\x00\x00\x00\x00\x00\x00\x00\x00\x34\x06\x00\x00\x00\x00\x0d\x0e\x00\x00\x00\x00\xc0\x07\x6d\x13\x51\x02\x00\x00\x5b\x05\x00\x00\x6a\x05\x57\x05\x52\x07\x56\x05\x70\x05\x4b\x05\xb6\x00\x00\x00\x00\x00\x00\x00\x19\x03\x78\x05\x6f\x05\x00\x00\x48\x01\x0f\x11\x32\x03\x23\x03\x6e\x05\x00\x00\x00\x00\x0d\x0e\x6d\x05\x6b\x05\x00\x00\x00\x00\x69\x05\x68\x05\x00\x00\x00\x00\x34\x06\x67\x05\x4a\x11\x66\x05\x0d\x0e\xa7\x01\x00\x00\x00\x00\xea\x11\xdf\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc6\x14\x65\x05\x6d\x11\x00\x00\x00\x00\x00\x00\xd7\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf2\x01\x00\x00\x5d\x05\xb7\x02\x00\x00\x4e\x05\x00\x00\x00\x00\xbe\x03\x00\x00\x66\x01\x49\x05\x43\x05\x00\x00\x00\x00\x4d\x05\x00\x00\x00\x00\x0d\x0e\x00\x00\x00\x00\xab\x0d\x00\x00\x48\x05\x00\x00\x49\x0d\x49\x0d\x49\x0d\x00\x00\x49\x0d\x4f\x08\xe7\x0c\x85\x0c\x00\x00\x00\x00\x00\x00\x8c\x0f\x00\x00\x00\x00\x39\x01\x00\x00\x41\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x09\x00\x00\x00\x00\x3b\x02\x00\x00\x3d\x05\x23\x0c\x00\x00\x00\x00\x00\x00\x42\x05\x00\x00\x00\x00\x39\x05\x00\x00\xd6\x02\x00\x00\x3f\x05\x3e\x05\xbb\x01\x00\x00\x00\x00\x41\x12\x00\x00\xf0\x04\x00\x00\x00\x00\xe7\x04\xef\x04\x00\x00\x00\x00\xea\x11\x35\x05\xd8\x04\x00\x00\xe4\x04\x00\x00\x22\x05\x23\x05\x18\x05\xbb\x12\x00\x00\x16\x05\xe6\x04\x00\x00\x12\x05\x17\x05\x8b\x03\x00\x00\x13\x05\x75\x09\x11\x05\x39\x01\xfc\x06\x0b\x05\x00\x00\x0a\x02\x09\x05\x05\x05\x04\x05\x63\x14\xdf\x13\x00\x00\x00\x00\x63\x14\x00\x00\x63\x14\x00\x00\x00\x00\xdb\x08\x63\x14\xbb\x05\x6d\x13\x00\x00\x00\x00\x00\x00\xf8\x04\x00\x00\x00\x00\xbe\x04\xb4\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdf\x13\x00\x00\x6d\x13\x00\x00\x9e\x00\x00\x00\x00\x00\xec\x04\xc7\x06\x00\x00\x00\x00\x0f\x00\x69\x04\xdf\x13\x00\x00\x00\x00\x00\x00\x00\x00\xe2\x04\x00\x00\x00\x00\x55\x03\x97\x04\xea\x04\x00\x00\x00\x00\xe8\x04\x00\x00\x00\x00\x00\x00\x9a\x11\x00\x00\x00\x00\xdf\x04\xe5\x04\x39\x01\xc1\x0b\xc1\x0b\xed\x07\xe3\x04\xe1\x04\x39\x01\x39\x01\xc1\x0b\x00\x00\xd5\x04\x00\x00\x8f\x06\x3b\x02\x41\x12\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x01\x00\x00\x00\x00\xdd\x04\x00\x00\xdc\x04\xd3\x04\xd0\x04\x51\x02\xac\x04\x00\x00\x00\x00\xd1\x04\x00\x00\xbc\x04\x00\x00\xb3\x04\x00\x00\x00\x00\x00\x00\x6d\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x10\x00\x00\x00\x00\xd9\x00\x00\x00\xa7\x01\xc1\x0b\x00\x00\x4b\x15\x00\x00\xc8\x04\x00\x00\x34\x15\x00\x00\x00\x00\x00\x00\x00\x00\x92\x04\xc1\x0b\x1d\x04\x00\x00\x8b\x07\x5f\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7c\x04\xaa\x04\xfd\x0a\x00\x00\xb7\x04\xa6\x04\x63\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2a\x0f\x6a\x04\x00\x00\x00\x00\x00\x00\x5d\x04\x00\x00\xfd\x0a\xa5\x04\x95\x04\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x02\x00\x00\x98\x04\x94\x04\x2b\x00\x8e\x04\x00\x00\x00\x00\x00\x00\x8b\x04\x00\x00\xd1\x0e\x90\x04\x2b\x00\x00\x00\xfd\x0a\x75\x09\x00\x00\x00\x00\x5c\x14\x00\x00\x00\x00\x00\x00\x38\x04\x11\x13\x6f\x04\x00\x00\x00\x00\x36\x14\x3c\x01\x85\x04\x84\x04\x17\x12\x63\x14\x00\x00\x82\x04\x00\x00\x00\x00\x00\x00\x00\x00\x47\x10\xd8\x14\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x02\x00\x00\xb4\x02\x00\x00\x00\x00\xbb\x05\x00\x00\x29\x07\x00\x00\x00\x00\x00\x00\x00\x00\x47\x10\x00\x00\x74\x04\xfd\x0a\x74\x04\x5b\x04\x80\x04\x13\x09\x80\x04\x00\x00\x63\x14\x00\x00\x00\x00\xfd\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x01\x00\x00\x00\x00\xb4\x03\x00\x00\x00\x00\x00\x00\x6f\x0e\x00\x00\xfd\x0a\x00\x00\x52\x07\x6e\x04\xee\x0f\x7b\x04\x00\x00\x55\x04\x6d\x04\x20\x02\x32\x02\x77\x04\x79\x04\x62\x04\x00\x00\x00\x00\x00\x00\x60\x04\xee\x0f\x40\x04\xb1\x08\x00\x00\x51\x05\x0c\x14\x73\x04\x00\x00\x00\x00\x63\x14\xe6\x13\x63\x14\x00\x00\x00\x00\x66\x13\x00\x00\x00\x00\x63\x14\x00\x00\x74\x02\x35\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0e\x12\x15\x04\x07\x15\x00\x00\x00\x00\x40\x13\x00\x00\x00\x00\xd8\x03\x12\x04\x00\x00\x0e\x04\xfd\x0a\x00\x00\xa7\x01\xe3\x03\x00\x00\x9b\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x02\x00\x00\x10\x04\x00\x00\xf2\x14\xe7\x12\x00\x00\x00\x00\x63\x14\x00\x00\x00\x00\x00\x00\xb9\x00\x00\x00\x39\x0a\x00\x00\x00\x00\x00\x00"# + +happyGotoOffsets :: HappyAddr +happyGotoOffsets = HappyA# "\x01\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\x00\x08\x00\x00\x00\x06\x00\x00\x00\x8c\x03\x84\x03\xe1\x03\x78\x03\x4f\x04\x00\x00\x00\x00\xb8\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0b\x00\x56\x03\x77\x03\x03\x00\x00\x00\x00\x00\x00\x00\x43\x04\x00\x00\x00\x00\x00\x00\xb9\x03\x00\x00\x00\x00\x00\x00\x00\x00\xe4\x00\x00\x00\x00\x00\x7c\x03\xea\x17\x00\x00\x00\x00\x07\x00\x00\x00\xda\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x03\x00\x00\x05\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x52\x15\xfd\x18\x00\x00\xeb\x1f\xae\x16\x00\x00\xfa\x1d\xb4\x1d\x5c\x1e\x49\x02\x3e\x03\x98\x1d\x00\x00\xc5\x03\x00\x00\xb1\x0e\x00\x00\xb8\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd2\x16\x52\x1d\x83\x02\x8a\x05\x6b\x04\x00\x00\x36\x1d\x33\x02\x1d\x02\x00\x00\xb8\x00\xac\x03\x00\x00\x00\x00\x00\x00\x06\x02\x9d\x00\xea\x01\xdb\xff\x4f\x00\x00\x00\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe4\x00\x00\x00\x00\x00\x7e\x03\x00\x00\x00\x00\xb6\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x01\x5f\x02\x97\x02\x75\x03\x00\x00\xb7\x18\x71\x18\x5b\x03\xff\x02\x00\x00\x00\x00\x26\x00\x5f\x03\x46\x03\x00\x00\x00\x00\x00\x00\x8e\x0a\x00\x00\xd1\x02\xc0\xff\xf0\x1c\x45\x00\x58\x03\x42\x03\x00\x00\x00\x00\x00\x00\x61\x03\x00\x00\x00\x00\x00\x00\x00\x00\x45\x01\x00\x00\x00\x00\xb8\x1f\xa2\x1f\x6f\x1f\x00\x00\x20\x03\xce\xff\x00\x00\x00\x00\x00\x00\x10\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x03\x00\x00\x00\x00\xd4\x1c\x00\x00\x00\x00\x6a\x02\xd4\x01\xf1\xff\x00\x00\x00\x00\xf8\xff\x00\x00\x00\x00\x8e\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x1e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x24\x03\x00\x00\xd2\x16\x00\x00\x92\x16\x6f\x03\xfb\x02\x00\x00\x59\x1f\xb1\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\xfc\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x01\xee\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8e\x1c\x00\x00\x00\x00\xdd\x1e\xb1\x02\xbe\xff\x00\x00\x72\x1c\x1c\x19\x2c\x1c\x00\x00\x10\x1c\xca\x1b\x4c\x16\x52\x18\x00\x00\x00\x00\x00\x00\xdd\x1e\x00\x00\x00\x00\xb3\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x02\x00\x00\x00\x00\x99\x02\x00\x00\x00\x00\x06\x16\x00\x00\x00\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x02\x00\x00\x00\x00\x49\x00\x00\x00\x00\x00\x35\x00\x2f\x00\x00\x00\x00\x00\x65\x00\x56\x00\xa4\x17\xa7\xff\xa5\x02\xb6\x03\xa2\x02\x87\x00\xd5\xff\x00\x00\x00\x00\xb6\x02\x00\x00\x00\x00\xc5\x02\x00\x00\x30\x02\x00\x00\xca\x09\x2e\x02\x00\x00\x0c\x18\x21\x00\x13\x02\xdb\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x02\x92\x02\x6c\x00\x00\x00\xcf\x02\x00\x00\xc0\x02\x00\x00\x00\x00\x2c\x03\xaa\x02\xdb\x01\xbe\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2f\x02\xad\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7c\x02\x00\x00\xa5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc6\x17\x79\x01\x47\x01\x65\x03\xbd\x01\x76\x02\x00\x00\x00\x00\xe9\x00\x24\x00\x00\x00\x00\x00\x00\x00\xef\x01\xdb\x01\x00\x00\x00\x00\x00\x00\xf4\xff\x00\x00\x77\x00\x68\x00\x26\x1f\x00\x00\x00\x00\x29\x01\x00\x00\x0b\x02\xae\x1b\x68\x1b\x3e\x00\x00\x00\x00\x00\x08\x02\x87\x01\x4c\x1b\x00\x00\x00\x00\x00\x00\xfe\x01\x5c\x01\x2e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x01\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8b\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x17\x00\x00\x00\x00\x00\x00\x00\x00\x35\x03\x06\x1b\x00\x00\x92\x01\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe7\x15\x00\x00\x00\x00\xea\x1a\x80\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x1a\x00\x00\x00\x00\x00\x00\x2a\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x03\x00\x00\xa7\x03\x00\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x01\x00\x00\x88\x1a\x0c\x01\x00\x00\xe0\x00\x00\x00\xd2\x01\xc6\x01\x07\x01\x31\x01\x00\x00\x00\x00\xcc\x00\x36\x00\xe2\xff\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x00\x00\x53\x00\x00\x00\x42\x1a\x3a\x17\x00\x00\x00\x00\x05\x03\x4b\x00\x00\x00\x00\x00\xdb\x01\x5a\x03\x00\x00\x00\x00\x00\x00\x01\x02\x49\x01\x00\x00\x00\x00\x00\x01\x4d\x03\x00\x00\x00\x00\x00\x00\x00\x00\x92\x03\x00\x00\xc1\x1e\x1c\x00\x00\x00\x00\x00\x7f\x03\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x01\x00\x00\x27\x00\x00\x00\x00\x00\x1c\x03\x00\x00\x7b\x1e\x00\x00\x00\x00\x26\x1a\x00\x00\x48\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x1b\x01\x00\x00\x00\x00\xe0\x19\x00\x00\x00\x00\xf3\xff\x00\x00\x00\x00\x00\x00\x00\x00\x06\x01\x00\x00\x00\x00\x00\x00\x7c\x00\x00\x00\xc4\x19\x00\x00\x99\x03\x4f\x01\xab\xff\x00\x00\x00\x00\xa9\x01\x00\x00\x67\x02\xe3\xff\x00\x00\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x78\x00\x00\x00\xf4\x16\x00\x00\x37\x03\x0d\x03\x8c\xff\x00\x00\x00\x00\x47\x03\x3f\x03\x31\x03\x00\x00\x00\x00\xf7\x02\x00\x00\x00\x00\xf7\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x64\x00\x00\x00\xf2\xff\x00\x00\x00\x00\x75\x01\x00\x00\x00\x00\xed\xff\x50\x00\x00\x00\x00\x00\x7e\x19\x00\x00\x26\x02\x00\x00\x00\x00\xa1\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x00\x46\x01\x00\x00\x00\x00\xa0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x19\x00\x00\x00\x00\x00\x00"# + +happyDefActions :: HappyAddr +happyDefActions = HappyA# "\x6f\xfe\x00\x00\xfe\xff\x00\x00\x00\x00\xfc\xff\x6e\xfe\x6f\xfe\x00\x00\x6e\xfe\xf8\xff\xef\xff\xef\xff\x00\x00\x00\x00\xed\xff\x6b\xfe\x6a\xfe\xe5\xfe\xec\xfe\xeb\xfe\xea\xfe\xe9\xfe\xe7\xfe\xe8\xfe\x00\x00\xf0\xff\xf2\xff\x00\x00\x6f\xfe\x6f\xfe\xf6\xff\x6c\xfe\x6d\xfe\xef\xff\xdf\xff\xaa\xff\xf4\xff\xef\xff\xbe\xff\xb3\xff\xab\xff\xa9\xff\x6f\xfe\xf1\xff\xf7\xff\x00\x00\x6f\xfe\x00\x00\xee\xff\xe9\xff\x00\x00\xe9\xff\xe7\xff\xe6\xff\xad\xfe\x8b\xfe\x94\xfe\x67\xfe\x85\xfe\xe5\xff\x92\xfe\x93\xfe\x83\xfe\x84\xfe\x00\x00\xea\xff\x8e\xfe\x8a\xfe\x89\xfe\x88\xfe\x8d\xfe\x8c\xfe\x91\xfe\x8f\xfe\x00\x00\x90\xfe\x6e\xfe\xe3\xfe\x23\xff\x1a\xff\x0c\xff\x00\x00\xe6\xfe\x00\x00\x17\xff\x18\xff\x19\xff\xb2\xfe\xab\xfe\xa8\xfe\x16\xff\x00\x00\x92\xfe\x87\xfe\x86\xfe\x83\xfe\x73\xfe\x71\xfe\x72\xfe\x70\xfe\x6f\xfe\x6f\xfe\x10\xff\x6f\xfe\x6f\xfe\x0b\xff\x6f\xfe\x6f\xfe\x6f\xfe\x00\x00\x6e\xfe\x6f\xfe\xed\xfe\xc7\xff\x00\x00\x6f\xfe\x36\xff\x2c\xff\x2a\xff\x2d\xff\x37\xff\x18\xff\xe1\xfe\x6f\xfe\x6f\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\x00\x00\x00\x00\x00\x00\x6e\xfe\xdc\xff\xc5\xff\xc4\xff\xc3\xff\x00\x00\x6e\xfe\x00\x00\x00\x00\xf0\xff\xc0\xff\xf0\xff\xf3\xff\xfd\xff\xe0\xff\xf5\xff\xbf\xff\x6f\xfe\x00\x00\x68\xfe\x7b\xff\x93\xff\x82\xff\x98\xff\x91\xff\x90\xff\x00\x00\x00\x00\x00\x00\x65\xfe\x8a\xff\x8f\xff\x00\x00\x00\x00\x00\x00\x7b\xff\x2e\xff\x6f\xfe\x6f\xfe\x4c\xff\x00\x00\xdd\xff\x2f\xff\xb0\xff\x6f\xff\x7a\xff\x00\x00\x3d\xff\x3c\xff\x3b\xff\x39\xff\x6f\xfe\x6e\xfe\x6f\xfe\x6e\xfe\x00\x00\x00\x00\x02\xff\x00\xff\x01\xff\x00\x00\x00\x00\x03\xff\x05\xff\x04\xff\x00\x00\x00\x00\x00\x00\x30\xff\x6f\xfe\x6f\xfe\x2b\xff\x45\xff\x43\xff\x41\xff\x9a\xfe\x99\xfe\x6f\xfe\x9e\xfe\x95\xfe\x82\xfe\xa4\xfe\x7f\xfe\x7e\xfe\x00\x00\x7b\xfe\x80\xfe\x74\xfe\x81\xfe\x00\x00\x78\xfe\x96\xfe\x6f\xfe\x7a\xfe\x79\xfe\x00\x00\x00\x00\x00\x00\xc6\xff\x00\x00\x6f\xfe\x00\x00\x00\x00\x3b\xff\x00\x00\x00\x00\xf8\xfe\x00\x00\xfa\xfe\xf9\xfe\x24\xff\xe0\xfe\x00\x00\xdf\xfe\xb4\xfe\x00\x00\x3b\xff\x00\x00\x00\x00\x00\x00\x98\xfe\x97\xfe\x6f\xfe\x9e\xfe\x00\x00\xa2\xfe\x7d\xfe\x7c\xfe\x77\xfe\xb5\xfe\xfe\xfe\x00\x00\x75\xfe\x7a\xfe\x76\xfe\x6f\xfe\x00\x00\xf1\xfe\xfa\xff\x6f\xfe\x00\x00\x20\xff\x1f\xff\x1e\xff\x1d\xff\x1c\xff\x1b\xff\xf9\xff\xe1\xff\x00\x00\x00\x00\xea\xff\xeb\xff\xe8\xff\xec\xff\x00\x00\xcb\xff\xca\xff\xc9\xff\xb1\xfe\xaa\xfe\x00\x00\xe3\xff\x00\x00\x00\x00\xbd\xfe\x00\x00\x22\xff\xe4\xfe\x6f\xfe\xe5\xfe\x00\x00\x00\x00\x00\x00\xac\xfe\xa7\xfe\x00\x00\x0f\xff\x14\xff\x6f\xfe\xb3\xfe\xff\xfe\x6f\xfe\x6f\xfe\x6e\xfe\x15\xff\x6f\xfe\x6f\xfe\x6f\xfe\x13\xff\x6f\xfe\xde\xfe\x6f\xfe\x6f\xfe\x0e\xff\x0a\xff\x09\xff\x6f\xfe\x08\xff\x07\xff\x00\x00\xf3\xfe\xc8\xff\x9c\xfe\x9b\xfe\xc1\xff\xa0\xfe\xa6\xfe\x00\x00\xa6\xff\xa2\xff\x00\x00\x44\xff\x00\x00\x6f\xfe\x38\xff\x42\xff\x47\xff\x6e\xfe\x25\xff\x26\xff\xb6\xff\x87\xff\x00\x00\x89\xff\x00\x00\x00\x00\x9b\xff\xa0\xff\x9f\xff\x00\x00\xa5\xff\x00\x00\xef\xff\xef\xff\x00\x00\x00\x00\xef\xff\xef\xff\x6f\xfe\x6e\xfe\x4f\xff\x7b\xff\x56\xff\x6f\xfe\x6e\xfe\x00\x00\xb1\xff\x98\xff\xb2\xff\x00\x00\xda\xff\xb8\xff\x6e\xfe\xbf\xfe\x3b\xff\x6f\xfe\x00\x00\x6f\xfe\x6e\xfe\x00\x00\x00\x00\x00\x00\x7f\xff\x00\x00\x82\xff\x00\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\x92\xff\x00\x00\x85\xff\x00\x00\x63\xfe\x62\xfe\x00\x00\x00\x00\x7d\xff\x00\x00\xbd\xff\x7c\xff\x95\xff\x00\x00\x96\xff\x97\xff\x56\xff\x68\xff\x83\xff\x94\xff\x8e\xff\x8b\xff\x8d\xff\x00\x00\x8c\xff\x00\x00\xc5\xfe\x00\x00\xc1\xfe\xc6\xfe\x00\x00\xc0\xfe\xef\xff\xef\xff\xd8\xff\x00\x00\x00\x00\xb7\xff\xbb\xff\xef\xff\xef\xff\x6e\xff\x6c\xff\xbc\xff\x00\x00\x00\x00\x79\xff\x77\xff\xb9\xff\x6e\xfe\x31\xff\xef\xff\xef\xff\x6f\xfe\x28\xff\x27\xff\x6f\xfe\x00\x00\x00\x00\x6f\xfe\x6f\xfe\xae\xff\x00\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\xb4\xff\x00\x00\xaf\xfe\x00\x00\x00\x00\x00\x00\x9e\xff\x9d\xff\x9c\xff\x88\xff\x86\xff\x46\xff\xd4\xfe\x00\x00\xd6\xfe\x6f\xfe\x6e\xfe\xa3\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\xff\xfb\xfe\xda\xfe\xdc\xfe\xd8\xfe\xd9\xfe\xf6\xfe\xf7\xfe\xfc\xfe\x3e\xff\x00\x00\x12\xff\xfd\xfe\x11\xff\x9d\xfe\xa1\xfe\x0d\xff\x6f\xfe\xee\xfe\xf2\xfe\x00\x00\xf0\xfe\x00\x00\x6f\xfe\x21\xff\x00\x00\xe4\xff\x00\x00\xe2\xff\x00\x00\xcc\xff\xa9\xfe\xbe\xfe\xbc\xfe\x00\x00\x6f\xfe\x00\x00\x3f\xff\xdd\xfe\x6f\xfe\x06\xff\xc2\xff\x9f\xfe\xa5\xfe\xb0\xfe\xd3\xfe\x00\x00\x6f\xfe\xb5\xff\x00\x00\x00\x00\x00\x00\x34\xff\xa3\xff\xa7\xff\xa4\xff\xa8\xff\xef\xff\xac\xff\xef\xff\xb7\xfe\x6f\xfe\x00\x00\x33\xff\xba\xfe\xbb\xfe\x00\x00\x29\xff\x6f\xfe\x6f\xfe\x00\x00\x00\x00\x50\xff\xef\xff\xef\xff\x7b\xff\x7b\xff\x66\xfe\x55\xff\x00\x00\x6f\xfe\x6f\xfe\x00\x00\x00\x00\x80\xff\xdb\xff\xde\xff\xd9\xff\x00\x00\xd5\xff\x4a\xff\x00\x00\x00\x00\xc2\xfe\x6f\xfe\x6f\xfe\x84\xff\x7e\xff\x00\x00\x7b\xff\xba\xff\x64\xfe\x00\x00\x63\xff\x00\x00\x6a\xff\x67\xff\x62\xff\x00\x00\x00\x00\x85\xfe\x00\x00\x00\x00\xc4\xfe\x00\x00\x4d\xff\x4e\xff\xef\xff\x48\xff\x6f\xfe\xe9\xff\x74\xff\x75\xff\xef\xff\x71\xff\x00\x00\x6d\xff\x00\x00\x51\xff\x54\xff\x76\xff\x78\xff\xae\xff\xd1\xfe\xd2\xfe\xef\xff\xce\xfe\x6f\xfe\x35\xff\x00\x00\x6f\xfe\x19\xff\xf0\xff\xb9\xfe\xf0\xff\xaf\xff\x99\xff\x00\x00\xae\xfe\x40\xff\x6f\xfe\xd7\xfe\xdb\xfe\xf1\xfe\xf4\xfe\x00\x00\xfb\xff\xef\xfe\x6f\xfe\xd5\xfe\x9a\xff\xad\xff\x6f\xfe\xb8\xfe\x6f\xfe\x32\xff\xc7\xfe\x6f\xfe\xf0\xff\xd0\xfe\x53\xff\x00\x00\x00\x00\x00\x00\xf0\xff\x73\xff\x00\x00\xe9\xff\xd2\xff\xd1\xff\x69\xfe\xd0\xff\xf0\xff\x4b\xff\x6f\xfe\x5c\xff\x00\x00\x00\x00\x00\x00\x5f\xff\x60\xff\x00\x00\x00\x00\x00\x00\x69\xff\x61\xff\x63\xff\x6b\xff\x5e\xff\x5d\xff\x66\xff\x00\x00\x00\x00\x5a\xff\xa1\xff\x65\xff\xc3\xfe\x49\xff\x00\x00\x00\x00\xea\xff\xd6\xff\x72\xff\x00\x00\x52\xff\xcf\xfe\x45\xff\xcb\xfe\xc9\xfe\x00\x00\x6f\xfe\xb6\xfe\x00\x00\x00\x00\xcc\xfe\x6f\xfe\xca\xfe\xcd\xfe\x70\xff\xd3\xff\xd7\xff\x00\x00\xce\xff\x00\x00\x64\xff\x00\x00\x00\x00\x58\xff\x59\xff\x00\x00\x5b\xff\xcf\xff\xcd\xff\x00\x00\xf5\xfe\x6f\xfe\x57\xff\xc8\xfe"# + +happyCheck :: HappyAddr +happyCheck = HappyA# "\xff\xff\x00\x00\x01\x00\x02\x00\x01\x00\x01\x00\x14\x00\x0b\x00\x03\x00\x03\x00\x02\x00\x1a\x00\x03\x00\x38\x00\x33\x00\x17\x00\x09\x00\x0a\x00\x0b\x00\x1b\x00\x1c\x00\x1d\x00\x22\x00\x0c\x00\x0d\x00\x21\x00\x73\x00\x23\x00\x3a\x00\x3b\x00\x3b\x00\x10\x00\x52\x00\x76\x00\x17\x00\x0d\x00\x98\x00\x09\x00\x1b\x00\x1c\x00\x1d\x00\x05\x00\x06\x00\x00\x00\x21\x00\x17\x00\x23\x00\x13\x00\x14\x00\x1b\x00\x1c\x00\x1d\x00\x05\x00\x06\x00\x22\x00\x21\x00\x24\x00\x23\x00\x05\x00\x06\x00\x4f\x00\x7f\x00\x17\x00\x7f\x00\x09\x00\x17\x00\x17\x00\x22\x00\x1e\x00\x24\x00\x4e\x00\x20\x00\x21\x00\xa2\x00\x23\x00\x21\x00\xa1\x00\x23\x00\x1f\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x1f\x00\x17\x00\x28\x00\x31\x00\x32\x00\x4e\x00\x67\x00\x05\x00\x06\x00\x39\x00\x20\x00\x21\x00\xa2\x00\x23\x00\xa2\x00\x22\x00\x4e\x00\x24\x00\x17\x00\x22\x00\x59\x00\x24\x00\x05\x00\x06\x00\x1d\x00\x05\x00\x06\x00\xa1\x00\x21\x00\x28\x00\x23\x00\x98\x00\x3e\x00\x4e\x00\x84\x00\xa2\x00\x4e\x00\x15\x00\x16\x00\x8a\x00\x05\x00\x06\x00\x8d\x00\x34\x00\x8f\x00\xa6\x00\x86\x00\xa1\x00\xa1\x00\x25\x00\x94\x00\x95\x00\x15\x00\x16\x00\x98\x00\x9a\x00\x4e\x00\x86\x00\x9d\x00\x93\x00\x94\x00\x95\x00\x15\x00\x97\x00\x98\x00\x19\x00\xa2\x00\xa5\x00\x16\x00\xa1\x00\x93\x00\x94\x00\x95\x00\x4e\x00\x97\x00\x98\x00\x84\x00\x25\x00\xa1\x00\xa7\x00\xa1\x00\xa1\x00\x46\x00\xa2\x00\xa2\x00\xa1\x00\x3e\x00\xa2\x00\xa1\x00\x87\x00\xa7\x00\x80\x00\x94\x00\x95\x00\x14\x00\x85\x00\x98\x00\x80\x00\xa2\x00\xa1\x00\x4d\x00\x4e\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x81\x00\x82\x00\xa5\x00\x94\x00\xa2\x00\x3d\x00\x3e\x00\x4e\x00\x21\x00\xa1\x00\x79\x00\x82\x00\xa1\x00\x2c\x00\x2d\x00\x85\x00\xa9\x00\x1a\x00\x15\x00\x56\x00\x1a\x00\x58\x00\x59\x00\x80\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x74\x00\x94\x00\x25\x00\xa1\x00\x63\x00\x19\x00\x66\x00\xa2\x00\x2e\x00\x80\x00\x86\x00\xa2\x00\x84\x00\xa1\x00\x6e\x00\x74\x00\x88\x00\x25\x00\x05\x00\x06\x00\xa1\x00\xa1\x00\x89\x00\x93\x00\x94\x00\x95\x00\xa3\x00\x84\x00\x94\x00\x95\x00\x5c\x00\x88\x00\x98\x00\x19\x00\x42\x00\x83\x00\x97\x00\x98\x00\x86\x00\x87\x00\x2b\x00\x89\x00\x84\x00\x94\x00\x95\x00\x25\x00\x88\x00\x98\x00\xa1\x00\xa1\x00\x68\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x49\x00\x94\x00\x95\x00\x7b\x00\xa1\x00\x98\x00\x42\x00\xa0\x00\xa1\x00\x56\x00\x63\x00\x58\x00\x59\x00\x39\x00\xa3\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xa1\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x66\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x7b\x00\x94\x00\x95\x00\x6e\x00\x97\x00\x98\x00\x00\x00\x56\x00\x34\x00\x58\x00\x59\x00\x37\x00\xa2\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x29\x00\x09\x00\x2b\x00\x2c\x00\x2d\x00\xa9\x00\x66\x00\x83\x00\x05\x00\x06\x00\x86\x00\x87\x00\x17\x00\x89\x00\x6e\x00\x29\x00\x1a\x00\x2b\x00\x2c\x00\x2d\x00\x1c\x00\x11\x00\xa2\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x61\x00\x1a\x00\x97\x00\x98\x00\x34\x00\x2c\x00\x83\x00\xa0\x00\xa1\x00\x86\x00\x87\x00\x66\x00\x89\x00\x68\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xa8\x00\x2f\x00\x30\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x35\x00\x05\x00\x06\x00\x1a\x00\x75\x00\x76\x00\xa3\x00\xa0\x00\xa1\x00\x2b\x00\x87\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x47\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x2c\x00\x4c\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x1f\x00\x9a\x00\x21\x00\x1a\x00\x42\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x21\x00\x2f\x00\x30\x00\x61\x00\xa1\x00\x01\x00\xa9\x00\x81\x00\x82\x00\x05\x00\xa1\x00\x07\x00\x94\x00\x95\x00\xa1\x00\x97\x00\x98\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x9a\x00\x2f\x00\x30\x00\x9d\x00\x1a\x00\x94\x00\x95\x00\x61\x00\x97\x00\x98\x00\x20\x00\xa9\x00\x4c\x00\x77\x00\x78\x00\x79\x00\x26\x00\xa1\x00\x05\x00\x06\x00\x87\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xa9\x00\x2f\x00\x30\x00\x8d\x00\x05\x00\x06\x00\x36\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x1f\x00\x9b\x00\x21\x00\x9d\x00\x9a\x00\x9f\x00\x1f\x00\x87\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x3f\x00\x2f\x00\x30\x00\xa9\x00\xa1\x00\x1f\x00\x26\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x51\x00\x9d\x00\x08\x00\x09\x00\x87\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x36\x00\x2f\x00\x30\x00\x4a\x00\x4b\x00\x4c\x00\xa9\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x67\x00\x1d\x00\x7e\x00\x00\x00\x87\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x86\x00\x2f\x00\x30\x00\x29\x00\x2a\x00\x13\x00\xa9\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x1a\x00\x93\x00\x94\x00\x95\x00\x17\x00\x09\x00\xa3\x00\x0b\x00\x87\x00\x2c\x00\x2d\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xa9\x00\x2f\x00\x30\x00\x05\x00\x06\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x49\x00\x1f\x00\x97\x00\x98\x00\x10\x00\x08\x00\x43\x00\x87\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x16\x00\x2f\x00\x30\x00\xa9\x00\x1a\x00\x5b\x00\xa8\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x87\x00\x1d\x00\x08\x00\x09\x00\x87\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xa4\x00\x2f\x00\x30\x00\x29\x00\x2a\x00\x96\x00\xa9\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x1c\x00\x1d\x00\x94\x00\x95\x00\x87\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x48\x00\x2f\x00\x30\x00\x29\x00\x2a\x00\x11\x00\xa9\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x85\x00\xa9\x00\x1a\x00\x97\x00\x98\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x87\x00\x1a\x00\x69\x00\x6a\x00\x32\x00\x94\x00\xa9\x00\x20\x00\x94\x00\x95\x00\xa8\x00\x97\x00\x98\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x87\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xa9\x00\xa3\x00\x05\x00\x06\x00\xa3\x00\xa9\x00\x2d\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\xa3\x00\x08\x00\x11\x00\x0a\x00\x87\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x11\x00\xa9\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x1d\x00\x16\x00\x1a\x00\xa1\x00\x87\x00\x1a\x00\xa2\x00\x29\x00\x0f\x00\x2b\x00\x2c\x00\x2d\x00\x29\x00\x2a\x00\x05\x00\x06\x00\xa9\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x2c\x00\x2d\x00\x2e\x00\x10\x00\x87\x00\x11\x00\x11\x00\x29\x00\x48\x00\x2b\x00\x2c\x00\x2d\x00\x84\x00\x4a\x00\x1a\x00\x1a\x00\xa9\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x29\x00\x92\x00\x2b\x00\x2c\x00\x2d\x00\x87\x00\x94\x00\x95\x00\x99\x00\x9a\x00\x29\x00\x87\x00\x2b\x00\x2c\x00\x2d\x00\x27\x00\xa9\x00\x86\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x1a\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x20\x00\x93\x00\x94\x00\x95\x00\x87\x00\x97\x00\x98\x00\x94\x00\x95\x00\x87\x00\xa9\x00\x98\x00\x05\x00\x06\x00\x2c\x00\x2d\x00\xa9\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x2b\x00\x2c\x00\x2d\x00\x1a\x00\x11\x00\x30\x00\x9d\x00\x1e\x00\x2b\x00\x2c\x00\x2d\x00\xa9\x00\x23\x00\x1a\x00\x94\x00\x95\x00\xa9\x00\x97\x00\x98\x00\x11\x00\x8e\x00\x40\x00\x41\x00\x42\x00\x92\x00\x44\x00\x94\x00\x95\x00\x1a\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x44\x00\xa1\x00\xa9\x00\x94\x00\x95\x00\xa3\x00\x97\x00\x98\x00\x6b\x00\x05\x00\x06\x00\x25\x00\x2c\x00\x2d\x00\xa9\x00\xaa\x00\xab\x00\x67\x00\x94\x00\x95\x00\x10\x00\x97\x00\x98\x00\x26\x00\xa9\x00\x2b\x00\x2c\x00\x2d\x00\x94\x00\x95\x00\x4f\x00\x97\x00\x98\x00\xa1\x00\x2c\x00\x2d\x00\x10\x00\x11\x00\x12\x00\xa9\x00\x2c\x00\x2d\x00\x35\x00\x45\x00\x46\x00\x26\x00\x40\x00\x41\x00\x42\x00\xa9\x00\x44\x00\x05\x00\x06\x00\x2c\x00\x2d\x00\x04\x00\x05\x00\x06\x00\x94\x00\x95\x00\x88\x00\x97\x00\x98\x00\x04\x00\x05\x00\x06\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x05\x00\x06\x00\x94\x00\x95\x00\x3c\x00\x97\x00\x98\x00\x69\x00\x6a\x00\xa9\x00\x94\x00\x95\x00\xa4\x00\x97\x00\x98\x00\x4b\x00\x1c\x00\x1d\x00\x34\x00\x1f\x00\x20\x00\x05\x00\x06\x00\xa9\x00\x24\x00\x05\x00\x06\x00\x34\x00\x15\x00\x29\x00\x2a\x00\xa9\x00\x93\x00\x94\x00\x95\x00\x0e\x00\x97\x00\x98\x00\x86\x00\x05\x00\x06\x00\x94\x00\x95\x00\x61\x00\x97\x00\x98\x00\x94\x00\x95\x00\x88\x00\x97\x00\x98\x00\x93\x00\x94\x00\x95\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x94\x00\x95\x00\xa9\x00\x97\x00\x98\x00\x69\x00\x6a\x00\xa9\x00\x94\x00\x95\x00\x18\x00\x97\x00\x98\x00\xa2\x00\x94\x00\x95\x00\x09\x00\x97\x00\x98\x00\x6a\x00\x9b\x00\xa9\x00\x9d\x00\x34\x00\x9f\x00\x36\x00\x37\x00\x94\x00\x95\x00\xa9\x00\x97\x00\x98\x00\x92\x00\x69\x00\x41\x00\xa9\x00\x43\x00\x44\x00\xa3\x00\x99\x00\x9a\x00\x9b\x00\xa4\x00\x9d\x00\x41\x00\x9f\x00\x43\x00\x44\x00\xa9\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\x0f\x00\x10\x00\x11\x00\x93\x00\x94\x00\x95\x00\xa1\x00\x97\x00\x98\x00\x18\x00\xa4\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x11\x00\x1f\x00\x6b\x00\x8b\x00\x22\x00\x11\x00\x8e\x00\x45\x00\x90\x00\x27\x00\x92\x00\x29\x00\x2a\x00\x7d\x00\x7e\x00\x2d\x00\x23\x00\x99\x00\x9a\x00\x9b\x00\x23\x00\x9d\x00\x86\x00\x9f\x00\x01\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x68\x00\x3e\x00\x3f\x00\x40\x00\x93\x00\x94\x00\x95\x00\x44\x00\x05\x00\x06\x00\x69\x00\x6a\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x14\x00\x1d\x00\x07\x00\x08\x00\x55\x00\x56\x00\x05\x00\x06\x00\x59\x00\x5a\x00\x03\x00\x04\x00\x03\x00\x04\x00\x45\x00\x46\x00\x61\x00\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x6a\x00\x05\x00\x06\x00\x10\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x4d\x00\x4e\x00\x05\x00\x14\x00\x05\x00\x06\x00\x1a\x00\x18\x00\x45\x00\x46\x00\x1b\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x05\x00\x06\x00\x11\x00\x14\x00\x27\x00\x20\x00\x29\x00\x14\x00\x2b\x00\x59\x00\x2d\x00\x25\x00\x14\x00\x21\x00\x14\x00\x28\x00\x01\x00\x15\x00\x15\x00\x10\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x6a\x00\x3e\x00\x3f\x00\x40\x00\x16\x00\x42\x00\x1a\x00\x44\x00\x16\x00\x16\x00\x14\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x14\x00\x8a\x00\x56\x00\x25\x00\x8d\x00\x59\x00\x8f\x00\x5b\x00\x57\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x20\x00\x62\x00\x11\x00\x64\x00\x9a\x00\x60\x00\x67\x00\x9d\x00\x24\x00\x6a\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x45\x00\x5c\x00\x11\x00\x1e\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x18\x00\x35\x00\x3d\x00\x1b\x00\x1a\x00\x1c\x00\x11\x00\x83\x00\x1c\x00\x59\x00\x86\x00\x15\x00\x14\x00\x89\x00\x20\x00\x27\x00\x16\x00\x29\x00\x16\x00\x2b\x00\x16\x00\x2d\x00\x15\x00\x93\x00\x94\x00\x95\x00\x6a\x00\x97\x00\x98\x00\x1a\x00\x23\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x58\x00\x3e\x00\x3f\x00\x40\x00\x24\x00\x42\x00\x54\x00\x44\x00\x1c\x00\x11\x00\x11\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x1a\x00\x19\x00\x56\x00\x15\x00\x15\x00\x59\x00\x16\x00\x5b\x00\x14\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x1a\x00\x62\x00\x1a\x00\x64\x00\x11\x00\x4f\x00\x67\x00\x15\x00\x54\x00\x6a\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x68\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x15\x00\x5c\x00\x5c\x00\x66\x00\x15\x00\x11\x00\x11\x00\x18\x00\x01\x00\x02\x00\x1b\x00\x1c\x00\x1d\x00\x15\x00\x1f\x00\x1c\x00\x21\x00\x1a\x00\x23\x00\x15\x00\x11\x00\x1c\x00\x27\x00\x10\x00\x29\x00\x2a\x00\x2b\x00\x1c\x00\x2d\x00\x16\x00\x2f\x00\x30\x00\x31\x00\x32\x00\x33\x00\x34\x00\x11\x00\x21\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x11\x00\x11\x00\x11\x00\x11\x00\x11\x00\x42\x00\x11\x00\x44\x00\x11\x00\x11\x00\x35\x00\x11\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x1a\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x19\x00\x59\x00\x3d\x00\x3d\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x18\x00\x47\x00\x6a\x00\x1b\x00\x23\x00\x23\x00\x3d\x00\x68\x00\x11\x00\x59\x00\x19\x00\x19\x00\x68\x00\x15\x00\x15\x00\x27\x00\x65\x00\x29\x00\x23\x00\x2b\x00\x20\x00\x2d\x00\x28\x00\x21\x00\x14\x00\x05\x00\x6a\x00\x01\x00\x21\x00\x15\x00\x6a\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x15\x00\x3e\x00\x3f\x00\x40\x00\x10\x00\x42\x00\x0c\x00\x44\x00\x21\x00\x10\x00\x1a\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x15\x00\x11\x00\x56\x00\x16\x00\x68\x00\x59\x00\x1f\x00\x10\x00\x47\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x60\x00\x62\x00\x6b\x00\x64\x00\x42\x00\x44\x00\x67\x00\xff\xff\xff\xff\x6a\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x18\x00\xff\xff\x83\x00\x1b\x00\xff\xff\x86\x00\xff\xff\xff\xff\x89\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\x93\x00\x94\x00\x95\x00\x2d\x00\x97\x00\x98\x00\xff\xff\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\x3e\x00\x3f\x00\x40\x00\xff\xff\x01\x00\x02\x00\x44\x00\xff\xff\x05\x00\x06\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\xff\xff\x56\x00\xff\xff\xff\xff\x59\x00\xff\xff\x5b\x00\xff\xff\x5d\x00\x5e\x00\x5f\x00\x60\x00\xff\xff\x62\x00\xff\xff\x64\x00\xff\xff\xff\xff\x67\x00\xff\xff\xff\xff\x6a\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\x59\x00\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\x3e\x00\x3f\x00\x40\x00\x6a\x00\x10\x00\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\xff\xff\xff\xff\x56\x00\xff\xff\xff\xff\x59\x00\xff\xff\xff\xff\xff\xff\x5d\x00\x5e\x00\x5f\x00\x60\x00\xff\xff\x62\x00\xff\xff\x64\x00\xff\xff\xff\xff\x67\x00\xff\xff\xff\xff\x6a\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x49\x00\xff\xff\xff\xff\x14\x00\x4d\x00\x4e\x00\x4f\x00\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x59\x00\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\x2b\x00\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\x01\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\x1d\x00\xff\xff\xff\xff\x55\x00\x56\x00\xff\xff\xff\xff\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\x14\x00\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\x2b\x00\x59\x00\x2d\x00\xff\xff\xff\xff\xff\xff\x08\x00\x09\x00\x0a\x00\x0b\x00\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x6a\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\xff\xff\x44\x00\x1c\x00\x1d\x00\xff\xff\x1f\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\x29\x00\x2a\x00\xff\xff\xff\xff\x56\x00\xff\xff\xff\xff\x59\x00\xff\xff\xff\xff\xff\xff\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\x11\x00\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\x1a\x00\xff\xff\xff\xff\x1d\x00\x27\x00\x1f\x00\x29\x00\xff\xff\x2b\x00\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x29\x00\x2a\x00\xff\xff\xff\xff\x01\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\xff\xff\x44\x00\x10\x00\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\x56\x00\xff\xff\xff\xff\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x08\x00\xff\xff\x0a\x00\x14\x00\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\x11\x00\x1b\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x1a\x00\xff\xff\xff\xff\x1d\x00\x27\x00\xff\xff\x29\x00\xff\xff\x2b\x00\x59\x00\x2d\x00\x25\x00\xff\xff\xff\xff\xff\xff\x29\x00\x2a\x00\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x6a\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\xff\xff\x59\x00\xff\xff\xff\xff\xff\xff\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\x1c\x00\x1d\x00\x27\x00\x1f\x00\x29\x00\x21\x00\x2b\x00\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x29\x00\x2a\x00\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\x56\x00\xff\xff\xff\xff\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\x14\x00\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\x01\x00\xff\xff\x2d\x00\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\x56\x00\xff\xff\xff\xff\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\x2b\x00\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\xff\xff\x59\x00\xff\xff\xff\xff\xff\xff\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\x14\x00\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\x01\x00\xff\xff\x2d\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\x56\x00\xff\xff\xff\xff\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x18\x00\x19\x00\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x59\x00\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\x56\x00\xff\xff\xff\xff\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\x8b\x00\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\x22\x00\x92\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\x99\x00\x9a\x00\x9b\x00\x2d\x00\x9d\x00\xff\xff\x9f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\x56\x00\xff\xff\xff\xff\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\x8b\x00\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\x22\x00\x92\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\x99\x00\x9a\x00\x9b\x00\x2d\x00\x9d\x00\xff\xff\x9f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\x56\x00\xff\xff\xff\xff\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\x8b\x00\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\x22\x00\x92\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\x99\x00\x9a\x00\x9b\x00\x2d\x00\x9d\x00\xff\xff\x9f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\x56\x00\xff\xff\xff\xff\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\x56\x00\xff\xff\xff\xff\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\x56\x00\xff\xff\xff\xff\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\x56\x00\xff\xff\xff\xff\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\x56\x00\xff\xff\xff\xff\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\x56\x00\xff\xff\xff\xff\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\x56\x00\xff\xff\xff\xff\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\x56\x00\xff\xff\xff\xff\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\x56\x00\xff\xff\xff\xff\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\xff\xff\x59\x00\xff\xff\xff\xff\xff\xff\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\x14\x00\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\x2b\x00\xff\xff\x2d\x00\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\xff\xff\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\xff\xff\x59\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\x62\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x6a\x00\x8b\x00\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\x18\x00\x92\x00\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\x9a\x00\x9b\x00\xff\xff\x9d\x00\xff\xff\x9f\x00\x27\x00\xa1\x00\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\xff\xff\x59\x00\xff\xff\xff\xff\xff\xff\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\x55\x00\x56\x00\xff\xff\xff\xff\x59\x00\x5a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\x2b\x00\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\xff\xff\x59\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\x62\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\xff\xff\x59\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\x62\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\x3e\x00\x3f\x00\x40\x00\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\xff\xff\x59\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\x62\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\x08\x00\x09\x00\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\x27\x00\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x1d\x00\x10\x00\x1f\x00\x20\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xff\xff\x1a\x00\x29\x00\x2a\x00\xff\xff\xff\xff\xff\xff\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\x51\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\x59\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x67\x00\xff\xff\x18\x00\x6a\x00\xff\xff\x1b\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\x01\x00\x02\x00\xff\xff\x27\x00\x05\x00\x06\x00\xff\xff\x2b\x00\x59\x00\x2d\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\xff\xff\x63\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x42\x00\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\x59\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\x6a\x00\x1b\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\x25\x00\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\x59\x00\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x44\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\x59\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\x6a\x00\x1b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\x27\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\x2d\x00\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\x10\x00\x11\x00\x09\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x10\x00\x11\x00\x12\x00\xff\xff\xff\xff\x1e\x00\xff\xff\x44\x00\x18\x00\xff\xff\x1a\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x59\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\x0f\x00\x10\x00\xff\xff\xff\xff\x6a\x00\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\x58\x00\x59\x00\x05\x00\x06\x00\xff\xff\x08\x00\x09\x00\xff\xff\x0b\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\x6a\x00\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x1c\x00\xff\xff\x49\x00\x1f\x00\xff\xff\xff\xff\x4d\x00\x4e\x00\x4f\x00\x25\x00\xff\xff\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x59\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\x11\x00\x12\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\x1a\x00\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x01\x00\x25\x00\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\x08\x00\x09\x00\x59\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x6a\x00\x1c\x00\xff\xff\xff\xff\x1f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x25\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x6a\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\x01\x00\xff\xff\x59\x00\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\x6a\x00\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\x59\x00\x05\x00\x06\x00\xff\xff\x01\x00\x09\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\x6a\x00\xff\xff\x10\x00\x18\x00\x12\x00\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x2a\x00\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x19\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\x01\x00\x59\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\x6a\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\x01\x00\xff\xff\x59\x00\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\x18\x00\x12\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x01\x00\xff\xff\xff\xff\x2a\x00\x05\x00\x06\x00\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\x6a\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x2a\x00\x01\x00\x59\x00\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\x01\x00\xff\xff\xff\xff\x2a\x00\x05\x00\x06\x00\xff\xff\x01\x00\x59\x00\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\x18\x00\x12\x00\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x2a\x00\x01\x00\x02\x00\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x01\x00\x02\x00\x59\x00\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\xff\xff\xff\xff\x6a\x00\x01\x00\xff\xff\xff\xff\x18\x00\x05\x00\xff\xff\x6a\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x10\x00\x11\x00\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\xff\xff\x59\x00\x01\x00\x02\x00\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\x6a\x00\xff\xff\x1a\x00\x01\x00\x02\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\x59\x00\x05\x00\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6a\x00\xff\xff\xff\xff\x59\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\x6a\x00\x59\x00\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\x59\x00\x05\x00\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x6a\x00\xff\xff\x10\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6a\x00\xff\xff\x59\x00\x01\x00\x02\x00\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x59\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\xff\xff\xff\xff\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\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\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x59\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\x61\x00\x62\x00\x6a\x00\xff\xff\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\x8c\x00\xff\xff\x8e\x00\xff\xff\xff\xff\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\x71\x00\x72\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xa0\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\xff\xff\x66\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\x71\x00\x72\x00\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa0\x00\xa1\x00\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xa0\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\x71\x00\x72\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xa0\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\x65\x00\x66\x00\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x59\x00\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x83\x00\xa0\x00\xa1\x00\x86\x00\x87\x00\xff\xff\x89\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xa0\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\x66\x00\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\x7a\x00\xff\xff\x7c\x00\xff\xff\xa0\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\x66\x00\xff\xff\xff\xff\x69\x00\x6a\x00\xff\xff\x6c\x00\x6d\x00\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xa0\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\x66\x00\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\x7a\x00\xff\xff\x7c\x00\xff\xff\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xa0\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\x72\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7a\x00\xff\xff\xff\xff\xff\xff\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xa0\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\x66\x00\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\x7a\x00\xff\xff\x7c\x00\xff\xff\xa0\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\x66\x00\xff\xff\xff\xff\x69\x00\x6a\x00\xff\xff\x6c\x00\x6d\x00\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xa0\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\x66\x00\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\x7a\x00\xff\xff\x7c\x00\xff\xff\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xa0\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\xff\xff\x66\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x7a\x00\xff\xff\x7c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xa0\x00\xa1\x00\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xa0\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7a\x00\xff\xff\x7c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xa0\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\xff\xff\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\x65\x00\x66\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa0\x00\xa1\x00\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xa0\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\xa0\x00\xa1\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xa0\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\xa0\x00\xa1\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xa0\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\xa0\x00\xa1\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xa0\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\xa0\x00\xa1\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xa0\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\xa0\x00\xa1\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xa0\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\xa0\x00\xa1\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xa0\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\xa0\x00\xa1\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xa0\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\xa0\x00\xa1\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xa0\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\xa0\x00\xa1\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xa0\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\xa0\x00\xa1\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xa0\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\xa0\x00\xa1\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xa0\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\xa0\x00\xa1\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xa0\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\xa0\x00\xa1\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\xff\xff\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\xa0\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\xff\xff\x66\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x7a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa0\x00\xa1\x00\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\x59\x00\xa0\x00\xa1\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x59\x00\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\xa0\x00\xa1\x00\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa0\x00\xa1\x00\xff\xff\xff\xff\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\xa0\x00\xa1\x00\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa0\x00\xa1\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\xff\xff\xff\xff\x86\x00\x87\x00\xff\xff\x89\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa0\x00\xa1\x00\xff\xff\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\x04\x00\x02\x00\x05\x00\x93\x00\x02\x00\xd4\x02\x1f\x01\x19\x01\x0a\x00\x08\x00\x50\x01\x0a\x00\xbb\x01\x98\x00\x24\x00\x33\x00\x34\x00\x35\x00\x4e\x01\x26\x00\x27\x00\x37\x02\x22\x00\x23\x00\x28\x00\xc7\x01\x29\x00\x6a\x02\x6b\x02\xc3\x02\xd4\xff\x5e\x01\xc6\x02\x24\x00\x94\x00\xec\x01\x9f\x02\x25\x00\x26\x00\x27\x00\x1a\x00\x40\x02\x21\x00\x28\x00\x24\x00\x29\x00\xa0\x02\xa1\x02\x95\x00\x26\x00\x27\x00\x1a\x00\xd2\x01\x6d\x01\x28\x00\x1c\x02\x29\x00\x1a\x00\xd2\x01\xd2\x02\xf8\x01\x24\x00\x72\x01\xc0\x02\x24\x00\x22\x00\x6d\x01\x7c\x01\xb0\x01\x2a\x00\x28\x02\x29\x02\xc8\x01\x29\x00\x90\x02\x78\x02\x29\x00\xd3\x01\x9b\x00\x7d\x01\x7e\x01\x9e\x00\x9f\x00\xd5\x01\x24\x00\x1f\x02\x7f\x01\x80\x01\x2a\x00\x8d\x02\x1a\x00\xcd\x01\x41\x02\x28\x02\x29\x02\x73\x01\x29\x00\x73\x01\x6d\x01\x2a\x00\xe3\x01\x24\x00\x6d\x01\x49\x02\x6e\x01\x1a\x00\xcd\x01\x96\x00\x1a\x00\x34\x02\xda\x00\x28\x00\xd8\x01\x29\x00\x99\x00\x6d\x02\x2a\x00\xa2\x02\xbc\x01\x2a\x00\xd6\x02\x22\x01\x51\x01\x1a\x00\x34\x02\x52\x01\x55\x02\x53\x01\x9a\x00\x36\x00\x6c\x02\x6c\x02\xb8\x02\x38\x00\x25\x01\x21\x01\x22\x01\xa3\x02\x54\x01\x2a\x00\x36\x00\x55\x01\x37\x00\x38\x00\x39\x00\x0d\x00\x3a\x00\x3b\x00\x72\x00\x38\x02\xa4\x02\x0d\x02\x97\x00\x37\x00\x38\x00\x39\x00\x2a\x00\x3a\x00\x3b\x00\xa2\x02\x73\x00\x06\x00\x3c\x00\x03\x00\x03\x00\xdf\x02\x0b\x00\x0b\x00\x09\x00\xa5\x01\x0b\x00\x2b\x00\xa2\x00\x3c\x00\xd4\x01\x38\x00\x25\x01\x4f\x02\xd9\x01\xa3\x02\xd6\x01\x6f\x01\x2b\x00\x64\x02\x65\x02\x38\x00\xa3\x00\x59\x00\xa4\x00\x3b\x00\x2a\x02\x2b\x02\xa4\x02\xda\x01\x6f\x01\xbe\x01\xbf\x01\xbe\x02\x7b\x01\x91\x02\xd1\x02\x92\x02\x91\x02\xe5\x02\x9f\x00\xd9\x01\xa5\x00\x48\x01\x0d\x00\x74\x00\x17\x02\x75\x00\x76\x00\xce\x01\xa6\x01\x77\x00\x4f\x00\x50\x00\x78\x00\x35\x02\xda\x01\xe5\x02\x2c\x02\x0f\x00\x72\x00\x51\x00\x6f\x01\x49\x01\xcf\x01\xbb\x02\x6f\x01\x23\x01\x31\x02\x79\x00\x36\x02\x24\x01\x73\x00\x1a\x00\x40\x02\x97\x00\xca\x02\x9b\x02\x37\x00\x38\x00\x39\x00\x62\x02\x23\x01\x38\x00\x25\x01\xd8\x01\x24\x01\x26\x01\x72\x00\x0e\x00\x55\x00\x5a\x00\x3b\x00\x7a\x00\x57\x00\x13\x02\x58\x00\x23\x01\x38\x00\x25\x01\x73\x00\x24\x01\x26\x01\x66\x02\xa6\x01\x7c\x01\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x6e\x02\x38\x00\x25\x01\xaa\x00\x66\x02\x26\x01\x0f\x01\x5b\x00\x5c\x00\x74\x00\x0f\x00\x75\x00\x76\x00\x42\x02\x68\x02\x77\x00\x4f\x00\x50\x00\x78\x00\xa6\x01\x9b\x00\x8f\x01\x9d\x00\x9e\x00\x9f\x00\x51\x00\x90\x01\xa1\x00\x91\x01\x80\x01\xb0\x00\x38\x00\xa3\x00\x79\x00\xa4\x00\x3b\x00\x21\x00\x74\x00\xc2\x01\x75\x00\x76\x00\x72\x02\xab\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x8f\x02\xdd\x00\x7e\x01\x9e\x00\x9f\x00\xa5\x00\x51\x00\x55\x00\x1a\x00\x49\x02\x7a\x00\x7c\x02\x22\x00\x58\x00\x79\x00\x81\x02\x48\x01\x7e\x01\x9e\x00\x9f\x00\xac\x02\x40\x01\xab\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x65\x01\x41\x01\x3c\x02\x3b\x00\x71\x02\x8d\x02\x55\x00\x5b\x00\x5c\x00\x7a\x00\x57\x00\x01\x02\x58\x00\x02\x02\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\x6f\x02\xdc\x02\xa1\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x42\x01\x1a\x00\x49\x02\x48\x01\x76\x02\x77\x02\x74\x02\x5b\x00\x5c\x00\x0e\x01\xa2\x00\x9b\x00\x8f\x01\x9d\x00\x9e\x00\x9f\x00\xdd\x02\x90\x01\xa1\x00\x91\x01\x80\x01\x00\x02\x4a\x02\x38\x00\xa3\x00\x59\x00\xa4\x00\x3b\x00\xea\xfe\x0a\x02\xea\xfe\x17\x02\x0f\x01\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\x1f\x02\xd3\x02\xa1\x00\x65\x01\x03\x02\x15\x00\xa5\x00\x2a\x02\x2b\x02\x16\x00\x78\x02\x17\x00\x38\x00\xa3\x00\x1d\x02\xa4\x00\x3b\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\x0a\x02\x14\x02\xa1\x00\xea\x01\xa1\xff\x38\x00\xa3\x00\x65\x01\xa4\x00\x3b\x00\xa1\xff\xa5\x00\x4b\x02\xc7\x02\xc8\x02\xc9\x02\xcc\x00\x31\x02\x1a\x00\x73\x02\xa2\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa5\x00\x4f\x02\xa1\x00\xaa\x02\x1a\x00\x73\x02\xcd\x00\x38\x00\xa3\x00\x59\x00\xa4\x00\x3b\x00\xeb\xfe\x02\x01\xeb\xfe\xd8\x00\x54\x01\xd9\x00\xd3\x01\xa2\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\x51\x02\x9f\x01\xa1\x00\xa5\x00\xca\x02\xd5\x01\xcc\x00\x38\x00\xa3\x00\x59\x00\xa4\x00\x3b\x00\x18\x00\x20\x02\xdc\x00\xdd\x00\xa2\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xcd\x00\x57\x01\xa1\x00\xdf\x01\xe0\x01\xe1\x01\xa5\x00\x38\x00\xa3\x00\x59\x00\xa4\x00\x3b\x00\x19\x00\xe1\x00\x0f\x02\x21\x00\xa2\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\x2c\x01\xa0\x00\xa1\x00\xe4\x00\xe5\x00\xac\x01\xa5\x00\x38\x00\xa3\x00\x59\x00\xa4\x00\x3b\x00\xad\x01\x37\x00\x38\x00\x39\x00\x22\x00\xdd\x00\x24\x02\xdf\x00\xa2\x00\xac\x02\x9f\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa5\x00\xad\x00\xa1\x00\x6f\xfe\x6f\xfe\x38\x00\xa3\x00\x59\x00\xa4\x00\x3b\x00\xbe\x00\xe2\x00\x3c\x02\x3b\x00\x6f\xfe\xdc\x00\xad\x02\xa2\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xda\x02\xb2\x00\xa1\x00\xa5\x00\xdb\x02\xbf\x00\xc5\x02\x38\x00\xa3\x00\x59\x00\xa4\x00\x3b\x00\x7a\x02\xe1\x00\xdc\x00\xdd\x00\xa2\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\x44\x02\xb3\x00\xa1\x00\xe4\x00\xe5\x00\x59\x00\xa5\x00\x38\x00\xa3\x00\x59\x00\xa4\x00\x3b\x00\x57\x01\xe1\x00\x38\x00\xa3\x00\xa2\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\x53\x02\xeb\x00\xa1\x00\xe4\x00\xe5\x00\xe2\x02\xa5\x00\x38\x00\xa3\x00\x59\x00\xa4\x00\x3b\x00\x21\x02\xa0\x01\x0d\x02\x3c\x02\x3b\x00\x9b\x00\x8d\x01\x7e\x01\x9e\x00\x9f\x00\xa2\x00\xe6\x00\xce\x02\x13\x00\x8e\x01\xda\x01\xa5\x00\xdc\x02\x38\x00\xa3\x00\x3d\x02\xa4\x00\x3b\x00\x38\x00\xa3\x00\x59\x00\xa4\x00\x3b\x00\x9b\x00\x43\x02\x7e\x01\x9e\x00\x9f\x00\xa2\x00\x9b\x00\x50\x02\x7e\x01\x9e\x00\x9f\x00\xa5\x00\x25\x02\x40\x00\x41\x00\x2f\x02\xa5\x00\xc5\x00\x38\x00\xa3\x00\x59\x00\xa4\x00\x3b\x00\xaf\x01\xdc\x00\x71\x02\xde\x00\xa2\x00\x9b\x00\xa7\x01\x7e\x01\x9e\x00\x9f\x00\x9b\x00\x8c\x01\x7e\x01\x9e\x00\x9f\x00\x9a\x02\xa5\x00\x38\x00\xa3\x00\x59\x00\xa4\x00\x3b\x00\xe1\x00\x08\x02\x9b\x02\xb3\x01\xa2\x00\x09\x02\xb5\x01\xa1\x01\xb7\x01\x7e\x01\x9e\x00\x9f\x00\xe4\x00\xe5\x00\x40\x00\x41\x00\xa5\x00\x38\x00\xa3\x00\x59\x00\xa4\x00\x3b\x00\x95\x01\x9f\x00\x96\x01\x9d\x02\xa2\x00\xe3\x01\x0c\x02\xa3\x01\xc0\x01\x7e\x01\x9e\x00\x9f\x00\x58\x01\xc5\x01\x3c\x01\x0d\x02\xa5\x00\x38\x00\xa3\x00\x59\x00\xa4\x00\x3b\x00\xa4\x01\x68\x01\x7e\x01\x9e\x00\x9f\x00\xa2\x00\x38\x00\x25\x01\xd5\x00\xd6\x00\xa8\x01\xa2\x00\x7e\x01\x9e\x00\x9f\x00\xdd\x01\xa5\x00\xc6\x00\x38\x00\xa3\x00\x59\x00\xa4\x00\x3b\x00\xe6\x00\x38\x00\xa3\x00\x59\x00\xa4\x00\x3b\x00\xe7\x00\x37\x00\x38\x00\x39\x00\xa2\x00\xa4\x00\x3b\x00\x38\x00\xeb\x01\xa2\x00\xa5\x00\xec\x01\x97\x02\x98\x02\x95\x01\x9f\x00\xa5\x00\x38\x00\xa3\x00\x59\x00\xa4\x00\x3b\x00\x38\x00\xa3\x00\x59\x00\xa4\x00\x3b\x00\x56\x02\x9e\x00\x9f\x00\x45\x01\x39\x01\x57\x02\xea\x01\x46\x01\xb6\x02\x9e\x00\x9f\x00\xa5\x00\x47\x01\x3a\x01\x38\x00\xa3\x00\xa5\x00\xa4\x00\x3b\x00\x3b\x01\x97\x01\x58\x02\x59\x02\x5a\x02\xd4\x00\x5b\x02\x38\x00\xa3\x00\x3c\x01\xa4\x00\x3b\x00\xd5\x00\xd6\x00\xb7\x02\xf9\x01\xa5\x00\x38\x00\xa3\x00\xee\x01\xa4\x00\x3b\x00\x00\x02\x40\x00\x41\x00\xb8\x02\xb2\x02\x9f\x00\xa5\x00\x98\x01\x99\x01\x2f\x01\x38\x00\xa3\x00\x3f\x02\xa4\x00\x3b\x00\x69\x01\xa5\x00\xb3\x02\x9e\x00\x9f\x00\x38\x00\xa3\x00\x5f\x01\xa4\x00\x3b\x00\x75\x01\xb5\x02\x9f\x00\x45\x02\x46\x02\x47\x02\xa5\x00\xa8\x02\x9f\x00\x77\x01\xb9\x02\xba\x02\x6c\x01\xb4\x02\x59\x02\x5a\x02\xa5\x00\x5b\x02\x9d\x02\x9e\x02\x95\x01\x9f\x00\x19\x00\x1a\x00\x1b\x00\x38\x00\xa3\x00\x5c\x02\xa4\x00\x3b\x00\x1c\x00\x1a\x00\x1b\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xa5\x02\xa6\x02\x38\x00\xa3\x00\x79\x01\xa4\x00\x5d\x02\x11\x02\x13\x00\xa5\x00\x38\x00\xa3\x00\x81\x01\xa4\x00\x3b\x00\x82\x01\xe0\x00\xe1\x00\x8b\x01\xe2\x00\x3e\x01\x7d\x02\x7e\x02\xa5\x00\xc7\xfe\x7f\x02\x80\x02\x9d\x01\x13\x01\xe4\x00\xe5\x00\xa5\x00\x32\x01\x38\x00\x39\x00\xae\x00\x33\x01\x3b\x00\xbb\x02\x8f\x00\x90\x00\x38\x00\xa3\x00\xfb\x00\x33\x01\x3b\x00\x38\x00\xa3\x00\x5c\x02\xa4\x00\x3b\x00\x37\x00\x38\x00\x39\x00\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x38\x00\xa3\x00\xa2\x01\xa4\x00\x5d\x02\x30\x01\x13\x00\xa5\x00\x38\x00\xa3\x00\xe7\x00\xa4\x00\x3b\x00\xea\x00\x38\x00\xa3\x00\x1c\x01\xa4\x00\x3b\x00\x71\x00\x02\x01\xa5\x00\xd8\x00\xc2\x01\xd9\x00\xc3\x01\xc4\x01\x38\x00\xa3\x00\xa5\x00\xa4\x00\x3b\x00\x68\x01\x3f\x01\x05\x02\xa5\x00\xce\x02\x71\x00\x1f\x00\xd5\x00\xd6\x00\x02\x01\x1a\x01\xd8\x00\x05\x02\xd9\x00\x06\x02\x71\x00\xa5\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7c\x00\x07\x01\xdd\x00\xde\x00\xdf\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x08\x01\x5b\x01\x38\x00\x39\x00\x1e\x00\x33\x01\x3b\x00\x67\x00\x0f\x00\x09\x01\x68\x00\x0a\x01\x0b\x01\xe1\x02\xe2\x00\x2f\x00\xd1\x00\xba\x00\xd6\x02\xd2\x00\xe4\x02\xd3\x00\x69\x00\xd4\x00\x0c\x01\x0d\x01\x2a\x01\x2b\x01\x6a\x00\xd1\x02\xd5\x00\xd6\x00\xd7\x00\x6f\xfe\xd8\x00\x2c\x01\xd9\x00\x3e\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x61\x01\x7f\x00\x80\x00\x81\x00\x37\x00\x38\x00\x39\x00\x71\x00\x91\x00\x92\x00\x12\x00\x13\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x83\x00\x2d\x00\xb2\x02\x30\x00\x31\x00\xbb\x00\x87\x00\x40\x00\x41\x00\x4b\x00\xbc\x00\x6f\xfe\x6f\xfe\x5f\x00\x60\x00\x89\x02\x8a\x02\xbd\x00\x8d\x00\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x4d\x00\x11\x00\x12\x00\xc0\x02\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6b\x01\x6c\x01\x40\x00\x2d\x00\x11\x00\x12\x00\xc2\x02\x6f\xfe\x10\x01\x11\x01\x6f\xfe\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x11\x00\x12\x00\xc3\x02\x2d\x00\x6f\xfe\xc5\x02\x6f\xfe\x2d\x00\x6f\xfe\x4b\x00\x6f\xfe\xcc\x02\x2d\x00\x94\x02\xa8\x02\xb0\x02\x3e\x00\xaa\xfe\xaa\x02\x68\x02\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x4d\x00\x6f\xfe\x6f\xfe\x6f\xfe\x64\x02\x6f\xfe\x7e\xff\x6f\xfe\x6a\x02\x76\x02\x2d\x00\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x2d\x00\x51\x01\x6f\xfe\x3c\x02\x52\x01\x6f\xfe\x18\x02\x6f\xfe\x7c\x02\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x83\x02\x6f\xfe\x84\x02\x6f\xfe\x54\x01\xbf\x00\x6f\xfe\x55\x01\x86\x02\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x8c\x02\xd8\x01\x0f\x02\x16\x02\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x6f\xfe\x42\x01\x18\x02\x6f\xfe\x17\x02\x1a\x02\x1c\x02\xc0\x00\x1b\x02\x4b\x00\xc1\x00\x71\x01\x2d\x00\x58\x00\x23\x02\x6f\xfe\x27\x02\x6f\xfe\x28\x02\x6f\xfe\x31\x02\x6f\xfe\x3a\x02\x37\x00\x38\x00\x39\x00\x4d\x00\x5a\x00\x3b\x00\x3b\x02\x40\x02\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x53\x02\x6f\xfe\x6f\xfe\x6f\xfe\x4e\x02\x6f\xfe\xc2\x01\x6f\xfe\x55\x02\xaa\x01\xab\x01\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x7f\xff\xae\x01\x6f\xfe\x71\x01\xb7\x01\x6f\xfe\xb3\x01\x6f\xfe\xb5\x01\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\xba\x01\x6f\xfe\x7f\xff\x6f\xfe\xbb\x01\xb9\x01\x6f\xfe\xbe\x01\xc2\x01\x6f\xfe\x0a\xff\x0a\xff\x0a\xff\x0a\xff\x0a\xff\x0a\xff\xc7\x01\x0a\xff\x0a\xff\x0a\xff\x0a\xff\x0a\xff\x0a\xff\x0a\xff\x0a\xff\x0a\xff\xca\x01\xd1\x01\xd8\x01\xd2\x01\x0a\xff\x36\x01\xe2\x01\x0a\xff\x3e\x00\x3f\x00\x0a\xff\x0a\xff\x0a\xff\x71\x01\x0a\xff\xea\x01\x0a\xff\xee\x01\x0a\xff\x75\x01\xfd\x01\xfe\x01\x0a\xff\x42\x00\x0a\xff\x0a\xff\x0a\xff\xff\x01\x0a\xff\xbd\x02\x0a\xff\x0a\xff\x0a\xff\x0a\xff\x0a\xff\x0a\xff\x0a\x02\x07\x02\x0a\xff\x0a\xff\x0a\xff\x0a\xff\x0a\xff\x0a\xff\x21\x01\x79\xfe\x78\xfe\x7b\xfe\x7e\xfe\x0a\xff\x35\x01\x0a\xff\x36\x01\x38\x01\x42\x01\x4a\x01\x0a\xff\x0a\xff\x0a\xff\x0a\xff\x0a\xff\x0a\xff\x0a\xff\x43\x01\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x44\x01\x0a\xff\x4b\x01\x4d\x01\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x6f\xfe\x50\x01\x0a\xff\x6f\xfe\x5d\x01\x6f\xfe\x4e\x01\x61\x01\x64\x01\x4b\x00\x65\x01\xf9\x00\x84\x01\x71\x01\x75\x01\x6f\xfe\x77\x01\x6f\xfe\x79\x01\x6f\xfe\x93\x01\x6f\xfe\x94\x01\x95\x01\x2d\x00\x40\x00\x4d\x00\x3e\x00\x9f\x01\xad\x00\xb0\x00\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\xad\x00\x6f\xfe\x6f\xfe\x6f\xfe\xb2\x00\x6f\xfe\xe9\x00\x6f\xfe\x12\x01\x1c\x01\x1e\x01\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x0d\x00\x1f\x01\x6f\xfe\x2e\x00\x4e\x00\x6f\xfe\x2f\x00\x33\x00\x1e\x00\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\xc4\x00\x6f\xfe\xff\xff\x6f\xfe\x0e\x00\x08\x00\x6f\xfe\x00\x00\x00\x00\x6f\xfe\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x67\x00\x00\x00\xc0\x00\x68\x00\x00\x00\xc1\x00\x00\x00\x00\x00\x58\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7d\x00\x37\x00\x38\x00\x39\x00\x6a\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x7e\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x7f\x00\x80\x00\x81\x00\x00\x00\x3e\x00\x3f\x00\x71\x00\x00\x00\x40\x00\x41\x00\x82\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x83\x00\x84\x00\x85\x00\x86\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x88\x00\x00\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x00\x00\x8d\x00\x00\x00\x8e\x00\x00\x00\x00\x00\x8f\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x69\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x7e\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x7f\x00\x80\x00\x81\x00\x4d\x00\xdd\x01\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x82\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x83\x00\x84\x00\x85\x00\x86\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x00\x00\x8d\x00\x00\x00\x8e\x00\x00\x00\x00\x00\x8f\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x44\x00\x00\x00\x00\x00\x89\x01\x48\x00\x49\x00\x4a\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7d\x00\x00\x00\x6f\xfe\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x7f\x00\x80\x00\x81\x00\x00\x00\x6f\xfe\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x83\x00\x00\x00\xaf\x01\x00\x00\x00\x00\xbb\x00\x87\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8a\x01\x8d\x00\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x4d\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x00\x00\x00\x00\x00\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\x00\x00\x00\x00\x6f\xfe\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\x00\x00\x6f\xfe\x00\x00\x6f\xfe\x4b\x00\x6f\xfe\x00\x00\x00\x00\x00\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\x00\x00\x00\x00\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x4d\x00\x6f\xfe\x6f\xfe\x6f\xfe\x00\x00\x6f\xfe\x00\x00\x6f\xfe\xe0\x00\xe1\x00\x00\x00\xe2\x00\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x00\x00\xe4\x00\xe5\x00\x00\x00\x00\x00\x6f\xfe\x00\x00\x00\x00\x6f\xfe\x00\x00\x00\x00\x00\x00\x6f\xfe\x6f\xfe\x6f\xfe\x00\x00\x00\x00\x6f\xfe\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7c\x00\x6f\xfe\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x08\x01\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x00\x09\x01\x00\x00\x00\x00\xe1\x00\x69\x00\xe2\x00\x7d\x00\x00\x00\x6f\xfe\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe4\x00\xe5\x00\x00\x00\x00\x00\x3e\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x7f\x00\x80\x00\x81\x00\x00\x00\x6f\xfe\x00\x00\x71\x00\x5a\x01\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x87\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x4d\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\xdc\x00\x00\x00\xde\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\x00\x00\x67\x01\x6f\xfe\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x09\x01\x00\x00\x00\x00\xe1\x00\x6f\xfe\x00\x00\x6f\xfe\x00\x00\x6f\xfe\x4b\x00\x6f\xfe\x68\x01\x00\x00\x00\x00\x00\x00\xe4\x00\xe5\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x4d\x00\x6f\xfe\x6f\xfe\x6f\xfe\x00\x00\x6f\xfe\x00\x00\x6f\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\x00\x00\x00\x00\x6f\xfe\x00\x00\x00\x00\x00\x00\x6f\xfe\x6f\xfe\x6f\xfe\x00\x00\x00\x00\x6f\xfe\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7c\x00\x6f\xfe\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x00\x00\x00\x00\x00\xe0\x00\xe1\x00\x69\x00\xe2\x00\x7d\x00\xe3\x00\x6f\xfe\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe4\x00\xe5\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x7f\x00\x80\x00\x81\x00\x00\x00\x6f\xfe\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x87\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x89\x01\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7d\x00\x00\x00\x3e\x00\x00\x00\x6a\x00\x00\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x7f\x00\x80\x00\x81\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x87\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8a\x01\x8d\x00\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x4d\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x6f\xfe\x00\x00\x00\x00\x6f\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\x00\x00\x6f\xfe\x00\x00\x6f\xfe\x00\x00\x6f\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x00\x00\x6f\xfe\x6f\xfe\x6f\xfe\x00\x00\x6f\xfe\x00\x00\x6f\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\x00\x00\x00\x00\x6f\xfe\x00\x00\x00\x00\x00\x00\x6f\xfe\x6f\xfe\x6f\xfe\x00\x00\x00\x00\x6f\xfe\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7c\x00\x6f\xfe\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x89\x01\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7d\x00\x00\x00\x3e\x00\x00\x00\x6a\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x7f\x00\x80\x00\x81\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x87\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8a\x01\x8d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x67\x00\xf9\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x7f\x00\x80\x00\x81\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x87\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\xd1\x00\x00\x00\x00\x00\xd2\x00\x00\x00\x4b\x01\xba\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7d\x00\xd5\x00\xd6\x00\xd7\x00\x6a\x00\xd8\x00\x00\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x7f\x00\x80\x00\x81\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x87\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\xd1\x00\x00\x00\x00\x00\xd2\x00\x00\x00\x3c\x01\xba\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7d\x00\xd5\x00\xd6\x00\xd7\x00\x6a\x00\xd8\x00\x00\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x7f\x00\x80\x00\x81\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x87\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\x01\x8d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\xd1\x00\x00\x00\x00\x00\xd2\x00\x00\x00\x4b\x01\xba\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7d\x00\xd5\x00\xd6\x00\xd7\x00\x6a\x00\xd8\x00\x00\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x7f\x00\x80\x00\x81\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x87\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x7f\x00\x80\x00\x81\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x87\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\x01\x8d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x7f\x00\x80\x00\x81\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x87\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x7f\x00\x80\x00\x81\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x87\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\x01\x8d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x7f\x00\x80\x00\x81\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x87\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x7f\x00\x80\x00\x81\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x87\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\x01\x8d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x7f\x00\x80\x00\x81\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x87\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\xfb\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x7f\x00\x80\x00\x81\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x87\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x7f\x00\x80\x00\x81\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x87\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7c\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x7f\x00\x80\x00\x81\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x89\x00\x8a\x00\x8b\x00\x00\x00\x00\x00\x8d\x00\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x4d\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x00\x00\x00\x00\x00\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\x00\x00\x00\x00\x6f\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\x00\x00\x6f\xfe\x00\x00\x6f\xfe\x00\x00\x6f\xfe\x00\x00\x00\x00\xce\x00\xcf\x00\xd0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x00\x00\x6f\xfe\x6f\xfe\x6f\xfe\x00\x00\x6f\xfe\x00\x00\x6f\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\x00\x00\x00\x00\x6f\xfe\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7c\x00\x00\x00\x6f\xfe\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x6f\xfe\xd1\x00\x00\x00\x00\x00\xd2\x00\x00\x00\xd3\x00\x67\x00\xd4\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x00\xd6\x00\xd7\x00\x00\x00\xd8\x00\x00\x00\xd9\x00\x69\x00\xda\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x7f\x00\x80\x00\x81\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x89\x00\x8a\x00\x8b\x00\x00\x00\x00\x00\x8d\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x7f\x00\x80\x00\x81\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x87\x00\x00\x00\x00\x00\x4b\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x8d\x00\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x4d\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\x00\x00\x00\x00\x6f\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\x00\x00\x6f\xfe\x00\x00\x6f\xfe\x00\x00\x6f\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x00\x00\x6f\xfe\x6f\xfe\x6f\xfe\x00\x00\x6f\xfe\x00\x00\x6f\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x6f\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\x00\x00\x00\x00\x6f\xfe\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x7c\x00\x00\x00\x6f\xfe\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x6f\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x7f\x00\x80\x00\x81\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x4b\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\x00\x00\x8d\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x7f\x00\x80\x00\x81\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x83\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x4b\x00\x5e\x00\x3f\x00\x5f\x00\x60\x00\x61\x00\x41\x00\x17\x00\x00\x00\x8d\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x3f\x00\x69\x00\x00\x00\x40\x00\x41\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe0\x00\xe1\x00\x42\x00\xe2\x00\x3e\x01\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x00\x00\x43\x00\xe4\x00\xe5\x00\x00\x00\x00\x00\x00\x00\x71\x00\xe2\xfe\xe2\xfe\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x18\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x00\x00\x67\x00\x4d\x00\x00\x00\x68\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x3e\x00\x3f\x00\x00\x00\x69\x00\x40\x00\x41\x00\x00\x00\x6f\xfe\x4b\x00\x6a\x00\x3f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x00\x00\x4c\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\xfe\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x4d\x00\x68\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x34\x02\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x3e\x00\x3f\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x4d\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x69\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x3e\x00\x00\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x28\x01\xd8\x02\xdd\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\xa7\x00\x67\x01\xa8\x00\x00\x00\x00\x00\xd9\x02\x00\x00\x71\x00\xa9\x00\x00\x00\x09\x01\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x68\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x4b\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\xdc\x01\xdd\x01\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\xaa\x00\x4b\x00\x40\x00\x41\x00\x00\x00\x9b\x01\xdd\x00\x00\x00\xdf\x00\x4d\x00\x00\x00\x00\x00\x00\x00\xa7\x00\x00\x00\xa8\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\xa9\x00\x00\x00\x00\x00\x00\x00\x9c\x01\x00\x00\x44\x00\xe2\x00\x00\x00\x00\x00\x48\x00\x49\x00\x4a\x00\x9d\x01\x00\x00\x00\x00\x81\xff\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x4b\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x00\x67\x01\xa8\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x00\x00\x00\x09\x01\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x3e\x00\x68\x01\x00\x00\x00\x00\x40\x00\x41\x00\x00\x00\x9b\x01\xdd\x00\x4b\x00\xdf\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x00\x00\x00\xa8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x00\x00\x00\x00\x00\x4d\x00\x9c\x01\x00\x00\x00\x00\xe2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x01\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x3e\x00\x00\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\x00\x00\xaa\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x00\x00\x00\xa8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdf\x02\x3e\x00\x00\x00\x4b\x00\x00\x00\x40\x00\x41\x00\x00\x00\x00\x00\x5d\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x00\x00\x00\xa8\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\xa9\x00\x00\x00\x00\x00\x00\x00\x5d\xff\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x81\xff\x00\x00\xb1\x02\x00\x00\x00\x00\x00\x00\xaa\x00\x4b\x00\x3e\x00\x00\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x00\x4d\x00\xa8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x4b\x00\x40\x00\x41\x00\x00\x00\x3e\x00\x5d\xff\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\x00\x00\xa7\x00\x00\x00\xa8\x00\x00\x00\x00\x00\x4d\x00\x00\x00\xa7\x00\xa9\x00\xa8\x00\x00\x00\x00\x00\x5d\xff\x00\x00\x00\x00\xa9\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\xb1\x02\x3e\x00\x00\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\xaa\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x00\x00\x00\xa8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x00\x65\x01\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x3e\x00\x4b\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\xaa\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x00\x00\x00\xa8\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x00\x00\x00\x4d\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x3e\x00\x00\x00\x5f\x00\x60\x00\x40\x00\x41\x00\x00\x00\x3e\x00\x00\x00\x4b\x00\x00\x00\x40\x00\x41\x00\x00\x00\x00\x00\xa7\x00\x00\x00\xa8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x02\xa9\x00\xa8\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\xa9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x3e\x00\x00\x00\x00\x00\x60\x02\x40\x00\x41\x00\x00\x00\x00\x00\xaa\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x00\x00\x00\xa8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x00\x00\x00\x00\x00\x4d\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x60\x02\x3e\x00\x4b\x00\x00\x00\x00\x00\x40\x00\x41\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x00\x00\x00\xa8\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x3e\x00\x00\x00\x00\x00\xaf\x02\x40\x00\x41\x00\x00\x00\x3e\x00\x4b\x00\x00\x00\x00\x00\x40\x00\x41\x00\x00\x00\x00\x00\x5f\x02\x00\x00\xa8\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x00\xa9\x00\xa8\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x60\x02\x3e\x00\x3f\x00\x00\x00\x00\x00\x40\x00\x41\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc4\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x3e\x00\x3f\x00\x4b\x00\x00\x00\x40\x00\x41\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x3e\x00\x00\x00\x00\x00\xc9\x00\x40\x00\x00\x00\x4d\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x28\x01\x29\x01\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x4b\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x2a\x01\x00\x00\x00\x00\x00\x00\x5a\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x4d\x00\x00\x00\x43\x00\x3e\x00\x3f\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x42\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x4b\x00\x40\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x5a\x01\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x4d\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x4b\x00\x40\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x4d\x00\x00\x00\x28\x01\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x4b\x00\x3e\x00\x3f\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x4b\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\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x45\x00\x46\x00\x47\x00\x48\x00\x49\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\xf9\x00\xb5\x00\xb6\x00\xfa\x00\xb8\x00\x75\x00\x76\x00\x00\x00\x00\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\xfb\x00\xfc\x00\x4d\x00\x00\x00\xfd\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\xfe\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x01\x01\x01\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xd5\x00\xd6\x00\x02\x01\x03\x01\xd8\x00\x04\x01\x05\x01\x5b\x00\x5c\x00\xe4\x01\xb5\x00\xb6\x00\x85\x01\xb8\x00\x75\x00\x76\x00\x00\x00\x00\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\xe2\x02\xe6\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe7\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xf0\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x5b\x00\x5c\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x8a\x02\xf2\x00\xf3\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x00\x00\xe4\x01\xb5\x00\xb6\x00\x85\x01\xb8\x00\x75\x00\x76\x00\x00\x00\x00\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x51\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\xe5\x01\xe6\x01\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xe7\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xe4\x01\xb5\x00\xb6\x00\x85\x01\xb8\x00\x75\x00\x76\x00\x5b\x00\x5c\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\xf1\x01\xe6\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe7\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xf0\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x5b\x00\x5c\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x31\x01\xf2\x00\xf3\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\xf0\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x00\x00\x00\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\xf1\x00\xf2\x00\xf3\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x79\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xca\x00\x00\x00\x00\x00\x77\x00\x4f\x00\x50\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x84\x01\xb5\x00\xb6\x00\x85\x01\xb8\x00\x75\x00\x76\x00\x5b\x00\x5c\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x51\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x86\x01\x00\x00\xbd\x02\x00\x00\x5b\x00\x5c\x00\x4e\x00\x4f\x00\x50\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x51\x00\x00\x00\x00\x00\x52\x00\x13\x00\x00\x00\x53\x00\x13\x02\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x84\x01\xb5\x00\xb6\x00\x85\x01\xb8\x00\x75\x00\x76\x00\x5b\x00\x5c\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x51\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x86\x01\x00\x00\x60\x02\x00\x00\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xe4\x01\xb5\x00\xb6\x00\x85\x01\xb8\x00\x75\x00\x76\x00\x5b\x00\x5c\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x00\x00\x86\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe7\x01\x00\x00\x00\x00\x00\x00\xca\x01\xcb\x01\xcc\x01\x4f\x00\x50\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x84\x01\xb5\x00\xb6\x00\x85\x01\xb8\x00\x75\x00\x76\x00\x5b\x00\x5c\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x51\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x86\x01\x00\x00\x4c\x02\x00\x00\x5b\x00\x5c\x00\x4e\x00\x4f\x00\x50\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x51\x00\x00\x00\x00\x00\x52\x00\x13\x00\x00\x00\x53\x00\x54\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x84\x01\xb5\x00\xb6\x00\x85\x01\xb8\x00\x75\x00\x76\x00\x5b\x00\x5c\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x51\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x86\x01\x00\x00\xb1\x01\x00\x00\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xf0\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x5b\x00\x5c\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x01\xf3\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x00\x00\x84\x01\xb5\x00\xb6\x00\x85\x01\xb8\x00\x75\x00\x76\x00\x00\x00\x00\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x51\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x86\x01\x00\x00\x87\x01\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x84\x01\xb5\x00\xb6\x00\x85\x01\xb8\x00\x75\x00\x76\x00\x5b\x00\x5c\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x01\x00\x00\x8a\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xf5\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x5b\x00\x5c\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\xf6\x00\xf7\x00\x00\x00\xf5\x01\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x00\x00\x00\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\xf6\x01\x51\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xe6\x02\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x5b\x00\x5c\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\xcf\x02\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x00\x00\x00\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x79\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xcc\x02\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x5b\x00\x5c\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x8e\x02\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x00\x00\x00\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x79\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x94\x02\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x5b\x00\x5c\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x61\x02\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x00\x00\x00\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x79\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x79\x02\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x5b\x00\x5c\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x84\x02\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x00\x00\x00\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x79\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x87\x02\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x5b\x00\x5c\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x10\x02\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x00\x00\x00\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x79\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x23\x02\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x5b\x00\x5c\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x2d\x02\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x00\x00\x00\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x79\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x2e\x02\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x5b\x00\x5c\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\xf2\x01\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x00\x00\x00\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x79\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xf3\x01\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x5b\x00\x5c\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\xf4\x01\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x00\x00\x00\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x79\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xf7\x01\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x5b\x00\x5c\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\xfb\x01\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x00\x00\x00\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x79\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x5a\x01\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x5b\x00\x5c\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x71\x01\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x00\x00\x00\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x79\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x5b\x00\x5c\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\xc9\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x00\x00\x00\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x79\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xe9\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x5b\x00\x5c\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\xee\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x00\x00\x00\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x79\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\xef\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\x75\x00\x76\x00\x5b\x00\x5c\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x36\x01\xb6\x00\xed\x00\xb8\x00\x75\x00\x76\x00\x00\x00\x00\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x79\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\xec\x00\xb6\x00\xed\x00\xb8\x00\x75\x00\x76\x00\x5b\x00\x5c\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x95\x02\x00\x00\x75\x00\x76\x00\x00\x00\x00\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x51\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x96\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x74\x00\x00\x00\x75\x00\x76\x00\x5b\x00\x5c\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x00\x00\x00\x00\xef\x01\x5d\x01\x76\x00\x00\x00\x00\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x5b\x00\x5c\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x5d\x01\x76\x00\x00\x00\x00\x00\x77\x00\x4f\x00\x50\x00\x78\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x00\x00\x00\x00\x32\x02\xcc\x01\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x2e\x01\x4f\x00\x50\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x61\x01\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x62\x01\x4f\x00\x50\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\xcd\x00\x4f\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\xf4\x00\x4f\x00\x50\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x51\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x00\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x37\x00\x38\x00\x39\x00\x59\x00\x5a\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"# + +happyReduceArr = array (1, 413) [ + (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), + (303 , happyReduce_303), + (304 , happyReduce_304), + (305 , happyReduce_305), + (306 , happyReduce_306), + (307 , happyReduce_307), + (308 , happyReduce_308), + (309 , happyReduce_309), + (310 , happyReduce_310), + (311 , happyReduce_311), + (312 , happyReduce_312), + (313 , happyReduce_313), + (314 , happyReduce_314), + (315 , happyReduce_315), + (316 , happyReduce_316), + (317 , happyReduce_317), + (318 , happyReduce_318), + (319 , happyReduce_319), + (320 , happyReduce_320), + (321 , happyReduce_321), + (322 , happyReduce_322), + (323 , happyReduce_323), + (324 , happyReduce_324), + (325 , happyReduce_325), + (326 , happyReduce_326), + (327 , happyReduce_327), + (328 , happyReduce_328), + (329 , happyReduce_329), + (330 , happyReduce_330), + (331 , happyReduce_331), + (332 , happyReduce_332), + (333 , happyReduce_333), + (334 , happyReduce_334), + (335 , happyReduce_335), + (336 , happyReduce_336), + (337 , happyReduce_337), + (338 , happyReduce_338), + (339 , happyReduce_339), + (340 , happyReduce_340), + (341 , happyReduce_341), + (342 , happyReduce_342), + (343 , happyReduce_343), + (344 , happyReduce_344), + (345 , happyReduce_345), + (346 , happyReduce_346), + (347 , happyReduce_347), + (348 , happyReduce_348), + (349 , happyReduce_349), + (350 , happyReduce_350), + (351 , happyReduce_351), + (352 , happyReduce_352), + (353 , happyReduce_353), + (354 , happyReduce_354), + (355 , happyReduce_355), + (356 , happyReduce_356), + (357 , happyReduce_357), + (358 , happyReduce_358), + (359 , happyReduce_359), + (360 , happyReduce_360), + (361 , happyReduce_361), + (362 , happyReduce_362), + (363 , happyReduce_363), + (364 , happyReduce_364), + (365 , happyReduce_365), + (366 , happyReduce_366), + (367 , happyReduce_367), + (368 , happyReduce_368), + (369 , happyReduce_369), + (370 , happyReduce_370), + (371 , happyReduce_371), + (372 , happyReduce_372), + (373 , happyReduce_373), + (374 , happyReduce_374), + (375 , happyReduce_375), + (376 , happyReduce_376), + (377 , happyReduce_377), + (378 , happyReduce_378), + (379 , happyReduce_379), + (380 , happyReduce_380), + (381 , happyReduce_381), + (382 , happyReduce_382), + (383 , happyReduce_383), + (384 , happyReduce_384), + (385 , happyReduce_385), + (386 , happyReduce_386), + (387 , happyReduce_387), + (388 , happyReduce_388), + (389 , happyReduce_389), + (390 , happyReduce_390), + (391 , happyReduce_391), + (392 , happyReduce_392), + (393 , happyReduce_393), + (394 , happyReduce_394), + (395 , happyReduce_395), + (396 , happyReduce_396), + (397 , happyReduce_397), + (398 , happyReduce_398), + (399 , happyReduce_399), + (400 , happyReduce_400), + (401 , happyReduce_401), + (402 , happyReduce_402), + (403 , happyReduce_403), + (404 , happyReduce_404), + (405 , happyReduce_405), + (406 , happyReduce_406), + (407 , happyReduce_407), + (408 , happyReduce_408), + (409 , happyReduce_409), + (410 , happyReduce_410), + (411 , happyReduce_411), + (412 , happyReduce_412), + (413 , happyReduce_413) + ] + +happy_n_terms = 108 :: Int +happy_n_nonterms = 172 :: Int + +happyReduce_1 = happyMonadReduce 1# 0# happyReduction_1 +happyReduction_1 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut5 happy_x_1 of { happy_var_1 -> + ( mkPageModule happy_var_1)} + ) (\r -> happyReturn (happyIn4 r)) + +happyReduce_2 = happyMonadReduce 5# 0# happyReduction_2 +happyReduction_2 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut6 happy_x_2 of { happy_var_2 -> + case happyOut165 happy_x_4 of { happy_var_4 -> + case happyOut5 happy_x_5 of { happy_var_5 -> + ( mkPage happy_var_2 happy_var_4 happy_var_5)}}} + ) (\r -> happyReturn (happyIn4 r)) + +happyReduce_3 = happySpecReduce_1 0# happyReduction_3 +happyReduction_3 happy_x_1 + = case happyOut6 happy_x_1 of { happy_var_1 -> + happyIn4 + (happy_var_1 + )} + +happyReduce_4 = happyMonadReduce 10# 1# happyReduction_4 +happyReduction_4 (happy_x_10 `HappyStk` + 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) tk + = happyThen (case happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut109 happy_x_3 of { happy_var_3 -> + case happyOut111 happy_x_4 of { happy_var_4 -> + case happyOut113 happy_x_5 of { happy_var_5 -> + case happyOut107 happy_x_7 of { happy_var_7 -> + case happyOut109 happy_x_9 of { happy_var_9 -> + ( do { n <- checkEqNames happy_var_3 happy_var_9; + let { cn = reverse happy_var_7; + as = reverse happy_var_4; }; + return $ HsXTag happy_var_1 n as happy_var_5 cn })}}}}}} + ) (\r -> happyReturn (happyIn5 r)) + +happyReduce_5 = happyReduce 6# 1# happyReduction_5 +happyReduction_5 (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 happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut109 happy_x_3 of { happy_var_3 -> + case happyOut111 happy_x_4 of { happy_var_4 -> + case happyOut113 happy_x_5 of { happy_var_5 -> + happyIn5 + (HsXETag happy_var_1 happy_var_3 (reverse happy_var_4) happy_var_5 + ) `HappyStk` happyRest}}}} + +happyReduce_6 = happyReduce 6# 2# happyReduction_6 +happyReduction_6 (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 happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut168 happy_x_3 of { happy_var_3 -> + case happyOut11 happy_x_4 of { happy_var_4 -> + case happyOut7 happy_x_6 of { happy_var_6 -> + happyIn6 + (HsModule happy_var_1 happy_var_3 happy_var_4 (fst happy_var_6) (snd happy_var_6) + ) `HappyStk` happyRest}}}} + +happyReduce_7 = happySpecReduce_2 2# happyReduction_7 +happyReduction_7 happy_x_2 + happy_x_1 + = case happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut7 happy_x_2 of { happy_var_2 -> + happyIn6 + (HsModule happy_var_1 main_mod (Just [HsEVar (UnQual main_name)]) + (fst happy_var_2) (snd happy_var_2) + )}} + +happyReduce_8 = happySpecReduce_3 3# happyReduction_8 +happyReduction_8 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut8 happy_x_2 of { happy_var_2 -> + happyIn7 + (happy_var_2 + )} + +happyReduce_9 = happySpecReduce_3 3# happyReduction_9 +happyReduction_9 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut8 happy_x_2 of { happy_var_2 -> + happyIn7 + (happy_var_2 + )} + +happyReduce_10 = happyReduce 4# 4# happyReduction_10 +happyReduction_10 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut16 happy_x_2 of { happy_var_2 -> + case happyOut31 happy_x_4 of { happy_var_4 -> + happyIn8 + ((reverse happy_var_2, happy_var_4) + ) `HappyStk` happyRest}} + +happyReduce_11 = happySpecReduce_2 4# happyReduction_11 +happyReduction_11 happy_x_2 + happy_x_1 + = case happyOut31 happy_x_2 of { happy_var_2 -> + happyIn8 + (([], happy_var_2) + )} + +happyReduce_12 = happySpecReduce_3 4# happyReduction_12 +happyReduction_12 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut16 happy_x_2 of { happy_var_2 -> + happyIn8 + ((reverse happy_var_2, []) + )} + +happyReduce_13 = happySpecReduce_1 4# happyReduction_13 +happyReduction_13 happy_x_1 + = happyIn8 + (([], []) + ) + +happyReduce_14 = happySpecReduce_2 5# happyReduction_14 +happyReduction_14 happy_x_2 + happy_x_1 + = happyIn9 + (() + ) + +happyReduce_15 = happySpecReduce_1 6# happyReduction_15 +happyReduction_15 happy_x_1 + = happyIn10 + (() + ) + +happyReduce_16 = happySpecReduce_0 6# happyReduction_16 +happyReduction_16 = happyIn10 + (() + ) + +happyReduce_17 = happySpecReduce_1 7# happyReduction_17 +happyReduction_17 happy_x_1 + = case happyOut12 happy_x_1 of { happy_var_1 -> + happyIn11 + (Just happy_var_1 + )} + +happyReduce_18 = happySpecReduce_0 7# happyReduction_18 +happyReduction_18 = happyIn11 + (Nothing + ) + +happyReduce_19 = happyReduce 4# 8# happyReduction_19 +happyReduction_19 (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 -> + happyIn12 + (reverse happy_var_2 + ) `HappyStk` happyRest} + +happyReduce_20 = happySpecReduce_3 8# happyReduction_20 +happyReduction_20 happy_x_3 + happy_x_2 + happy_x_1 + = happyIn12 + ([] + ) + +happyReduce_21 = happySpecReduce_1 9# happyReduction_21 +happyReduction_21 happy_x_1 + = happyIn13 + (() + ) + +happyReduce_22 = happySpecReduce_0 9# happyReduction_22 +happyReduction_22 = happyIn13 + (() + ) + +happyReduce_23 = happySpecReduce_3 10# happyReduction_23 +happyReduction_23 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_24 = happySpecReduce_1 10# happyReduction_24 +happyReduction_24 happy_x_1 + = case happyOut15 happy_x_1 of { happy_var_1 -> + happyIn14 + ([happy_var_1] + )} + +happyReduce_25 = happySpecReduce_1 11# happyReduction_25 +happyReduction_25 happy_x_1 + = case happyOut138 happy_x_1 of { happy_var_1 -> + happyIn15 + (HsEVar happy_var_1 + )} + +happyReduce_26 = happySpecReduce_1 11# happyReduction_26 +happyReduction_26 happy_x_1 + = case happyOut171 happy_x_1 of { happy_var_1 -> + happyIn15 + (HsEAbs happy_var_1 + )} + +happyReduce_27 = happyReduce 4# 11# happyReduction_27 +happyReduction_27 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut171 happy_x_1 of { happy_var_1 -> + happyIn15 + (HsEThingAll happy_var_1 + ) `HappyStk` happyRest} + +happyReduce_28 = happySpecReduce_3 11# happyReduction_28 +happyReduction_28 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut171 happy_x_1 of { happy_var_1 -> + happyIn15 + (HsEThingWith happy_var_1 [] + )} + +happyReduce_29 = happyReduce 4# 11# happyReduction_29 +happyReduction_29 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut171 happy_x_1 of { happy_var_1 -> + case happyOut25 happy_x_3 of { happy_var_3 -> + happyIn15 + (HsEThingWith happy_var_1 (reverse happy_var_3) + ) `HappyStk` happyRest}} + +happyReduce_30 = happySpecReduce_2 11# happyReduction_30 +happyReduction_30 happy_x_2 + happy_x_1 + = case happyOut168 happy_x_2 of { happy_var_2 -> + happyIn15 + (HsEModuleContents happy_var_2 + )} + +happyReduce_31 = happySpecReduce_3 12# happyReduction_31 +happyReduction_31 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut16 happy_x_1 of { happy_var_1 -> + case happyOut17 happy_x_3 of { happy_var_3 -> + happyIn16 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_32 = happySpecReduce_1 12# happyReduction_32 +happyReduction_32 happy_x_1 + = case happyOut17 happy_x_1 of { happy_var_1 -> + happyIn16 + ([happy_var_1] + )} + +happyReduce_33 = happyReduce 6# 13# happyReduction_33 +happyReduction_33 (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 happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut18 happy_x_3 of { happy_var_3 -> + case happyOut168 happy_x_4 of { happy_var_4 -> + case happyOut19 happy_x_5 of { happy_var_5 -> + case happyOut20 happy_x_6 of { happy_var_6 -> + happyIn17 + (HsImportDecl happy_var_1 happy_var_4 happy_var_3 happy_var_5 happy_var_6 + ) `HappyStk` happyRest}}}}} + +happyReduce_34 = happySpecReduce_1 14# happyReduction_34 +happyReduction_34 happy_x_1 + = happyIn18 + (True + ) + +happyReduce_35 = happySpecReduce_0 14# happyReduction_35 +happyReduction_35 = happyIn18 + (False + ) + +happyReduce_36 = happySpecReduce_2 15# happyReduction_36 +happyReduction_36 happy_x_2 + happy_x_1 + = case happyOut168 happy_x_2 of { happy_var_2 -> + happyIn19 + (Just happy_var_2 + )} + +happyReduce_37 = happySpecReduce_0 15# happyReduction_37 +happyReduction_37 = happyIn19 + (Nothing + ) + +happyReduce_38 = happySpecReduce_1 16# happyReduction_38 +happyReduction_38 happy_x_1 + = case happyOut21 happy_x_1 of { happy_var_1 -> + happyIn20 + (Just happy_var_1 + )} + +happyReduce_39 = happySpecReduce_0 16# happyReduction_39 +happyReduction_39 = happyIn20 + (Nothing + ) + +happyReduce_40 = happyReduce 5# 17# happyReduction_40 +happyReduction_40 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut22 happy_x_1 of { happy_var_1 -> + case happyOut23 happy_x_3 of { happy_var_3 -> + happyIn21 + ((happy_var_1, reverse happy_var_3) + ) `HappyStk` happyRest}} + +happyReduce_41 = happyReduce 4# 17# happyReduction_41 +happyReduction_41 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut22 happy_x_1 of { happy_var_1 -> + happyIn21 + ((happy_var_1, []) + ) `HappyStk` happyRest} + +happyReduce_42 = happySpecReduce_1 18# happyReduction_42 +happyReduction_42 happy_x_1 + = happyIn22 + (True + ) + +happyReduce_43 = happySpecReduce_0 18# happyReduction_43 +happyReduction_43 = happyIn22 + (False + ) + +happyReduce_44 = happySpecReduce_3 19# happyReduction_44 +happyReduction_44 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_45 = happySpecReduce_1 19# happyReduction_45 +happyReduction_45 happy_x_1 + = case happyOut24 happy_x_1 of { happy_var_1 -> + happyIn23 + ([happy_var_1] + )} + +happyReduce_46 = happySpecReduce_1 20# happyReduction_46 +happyReduction_46 happy_x_1 + = case happyOut136 happy_x_1 of { happy_var_1 -> + happyIn24 + (HsIVar happy_var_1 + )} + +happyReduce_47 = happySpecReduce_1 20# happyReduction_47 +happyReduction_47 happy_x_1 + = case happyOut169 happy_x_1 of { happy_var_1 -> + happyIn24 + (HsIAbs happy_var_1 + )} + +happyReduce_48 = happyReduce 4# 20# happyReduction_48 +happyReduction_48 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut169 happy_x_1 of { happy_var_1 -> + happyIn24 + (HsIThingAll happy_var_1 + ) `HappyStk` happyRest} + +happyReduce_49 = happySpecReduce_3 20# happyReduction_49 +happyReduction_49 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut169 happy_x_1 of { happy_var_1 -> + happyIn24 + (HsIThingWith happy_var_1 [] + )} + +happyReduce_50 = happyReduce 4# 20# happyReduction_50 +happyReduction_50 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut169 happy_x_1 of { happy_var_1 -> + case happyOut25 happy_x_3 of { happy_var_3 -> + happyIn24 + (HsIThingWith happy_var_1 (reverse happy_var_3) + ) `HappyStk` happyRest}} + +happyReduce_51 = happySpecReduce_3 21# happyReduction_51 +happyReduction_51 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut25 happy_x_1 of { happy_var_1 -> + case happyOut26 happy_x_3 of { happy_var_3 -> + happyIn25 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_52 = happySpecReduce_1 21# happyReduction_52 +happyReduction_52 happy_x_1 + = case happyOut26 happy_x_1 of { happy_var_1 -> + happyIn25 + ([happy_var_1] + )} + +happyReduce_53 = happySpecReduce_1 22# happyReduction_53 +happyReduction_53 happy_x_1 + = case happyOut136 happy_x_1 of { happy_var_1 -> + happyIn26 + (HsVarName happy_var_1 + )} + +happyReduce_54 = happySpecReduce_1 22# happyReduction_54 +happyReduction_54 happy_x_1 + = case happyOut140 happy_x_1 of { happy_var_1 -> + happyIn26 + (HsConName happy_var_1 + )} + +happyReduce_55 = happyReduce 4# 23# happyReduction_55 +happyReduction_55 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut29 happy_x_2 of { happy_var_2 -> + case happyOut28 happy_x_3 of { happy_var_3 -> + case happyOut30 happy_x_4 of { happy_var_4 -> + happyIn27 + (HsInfixDecl happy_var_1 happy_var_2 happy_var_3 (reverse happy_var_4) + ) `HappyStk` happyRest}}}} + +happyReduce_56 = happySpecReduce_0 24# happyReduction_56 +happyReduction_56 = happyIn28 + (9 + ) + +happyReduce_57 = happyMonadReduce 1# 24# happyReduction_57 +happyReduction_57 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { (IntTok happy_var_1) -> + ( checkPrec happy_var_1)} + ) (\r -> happyReturn (happyIn28 r)) + +happyReduce_58 = happySpecReduce_1 25# happyReduction_58 +happyReduction_58 happy_x_1 + = happyIn29 + (HsAssocNone + ) + +happyReduce_59 = happySpecReduce_1 25# happyReduction_59 +happyReduction_59 happy_x_1 + = happyIn29 + (HsAssocLeft + ) + +happyReduce_60 = happySpecReduce_1 25# happyReduction_60 +happyReduction_60 happy_x_1 + = happyIn29 + (HsAssocRight + ) + +happyReduce_61 = happySpecReduce_3 26# happyReduction_61 +happyReduction_61 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut30 happy_x_1 of { happy_var_1 -> + case happyOut147 happy_x_3 of { happy_var_3 -> + happyIn30 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_62 = happySpecReduce_1 26# happyReduction_62 +happyReduction_62 happy_x_1 + = case happyOut147 happy_x_1 of { happy_var_1 -> + happyIn30 + ([happy_var_1] + )} + +happyReduce_63 = happyMonadReduce 2# 27# happyReduction_63 +happyReduction_63 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut32 happy_x_1 of { happy_var_1 -> + ( checkRevDecls happy_var_1)} + ) (\r -> happyReturn (happyIn31 r)) + +happyReduce_64 = happySpecReduce_3 28# happyReduction_64 +happyReduction_64 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut32 happy_x_1 of { happy_var_1 -> + case happyOut33 happy_x_3 of { happy_var_3 -> + happyIn32 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_65 = happySpecReduce_1 28# happyReduction_65 +happyReduction_65 happy_x_1 + = case happyOut33 happy_x_1 of { happy_var_1 -> + happyIn32 + ([happy_var_1] + )} + +happyReduce_66 = happyReduce 5# 29# 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 happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut55 happy_x_3 of { happy_var_3 -> + case happyOut51 happy_x_5 of { happy_var_5 -> + happyIn33 + (HsTypeDecl happy_var_1 (fst happy_var_3) (snd happy_var_3) happy_var_5 + ) `HappyStk` happyRest}}} + +happyReduce_67 = happyMonadReduce 5# 29# happyReduction_67 +happyReduction_67 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut51 happy_x_3 of { happy_var_3 -> + case happyOut64 happy_x_4 of { happy_var_4 -> + case happyOut76 happy_x_5 of { happy_var_5 -> + ( do { (cs,c,t) <- checkDataHeader happy_var_3; + return (HsDataDecl happy_var_1 cs c t (reverse happy_var_4) happy_var_5) })}}}} + ) (\r -> happyReturn (happyIn33 r)) + +happyReduce_68 = happyMonadReduce 5# 29# happyReduction_68 +happyReduction_68 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut51 happy_x_3 of { happy_var_3 -> + case happyOut60 happy_x_5 of { happy_var_5 -> + ( do { (cs,c,t) <- checkDataHeader happy_var_3; + return (HsGDataDecl happy_var_1 cs c t (reverse happy_var_5)) })}}} + ) (\r -> happyReturn (happyIn33 r)) + +happyReduce_69 = happyMonadReduce 6# 29# happyReduction_69 +happyReduction_69 (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 happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut51 happy_x_3 of { happy_var_3 -> + case happyOut66 happy_x_5 of { happy_var_5 -> + case happyOut76 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 (happyIn33 r)) + +happyReduce_70 = happyMonadReduce 5# 29# happyReduction_70 +happyReduction_70 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut51 happy_x_3 of { happy_var_3 -> + case happyOut57 happy_x_4 of { happy_var_4 -> + case happyOut78 happy_x_5 of { happy_var_5 -> + ( do { (cs,c,vs) <- checkClassHeader happy_var_3; + return (HsClassDecl happy_var_1 cs c vs happy_var_4 happy_var_5) })}}}} + ) (\r -> happyReturn (happyIn33 r)) + +happyReduce_71 = happyMonadReduce 4# 29# happyReduction_71 +happyReduction_71 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut51 happy_x_3 of { happy_var_3 -> + case happyOut79 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 (happyIn33 r)) + +happyReduce_72 = happyReduce 5# 29# happyReduction_72 +happyReduction_72 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut34 happy_x_4 of { happy_var_4 -> + happyIn33 + (HsDefaultDecl happy_var_1 happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_73 = happyMonadReduce 4# 29# happyReduction_73 +happyReduction_73 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut87 happy_x_3 of { happy_var_3 -> + ( do { e <- checkExpr happy_var_3; + return $ HsSpliceDecl happy_var_1 $ HsParenSplice e })}} + ) (\r -> happyReturn (happyIn33 r)) + +happyReduce_74 = happyReduce 6# 29# happyReduction_74 +happyReduction_74 (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 happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut42 happy_x_4 of { happy_var_4 -> + case happyOut43 happy_x_5 of { happy_var_5 -> + case happyOut44 happy_x_6 of { happy_var_6 -> + happyIn33 + (let (s,n,t) = happy_var_6 in HsForImp happy_var_1 happy_var_4 happy_var_5 s n t + ) `HappyStk` happyRest}}}} + +happyReduce_75 = happyReduce 5# 29# happyReduction_75 +happyReduction_75 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut42 happy_x_4 of { happy_var_4 -> + case happyOut44 happy_x_5 of { happy_var_5 -> + happyIn33 + (let (s,n,t) = happy_var_5 in HsForExp happy_var_1 happy_var_4 s n t + ) `HappyStk` happyRest}}} + +happyReduce_76 = happySpecReduce_1 29# happyReduction_76 +happyReduction_76 happy_x_1 + = case happyOut37 happy_x_1 of { happy_var_1 -> + happyIn33 + (happy_var_1 + )} + +happyReduce_77 = happySpecReduce_1 30# happyReduction_77 +happyReduction_77 happy_x_1 + = case happyOut53 happy_x_1 of { happy_var_1 -> + happyIn34 + (reverse happy_var_1 + )} + +happyReduce_78 = happySpecReduce_1 30# happyReduction_78 +happyReduction_78 happy_x_1 + = case happyOut46 happy_x_1 of { happy_var_1 -> + happyIn34 + ([happy_var_1] + )} + +happyReduce_79 = happySpecReduce_0 30# happyReduction_79 +happyReduction_79 = happyIn34 + ([] + ) + +happyReduce_80 = happyMonadReduce 3# 31# happyReduction_80 +happyReduction_80 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut36 happy_x_2 of { happy_var_2 -> + ( checkRevDecls happy_var_2)} + ) (\r -> happyReturn (happyIn35 r)) + +happyReduce_81 = happySpecReduce_1 31# happyReduction_81 +happyReduction_81 happy_x_1 + = happyIn35 + ([] + ) + +happyReduce_82 = happySpecReduce_3 32# happyReduction_82 +happyReduction_82 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut36 happy_x_1 of { happy_var_1 -> + case happyOut37 happy_x_3 of { happy_var_3 -> + happyIn36 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_83 = happySpecReduce_1 32# happyReduction_83 +happyReduction_83 happy_x_1 + = case happyOut37 happy_x_1 of { happy_var_1 -> + happyIn36 + ([happy_var_1] + )} + +happyReduce_84 = happySpecReduce_1 33# happyReduction_84 +happyReduction_84 happy_x_1 + = case happyOut39 happy_x_1 of { happy_var_1 -> + happyIn37 + (happy_var_1 + )} + +happyReduce_85 = happySpecReduce_1 33# happyReduction_85 +happyReduction_85 happy_x_1 + = case happyOut27 happy_x_1 of { happy_var_1 -> + happyIn37 + (happy_var_1 + )} + +happyReduce_86 = happySpecReduce_1 33# happyReduction_86 +happyReduction_86 happy_x_1 + = case happyOut82 happy_x_1 of { happy_var_1 -> + happyIn37 + (happy_var_1 + )} + +happyReduce_87 = happySpecReduce_3 34# happyReduction_87 +happyReduction_87 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut35 happy_x_2 of { happy_var_2 -> + happyIn38 + (happy_var_2 + )} + +happyReduce_88 = happySpecReduce_3 34# happyReduction_88 +happyReduction_88 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut35 happy_x_2 of { happy_var_2 -> + happyIn38 + (happy_var_2 + )} + +happyReduce_89 = happyReduce 4# 35# happyReduction_89 +happyReduction_89 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut41 happy_x_2 of { happy_var_2 -> + case happyOut51 happy_x_4 of { happy_var_4 -> + happyIn39 + (HsTypeSig happy_var_1 (reverse happy_var_2) happy_var_4 + ) `HappyStk` happyRest}}} + +happyReduce_90 = happySpecReduce_1 36# happyReduction_90 +happyReduction_90 happy_x_1 + = case happyOut38 happy_x_1 of { happy_var_1 -> + happyIn40 + (HsBDecls happy_var_1 + )} + +happyReduce_91 = happySpecReduce_3 36# happyReduction_91 +happyReduction_91 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut132 happy_x_2 of { happy_var_2 -> + happyIn40 + (HsIPBinds happy_var_2 + )} + +happyReduce_92 = happySpecReduce_3 36# happyReduction_92 +happyReduction_92 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut132 happy_x_2 of { happy_var_2 -> + happyIn40 + (HsIPBinds happy_var_2 + )} + +happyReduce_93 = happySpecReduce_3 37# happyReduction_93 +happyReduction_93 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut41 happy_x_1 of { happy_var_1 -> + case happyOut136 happy_x_3 of { happy_var_3 -> + happyIn41 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_94 = happyMonadReduce 1# 37# happyReduction_94 +happyReduction_94 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut138 happy_x_1 of { happy_var_1 -> + ( do { n <- checkUnQual happy_var_1; + return [n] })} + ) (\r -> happyReturn (happyIn41 r)) + +happyReduce_95 = happySpecReduce_1 38# happyReduction_95 +happyReduction_95 happy_x_1 + = happyIn42 + (StdCall + ) + +happyReduce_96 = happySpecReduce_1 38# happyReduction_96 +happyReduction_96 happy_x_1 + = happyIn42 + (CCall + ) + +happyReduce_97 = happySpecReduce_1 39# happyReduction_97 +happyReduction_97 happy_x_1 + = happyIn43 + (PlaySafe False + ) + +happyReduce_98 = happySpecReduce_1 39# happyReduction_98 +happyReduction_98 happy_x_1 + = happyIn43 + (PlayRisky + ) + +happyReduce_99 = happySpecReduce_1 39# happyReduction_99 +happyReduction_99 happy_x_1 + = happyIn43 + (PlaySafe True + ) + +happyReduce_100 = happySpecReduce_0 39# happyReduction_100 +happyReduction_100 = happyIn43 + (PlaySafe False + ) + +happyReduce_101 = happyReduce 4# 40# happyReduction_101 +happyReduction_101 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOutTok happy_x_1 of { (StringTok happy_var_1) -> + case happyOut137 happy_x_2 of { happy_var_2 -> + case happyOut45 happy_x_4 of { happy_var_4 -> + happyIn44 + ((happy_var_1, happy_var_2, happy_var_4) + ) `HappyStk` happyRest}}} + +happyReduce_102 = happySpecReduce_3 40# happyReduction_102 +happyReduction_102 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut137 happy_x_1 of { happy_var_1 -> + case happyOut45 happy_x_3 of { happy_var_3 -> + happyIn44 + (("", happy_var_1, happy_var_3) + )}} + +happyReduce_103 = happySpecReduce_1 41# happyReduction_103 +happyReduction_103 happy_x_1 + = case happyOut47 happy_x_1 of { happy_var_1 -> + happyIn45 + (happy_var_1 + )} + +happyReduce_104 = happySpecReduce_3 41# happyReduction_104 +happyReduction_104 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut47 happy_x_1 of { happy_var_1 -> + case happyOut50 happy_x_2 of { happy_var_2 -> + case happyOut45 happy_x_3 of { happy_var_3 -> + happyIn45 + (HsTyInfix happy_var_1 happy_var_2 happy_var_3 + )}}} + +happyReduce_105 = happySpecReduce_3 41# happyReduction_105 +happyReduction_105 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut47 happy_x_1 of { happy_var_1 -> + case happyOut174 happy_x_2 of { happy_var_2 -> + case happyOut45 happy_x_3 of { happy_var_3 -> + happyIn45 + (HsTyInfix happy_var_1 happy_var_2 happy_var_3 + )}}} + +happyReduce_106 = happySpecReduce_3 41# happyReduction_106 +happyReduction_106 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut47 happy_x_1 of { happy_var_1 -> + case happyOut45 happy_x_3 of { happy_var_3 -> + happyIn45 + (HsTyFun happy_var_1 happy_var_3 + )}} + +happyReduce_107 = happySpecReduce_3 42# happyReduction_107 +happyReduction_107 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut139 happy_x_1 of { happy_var_1 -> + case happyOut45 happy_x_3 of { happy_var_3 -> + happyIn46 + (HsTyPred $ HsIParam happy_var_1 happy_var_3 + )}} + +happyReduce_108 = happySpecReduce_1 42# happyReduction_108 +happyReduction_108 happy_x_1 + = case happyOut45 happy_x_1 of { happy_var_1 -> + happyIn46 + (happy_var_1 + )} + +happyReduce_109 = happySpecReduce_2 43# happyReduction_109 +happyReduction_109 happy_x_2 + happy_x_1 + = case happyOut47 happy_x_1 of { happy_var_1 -> + case happyOut48 happy_x_2 of { happy_var_2 -> + happyIn47 + (HsTyApp happy_var_1 happy_var_2 + )}} + +happyReduce_110 = happySpecReduce_1 43# happyReduction_110 +happyReduction_110 happy_x_1 + = case happyOut48 happy_x_1 of { happy_var_1 -> + happyIn47 + (happy_var_1 + )} + +happyReduce_111 = happySpecReduce_1 44# happyReduction_111 +happyReduction_111 happy_x_1 + = case happyOut49 happy_x_1 of { happy_var_1 -> + happyIn48 + (HsTyCon happy_var_1 + )} + +happyReduce_112 = happySpecReduce_1 44# happyReduction_112 +happyReduction_112 happy_x_1 + = case happyOut173 happy_x_1 of { happy_var_1 -> + happyIn48 + (HsTyVar happy_var_1 + )} + +happyReduce_113 = happySpecReduce_3 44# happyReduction_113 +happyReduction_113 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut53 happy_x_2 of { happy_var_2 -> + happyIn48 + (HsTyTuple Boxed (reverse happy_var_2) + )} + +happyReduce_114 = happySpecReduce_3 44# happyReduction_114 +happyReduction_114 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut54 happy_x_2 of { happy_var_2 -> + happyIn48 + (HsTyTuple Unboxed (reverse happy_var_2) + )} + +happyReduce_115 = happySpecReduce_3 44# happyReduction_115 +happyReduction_115 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut46 happy_x_2 of { happy_var_2 -> + happyIn48 + (HsTyApp list_tycon happy_var_2 + )} + +happyReduce_116 = happySpecReduce_3 44# happyReduction_116 +happyReduction_116 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut51 happy_x_2 of { happy_var_2 -> + happyIn48 + (happy_var_2 + )} + +happyReduce_117 = happySpecReduce_1 45# happyReduction_117 +happyReduction_117 happy_x_1 + = case happyOut155 happy_x_1 of { happy_var_1 -> + happyIn49 + (happy_var_1 + )} + +happyReduce_118 = happySpecReduce_2 45# happyReduction_118 +happyReduction_118 happy_x_2 + happy_x_1 + = happyIn49 + (unit_tycon_name + ) + +happyReduce_119 = happySpecReduce_3 45# happyReduction_119 +happyReduction_119 happy_x_3 + happy_x_2 + happy_x_1 + = happyIn49 + (fun_tycon_name + ) + +happyReduce_120 = happySpecReduce_2 45# happyReduction_120 +happyReduction_120 happy_x_2 + happy_x_1 + = happyIn49 + (list_tycon_name + ) + +happyReduce_121 = happySpecReduce_3 45# happyReduction_121 +happyReduction_121 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut101 happy_x_2 of { happy_var_2 -> + happyIn49 + (tuple_tycon_name happy_var_2 + )} + +happyReduce_122 = happySpecReduce_1 46# happyReduction_122 +happyReduction_122 happy_x_1 + = case happyOut146 happy_x_1 of { happy_var_1 -> + happyIn50 + (happy_var_1 + )} + +happyReduce_123 = happyReduce 4# 47# happyReduction_123 +happyReduction_123 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut56 happy_x_2 of { happy_var_2 -> + case happyOut51 happy_x_4 of { happy_var_4 -> + happyIn51 + (mkHsTyForall (Just happy_var_2) [] happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_124 = happySpecReduce_3 47# happyReduction_124 +happyReduction_124 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut52 happy_x_1 of { happy_var_1 -> + case happyOut46 happy_x_3 of { happy_var_3 -> + happyIn51 + (mkHsTyForall Nothing happy_var_1 happy_var_3 + )}} + +happyReduce_125 = happySpecReduce_1 47# happyReduction_125 +happyReduction_125 happy_x_1 + = case happyOut46 happy_x_1 of { happy_var_1 -> + happyIn51 + (happy_var_1 + )} + +happyReduce_126 = happyMonadReduce 1# 48# happyReduction_126 +happyReduction_126 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut47 happy_x_1 of { happy_var_1 -> + ( checkContext happy_var_1)} + ) (\r -> happyReturn (happyIn52 r)) + +happyReduce_127 = happySpecReduce_3 49# happyReduction_127 +happyReduction_127 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut54 happy_x_1 of { happy_var_1 -> + case happyOut46 happy_x_3 of { happy_var_3 -> + happyIn53 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_128 = happySpecReduce_1 50# happyReduction_128 +happyReduction_128 happy_x_1 + = case happyOut46 happy_x_1 of { happy_var_1 -> + happyIn54 + ([happy_var_1] + )} + +happyReduce_129 = happySpecReduce_3 50# happyReduction_129 +happyReduction_129 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut54 happy_x_1 of { happy_var_1 -> + case happyOut46 happy_x_3 of { happy_var_3 -> + happyIn54 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_130 = happySpecReduce_2 51# happyReduction_130 +happyReduction_130 happy_x_2 + happy_x_1 + = case happyOut170 happy_x_1 of { happy_var_1 -> + case happyOut56 happy_x_2 of { happy_var_2 -> + happyIn55 + ((happy_var_1,reverse happy_var_2) + )}} + +happyReduce_131 = happySpecReduce_2 52# happyReduction_131 +happyReduction_131 happy_x_2 + happy_x_1 + = case happyOut56 happy_x_1 of { happy_var_1 -> + case happyOut173 happy_x_2 of { happy_var_2 -> + happyIn56 + (happy_var_2 : happy_var_1 + )}} + +happyReduce_132 = happySpecReduce_0 52# happyReduction_132 +happyReduction_132 = happyIn56 + ([] + ) + +happyReduce_133 = happySpecReduce_0 53# happyReduction_133 +happyReduction_133 = happyIn57 + ([] + ) + +happyReduce_134 = happySpecReduce_2 53# happyReduction_134 +happyReduction_134 happy_x_2 + happy_x_1 + = case happyOut58 happy_x_2 of { happy_var_2 -> + happyIn57 + (reverse happy_var_2 + )} + +happyReduce_135 = happySpecReduce_3 54# happyReduction_135 +happyReduction_135 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_136 = happySpecReduce_1 54# happyReduction_136 +happyReduction_136 happy_x_1 + = case happyOut59 happy_x_1 of { happy_var_1 -> + happyIn58 + ([happy_var_1] + )} + +happyReduce_137 = happySpecReduce_3 55# happyReduction_137 +happyReduction_137 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut56 happy_x_1 of { happy_var_1 -> + case happyOut56 happy_x_3 of { happy_var_3 -> + happyIn59 + (HsFunDep (reverse happy_var_1) (reverse happy_var_3) + )}} + +happyReduce_138 = happySpecReduce_3 56# happyReduction_138 +happyReduction_138 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut61 happy_x_2 of { happy_var_2 -> + happyIn60 + (happy_var_2 + )} + +happyReduce_139 = happySpecReduce_3 56# happyReduction_139 +happyReduction_139 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut61 happy_x_2 of { happy_var_2 -> + happyIn60 + (happy_var_2 + )} + +happyReduce_140 = happySpecReduce_3 57# happyReduction_140 +happyReduction_140 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut62 happy_x_2 of { happy_var_2 -> + happyIn61 + (happy_var_2 + )} + +happyReduce_141 = happySpecReduce_3 58# happyReduction_141 +happyReduction_141 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut62 happy_x_1 of { happy_var_1 -> + case happyOut63 happy_x_3 of { happy_var_3 -> + happyIn62 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_142 = happySpecReduce_1 58# happyReduction_142 +happyReduction_142 happy_x_1 + = case happyOut63 happy_x_1 of { happy_var_1 -> + happyIn62 + ([happy_var_1] + )} + +happyReduce_143 = happyMonadReduce 4# 59# happyReduction_143 +happyReduction_143 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut141 happy_x_2 of { happy_var_2 -> + case happyOut51 happy_x_4 of { happy_var_4 -> + ( do { c <- checkUnQual happy_var_2; + return $ HsGadtDecl happy_var_1 c happy_var_4 })}}} + ) (\r -> happyReturn (happyIn63 r)) + +happyReduce_144 = happySpecReduce_0 60# happyReduction_144 +happyReduction_144 = happyIn64 + ([] + ) + +happyReduce_145 = happySpecReduce_2 60# happyReduction_145 +happyReduction_145 happy_x_2 + happy_x_1 + = case happyOut65 happy_x_2 of { happy_var_2 -> + happyIn64 + (happy_var_2 + )} + +happyReduce_146 = happySpecReduce_3 61# happyReduction_146 +happyReduction_146 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut65 happy_x_1 of { happy_var_1 -> + case happyOut66 happy_x_3 of { happy_var_3 -> + happyIn65 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_147 = happySpecReduce_1 61# happyReduction_147 +happyReduction_147 happy_x_1 + = case happyOut66 happy_x_1 of { happy_var_1 -> + happyIn65 + ([happy_var_1] + )} + +happyReduce_148 = happyReduce 5# 62# happyReduction_148 +happyReduction_148 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut67 happy_x_2 of { happy_var_2 -> + case happyOut52 happy_x_3 of { happy_var_3 -> + case happyOut68 happy_x_5 of { happy_var_5 -> + happyIn66 + (HsQualConDecl happy_var_1 happy_var_2 happy_var_3 happy_var_5 + ) `HappyStk` happyRest}}}} + +happyReduce_149 = happySpecReduce_3 62# happyReduction_149 +happyReduction_149 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut67 happy_x_2 of { happy_var_2 -> + case happyOut68 happy_x_3 of { happy_var_3 -> + happyIn66 + (HsQualConDecl happy_var_1 happy_var_2 [] happy_var_3 + )}}} + +happyReduce_150 = happySpecReduce_3 63# happyReduction_150 +happyReduction_150 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut56 happy_x_2 of { happy_var_2 -> + happyIn67 + (happy_var_2 + )} + +happyReduce_151 = happySpecReduce_0 63# happyReduction_151 +happyReduction_151 = happyIn67 + ([] + ) + +happyReduce_152 = happySpecReduce_1 64# happyReduction_152 +happyReduction_152 happy_x_1 + = case happyOut69 happy_x_1 of { happy_var_1 -> + happyIn68 + (HsConDecl (fst happy_var_1) (snd happy_var_1) + )} + +happyReduce_153 = happySpecReduce_3 64# happyReduction_153 +happyReduction_153 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut72 happy_x_1 of { happy_var_1 -> + case happyOut145 happy_x_2 of { happy_var_2 -> + case happyOut72 happy_x_3 of { happy_var_3 -> + happyIn68 + (HsConDecl happy_var_2 [happy_var_1,happy_var_3] + )}}} + +happyReduce_154 = happySpecReduce_3 64# happyReduction_154 +happyReduction_154 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut140 happy_x_1 of { happy_var_1 -> + happyIn68 + (HsRecDecl happy_var_1 [] + )} + +happyReduce_155 = happyReduce 4# 64# happyReduction_155 +happyReduction_155 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut140 happy_x_1 of { happy_var_1 -> + case happyOut73 happy_x_3 of { happy_var_3 -> + happyIn68 + (HsRecDecl happy_var_1 (reverse happy_var_3) + ) `HappyStk` happyRest}} + +happyReduce_156 = happyMonadReduce 1# 65# happyReduction_156 +happyReduction_156 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut47 happy_x_1 of { happy_var_1 -> + ( do { (c,ts) <- splitTyConApp happy_var_1; + return (c,map HsUnBangedTy ts) })} + ) (\r -> happyReturn (happyIn69 r)) + +happyReduce_157 = happySpecReduce_1 65# happyReduction_157 +happyReduction_157 happy_x_1 + = case happyOut70 happy_x_1 of { happy_var_1 -> + happyIn69 + (happy_var_1 + )} + +happyReduce_158 = happyMonadReduce 3# 66# happyReduction_158 +happyReduction_158 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut47 happy_x_1 of { happy_var_1 -> + case happyOut48 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 (happyIn70 r)) + +happyReduce_159 = happySpecReduce_2 66# happyReduction_159 +happyReduction_159 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 + ((fst happy_var_1, snd happy_var_1 ++ [happy_var_2] ) + )}} + +happyReduce_160 = happySpecReduce_1 67# happyReduction_160 +happyReduction_160 happy_x_1 + = case happyOut48 happy_x_1 of { happy_var_1 -> + happyIn71 + (HsUnBangedTy happy_var_1 + )} + +happyReduce_161 = happySpecReduce_2 67# happyReduction_161 +happyReduction_161 happy_x_2 + happy_x_1 + = case happyOut48 happy_x_2 of { happy_var_2 -> + happyIn71 + (HsBangedTy happy_var_2 + )} + +happyReduce_162 = happySpecReduce_1 68# happyReduction_162 +happyReduction_162 happy_x_1 + = case happyOut47 happy_x_1 of { happy_var_1 -> + happyIn72 + (HsUnBangedTy happy_var_1 + )} + +happyReduce_163 = happySpecReduce_2 68# happyReduction_163 +happyReduction_163 happy_x_2 + happy_x_1 + = case happyOut48 happy_x_2 of { happy_var_2 -> + happyIn72 + (HsBangedTy happy_var_2 + )} + +happyReduce_164 = happySpecReduce_3 69# happyReduction_164 +happyReduction_164 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut73 happy_x_1 of { happy_var_1 -> + case happyOut74 happy_x_3 of { happy_var_3 -> + happyIn73 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_165 = happySpecReduce_1 69# happyReduction_165 +happyReduction_165 happy_x_1 + = case happyOut74 happy_x_1 of { happy_var_1 -> + happyIn73 + ([happy_var_1] + )} + +happyReduce_166 = happySpecReduce_3 70# happyReduction_166 +happyReduction_166 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut41 happy_x_1 of { happy_var_1 -> + case happyOut75 happy_x_3 of { happy_var_3 -> + happyIn74 + ((reverse happy_var_1, happy_var_3) + )}} + +happyReduce_167 = happySpecReduce_1 71# happyReduction_167 +happyReduction_167 happy_x_1 + = case happyOut51 happy_x_1 of { happy_var_1 -> + happyIn75 + (HsUnBangedTy happy_var_1 + )} + +happyReduce_168 = happySpecReduce_2 71# happyReduction_168 +happyReduction_168 happy_x_2 + happy_x_1 + = case happyOut48 happy_x_2 of { happy_var_2 -> + happyIn75 + (HsBangedTy happy_var_2 + )} + +happyReduce_169 = happySpecReduce_0 72# happyReduction_169 +happyReduction_169 = happyIn76 + ([] + ) + +happyReduce_170 = happySpecReduce_2 72# happyReduction_170 +happyReduction_170 happy_x_2 + happy_x_1 + = case happyOut172 happy_x_2 of { happy_var_2 -> + happyIn76 + ([happy_var_2] + )} + +happyReduce_171 = happySpecReduce_3 72# happyReduction_171 +happyReduction_171 happy_x_3 + happy_x_2 + happy_x_1 + = happyIn76 + ([] + ) + +happyReduce_172 = happyReduce 4# 72# happyReduction_172 +happyReduction_172 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut77 happy_x_3 of { happy_var_3 -> + happyIn76 + (reverse happy_var_3 + ) `HappyStk` happyRest} + +happyReduce_173 = happySpecReduce_3 73# happyReduction_173 +happyReduction_173 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut77 happy_x_1 of { happy_var_1 -> + case happyOut172 happy_x_3 of { happy_var_3 -> + happyIn77 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_174 = happySpecReduce_1 73# happyReduction_174 +happyReduction_174 happy_x_1 + = case happyOut172 happy_x_1 of { happy_var_1 -> + happyIn77 + ([happy_var_1] + )} + +happyReduce_175 = happyMonadReduce 2# 74# happyReduction_175 +happyReduction_175 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut38 happy_x_2 of { happy_var_2 -> + ( checkClassBody happy_var_2)} + ) (\r -> happyReturn (happyIn78 r)) + +happyReduce_176 = happySpecReduce_0 74# happyReduction_176 +happyReduction_176 = happyIn78 + ([] + ) + +happyReduce_177 = happyMonadReduce 4# 75# happyReduction_177 +happyReduction_177 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut80 happy_x_3 of { happy_var_3 -> + ( checkClassBody happy_var_3)} + ) (\r -> happyReturn (happyIn79 r)) + +happyReduce_178 = happyMonadReduce 4# 75# happyReduction_178 +happyReduction_178 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut80 happy_x_3 of { happy_var_3 -> + ( checkClassBody happy_var_3)} + ) (\r -> happyReturn (happyIn79 r)) + +happyReduce_179 = happySpecReduce_0 75# happyReduction_179 +happyReduction_179 = happyIn79 + ([] + ) + +happyReduce_180 = happyMonadReduce 3# 76# happyReduction_180 +happyReduction_180 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut81 happy_x_2 of { happy_var_2 -> + ( checkRevDecls happy_var_2)} + ) (\r -> happyReturn (happyIn80 r)) + +happyReduce_181 = happySpecReduce_1 76# happyReduction_181 +happyReduction_181 happy_x_1 + = happyIn80 + ([] + ) + +happyReduce_182 = happySpecReduce_3 77# happyReduction_182 +happyReduction_182 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut81 happy_x_1 of { happy_var_1 -> + case happyOut82 happy_x_3 of { happy_var_3 -> + happyIn81 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_183 = happySpecReduce_1 77# happyReduction_183 +happyReduction_183 happy_x_1 + = case happyOut82 happy_x_1 of { happy_var_1 -> + happyIn81 + ([happy_var_1] + )} + +happyReduce_184 = happyMonadReduce 4# 78# happyReduction_184 +happyReduction_184 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut90 happy_x_2 of { happy_var_2 -> + case happyOut84 happy_x_3 of { happy_var_3 -> + case happyOut83 happy_x_4 of { happy_var_4 -> + ( checkValDef happy_var_1 happy_var_2 happy_var_3 happy_var_4)}}}} + ) (\r -> happyReturn (happyIn82 r)) + +happyReduce_185 = happySpecReduce_2 79# happyReduction_185 +happyReduction_185 happy_x_2 + happy_x_1 + = case happyOut40 happy_x_2 of { happy_var_2 -> + happyIn83 + (happy_var_2 + )} + +happyReduce_186 = happySpecReduce_0 79# happyReduction_186 +happyReduction_186 = happyIn83 + (HsBDecls [] + ) + +happyReduce_187 = happyMonadReduce 2# 80# happyReduction_187 +happyReduction_187 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut87 happy_x_2 of { happy_var_2 -> + ( do { e <- checkExpr happy_var_2; + return (HsUnGuardedRhs e) })} + ) (\r -> happyReturn (happyIn84 r)) + +happyReduce_188 = happySpecReduce_1 80# happyReduction_188 +happyReduction_188 happy_x_1 + = case happyOut85 happy_x_1 of { happy_var_1 -> + happyIn84 + (HsGuardedRhss (reverse happy_var_1) + )} + +happyReduce_189 = happySpecReduce_2 81# happyReduction_189 +happyReduction_189 happy_x_2 + happy_x_1 + = case happyOut85 happy_x_1 of { happy_var_1 -> + case happyOut86 happy_x_2 of { happy_var_2 -> + happyIn85 + (happy_var_2 : happy_var_1 + )}} + +happyReduce_190 = happySpecReduce_1 81# happyReduction_190 +happyReduction_190 happy_x_1 + = case happyOut86 happy_x_1 of { happy_var_1 -> + happyIn85 + ([happy_var_1] + )} + +happyReduce_191 = happyMonadReduce 5# 82# happyReduction_191 +happyReduction_191 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut117 happy_x_3 of { happy_var_3 -> + case happyOut87 happy_x_5 of { happy_var_5 -> + ( do { e <- checkExpr happy_var_5; + return (HsGuardedRhs happy_var_1 (reverse happy_var_3) e) })}}} + ) (\r -> happyReturn (happyIn86 r)) + +happyReduce_192 = happyReduce 4# 83# happyReduction_192 +happyReduction_192 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut90 happy_x_1 of { happy_var_1 -> + case happyOut165 happy_x_3 of { happy_var_3 -> + case happyOut51 happy_x_4 of { happy_var_4 -> + happyIn87 + (HsExpTypeSig happy_var_3 happy_var_1 happy_var_4 + ) `HappyStk` happyRest}}} + +happyReduce_193 = happySpecReduce_3 83# happyReduction_193 +happyReduction_193 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut90 happy_x_1 of { happy_var_1 -> + case happyOut131 happy_x_3 of { happy_var_3 -> + happyIn87 + (HsWith happy_var_1 happy_var_3 + )}} + +happyReduce_194 = happySpecReduce_1 83# happyReduction_194 +happyReduction_194 happy_x_1 + = case happyOut88 happy_x_1 of { happy_var_1 -> + happyIn87 + (happy_var_1 + )} + +happyReduce_195 = happySpecReduce_1 84# happyReduction_195 +happyReduction_195 happy_x_1 + = case happyOut89 happy_x_1 of { happy_var_1 -> + happyIn88 + (happy_var_1 + )} + +happyReduce_196 = happySpecReduce_1 84# happyReduction_196 +happyReduction_196 happy_x_1 + = case happyOut90 happy_x_1 of { happy_var_1 -> + happyIn88 + (happy_var_1 + )} + +happyReduce_197 = happySpecReduce_3 85# happyReduction_197 +happyReduction_197 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut90 happy_x_1 of { happy_var_1 -> + case happyOut148 happy_x_2 of { happy_var_2 -> + case happyOut91 happy_x_3 of { happy_var_3 -> + happyIn89 + (HsInfixApp happy_var_1 happy_var_2 happy_var_3 + )}}} + +happyReduce_198 = happySpecReduce_1 85# happyReduction_198 +happyReduction_198 happy_x_1 + = case happyOut91 happy_x_1 of { happy_var_1 -> + happyIn89 + (happy_var_1 + )} + +happyReduce_199 = happySpecReduce_3 86# happyReduction_199 +happyReduction_199 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut90 happy_x_1 of { happy_var_1 -> + case happyOut148 happy_x_2 of { happy_var_2 -> + case happyOut92 happy_x_3 of { happy_var_3 -> + happyIn90 + (HsInfixApp happy_var_1 happy_var_2 happy_var_3 + )}}} + +happyReduce_200 = happySpecReduce_1 86# happyReduction_200 +happyReduction_200 happy_x_1 + = case happyOut114 happy_x_1 of { happy_var_1 -> + happyIn90 + (happy_var_1 + )} + +happyReduce_201 = happySpecReduce_1 86# happyReduction_201 +happyReduction_201 happy_x_1 + = case happyOut92 happy_x_1 of { happy_var_1 -> + happyIn90 + (happy_var_1 + )} + +happyReduce_202 = happyReduce 5# 87# happyReduction_202 +happyReduction_202 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut165 happy_x_2 of { happy_var_2 -> + case happyOut94 happy_x_3 of { happy_var_3 -> + case happyOut87 happy_x_5 of { happy_var_5 -> + happyIn91 + (HsLambda happy_var_2 (reverse happy_var_3) happy_var_5 + ) `HappyStk` happyRest}}} + +happyReduce_203 = happyReduce 4# 87# happyReduction_203 +happyReduction_203 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut40 happy_x_2 of { happy_var_2 -> + case happyOut87 happy_x_4 of { happy_var_4 -> + happyIn91 + (HsLet happy_var_2 happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_204 = happyReduce 4# 87# happyReduction_204 +happyReduction_204 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut131 happy_x_2 of { happy_var_2 -> + case happyOut87 happy_x_4 of { happy_var_4 -> + happyIn91 + (HsDLet happy_var_2 happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_205 = happyReduce 6# 87# happyReduction_205 +happyReduction_205 (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 happyOut87 happy_x_2 of { happy_var_2 -> + case happyOut87 happy_x_4 of { happy_var_4 -> + case happyOut87 happy_x_6 of { happy_var_6 -> + happyIn91 + (HsIf happy_var_2 happy_var_4 happy_var_6 + ) `HappyStk` happyRest}}} + +happyReduce_206 = happyReduce 4# 88# happyReduction_206 +happyReduction_206 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut87 happy_x_2 of { happy_var_2 -> + case happyOut119 happy_x_4 of { happy_var_4 -> + happyIn92 + (HsCase happy_var_2 happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_207 = happySpecReduce_2 88# happyReduction_207 +happyReduction_207 happy_x_2 + happy_x_1 + = case happyOut93 happy_x_2 of { happy_var_2 -> + happyIn92 + (HsNegApp happy_var_2 + )} + +happyReduce_208 = happySpecReduce_2 88# happyReduction_208 +happyReduction_208 happy_x_2 + happy_x_1 + = case happyOut127 happy_x_2 of { happy_var_2 -> + happyIn92 + (HsDo happy_var_2 + )} + +happyReduce_209 = happySpecReduce_2 88# happyReduction_209 +happyReduction_209 happy_x_2 + happy_x_1 + = case happyOut127 happy_x_2 of { happy_var_2 -> + happyIn92 + (HsMDo happy_var_2 + )} + +happyReduce_210 = happySpecReduce_1 88# happyReduction_210 +happyReduction_210 happy_x_1 + = case happyOut99 happy_x_1 of { happy_var_1 -> + happyIn92 + (HsReifyExp happy_var_1 + )} + +happyReduce_211 = happySpecReduce_1 88# happyReduction_211 +happyReduction_211 happy_x_1 + = case happyOut93 happy_x_1 of { happy_var_1 -> + happyIn92 + (happy_var_1 + )} + +happyReduce_212 = happySpecReduce_2 89# happyReduction_212 +happyReduction_212 happy_x_2 + happy_x_1 + = case happyOut93 happy_x_1 of { happy_var_1 -> + case happyOut96 happy_x_2 of { happy_var_2 -> + happyIn93 + (HsApp happy_var_1 happy_var_2 + )}} + +happyReduce_213 = happySpecReduce_1 89# happyReduction_213 +happyReduction_213 happy_x_1 + = case happyOut96 happy_x_1 of { happy_var_1 -> + happyIn93 + (happy_var_1 + )} + +happyReduce_214 = happySpecReduce_2 90# happyReduction_214 +happyReduction_214 happy_x_2 + happy_x_1 + = case happyOut94 happy_x_1 of { happy_var_1 -> + case happyOut95 happy_x_2 of { happy_var_2 -> + happyIn94 + (happy_var_2 : happy_var_1 + )}} + +happyReduce_215 = happySpecReduce_1 90# happyReduction_215 +happyReduction_215 happy_x_1 + = case happyOut95 happy_x_1 of { happy_var_1 -> + happyIn94 + ([happy_var_1] + )} + +happyReduce_216 = happyMonadReduce 1# 91# happyReduction_216 +happyReduction_216 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut96 happy_x_1 of { happy_var_1 -> + ( checkPattern happy_var_1)} + ) (\r -> happyReturn (happyIn95 r)) + +happyReduce_217 = happyMonadReduce 3# 92# happyReduction_217 +happyReduction_217 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut138 happy_x_1 of { happy_var_1 -> + case happyOut96 happy_x_3 of { happy_var_3 -> + ( do { n <- checkUnQual happy_var_1; + return (HsAsPat n happy_var_3) })}} + ) (\r -> happyReturn (happyIn96 r)) + +happyReduce_218 = happyMonadReduce 3# 92# happyReduction_218 +happyReduction_218 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut138 happy_x_1 of { happy_var_1 -> + case happyOut96 happy_x_3 of { happy_var_3 -> + ( do { n <- checkUnQual happy_var_1; + return (HsCAsRP n happy_var_3) })}} + ) (\r -> happyReturn (happyIn96 r)) + +happyReduce_219 = happySpecReduce_2 92# happyReduction_219 +happyReduction_219 happy_x_2 + happy_x_1 + = case happyOut96 happy_x_2 of { happy_var_2 -> + happyIn96 + (HsIrrPat happy_var_2 + )} + +happyReduce_220 = happySpecReduce_1 92# happyReduction_220 +happyReduction_220 happy_x_1 + = case happyOut97 happy_x_1 of { happy_var_1 -> + happyIn96 + (happy_var_1 + )} + +happyReduce_221 = happyMonadReduce 3# 93# happyReduction_221 +happyReduction_221 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut97 happy_x_1 of { happy_var_1 -> + ( mkRecConstrOrUpdate happy_var_1 [])} + ) (\r -> happyReturn (happyIn97 r)) + +happyReduce_222 = happyMonadReduce 4# 93# happyReduction_222 +happyReduction_222 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut97 happy_x_1 of { happy_var_1 -> + case happyOut129 happy_x_3 of { happy_var_3 -> + ( mkRecConstrOrUpdate happy_var_1 (reverse happy_var_3))}} + ) (\r -> happyReturn (happyIn97 r)) + +happyReduce_223 = happySpecReduce_2 93# happyReduction_223 +happyReduction_223 happy_x_2 + happy_x_1 + = case happyOut97 happy_x_1 of { happy_var_1 -> + happyIn97 + (HsStarRP happy_var_1 + )} + +happyReduce_224 = happySpecReduce_2 93# happyReduction_224 +happyReduction_224 happy_x_2 + happy_x_1 + = case happyOut97 happy_x_1 of { happy_var_1 -> + happyIn97 + (HsStarGRP happy_var_1 + )} + +happyReduce_225 = happySpecReduce_2 93# happyReduction_225 +happyReduction_225 happy_x_2 + happy_x_1 + = case happyOut97 happy_x_1 of { happy_var_1 -> + happyIn97 + (HsPlusRP happy_var_1 + )} + +happyReduce_226 = happySpecReduce_2 93# happyReduction_226 +happyReduction_226 happy_x_2 + happy_x_1 + = case happyOut97 happy_x_1 of { happy_var_1 -> + happyIn97 + (HsPlusGRP happy_var_1 + )} + +happyReduce_227 = happySpecReduce_2 93# happyReduction_227 +happyReduction_227 happy_x_2 + happy_x_1 + = case happyOut97 happy_x_1 of { happy_var_1 -> + happyIn97 + (HsOptRP happy_var_1 + )} + +happyReduce_228 = happySpecReduce_2 93# happyReduction_228 +happyReduction_228 happy_x_2 + happy_x_1 + = case happyOut97 happy_x_1 of { happy_var_1 -> + happyIn97 + (HsOptGRP happy_var_1 + )} + +happyReduce_229 = happySpecReduce_1 93# happyReduction_229 +happyReduction_229 happy_x_1 + = case happyOut98 happy_x_1 of { happy_var_1 -> + happyIn97 + (happy_var_1 + )} + +happyReduce_230 = happySpecReduce_1 94# happyReduction_230 +happyReduction_230 happy_x_1 + = case happyOut139 happy_x_1 of { happy_var_1 -> + happyIn98 + (HsIPVar happy_var_1 + )} + +happyReduce_231 = happySpecReduce_1 94# happyReduction_231 +happyReduction_231 happy_x_1 + = case happyOut138 happy_x_1 of { happy_var_1 -> + happyIn98 + (HsVar happy_var_1 + )} + +happyReduce_232 = happySpecReduce_1 94# happyReduction_232 +happyReduction_232 happy_x_1 + = case happyOut135 happy_x_1 of { happy_var_1 -> + happyIn98 + (happy_var_1 + )} + +happyReduce_233 = happySpecReduce_1 94# happyReduction_233 +happyReduction_233 happy_x_1 + = case happyOut164 happy_x_1 of { happy_var_1 -> + happyIn98 + (HsLit happy_var_1 + )} + +happyReduce_234 = happySpecReduce_3 94# happyReduction_234 +happyReduction_234 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut87 happy_x_2 of { happy_var_2 -> + happyIn98 + (HsParen happy_var_2 + )} + +happyReduce_235 = happySpecReduce_3 94# happyReduction_235 +happyReduction_235 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut102 happy_x_2 of { happy_var_2 -> + happyIn98 + (HsTuple (reverse happy_var_2) + )} + +happyReduce_236 = happySpecReduce_3 94# happyReduction_236 +happyReduction_236 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut115 happy_x_2 of { happy_var_2 -> + happyIn98 + (happy_var_2 + )} + +happyReduce_237 = happyReduce 4# 94# happyReduction_237 +happyReduction_237 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut90 happy_x_2 of { happy_var_2 -> + case happyOut148 happy_x_3 of { happy_var_3 -> + happyIn98 + (HsLeftSection happy_var_2 happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_238 = happyReduce 4# 94# happyReduction_238 +happyReduction_238 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut149 happy_x_2 of { happy_var_2 -> + case happyOut88 happy_x_3 of { happy_var_3 -> + happyIn98 + (HsRightSection happy_var_2 happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_239 = happySpecReduce_1 94# happyReduction_239 +happyReduction_239 happy_x_1 + = happyIn98 + (HsWildCard + ) + +happyReduce_240 = happySpecReduce_3 94# happyReduction_240 +happyReduction_240 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut105 happy_x_2 of { happy_var_2 -> + happyIn98 + (happy_var_2 + )} + +happyReduce_241 = happySpecReduce_3 94# happyReduction_241 +happyReduction_241 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut103 happy_x_2 of { happy_var_2 -> + happyIn98 + (HsSeqRP $ reverse happy_var_2 + )} + +happyReduce_242 = happyReduce 4# 94# happyReduction_242 +happyReduction_242 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut103 happy_x_3 of { happy_var_3 -> + happyIn98 + (HsRPats happy_var_1 $ reverse happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_243 = happySpecReduce_1 94# happyReduction_243 +happyReduction_243 happy_x_1 + = case happyOut106 happy_x_1 of { happy_var_1 -> + happyIn98 + (happy_var_1 + )} + +happyReduce_244 = happySpecReduce_1 94# happyReduction_244 +happyReduction_244 happy_x_1 + = case happyOutTok happy_x_1 of { (THIdEscape happy_var_1) -> + happyIn98 + (HsSpliceExp $ HsIdSplice happy_var_1 + )} + +happyReduce_245 = happyMonadReduce 3# 94# happyReduction_245 +happyReduction_245 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut87 happy_x_2 of { happy_var_2 -> + ( do { e <- checkExpr happy_var_2; + return $ HsSpliceExp $ HsParenSplice e })} + ) (\r -> happyReturn (happyIn98 r)) + +happyReduce_246 = happyMonadReduce 3# 94# happyReduction_246 +happyReduction_246 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut87 happy_x_2 of { happy_var_2 -> + ( do { e <- checkExpr happy_var_2; + return $ HsBracketExp $ HsExpBracket e })} + ) (\r -> happyReturn (happyIn98 r)) + +happyReduce_247 = happyMonadReduce 3# 94# happyReduction_247 +happyReduction_247 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut88 happy_x_2 of { happy_var_2 -> + ( do { p <- checkPattern happy_var_2; + return $ HsBracketExp $ HsPatBracket p })} + ) (\r -> happyReturn (happyIn98 r)) + +happyReduce_248 = happySpecReduce_3 94# happyReduction_248 +happyReduction_248 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut51 happy_x_2 of { happy_var_2 -> + happyIn98 + (HsBracketExp $ HsTypeBracket happy_var_2 + )} + +happyReduce_249 = happyReduce 5# 94# happyReduction_249 +happyReduction_249 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut31 happy_x_3 of { happy_var_3 -> + happyIn98 + (HsBracketExp $ HsDeclBracket happy_var_3 + ) `HappyStk` happyRest} + +happyReduce_250 = happySpecReduce_2 95# happyReduction_250 +happyReduction_250 happy_x_2 + happy_x_1 + = case happyOut49 happy_x_2 of { happy_var_2 -> + happyIn99 + (HsReifyDecl happy_var_2 + )} + +happyReduce_251 = happySpecReduce_2 95# happyReduction_251 +happyReduction_251 happy_x_2 + happy_x_1 + = case happyOut138 happy_x_2 of { happy_var_2 -> + happyIn99 + (HsReifyDecl happy_var_2 + )} + +happyReduce_252 = happySpecReduce_2 95# happyReduction_252 +happyReduction_252 happy_x_2 + happy_x_1 + = case happyOut100 happy_x_2 of { happy_var_2 -> + happyIn99 + (HsReifyType happy_var_2 + )} + +happyReduce_253 = happySpecReduce_2 95# happyReduction_253 +happyReduction_253 happy_x_2 + happy_x_1 + = case happyOut100 happy_x_2 of { happy_var_2 -> + happyIn99 + (HsReifyFixity happy_var_2 + )} + +happyReduce_254 = happySpecReduce_1 96# happyReduction_254 +happyReduction_254 happy_x_1 + = case happyOut138 happy_x_1 of { happy_var_1 -> + happyIn100 + (happy_var_1 + )} + +happyReduce_255 = happyMonadReduce 1# 96# happyReduction_255 +happyReduction_255 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut135 happy_x_1 of { happy_var_1 -> + ( getGConName happy_var_1)} + ) (\r -> happyReturn (happyIn100 r)) + +happyReduce_256 = happySpecReduce_2 97# happyReduction_256 +happyReduction_256 happy_x_2 + happy_x_1 + = case happyOut101 happy_x_1 of { happy_var_1 -> + happyIn101 + (happy_var_1 + 1 + )} + +happyReduce_257 = happySpecReduce_1 97# happyReduction_257 +happyReduction_257 happy_x_1 + = happyIn101 + (1 + ) + +happyReduce_258 = happySpecReduce_3 98# happyReduction_258 +happyReduction_258 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut102 happy_x_1 of { happy_var_1 -> + case happyOut87 happy_x_3 of { happy_var_3 -> + happyIn102 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_259 = happySpecReduce_3 98# happyReduction_259 +happyReduction_259 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut87 happy_x_1 of { happy_var_1 -> + case happyOut87 happy_x_3 of { happy_var_3 -> + happyIn102 + ([happy_var_3,happy_var_1] + )}} + +happyReduce_260 = happySpecReduce_3 99# happyReduction_260 +happyReduction_260 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut103 happy_x_1 of { happy_var_1 -> + case happyOut104 happy_x_3 of { happy_var_3 -> + happyIn103 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_261 = happySpecReduce_1 99# happyReduction_261 +happyReduction_261 happy_x_1 + = case happyOut104 happy_x_1 of { happy_var_1 -> + happyIn103 + ([happy_var_1] + )} + +happyReduce_262 = happySpecReduce_1 100# happyReduction_262 +happyReduction_262 happy_x_1 + = case happyOut105 happy_x_1 of { happy_var_1 -> + happyIn104 + (happy_var_1 + )} + +happyReduce_263 = happySpecReduce_1 100# happyReduction_263 +happyReduction_263 happy_x_1 + = case happyOut87 happy_x_1 of { happy_var_1 -> + happyIn104 + (happy_var_1 + )} + +happyReduce_264 = happySpecReduce_3 101# happyReduction_264 +happyReduction_264 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut87 happy_x_1 of { happy_var_1 -> + case happyOut105 happy_x_3 of { happy_var_3 -> + happyIn105 + (HsEitherRP happy_var_1 happy_var_3 + )}} + +happyReduce_265 = happySpecReduce_3 101# happyReduction_265 +happyReduction_265 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut87 happy_x_1 of { happy_var_1 -> + case happyOut87 happy_x_3 of { happy_var_3 -> + happyIn105 + (HsEitherRP happy_var_1 happy_var_3 + )}} + +happyReduce_266 = happyMonadReduce 10# 102# happyReduction_266 +happyReduction_266 (happy_x_10 `HappyStk` + 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) tk + = happyThen (case happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut109 happy_x_3 of { happy_var_3 -> + case happyOut111 happy_x_4 of { happy_var_4 -> + case happyOut113 happy_x_5 of { happy_var_5 -> + case happyOut107 happy_x_7 of { happy_var_7 -> + case happyOut109 happy_x_9 of { happy_var_9 -> + ( do { n <- checkEqNames happy_var_3 happy_var_9; + let { cn = reverse happy_var_7; + as = reverse happy_var_4; }; + return $ HsXTag happy_var_1 n as happy_var_5 cn })}}}}}} + ) (\r -> happyReturn (happyIn106 r)) + +happyReduce_267 = happyReduce 6# 102# happyReduction_267 +happyReduction_267 (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 happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut109 happy_x_3 of { happy_var_3 -> + case happyOut111 happy_x_4 of { happy_var_4 -> + case happyOut113 happy_x_5 of { happy_var_5 -> + happyIn106 + (HsXETag happy_var_1 happy_var_3 (reverse happy_var_4) happy_var_5 + ) `HappyStk` happyRest}}}} + +happyReduce_268 = happySpecReduce_3 102# happyReduction_268 +happyReduction_268 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut87 happy_x_2 of { happy_var_2 -> + happyIn106 + (HsXExpTag happy_var_2 + )} + +happyReduce_269 = happySpecReduce_2 103# happyReduction_269 +happyReduction_269 happy_x_2 + happy_x_1 + = case happyOut107 happy_x_1 of { happy_var_1 -> + case happyOut108 happy_x_2 of { happy_var_2 -> + happyIn107 + (happy_var_2 : happy_var_1 + )}} + +happyReduce_270 = happySpecReduce_0 103# happyReduction_270 +happyReduction_270 = happyIn107 + ([] + ) + +happyReduce_271 = happySpecReduce_1 104# happyReduction_271 +happyReduction_271 happy_x_1 + = case happyOutTok happy_x_1 of { (XPcdata happy_var_1) -> + happyIn108 + (HsXPcdata happy_var_1 + )} + +happyReduce_272 = happyReduce 4# 104# happyReduction_272 +happyReduction_272 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut103 happy_x_3 of { happy_var_3 -> + happyIn108 + (HsRPats happy_var_1 $ reverse happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_273 = happySpecReduce_1 104# happyReduction_273 +happyReduction_273 happy_x_1 + = case happyOut106 happy_x_1 of { happy_var_1 -> + happyIn108 + (happy_var_1 + )} + +happyReduce_274 = happySpecReduce_3 105# happyReduction_274 +happyReduction_274 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut110 happy_x_1 of { happy_var_1 -> + case happyOut110 happy_x_3 of { happy_var_3 -> + happyIn109 + (HsXDomName happy_var_1 happy_var_3 + )}} + +happyReduce_275 = happySpecReduce_1 105# happyReduction_275 +happyReduction_275 happy_x_1 + = case happyOut110 happy_x_1 of { happy_var_1 -> + happyIn109 + (HsXName happy_var_1 + )} + +happyReduce_276 = happySpecReduce_1 106# happyReduction_276 +happyReduction_276 happy_x_1 + = case happyOutTok happy_x_1 of { (VarId happy_var_1) -> + happyIn110 + (happy_var_1 + )} + +happyReduce_277 = happySpecReduce_1 106# happyReduction_277 +happyReduction_277 happy_x_1 + = case happyOutTok happy_x_1 of { (ConId happy_var_1) -> + happyIn110 + (happy_var_1 + )} + +happyReduce_278 = happySpecReduce_1 106# happyReduction_278 +happyReduction_278 happy_x_1 + = case happyOutTok happy_x_1 of { (DVarId happy_var_1) -> + happyIn110 + (mkDVar happy_var_1 + )} + +happyReduce_279 = happySpecReduce_1 106# happyReduction_279 +happyReduction_279 happy_x_1 + = happyIn110 + ("type" + ) + +happyReduce_280 = happySpecReduce_1 106# happyReduction_280 +happyReduction_280 happy_x_1 + = happyIn110 + ("class" + ) + +happyReduce_281 = happySpecReduce_2 107# happyReduction_281 +happyReduction_281 happy_x_2 + happy_x_1 + = case happyOut111 happy_x_1 of { happy_var_1 -> + case happyOut112 happy_x_2 of { happy_var_2 -> + happyIn111 + (happy_var_2 : happy_var_1 + )}} + +happyReduce_282 = happySpecReduce_0 107# happyReduction_282 +happyReduction_282 = happyIn111 + ([] + ) + +happyReduce_283 = happySpecReduce_3 108# happyReduction_283 +happyReduction_283 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut109 happy_x_1 of { happy_var_1 -> + case happyOut96 happy_x_3 of { happy_var_3 -> + happyIn112 + (HsXAttr happy_var_1 happy_var_3 + )}} + +happyReduce_284 = happySpecReduce_1 109# happyReduction_284 +happyReduction_284 happy_x_1 + = case happyOut96 happy_x_1 of { happy_var_1 -> + happyIn113 + (Just happy_var_1 + )} + +happyReduce_285 = happySpecReduce_0 109# happyReduction_285 +happyReduction_285 = happyIn113 + (Nothing + ) + +happyReduce_286 = happySpecReduce_1 110# happyReduction_286 +happyReduction_286 happy_x_1 + = case happyOutTok happy_x_1 of { (DVarId happy_var_1) -> + happyIn114 + (mkDVarExpr happy_var_1 + )} + +happyReduce_287 = happySpecReduce_1 111# happyReduction_287 +happyReduction_287 happy_x_1 + = case happyOut87 happy_x_1 of { happy_var_1 -> + happyIn115 + (HsList [happy_var_1] + )} + +happyReduce_288 = happySpecReduce_1 111# happyReduction_288 +happyReduction_288 happy_x_1 + = case happyOut116 happy_x_1 of { happy_var_1 -> + happyIn115 + (HsList (reverse happy_var_1) + )} + +happyReduce_289 = happySpecReduce_2 111# happyReduction_289 +happyReduction_289 happy_x_2 + happy_x_1 + = case happyOut87 happy_x_1 of { happy_var_1 -> + happyIn115 + (HsEnumFrom happy_var_1 + )} + +happyReduce_290 = happyReduce 4# 111# happyReduction_290 +happyReduction_290 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut87 happy_x_1 of { happy_var_1 -> + case happyOut87 happy_x_3 of { happy_var_3 -> + happyIn115 + (HsEnumFromThen happy_var_1 happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_291 = happySpecReduce_3 111# happyReduction_291 +happyReduction_291 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut87 happy_x_1 of { happy_var_1 -> + case happyOut87 happy_x_3 of { happy_var_3 -> + happyIn115 + (HsEnumFromTo happy_var_1 happy_var_3 + )}} + +happyReduce_292 = happyReduce 5# 111# happyReduction_292 +happyReduction_292 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut87 happy_x_1 of { happy_var_1 -> + case happyOut87 happy_x_3 of { happy_var_3 -> + case happyOut87 happy_x_5 of { happy_var_5 -> + happyIn115 + (HsEnumFromThenTo happy_var_1 happy_var_3 happy_var_5 + ) `HappyStk` happyRest}}} + +happyReduce_293 = happySpecReduce_3 111# happyReduction_293 +happyReduction_293 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut87 happy_x_1 of { happy_var_1 -> + case happyOut117 happy_x_3 of { happy_var_3 -> + happyIn115 + (HsListComp happy_var_1 (reverse happy_var_3) + )}} + +happyReduce_294 = happySpecReduce_3 112# happyReduction_294 +happyReduction_294 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut116 happy_x_1 of { happy_var_1 -> + case happyOut87 happy_x_3 of { happy_var_3 -> + happyIn116 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_295 = happySpecReduce_3 112# happyReduction_295 +happyReduction_295 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut87 happy_x_1 of { happy_var_1 -> + case happyOut87 happy_x_3 of { happy_var_3 -> + happyIn116 + ([happy_var_3,happy_var_1] + )}} + +happyReduce_296 = happySpecReduce_3 113# happyReduction_296 +happyReduction_296 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut117 happy_x_1 of { happy_var_1 -> + case happyOut118 happy_x_3 of { happy_var_3 -> + happyIn117 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_297 = happySpecReduce_1 113# happyReduction_297 +happyReduction_297 happy_x_1 + = case happyOut118 happy_x_1 of { happy_var_1 -> + happyIn117 + ([happy_var_1] + )} + +happyReduce_298 = happyReduce 4# 114# happyReduction_298 +happyReduction_298 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut126 happy_x_1 of { happy_var_1 -> + case happyOut165 happy_x_2 of { happy_var_2 -> + case happyOut87 happy_x_4 of { happy_var_4 -> + happyIn118 + (HsGenerator happy_var_2 happy_var_1 happy_var_4 + ) `HappyStk` happyRest}}} + +happyReduce_299 = happySpecReduce_1 114# happyReduction_299 +happyReduction_299 happy_x_1 + = case happyOut87 happy_x_1 of { happy_var_1 -> + happyIn118 + (HsQualifier happy_var_1 + )} + +happyReduce_300 = happySpecReduce_2 114# happyReduction_300 +happyReduction_300 happy_x_2 + happy_x_1 + = case happyOut40 happy_x_2 of { happy_var_2 -> + happyIn118 + (HsLetStmt happy_var_2 + )} + +happyReduce_301 = happySpecReduce_3 115# happyReduction_301 +happyReduction_301 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut120 happy_x_2 of { happy_var_2 -> + happyIn119 + (happy_var_2 + )} + +happyReduce_302 = happySpecReduce_3 115# happyReduction_302 +happyReduction_302 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut120 happy_x_2 of { happy_var_2 -> + happyIn119 + (happy_var_2 + )} + +happyReduce_303 = happySpecReduce_3 116# happyReduction_303 +happyReduction_303 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut121 happy_x_2 of { happy_var_2 -> + happyIn120 + (reverse happy_var_2 + )} + +happyReduce_304 = happySpecReduce_3 117# happyReduction_304 +happyReduction_304 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut121 happy_x_1 of { happy_var_1 -> + case happyOut122 happy_x_3 of { happy_var_3 -> + happyIn121 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_305 = happySpecReduce_1 117# happyReduction_305 +happyReduction_305 happy_x_1 + = case happyOut122 happy_x_1 of { happy_var_1 -> + happyIn121 + ([happy_var_1] + )} + +happyReduce_306 = happyReduce 4# 118# happyReduction_306 +happyReduction_306 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut126 happy_x_2 of { happy_var_2 -> + case happyOut123 happy_x_3 of { happy_var_3 -> + case happyOut83 happy_x_4 of { happy_var_4 -> + happyIn122 + (HsAlt happy_var_1 happy_var_2 happy_var_3 happy_var_4 + ) `HappyStk` happyRest}}}} + +happyReduce_307 = happySpecReduce_2 119# happyReduction_307 +happyReduction_307 happy_x_2 + happy_x_1 + = case happyOut87 happy_x_2 of { happy_var_2 -> + happyIn123 + (HsUnGuardedAlt happy_var_2 + )} + +happyReduce_308 = happySpecReduce_1 119# happyReduction_308 +happyReduction_308 happy_x_1 + = case happyOut124 happy_x_1 of { happy_var_1 -> + happyIn123 + (HsGuardedAlts (reverse happy_var_1) + )} + +happyReduce_309 = happySpecReduce_2 120# happyReduction_309 +happyReduction_309 happy_x_2 + happy_x_1 + = case happyOut124 happy_x_1 of { happy_var_1 -> + case happyOut125 happy_x_2 of { happy_var_2 -> + happyIn124 + (happy_var_2 : happy_var_1 + )}} + +happyReduce_310 = happySpecReduce_1 120# happyReduction_310 +happyReduction_310 happy_x_1 + = case happyOut125 happy_x_1 of { happy_var_1 -> + happyIn124 + ([happy_var_1] + )} + +happyReduce_311 = happyReduce 5# 121# happyReduction_311 +happyReduction_311 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut117 happy_x_3 of { happy_var_3 -> + case happyOut87 happy_x_5 of { happy_var_5 -> + happyIn125 + (HsGuardedAlt happy_var_1 (reverse happy_var_3) happy_var_5 + ) `HappyStk` happyRest}}} + +happyReduce_312 = happyMonadReduce 1# 122# happyReduction_312 +happyReduction_312 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut90 happy_x_1 of { happy_var_1 -> + ( checkPattern happy_var_1)} + ) (\r -> happyReturn (happyIn126 r)) + +happyReduce_313 = happySpecReduce_3 123# happyReduction_313 +happyReduction_313 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut128 happy_x_2 of { happy_var_2 -> + happyIn127 + (happy_var_2 + )} + +happyReduce_314 = happySpecReduce_3 123# happyReduction_314 +happyReduction_314 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut128 happy_x_2 of { happy_var_2 -> + happyIn127 + (happy_var_2 + )} + +happyReduce_315 = happyReduce 4# 124# happyReduction_315 +happyReduction_315 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut40 happy_x_2 of { happy_var_2 -> + case happyOut128 happy_x_4 of { happy_var_4 -> + happyIn128 + (HsLetStmt happy_var_2 : happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_316 = happyReduce 6# 124# happyReduction_316 +happyReduction_316 (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 happyOut126 happy_x_1 of { happy_var_1 -> + case happyOut165 happy_x_2 of { happy_var_2 -> + case happyOut87 happy_x_4 of { happy_var_4 -> + case happyOut128 happy_x_6 of { happy_var_6 -> + happyIn128 + (HsGenerator happy_var_2 happy_var_1 happy_var_4 : happy_var_6 + ) `HappyStk` happyRest}}}} + +happyReduce_317 = happySpecReduce_3 124# happyReduction_317 +happyReduction_317 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut87 happy_x_1 of { happy_var_1 -> + case happyOut128 happy_x_3 of { happy_var_3 -> + happyIn128 + (HsQualifier happy_var_1 : happy_var_3 + )}} + +happyReduce_318 = happySpecReduce_2 124# happyReduction_318 +happyReduction_318 happy_x_2 + happy_x_1 + = case happyOut128 happy_x_2 of { happy_var_2 -> + happyIn128 + (happy_var_2 + )} + +happyReduce_319 = happySpecReduce_2 124# happyReduction_319 +happyReduction_319 happy_x_2 + happy_x_1 + = case happyOut87 happy_x_1 of { happy_var_1 -> + happyIn128 + ([HsQualifier happy_var_1] + )} + +happyReduce_320 = happySpecReduce_1 124# happyReduction_320 +happyReduction_320 happy_x_1 + = case happyOut87 happy_x_1 of { happy_var_1 -> + happyIn128 + ([HsQualifier happy_var_1] + )} + +happyReduce_321 = happySpecReduce_3 125# happyReduction_321 +happyReduction_321 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut129 happy_x_1 of { happy_var_1 -> + case happyOut130 happy_x_3 of { happy_var_3 -> + happyIn129 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_322 = happySpecReduce_1 125# happyReduction_322 +happyReduction_322 happy_x_1 + = case happyOut130 happy_x_1 of { happy_var_1 -> + happyIn129 + ([happy_var_1] + )} + +happyReduce_323 = happySpecReduce_3 126# happyReduction_323 +happyReduction_323 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut138 happy_x_1 of { happy_var_1 -> + case happyOut87 happy_x_3 of { happy_var_3 -> + happyIn130 + (HsFieldUpdate happy_var_1 happy_var_3 + )}} + +happyReduce_324 = happySpecReduce_3 127# happyReduction_324 +happyReduction_324 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut132 happy_x_2 of { happy_var_2 -> + happyIn131 + (happy_var_2 + )} + +happyReduce_325 = happySpecReduce_3 127# happyReduction_325 +happyReduction_325 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut132 happy_x_2 of { happy_var_2 -> + happyIn131 + (happy_var_2 + )} + +happyReduce_326 = happySpecReduce_3 128# happyReduction_326 +happyReduction_326 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut133 happy_x_2 of { happy_var_2 -> + happyIn132 + (reverse happy_var_2 + )} + +happyReduce_327 = happySpecReduce_3 129# happyReduction_327 +happyReduction_327 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut133 happy_x_1 of { happy_var_1 -> + case happyOut134 happy_x_3 of { happy_var_3 -> + happyIn133 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_328 = happySpecReduce_1 129# happyReduction_328 +happyReduction_328 happy_x_1 + = case happyOut134 happy_x_1 of { happy_var_1 -> + happyIn133 + ([happy_var_1] + )} + +happyReduce_329 = happyReduce 4# 130# happyReduction_329 +happyReduction_329 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut139 happy_x_2 of { happy_var_2 -> + case happyOut87 happy_x_4 of { happy_var_4 -> + happyIn134 + (HsIPBind happy_var_1 happy_var_2 happy_var_4 + ) `HappyStk` happyRest}}} + +happyReduce_330 = happySpecReduce_2 131# happyReduction_330 +happyReduction_330 happy_x_2 + happy_x_1 + = happyIn135 + (unit_con + ) + +happyReduce_331 = happySpecReduce_2 131# happyReduction_331 +happyReduction_331 happy_x_2 + happy_x_1 + = happyIn135 + (HsList [] + ) + +happyReduce_332 = happySpecReduce_3 131# happyReduction_332 +happyReduction_332 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut101 happy_x_2 of { happy_var_2 -> + happyIn135 + (tuple_con happy_var_2 + )} + +happyReduce_333 = happySpecReduce_1 131# happyReduction_333 +happyReduction_333 happy_x_1 + = case happyOut141 happy_x_1 of { happy_var_1 -> + happyIn135 + (HsCon happy_var_1 + )} + +happyReduce_334 = happySpecReduce_1 132# happyReduction_334 +happyReduction_334 happy_x_1 + = case happyOut153 happy_x_1 of { happy_var_1 -> + happyIn136 + (happy_var_1 + )} + +happyReduce_335 = happySpecReduce_3 132# happyReduction_335 +happyReduction_335 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut161 happy_x_2 of { happy_var_2 -> + happyIn136 + (happy_var_2 + )} + +happyReduce_336 = happySpecReduce_1 133# happyReduction_336 +happyReduction_336 happy_x_1 + = case happyOut152 happy_x_1 of { happy_var_1 -> + happyIn137 + (happy_var_1 + )} + +happyReduce_337 = happySpecReduce_3 133# happyReduction_337 +happyReduction_337 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut161 happy_x_2 of { happy_var_2 -> + happyIn137 + (happy_var_2 + )} + +happyReduce_338 = happySpecReduce_1 134# happyReduction_338 +happyReduction_338 happy_x_1 + = case happyOut151 happy_x_1 of { happy_var_1 -> + happyIn138 + (happy_var_1 + )} + +happyReduce_339 = happySpecReduce_3 134# happyReduction_339 +happyReduction_339 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut159 happy_x_2 of { happy_var_2 -> + happyIn138 + (happy_var_2 + )} + +happyReduce_340 = happySpecReduce_1 135# happyReduction_340 +happyReduction_340 happy_x_1 + = case happyOut154 happy_x_1 of { happy_var_1 -> + happyIn139 + (happy_var_1 + )} + +happyReduce_341 = happySpecReduce_1 136# happyReduction_341 +happyReduction_341 happy_x_1 + = case happyOut156 happy_x_1 of { happy_var_1 -> + happyIn140 + (happy_var_1 + )} + +happyReduce_342 = happySpecReduce_3 136# happyReduction_342 +happyReduction_342 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut158 happy_x_2 of { happy_var_2 -> + happyIn140 + (happy_var_2 + )} + +happyReduce_343 = happySpecReduce_1 137# happyReduction_343 +happyReduction_343 happy_x_1 + = case happyOut155 happy_x_1 of { happy_var_1 -> + happyIn141 + (happy_var_1 + )} + +happyReduce_344 = happySpecReduce_3 137# happyReduction_344 +happyReduction_344 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut150 happy_x_2 of { happy_var_2 -> + happyIn141 + (happy_var_2 + )} + +happyReduce_345 = happySpecReduce_1 138# happyReduction_345 +happyReduction_345 happy_x_1 + = case happyOut161 happy_x_1 of { happy_var_1 -> + happyIn142 + (happy_var_1 + )} + +happyReduce_346 = happySpecReduce_3 138# happyReduction_346 +happyReduction_346 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut153 happy_x_2 of { happy_var_2 -> + happyIn142 + (happy_var_2 + )} + +happyReduce_347 = happySpecReduce_1 139# happyReduction_347 +happyReduction_347 happy_x_1 + = case happyOut159 happy_x_1 of { happy_var_1 -> + happyIn143 + (happy_var_1 + )} + +happyReduce_348 = happySpecReduce_3 139# happyReduction_348 +happyReduction_348 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut151 happy_x_2 of { happy_var_2 -> + happyIn143 + (happy_var_2 + )} + +happyReduce_349 = happySpecReduce_1 140# happyReduction_349 +happyReduction_349 happy_x_1 + = case happyOut160 happy_x_1 of { happy_var_1 -> + happyIn144 + (happy_var_1 + )} + +happyReduce_350 = happySpecReduce_3 140# happyReduction_350 +happyReduction_350 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut151 happy_x_2 of { happy_var_2 -> + happyIn144 + (happy_var_2 + )} + +happyReduce_351 = happySpecReduce_1 141# happyReduction_351 +happyReduction_351 happy_x_1 + = case happyOut158 happy_x_1 of { happy_var_1 -> + happyIn145 + (happy_var_1 + )} + +happyReduce_352 = happySpecReduce_3 141# happyReduction_352 +happyReduction_352 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut156 happy_x_2 of { happy_var_2 -> + happyIn145 + (happy_var_2 + )} + +happyReduce_353 = happySpecReduce_1 142# happyReduction_353 +happyReduction_353 happy_x_1 + = case happyOut150 happy_x_1 of { happy_var_1 -> + happyIn146 + (happy_var_1 + )} + +happyReduce_354 = happySpecReduce_3 142# happyReduction_354 +happyReduction_354 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut155 happy_x_2 of { happy_var_2 -> + happyIn146 + (happy_var_2 + )} + +happyReduce_355 = happySpecReduce_1 143# happyReduction_355 +happyReduction_355 happy_x_1 + = case happyOut142 happy_x_1 of { happy_var_1 -> + happyIn147 + (HsVarOp happy_var_1 + )} + +happyReduce_356 = happySpecReduce_1 143# happyReduction_356 +happyReduction_356 happy_x_1 + = case happyOut145 happy_x_1 of { happy_var_1 -> + happyIn147 + (HsConOp happy_var_1 + )} + +happyReduce_357 = happySpecReduce_1 144# happyReduction_357 +happyReduction_357 happy_x_1 + = case happyOut143 happy_x_1 of { happy_var_1 -> + happyIn148 + (HsQVarOp happy_var_1 + )} + +happyReduce_358 = happySpecReduce_1 144# happyReduction_358 +happyReduction_358 happy_x_1 + = case happyOut146 happy_x_1 of { happy_var_1 -> + happyIn148 + (HsQConOp happy_var_1 + )} + +happyReduce_359 = happySpecReduce_1 145# happyReduction_359 +happyReduction_359 happy_x_1 + = case happyOut144 happy_x_1 of { happy_var_1 -> + happyIn149 + (HsQVarOp happy_var_1 + )} + +happyReduce_360 = happySpecReduce_1 145# happyReduction_360 +happyReduction_360 happy_x_1 + = case happyOut146 happy_x_1 of { happy_var_1 -> + happyIn149 + (HsQConOp happy_var_1 + )} + +happyReduce_361 = happySpecReduce_1 146# happyReduction_361 +happyReduction_361 happy_x_1 + = happyIn150 + (list_cons_name + ) + +happyReduce_362 = happySpecReduce_1 146# happyReduction_362 +happyReduction_362 happy_x_1 + = case happyOut157 happy_x_1 of { happy_var_1 -> + happyIn150 + (happy_var_1 + )} + +happyReduce_363 = happySpecReduce_1 147# happyReduction_363 +happyReduction_363 happy_x_1 + = case happyOut153 happy_x_1 of { happy_var_1 -> + happyIn151 + (UnQual happy_var_1 + )} + +happyReduce_364 = happySpecReduce_1 147# happyReduction_364 +happyReduction_364 happy_x_1 + = case happyOutTok happy_x_1 of { (QVarId happy_var_1) -> + happyIn151 + (Qual (Module (fst happy_var_1)) (HsIdent (snd happy_var_1)) + )} + +happyReduce_365 = happySpecReduce_1 148# happyReduction_365 +happyReduction_365 happy_x_1 + = case happyOutTok happy_x_1 of { (VarId happy_var_1) -> + happyIn152 + (HsIdent happy_var_1 + )} + +happyReduce_366 = happySpecReduce_1 148# happyReduction_366 +happyReduction_366 happy_x_1 + = happyIn152 + (as_name + ) + +happyReduce_367 = happySpecReduce_1 148# happyReduction_367 +happyReduction_367 happy_x_1 + = happyIn152 + (qualified_name + ) + +happyReduce_368 = happySpecReduce_1 148# happyReduction_368 +happyReduction_368 happy_x_1 + = happyIn152 + (hiding_name + ) + +happyReduce_369 = happySpecReduce_1 148# happyReduction_369 +happyReduction_369 happy_x_1 + = happyIn152 + (export_name + ) + +happyReduce_370 = happySpecReduce_1 148# happyReduction_370 +happyReduction_370 happy_x_1 + = happyIn152 + (stdcall_name + ) + +happyReduce_371 = happySpecReduce_1 148# happyReduction_371 +happyReduction_371 happy_x_1 + = happyIn152 + (ccall_name + ) + +happyReduce_372 = happySpecReduce_1 149# happyReduction_372 +happyReduction_372 happy_x_1 + = case happyOut152 happy_x_1 of { happy_var_1 -> + happyIn153 + (happy_var_1 + )} + +happyReduce_373 = happySpecReduce_1 149# happyReduction_373 +happyReduction_373 happy_x_1 + = happyIn153 + (safe_name + ) + +happyReduce_374 = happySpecReduce_1 149# happyReduction_374 +happyReduction_374 happy_x_1 + = happyIn153 + (unsafe_name + ) + +happyReduce_375 = happySpecReduce_1 149# happyReduction_375 +happyReduction_375 happy_x_1 + = happyIn153 + (threadsafe_name + ) + +happyReduce_376 = happySpecReduce_1 150# happyReduction_376 +happyReduction_376 happy_x_1 + = case happyOutTok happy_x_1 of { (IDupVarId happy_var_1) -> + happyIn154 + (HsIPDup happy_var_1 + )} + +happyReduce_377 = happySpecReduce_1 150# happyReduction_377 +happyReduction_377 happy_x_1 + = case happyOutTok happy_x_1 of { (ILinVarId happy_var_1) -> + happyIn154 + (HsIPLin happy_var_1 + )} + +happyReduce_378 = happySpecReduce_1 151# happyReduction_378 +happyReduction_378 happy_x_1 + = case happyOut156 happy_x_1 of { happy_var_1 -> + happyIn155 + (UnQual happy_var_1 + )} + +happyReduce_379 = happySpecReduce_1 151# happyReduction_379 +happyReduction_379 happy_x_1 + = case happyOutTok happy_x_1 of { (QConId happy_var_1) -> + happyIn155 + (Qual (Module (fst happy_var_1)) (HsIdent (snd happy_var_1)) + )} + +happyReduce_380 = happySpecReduce_1 152# happyReduction_380 +happyReduction_380 happy_x_1 + = case happyOutTok happy_x_1 of { (ConId happy_var_1) -> + happyIn156 + (HsIdent happy_var_1 + )} + +happyReduce_381 = happySpecReduce_1 153# happyReduction_381 +happyReduction_381 happy_x_1 + = case happyOut158 happy_x_1 of { happy_var_1 -> + happyIn157 + (UnQual happy_var_1 + )} + +happyReduce_382 = happySpecReduce_1 153# happyReduction_382 +happyReduction_382 happy_x_1 + = case happyOutTok happy_x_1 of { (QConSym happy_var_1) -> + happyIn157 + (Qual (Module (fst happy_var_1)) (HsSymbol (snd happy_var_1)) + )} + +happyReduce_383 = happySpecReduce_1 154# happyReduction_383 +happyReduction_383 happy_x_1 + = case happyOutTok happy_x_1 of { (ConSym happy_var_1) -> + happyIn158 + (HsSymbol happy_var_1 + )} + +happyReduce_384 = happySpecReduce_1 155# happyReduction_384 +happyReduction_384 happy_x_1 + = case happyOut161 happy_x_1 of { happy_var_1 -> + happyIn159 + (UnQual happy_var_1 + )} + +happyReduce_385 = happySpecReduce_1 155# happyReduction_385 +happyReduction_385 happy_x_1 + = case happyOut163 happy_x_1 of { happy_var_1 -> + happyIn159 + (happy_var_1 + )} + +happyReduce_386 = happySpecReduce_1 156# happyReduction_386 +happyReduction_386 happy_x_1 + = case happyOut162 happy_x_1 of { happy_var_1 -> + happyIn160 + (UnQual happy_var_1 + )} + +happyReduce_387 = happySpecReduce_1 156# happyReduction_387 +happyReduction_387 happy_x_1 + = case happyOut163 happy_x_1 of { happy_var_1 -> + happyIn160 + (happy_var_1 + )} + +happyReduce_388 = happySpecReduce_1 157# happyReduction_388 +happyReduction_388 happy_x_1 + = case happyOutTok happy_x_1 of { (VarSym happy_var_1) -> + happyIn161 + (HsSymbol happy_var_1 + )} + +happyReduce_389 = happySpecReduce_1 157# happyReduction_389 +happyReduction_389 happy_x_1 + = happyIn161 + (minus_name + ) + +happyReduce_390 = happySpecReduce_1 157# happyReduction_390 +happyReduction_390 happy_x_1 + = happyIn161 + (pling_name + ) + +happyReduce_391 = happySpecReduce_1 157# happyReduction_391 +happyReduction_391 happy_x_1 + = happyIn161 + (dot_name + ) + +happyReduce_392 = happySpecReduce_1 158# happyReduction_392 +happyReduction_392 happy_x_1 + = case happyOutTok happy_x_1 of { (VarSym happy_var_1) -> + happyIn162 + (HsSymbol happy_var_1 + )} + +happyReduce_393 = happySpecReduce_1 158# happyReduction_393 +happyReduction_393 happy_x_1 + = happyIn162 + (pling_name + ) + +happyReduce_394 = happySpecReduce_1 158# happyReduction_394 +happyReduction_394 happy_x_1 + = happyIn162 + (dot_name + ) + +happyReduce_395 = happySpecReduce_1 159# happyReduction_395 +happyReduction_395 happy_x_1 + = case happyOutTok happy_x_1 of { (QVarSym happy_var_1) -> + happyIn163 + (Qual (Module (fst happy_var_1)) (HsSymbol (snd happy_var_1)) + )} + +happyReduce_396 = happySpecReduce_1 160# happyReduction_396 +happyReduction_396 happy_x_1 + = case happyOutTok happy_x_1 of { (IntTok happy_var_1) -> + happyIn164 + (HsInt happy_var_1 + )} + +happyReduce_397 = happySpecReduce_1 160# happyReduction_397 +happyReduction_397 happy_x_1 + = case happyOutTok happy_x_1 of { (Character happy_var_1) -> + happyIn164 + (HsChar happy_var_1 + )} + +happyReduce_398 = happySpecReduce_1 160# happyReduction_398 +happyReduction_398 happy_x_1 + = case happyOutTok happy_x_1 of { (FloatTok happy_var_1) -> + happyIn164 + (HsFrac happy_var_1 + )} + +happyReduce_399 = happySpecReduce_1 160# happyReduction_399 +happyReduction_399 happy_x_1 + = case happyOutTok happy_x_1 of { (StringTok happy_var_1) -> + happyIn164 + (HsString happy_var_1 + )} + +happyReduce_400 = happyMonadReduce 0# 161# happyReduction_400 +happyReduction_400 (happyRest) tk + = happyThen (( getSrcLoc) + ) (\r -> happyReturn (happyIn165 r)) + +happyReduce_401 = happyMonadReduce 0# 162# happyReduction_401 +happyReduction_401 (happyRest) tk + = happyThen (( pushCurrentContext) + ) (\r -> happyReturn (happyIn166 r)) + +happyReduce_402 = happySpecReduce_1 163# happyReduction_402 +happyReduction_402 happy_x_1 + = happyIn167 + (() + ) + +happyReduce_403 = happyMonadReduce 1# 163# happyReduction_403 +happyReduction_403 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (( popContext) + ) (\r -> happyReturn (happyIn167 r)) + +happyReduce_404 = happySpecReduce_1 164# happyReduction_404 +happyReduction_404 happy_x_1 + = case happyOutTok happy_x_1 of { (ConId happy_var_1) -> + happyIn168 + (Module happy_var_1 + )} + +happyReduce_405 = happySpecReduce_1 164# happyReduction_405 +happyReduction_405 happy_x_1 + = case happyOutTok happy_x_1 of { (QConId happy_var_1) -> + happyIn168 + (Module (fst happy_var_1 ++ '.':snd happy_var_1) + )} + +happyReduce_406 = happySpecReduce_1 165# happyReduction_406 +happyReduction_406 happy_x_1 + = case happyOut156 happy_x_1 of { happy_var_1 -> + happyIn169 + (happy_var_1 + )} + +happyReduce_407 = happySpecReduce_1 166# happyReduction_407 +happyReduction_407 happy_x_1 + = case happyOut156 happy_x_1 of { happy_var_1 -> + happyIn170 + (happy_var_1 + )} + +happyReduce_408 = happySpecReduce_1 167# happyReduction_408 +happyReduction_408 happy_x_1 + = case happyOut155 happy_x_1 of { happy_var_1 -> + happyIn171 + (happy_var_1 + )} + +happyReduce_409 = happySpecReduce_1 168# happyReduction_409 +happyReduction_409 happy_x_1 + = case happyOut155 happy_x_1 of { happy_var_1 -> + happyIn172 + (happy_var_1 + )} + +happyReduce_410 = happySpecReduce_1 169# happyReduction_410 +happyReduction_410 happy_x_1 + = case happyOut153 happy_x_1 of { happy_var_1 -> + happyIn173 + (happy_var_1 + )} + +happyReduce_411 = happySpecReduce_3 170# happyReduction_411 +happyReduction_411 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut173 happy_x_2 of { happy_var_2 -> + happyIn174 + (UnQual happy_var_2 + )} + +happyReduce_412 = happySpecReduce_1 170# happyReduction_412 +happyReduction_412 happy_x_1 + = case happyOut175 happy_x_1 of { happy_var_1 -> + happyIn174 + (UnQual happy_var_1 + )} + +happyReduce_413 = happySpecReduce_1 171# happyReduction_413 +happyReduction_413 happy_x_1 + = case happyOutTok happy_x_1 of { (VarSym happy_var_1) -> + happyIn175 + (HsSymbol happy_var_1 + )} + +happyNewToken action sts stk + = lexer(\tk -> + let cont i = happyDoAction i tk action sts stk in + case tk of { + EOF -> happyDoAction 107# tk action sts stk; + VarId happy_dollar_dollar -> cont 1#; + QVarId happy_dollar_dollar -> cont 2#; + IDupVarId happy_dollar_dollar -> cont 3#; + ILinVarId happy_dollar_dollar -> cont 4#; + ConId happy_dollar_dollar -> cont 5#; + QConId happy_dollar_dollar -> cont 6#; + DVarId happy_dollar_dollar -> cont 7#; + VarSym happy_dollar_dollar -> cont 8#; + ConSym happy_dollar_dollar -> cont 9#; + QVarSym happy_dollar_dollar -> cont 10#; + QConSym happy_dollar_dollar -> cont 11#; + IntTok happy_dollar_dollar -> cont 12#; + FloatTok happy_dollar_dollar -> cont 13#; + Character happy_dollar_dollar -> cont 14#; + StringTok happy_dollar_dollar -> cont 15#; + LeftParen -> cont 16#; + RightParen -> cont 17#; + LeftHashParen -> cont 18#; + RightHashParen -> cont 19#; + SemiColon -> cont 20#; + LeftCurly -> cont 21#; + RightCurly -> cont 22#; + VRightCurly -> cont 23#; + LeftSquare -> cont 24#; + RightSquare -> cont 25#; + Comma -> cont 26#; + Underscore -> cont 27#; + BackQuote -> cont 28#; + Dot -> cont 29#; + DotDot -> cont 30#; + Colon -> cont 31#; + DoubleColon -> cont 32#; + Equals -> cont 33#; + Backslash -> cont 34#; + Bar -> cont 35#; + LeftArrow -> cont 36#; + RightArrow -> cont 37#; + At -> cont 38#; + Tilde -> cont 39#; + DoubleArrow -> cont 40#; + Minus -> cont 41#; + Exclamation -> cont 42#; + RPOpen -> cont 43#; + RPClose -> cont 44#; + RPSeqOpen -> cont 45#; + RPSeqClose -> cont 46#; + RPStar -> cont 47#; + RPStarG -> cont 48#; + RPPlus -> cont 49#; + RPPlusG -> cont 50#; + RPOpt -> cont 51#; + RPOptG -> cont 52#; + RPEither -> cont 53#; + RPCAt -> cont 54#; + THIdEscape happy_dollar_dollar -> cont 55#; + THParenEscape -> cont 56#; + THExpQuote -> cont 57#; + THPatQuote -> cont 58#; + THTypQuote -> cont 59#; + THDecQuote -> cont 60#; + THCloseQuote -> cont 61#; + THReifyDecl -> cont 62#; + THReifyType -> cont 63#; + THReifyFixity -> cont 64#; + XPcdata happy_dollar_dollar -> cont 65#; + XStdTagOpen -> cont 66#; + XCloseTagOpen -> cont 67#; + XCodeTagOpen -> cont 68#; + XStdTagClose -> cont 69#; + XEmptyTagClose -> cont 70#; + XCodeTagClose -> cont 71#; + KW_Foreign -> cont 72#; + KW_Export -> cont 73#; + KW_Safe -> cont 74#; + KW_Unsafe -> cont 75#; + KW_Threadsafe -> cont 76#; + KW_StdCall -> cont 77#; + KW_CCall -> cont 78#; + KW_As -> cont 79#; + KW_Case -> cont 80#; + KW_Class -> cont 81#; + KW_Data -> cont 82#; + KW_Default -> cont 83#; + KW_Deriving -> cont 84#; + KW_DLet -> cont 85#; + KW_Do -> cont 86#; + KW_Else -> cont 87#; + KW_Forall -> cont 88#; + KW_Hiding -> cont 89#; + KW_If -> cont 90#; + KW_Import -> cont 91#; + KW_In -> cont 92#; + KW_Infix -> cont 93#; + KW_InfixL -> cont 94#; + KW_InfixR -> cont 95#; + KW_Instance -> cont 96#; + KW_Let -> cont 97#; + KW_MDo -> cont 98#; + KW_Module -> cont 99#; + KW_NewType -> cont 100#; + KW_Of -> cont 101#; + KW_Then -> cont 102#; + KW_Type -> cont 103#; + KW_Where -> cont 104#; + KW_With -> cont 105#; + KW_Qualified -> cont 106#; + _ -> 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 1 "templates/GenericTemplate.hs" #-} +-- Id: GenericTemplate.hs,v 1.26 2005/01/14 14:47:22 simonmar Exp + +{-# LINE 28 "templates/GenericTemplate.hs" #-} + + +data Happy_IntList = HappyCons Int# Happy_IntList + + + + + +{-# LINE 49 "templates/GenericTemplate.hs" #-} + +{-# LINE 59 "templates/GenericTemplate.hs" #-} + +{-# LINE 68 "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 | (n <# (0# :: Int#)) -> {- nothing -} + + (happyReduceArr ! rule) i tk st + where rule = (I# ((negateInt# ((n +# (1# :: Int#)))))) + n -> {- nothing -} + + + happyShift new_state i tk st + where new_state = (n -# (1# :: Int#)) + where off = indexShortOffAddr happyActOffsets st + off_i = (off +# i) + check = if (off_i >=# (0# :: Int#)) + then (indexShortOffAddr happyCheck off_i ==# i) + else False + action | check = indexShortOffAddr happyTable off_i + | otherwise = indexShortOffAddr happyDefActions st + +{-# LINE 127 "templates/GenericTemplate.hs" #-} + + +indexShortOffAddr (HappyA# arr) off = +#if __GLASGOW_HASKELL__ > 500 + narrow16Int# i +#elif __GLASGOW_HASKELL__ == 500 + intToInt16# i +#else + (i `iShiftL#` 16#) `iShiftRA#` 16# +#endif + where +#if __GLASGOW_HASKELL__ >= 503 + i = word2Int# ((high `uncheckedShiftL#` 8#) `or#` low) +#else + i = word2Int# ((high `shiftL#` 8#) `or#` low) +#endif + high = int2Word# (ord# (indexCharOffAddr# arr (off' +# 1#))) + low = int2Word# (ord# (indexCharOffAddr# arr off')) + off' = off *# 2# + + + + + +data HappyAddr = HappyA# 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 unsafeCoerce# x of { (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 -# (1# :: 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 = + happyThen1 (fn stk tk) (\r -> happyGoto nt j tk st1 sts1 (r `HappyStk` drop_stk)) + where sts1@((HappyCons (st1@(action)) (_))) = happyDrop k (HappyCons (st) (sts)) + drop_stk = happyDropStk k 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 = + happyThen1 (fn stk tk) (\r -> happyNewToken new_state sts1 (r `HappyStk` drop_stk)) + where sts1@((HappyCons (st1@(action)) (_))) = happyDrop k (HappyCons (st) (sts)) + drop_stk = happyDropStk k stk + + off = indexShortOffAddr happyGotoOffsets st1 + off_i = (off +# nt) + new_state = indexShortOffAddr happyTable off_i + + + + +happyDrop 0# l = l +happyDrop n (HappyCons (_) (t)) = happyDrop (n -# (1# :: Int#)) t + +happyDropStk 0# l = l +happyDropStk n (x `HappyStk` xs) = happyDropStk (n -# (1#::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 +# 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 = +-- trace "failing" $ + happyError_ 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 ( (unsafeCoerce# (I# (i))) `HappyStk` stk) + +-- Internal happy errors: + +notHappyAtAll = error "Internal Happy error\n" + +----------------------------------------------------------------------------- +-- Hack to get the typechecker to accept our action functions + + +happyTcHack :: 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. diff --git a/Language/Haskell/Hsx/Parser.ly b/Language/Haskell/Hsx/Parser.ly new file mode 100644 --- /dev/null +++ b/Language/Haskell/Hsx/Parser.ly @@ -0,0 +1,1167 @@ +> { +> ----------------------------------------------------------------------------- +> -- | +> -- Module : Language.Haskell.Hsx.Parser +> -- Original : Language.Haskell.Parser +> -- Copyright : (c) Niklas Broberg 2004, +> -- Original (c) Simon Marlow, Sven Panne 1997-2000 +> -- License : BSD-style (see the file LICENSE.txt) +> -- +> -- Maintainer : Niklas Broberg, d00nibro@dtek.chalmers.se +> -- Stability : experimental +> -- Portability : portable +> -- +> -- +> ----------------------------------------------------------------------------- +> +> module Language.Haskell.Hsx.Parser ( +> parseModule, parseModuleWithMode, +> ParseMode(..), defaultParseMode, ParseResult(..)) where +> +> import Language.Haskell.Hsx.Syntax +> import Language.Haskell.Hsx.ParseMonad +> import Language.Haskell.Hsx.Lexer +> import Language.Haskell.Hsx.ParseUtils +> } + +----------------------------------------------------------------------------- +This module comprises a parser for Haskell 98 with the following extensions + +* Multi-parameter type classes with functional dependencies +* Implicit parameters +* Pattern guards +* Mdo notation +* FFI +* HaRP +* HSP + +Most of the code is blatantly stolen from the GHC module Language.Haskell.Parser. +Some of the code for extensions is greatly influenced by GHC's internal parser +library, ghc/compiler/parser/Parser.y. +----------------------------------------------------------------------------- +Conflicts: 3 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). + +1 for ambiguity in 'let ?x ...' + the parser can't tell whether the ?x is the lhs of a normal binding or + an implicit binding. Fortunately resolving as shift gives it the only + sensible meaning, namely the lhs of an implicit binding. + +----------------------------------------------------------------------------- + +> %token +> VARID { VarId $$ } +> QVARID { QVarId $$ } +> IDUPID { IDupVarId $$ } -- duplicable implicit parameter ?x +> ILINID { ILinVarId $$ } -- linear implicit parameter %x +> CONID { ConId $$ } +> QCONID { QConId $$ } +> DVARID { DVarId $$ } -- VARID containing dashes +> VARSYM { VarSym $$ } +> CONSYM { ConSym $$ } +> QVARSYM { QVarSym $$ } +> QCONSYM { QConSym $$ } +> INT { IntTok $$ } +> RATIONAL { FloatTok $$ } +> CHAR { Character $$ } +> STRING { StringTok $$ } + +Symbols + +> '(' { LeftParen } +> ')' { RightParen } +> '(#' { LeftHashParen } +> '#)' { RightHashParen } +> ';' { SemiColon } +> '{' { LeftCurly } +> '}' { RightCurly } +> vccurly { VRightCurly } -- a virtual close brace +> '[' { LeftSquare } +> ']' { RightSquare } +> ',' { Comma } +> '_' { Underscore } +> '`' { BackQuote } + +Reserved operators + +> '.' { Dot } +> '..' { DotDot } +> ':' { Colon } +> '::' { DoubleColon } +> '=' { Equals } +> '\\' { Backslash } +> '|' { Bar } +> '<-' { LeftArrow } +> '->' { RightArrow } +> '@' { At } +> '~' { Tilde } +> '=>' { DoubleArrow } +> '-' { Minus } +> '!' { Exclamation } + +Harp + +> '[/' { RPOpen } +> '/]' { RPClose } +> '(/' { RPSeqOpen } +> '/)' { RPSeqClose } +> '*' { RPStar } +> '*!' { RPStarG } +> '+' { RPPlus } +> '+!' { RPPlusG } +> '?' { RPOpt } +> '?!' { RPOptG } +> 'rp|' { RPEither } -- '|' already taken +> '@:' { RPCAt } + +Template Haskell + +> IDSPLICE { THIdEscape $$ } +> '$(' { THParenEscape } +> '[|' { THExpQuote } +> '[p|' { THPatQuote } +> '[t|' { THTypQuote } +> '[d|' { THDecQuote } +> '|]' { THCloseQuote } +> 'reifyDecl' { THReifyDecl } +> 'reifyType' { THReifyType } +> 'reifyFixity' { THReifyFixity } + +Hsx + +> PCDATA { XPcdata $$ } +> '<' { XStdTagOpen } +> ' '<%' { XCodeTagOpen } +> '>' { XStdTagClose } +> '/>' { XEmptyTagClose } +> '%>' { XCodeTagClose } + +FFI + +> 'foreign' { KW_Foreign } +> 'export' { KW_Export } +> 'safe' { KW_Safe } +> 'unsafe' { KW_Unsafe } +> 'threadsafe' { KW_Threadsafe } +> 'stdcall' { KW_StdCall } +> 'ccall' { KW_CCall } + +Reserved Ids + +> 'as' { KW_As } +> 'case' { KW_Case } +> 'class' { KW_Class } +> 'data' { KW_Data } +> 'default' { KW_Default } +> 'deriving' { KW_Deriving } +> 'dlet' { KW_DLet } -- implicit parameter binding clause +> 'do' { KW_Do } +> 'else' { KW_Else } +> 'forall' { KW_Forall } -- universal/existential qualification +> 'hiding' { KW_Hiding } +> 'if' { KW_If } +> 'import' { KW_Import } +> 'in' { KW_In } +> 'infix' { KW_Infix } +> 'infixl' { KW_InfixL } +> 'infixr' { KW_InfixR } +> 'instance' { KW_Instance } +> 'let' { KW_Let } +> 'mdo' { KW_MDo } +> 'module' { KW_Module } +> 'newtype' { KW_NewType } +> 'of' { KW_Of } +> 'then' { KW_Then } +> 'type' { KW_Type } +> 'where' { KW_Where } +> 'with' { KW_With } -- implicit parameter binding clause +> 'qualified' { KW_Qualified } + +> %monad { P } +> %lexer { lexer } { EOF } +> %name parse +> %tokentype { Token } +> %% + +----------------------------------------------------------------------------- +HSP Pages + +> page :: { HsModule } +> : topxml {% mkPageModule $1 } +> | '<%' module '%>' srcloc topxml {% mkPage $2 $4 $5 } +> | module { $1 } + +> topxml :: { HsExp } +> : srcloc '<' name attrs mattr '>' children '' {% do { n <- checkEqNames $3 $9; +> let { cn = reverse $7; +> as = reverse $4; }; +> return $ HsXTag $1 n as $5 cn } } +> | srcloc '<' name attrs mattr '/>' { HsXETag $1 $3 (reverse $4) $5 } + + +----------------------------------------------------------------------------- +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 '=' ctype +> { HsTypeDecl $1 (fst $3) (snd $3) $5 } +> | srcloc 'data' ctype constrs0 deriving +> {% do { (cs,c,t) <- checkDataHeader $3; +> return (HsDataDecl $1 cs c t (reverse $4) $5) } } +> | srcloc 'data' ctype 'where' gadtlist +> {% do { (cs,c,t) <- checkDataHeader $3; +> return (HsGDataDecl $1 cs c t (reverse $5)) } } +> | srcloc 'newtype' ctype '=' constr deriving +> {% do { (cs,c,t) <- checkDataHeader $3; +> return (HsNewTypeDecl $1 cs c t $5 $6) } } + +A class declaration may include functional dependencies. +> | srcloc 'class' ctype fds optcbody +> {% do { (cs,c,vs) <- checkClassHeader $3; +> return (HsClassDecl $1 cs c vs $4 $5) } } +> | srcloc 'instance' ctype optvaldefs +> {% do { (cs,c,ts) <- checkInstHeader $3; +> return (HsInstDecl $1 cs c ts $4) } } +> | srcloc 'default' '(' typelist ')' +> { HsDefaultDecl $1 $4 } +> | srcloc '$(' exp ')' +> {% do { e <- checkExpr $3; +> return $ HsSpliceDecl $1 $ HsParenSplice e } } +> +> | srcloc 'foreign' 'import' callconv safety fspec +> { let (s,n,t) = $6 in HsForImp $1 $4 $5 s n t } +> | srcloc 'foreign' 'export' callconv fspec +> { let (s,n,t) = $5 in HsForExp $1 $4 s n t } +> | 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 } + +Binding can be either of implicit parameters, or it can be a normal sequence +of declarations. The two kinds cannot be mixed within the same block of +binding. + +> binds :: { HsBinds } +> : decllist { HsBDecls $1 } +> | '{' ipbinds '}' { HsIPBinds $2 } +> | open ipbinds close { HsIPBinds $2 } + +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] } } + +----------------------------------------------------------------------------- +FFI + +> callconv :: { HsCallConv } +> : 'stdcall' { StdCall } +> | 'ccall' { CCall } + +> safety :: { HsSafety } +> : 'safe' { PlaySafe False } +> | 'unsafe' { PlayRisky } +> | 'threadsafe' { PlaySafe True } +> | {- empty -} { PlaySafe False } + +> fspec :: { (String, HsName, HsType) } +> : STRING var_no_safety '::' dtype { ($1, $2, $4) } +> | var_no_safety '::' dtype { ("", $1, $3) } + +----------------------------------------------------------------------------- +Types + +> dtype :: { HsType } +> : btype { $1 } +> | btype qtyconop dtype { HsTyInfix $1 $2 $3 } +> | btype qtyvarop dtype { HsTyInfix $1 $2 $3 } +> | btype '->' dtype { HsTyFun $1 $3 } + +Implicit parameters can occur in normal types, as well as in contexts. + +> type :: { HsType } +> : ivar '::' dtype { HsTyPred $ HsIParam $1 $3 } +> | dtype { $1 } + +> btype :: { HsType } +> : btype atype { HsTyApp $1 $2 } +> | atype { $1 } + +> atype :: { HsType } +> : gtycon { HsTyCon $1 } +> | tyvar { HsTyVar $1 } +> | '(' types ')' { HsTyTuple Boxed (reverse $2) } +> | '(#' types1 '#)' { HsTyTuple Unboxed (reverse $2) } +> | '[' type ']' { HsTyApp list_tycon $2 } +> | '(' ctype ')' { $2 } + +> gtycon :: { HsQName } +> : qconid { $1 } +> | '(' ')' { unit_tycon_name } +> | '(' '->' ')' { fun_tycon_name } +> | '[' ']' { list_tycon_name } +> | '(' commas ')' { tuple_tycon_name $2 } + +These are for infix types + +> qtyconop :: { HsQName } +> : qconop { $1 } + + + + + +(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 :: { HsType } +> : 'forall' tyvars '.' ctype { mkHsTyForall (Just $2) [] $4 } +> | context '=>' type { mkHsTyForall Nothing $1 $3 } +> | type { $1 } + +> context :: { HsContext } +> : btype {% checkContext $1 } + +> types :: { [HsType] } +> : types1 ',' type { $3 : $1 } + +> types1 :: { [HsType] } +> : type { [$1] } +> | types1 ',' type { $3 : $1 } + +> simpletype :: { (HsName, [HsName]) } +> : tycon tyvars { ($1,reverse $2) } + +> tyvars :: { [HsName] } +> : tyvars tyvar { $2 : $1 } +> | {- empty -} { [] } + +----------------------------------------------------------------------------- +Functional Dependencies + +> fds :: { [HsFunDep] } +> : {- empty -} { [] } +> | '|' fds1 { reverse $2 } + +> fds1 :: { [HsFunDep] } +> : fds1 ',' fd { $3 : $1 } +> | fd { [$1] } + +> fd :: { HsFunDep } +> : tyvars '->' tyvars { HsFunDep (reverse $1) (reverse $3) } + +----------------------------------------------------------------------------- +Datatype declarations + +GADTs + +> gadtlist :: { [HsGadtDecl] } +> : '{' gadtconstrs1 '}' { $2 } +> | open gadtconstrs1 close { $2 } + +> gadtconstrs1 :: { [HsGadtDecl] } +> : optsemis gadtconstrs optsemis { $2 } + +> gadtconstrs :: { [HsGadtDecl] } +> : gadtconstrs semis gadtconstr { $3 : $1 } +> | gadtconstr { [$1] } + +> gadtconstr :: { HsGadtDecl } +> : srcloc qcon '::' ctype {% do { c <- checkUnQual $2; +> return $ HsGadtDecl $1 c $4 } } + +> constrs0 :: { [HsQualConDecl] } +> : {- empty -} { [] } +> | '=' constrs { $2 } + +> constrs :: { [HsQualConDecl] } +> : constrs '|' constr { $3 : $1 } +> | constr { [$1] } + +> constr :: { HsQualConDecl } +> : srcloc forall context '=>' constr1 { HsQualConDecl $1 $2 $3 $5 } +> | srcloc forall constr1 { HsQualConDecl $1 $2 [] $3 } + +> forall :: { [HsName] } +> : 'forall' tyvars '.' { $2 } +> | {- empty -} { [] } + +> constr1 :: { HsConDecl } +> : scontype { HsConDecl (fst $1) (snd $1) } +> | sbtype conop sbtype { HsConDecl $2 [$1,$3] } +> | con '{' '}' { HsRecDecl $1 [] } +> | con '{' fielddecls '}' { HsRecDecl $1 (reverse $3) } + +> 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 } +> : ctype { 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 + +No implicit parameters in the where clause of a class declaration. +> 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 } + +May bind implicit parameters +> optwhere :: { HsBinds } +> : 'where' binds { $2 } +> | {- empty -} { HsBDecls [] } + +> rhs :: { HsRhs } +> : '=' exp {% do { e <- checkExpr $2; +> return (HsUnGuardedRhs e) } } +> | gdrhs { HsGuardedRhss (reverse $1) } + +> gdrhs :: { [HsGuardedRhs] } +> : gdrhs gdrh { $2 : $1 } +> | gdrh { [$1] } + +Guards may contain patterns, hence quals instead of exp. +> gdrh :: { HsGuardedRhs } +> : srcloc '|' quals '=' exp {% do { e <- checkExpr $5; +> return (HsGuardedRhs $1 (reverse $3) 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 } +> | exp0b 'with' ipbinding { HsWith $1 $3 } -- implicit parameters +> | 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 } +> | dvarexp { $1 } +> | exp10b { $1 } + +> exp10a :: { HsExp } +> : '\\' srcloc apats '->' exp { HsLambda $2 (reverse $3) $5 } +A let may bind implicit parameters +> | 'let' binds 'in' exp { HsLet $2 $4 } +> | 'dlet' ipbinding 'in' exp { HsDLet $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 } +> | 'mdo' stmtlist { HsMDo $2 } +> | reifyexp { HsReifyExp $1 } +> | 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) } } +> | qvar '@:' aexp {% do { n <- checkUnQual $1; +> return (HsCAsRP 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) } +> | aexp1 '*' { HsStarRP $1 } +> | aexp1 '*!' { HsStarGRP $1 } +> | aexp1 '+' { HsPlusRP $1 } +> | aexp1 '+!' { HsPlusGRP $1 } +> | aexp1 '?' { HsOptRP $1 } +> | aexp1 '?!' { HsOptGRP $1 } +> | 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. +An implicit parameter can be used as an expression. + +> aexp2 :: { HsExp } +> : ivar { HsIPVar $1 } +> | 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 } +> | '(' erpats ')' { $2 } +> | '(/' rpats '/)' { HsSeqRP $ reverse $2 } +> | srcloc '[/' rpats '/]' { HsRPats $1 $ reverse $3 } +> | xml { $1 } + +Template Haskell +> | IDSPLICE { HsSpliceExp $ HsIdSplice $1 } +> | '$(' exp ')' {% do { e <- checkExpr $2; +> return $ HsSpliceExp $ HsParenSplice e } } +> | '[|' exp '|]' {% do { e <- checkExpr $2; +> return $ HsBracketExp $ HsExpBracket e } } +> | '[p|' exp0 '|]' {% do { p <- checkPattern $2; +> return $ HsBracketExp $ HsPatBracket p } } +> | '[t|' ctype '|]' { HsBracketExp $ HsTypeBracket $2 } +> | '[d|' open topdecls close '|]' { HsBracketExp $ HsDeclBracket $3 } + +> reifyexp :: { HsReify } +> : 'reifyDecl' gtycon { HsReifyDecl $2 } +> | 'reifyDecl' qvar { HsReifyDecl $2 } +> | 'reifyType' qcname { HsReifyType $2 } +> | 'reifyFixity' qcname { HsReifyFixity $2 } + +> qcname :: { HsQName } +> : qvar { $1 } +> | gcon {% getGConName $1 } +End Template Haskell + +> commas :: { Int } +> : commas ',' { $1 + 1 } +> | ',' { 1 } + +> texps :: { [HsExp] } +> : texps ',' exp { $3 : $1 } +> | exp ',' exp { [$3,$1] } + +----------------------------------------------------------------------------- +Harp Extensions + +> rpats :: { [HsExp] } +> : rpats ',' rpat { $3 : $1 } +> | rpat { [$1] } + +> rpat :: { HsExp } +> : erpats { $1 } +> | exp { $1 } + +Either patterns are left associative +> erpats :: { HsExp } +> : exp 'rp|' erpats { HsEitherRP $1 $3 } +> | exp 'rp|' exp { HsEitherRP $1 $3 } + +----------------------------------------------------------------------------- +Hsx Extensions + +> xml :: { HsExp } +> : srcloc '<' name attrs mattr '>' children '' {% do { n <- checkEqNames $3 $9; +> let { cn = reverse $7; +> as = reverse $4; }; +> return $ HsXTag $1 n as $5 cn } } +> | srcloc '<' name attrs mattr '/>' { HsXETag $1 $3 (reverse $4) $5 } +> | '<%' exp '%>' { HsXExpTag $2 } + +> children :: { [HsExp] } +> : children child { $2 : $1 } +> | {- empty -} { [] } + +> child :: { HsExp } +> : PCDATA { HsXPcdata $1 } +> | srcloc '[/' rpats '/]' { HsRPats $1 $ reverse $3 } +> | xml { $1 } + +> name :: { HsXName } +> : xmlname ':' xmlname { HsXDomName $1 $3 } +> | xmlname { HsXName $1 } + +> xmlname :: { String } +> : VARID { $1 } +> | CONID { $1 } +> | DVARID { mkDVar $1 } +> | 'type' { "type" } +> | 'class' { "class" } + +> attrs :: { [HsXAttr] } +> : attrs attr { $2 : $1 } +> | {- empty -} { [] } + +> attr :: { HsXAttr } +> : name '=' aexp { HsXAttr $1 $3 } + +> mattr :: { Maybe HsExp } +> : aexp { Just $1 } +> | {-empty-} { Nothing } + +Turning dash variables into infix expressions with '-' +> dvarexp :: { HsExp } +> : DVARID { mkDVarExpr $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' binds { 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] } + +A guard can be a pattern guard, hence quals instead of exp0. +> gdpat :: { HsGuardedAlt } +> : srcloc '|' quals '->' exp { HsGuardedAlt $1 (reverse $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 } + +A let statement may bind implicit parameters. +> stmts :: { [HsStmt] } +> : 'let' binds ';' 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 } + +----------------------------------------------------------------------------- +Implicit parameter bindings + +> ipbinding :: { [HsIPBind] } +> : '{' ipbinds '}' { $2 } +> | open ipbinds close { $2 } + +> ipbinds :: { [HsIPBind] } +> : optsemis ipbinds1 optsemis { reverse $2 } + +> ipbinds1 :: { [HsIPBind] } +> : ipbinds1 semis ipbind { $3 : $1 } +> | ipbind { [$1] } + +> ipbind :: { HsIPBind } +> : srcloc ivar '=' exp { HsIPBind $1 $2 $4 } + +----------------------------------------------------------------------------- +Variables, Constructors and Operators. + +> gcon :: { HsExp } +> : '(' ')' { unit_con } +> | '[' ']' { HsList [] } +> | '(' commas ')' { tuple_con $2 } +> | qcon { HsCon $1 } + +> var :: { HsName } +> : varid { $1 } +> | '(' varsym ')' { $2 } + +> var_no_safety :: { HsName } +> : varid_no_safety { $1 } +> | '(' varsym ')' { $2 } + +> qvar :: { HsQName } +> : qvarid { $1 } +> | '(' qvarsym ')' { $2 } + +Implicit parameter +> ivar :: { HsIPName } +> : ivarid { $1 } + +> 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_no_safety :: { HsName } +> : VARID { HsIdent $1 } +> | 'as' { as_name } +> | 'qualified' { qualified_name } +> | 'hiding' { hiding_name } +> | 'export' { export_name } +> | 'stdcall' { stdcall_name } +> | 'ccall' { ccall_name } + +> varid :: { HsName } +> : varid_no_safety { $1 } +> | 'safe' { safe_name } +> | 'unsafe' { unsafe_name } +> | 'threadsafe' { threadsafe_name } + + +Implicit parameter +> ivarid :: { HsIPName } +> : IDUPID { HsIPDup $1 } +> | ILINID { HsIPLin $1 } + +> 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 } +> | '-' { minus_name } +> | '!' { pling_name } +> | '.' { dot_name } + +> varsymm :: { HsName } -- varsym not including '-' +> : VARSYM { HsSymbol $1 } +> | '!' { pling_name } +> | '.' { dot_name } + +> 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 } + +> qtyvarop :: { HsQName } +> qtyvarop : '`' tyvar '`' { UnQual $2 } +> | tyvarsym { UnQual $1 } + +> tyvarsym :: { HsName } +> tyvarsym : VARSYM { HsSymbol $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 +> } diff --git a/Language/Haskell/Hsx/Pretty.hs b/Language/Haskell/Hsx/Pretty.hs new file mode 100644 --- /dev/null +++ b/Language/Haskell/Hsx/Pretty.hs @@ -0,0 +1,985 @@ +{-# OPTIONS_GHC -w #-} +----------------------------------------------------------------------------- +-- | +-- Module : Language.Haskell.Hsx.Pretty +-- Original : Language.Haskell.Pretty +-- Copyright : (c) Niklas Broberg 2004, +-- (c) The GHC Team, Noel Winstanley 1997-2000 +-- License : BSD-style (see the file LICENSE.txt) +-- +-- Maintainer : Niklas Broberg, d00nibro@dtek.chalmers.se +-- Stability : experimental +-- Portability : portable +-- +-- Pretty printer for Haskell with extensions. +-- +----------------------------------------------------------------------------- + +module Language.Haskell.Hsx.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.Hsx.Syntax + +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 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 (HsGDataDecl loc context name nameList gadtList) = + blankline $ + markLine loc $ + mySep ( [text "data", ppHsContext context, pretty name] + ++ map pretty nameList ++ [text "where"]) + $$$ ppBody classIndent (map pretty gadtList) + + 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 fundeps []) = + blankline $ + markLine pos $ + mySep ( [text "class", ppHsContext context, pretty name] + ++ map pretty nameList ++ [ppFunDeps fundeps]) + pretty (HsClassDecl pos context name nameList fundeps declList) = + blankline $ + markLine pos $ + mySep ( [text "class", ppHsContext context, pretty name] + ++ map pretty nameList ++ [ppFunDeps fundeps, 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 (HsSpliceDecl pos splice) = + blankline $ + markLine pos $ + pretty splice + + pretty (HsTypeSig pos nameList qualType) = + blankline $ + markLine pos $ + mySep ((punctuate comma . map pretty $ nameList) + ++ [text "::", pretty qualType]) + + pretty (HsFunBind matches) = + foldr ($$$) empty (map pretty matches) + + pretty (HsPatBind pos pat rhs whereBinds) = + markLine pos $ + myFsep [pretty pat, pretty rhs] $$$ ppWhere whereBinds + + pretty (HsInfixDecl pos assoc prec opList) = + blankline $ + markLine pos $ + mySep ([pretty assoc, int prec] + ++ (punctuate comma . map pretty $ opList)) + + pretty (HsForImp pos cconv saf str name typ) = + blankline $ + markLine pos $ + mySep [text "foreign import", pretty cconv, pretty saf, + text (show str), pretty name, text "::", pretty typ] + + pretty (HsForExp pos cconv str name typ) = + blankline $ + markLine pos $ + mySep [text "foreign export", pretty cconv, + text (show str), pretty name, text "::", pretty typ] + +instance Pretty HsAssoc where + pretty HsAssocNone = text "infix" + pretty HsAssocLeft = text "infixl" + pretty HsAssocRight = text "infixr" + +instance Pretty HsMatch where + pretty (HsMatch pos f ps rhs whereBinds) = + markLine pos $ + myFsep (lhs ++ [pretty rhs]) + $$$ ppWhere whereBinds + 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 :: HsBinds -> Doc +ppWhere (HsBDecls []) = empty +ppWhere (HsBDecls l) = nest 2 (text "where" $$$ ppBody whereIndent (map pretty l)) +ppWhere (HsIPBinds b) = nest 2 (text "where" $$$ ppBody whereIndent (map pretty b)) + +------------------------- FFI stuff ------------------------------------- +instance Pretty HsSafety where + pretty PlayRisky = text "unsafe" + pretty (PlaySafe b) = text $ if b then "threadsafe" else "safe" + +instance Pretty HsCallConv where + pretty StdCall = text "stdcall" + pretty CCall = text "ccall" + +------------------------- Data & Newtype Bodies ------------------------- +instance Pretty HsQualConDecl where + pretty (HsQualConDecl _pos tvs ctxt con) = + myFsep [ppForall (Just tvs), ppHsContext ctxt, pretty con] + +instance Pretty HsGadtDecl where + pretty (HsGadtDecl _pos name ty) = + myFsep [pretty name, text "::", pretty ty] + +instance Pretty HsConDecl where + pretty (HsRecDecl name fieldList) = + pretty name <> (braceList . map ppField $ fieldList) + + pretty (HsConDecl name@(HsSymbol _) [l, r]) = + myFsep [prettyPrec prec_btype l, ppHsName name, + prettyPrec prec_btype r] + pretty (HsConDecl 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 (HsTyForall mtvs ctxt htype) = parensIf (p > 0) $ + myFsep [ppForall mtvs, ppHsContext ctxt, pretty htype] + prettyPrec p (HsTyFun a b) = parensIf (p > 0) $ + myFsep [ppHsBType a, text "->", pretty b] + prettyPrec _ (HsTyTuple bxd l) = + let ds = map pretty l + in case bxd of + Boxed -> parenList ds + Unboxed -> hashParenList ds + 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 + prettyPrec _ (HsTyPred asst) = pretty asst + prettyPrec _ (HsTyInfix a op b) = parens (myFsep [pretty op, pretty a, pretty b]) + + +ppForall :: Maybe [HsName] -> Doc +ppForall Nothing = empty +ppForall (Just []) = empty +ppForall (Just vs) = myFsep (text "forall" : map pretty vs ++ [char '.']) + +------------------- Functional Dependencies ------------------- +instance Pretty HsFunDep where + pretty (HsFunDep from to) = + myFsep $ map pretty from ++ [text "->"] ++ map pretty to + + +ppFunDeps :: [HsFunDep] -> Doc +ppFunDeps [] = empty +ppFunDeps fds = myFsep $ (char '|':) . punctuate comma . map pretty $ fds + +------------------------- 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 guards ppBody) = + myFsep $ [char '|'] ++ (punctuate comma . map pretty $ guards) ++ [equals, pretty ppBody] + +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 ppBody) = myFsep $ + char '\\' : map pretty expList ++ [text "->", pretty ppBody] + -- keywords + -- two cases for lets + pretty (HsLet (HsBDecls declList) letBody) = + ppLetExp declList letBody + pretty (HsLet (HsIPBinds bindList) letBody) = + ppLetExp bindList letBody + pretty (HsDLet bindList letBody) = + myFsep [text "dlet" <+> ppBody letIndent (map pretty bindList), + text "in", pretty letBody] + pretty (HsWith exp bindList) = + pretty exp $$$ ppWith bindList + 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) + pretty (HsMDo stmtList) = + text "mdo" $$$ ppBody doIndent (map pretty stmtList) + -- Constructors & Vars + pretty (HsVar name) = pretty name + pretty (HsIPVar ipname) = pretty ipname + 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] + -- Template Haskell + pretty (HsReifyExp r) = pretty r + pretty (HsBracketExp b) = pretty b + pretty (HsSpliceExp s) = pretty s + -- regular patterns + pretty (HsRPats _ rs) = + myFsep $ text "[/" : map pretty rs ++ [text "/]"] + pretty (HsSeqRP rs) = + myFsep $ text "(/" : map pretty rs ++ [text "/)"] + pretty (HsStarRP r) = pretty r <> char '*' + pretty (HsStarGRP r) = pretty r <> text "*!" + pretty (HsPlusRP r) = pretty r <> char '+' + pretty (HsPlusGRP r) = pretty r <> text "+!" + pretty (HsOptRP r) = pretty r <> char '?' + pretty (HsOptGRP r) = pretty r <> text "?!" + pretty (HsEitherRP r1 r2) = parens . myFsep $ + [pretty r1, char '|', pretty r2] + -- special case that would otherwise be buggy + pretty (HsCAsRP n (HsIrrPat e)) = + myFsep [pretty n <> text "@:", char '~' <> pretty e] + pretty (HsCAsRP n r) = hcat [pretty n, text "@:", pretty r] + -- Hsx + pretty (HsXTag _ n attrs mattr cs) = + let ax = maybe [] (return . pretty) mattr + in hcat $ + (myFsep $ (char '<' <> pretty n): map pretty attrs ++ ax ++ [char '>']): + map pretty cs ++ [myFsep $ [text " pretty n, char '>']] + pretty (HsXETag _ n attrs mattr) = + let ax = maybe [] (return . pretty) mattr + in myFsep $ (char '<' <> pretty n): map pretty attrs ++ ax ++ [text "/>"] + pretty (HsXPcdata s) = text s + pretty (HsXExpTag e) = + myFsep $ [text "<%", pretty e, text "%>"] + +instance Pretty HsXAttr where + pretty (HsXAttr n v) = + myFsep [pretty n, char '=', pretty v] + +instance Pretty HsXName where + pretty (HsXName n) = text n + pretty (HsXDomName d n) = text d <> char ':' <> text n + +--ppLetExp :: [HsDecl] -> HsExp -> Doc +ppLetExp l b = myFsep [text "let" <+> ppBody letIndent (map pretty l), + text "in", pretty b] + +ppWith binds = nest 2 (text "with" $$$ ppBody withIndent (map pretty binds)) +withIndent = whereIndent + +--------------------- Template Haskell ------------------------- +instance Pretty HsReify where + pretty (HsReifyDecl name) = ppReify "reifyDecl" name + pretty (HsReifyType name) = ppReify "reifyType" name + pretty (HsReifyFixity name) = ppReify "reifyFixity" name + +ppReify t n = myFsep [text t, pretty n] + +instance Pretty HsBracket where + pretty (HsExpBracket e) = ppBracket "[|" e + pretty (HsPatBracket p) = ppBracket "[p|" p + pretty (HsTypeBracket t) = ppBracket "[t|" t + pretty (HsDeclBracket d) = + myFsep $ text "[d|" : map pretty d ++ [text "|]"] + +ppBracket o x = myFsep [text o, pretty x, text "|]"] + +instance Pretty HsSplice where + pretty (HsIdSplice s) = char '$' <> text s + pretty (HsParenSplice e) = + myFsep [text "$(", pretty e, char ')'] + +------------------------- 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 + prettyPrec _ (HsPRPat _ rs) = + myFsep $ text "[/" : map pretty rs ++ [text "/]"] + prettyPrec _ (HsPatTypeSig _pos pat ty) = + myFsep [pretty pat, text "::", pretty ty] + + -- Hsx + prettyPrec _ (HsPXTag _ n attrs mattr cp) = + let ap = maybe [] (return . pretty) mattr + in hcat $ -- TODO: should not introduce blanks + (myFsep $ (char '<' <> pretty n): map pretty attrs ++ ap ++ [char '>']): + prettyChildren cp ++ [myFsep $ [text " pretty n, char '>']] + prettyPrec _ (HsPXETag _ n attrs mattr) = + let ap = maybe [] (return . pretty) mattr + in myFsep $ (char '<' <> pretty n): map pretty attrs ++ ap ++ [text "/>"] + prettyPrec _ (HsPXPcdata s) = text s + prettyPrec _ (HsPXPatTag p) = + myFsep $ [text "<%", pretty p, text "%>"] + +prettyChildren :: HsPat -> [Doc] +prettyChildren p = case p of + HsPList ps -> map prettyChild ps + HsPRPat _ _ -> [pretty p] + _ -> error "The pattern representing the children of an xml pattern \ + \ should always be a list." + +prettyChild :: HsPat -> Doc +prettyChild p = case p of + HsPXTag _ _ _ _ _ -> pretty p + HsPXETag _ _ _ _ -> pretty p + HsPXPatTag _ -> pretty p + HsPXPcdata _ -> pretty p + _ -> pretty $ HsPXPatTag p + +instance Pretty HsPXAttr where + pretty (HsPXAttr n p) = + myFsep [pretty n, char '=', pretty p] + +instance Pretty HsPatField where + pretty (HsPFieldPat name pat) = + myFsep [pretty name, equals, pretty pat] + +--------------------- Regular Patterns ------------------------- + +instance Pretty HsRPat where + pretty (HsRPStar r) = pretty r <> char '*' + pretty (HsRPStarG r) = pretty r <> text "*!" + pretty (HsRPPlus r) = pretty r <> char '+' + pretty (HsRPPlusG r) = pretty r <> text "+!" + pretty (HsRPOpt r) = pretty r <> char '?' + pretty (HsRPOptG r) = pretty r <> text "?!" + pretty (HsRPEither r1 r2) = parens . myFsep $ + [pretty r1, char '|', pretty r2] + pretty (HsRPSeq rs) = + myFsep $ text "(/" : map pretty rs ++ [text "/)"] + -- special case that would otherwise be buggy + pretty (HsRPCAs n (HsRPPat (HsPIrrPat p))) = + myFsep [pretty n <> text "@:", char '~' <> pretty p] + pretty (HsRPCAs n r) = hcat [pretty n, text "@:", pretty r] + -- special case that would otherwise be buggy + pretty (HsRPAs n (HsRPPat (HsPIrrPat p))) = + myFsep [pretty n <> text "@:", char '~' <> pretty p] + pretty (HsRPAs n r) = hcat [pretty n, char '@', pretty r] + pretty (HsRPPat p) = pretty p + pretty (HsRPParen rp) = parens . pretty $ rp + +------------------------- Case bodies ------------------------- +instance Pretty HsAlt where + pretty (HsAlt _pos e gAlts binds) = + pretty e <+> pretty gAlts $$$ ppWhere binds + +instance Pretty HsGuardedAlts where + pretty (HsUnGuardedAlt e) = text "->" <+> pretty e + pretty (HsGuardedAlts altList) = myVcat . map pretty $ altList + +instance Pretty HsGuardedAlt where + pretty (HsGuardedAlt _pos guards body) = + myFsep $ char '|': (punctuate comma . map pretty $ guards) ++ [text "->", pretty body] + +------------------------- Statements in monads, guards & list comprehensions ----- +instance Pretty HsStmt where + pretty (HsGenerator _loc e from) = + pretty e <+> text "<-" <+> pretty from + pretty (HsQualifier e) = pretty e + -- two cases for lets + pretty (HsLetStmt (HsBDecls declList)) = + ppLetStmt declList + pretty (HsLetStmt (HsIPBinds bindList)) = + ppLetStmt bindList + +ppLetStmt l = text "let" $$$ ppBody letIndent (map pretty l) + +------------------------- 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 = case name of + UnQual (HsSymbol ('#':_)) -> char '(' <+> ppHsQName name <+> char ')' + _ -> 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 = case name of + HsSymbol ('#':_) -> char '(' <+> ppHsName name <+> char ')' + _ -> parensIf (isSymbolName name) (ppHsName name) + +ppHsName :: HsName -> Doc +ppHsName (HsIdent s) = text s +ppHsName (HsSymbol s) = text s + +instance Pretty HsIPName where + pretty (HsIPDup s) = char '?' <> text s + pretty (HsIPLin s) = char '%' <> text s + +instance Pretty HsIPBind where + pretty (HsIPBind _loc ipname exp) = + myFsep [pretty ipname, equals, pretty exp] + +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 pretty context), text "=>"] + +-- hacked for multi-parameter type classes +instance Pretty HsAsst where + pretty (HsClassA a ts) = myFsep $ ppHsQName a : map ppHsAType ts + pretty (HsIParam i t) = myFsep $ [pretty i, text "::", pretty t] + +------------------------- pp utils ------------------------- +maybePP :: (a -> Doc) -> Maybe a -> Doc +maybePP pp Nothing = empty +maybePP pp (Just a) = pp a + +parenList :: [Doc] -> Doc +parenList = parens . myFsepSimple . punctuate comma + +hashParenList :: [Doc] -> Doc +hashParenList = hashParens . myFsepSimple . punctuate comma + where hashParens = parens . hashes + hashes = \doc -> char '#' <> doc <> char '#' + +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 + case e of PPOffsideRule -> indent + PPSemiColon -> indentExplicit + _ -> flatBlock dl + where + indent = do{i <-fmap f getPPEnv;nest i . vcat $ dl} + indentExplicit = do {i <- fmap f getPPEnv; + nest i . prettyBlock $ 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 diff --git a/Language/Haskell/Hsx/Syntax.hs b/Language/Haskell/Hsx/Syntax.hs new file mode 100644 --- /dev/null +++ b/Language/Haskell/Hsx/Syntax.hs @@ -0,0 +1,794 @@ +{-# OPTIONS_GHC -fglasgow-exts -cpp #-} +----------------------------------------------------------------------------- +-- | +-- Module : Language.Haskell.Hsx.Syntax +-- Original : Language.Haskell.Syntax +-- Copyright : (c) Niklas Broberg 2004, +-- (c) The GHC Team, 1997-2000 +-- License : BSD-style (see the file LICENSE.txt) +-- +-- Maintainer : Niklas Broberg, d00nibro@dtek.chalmers.se +-- Stability : experimental +-- Portability : portable +-- +-- A suite of datatypes describing the abstract syntax of Haskell 98 +-- plus some extensions: +-- +-- * multi-parameter type classes with functional dependencies +-- +-- * parameters of type class assertions are unrestricted +-- +-- * 'forall' types as universal and existential quantification +-- +-- * pattern guards +-- +-- * implicit parameters +-- +-- * generalised algebraic data types +-- +-- * template haskell +-- +-- * empty data type declarations +-- +-- * unboxed tuples +-- +-- * regular patterns (HaRP) +-- +-- * HSP-style XML expressions and patterns (HSP) +-- +-- Also worth noting is that (n+k) patterns from Haskell 98 are not supported +----------------------------------------------------------------------------- + +module Language.Haskell.Hsx.Syntax ( + -- * Modules + HsModule(..), HsExportSpec(..), + HsImportDecl(..), HsImportSpec(..), HsAssoc(..), + -- * Declarations + HsDecl(..), HsBinds(..), HsIPBind(..), + HsGadtDecl(..), HsConDecl(..), HsQualConDecl(..), HsBangType(..), + HsMatch(..), HsRhs(..), HsGuardedRhs(..), + -- * Class Assertions and Contexts + HsContext, HsFunDep(..), HsAsst(..), + -- * Types + HsType(..), HsBoxed(..), + -- * Expressions + HsExp(..), HsStmt(..), HsFieldUpdate(..), + HsAlt(..), HsGuardedAlts(..), HsGuardedAlt(..), + -- * Patterns + HsPat(..), HsPatField(..), + -- * Literals + HsLiteral(..), + -- * Variables, Constructors and Operators + Module(..), HsQName(..), HsName(..), HsQOp(..), HsOp(..), + HsSpecialCon(..), HsCName(..), HsIPName(..), + + -- * Template Haskell + HsReify(..), HsBracket(..), HsSplice(..), + + -- * HaRP + HsRPat(..), + + -- * Hsx + HsXAttr(..), HsXName(..), HsPXAttr(..), + + -- * FFI + HsSafety(..), HsCallConv(..), + + -- * 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, + -- ** Special identifiers + as_name, qualified_name, hiding_name, minus_name, pling_name, dot_name, + export_name, safe_name, unsafe_name, threadsafe_name, stdcall_name, ccall_name, + -- ** 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 + +-- | This type is used to represent implicit parameter names. +data HsIPName + = HsIPDup String -- ?x + | HsIPLin String -- %x +#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] [HsQualConDecl] [HsQName] + | HsGDataDecl SrcLoc HsContext HsName [HsName] [HsGadtDecl] {-no deriving-} + | HsInfixDecl SrcLoc HsAssoc Int [HsOp] + | HsNewTypeDecl SrcLoc HsContext HsName [HsName] HsQualConDecl [HsQName] + | HsClassDecl SrcLoc HsContext HsName [HsName] [HsFunDep] [HsDecl] + | HsInstDecl SrcLoc HsContext HsQName [HsType] [HsDecl] + | HsDefaultDecl SrcLoc [HsType] + | HsSpliceDecl SrcLoc HsSplice + | HsTypeSig SrcLoc [HsName] HsType + | HsFunBind [HsMatch] + | HsPatBind SrcLoc HsPat HsRhs {-where-} HsBinds + | HsForImp SrcLoc HsCallConv HsSafety String HsName HsType + | HsForExp SrcLoc HsCallConv String HsName HsType +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +data HsBinds + = HsBDecls [HsDecl] + | HsIPBinds [HsIPBind] +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +data HsIPBind = HsIPBind SrcLoc HsIPName HsExp +#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-} HsBinds +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +data HsQualConDecl + = HsQualConDecl SrcLoc + {-forall-} [HsName] {- . -} HsContext + {- => -} HsConDecl +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +data HsGadtDecl + = HsGadtDecl SrcLoc HsName HsType +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +-- | Declaration of a data constructor. +data HsConDecl + = HsConDecl HsName [HsBangType] + -- ^ ordinary data constructor + | HsRecDecl 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 [HsStmt] HsExp +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +-- | A type qualified with a context. +-- An unqualified type has an empty context. + +data HsType + = HsTyForall + (Maybe [HsName]) + HsContext + HsType + | HsTyFun HsType HsType -- ^ function type + | HsTyTuple HsBoxed [HsType] -- ^ tuple type, possibly boxed + | HsTyApp HsType HsType -- ^ application of a type constructor + | HsTyVar HsName -- ^ type variable + | HsTyCon HsQName -- ^ named type or type constructor + | HsTyPred HsAsst -- ^ assertion of an implicit parameter + | HsTyInfix HsType HsQName HsType -- ^ infix type constructor +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +data HsBoxed = Boxed | Unboxed +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + + +-- | A functional dependency, given on the form +-- l1 l2 ... ln -> r2 r3 .. rn +data HsFunDep + = HsFunDep [HsName] [HsName] +#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. +-- Also extended with support for implicit parameters. +data HsAsst = HsClassA HsQName [HsType] + | HsIParam HsIPName HsType +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +-- | /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 + | HsIPVar HsIPName -- ^ implicit parameter 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 HsBinds HsExp -- ^ local declarations with @let@ + | HsDLet [HsIPBind] HsExp -- ^ local declarations of implicit parameters (hugs) + | HsWith HsExp [HsIPBind] -- ^ local declarations of implicit parameters + | 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. + | HsMDo [HsStmt] -- ^ @mdo@-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 HsType + -- ^ expression type signature + | HsAsPat HsName HsExp -- ^ patterns only + | HsWildCard -- ^ patterns only + | HsIrrPat HsExp -- ^ patterns only + +-- HaRP + | HsRPats SrcLoc [HsExp] -- ^ regular patterns only + | HsSeqRP [HsExp] -- ^ regular patterns only + | HsStarRP HsExp -- ^ regular patterns only + | HsStarGRP HsExp -- ^ regular patterns only + | HsPlusRP HsExp -- ^ regular patterns only + | HsPlusGRP HsExp -- ^ regular patterns only + | HsOptRP HsExp -- ^ regular patterns only + | HsOptGRP HsExp -- ^ regular patterns only + | HsEitherRP HsExp HsExp -- ^ regular patterns only + | HsCAsRP HsName HsExp -- ^ regular patterns only + +-- Template Haskell + | HsReifyExp HsReify + | HsBracketExp HsBracket + | HsSpliceExp HsSplice + +-- Hsx + | HsXTag SrcLoc HsXName [HsXAttr] (Maybe HsExp) [HsExp] + | HsXETag SrcLoc HsXName [HsXAttr] (Maybe HsExp) + | HsXPcdata String + | HsXExpTag HsExp +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +data HsXName + = HsXName String -- @ /exp/ + | HsGuardedAlts [HsGuardedAlt] -- ^ /gdpat/ +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +-- | A guarded alternative @|@ /stmt/, ... , /stmt/ @->@ /exp/. +data HsGuardedAlt + = HsGuardedAlt SrcLoc [HsStmt] 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) + +as_name, qualified_name, hiding_name, minus_name, pling_name, dot_name :: HsName +as_name = HsIdent "as" +qualified_name = HsIdent "qualified" +hiding_name = HsIdent "hiding" +minus_name = HsSymbol "-" +pling_name = HsSymbol "!" +dot_name = HsSymbol "." + +export_name, safe_name, unsafe_name, threadsafe_name, stdcall_name, ccall_name :: HsName +export_name = HsIdent "export" +safe_name = HsIdent "safe" +unsafe_name = HsIdent "unsafe" +threadsafe_name = HsIdent "threadsafe" +stdcall_name = HsIdent "stdcall" +ccall_name = HsIdent "ccall" + +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) diff --git a/Language/Haskell/Hsx/Transform.hs b/Language/Haskell/Hsx/Transform.hs new file mode 100644 --- /dev/null +++ b/Language/Haskell/Hsx/Transform.hs @@ -0,0 +1,1780 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Language.Haskell.Harp.Tranform +-- Copyright : (c) Niklas Broberg 2004, +-- License : BSD-style (see the file LICENSE.txt) +-- +-- Maintainer : Niklas Broberg, d00nibro@dtek.chalmers.se +-- Stability : experimental +-- Portability : portable +-- +-- Functions for transforming abstract Haskell code extended with regular +-- patterns into semantically equivalent normal abstract Haskell code. In +-- other words, we transform away regular patterns. +----------------------------------------------------------------------------- + +module Language.Haskell.Hsx.Transform ( + transform -- :: HsModule -> HsModule + ) where + +import Language.Haskell.Hsx.Syntax +import Language.Haskell.Hsx.Build +import Data.List (union) + +import Debug.Trace (trace) + +----------------------------------------------------------------------------- +-- A monad for threading a boolean value through the boilerplate code, +-- to signal whether a transformation has taken place or not. + +newtype HsxM a = MkHsxM (HsxState -> (a, HsxState)) + +instance Monad HsxM where + return x = MkHsxM (\s -> (x,s)) + (MkHsxM f) >>= k = MkHsxM (\s -> let (a, s') = f s + (MkHsxM f') = k a + in f' s') + +getHsxState :: HsxM HsxState +getHsxState = MkHsxM (\s -> (s, s)) + +setHsxState :: HsxState -> HsxM () +setHsxState s = MkHsxM (\_ -> ((),s)) + +instance Functor HsxM where + fmap f hma = do a <- hma + return $ f a + +----- + +type HsxState = (Bool, Bool) + +initHsxState :: HsxState +initHsxState = (False, False) + +setHarpTransformed :: HsxM () +setHarpTransformed = + do (_,x) <- getHsxState + setHsxState (True,x) + +setXmlTransformed :: HsxM () +setXmlTransformed = + do (h,_) <- getHsxState + setHsxState (h,True) + +runHsxM :: HsxM a -> (a, (Bool, Bool)) +runHsxM (MkHsxM f) = f initHsxState + +----------------------------------------------------------------------------- +-- Traversing and transforming the syntax tree + + +-- | Transform away occurences of regular patterns from an abstract +-- Haskell module, preserving semantics. +transform :: HsModule -> HsModule +transform (HsModule s m mes is decls) = + let (decls', (harp, hsx)) = runHsxM $ mapM transformDecl decls + -- We may need to add an import for Match.hs that defines the matcher monad + imps1 = if harp + then (:) $ HsImportDecl s match_mod True + (Just match_qual_mod) + Nothing + else id + imps2 = {- if hsx + then (:) $ HsImportDecl s hsx_data_mod False + Nothing + Nothing + else -} id -- we no longer want to import HSP.Data + in HsModule s m mes (imps1 $ imps2 is) decls' + +----------------------------------------------------------------------------- +-- Declarations + +-- | Transform a declaration by transforming subterms that could +-- contain regular patterns. +transformDecl :: HsDecl -> HsxM HsDecl +transformDecl d = case d of + -- Pattern binds can contain regular patterns in the pattern being bound + -- as well as on the right-hand side and in declarations in a where clause + HsPatBind srcloc pat rhs decls -> do + -- Preserve semantics of irrefutable regular patterns by postponing + -- their evaluation to a let-expression on the right-hand side + let ([pat'], rnpss) = unzip $ renameIrrPats [pat] + -- Transform the pattern itself + ([pat''], attrGuards, guards, decls'') <- transformPatterns [pat'] + -- Transform the right-hand side, and add any generated guards + -- and let expressions to it + rhs' <- mkRhs srcloc (attrGuards ++ guards) (concat rnpss) rhs + -- Transform declarations in the where clause, adding any generated + -- declarations to it + decls' <- case decls of + HsBDecls ds -> do ds' <- transformLetDecls ds + return $ HsBDecls $ decls'' ++ ds' + _ -> error "Cannot bind implicit parameters in the \ + \ \'where\' clause of a function using regular patterns." + return $ HsPatBind srcloc pat'' rhs' decls' + + -- Function binds can contain regular patterns in their matches + HsFunBind ms -> fmap HsFunBind $ mapM transformMatch ms + -- Instance declarations can contain regular patterns in the + -- declarations of functions inside it + HsInstDecl s c n ts decls -> + fmap (HsInstDecl s c n ts) $ mapM transformDecl decls + -- Class declarations can contain regular patterns in the + -- declarations of automatically instantiated functions + HsClassDecl s c n ns ds decls -> + fmap (HsClassDecl s c n ns ds) $ mapM transformDecl decls + -- Type signatures, type, newtype or data declarations, infix declarations + -- and default declarations; none can contain regular patterns + _ -> return d + + +-- | Transform a function "match" by generating pattern guards and +-- declarations representing regular patterns in the argument list. +-- Subterms, such as guards and the right-hand side, are also traversed +-- transformed. +transformMatch :: HsMatch -> HsxM HsMatch +transformMatch (HsMatch srcloc name pats rhs decls) = do + -- Preserve semantics of irrefutable regular patterns by postponing + -- their evaluation to a let-expression on the right-hand side + let (pats', rnpss) = unzip $ renameIrrPats pats + -- Transform the patterns that stand as arguments to the function + (pats'', attrGuards, guards, decls'') <- transformPatterns pats' + -- Transform the right-hand side, and add any generated guards + -- and let expressions to it + rhs' <- mkRhs srcloc (attrGuards ++ guards) (concat rnpss) rhs + -- Transform declarations in the where clause, adding any generated + -- declarations to it + decls' <- case decls of + HsBDecls ds -> do ds' <- transformLetDecls ds + return $ HsBDecls $ decls'' ++ ds' + _ -> error "Cannot bind implicit parameters in the \ + \ \'where\' clause of a function using regular patterns." + + return $ HsMatch srcloc name pats'' rhs' decls' +-- | Transform and update guards and right-hand side of a function or +-- pattern binding. The supplied list of guards is prepended to the +-- original guards, and subterms are traversed and transformed. +mkRhs :: SrcLoc -> [Guard] -> [(HsName, HsPat)] -> HsRhs -> HsxM HsRhs +mkRhs srcloc guards rnps (HsUnGuardedRhs rhs) = do + -- Add the postponed patterns to the right-hand side by placing + -- them in a let-expression to make them lazily evaluated. + -- Then transform the whole right-hand side as an expression. + rhs' <- transformExp $ addLetDecls srcloc rnps rhs + case guards of + -- There were no guards before, and none should be added, + -- so we still have an unguarded right-hand side + [] -> return $ HsUnGuardedRhs rhs' + -- There are guards to add. These should be added as pattern + -- guards, i.e. as statements. + _ -> return $ HsGuardedRhss [HsGuardedRhs srcloc (map mkStmtGuard guards) rhs'] +mkRhs _ guards rnps (HsGuardedRhss gdrhss) = fmap HsGuardedRhss $ mapM (mkGRhs guards rnps) gdrhss + where mkGRhs :: [Guard] -> [(HsName, HsPat)] -> HsGuardedRhs -> HsxM HsGuardedRhs + mkGRhs gs rnps (HsGuardedRhs s oldgs rhs) = do + -- Add the postponed patterns to the right-hand side by placing + -- them in a let-expression to make them lazily evaluated. + -- Then transform the whole right-hand side as an expression. + rhs' <- transformExp $ addLetDecls s rnps rhs + -- Now there are guards, so first we need to transform those + oldgs' <- fmap concat $ mapM (transformStmt Guard) oldgs + -- ... and then prepend the newly generated ones, as statements + return $ HsGuardedRhs s ((map mkStmtGuard gs) ++ oldgs') rhs' + +-- | Place declarations of postponed regular patterns in a let-expression to +-- make them lazy, in order to make them behave as irrefutable patterns. +addLetDecls :: SrcLoc -> [(HsName, HsPat)] -> HsExp -> HsExp +addLetDecls s [] e = e -- no declarations to add +addLetDecls s rnps e = + -- Place all postponed patterns in the same let-expression + letE (map (mkDecl s) rnps) e + +-- | Make pattern binds from postponed regular patterns +mkDecl :: SrcLoc -> (HsName, HsPat) -> HsDecl +mkDecl srcloc (n,p) = patBind srcloc p (var n) + +------------------------------------------------------------------------------------ +-- Expressions + +-- | Transform expressions by traversing subterms. +-- Of special interest are expressions that contain patterns as subterms, +-- i.e. @let@, @case@ and lambda expressions, and also list comprehensions +-- and @do@-expressions. All other expressions simply transform their +-- sub-expressions, if any. +-- Of special interest are of course also any xml expressions. +transformExp :: HsExp -> HsxM HsExp +transformExp e = case e of + -- A standard xml tag should be transformed into an element of the + -- XML datatype. Attributes should be made into a set of mappings, + -- and children should be transformed. + HsXTag _ name attrs mattr cs -> do + -- Hey Pluto, look, we have XML in our syntax tree! + setXmlTransformed + let -- ... make tuples of the attributes + as = map mkAttr attrs + -- ... transform the children + cs' <- mapM transformChild cs + -- ... and lift the values into the XML datatype. + return $ paren $ metaMkTag name as mattr cs' + + where -- | Transform expressions appearing in child position of an xml tag. + -- Expressions are first transformed, then wrapped in a call to + -- @toXml@. + transformChild :: HsExp -> HsxM HsExp + transformChild e = do + -- Transform the expression + te <- transformExp e + -- ... and apply the overloaded toXMLs to it + return $ metaToXmls te + + -- An empty xml tag should be transformed just as a standard tag, + -- only that there are no children, + HsXETag _ name attrs mattr -> do + -- ... 'tis the season to be jolly, falalalalaaaa.... + setXmlTransformed + let -- ... make tuples of the attributes + as = map mkAttr attrs + -- ... and lift the values into the XML datatype. + return $ paren $ metaMkETag name as mattr + -- PCDATA should be lifted as a string into the XML datatype. + HsXPcdata pcdata -> do setXmlTransformed + return $ metaMkPcdata pcdata + -- Escaped expressions should be treated as just expressions. + HsXExpTag e -> do setXmlTransformed + transformExp e + + -- Patterns as arguments to a lambda expression could be regular, + -- but we cannot put the evaluation here since a lambda expression + -- can have neither guards nor a where clause. Thus we must postpone + -- them to a case expressions on the right-hand side. + HsLambda s pats rhs -> do + let -- First rename regular patterns + (ps, rnpss) = unzip $ renameRPats pats + -- ... group them up to one big tuple + (rns, rps) = unzip (concat rnpss) + alt1 = alt s (pTuple rps) rhs + texp = varTuple rns + -- ... and put it all in a case expression, which + -- can then be transformed in the normal way. + e = if null rns then rhs else caseE texp [alt1] + rhs' <- transformExp e + return $ HsLambda s ps rhs' + -- A let expression can contain regular patterns in the declarations, + -- or in the expression that makes up the body of the let. + HsLet (HsBDecls ds) e -> do + -- Declarations appearing in a let expression must be transformed + -- in a special way due to scoping, see later documentation. + -- The body is transformed as a normal expression. + ds' <- transformLetDecls ds + e' <- transformExp e + return $ letE ds' e' + -- Bindings of implicit parameters can appear either in ordinary let + -- expressions (GHC), in dlet expressions (Hugs) or in a with clause + -- (both). Such bindings are transformed in a special way. The body + -- is transformed as a normal expression in all cases. + HsLet (HsIPBinds is) e -> do + is' <- mapM transformIPBind is + e' <- transformExp e + return $ HsLet (HsIPBinds is') e' + HsDLet ipbs e -> do + ipbs' <- mapM transformIPBind ipbs + e' <- transformExp e + return $ HsDLet ipbs' e' + HsWith e ipbs -> do + ipbs' <- mapM transformIPBind ipbs + e' <- transformExp e + return $ HsWith e' ipbs' + -- A case expression can contain regular patterns in the expression + -- that is the subject of the casing, or in either of the alternatives. + HsCase e alts -> do + e' <- transformExp e + alts' <- mapM transformAlt alts + return $ HsCase e' alts' + -- A do expression can contain regular patterns in its statements. + HsDo stmts -> do + stmts' <- fmap concat $ mapM (transformStmt Do) stmts + return $ HsDo stmts' + HsMDo stmts -> do + stmts' <- fmap concat $ mapM (transformStmt Do) stmts + return $ HsMDo stmts' + -- A list comprehension can contain regular patterns in the result + -- expression, or in any of its statements. + HsListComp e stmts -> do + e' <- transformExp e + stmts' <- fmap concat $ mapM (transformStmt ListComp) stmts + return $ HsListComp e' stmts' + -- All other expressions simply transform their immediate subterms. + HsInfixApp e1 op e2 -> transform2exp e1 e2 + (\e1 e2 -> HsInfixApp e1 op e2) + HsApp e1 e2 -> transform2exp e1 e2 HsApp + HsNegApp e -> fmap HsNegApp $ transformExp e + HsIf e1 e2 e3 -> transform3exp e1 e2 e3 HsIf + HsTuple es -> fmap HsTuple $ mapM transformExp es + HsList es -> fmap HsList $ mapM transformExp es + HsParen e -> fmap HsParen $ transformExp e + HsLeftSection e op -> do e' <- transformExp e + return $ HsLeftSection e' op + HsRightSection op e -> fmap (HsRightSection op) $ transformExp e + HsRecConstr n fus -> fmap (HsRecConstr n) $ mapM transformFieldUpdate fus + HsRecUpdate e fus -> do e' <- transformExp e + fus' <- mapM transformFieldUpdate fus + return $ HsRecUpdate e' fus' + HsEnumFrom e -> fmap HsEnumFrom $ transformExp e + HsEnumFromTo e1 e2 -> transform2exp e1 e2 HsEnumFromTo + HsEnumFromThen e1 e2 -> transform2exp e1 e2 HsEnumFromThen + HsEnumFromThenTo e1 e2 e3 -> transform3exp e1 e2 e3 HsEnumFromThenTo + HsExpTypeSig s e t -> do e' <- transformExp e + return $ HsExpTypeSig s e' t + _ -> return e -- Warning! Does not work with TH bracketed expressions ([| ... |]) + + where transformFieldUpdate :: HsFieldUpdate -> HsxM HsFieldUpdate + transformFieldUpdate (HsFieldUpdate n e) = + fmap (HsFieldUpdate n) $ transformExp e + + transform2exp :: HsExp -> HsExp -> (HsExp -> HsExp -> HsExp) -> HsxM HsExp + transform2exp e1 e2 f = do e1' <- transformExp e1 + e2' <- transformExp e2 + return $ f e1' e2' + + transform3exp :: HsExp -> HsExp -> HsExp -> (HsExp -> HsExp -> HsExp -> HsExp) -> HsxM HsExp + transform3exp e1 e2 e3 f = do e1' <- transformExp e1 + e2' <- transformExp e2 + e3' <- transformExp e3 + return $ f e1' e2' e3' + + mkAttr :: HsXAttr -> HsExp + mkAttr (HsXAttr name e) = + paren (metaMkName name `metaAssign` e) + + +-- | Transform pattern bind declarations inside a @let@-expression by transforming +-- subterms that could appear as regular patterns, as well as transforming the bound +-- pattern itself. The reason we need to do this in a special way is scoping, i.e. +-- in the expression @let a | Just b <- match a = list in b@ the variable b will not +-- be in scope after the @in@. And besides, we would be on thin ice even if it was in +-- scope since we are referring to the pattern being bound in the guard that will +-- decide if the pattern will be bound... yikes, why does Haskell allow guards on +-- pattern binds to refer to the patterns being bound, could that ever lead to anything +-- but an infinite loop?? +transformLetDecls :: [HsDecl] -> HsxM [HsDecl] +transformLetDecls ds = do + -- We need to rename regular patterns in pattern bindings, since we need to + -- separate the generated declaration sets. This since we need to add them not + -- to the actual binding but rather to the declaration that will be the guard + -- of the binding. + let ds' = renameLetDecls ds + transformLDs 0 0 ds' + where transformLDs :: Int -> Int -> [HsDecl] -> HsxM [HsDecl] + transformLDs k l ds = case ds of + [] -> return [] + (d:ds) -> case d of + HsPatBind srcloc pat rhs decls -> do + -- We need to transform all pattern bindings in a set of + -- declarations in the same context w.r.t. generating fresh + -- variable names, since they will all be in scope at the same time. + ([pat'], ags, gs, ws, k', l') <- runTrFromTo k l (trPatterns [pat]) + decls' <- case decls of + -- Any declarations already in place should be left where they + -- are since they probably refer to the generating right-hand + -- side of the pattern bind. If they don't, we're in trouble... + HsBDecls decls -> fmap HsBDecls $ transformLetDecls decls + -- If they are implicit parameter bindings we simply transform + -- them as such. + HsIPBinds decls -> fmap HsIPBinds $ mapM transformIPBind decls + -- The generated guard, if any, should be a declaration, and the + -- generated declarations should be associated with it. + let gs' = case gs of + [] -> [] + [g] -> [mkDeclGuard g ws] + _ -> error "This should not happen since we \ + \ have called renameLetDecls already!" + -- Generated attribute guards should also be added as declarations, + -- but with no where clauses. + ags' = map (flip mkDeclGuard $ []) ags + -- We must transform the right-hand side as well, but there are + -- no new guards, nor any postponed patterns, to supply at this time. + rhs' <- mkRhs srcloc [] [] rhs + -- ... and then we should recurse with the new gensym argument. + ds' <- transformLDs k' l' ds + -- The generated guards, which should be at most one, should be + -- added as declarations rather than as guards due to the + -- scoping issue described above. + return $ (HsPatBind srcloc pat' rhs' decls') : ags' ++ gs' ++ ds' + + -- We only need to treat pattern binds separately, other declarations + -- can be transformed normally. + d -> do d' <- transformDecl d + ds' <- transformLDs k l ds + return $ d':ds' + + +-- | Transform binding of implicit parameters by transforming the expression on the +-- right-hand side. The left-hand side can only be an implicit parameter, so no +-- regular patterns there... +transformIPBind :: HsIPBind -> HsxM HsIPBind +transformIPBind (HsIPBind s n e) = + fmap (HsIPBind s n) $ transformExp e + +------------------------------------------------------------------------------------ +-- Statements of various kinds + +-- | A simple annotation datatype for statement contexts. +data StmtType = Do | Guard | ListComp + +-- | Transform statements by traversing and transforming subterms. +-- Since generator statements have slightly different semantics +-- depending on their context, statements are annotated with their +-- context to ensure that the semantics of the resulting statement +-- sequence is correct. The return type is a list since generated +-- guards will be added as statements on the same level as the +-- statement to be transformed. +transformStmt :: StmtType -> HsStmt -> HsxM [HsStmt] +transformStmt t s = case s of + -- Generators can have regular patterns in the result pattern on the + -- left-hand side and in the generating expression. + HsGenerator s p e -> do + let -- We need to treat generated guards differently depending + -- on the context of the statement. + guardFun = case t of + Do -> monadify + ListComp -> monadify + Guard -> mkStmtGuard + -- Preserve semantics of irrefutable regular patterns by postponing + -- their evaluation to a let-expression on the right-hand side + ([p'], rnpss) = unzip $ renameIrrPats [p] + -- Transform the pattern itself + ([p''], ags, gs, ds) <- transformPatterns [p'] + -- Put the generated declarations in a let-statement + let lt = case ds of + [] -> [] + _ -> [letStmt ds] + -- Perform the designated trick on the generated guards. + gs' = map guardFun (ags ++ gs) + -- Add the postponed patterns to the right-hand side by placing + -- them in a let-expression to make them lazily evaluated. + -- Then transform the whole right-hand side as an expression. + e' <- transformExp $ addLetDecls s (concat rnpss) e + return $ HsGenerator s p'' e':lt ++ gs' + where monadify :: Guard -> HsStmt + -- To monadify is to create a statement guard, only that the + -- generation must take place in a monad, so we need to "return" + -- the value gotten from the guard. + monadify (s,p,e) = genStmt s p (metaReturn $ paren e) + -- Qualifiers are simply wrapped expressions and are treated as such. + HsQualifier e -> fmap (\e -> [HsQualifier $ e]) $ transformExp e + -- Let statements suffer from the same problem as let expressions, so + -- the declarations should be treated in the same special way. + HsLetStmt (HsBDecls ds) -> + fmap (\ds -> [letStmt ds]) $ transformLetDecls ds + -- If the bindings are of implicit parameters we simply transform them as such. + HsLetStmt (HsIPBinds is) -> + fmap (\is -> [HsLetStmt (HsIPBinds is)]) $ mapM transformIPBind is + + +------------------------------------------------------------------------------------------ +-- Case alternatives + +-- | Transform alternatives in a @case@-expression. Patterns are +-- transformed, while other subterms are traversed further. +transformAlt :: HsAlt -> HsxM HsAlt +transformAlt (HsAlt srcloc pat rhs decls) = do + -- Preserve semantics of irrefutable regular patterns by postponing + -- their evaluation to a let-expression on the right-hand side + let ([pat'], rnpss) = unzip $ renameIrrPats [pat] + -- Transform the pattern itself + ([pat''], attrGuards, guards, decls'') <- transformPatterns [pat'] + -- Transform the right-hand side, and add any generated guards + -- and let expressions to it. + rhs' <- mkGAlts srcloc (attrGuards ++ guards) (concat rnpss) rhs + -- Transform declarations in the where clause, adding any generated + -- declarations to it. + decls' <- case decls of + HsBDecls ds -> do ds' <- mapM transformDecl ds + return $ HsBDecls $ decls'' ++ ds + _ -> error "Cannot bind implicit parameters in the \ + \ \'where\' clause of a function using regular patterns." + + return $ HsAlt srcloc pat'' rhs' decls' + + -- Transform and update guards and right-hand side of a case-expression. + -- The supplied list of guards is prepended to the original guards, and + -- subterms are traversed and transformed. + where mkGAlts :: SrcLoc -> [Guard] -> [(HsName, HsPat)] -> HsGuardedAlts -> HsxM HsGuardedAlts + mkGAlts s guards rnps (HsUnGuardedAlt rhs) = do + -- Add the postponed patterns to the right-hand side by placing + -- them in a let-expression to make them lazily evaluated. + -- Then transform the whole right-hand side as an expression. + rhs' <- transformExp $ addLetDecls s rnps rhs + case guards of + -- There were no guards before, and none should be added, + -- so we still have an unguarded right-hand side + [] -> return $ HsUnGuardedAlt rhs' + -- There are guards to add. These should be added as pattern + -- guards, i.e. as statements. + _ -> return $ HsGuardedAlts [HsGuardedAlt s (map mkStmtGuard guards) rhs'] + mkGAlts s gs rnps (HsGuardedAlts galts) = + fmap HsGuardedAlts $ mapM (mkGAlt gs rnps) galts + where mkGAlt :: [Guard] -> [(HsName, HsPat)] -> HsGuardedAlt -> HsxM HsGuardedAlt + mkGAlt gs rnps (HsGuardedAlt s oldgs rhs) = do + -- Add the postponed patterns to the right-hand side by placing + -- them in a let-expression to make them lazily evaluated. + -- Then transform the whole right-hand side as an expression. + do rhs' <- transformExp $ addLetDecls s rnps rhs + -- Now there are guards, so first we need to transform those + oldgs' <- fmap concat $ mapM (transformStmt Guard) oldgs + -- ... and then prepend the newly generated ones, as statements + return $ HsGuardedAlt s ((map mkStmtGuard gs) ++ oldgs') rhs' + +---------------------------------------------------------------------------------- +-- Guards + +-- In some places, a guard will be a declaration instead of the +-- normal statement, so we represent it in a generic fashion. +type Guard = (SrcLoc, HsPat, HsExp) + +mkStmtGuard :: Guard -> HsStmt +mkStmtGuard (s, p, e) = genStmt s p e + +mkDeclGuard :: Guard -> [HsDecl] -> HsDecl +mkDeclGuard (s, p, e) ds = patBindWhere s p e ds + +---------------------------------------------------------------------------------- +-- Rewriting expressions before transformation. +-- Done in a monad for gensym capability. + +newtype RN a = RN (RNState -> (a, RNState)) + +type RNState = Int + +initRNState = 0 + +instance Monad RN where + return a = RN $ \s -> (a,s) + (RN f) >>= k = RN $ \s -> let (a,s') = f s + (RN g) = k a + in g s' + +instance Functor RN where + fmap f rna = do a <- rna + return $ f a + + +runRename :: RN a -> a +runRename (RN f) = let (a,_) = f initRNState + in a + +getRNState :: RN RNState +getRNState = RN $ \s -> (s,s) + +setRNState :: RNState -> RN () +setRNState s = RN $ \_ -> ((), s) + +genVarName :: RN HsName +genVarName = do + k <- getRNState + setRNState $ k+1 + return $ name $ "harp_rnvar" ++ show k + + +type NameBind = (HsName, HsPat) + +-- Some generic functions on monads for traversing subterms + +rename1pat :: a -> (b -> c) -> (a -> RN (b, [d])) -> RN (c, [d]) +rename1pat p f rn = do (q, ms) <- rn p + return (f q, ms) + +rename2pat :: a -> a -> (b -> b -> c) -> (a -> RN (b, [d])) -> RN (c, [d]) +rename2pat p1 p2 f rn = do (q1, ms1) <- rn p1 + (q2, ms2) <- rn p2 + return $ (f q1 q2, ms1 ++ ms2) + +renameNpat :: [a] -> ([b] -> c) -> (a -> RN (b, [d])) -> RN (c, [d]) +renameNpat ps f rn = do (qs, mss) <- fmap unzip $ mapM rn ps + return (f qs, concat mss) + + + + +-- | Generate variables as placeholders for any regular patterns, in order +-- to place their evaluation elsewhere. We must likewise move the evaluation +-- of Tags because attribute lookups are force evaluation. +renameRPats :: [HsPat] -> [(HsPat, [NameBind])] +renameRPats ps = runRename $ mapM renameRP ps + +renameRP :: HsPat -> RN (HsPat, [NameBind]) +renameRP p = case p of + -- We must rename regular patterns and Tag expressions + HsPRPat _ _ -> rename p + HsPXTag _ _ _ _ _ -> rename p + HsPXETag _ _ _ _ -> rename p + -- The rest of the rules simply try to rename regular patterns in + -- their immediate subpatterns. + HsPNeg p -> rename1pat p HsPNeg renameRP + HsPInfixApp p1 n p2 -> rename2pat p1 p2 + (\p1 p2 -> HsPInfixApp p1 n p2) + renameRP + HsPApp n ps -> renameNpat ps (HsPApp n) renameRP + HsPTuple ps -> renameNpat ps HsPTuple renameRP + HsPList ps -> renameNpat ps HsPList renameRP + HsPParen p -> rename1pat p HsPParen renameRP + HsPRec n pfs -> renameNpat pfs (HsPRec n) renameRPf + HsPAsPat n p -> rename1pat p (HsPAsPat n) renameRP + HsPIrrPat p -> rename1pat p HsPIrrPat renameRP + HsPXPatTag p -> rename1pat p HsPXPatTag renameRP + HsPatTypeSig s p t -> rename1pat p (\p -> HsPatTypeSig s p t) renameRP + _ -> return (p, []) + + where renameRPf :: HsPatField -> RN (HsPatField, [NameBind]) + renameRPf (HsPFieldPat n p) = rename1pat p (HsPFieldPat n) renameRP + + renameAttr :: HsPXAttr -> RN (HsPXAttr, [NameBind]) + renameAttr (HsPXAttr s p) = rename1pat p (HsPXAttr s) renameRP + + rename :: HsPat -> RN (HsPat, [NameBind]) + rename p = do -- Generate a fresh variable + n <- genVarName + -- ... and return that, along with the association of + -- the variable with the old pattern + return (pvar n, [(n,p)]) + +-- | Rename declarations appearing in @let@s or @where@ clauses. +renameLetDecls :: [HsDecl] -> [HsDecl] +renameLetDecls ds = + let -- Rename all regular patterns bound in pattern bindings. + (ds', smss) = unzip $ runRename $ mapM renameLetDecl ds + -- ... and then generate declarations for the associations + gs = map (\(s,n,p) -> mkDecl s (n,p)) (concat smss) + -- ... which should be added to the original list of declarations. + in ds' ++ gs + + where renameLetDecl :: HsDecl -> RN (HsDecl, [(SrcLoc, HsName, HsPat)]) + renameLetDecl d = case d of + -- We need only bother about pattern bindings. + HsPatBind srcloc pat rhs decls -> do + -- Rename any regular patterns that appear in the + -- pattern being bound. + (p, ms) <- renameRP pat + let sms = map (\(n,p) -> (srcloc, n, p)) ms + return $ (HsPatBind srcloc p rhs decls, sms) + _ -> return (d, []) + + +-- | Move irrefutable regular patterns into a @let@-expression instead, +-- to make sure that the semantics of @~@ are preserved. +renameIrrPats :: [HsPat] -> [(HsPat, [NameBind])] +renameIrrPats ps = runRename (mapM renameIrrP ps) + +renameIrrP :: HsPat -> RN (HsPat, [(HsName, HsPat)]) +renameIrrP p = case p of + -- We should rename any regular pattern appearing + -- inside an irrefutable pattern. + HsPIrrPat p -> do (q, ms) <- renameRP p + return $ (HsPIrrPat q, ms) + -- The rest of the rules simply try to rename regular patterns in + -- irrefutable patterns in their immediate subpatterns. + HsPNeg p -> rename1pat p HsPNeg renameIrrP + HsPInfixApp p1 n p2 -> rename2pat p1 p2 + (\p1 p2 -> HsPInfixApp p1 n p2) + renameIrrP + HsPApp n ps -> renameNpat ps (HsPApp n) renameIrrP + HsPTuple ps -> renameNpat ps HsPTuple renameIrrP + HsPList ps -> renameNpat ps HsPList renameIrrP + HsPParen p -> rename1pat p HsPParen renameIrrP + HsPRec n pfs -> renameNpat pfs (HsPRec n) renameIrrPf + HsPAsPat n p -> rename1pat p (HsPAsPat n) renameIrrP + HsPatTypeSig s p t -> rename1pat p (\p -> HsPatTypeSig s p t) renameIrrP + + -- Hsx + HsPXTag s n attrs mat p -> do (attrs', nss) <- fmap unzip $ mapM renameIrrAttr attrs + (mat', ns1) <- case mat of + Nothing -> return (Nothing, []) + Just at -> do (at', ns) <- renameIrrP at + return (Just at', ns) + (q, ns) <- rename1pat p (HsPXTag s n attrs' mat') renameIrrP + return (q, concat nss ++ ns1 ++ ns) + HsPXETag s n attrs mat -> do (as, nss) <- fmap unzip $ mapM renameIrrAttr attrs + (mat', ns1) <- case mat of + Nothing -> return (Nothing, []) + Just at -> do (at', ns) <- renameIrrP at + return (Just at', ns) + return $ (HsPXETag s n as mat', concat nss ++ ns1) + HsPXPatTag p -> rename1pat p HsPXPatTag renameIrrP + -- End Hsx + + _ -> return (p, []) + + where renameIrrPf :: HsPatField -> RN (HsPatField, [NameBind]) + renameIrrPf (HsPFieldPat n p) = rename1pat p (HsPFieldPat n) renameIrrP + + renameIrrAttr :: HsPXAttr -> RN (HsPXAttr, [NameBind]) + renameIrrAttr (HsPXAttr s p) = rename1pat p (HsPXAttr s) renameIrrP +----------------------------------------------------------------------------------- +-- Transforming Patterns: the real stuff + +-- | Transform several patterns in the same context, thereby +-- generating any code for matching regular patterns. +transformPatterns :: [HsPat] -> HsxM ([HsPat], [Guard], [Guard], [HsDecl]) +transformPatterns ps = runTr (trPatterns ps) + +--------------------------------------------------- +-- The transformation monad + +type State = (Int, Int, Int, [Guard], [Guard], [HsDecl]) + +newtype Tr a = Tr (State -> HsxM (a, State)) + +instance Monad Tr where + return a = Tr $ \s -> return (a, s) + (Tr f) >>= k = Tr $ \s -> + do (a, s') <- f s + let (Tr f') = k a + f' s' + +instance Functor Tr where + fmap f tra = tra >>= (return . f) + +liftTr :: HsxM a -> Tr a +liftTr hma = Tr $ \s -> do a <- hma + return (a, s) + +initState = initStateFrom 0 0 + +initStateFrom k l = (0, k, l, [], [], []) + +runTr :: Tr a -> HsxM (a, [Guard], [Guard], [HsDecl]) +runTr (Tr f) = do (a, (_,_,_,gs1,gs2,ds)) <- f initState + return (a, reverse gs1, reverse gs2, reverse ds) + + +runTrFromTo :: Int -> Int -> Tr a -> HsxM (a, [Guard], [Guard], [HsDecl], Int, Int) +runTrFromTo k l (Tr f) = do (a, (_,k',l',gs1,gs2,ds)) <- f $ initStateFrom k l + return (a, reverse gs1, reverse gs2, reverse ds, k', l') + + +-- manipulating the state +getState :: Tr State +getState = Tr $ \s -> return (s,s) + +setState :: State -> Tr () +setState s = Tr $ \_ -> return ((),s) + +updateState :: (State -> (a,State)) -> Tr a +updateState f = do s <- getState + let (a,s') = f s + setState s' + return a + +-- specific state manipulating functions +pushGuard :: SrcLoc -> HsPat -> HsExp -> Tr () +pushGuard s p e = updateState $ \(n,m,a,gs1,gs2,ds) -> ((),(n,m,a,gs1,(s,p,e):gs2,ds)) + +pushDecl :: HsDecl -> Tr () +pushDecl d = updateState $ \(n,m,a,gs1,gs2,ds) -> ((),(n,m,a,gs1,gs2,d:ds)) + +pushAttrGuard :: SrcLoc -> HsPat -> HsExp -> Tr () +pushAttrGuard s p e = updateState $ \(n,m,a,gs1,gs2,ds) -> ((),(n,m,a,(s,p,e):gs1,gs2,ds)) + +genMatchName :: Tr HsName +genMatchName = do k <- updateState $ \(n,m,a,gs1,gs2,ds) -> (n,(n+1,m,a,gs1,gs2,ds)) + return $ HsIdent $ "harp_match" ++ show k + +genPatName :: Tr HsName +genPatName = do k <- updateState $ \(n,m,a,gs1,gs2,ds) -> (m,(n,m+1,a,gs1,gs2,ds)) + return $ HsIdent $ "harp_pat" ++ show k + +genAttrName :: Tr HsName +genAttrName = do k <- updateState $ \(n,m,a,gs1,gs2,ds) -> (m,(n,m,a+1,gs1,gs2,ds)) + return $ HsIdent $ "hsx_attrs" ++ show k + + +setHarpTransformedT, setXmlTransformedT :: Tr () +setHarpTransformedT = liftTr setHarpTransformed +setXmlTransformedT = liftTr setXmlTransformed + + +------------------------------------------------------------------- +-- Some generic functions for computations in the Tr monad. Could +-- be made even more general, but there's really no point right now... + +tr1pat :: a -> (b -> c) -> (a -> Tr b) -> Tr c +tr1pat p f tr = do q <- tr p + return $ f q + +tr2pat :: a -> a -> (b -> b -> c) -> (a -> Tr b) -> Tr c +tr2pat p1 p2 f tr = do q1 <- tr p1 + q2 <- tr p2 + return $ f q1 q2 + +trNpat :: [a] -> ([b] -> c) -> (a -> Tr b) -> Tr c +trNpat ps f tr = do qs <- mapM tr ps + return $ f qs + +----------------------------------------------------------------------------- +-- The *real* transformations +-- Transforming patterns + +-- | Transform several patterns in the same context +trPatterns :: [HsPat] -> Tr [HsPat] +trPatterns = mapM trPattern + +-- | Transform a pattern by traversing the syntax tree. +-- A regular pattern is translated, other patterns are +-- simply left as is. +trPattern :: HsPat -> Tr HsPat +trPattern p = case p of + -- This is where the fun starts. =) + -- Regular patterns must be transformed of course. + HsPRPat s rps -> do + -- First we need a name for the placeholder pattern. + n <- genPatName + -- A top-level regular pattern is a sequence in linear + -- context, so we can simply translate it as if it was one. + (mname, vars, _) <- trRPat s True (HsRPSeq rps) + -- Generate a top level declaration. + topmname <- mkTopDecl s mname vars + -- Generate a pattern guard for this regular pattern, + -- that will match the generated declaration to the + -- value of the placeholder, and bind all variables. + mkGuard s vars topmname n + -- And indeed, we have made a transformation! + setHarpTransformedT + -- Return the placeholder pattern. + return $ pvar n + -- Tag patterns should be transformed + HsPXTag s name attrs mattr cpat -> do + -- We need a name for the attribute list, if there are lookups + an <- case (mattr, attrs) of + -- ... if there is one already, and there are no lookups + -- we can just return that + (Just ap, []) -> return $ ap + -- ... if there are none, we dont' care + (_, []) -> return wildcard + (_, _) -> do -- ... but if there are, we want a name for that list + n <- genAttrName + -- ... we must turn attribute lookups into guards + mkAttrGuards s n attrs mattr + -- ... and we return the pattern + return $ pvar n + -- ... the pattern representing children should be transformed + cpat' <- trPattern cpat + -- ... we have made a transformation and should report that + setHarpTransformedT + -- ... and we return a Tag pattern. + let (dom, n) = xNameParts name + return $ metaTag dom n an cpat' + -- ... as should empty Tag patterns + HsPXETag s name attrs mattr -> do + -- We need a name for the attribute list, if there are lookups + an <- case (mattr, attrs) of + -- ... if there is a pattern already, and there are no lookups + -- we can just return that + (Just ap, []) -> return $ ap + -- ... if there are none, we dont' care + (_, []) -> return wildcard + (_, _) -> do -- ... but if there are, we want a name for that list + n <- genAttrName + -- ... we must turn attribute lookups into guards + mkAttrGuards s n attrs mattr + -- ... and we return the pattern + return $ pvar n + -- ... we have made a transformation and should report that + setHarpTransformedT + -- ... and we return an ETag pattern. + let (dom, n) = xNameParts name + return $ metaTag dom n an peList + -- PCDATA patterns are strings in the xml datatype. + HsPXPcdata s -> setHarpTransformedT >> (return $ metaPcdata s) + -- XML comments are likewise just treated as strings. + HsPXPatTag p -> setHarpTransformedT >> trPattern p + + -- Transforming any other patterns simply means transforming + -- their subparts. + HsPVar _ -> return p + HsPLit _ -> return p + HsPNeg q -> tr1pat q HsPNeg trPattern + HsPInfixApp p1 op p2 -> tr2pat p1 p2 (\p1 p2 -> HsPInfixApp p1 op p2) trPattern + HsPApp n ps -> trNpat ps (HsPApp n) trPattern + HsPTuple ps -> trNpat ps HsPTuple trPattern + HsPList ps -> trNpat ps HsPList trPattern + HsPParen p -> tr1pat p HsPParen trPattern + HsPRec n pfs -> trNpat pfs (HsPRec n) trPatternField + HsPAsPat n p -> tr1pat p (HsPAsPat n) trPattern + HsPWildCard -> return p + HsPIrrPat p -> tr1pat p HsPIrrPat trPattern + HsPatTypeSig s p t -> tr1pat p (\p -> HsPatTypeSig s p t) trPattern + + where -- Transform a pattern field. + trPatternField :: HsPatField -> Tr HsPatField + trPatternField (HsPFieldPat n p) = + tr1pat p (HsPFieldPat n) trPattern + + -- Deconstruct an xml tag name into its parts. + xNameParts :: HsXName -> (Maybe String, String) + xNameParts n = case n of + HsXName s -> (Nothing, s) + HsXDomName d s -> (Just d, s) + + -- | Generate a guard for looking up xml attributes. + mkAttrGuards :: SrcLoc -> HsName -> [HsPXAttr] -> Maybe HsPat -> Tr () + mkAttrGuards s attrs [HsPXAttr n q] mattr = do + -- Apply lookupAttr to the attribute name and + -- attribute set + let rhs = metaExtract n attrs + -- ... catch the result + pat = metaPJust q + -- ... catch the remainder list + rml = case mattr of + Nothing -> wildcard + Just ap -> ap + -- ... and add the generated guard to the store. + pushAttrGuard s (pTuple [pat, rml]) rhs + + mkAttrGuards s attrs ((HsPXAttr a q):xs) mattr = do + -- Apply lookupAttr to the attribute name and + -- attribute set + let rhs = metaExtract a attrs + -- ... catch the result + pat = metaPJust q + -- ... catch the remainder list + newAttrs <- genAttrName + -- ... and add the generated guard to the store. + pushAttrGuard s (pTuple [pat, pvar newAttrs]) rhs + -- ... and finally recurse + mkAttrGuards s newAttrs xs mattr + + -- | Generate a declaration at top level that will finalise all + -- variable continuations, and then return all bound variables. + mkTopDecl :: SrcLoc -> HsName -> [HsName] -> Tr HsName + mkTopDecl s mname vars = + do -- Give the match function a name + n <- genMatchName + -- Create the declaration and add it to the store. + pushDecl $ topDecl s n mname vars + -- Return the name of the match function so that the + -- guard that will be generated can call it. + return n + + topDecl :: SrcLoc -> HsName -> HsName -> [HsName] -> HsDecl + topDecl s n mname vs = + let pat = pTuple [wildcard, pvarTuple vs] -- (_, (foo, bar, ...)) + g = var mname -- harp_matchX + a = genStmt s pat g -- (_, (foo, ...)) <- harp_matchX + vars = map (\v -> app (var v) eList) vs -- (foo [], bar [], ...) + b = qualStmt $ metaReturn $ tuple vars -- return (foo [], bar [], ...) + e = doE [a,b] -- do (...) <- harp_matchX + -- return (foo [], bar [], ...) + in nameBind s n e -- harp_matchY = do .... + + -- | Generate a pattern guard that will apply the @runMatch@ + -- function on the top-level match function and the input list, + -- thereby binding all variables. + mkGuard :: SrcLoc -> [HsName] -> HsName -> HsName -> Tr () + mkGuard s vars mname n = do + let tvs = pvarTuple vars -- (foo, bar, ...) + ge = appFun runMatchFun [var mname, var n] -- runMatch harp_matchX harp_patY + pushGuard s (pApp just_name [tvs]) ge -- Just (foo, bar, ...) , runMatch ... + + +-------------------------------------------------------------------------------- +-- Transforming regular patterns + +-- | A simple datatype to annotate return values from sub-patterns +data MType = S -- Single element + | L MType -- List of ... , (/ /), *, + + | E MType MType -- Either ... or ... , ( | ) + | M MType -- Maybe ... , ? + + +-- When transforming a regular sub-pattern, we need to know the +-- name of the function generated to match it, the names of all +-- variables it binds, and the type of its returned value. +type MFunMetaInfo = (HsName, [HsName], MType) + + +-- | Transform away a regular pattern, generating code +-- to replace it. +trRPat :: SrcLoc -> Bool -> HsRPat -> Tr MFunMetaInfo +trRPat s linear rp = case rp of + -- For an ordinary Haskell pattern we need to generate a + -- base match function for the pattern, and a declaration + -- that lifts that function into the matcher monad. + HsRPPat p -> do mkBaseDecl s linear p + + where -- | Generate declarations for matching ordinary Haskell patterns + mkBaseDecl :: SrcLoc -> Bool -> HsPat -> Tr MFunMetaInfo + mkBaseDecl s linear p = case p of + -- We can simplify a lot if the pattern is a wildcard or a variable + HsPWildCard -> mkWCMatch s + HsPVar v -> mkVarMatch s linear v + -- ... and if it is an embedded pattern tag, we can just skip it + HsPXPatTag q -> mkBaseDecl s linear q + + -- ... otherwise we'll have to take the long way... + p -> do -- First do a case match on a single element + (name, vars, _) <- mkBasePat s linear p + -- ... apply baseMatch to the case matcher to + -- lift it into the matcher monad. + newname <- mkBaseMatch s name + -- ... and return the meta-info gathered. + return (newname, vars, S) + + -- | Generate a declaration for matching a variable. + mkVarMatch :: SrcLoc -> Bool -> HsName -> Tr MFunMetaInfo + mkVarMatch s linear v = do + -- First we need a name for the new match function. + n <- genMatchName + -- Then we need a basic matching function that always matches, + -- and that binds the value matched to the variable in question. + let e = paren $ lamE s [pvar v] $ -- (\v -> Just (mf v)) + app (var just_name) + (paren $ retVar linear v) + -- Lift the function into the matcher monad, and bind it to its name, + -- then add it the declaration to the store. + pushDecl $ nameBind s n $ + app baseMatchFun e -- harp_matchX = baseMatch (\v -> Just (mf v)) + return (n, [v], S) -- always binds v and only v + + where retVar :: Bool -> HsName -> HsExp + retVar linear v + -- if bound in linear context, apply const + | linear = metaConst (var v) + -- if bound in non-linear context, apply (:) + | otherwise = app consFun (var v) + + -- | Generate a declaration for matching a wildcard + mkWCMatch :: SrcLoc -> Tr MFunMetaInfo + mkWCMatch s = do + -- First we need a name... + n <- genMatchName + -- ... and then a function that always matches, discarding the result + let e = paren $ lamE s [wildcard] $ -- (\_ -> Just ()) + app (var just_name) unit_con + -- ... which we lift, bind, and add to the store. + pushDecl $ nameBind s n $ -- harp_matchX = baseMatch (\_ -> Just ()) + app baseMatchFun e + return (n, [], S) -- no variables bound, hence [] + + -- | Generate a basic function that cases on a single element, + -- returning Just (all bound variables) on a match, and + -- Nothing on a mismatch. + mkBasePat :: SrcLoc -> Bool -> HsPat -> Tr MFunMetaInfo + mkBasePat s b p = + do -- First we need a name... + n <- genMatchName + -- ... and then we need to know what variables that + -- will be bound by this match. + let vs = gatherPVars p + -- ... and then we can create and store away a casing function. + basePatDecl s b n vs p >>= pushDecl + return (n, vs, S) + + where -- | Gather up the names of all variables in a pattern, + -- using a simple fold over the syntax structure. + gatherPVars :: HsPat -> [HsName] + gatherPVars p = case p of + HsPVar v -> [v] + HsPNeg q -> gatherPVars q + HsPInfixApp p1 _ p2 -> gatherPVars p1 ++ + gatherPVars p2 + HsPApp _ ps -> concatMap gatherPVars ps + HsPTuple ps -> concatMap gatherPVars ps + HsPList ps -> concatMap gatherPVars ps + HsPParen p -> gatherPVars p + HsPRec _ pfs -> concatMap help pfs + where help (HsPFieldPat _ p) = gatherPVars p + HsPAsPat n p -> n : gatherPVars p + HsPWildCard -> [] + HsPIrrPat p -> gatherPVars p + HsPatTypeSig _ p _ -> gatherPVars p + HsPRPat _ rps -> concatMap gatherRPVars rps + HsPXTag _ _ attrs mattr cp -> + concatMap gatherAttrVars attrs ++ gatherPVars cp ++ + case mattr of + Nothing -> [] + Just ap -> gatherPVars ap + HsPXETag _ _ attrs mattr -> + concatMap gatherAttrVars attrs ++ + case mattr of + Nothing -> [] + Just ap -> gatherPVars ap + HsPXPatTag p -> gatherPVars p + _ -> [] + + gatherRPVars :: HsRPat -> [HsName] + gatherRPVars rp = case rp of + HsRPStar rq -> gatherRPVars rq + HsRPStarG rq -> gatherRPVars rq + HsRPPlus rq -> gatherRPVars rq + HsRPPlusG rq -> gatherRPVars rq + HsRPOpt rq -> gatherRPVars rq + HsRPOptG rq -> gatherRPVars rq + HsRPEither rq1 rq2 -> gatherRPVars rq1 ++ gatherRPVars rq2 + HsRPSeq rqs -> concatMap gatherRPVars rqs + HsRPCAs n rq -> n : gatherRPVars rq + HsRPAs n rq -> n : gatherRPVars rq + HsRPParen rq -> gatherRPVars rq + HsRPPat q -> gatherPVars q + + gatherAttrVars :: HsPXAttr -> [HsName] + gatherAttrVars (HsPXAttr _ p) = gatherPVars p + + -- | Generate a basic casing function for a given pattern. + basePatDecl :: SrcLoc -> Bool -> HsName -> [HsName] -> HsPat -> Tr HsDecl + basePatDecl s linear f vs p = do + -- We can use the magic variable harp_a since nothing else needs to + -- be in scope at this time (we could use just a, or foo, or whatever) + let a = HsIdent $ "harp_a" + -- ... and we should case on that variable on the right-hand side. + rhs <- baseCaseE s linear p a vs -- case harp_a of ... + -- The result is a simple function with one paramenter and + -- the right-hand side we just generated. + return $ simpleFun s f a rhs + where baseCaseE :: SrcLoc -> Bool -> HsPat -> HsName -> [HsName] -> Tr HsExp + baseCaseE s b p a vs = do + -- First the alternative if we actually + -- match the given pattern + let alt1 = alt s p -- foo -> Just (mf foo) + (app (var just_name) $ + tuple (map (retVar b) vs)) + -- .. and finally an alternative for not matching the pattern. + alt2 = alt s wildcard (var nothing_name) -- _ -> Nothing + -- ... and that pattern could itself contain regular patterns + -- so we must transform away these. + alt1' <- liftTr $ transformAlt alt1 + return $ caseE (var a) [alt1', alt2] + retVar :: Bool -> HsName -> HsExp + retVar linear v + -- if bound in linear context, apply const + | linear = metaConst (var v) + -- if bound in non-linear context, apply (:) + | otherwise = app consFun (var v) + + -- | Generate a match function that lift the result of the + -- basic casing function into the matcher monad. + mkBaseMatch :: SrcLoc -> HsName -> Tr HsName + mkBaseMatch s name = + do -- First we need a name... + n <- genMatchName + -- ... to which we bind the lifting function + pushDecl $ baseMatchDecl s n name + -- and then return for others to use. + return n + + -- | Generate a declaration for the function that lifts a simple + -- casing function into the matcher monad. + baseMatchDecl :: SrcLoc -> HsName -> HsName -> HsDecl + baseMatchDecl s newname oldname = + -- Apply the lifting function "baseMatch" to the casing function + let e = app baseMatchFun (var oldname) + -- ... and bind it to the new name. + in nameBind s newname e -- harp_matchX = baseMatch harp_matchY + + + -- For a sequence of regular patterns, we should transform all + -- sub-patterns and then generate a function for sequencing them. + HsRPSeq rps -> do + nvts <- mapM (trRPat s linear) rps + mkSeqDecl s nvts + + where -- | Generate a match function for a sequence of regular patterns, + -- flattening any special sub-patterns into normal elements of the list + mkSeqDecl :: SrcLoc -> [MFunMetaInfo] -> Tr MFunMetaInfo + mkSeqDecl s nvts = do + -- First, as always, we need a name... + name <- genMatchName + let -- We need a generating statement for each sub-pattern. + (gs, vals) = unzip $ mkGenExps s 0 nvts -- (harp_valX, (foo, ...)) <- harp_matchY + -- Gather up all variables from all sub-patterns. + vars = concatMap (\(_,vars,_) -> vars) nvts + -- ... flatten all values to simple lists, and concatenate + -- the lists to a new return value + fldecls = flattenVals s vals -- harp_valXf = $flatten harp_valX + -- harp_ret = foldComp [harp_val1f, ...] + -- ... return the value along with all variables + ret = qualStmt $ metaReturn $ -- return (harp_ret, (foo, .....)) + tuple [var retname, varTuple vars] + -- ... do all these steps in a do expression + rhs = doE $ gs ++ -- do (harp_valX, (foo, ...)) <- harpMatchY + [letStmt fldecls, ret] -- let harp_valXf = $flatten harp_valX + -- return (harp_ret, (foo, .....)) + -- ... bind it to its name, and add the declaration + -- to the store. + pushDecl $ nameBind s name rhs -- harp_matchZ = do .... + -- The return value of a sequence is always a list of elements. + return (name, vars, L S) + + -- | Flatten values of all sub-patterns into normal elements of the list + flattenVals :: SrcLoc -> [(HsName, MType)] -> [HsDecl] + flattenVals s nts = + let -- Flatten the values of all sub-patterns to + -- lists of elements + (nns, ds) = unzip $ map (flVal s) nts + -- ... and concatenate their results. + ret = nameBind s retname $ app + (paren $ app foldCompFun + (listE $ map var nns)) $ eList + in ds ++ [ret] + + + flVal :: SrcLoc -> (HsName, MType) -> (HsName, HsDecl) + flVal s (name, mt) = + let -- We reuse the old names, we just extend them a bit. + newname = extendVar name "f" -- harp_valXf + -- Create the appropriate flattening function depending + -- on the type of the value + f = flatten mt + -- ... apply it to the value and bind it to its new name. + in (newname, nameBind s newname $ -- harp_valXf = $flatten harp_valX + app f (var name)) + + -- | Generate a flattening function for a given type structure. + flatten :: MType -> HsExp + flatten S = consFun -- (:) + flatten (L mt) = + let f = flatten mt + r = paren $ metaMap f + in paren $ foldCompFun `metaComp` r -- (foldComp . (map $flatten)) + flatten (E mt1 mt2) = + let f1 = flatten mt1 + f2 = flatten mt2 + in paren $ metaEither f1 f2 -- (either $flatten $flatten) + flatten (M mt) = + let f = flatten mt + in paren $ metaMaybe idFun f -- (maybe id $flatten) + + -- For accumulating as-patterns we should transform the subpattern, and then generate + -- a declaration that supplies the value to be bound to the variable in question. + -- The variable should be bound non-linearly. + HsRPCAs v rp -> do + -- Transform the subpattern + nvt@(name, vs, mt) <- trRPat s linear rp + -- ... and create a declaration to bind its value. + n <- mkCAsDecl s nvt + -- The type of the value is unchanged. + return (n, (v:vs), mt) + + where -- | Generate a declaration for a @: binding. + mkCAsDecl :: SrcLoc -> MFunMetaInfo -> Tr HsName + mkCAsDecl = asDecl $ app consFun -- should become lists when applied to [] + + + -- For ordinary as-patterns we should transform the subpattern, and then generate + -- a declaration that supplies the value to be bound to the variable in question. + -- The variable should be bound linearly. + HsRPAs v rp + | linear -> + do -- Transform the subpattern + nvt@(name, vs, mt) <- trRPat s linear rp + -- ... and create a declaration to bind its value + n <- mkAsDecl s nvt + -- The type of the value is unchanged. + return (n, (v:vs), mt) + -- We may not use an @ bind in non-linear context + | otherwise -> case v of + HsIdent n -> fail $ "Attempting to bind variable "++n++ + " inside the context of a numerable regular pattern" + _ -> fail $ "This should never ever ever happen...\ + \ how the #% did you do it??!?" + + where -- | Generate a declaration for a @ binding. + mkAsDecl :: SrcLoc -> MFunMetaInfo -> Tr HsName + mkAsDecl = asDecl metaConst -- should be constant when applied to [] + + + -- For regular patterns, parentheses have no real meaning + -- so at this point we can just skip them. + HsRPParen rp -> trRPat s linear rp + + -- For (possibly non-greedy) optional regular patterns we need to + -- transform the subpattern, and the generate a function that can + -- choose to match or not to match, that is the question... + HsRPOpt rp -> + do -- Transform the subpattern + nvt <- trRPat s False rp + -- ... and create a declaration that can optionally match it. + mkOptDecl s False nvt + -- ... similarly for the non-greedy version. + HsRPOptG rp -> + do -- Transform the subpattern + nvt <- trRPat s False rp + -- ... and create a declaration that can optionally match it. + mkOptDecl s True nvt + + + -- For union patterns, we should transform both subexpressions, + -- and generate a function that chooses between them. + HsRPEither rp1 rp2 -> + do -- Transform the subpatterns + nvt1 <- trRPat s False rp1 + nvt2 <- trRPat s False rp2 + -- ... and create a declaration that can choose between them. + mkEitherDecl s nvt1 nvt2 + -- | Generate declarations for either patterns, i.e. ( | ) + where mkEitherDecl :: SrcLoc -> MFunMetaInfo -> MFunMetaInfo -> Tr MFunMetaInfo + mkEitherDecl s nvt1@(_, vs1, t1) nvt2@(_, vs2, t2) = do + -- Eine namen, bitte! + n <- genMatchName + let -- Generate generators for the subpatterns + (g1, v1) = mkGenExp s nvt1 + (g2, v2) = mkGenExp s nvt2 -- (harp_valX, (foo, bar, ...)) <- harp_matchY + -- ... gather all variables from both sides + allvs = vs1 `union` vs2 + -- ... some may be bound on both sides, so we + -- need to check which ones are bound on each, + -- supplying empty value for those that are not + vals1 = map (varOrId vs1) allvs + vals2 = map (varOrId vs2) allvs + -- ... apply either Left or Right to the returned value + ret1 = metaReturn $ tuple -- return (Left harp_val1, (foo, id, ...)) + [app (var left_name) + (var v1), tuple vals1] + ret2 = metaReturn $ tuple -- return (Right harp_val2, (id, bar, ...)) + [app (var right_name) + (var v2), tuple vals2] + -- ... and do all these things in do-expressions + exp1 = doE [g1, qualStmt ret1] + exp2 = doE [g2, qualStmt ret2] + -- ... and choose between them using the choice (+++) operator. + rhs = (paren exp1) `metaChoice` -- (do ...) +++ + (paren exp2) -- (do ...) + -- Finally we create a declaration for this function and + -- add it to the store. + pushDecl $ nameBind s n rhs -- harp_matchZ = (do ...) ... + -- The type of the returned value is Either the type of the first + -- or the second subpattern. + return (n, allvs, E t1 t2) + + varOrId :: [HsName] -> HsName -> HsExp + varOrId vs v = if v `elem` vs -- the variable is indeed bound in this branch + then var v -- ... so it should be added to the result + else idFun -- ... else it should be empty. + + -- For (possibly non-greedy) repeating regular patterns we need to transform the subpattern, + -- and then generate a function to handle many matches of it. + HsRPStar rp -> + do -- Transform the subpattern + nvt <- trRPat s False rp + -- ... and create a declaration that can match it many times. + mkStarDecl s False nvt + -- ... and similarly for the non-greedy version. + HsRPStarG rp -> + do -- Transform the subpattern + nvt <- trRPat s False rp + -- ... and create a declaration that can match it many times. + mkStarDecl s True nvt + + -- For (possibly non-greedy) non-empty repeating patterns we need to transform the subpattern, + -- and then generate a function to handle one or more matches of it. + HsRPPlus rp -> + do -- Transform the subpattern + nvt <- trRPat s False rp + -- ... and create a declaration that can match it one or more times. + mkPlusDecl s False nvt + -- ... and similarly for the non-greedy version. + HsRPPlusG rp -> + do -- Transform the subpattern + nvt <- trRPat s False rp + -- ... and create a declaration that can match it one or more times. + mkPlusDecl s True nvt + + + where -- These are the functions that must be in scope for more than one case alternative above. + + -- | Generate the generators that call sub-matching functions, and + -- annotate names with types for future flattening of values. + -- Iterate to enable gensym-like behavior. + mkGenExps :: SrcLoc -> Int -> [MFunMetaInfo] -> [(HsStmt, (HsName, MType))] + mkGenExps _ _ [] = [] + mkGenExps s k ((name, vars, t):nvs) = + let valname = mkValName k -- harp_valX + pat = pTuple [pvar valname, pvarTuple vars] -- (harp_valX, (foo, bar, ...)) + g = var name + in (genStmt s pat g, (valname, t)) : -- (harp_valX, (foo, ...)) <- harp_matchY + mkGenExps s (k+1) nvs + + -- | Create a single generator. + mkGenExp :: SrcLoc -> MFunMetaInfo -> (HsStmt, HsName) + mkGenExp s nvt = let [(g, (name, _t))] = mkGenExps s 0 [nvt] + in (g, name) + + -- | Generate a single generator with a call to (ng)manyMatch, + -- and an extra variable name to use after unzipping. + mkManyGen :: SrcLoc -> Bool -> HsName -> HsStmt + mkManyGen s greedy mname = + -- Choose which repeater function to use, determined by greed + let mf = if greedy then gManyMatchFun else manyMatchFun + -- ... and create a generator that applies it to the + -- matching function in question. + in genStmt s (pvar valsvarsname) $ + app mf (var mname) + + -- | Generate declarations for @: and @ bindings. + asDecl :: (HsExp -> HsExp) -> SrcLoc -> MFunMetaInfo -> Tr HsName + asDecl mf s nvt@(_, vs, _) = do + -- A name, if you would + n <- genMatchName -- harp_matchX + let -- Generate a generator for matching the subpattern + (g, val) = mkGenExp s nvt -- (harp_valY, (foo, ...)) <- harp_matchZ + -- ... fix the old variables + vars = map var vs -- (apa, bepa, ...) + -- ... and return the generated value, along with the + -- new set of variables which is the old set prepended + -- by the variable currently being bound. + ret = qualStmt $ metaReturn $ tuple -- return (harp_valY, ($mf harp_valY, apa, ...)) + [var val, tuple $ mf (var val) : vars] -- mf in the line above is what separates + -- @: ((:)) from @ (const) + -- Finally we create a declaration for this function and + -- add it to the store. + pushDecl $ nameBind s n $ doE [g, ret] -- harp_matchX = do ... + return n + + -- | Generate declarations for optional patterns, ? and #?. + -- (Unfortunally we must place this function here since both variations + -- of transformations of optional patterns should be able to call it...) + mkOptDecl :: SrcLoc -> Bool -> MFunMetaInfo -> Tr MFunMetaInfo + mkOptDecl s greedy nvt@(_, vs, t) = do + -- Un nome, s'il vouz plaît. + n <- genMatchName + let -- Generate a generator for matching the subpattern + (g, val) = mkGenExp s nvt -- (harp_valX, (foo, bar, ...)) <- harp_matchY + -- ... and apply a Just to its value + ret1 = metaReturn $ tuple -- return (Just harp_val1, (foo, bar, ...)) + [app (var just_name) + (var val), varTuple vs] + -- ... and do those two steps in a do-expression + exp1 = doE [g, qualStmt ret1] -- do .... + -- For the non-matching branch, all the variables should be empty + ids = map (const idFun) vs -- (id, id, ...) + -- ... and the value should be Nothing. + ret2 = metaReturn $ tuple -- return (Nothing, (id, id, ...)) + [var nothing_name, tuple ids] -- i.e. no vars were bound + -- The order of the arguments to the choice (+++) operator + -- is determined by greed... + mc = if greedy + then metaChoice -- standard order + else (flip metaChoice) -- reversed order + -- ... and then apply it to the branches. + rhs = (paren exp1) `mc` -- (do ....) +++ + (paren ret2) -- (return (Nothing, .....)) + -- Finally we create a declaration for this function and + -- add it to the store. + pushDecl $ nameBind s n rhs -- harp_matchZ = (do ....) +++ (return ....) + -- The type of the returned value will be Maybe the type + -- of the value of the subpattern. + return (n, vs, M t) + + -- | Generate declarations for star patterns, * and #* + -- (Unfortunally we must place this function here since both variations + -- of transformations of repeating patterns should be able to call it...) + mkStarDecl :: SrcLoc -> Bool -> MFunMetaInfo -> Tr MFunMetaInfo + mkStarDecl s greedy (mname, vs, t) = do + -- Ett namn, tack! + n <- genMatchName + let -- Create a generator that matches the subpattern + -- many times, either greedily or non-greedily + g = mkManyGen s greedy mname + -- ... and unzip the result, choosing the proper unzip + -- function depending on the number of variables returned. + metaUnzipK = mkMetaUnzip s (length vs) + -- ... first unzip values from variables + dec1 = patBind s (pvarTuple [valname, varsname]) + (metaUnzip $ var valsvarsname) + -- ... and then unzip the variables + dec2 = patBind s (pvarTuple vs) + (metaUnzipK $ var varsname) + -- ... fold all the values for variables + retExps = map ((app foldCompFun) . var) vs + -- ... and return value and variables + ret = metaReturn $ tuple $ + [var valname, tuple retExps] + -- Finally we need to generate a function that does all this, + -- using a let-statement for the non-monadic stuff and a + -- do-expression to wrap it all in. + pushDecl $ nameBind s n $ + doE [g, letStmt [dec1, dec2], qualStmt ret] + -- The type of the returned value is a list ([]) of the + -- type of the subpattern. + return (n, vs, L t) + + -- | Generate declarations for plus patterns, + and #+ + -- (Unfortunally we must place this function here since both variations + -- of transformations of non-empty repeating patterns should be able to call it...) + mkPlusDecl :: SrcLoc -> Bool -> MFunMetaInfo -> Tr MFunMetaInfo + mkPlusDecl s greedy nvt@(mname, vs, t) = do + -- and now I've run out of languages... + n <- genMatchName + let k = length vs + -- First we want a generator to match the + -- subpattern exactly one time + (g1, val1) = mkGenExp s nvt -- (harp_valX, (foo, ...)) <- harpMatchY + -- ... and then one that matches it many times. + g2 = mkManyGen s greedy mname -- harp_vvs <- manyMatch harpMatchY + -- ... we want to unzip the result, using + -- the proper unzip function + metaUnzipK = mkMetaUnzip s k + -- ... first unzip values from variables + dec1 = patBind s -- (harp_vals, harp_vars) = unzip harp_vvs + (pvarTuple [valsname, varsname]) + (metaUnzip $ var valsvarsname) + -- .. now we need new fresh names for variables + -- since the ordinary ones are already taken. + vlvars = genNames "harp_vl" k + -- ... and then we can unzip the variables + dec2 = patBind s (pvarTuple vlvars) -- (harp_vl1, ...) = unzipK harp_vars + (metaUnzipK $ var varsname) + -- .. and do the unzipping in a let-statement + letSt = letStmt [dec1, dec2] + -- ... fold variables from the many-match, + -- prepending the variables from the single match + retExps = map mkRetFormat $ zip vs vlvars -- foo . (foldComp harp_vl1), ... + -- ... prepend values from the single match to + -- those of the many-match. + retVal = (var val1) `metaCons` + (var valsname) -- harp_valX : harp_vals + -- ... return all values and variables + ret = metaReturn $ tuple $ -- return (harp_valX:harpVals, + [retVal, tuple retExps] -- (foo . (...), ...)) + -- ... and wrap all of it in a do-expression. + rhs = doE [g1, g2, letSt, qualStmt ret] + -- Finally we create a declaration for this function and + -- add it to the store. + pushDecl $ nameBind s n rhs + -- The type of the returned value is a list ([]) of the + -- type of the subpattern. + return (n, vs, L t) + + where mkRetFormat :: (HsName, HsName) -> HsExp + mkRetFormat (v, vl) = + -- Prepend variables using function composition. + (var v) `metaComp` + (paren $ (app foldCompFun) $ var vl) + + +-------------------------------------------------------------------------- +-- HaRP-specific functions and ids + +-- | Functions and ids from the @Match@ module, +-- used in the generated matching functions +runMatchFun, baseMatchFun, manyMatchFun, gManyMatchFun :: HsExp +runMatchFun = match_qual runMatch_name +baseMatchFun = match_qual baseMatch_name +manyMatchFun = match_qual manyMatch_name +gManyMatchFun = match_qual gManyMatch_name + +runMatch_name, baseMatch_name, manyMatch_name, gManyMatch_name :: HsName +runMatch_name = HsIdent "runMatch" +baseMatch_name = HsIdent "baseMatch" +manyMatch_name = HsIdent "manyMatch" +gManyMatch_name = HsIdent "gManyMatch" + +match_mod, match_qual_mod :: Module +match_mod = Module "Harp.Match" +match_qual_mod = Module "HaRPMatch" + +match_qual :: HsName -> HsExp +match_qual = qvar match_qual_mod + +choiceOp :: HsQOp +choiceOp = HsQVarOp $ Qual match_qual_mod choice + +appendOp :: HsQOp +appendOp = HsQVarOp $ UnQual append + +-- foldComp = foldl (.) id, i.e. fold by composing +foldCompFun :: HsExp +foldCompFun = match_qual $ HsIdent "foldComp" + +mkMetaUnzip :: SrcLoc -> Int -> HsExp -> HsExp +mkMetaUnzip s k | k <= 7 = let n = "unzip" ++ show k + in (\e -> matchFunction n [e]) + | otherwise = + let vs = genNames "x" k + lvs = genNames "xs" k + uz = name $ "unzip" ++ show k + ys = name "ys" + xs = name "xs" + alt1 = alt s peList $ tuple $ replicate k eList -- [] -> ([], [], ...) + pat2 = (pvarTuple vs) `metaPCons` (pvar xs) -- (x1, x2, ...) + ret2 = tuple $ map appCons $ zip vs lvs -- (x1:xs1, x2:xs2, ...) + rhs2 = app (var uz) (var xs) -- unzipK xs + dec2 = patBind s (pvarTuple lvs) rhs2 -- (xs1, xs2, ...) = unzipK xs + exp2 = letE [dec2] ret2 + alt2 = alt s pat2 exp2 + topexp = lamE s [pvar ys] $ caseE (var ys) [alt1, alt2] + topbind = nameBind s uz topexp + in app (paren $ letE [topbind] (var uz)) + where appCons :: (HsName, HsName) -> HsExp + appCons (x, xs) = metaCons (var x) (var xs) + +matchFunction :: String -> [HsExp] -> HsExp +matchFunction s es = mf s (reverse es) + where mf s [] = match_qual $ HsIdent s + mf s (e:es) = app (mf s es) e + +-- | Some 'magic' gensym-like functions, and functions +-- with related functionality. +retname :: HsName +retname = name "harp_ret" + +varsname :: HsName +varsname = name "harp_vars" + +valname :: HsName +valname = name "harp_val" + +valsname :: HsName +valsname = name "harp_vals" + +valsvarsname :: HsName +valsvarsname = name "harp_vvs" + +mkValName :: Int -> HsName +mkValName k = name $ "harp_val" ++ show k + +extendVar :: HsName -> String -> HsName +extendVar (HsIdent n) s = HsIdent $ n ++ s +extendVar n _ = n + +xNameParts :: HsXName -> (Maybe String, String) +xNameParts n = case n of + HsXName s -> (Nothing, s) + HsXDomName d s -> (Just d, s) + +--------------------------------------------------------- +-- meta-level functions, i.e. functions that represent functions, +-- and that take arguments representing arguments... whew! + +metaReturn, metaConst, metaMap, metaUnzip :: HsExp -> HsExp +metaReturn e = metaFunction "return" [e] +metaConst e = metaFunction "const" [e] +metaMap e = metaFunction "map" [e] +metaUnzip e = metaFunction "unzip" [e] + +metaEither, metaMaybe :: HsExp -> HsExp -> HsExp +metaEither e1 e2 = metaFunction "either" [e1,e2] +metaMaybe e1 e2 = metaFunction "maybe" [e1,e2] + +metaConcat :: [HsExp] -> HsExp +metaConcat es = metaFunction "concat" [listE es] + +metaAppend :: HsExp -> HsExp -> HsExp +metaAppend l1 l2 = infixApp l1 appendOp l2 + +-- the +++ choice operator +metaChoice :: HsExp -> HsExp -> HsExp +metaChoice e1 e2 = infixApp e1 choiceOp e2 + +metaPCons :: HsPat -> HsPat -> HsPat +metaPCons p1 p2 = HsPInfixApp p1 cons p2 + +metaCons, metaComp :: HsExp -> HsExp -> HsExp +metaCons e1 e2 = infixApp e1 (HsQConOp cons) e2 +metaComp e1 e2 = infixApp e1 (op fcomp) e2 + +metaPJust :: HsPat -> HsPat +metaPJust p = pApp just_name [p] + +metaPNothing :: HsPat +metaPNothing = pvar nothing_name + +metaPMkMaybe :: Maybe HsPat -> HsPat +metaPMkMaybe mp = case mp of + Nothing -> metaPNothing + Just p -> pParen $ metaPJust p + +metaJust :: HsExp -> HsExp +metaJust e = app (var just_name) e + +metaNothing :: HsExp +metaNothing = var nothing_name + +metaMkMaybe :: Maybe HsExp -> HsExp +metaMkMaybe me = case me of + Nothing -> metaNothing + Just e -> paren $ metaJust e + +--------------------------------------------------- +-- some other useful functions at abstract level +consFun, idFun :: HsExp +consFun = HsCon cons +idFun = function "id" + +cons :: HsQName +cons = Special HsCons + +fcomp, choice, append :: HsName +fcomp = HsSymbol "." +choice = HsSymbol "+++" +append = HsSymbol "++" + +just_name, nothing_name, left_name, right_name :: HsName +just_name = HsIdent "Just" +nothing_name = HsIdent "Nothing" +left_name = HsIdent "Left" +right_name = HsIdent "Right" + +------------------------------------------------------------------------ +-- Help functions for meta programming xml + +hsx_data_mod :: Module +hsx_data_mod = Module "HSP.Data" + +-- | Create an xml PCDATA value +metaMkPcdata :: String -> HsExp +metaMkPcdata s = metaFunction "pcdata" [strE s] + +-- | Create an xml tag, given its domain, name, attributes and +-- children. +metaMkTag :: HsXName -> [HsExp] -> Maybe HsExp -> [HsExp] -> HsExp +metaMkTag name ats mat cs = + let (d,n) = xNameParts name + ne = tuple [metaMkMaybe $ fmap strE d, strE n] + m = maybe id (\x y -> paren $ y `metaAppend` (metaMap $ metaToAttribute x)) mat + attrs = m $ listE $ map metaToAttribute ats + in metaFunction "genTag" [ne, attrs, listE cs] + +-- | Create an empty xml tag, given its domain, name and attributes. +metaMkETag :: HsXName -> [HsExp] -> Maybe HsExp -> HsExp +metaMkETag name ats mat = + let (d,n) = xNameParts name + ne = tuple [metaMkMaybe $ fmap strE d, strE n] + m = maybe id (\x y -> paren $ y `metaAppend` (metaMap $ metaToAttribute x)) mat + attrs = m $ listE $ map metaToAttribute ats + in metaFunction "genETag" [ne, attrs] + +-- | Create an attribute by applying the overloaded @toAttribute@ +metaToAttribute :: HsExp -> HsExp +metaToAttribute e = metaFunction "toAttribute" [e] + +-- | Create a property from an attribute and a value. +metaAssign :: HsExp -> HsExp -> HsExp +metaAssign e1 e2 = infixApp e1 assignOp e2 + where assignOp = HsQVarOp $ UnQual $ HsSymbol ":=" + +-- | Make xml out of some expression by applying the overloaded function +-- @toXml@. +metaToXmls :: HsExp -> HsExp +metaToXmls e = metaFunction "toXMLs" [paren e] + +-- | Lookup an attribute in the set of attributes. +metaExtract :: HsXName -> HsName -> HsExp +metaExtract name attrs = + let (d,n) = xNameParts name + np = tuple [metaMkMaybe $ fmap strE d, strE n] + in metaFunction "extract" [np, var attrs] + +-- | Generate a pattern under the Tag data constructor. +metaTag :: (Maybe String) -> String -> HsPat -> HsPat -> HsPat +metaTag dom name ats cpat = + let d = metaPMkMaybe $ fmap strP dom + n = pTuple [d, strP name] + in metaConPat "Tag" [n, ats, cpat] + +-- | Generate a pattern under the PCDATA data constructor. +metaPcdata :: String -> HsPat +metaPcdata s = metaConPat "PCDATA" [strP s] + +metaMkName :: HsXName -> HsExp +metaMkName n = case n of + HsXName s -> strE s + HsXDomName d s -> tuple [strE d, strE s] diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,2 @@ +import Distribution.Simple +main = defaultMainWithHooks defaultUserHooks diff --git a/haskell-src-exts.cabal b/haskell-src-exts.cabal new file mode 100644 --- /dev/null +++ b/haskell-src-exts.cabal @@ -0,0 +1,54 @@ +Name: haskell-src-exts +Version: 0.2.1 +License: BSD4 +License-File: LICENSE +Author: Niklas Broberg +Maintainer: Niklas Broberg +Category: Language +Synopsis: Manipulating Haskell source: abstract syntax, lexer, parser, and pretty-printer +Description: Haskell-Source with eXtensions (HSX, haskell-src-exts) + is an extension of the standard haskell-src package, + and handles most common syntactic extensions to Haskell, including: + . + * Multi-parameter type classes with functional dependencies + . + * Empty data declarations + . + * GADTs + . + * Implicit parameters (ghc and hugs style) + . + * Template Haskell (broken for 6.4, needs redoing) + . + and a few more. Apart from these standard extensions, + it also handles regular patterns as per the HaRP extension + as well as HSP-style embedded XML syntax (HSP release imminent). + . + For details on usage, please see the website. +Homepage: http://www.cs.chalmers.se/~d00nibro/harp/ + +Stability: Experimental +Tested-with: GHC==6.8.2 +Build-Type: Simple +Cabal-Version: >= 1.2 + +Flag splitBase + Description: Choose the new smaller, split-up base package. + +Library + Build-Tools: happy + Build-Depends: base + if flag(splitBase) + Build-Depends: base >= 3, array >= 0.1, pretty >= 1.0 + else + Build-Depends: base < 3 + + Exposed-modules: Language.Haskell.Hsx, + Language.Haskell.Hsx.Parser, + Language.Haskell.Hsx.Pretty, + Language.Haskell.Hsx.Transform, + Language.Haskell.Hsx.Syntax, + Language.Haskell.Hsx.Build + Other-modules: Language.Haskell.Hsx.ParseMonad, + Language.Haskell.Hsx.Lexer, + Language.Haskell.Hsx.ParseUtils