diff --git a/Language/Haskell/Exts.hs b/Language/Haskell/Exts.hs deleted file mode 100644 --- a/Language/Haskell/Exts.hs +++ /dev/null @@ -1,31 +0,0 @@ -module Language.Haskell.Exts ( - module Language.Haskell.Exts.Syntax - , module Language.Haskell.Exts.Build - , module Language.Haskell.Exts.Parser - , module Language.Haskell.Exts.Pretty - , parseFileContents - , parseFileContentsWithMode - , parseFile - ) where - -import Language.Haskell.Exts.Build -import Language.Haskell.Exts.Syntax -import Language.Haskell.Exts.Parser -import Language.Haskell.Exts.Pretty -import Data.List -import Language.Preprocessor.Unlit - -parseFile :: FilePath -> IO (ParseResult Module) -parseFile fp = readFile fp >>= (return . parseFileContentsWithMode (ParseMode fp)) - -parseFileContents :: String -> ParseResult Module -parseFileContents = parseFileContentsWithMode defaultParseMode - -parseFileContentsWithMode :: ParseMode -> String -> ParseResult Module -parseFileContentsWithMode p rawStr = parseModuleWithMode p (delit $ unlines $ map f $ lines rawStr) - where - f ('#':_) = "" - f x = x - - filename = parseFilename p - delit = if ".lhs" `isSuffixOf` filename then unlit filename else id diff --git a/Language/Haskell/Exts/Build.hs b/Language/Haskell/Exts/Build.hs deleted file mode 100644 --- a/Language/Haskell/Exts/Build.hs +++ /dev/null @@ -1,235 +0,0 @@ ------------------------------------------------------------------------------ --- | --- Module : Language.Haskell.Exts.Build --- 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 --- ------------------------------------------------------------------------------ - --- This module badly needs Haddock documentation. -module Language.Haskell.Exts.Build ( - - -- * Syntax building functions - name, -- :: String -> Name - sym, -- :: String -> Name - var, -- :: Name -> Exp - op, -- :: Name -> QOp - qvar, -- :: Module -> Name -> Exp - pvar, -- :: Name -> Pat - app, -- :: Exp -> Exp -> Exp - infixApp, -- :: Exp -> QOp -> Exp -> Exp - appFun, -- :: Exp -> [Exp] -> Exp - pApp, -- :: Name -> [Pat] -> Pat - tuple, -- :: [Exp] -> Exp - pTuple, -- :: [Pat] -> Pat - varTuple, -- :: [Name] -> Exp - pvarTuple, -- :: [Name] -> Pat - function, -- :: String -> Exp - strE, -- :: String -> Exp - charE, -- :: Char -> Exp - intE, -- :: Integer -> Exp - strP, -- :: String -> Pat - charP, -- :: Char -> Pat - intP, -- :: Integer -> Pat - doE, -- :: [Stmt] -> Exp - lamE, -- :: SrcLoc -> [Pat] -> Exp -> Exp - letE, -- :: [Decl] -> Exp -> Exp - caseE, -- :: Exp -> [Alt] -> Exp - alt, -- :: SrcLoc -> Pat -> Exp -> Alt - altGW, -- :: SrcLoc -> Pat -> [Stmt] -> Exp -> Binds -> Alt - listE, -- :: [Exp] -> Exp - eList, -- :: Exp - peList, -- :: Pat - paren, -- :: Exp -> Exp - pParen, -- :: Pat -> Pat - qualStmt, -- :: Exp -> Stmt - genStmt, -- :: SrcLoc -> Pat -> Exp -> Stmt - letStmt, -- :: [Decl] -> Stmt - binds, -- :: [Decl] -> Binds - noBinds, -- :: Binds - wildcard, -- :: Pat - genNames, -- :: String -> Int -> [Name] - - -- * More advanced building - sfun, -- :: SrcLoc -> Name -> [Name] -> Rhs -> Binds -> Decl - simpleFun, -- :: SrcLoc -> Name -> Name -> Exp -> Decl - patBind, -- :: SrcLoc -> Pat -> Exp -> Decl - patBindWhere, -- :: SrcLoc -> Pat -> Exp -> [Decl] -> Decl - nameBind, -- :: SrcLoc -> Name -> Exp -> Decl - metaFunction, -- :: String -> [Exp] -> Exp - metaConPat -- :: String -> [Pat] -> Pat - ) where - -import Language.Haskell.Exts.Syntax - ------------------------------------------------------------------------------ --- Help functions for Abstract syntax - -name :: String -> Name -name = Ident - -sym :: String -> Name -sym = Symbol - -var :: Name -> Exp -var = Var . UnQual - -op :: Name -> QOp -op = QVarOp . UnQual - -qvar :: ModuleName -> Name -> Exp -qvar m n = Var $ Qual m n - -pvar :: Name -> Pat -pvar = PVar - -app :: Exp -> Exp -> Exp -app = App - -infixApp :: Exp -> QOp -> Exp -> Exp -infixApp = InfixApp - -appFun :: Exp -> [Exp] -> Exp -appFun f [] = f -appFun f (a:as) = appFun (app f a) as - -pApp :: Name -> [Pat] -> Pat -pApp n ps = PApp (UnQual n) ps - -tuple :: [Exp] -> Exp -tuple = Tuple - -pTuple :: [Pat] -> Pat -pTuple = PTuple - -varTuple :: [Name] -> Exp -varTuple ns = tuple $ map var ns - -pvarTuple :: [Name] -> Pat -pvarTuple ns = pTuple $ map pvar ns - -function :: String -> Exp -function = var . Ident - -strE :: String -> Exp -strE = Lit . String - -charE :: Char -> Exp -charE = Lit . Char - -intE :: Integer -> Exp -intE = Lit . Int - -strP :: String -> Pat -strP = PLit . String - -charP :: Char -> Pat -charP = PLit . Char - -intP :: Integer -> Pat -intP = PLit . Int - -doE :: [Stmt] -> Exp -doE = Do - -lamE :: SrcLoc -> [Pat] -> Exp -> Exp -lamE = Lambda - -letE :: [Decl] -> Exp -> Exp -letE ds e = Let (binds ds) e - -caseE :: Exp -> [Alt] -> Exp -caseE = Case - -alt :: SrcLoc -> Pat -> Exp -> Alt -alt s p e = Alt s p (UnGuardedAlt e) noBinds - -altGW :: SrcLoc -> Pat -> [Stmt] -> Exp -> Binds -> Alt -altGW s p gs e w = Alt s p (gAlt s gs e) w - -unGAlt :: Exp -> GuardedAlts -unGAlt = UnGuardedAlt - -gAlts :: SrcLoc -> [([Stmt],Exp)] -> GuardedAlts -gAlts s as = GuardedAlts $ map (\(gs,e) -> GuardedAlt s gs e) as - -gAlt :: SrcLoc -> [Stmt] -> Exp -> GuardedAlts -gAlt s gs e = gAlts s [(gs,e)] - -listE :: [Exp] -> Exp -listE = List - -eList :: Exp -eList = List [] - -peList :: Pat -peList = PList [] - -paren :: Exp -> Exp -paren = Paren - -pParen :: Pat -> Pat -pParen = PParen - -qualStmt :: Exp -> Stmt -qualStmt = Qualifier - -genStmt :: SrcLoc -> Pat -> Exp -> Stmt -genStmt = Generator - -letStmt :: [Decl] -> Stmt -letStmt ds = LetStmt $ binds ds - -binds :: [Decl] -> Binds -binds = BDecls - -noBinds :: Binds -noBinds = binds [] - -wildcard :: Pat -wildcard = PWildCard - -genNames :: String -> Int -> [Name] -genNames s k = [ Ident $ s ++ show i | i <- [1..k] ] - -------------------------------------------------------------------------------- --- Some more specialised help functions - --- | A function with a single "match" -sfun :: SrcLoc -> Name -> [Name] -> Rhs -> Binds -> Decl -sfun s f pvs rhs bs = FunBind [Match s f (map pvar pvs) Nothing rhs bs] - --- | A function with a single "match", a single argument, no guards --- and no where declarations -simpleFun :: SrcLoc -> Name -> Name -> Exp -> Decl -simpleFun s f a e = let rhs = UnGuardedRhs 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 -> Pat -> Exp -> Decl -patBind s p e = let rhs = UnGuardedRhs e - in PatBind s p Nothing rhs noBinds - -patBindWhere :: SrcLoc -> Pat -> Exp -> [Decl] -> Decl -patBindWhere s p e ds = let rhs = UnGuardedRhs e - in PatBind s p Nothing rhs (binds ds) - -nameBind :: SrcLoc -> Name -> Exp -> Decl -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 -> [Exp] -> Exp -metaFunction s es = mf s (reverse es) - where mf s [] = var $ name s - mf s (e:es) = app (mf s es) e - - -metaConPat :: String -> [Pat] -> Pat -metaConPat s ps = pApp (name s) ps diff --git a/Language/Haskell/Exts/Lexer.hs b/Language/Haskell/Exts/Lexer.hs deleted file mode 100644 --- a/Language/Haskell/Exts/Lexer.hs +++ /dev/null @@ -1,928 +0,0 @@ --- #hide ------------------------------------------------------------------------------ --- | --- Module : Language.Haskell.Exts.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.Exts.Lexer (Token(..), lexer) where - -import Language.Haskell.Exts.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 - | IntTokHash Integer -- 1# - | WordTokHash Integer -- 1## - | FloatTokHash Rational -- 1.0# - | DoubleTokHash Rational -- 1.0## - | CharacterHash Char -- c# - | StringHash String -- "Hello world!"# - --- 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 - | Star - --- Template Haskell - | THExpQuote -- [| or [e| - | THPatQuote -- [p| - | THDecQuote -- [d| - | THTypQuote -- [t| - | THCloseQuote -- |] - | THIdEscape (String) -- dollar x - | THParenEscape -- dollar ( - | THVarQuote -- 'x (but without the x) - | THTyQuote -- ''T (but without the T) - --- HaRP - | RPGuardOpen -- (| - | RPGuardClose -- |) - | RPCAt -- @: - --- Hsx - | XCodeTagOpen -- <% - | XCodeTagClose -- %> - | XStdTagOpen -- < - | XStdTagClose -- > - | XCloseTagOpen -- - | XPCDATA String - | XRPatOpen -- <[ - | XRPatClose -- ]> - --- Pragmas - - | PragmaEnd -- #-} - | PragmaUnknown (String,String) -- Any pragma not recognized - | RULES - | INLINE Bool - | SPECIALISE - | SPECIALISE_INLINE Bool - | SOURCE - | DEPRECATED - | WARNING - | SCC - | GENERATED - | CORE - | UNPACK - | OPTIONS (Maybe String,String) - | CFILES String - | LANGUAGE - | INCLUDE String --- These are not yet implemented --- | LINE - --- Reserved Ids - - | KW_As - | KW_Case - | KW_Class - | KW_Data - | KW_Default - | KW_Deriving - | KW_Do - | KW_MDo - | KW_Else - | KW_Family -- indexed type families - | 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_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 ), - ( "*", Star ) - ] - -special_varops :: [(String,Token)] -special_varops = [ - ( "-", Minus ), --ToDo: shouldn't be here - ( "!", Exclamation ) --ditto - ] - -reserved_ids :: [(String,Token)] -reserved_ids = [ - ( "_", Underscore ), - ( "case", KW_Case ), - ( "class", KW_Class ), - ( "data", KW_Data ), - ( "default", KW_Default ), - ( "deriving", KW_Deriving ), - ( "do", KW_Do ), - ( "else", KW_Else ), - ( "family", KW_Family ), -- indexed type families - ( "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 ), - --- 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) - ] - -pragmas :: [(String,Token)] -pragmas = [ - ( "rules", RULES ), - ( "inline", INLINE True ), - ( "noinline", INLINE False ), - ( "notinline", INLINE False ), - ( "specialise", SPECIALISE ), - ( "specialize", SPECIALISE ), - ( "source", SOURCE ), - ( "deprecated", DEPRECATED ), - ( "warning", WARNING ), - ( "scc", SCC ), - ( "generated", GENERATED ), - ( "core", CORE ), - ( "unpack", UNPACK ), - ( "language", LANGUAGE ), - ( "options", OPTIONS undefined ), -- we'll tweak it before use - promise! - ( "cfiles", CFILES undefined ), -- same here... - ( "include", INCLUDE undefined ) -- ...and here! - ] - -isIdent, isHSymbol :: Char -> Bool -isIdent c = isAlpha c || isDigit c || c == '\'' || c == '_' - -isHSymbol c = c `elem` ":!#%&*./?@\\-" || ((isSymbol c || isPunctuation c) && not (c `elem` "(),;[]`{}_\"'")) - -matchChar :: Char -> String -> Lex a () -matchChar c msg = do - s <- getInput - if null s || head s /= c then fail msg else discard 1 - --- The top-level lexer. --- We need to know whether we are at the beginning of the line to decide --- whether to insert layout tokens. - -lexer :: (Token -> P a) -> P a -lexer = runL $ do - bol <- checkBOL - (bol, 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 - return (bol, False) - '{':'-':_ -> do - discard 2 - bol <- lexNestedComment bol - (bol, _) <- lexWhiteSpace bol - return (bol, True) - '-':'-':s | all (== '-') (takeWhile isHSymbol s) -> do - lexWhile (== '-') - lexWhile (/= '\n') - s' <- getInput - case s' of - [] -> fail "Unterminated end-of-line comment" - _ -> do - 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 2 - pushExtContextL HarpCtxt - return XRPatOpen - '<':_ -> do discard 1 - pushExtContextL TagCtxt - return XStdTagOpen - _ -> 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 "" - _ -> 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 - popExtContextL "lexHarpToken" - return XRPatClose - _ -> 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 - '(':'|':c:_ | isHSymbol c -> discard 1 >> return LeftParen - '(':'|':_ -> do discard 2 - return RPGuardOpen - '|':')':_ -> do discard 2 - return RPGuardClose - '@':':':_ -> do discard 2 - return RPCAt - - -- 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 - - -- pragmas - - '{':'-':'#':_ -> do discard 3 >> lexPragmaStart - - '#':'-':'}':_ -> do discard 3 >> return PragmaEnd - - 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 - - '\'' -> lexCharacter - '"' -> lexString - - _ -> fail ("Illegal character \'" ++ show c ++ "\'\n") - - where lexIdents :: Lex a [String] - lexIdents = do - ident <- lexWhile isIdent - s <- getInput - case s of - '-':c:_ | isAlpha c -> do - discard 1 - idents <- lexIdents - return $ ident : idents - '#':_ -> do - discard 1 - return [ident ++ "#"] - _ -> return [ident] - - -lexPragmaStart :: Lex a Token -lexPragmaStart = do - lexWhile isSpace - pr <- lexWhile isAlphaNum - case lookup (map toLower pr) pragmas of - Just SPECIALISE -> do - s <- getInput - case dropWhile isSpace $ map toLower s of - 'i':'n':'l':'i':'n':'e':_ -> do - lexWhile isSpace - discard 6 - return $ SPECIALISE_INLINE True - 'n':'o':'i':'n':'l':'i':'n':'e':_ -> do - lexWhile isSpace - discard 8 - return $ SPECIALISE_INLINE False - 'n':'o':'t':'i':'n':'l':'i':'n':'e':_ -> do - lexWhile isSpace - discard 9 - return $ SPECIALISE_INLINE False - _ -> return SPECIALISE - - Just (OPTIONS _) -> do -- see, I promised we'd mask out the 'undefined' - s <- getInput - case s of - '_':_ -> do - discard 1 - com <- lexWhile isIdent - rest <- lexRawPragma - return $ OPTIONS (Just com, rest) - x:_ | isSpace x -> do - rest <- lexRawPragma - return $ OPTIONS (Nothing, rest) - _ -> fail "Malformed Options pragma" - Just (CFILES _) -> do - rest <- lexRawPragma - return $ CFILES rest - Just (INCLUDE _) -> do - rest <- lexRawPragma - return $ INCLUDE rest - Just p -> return p - - _ -> do rawStr <- lexRawPragma - return $ PragmaUnknown (pr, rawStr) - -lexRawPragma :: Lex a String -lexRawPragma = do - rpr <- lexRawPragmaAux - return $ dropWhile isSpace rpr - where lexRawPragmaAux = do - rpr <- lexWhile (/='#') - s <- getInput - case s of - '#':'-':'}':_ -> return rpr - _ -> do - discard 1 - rpr' <- lexRawPragma - return $ rpr ++ '#':rpr' - -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 - con <- lexHash FloatTok FloatTokHash (Right DoubleTokHash) - return $ con ((num%1) * 10^^(exponent - decimals)) - e:_ | toLower e == 'e' -> do - exponent <- lexExponent - con <- lexHash FloatTok FloatTokHash (Right DoubleTokHash) - return $ con ((parseInteger 10 ds%1) * 10^^exponent) - '#':'#':_ -> discard 2 >> return (WordTokHash (parseInteger 10 ds)) - '#':_ -> discard 1 >> return (IntTokHash (parseInteger 10 ds)) - _ -> 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" - -lexHash :: (b -> Token) -> (b -> Token) -> Either String (b -> Token) -> Lex a (b -> Token) -lexHash a b c = do - r <- getInput - case r of - '#':'#':_ -> case c of - Right c -> discard 2 >> return c - Left s -> fail s - '#':_ -> discard 1 >> return b - _ -> return a - -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 - s <- getInput - ident' <- case s of - '#':_ -> discard 1 >> return (ident ++ "#") - _ -> return ident - 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) - - '#':c:_ - | isSpace c -> do - discard 1 - case conid of - ConId con -> return $ ConId $ con ++ "#" - QConId (q,con) -> return $ QConId (q,con ++ "#") - _ -> return conid -- not a qualified thing - -lexCharacter :: Lex a Token -lexCharacter = do -- We need to keep track of not only character constants but also TH 'x and ''T - -- We've seen ' so far - s <- getInput - case s of - '\'':_ -> discard 1 >> return THTyQuote - '\\':_ -> do - c <- lexEscape - matchQuote - con <- lexHash Character CharacterHash - (Left "Double hash not available for character literals") - return (con c) - c:'\'':_ -> do - discard 2 - con <- lexHash Character CharacterHash - (Left "Double hash not available for character literals") - return (con c) - _ -> return THVarQuote - - where matchQuote = matchChar '\'' "Improperly terminated 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 2 - return (StringHash (reverse 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/Exts/ParseMonad.hs b/Language/Haskell/Exts/ParseMonad.hs deleted file mode 100644 --- a/Language/Haskell/Exts/ParseMonad.hs +++ /dev/null @@ -1,291 +0,0 @@ --- #hide ------------------------------------------------------------------------------ --- | --- Module : Language.Haskell.Exts.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.Exts.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.Exts.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/Exts/ParseUtils.hs b/Language/Haskell/Exts/ParseUtils.hs deleted file mode 100644 --- a/Language/Haskell/Exts/ParseUtils.hs +++ /dev/null @@ -1,775 +0,0 @@ --- #hide ------------------------------------------------------------------------------ --- | --- Module : Language.Haskell.Exts.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.Exts.ParseUtils ( - splitTyConApp -- Type -> P (Name,[Type]) - , mkRecConstrOrUpdate -- Exp -> [FieldUpdate] -> P S.Exp - , checkPrec -- Integer -> P Int - , checkContext -- Type -> P Context - , checkAssertion -- Type -> P Asst - , checkDataHeader -- Type -> P (Context,Name,[Name]) - , checkClassHeader -- Type -> P (Context,Name,[Name]) - , checkInstHeader -- Type -> P (Context,QName,[Type]) - , checkPattern -- PExp -> P Pat - , checkExpr -- PExp -> P Exp - , checkValDef -- SrcLoc -> S.Exp -> Rhs -> [Decl] -> P Decl - , checkClassBody -- [ClassDecl] -> P [ClassDecl] - , checkInstBody -- [InstDecl] -> P [InstDecl] - , checkUnQual -- QName -> P Name - , checkRevDecls -- [Decl] -> P [Decl] - , checkRevClsDecls -- [ClassDecl] -> P [ClassDecl] - , checkRevInstDecls -- [InstDecl] -> P [InstDecl] - , checkDataOrNew -- DataOrNew -> [Decl] -> P () - , checkSimpleType -- Type -> P () - , checkSigVar -- PExp -> P Name - , getGConName -- S.Exp -> P QName - , mkTyForall -- Maybe [Name] -> Context -> Type -> Type - -- HaRP - , checkRPattern -- PExp -> P RPat - -- Hsx - , checkEqNames -- XName -> XName -> P XName - , mkPageModule -- [OptionPragma] -> S.Exp -> P Module - , mkPage -- [OptionPragma] -> Module -> SrcLoc -> S.Exp -> P Module - , mkDVar -- [String] -> String - , mkDVarExpr -- [String] -> ParseExp - -- Pragmas - , checkRuleExpr -- PExp -> P Exp - , readTool -- Maybe String -> Maybe Tool - - -- Parsed expressions - , PExp(..), PFieldUpdate(..), ParseXAttr(..) - , p_unit_con -- PExp - , p_tuple_con -- Int -> PExp - ) where - -import Language.Haskell.Exts.Syntax hiding ( Exp(..), FieldUpdate(..), XAttr(..) ) -import qualified Language.Haskell.Exts.Syntax as S ( Exp(..), FieldUpdate(..), XAttr(..) ) -import Language.Haskell.Exts.ParseMonad -import Language.Haskell.Exts.Pretty -import Language.Haskell.Exts.Build - -import Data.List (intersperse) - -splitTyConApp :: Type -> P (Name,[Type]) -splitTyConApp t0 = split t0 [] - where - split :: Type -> [Type] -> P (Name,[Type]) - split (TyApp t u) ts = split t (u:ts) - split (TyCon (UnQual t)) ts = return (t,ts) - split (TyInfix a op b) ts = split (TyCon op) (a:b:ts) - split _ _ = fail "Illegal data/newtype declaration" - ------------------------------------------------------------------------------ --- Various Syntactic Checks - -checkContext :: Type -> P Context -checkContext (TyTuple 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 :: Type -> P Asst -checkAssertion (TyPred p@(IParam _ _)) = return p -checkAssertion (TyPred p@(EqualP _ _)) = return p -checkAssertion t = checkAssertion' [] t - where checkAssertion' ts (TyCon c) = return $ ClassA c ts - checkAssertion' ts (TyApp a t) = checkAssertion' (t:ts) a - checkAssertion' ts (TyInfix a op b) = checkAssertion' (a:b:ts) (TyCon op) - checkAssertion' _ _ = fail "Illegal class assertion" - - -checkDataHeader :: Type -> P (Context,Name,[Name]) -checkDataHeader (TyForall 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 :: Type -> P (Context,Name,[Name]) -checkClassHeader (TyForall 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 -> Type -> [Name] -> P (Name,[Name]) -checkSimple kw (TyApp l (TyVar a)) xs = checkSimple kw l (a:xs) -checkSimple _kw (TyInfix (TyVar a) (UnQual t) (TyVar b)) xs = return (t,a:b:xs) -checkSimple _kw (TyCon (UnQual t)) xs = return (t,xs) --- checkSimple _kw (TyKind t k) = ... -checkSimple kw _ _ = fail ("Illegal " ++ kw ++ " declaration") - -checkInstHeader :: Type -> P (Context,QName,[Type]) -checkInstHeader (TyForall Nothing cs t) = do - (c,ts) <- checkInsts t [] - return (cs,c,ts) -checkInstHeader t = do - (c,ts) <- checkInsts t [] - return ([],c,ts) - - -checkInsts :: Type -> [Type] -> P ((QName,[Type])) -checkInsts (TyApp l t) ts = checkInsts l (t:ts) -checkInsts (TyCon c) ts = return (c,ts) -checkInsts _ _ = fail "Illegal instance declaration" - ------------------------------------------------------------------------------ --- Checking Patterns. - --- We parse patterns as expressions and check for valid patterns below, --- converting the expression into a pattern at the same time. - -checkPattern :: PExp -> P Pat -checkPattern e = checkPat e [] - -checkPat :: PExp -> [Pat] -> P Pat -checkPat (Con c) args = return (PApp c args) -checkPat (App f x) args = do - x <- checkPat x [] - checkPat f (x:args) -checkPat e [] = case e of - Var (UnQual x) -> return (PVar x) - Lit l -> return (PLit l) - InfixApp l op r -> - case op of - QConOp c -> do - l <- checkPat l [] - r <- checkPat r [] - return (PInfixApp l c r) - QVarOp (UnQual (Symbol "+")) -> do - case (l,r) of - (Var (UnQual n@(Ident _)), Lit (Int k)) -> return (PNPlusK n k) - _ -> patFail "" - _ -> patFail "" - Tuple es -> do - ps <- mapM (\e -> checkPat e []) es - return (PTuple ps) - List es -> do - ps <- mapM checkRPattern es - return $ if all isStdPat ps - then PList $ map stripRP ps - else PRPat $ map fixRPOpPrec ps - where isStdPat :: RPat -> Bool - isStdPat (RPPat _) = True - isStdPat (RPAs _ p) = isStdPat p - isStdPat _ = False - stripRP :: RPat -> Pat - stripRP (RPPat p) = p - stripRP (RPAs n p) = PAsPat n (stripRP p) - stripRP _ = error "cannot strip RP wrapper if not all patterns are base" - - Paren e -> do - p <- checkPat e [] - return (PParen p) - AsPat n e -> do - p <- checkPat e [] - return (PAsPat n p) - WildCard -> return PWildCard - IrrPat e -> do - p <- checkPat e [] - return (PIrrPat p) - ViewPat e p -> do - e <- checkExpr e - p <- checkPat p [] - return (PViewPat e p) - RecConstr c fs -> do - fs <- mapM checkPatField fs - return (PRec c fs) - NegApp (Lit l) -> return (PNeg (PLit l)) - ExpTypeSig s e t -> do - p <- checkPat e [] - return (PatTypeSig s p t) - - -- Hsx - XTag 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 cps = mkChildrenPat pcs - return $ PXTag s n pattrs mpattr cps - XETag s n attrs mattr -> do - pattrs <- mapM checkPAttr attrs - mpattr <- maybe (return Nothing) - (\e -> do p <- checkPat e [] - return $ Just p) - mattr - return $ PXETag s n pattrs mpattr - XPcdata pcdata -> return $ PXPcdata pcdata - XExpTag e -> do - p <- checkPat e [] - return $ PXPatTag p - XRPats es -> do - rps <- mapM checkRPattern es - return (PXRPats $ map fixRPOpPrec rps) - e -> patFail $ show e - -checkPat e _ = patFail $ show e - -checkPatField :: PFieldUpdate -> P PatField -checkPatField (FieldUpdate n e) = do - p <- checkPat e [] - return (PFieldPat n p) -checkPatField (FieldPun n) = return (PFieldPun n) -checkPatField (FieldWildcard) = return PFieldWildcard - -checkPAttr :: ParseXAttr -> P PXAttr -checkPAttr (XAttr n v) = do p <- checkPat v [] - return $ PXAttr n p - -patFail :: String -> P a -patFail s = fail $ "Parse error in pattern: " ++ s - -checkRPattern :: PExp -> P RPat -checkRPattern e = case e of - SeqRP es -> do - rps <- mapM checkRPattern es - return $ RPSeq rps - PostOp e op -> do - rpop <- checkRPatOp op - rp <- checkRPattern e - return $ RPOp rp rpop - GuardRP e gs -> do - rp <- checkPattern e - return $ RPGuard rp gs - EitherRP e1 e2 -> do - rp1 <- checkRPattern e1 - rp2 <- checkRPattern e2 - return $ RPEither rp1 rp2 - CAsRP n e -> do - rp <- checkRPattern e - return $ RPCAs n rp - AsPat n e -> do - rp <- checkRPattern e - return $ RPAs n rp - Paren e -> do - rp <- checkRPattern e - return $ RPParen rp - _ -> do - p <- checkPattern e - return $ RPPat p - -checkRPatOp :: QOp -> P RPatOp -checkRPatOp o@(QVarOp (UnQual (Symbol sym))) = - case sym of - "*" -> return RPStar - "*!" -> return RPStarG - "+" -> return RPPlus - "+!" -> return RPPlusG - "?" -> return RPOpt - "?!" -> return RPOptG - _ -> rpOpFail o -checkRPatOp o = rpOpFail o - -rpOpFail sym = fail $ "Unrecognized regular pattern operator: " ++ show sym - -fixRPOpPrec :: RPat -> RPat -fixRPOpPrec rp = case rp of - RPOp rp rpop -> fPrecOp rp (flip RPOp rpop) - RPEither rp1 rp2 -> RPEither (fixRPOpPrec rp1) (fixRPOpPrec rp2) - RPSeq rps -> RPSeq $ map fixRPOpPrec rps - RPCAs n rp -> RPCAs n $ fixRPOpPrec rp - RPAs n rp -> RPAs n $ fixRPOpPrec rp - RPParen rp -> RPParen $ fixRPOpPrec rp - _ -> rp - - where fPrecOp :: RPat -> (RPat -> RPat) -> RPat - fPrecOp (RPOp rp rpop) f = fPrecOp rp (f . flip RPOp rpop) - fPrecOp (RPCAs n rp) f = fPrecAs rp f (RPCAs n) - fPrecOp (RPAs n rp) f = fPrecAs rp f (RPAs n) - fPrecOp rp f = f $ fixRPOpPrec rp - fPrecAs :: RPat -> (RPat -> RPat) -> (RPat -> RPat) -> RPat - fPrecAs (RPCAs n rp) f g = fPrecAs rp f (g . RPCAs n) - fPrecAs (RPAs n rp) f g = fPrecAs rp f (g . RPAs n) - fPrecAs rp f g = g . f $ fixRPOpPrec rp - - -mkChildrenPat :: [Pat] -> [Pat] -mkChildrenPat ps = mkCPAux ps [] - where mkCPAux :: [Pat] -> [Pat] -> [Pat] - mkCPAux [] qs = reverse qs - mkCPAux (p:ps) qs = case p of - (PRPat rps) -> [mkCRP ps (reverse rps ++ map RPPat qs)] - _ -> mkCPAux ps (p:qs) - - mkCRP :: [Pat] -> [RPat] -> Pat - mkCRP [] rps = PXRPats $ reverse rps - mkCRP (p:ps) rps = case p of - (PXRPats rqs) -> mkCRP ps (reverse rqs ++ rps) - _ -> mkCRP ps (RPPat p : rps) - ------------------------------------------------------------------------------ --- Check Expression Syntax - -checkExpr :: PExp -> P S.Exp -checkExpr e = case e of - Var v -> return $ S.Var v - IPVar v -> return $ S.IPVar v - Con c -> return $ S.Con c - Lit l -> return $ S.Lit l - InfixApp e1 op e2 -> check2Exprs e1 e2 (flip S.InfixApp op) - App e1 e2 -> check2Exprs e1 e2 S.App - NegApp e -> check1Expr e S.NegApp - Lambda loc ps e -> check1Expr e (S.Lambda loc ps) - Let bs e -> check1Expr e (S.Let bs) - If e1 e2 e3 -> check3Exprs e1 e2 e3 S.If - Case e alts -> do - e <- checkExpr e - return (S.Case e alts) - Do stmts -> return (S.Do stmts) - MDo stmts -> return (S.MDo stmts) - Tuple es -> checkManyExprs es S.Tuple - List es -> checkManyExprs es S.List - -- Since we don't parse things as left sections, we need to mangle them into that. - Paren e -> case e of - PostOp e1 op -> check1Expr e1 (flip S.LeftSection op) - _ -> check1Expr e S.Paren - RightSection op e -> check1Expr e (S.RightSection op) - RecConstr c fields -> do - fields <- mapM checkField fields - return (S.RecConstr c fields) - RecUpdate e fields -> do - fields <- mapM checkField fields - e <- checkExpr e - return (S.RecUpdate e fields) - EnumFrom e -> check1Expr e S.EnumFrom - EnumFromTo e1 e2 -> check2Exprs e1 e2 S.EnumFromTo - EnumFromThen e1 e2 -> check2Exprs e1 e2 S.EnumFromThen - EnumFromThenTo e1 e2 e3 -> check3Exprs e1 e2 e3 S.EnumFromThenTo - ListComp e stmts -> do - e <- checkExpr e - return (S.ListComp e stmts) - ExpTypeSig loc e ty -> do - e <- checkExpr e - return (S.ExpTypeSig loc e ty) - - -- Dashed variables - - - --Template Haskell - BracketExp e -> return $ S.BracketExp e - SpliceExp e -> return $ S.SpliceExp e - TypQuote q -> return $ S.TypQuote q - VarQuote q -> return $ S.VarQuote q - - -- Hsx - XTag 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 $ S.XTag s n attrs mattr cs - XETag s n attrs mattr -> do attrs <- mapM checkAttr attrs - mattr <- maybe (return Nothing) - (\e -> checkExpr e >>= return . Just) - mattr - return $ S.XETag s n attrs mattr - XPcdata p -> return $ S.XPcdata p - XExpTag e -> do e <- checkExpr e - return $ S.XExpTag e - -- Pragmas - CorePragma s -> return $ S.CorePragma s - SCCPragma s -> return $ S.SCCPragma s - GenPragma s xx yy -> return $ S.GenPragma s xx yy - UnknownExpPragma n s -> return $ S.UnknownExpPragma n s - - _ -> fail $ "Parse error in expression: " ++ show e - -checkAttr :: ParseXAttr -> P S.XAttr -checkAttr (XAttr n v) = do v <- checkExpr v - return $ S.XAttr n v - --- type signature for polymorphic recursion!! -check1Expr :: PExp -> (S.Exp -> a) -> P a -check1Expr e1 f = do - e1 <- checkExpr e1 - return (f e1) - -check2Exprs :: PExp -> PExp -> (S.Exp -> S.Exp -> a) -> P a -check2Exprs e1 e2 f = do - e1 <- checkExpr e1 - e2 <- checkExpr e2 - return (f e1 e2) - -check3Exprs :: PExp -> PExp -> PExp -> (S.Exp -> S.Exp -> S.Exp -> a) -> P a -check3Exprs e1 e2 e3 f = do - e1 <- checkExpr e1 - e2 <- checkExpr e2 - e3 <- checkExpr e3 - return (f e1 e2 e3) - -checkManyExprs :: [PExp] -> ([S.Exp] -> a) -> P a -checkManyExprs es f = do - es <- mapM checkExpr es - return (f es) - - -checkRuleExpr :: PExp -> P S.Exp -checkRuleExpr = checkExpr - -readTool :: Maybe String -> Maybe Tool -readTool = fmap readC - where readC str = case str of - "GHC" -> GHC - "HUGS" -> HUGS - "NHC98" -> NHC98 - "YHC" -> YHC - "HADDOCK" -> HADDOCK - _ -> UnknownTool str - -{- -checkAlt :: Alt -> P Alt -checkAlt (Alt loc p galts bs) = do - galts <- checkGAlts galts - return (Alt loc p galts bs) - -checkGAlts :: GuardedAlts -> P GuardedAlts -checkGAlts (UnGuardedAlt e) = check1Expr e UnGuardedAlt -checkGAlts (GuardedAlts galts) = do - galts <- mapM checkGAlt galts - return (GuardedAlts galts) - -checkGAlt :: GuardedAlt -> P GuardedAlt -checkGAlt (GuardedAlt loc g e) = check1Expr e (GuardedAlt loc g) - -checkStmt :: Stmt -> P Stmt -checkStmt (Generator loc p e) = check1Expr e (Generator loc p) -checkStmt (Qualifier e) = check1Expr e Qualifier -checkStmt s@(LetStmt _) = return s --} -checkField :: PFieldUpdate -> P S.FieldUpdate -checkField (FieldUpdate n e) = check1Expr e (S.FieldUpdate n) -checkField (FieldPun n) = return $ S.FieldPun n -checkField (FieldWildcard) = return S.FieldWildcard - -getGConName :: S.Exp -> P QName -getGConName (S.Con n) = return n -getGConName (S.List []) = return list_cons_name -getGConName _ = fail "Expression in reification is not a name" - ------------------------------------------------------------------------------ --- Check Equation Syntax - -checkValDef :: SrcLoc -> PExp -> Maybe Type -> Rhs -> Binds -> P Decl -checkValDef srcloc lhs optsig rhs whereBinds = - case isFunLhs lhs [] of - Just (f,es) -> do - ps <- mapM checkPattern es - return (FunBind [Match srcloc f ps optsig rhs whereBinds]) - Nothing -> do - lhs <- checkPattern lhs - return (PatBind srcloc lhs optsig rhs whereBinds) - --- A variable binding is parsed as an PatBind. - -isFunLhs :: PExp -> [PExp] -> Maybe (Name, [PExp]) -isFunLhs (InfixApp l (QVarOp (UnQual op)) r) es = Just (op, l:r:es) -isFunLhs (App (Var (UnQual f)) e) es = Just (f, e:es) -isFunLhs (App (Paren f) e) es = isFunLhs f (e:es) -isFunLhs (App f e) es = isFunLhs f (e:es) -isFunLhs _ _ = Nothing - --- Separating between signature declarations and value definitions in --- a post-processing step - -checkSigVar :: PExp -> P Name -checkSigVar (Var (UnQual n)) = return n -checkSigVar e = fail $ "Left-hand side of type signature is not a variable: " ++ show e - ------------------------------------------------------------------------------ --- In a class or instance body, a pattern binding must be of a variable. - -checkClassBody :: [ClassDecl] -> P [ClassDecl] -checkClassBody decls = do - mapM_ checkClassMethodDef decls - return decls - where checkClassMethodDef (ClsDecl decl) = checkMethodDef decl - checkClassMethodDef _ = return () - -checkInstBody :: [InstDecl] -> P [InstDecl] -checkInstBody decls = do - mapM_ checkInstMethodDef decls - return decls - where checkInstMethodDef (InsDecl decl) = checkMethodDef decl - checkInstMethodDef _ = return () - -checkMethodDef :: Decl -> P () -checkMethodDef (PatBind _ (PVar _) _ _ _) = return () -checkMethodDef (PatBind 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 :: QName -> P Name -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 :: XName -> XName -> P XName -checkEqNames n@(XName n1) (XName n2) - | n1 == n2 = return n - | otherwise = fail "names in matching xml tags are not equal" -checkEqNames n@(XDomName d1 n1) (XDomName 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 :: PExp -> [PFieldUpdate] -> P PExp -mkRecConstrOrUpdate (Con c) fs = return (RecConstr c fs) -mkRecConstrOrUpdate e fs@(_:_) = return (RecUpdate e fs) -mkRecConstrOrUpdate _ _ = fail "Empty record update" - ------------------------------------------------------------------------------ --- Reverse a list of declarations, merging adjacent FunBinds of the --- same name and checking that their arities match. - -checkRevDecls :: [Decl] -> P [Decl] -checkRevDecls = mergeFunBinds [] - where - mergeFunBinds revDs [] = return revDs - mergeFunBinds revDs (FunBind ms1@(Match _ name ps _ _ _:_):ds1) = - mergeMatches ms1 ds1 - where - arity = length ps - mergeMatches ms' (FunBind ms@(Match 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 (FunBind ms':revDs) ds - mergeFunBinds revDs (d:ds) = mergeFunBinds (d:revDs) ds - -checkRevClsDecls :: [ClassDecl] -> P [ClassDecl] -checkRevClsDecls = mergeClsFunBinds [] - where - mergeClsFunBinds revDs [] = return revDs - mergeClsFunBinds revDs (ClsDecl (FunBind ms1@(Match _ name ps _ _ _:_)):ds1) = - mergeMatches ms1 ds1 - where - arity = length ps - mergeMatches ms' (ClsDecl (FunBind ms@(Match 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 = mergeClsFunBinds (ClsDecl (FunBind ms'):revDs) ds - mergeClsFunBinds revDs (d:ds) = mergeClsFunBinds (d:revDs) ds - -checkRevInstDecls :: [InstDecl] -> P [InstDecl] -checkRevInstDecls = mergeInstFunBinds [] - where - mergeInstFunBinds revDs [] = return revDs - mergeInstFunBinds revDs (InsDecl (FunBind ms1@(Match _ name ps _ _ _:_)):ds1) = - mergeMatches ms1 ds1 - where - arity = length ps - mergeMatches ms' (InsDecl (FunBind ms@(Match 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 = mergeInstFunBinds (InsDecl (FunBind ms'):revDs) ds - mergeInstFunBinds revDs (d:ds) = mergeInstFunBinds (d:revDs) ds - ----------------------------------------------------------------- --- Check that newtype declarations have --- the right number (1) of constructors - -checkDataOrNew :: DataOrNew -> [a] -> P () -checkDataOrNew NewType [x] = return () -checkDataOrNew DataType _ = return () -checkDataOrNew _ _ = fail "newtype declaration must have exactly one constructor." - -checkSimpleType :: Type -> P (Name, [Name]) -checkSimpleType t = checkSimple "test" t [] - ---------------------------------------- --- Converting a complete page - -pageFun :: SrcLoc -> S.Exp -> Decl -pageFun loc e = PatBind loc namePat Nothing rhs (BDecls []) - where namePat = PVar $ Ident "page" - rhs = UnGuardedRhs e - -mkPage :: Module -> SrcLoc -> S.Exp -> P Module -mkPage (Module src md os warn exps imps decls) loc xml = do - let page = pageFun loc xml - return $ Module src md os warn exps imps (decls ++ [page]) - -mkPageModule :: [OptionPragma] -> S.Exp -> P Module -mkPageModule os xml = do - do loc <- case xml of - S.XTag l _ _ _ _ -> return l - S.XETag l _ _ _ -> return l - _ -> fail "Will not happen since mkPageModule is only called on XML expressions" - mod <- getModuleName - return $ (Module - loc - (ModuleName mod) - os - Nothing - (Just [EVar $ UnQual $ Ident "page"]) - [] - [pageFun loc xml]) - ---------------------------------------- --- Handle dash-identifiers - -mkDVar :: [String] -> String -mkDVar = concat . intersperse "-" - -mkDVarExpr :: [String] -> PExp -mkDVarExpr = foldl1 (\x y -> InfixApp x (op $ sym "-") y) . map (Var . UnQual . 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 - -mkTyForall :: Maybe [TyVarBind] -> Context -> Type -> Type -mkTyForall mtvs [] ty = mk_forall_ty mtvs ty -mkTyForall mtvs ctxt ty = TyForall 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 (TyForall mtvs2 ctxt ty) = mkTyForall (mtvs1 `plus` mtvs2) ctxt ty -mk_forall_ty mtvs1 ty = TyForall mtvs1 [] ty - -mtvs1 `plus` Nothing = mtvs1 -Nothing `plus` mtvs2 = mtvs2 -(Just tvs1) `plus` (Just tvs2) = Just (tvs1 ++ tvs2) - ---------------------------------------- --- Expressions as we parse them (and patters, and regular patterns) - -data PExp - = Var QName -- ^ variable - | IPVar IPName -- ^ implicit parameter variable - | Con QName -- ^ data constructor - | Lit Literal -- ^ literal constant - | InfixApp PExp QOp PExp -- ^ infix application - | App PExp PExp -- ^ ordinary application - | NegApp PExp -- ^ negation expression @-@ /exp/ - | Lambda SrcLoc [Pat] PExp -- ^ lambda expression - | Let Binds PExp -- ^ local declarations with @let@ - | If PExp PExp PExp -- ^ @if@ /exp/ @then@ /exp/ @else@ /exp/ - | Case PExp [Alt] -- ^ @case@ /exp/ @of@ /alts/ - | Do [Stmt] -- ^ @do@-expression: - -- the last statement in the list - -- should be an expression. - | MDo [Stmt] -- ^ @mdo@-expression - | Tuple [PExp] -- ^ tuple expression - | List [PExp] -- ^ list expression - | Paren PExp -- ^ parenthesized expression - | RightSection QOp PExp -- ^ right section @(@/qop/ /exp/@)@ - | RecConstr QName [PFieldUpdate] - -- ^ record construction expression - | RecUpdate PExp [PFieldUpdate] - -- ^ record update expression - | EnumFrom PExp -- ^ unbounded arithmetic sequence, - -- incrementing by 1 - | EnumFromTo PExp PExp -- ^ bounded arithmetic sequence, - -- incrementing by 1 - | EnumFromThen PExp PExp -- ^ unbounded arithmetic sequence, - -- with first two elements given - | EnumFromThenTo PExp PExp PExp - -- ^ bounded arithmetic sequence, - -- with first two elements given - | ListComp PExp [Stmt] -- ^ list comprehension - | ExpTypeSig SrcLoc PExp Type - -- ^ expression type signature - --- Cases used solely for patterns. Not to be left in the final tree. - | AsPat Name PExp -- ^ patterns only - | WildCard -- ^ patterns only - | IrrPat PExp -- ^ patterns only - --- Post-ops for parsing left sections and regular patterns. Not to be left in the final tree. - | PostOp PExp QOp -- ^ post-ops - --- Dashed vars, an artifact of HSX. Not to be left in the final tree. - | DVar [Name] -- ^ dashed variables - --- View patterns - | ViewPat PExp PExp -- ^ patterns only - --- HaRP - | SeqRP [PExp] -- ^ regular patterns only - | GuardRP PExp [Stmt] -- ^ regular patterns only - | EitherRP PExp PExp -- ^ regular patterns only - | CAsRP Name PExp -- ^ regular patterns only - --- Template Haskell - | VarQuote QName -- ^ 'x - | TypQuote QName -- ^ ''T - | BracketExp Bracket - | SpliceExp Splice - --- Hsx - | XTag SrcLoc XName [ParseXAttr] (Maybe PExp) [PExp] - | XETag SrcLoc XName [ParseXAttr] (Maybe PExp) - | XPcdata String - | XExpTag PExp - | XRPats [PExp] - --- Pragmas - | CorePragma String - | SCCPragma String - | GenPragma String (Int, Int) (Int, Int) - | UnknownExpPragma String String - deriving (Eq,Show) - -data PFieldUpdate - = FieldUpdate QName PExp - | FieldPun Name - | FieldWildcard - deriving (Eq,Show) - -data ParseXAttr = XAttr XName PExp - deriving (Eq,Show) - -p_unit_con :: PExp -p_unit_con = Con unit_con_name - -p_tuple_con :: Int -> PExp -p_tuple_con i = Con (tuple_con_name i) diff --git a/Language/Haskell/Exts/Parser.ly b/Language/Haskell/Exts/Parser.ly deleted file mode 100644 --- a/Language/Haskell/Exts/Parser.ly +++ /dev/null @@ -1,1428 +0,0 @@ -> { -> ----------------------------------------------------------------------------- -> -- | -> -- Module : Language.Haskell.Exts.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.Exts.Parser ( -> parseModule, parseModuleWithMode, -> ParseMode(..), defaultParseMode, ParseResult(..)) where -> -> import Language.Haskell.Exts.Syntax hiding ( Exp(..), XAttr(..), FieldUpdate(..) ) -> import Language.Haskell.Exts.Syntax ( Exp ) -> import Language.Haskell.Exts.ParseMonad -> import Language.Haskell.Exts.Lexer -> import Language.Haskell.Exts.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: 7 shift/reduce - -2 for ambiguity in 'case x of y | let z = y in z :: Bool -> b' [State 220, 236] - (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 ...' [State 707] - 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. - -1 for ambiguity using hybrid modules [State 5] - For HSP pages that start with a <% %> block, the parser cannot tell whether - to reduce a srcloc or shift the starting <%. Since any other body could not - start with <%, shifting is the only sensible thing to do. - -1 for ambiguity using toplevel xml modules [State 8] - For HSP xml pages starting with a <, the parser cannot tell whether to shift - that < or reduce an implicit 'open'. Since no other body could possibly start - with <, shifting is the only sensible thing to do. - -1 for ambiguity in '{-# RULES "name" [ ... #-}' [State 212] - we don't know whether the '[' starts the activation or not: it - might be the start of the declaration with the activation being - empty. Resolving with shift means the declaration cannot start with '['. - -1 for ambiguity in 'x :: Int = ...' - we don't know if we should reduce the lefthand side to a type signature - declaration, or shift the '=' and treat the lefthand side as a pattern with - a scoped type variable. Since a type signature declaration couldn't be followed - by a '=', shifting is the only sensible thing to do. ------------------------------------------------------------------------------ - -> %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 $$ } - -> PRIMINT { IntTokHash $$ } -> PRIMWORD { WordTokHash $$ } -> PRIMFLOAT { FloatTokHash $$ } -> PRIMDOUBLE { DoubleTokHash $$ } -> PRIMCHAR { CharacterHash $$ } -> PRIMSTRING { StringHash $$ } - -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 } -> '*' { Star } - -Harp - -> '(|' { RPGuardOpen } -> '|)' { RPGuardClose } -> '@:' { RPCAt } - -Template Haskell - -> IDSPLICE { THIdEscape $$ } -- $x -> '$(' { THParenEscape } -> '[|' { THExpQuote } -> '[p|' { THPatQuote } -> '[t|' { THTypQuote } -> '[d|' { THDecQuote } -> '|]' { THCloseQuote } -> VARQUOTE { THVarQuote } -- 'x -> TYPQUOTE { THTyQuote } -- ''T - -Hsx - -> PCDATA { XPCDATA $$ } -> '<' { XStdTagOpen } -> ' '<%' { XCodeTagOpen } -> '>' { XStdTagClose } -> '/>' { XEmptyTagClose } -> '%>' { XCodeTagClose } -> '<[' { XRPatOpen } -> ']>' { XRPatClose } - -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 } -> 'do' { KW_Do } -> 'else' { KW_Else } -> 'family' { KW_Family } -- indexed type families -> '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 } -> 'qualified' { KW_Qualified } - -Pragmas - -> '{-# INLINE' { INLINE $$ } -> '{-# SPECIALISE' { SPECIALISE } -> '{-# SPECIALISE_INLINE' { SPECIALISE_INLINE $$ } -> '{-# SOURCE' { SOURCE } -> '{-# RULES' { RULES } -> '{-# CORE' { CORE } -> '{-# SCC' { SCC } -> '{-# GENERATED' { GENERATED } -> '{-# DEPRECATED' { DEPRECATED } -> '{-# WARNING' { WARNING } -> '{-# UNPACK' { UNPACK } -> '{-# OPTIONS' { OPTIONS $$ } -> '{-# CFILES' { CFILES $$ } -> '{-# INCLUDE' { INCLUDE $$ } -> '{-# LANGUAGE' { LANGUAGE } -> '{-# unknown' { PragmaUnknown $$ } -> '#-}' { PragmaEnd } - - -> %monad { P } -> %lexer { lexer } { EOF } -> %name parse -> %tokentype { Token } -> %expect 7 -> %% - ------------------------------------------------------------------------------ -HSP Pages - -> page :: { Module } -> : toppragmas topxml {% checkExpr $2 >>= mkPageModule $1 } -> | toppragmas '<%' module '%>' srcloc topxml {% checkExpr $6 >>= \x -> mkPage ($3 $1) $5 x } -> | toppragmas module { $2 $1 } - -> topxml :: { PExp } -> : srcloc '<' name attrs mattr '>' children '' {% do { n <- checkEqNames $3 $9; -> let { cn = reverse $7; -> as = reverse $4; }; -> return $ XTag $1 n as $5 cn } } -> | srcloc '<' name attrs mattr '/>' { XETag $1 $3 (reverse $4) $5 } - - -> toppragmas :: { [OptionPragma] } -> : open toppragmasaux close { $2 } - -> toppragmasaux :: { [OptionPragma] } -> : toppragma ';' toppragmasaux { $1 : $3 } -> | {- nothing -} { [] } - -> toppragma :: { OptionPragma } -> : srcloc '{-# LANGUAGE' conids '#-}' { LanguagePragma $1 $3 } -> | srcloc '{-# INCLUDE' '#-}' { IncludePragma $1 $2 } -> | srcloc '{-# OPTIONS' '#-}' { let (mc, s) = $2 in OptionsPragma $1 (readTool mc) s } -> | srcloc '{-# CFILES' '#-}' { CFilesPragma $1 $2 } -> | srcloc '{-# unknown' '#-}' { let (n, s) = $2 in UnknownTopPragma $1 n s } - -> conids :: { [Name] } -> : conid ',' conids { $1 : $3 } -> | conid { [$1] } - ------------------------------------------------------------------------------ -Module Header - -> module :: { [OptionPragma] -> Module } -> : srcloc 'module' modid maybemodwarning maybeexports 'where' body -> { \os -> Module $1 $3 os $4 $5 (fst $7) (snd $7) } -> | srcloc body -> { \os -> Module $1 main_mod os Nothing (Just [EVar (UnQual main_name)]) -> (fst $2) (snd $2) } - -> maybemodwarning :: { Maybe WarningText } -> : '{-# DEPRECATED' STRING '#-}' { Just $ DeprText $2 } -> | '{-# WARNING' STRING '#-}' { Just $ WarnText $2 } -> | {- empty -} { Nothing } - -> body :: { ([ImportDecl],[Decl]) } -> : '{' bodyaux '}' { $2 } -> | open bodyaux close { $2 } - -> bodyaux :: { ([ImportDecl],[Decl]) } -> : 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 [ExportSpec] } -> : exports { Just $1 } -> | {- empty -} { Nothing } - -> exports :: { [ExportSpec] } -> : '(' exportlist optcomma ')' { reverse $2 } -> | '(' optcomma ')' { [] } - -> optcomma :: { () } -> : ',' { () } -> | {- empty -} { () } - -> exportlist :: { [ExportSpec] } -> : exportlist ',' export { $3 : $1 } -> | export { [$1] } - -> export :: { ExportSpec } -> : qvar { EVar $1 } -> | qtyconorcls { EAbs $1 } -> | qtyconorcls '(' '..' ')' { EThingAll $1 } -> | qtyconorcls '(' ')' { EThingWith $1 [] } -> | qtyconorcls '(' cnames ')' { EThingWith $1 (reverse $3) } -> | 'module' modid { EModuleContents $2 } - ------------------------------------------------------------------------------ -Import Declarations - -> impdecls :: { [ImportDecl] } -> : impdecls semis impdecl { $3 : $1 } -> | impdecl { [$1] } - -> impdecl :: { ImportDecl } -> : srcloc 'import' optsrc optqualified modid maybeas maybeimpspec -> { ImportDecl $1 $5 $4 $3 $6 $7 } - -> optsrc :: { Bool } -> : '{-# SOURCE' '#-}' { True } -> | {- empty -} { False } - -> optqualified :: { Bool } -> : 'qualified' { True } -> | {- empty -} { False } - -> maybeas :: { Maybe ModuleName } -> : 'as' modid { Just $2 } -> | {- empty -} { Nothing } - - -> maybeimpspec :: { Maybe (Bool, [ImportSpec]) } -> : impspec { Just $1 } -> | {- empty -} { Nothing } - -> impspec :: { (Bool, [ImportSpec]) } -> : opthiding '(' importlist optcomma ')' { ($1, reverse $3) } -> | opthiding '(' optcomma ')' { ($1, []) } - -> opthiding :: { Bool } -> : 'hiding' { True } -> | {- empty -} { False } - -> importlist :: { [ImportSpec] } -> : importlist ',' importspec { $3 : $1 } -> | importspec { [$1] } - -> importspec :: { ImportSpec } -> : var { IVar $1 } -> | tyconorcls { IAbs $1 } -> | tyconorcls '(' '..' ')' { IThingAll $1 } -> | tyconorcls '(' ')' { IThingWith $1 [] } -> | tyconorcls '(' cnames ')' { IThingWith $1 (reverse $3) } - -> cnames :: { [CName] } -> : cnames ',' cname { $3 : $1 } -> | cname { [$1] } - -> cname :: { CName } -> : var { VarName $1 } -> | con { ConName $1 } - ------------------------------------------------------------------------------ -Fixity Declarations - -> fixdecl :: { Decl } -> : srcloc infix prec ops { InfixDecl $1 $2 $3 (reverse $4) } - -> prec :: { Int } -> : {- empty -} { 9 } -> | INT {% checkPrec $1 } - -> infix :: { Assoc } -> : 'infix' { AssocNone } -> | 'infixl' { AssocLeft } -> | 'infixr' { AssocRight } - -> ops :: { [Op] } -> : 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 :: { [Decl] } -> : topdecls1 optsemis {% checkRevDecls $1 } - -> topdecls1 :: { [Decl] } -> : topdecls1 semis topdecl { $3 : $1 } -> | topdecl { [$1] } - -> topdecl :: { Decl } -> : srcloc 'type' dtype '=' ctype -> {% do { (c,ts) <- checkSimpleType $3; -> return (TypeDecl $1 c ts $5) } } -> | srcloc 'type' 'family' type optkind -> {% do { (c,ts) <- checkSimpleType $4; -> return (TypeFamDecl $1 c ts $5) } } -> | srcloc 'type' 'instance' dtype '=' ctype -> {% do { -- no checkSimpleType $4 since dtype may contain type patterns -> return (TypeInsDecl $1 $4 $6) } } -> | srcloc data_or_newtype ctype constrs0 deriving -> {% do { (cs,c,t) <- checkDataHeader $3; -> checkDataOrNew $2 $4; -> return (DataDecl $1 $2 cs c t (reverse $4) $5) } } -> | srcloc data_or_newtype ctype optkind 'where' gadtlist deriving -> {% do { (cs,c,t) <- checkDataHeader $3; -> checkDataOrNew $2 $6; -> return (GDataDecl $1 $2 cs c t $4 (reverse $6) $7) } } -> | srcloc 'data' 'family' ctype optkind -> {% do { (cs,c,t) <- checkDataHeader $4; -> return (DataFamDecl $1 cs c t $5) } } -> | srcloc data_or_newtype 'instance' ctype constrs0 deriving -> {% do { -- (cs,c,t) <- checkDataHeader $4; -> checkDataOrNew $2 $5; -> return (DataInsDecl $1 $2 $4 (reverse $5) $6) } } -> | srcloc data_or_newtype 'instance' ctype optkind 'where' gadtlist deriving -> {% do { -- (cs,c,t) <- checkDataHeader $4; -> checkDataOrNew $2 $7; -> return (GDataInsDecl $1 $2 $4 $5 (reverse $7) $8) } } -> | srcloc 'class' ctype fds optcbody -> {% do { (cs,c,vs) <- checkClassHeader $3; -> return (ClassDecl $1 cs c vs $4 $5) } } -> | srcloc 'instance' ctype optvaldefs -> {% do { (cs,c,ts) <- checkInstHeader $3; -> return (InstDecl $1 cs c ts $4) } } -> | srcloc 'deriving' 'instance' ctype -> {% do { (cs, c, ts) <- checkInstHeader $4; -> return (DerivDecl $1 cs c ts) } } -> | srcloc 'default' '(' typelist ')' -> { DefaultDecl $1 $4 } -> | srcloc '$(' trueexp ')' -> { SpliceDecl $1 $ ParenSplice $3 } -> -> | srcloc 'foreign' 'import' callconv safety fspec -> { let (s,n,t) = $6 in ForImp $1 $4 $5 s n t } -> | srcloc 'foreign' 'export' callconv fspec -> { let (s,n,t) = $5 in ForExp $1 $4 s n t } -> | srcloc '{-# RULES' rules '#-}' { RulePragmaDecl $1 $ reverse $3 } -> | srcloc '{-# DEPRECATED' warndeprs '#-}' { DeprPragmaDecl $1 $ reverse $3 } -> | srcloc '{-# WARNING' warndeprs '#-}' { WarnPragmaDecl $1 $ reverse $3 } -> | srcloc '{-# unknown' '#-}' { let (n, s) = $2 in UnknownDeclPragma $1 n s } -> | decl { $1 } - -> data_or_newtype :: { DataOrNew } -> : 'data' { DataType } -> | 'newtype' { NewType } - -> typelist :: { [Type] } -> : types { reverse $1 } -> | type { [$1] } -> | {- empty -} { [] } - -> decls :: { [Decl] } -> : optsemis decls1 optsemis {% checkRevDecls $2 } -> | optsemis { [] } - -> decls1 :: { [Decl] } -> : decls1 semis decl { $3 : $1 } -> | decl { [$1] } - -> decl :: { Decl } -> : signdecl { $1 } -> | fixdecl { $1 } -> | valdef { $1 } - -> decllist :: { [Decl] } -> : '{' decls '}' { $2 } -> | open decls close { $2 } - -> signdecl :: { Decl } -> : srcloc exp0b '::' ctype {% do { v <- checkSigVar $2; -> return $ TypeSig $1 [v] $4 } } -> | srcloc exp0b ',' vars '::' ctype {% do { v <- checkSigVar $2; -> return $ TypeSig $1 (v : reverse $4) $6 } } -> | srcloc '{-# INLINE' activation qvar '#-}' { InlineSig $1 $2 $3 $4 } -> | srcloc '{-# SPECIALISE' qvar '::' sigtypes '#-}' { SpecSig $1 $3 $5 } -> | srcloc '{-# SPECIALISE_INLINE' activation qvar '::' sigtypes '#-}' -> { SpecInlineSig $1 $2 $3 $4 $6 } -> | srcloc '{-# SPECIALISE' 'instance' ctype '#-}' {% do { (cs,c,ts) <- checkInstHeader $4; -> return $ InstSig $1 cs c ts } } - -> sigtypes :: { [Type] } -> : sigtype { [ $1 ] } -> | sigtype ',' sigtypes { $1 : $3 } - -> sigtype :: { Type } -> : ctype { mkTyForall Nothing [] $1 } - -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 :: { Binds } -> : decllist { BDecls $1 } -> | '{' ipbinds '}' { IPBinds $2 } -> | open ipbinds close { IPBinds $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 :: { [Name] } -> : vars ',' var { $3 : $1 } -> | qvar {% do { n <- checkUnQual $1; -> return [n] } } - ------------------------------------------------------------------------------ -FFI - -> callconv :: { CallConv } -> : 'stdcall' { StdCall } -> | 'ccall' { CCall } - -> safety :: { Safety } -> : 'safe' { PlaySafe False } -> | 'unsafe' { PlayRisky } -> | 'threadsafe' { PlaySafe True } -> | {- empty -} { PlaySafe False } - -> fspec :: { (String, Name, Type) } -> : STRING var_no_safety '::' dtype { ($1, $2, $4) } -> | var_no_safety '::' dtype { ("", $1, $3) } - ------------------------------------------------------------------------------ -Pragmas - -> rules :: { [Rule] } -> : rules ';'rule { $3 : $1 } -> | rules ';' { $1 } -> | rule { [$1] } -> | {- empty -} { [] } - -> rule :: { Rule } -> : STRING activation ruleforall exp0 '=' trueexp {% do { e <- checkRuleExpr $4; -> return $ Rule $1 $2 $3 e $6 } } - -> activation :: { Activation } -> : {- empty -} { AlwaysActive } -> | '[' INT ']' { ActiveFrom (fromInteger $2) } -> | '[' '~' INT ']' { ActiveUntil (fromInteger $3) } - -> ruleforall :: { Maybe [RuleVar] } -> : {- empty -} { Nothing } -> | 'forall' rulevars '.' { Just $2 } - -> rulevars :: { [RuleVar] } -> : rulevar { [$1] } -> | rulevar rulevars { $1 : $2 } - -> rulevar :: { RuleVar } -> : varid { RuleVar $1 } -> | '(' varid '::' ctype ')' { TypedRuleVar $2 $4 } - -> warndeprs :: { [([Name],String)] } -> : warndeprs ';' warndepr { $3 : $1 } -> | warndeprs ';' { $1 } -> | warndepr { [$1] } -> | {- empty -} { [] } - -> warndepr :: { ([Name], String) } -> : namevars STRING { ($1,$2) } - -> namevars :: { [Name] } -> : namevar { [$1] } -> | namevar ',' namevars { $1 : $3 } - -> namevar :: { Name } -> : con { $1 } -> | var { $1 } - ------------------------------------------------------------------------------ -Types - -> dtype :: { Type } -> : btype { $1 } -> | btype qtyconop dtype { TyInfix $1 $2 $3 } -> | btype qtyvarop dtype { TyInfix $1 $2 $3 } -> | btype '->' dtype { TyFun $1 $3 } -> | btype '~' btype { TyPred $ EqualP $1 $3 } - -Implicit parameters can occur in normal types, as well as in contexts. - -> type :: { Type } -> : ivar '::' dtype { TyPred $ IParam $1 $3 } -> | dtype { $1 } - -> btype :: { Type } -> : btype atype { TyApp $1 $2 } -> | atype { $1 } - -> atype :: { Type } -> : gtycon { TyCon $1 } -> | tyvar { TyVar $1 } -> | '(' types ')' { TyTuple Boxed (reverse $2) } -> | '(#' types1 '#)' { TyTuple Unboxed (reverse $2) } -> | '[' type ']' { TyApp list_tycon $2 } -> | '(' ctype ')' { $2 } -> | '(' ctype '::' kind ')' { TyKind $2 $4 } - -> gtycon :: { QName } -> : qconid { $1 } -> | '(' ')' { unit_tycon_name } -> | '(' '->' ')' { fun_tycon_name } -> | '[' ']' { list_tycon_name } -> | '(' commas ')' { tuple_tycon_name $2 } - -These are for infix types - -> qtyconop :: { QName } -> : 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 :: { Type } -> : 'forall' ktyvars '.' ctype { mkTyForall (Just $2) [] $4 } -> | context '=>' type { mkTyForall Nothing $1 $3 } -> | type { $1 } - -> context :: { Context } -> : btype {% checkContext $1 } -> | btype '~' btype {% checkContext (TyPred $ EqualP $1 $3) } - -> types :: { [Type] } -> : types1 ',' type { $3 : $1 } - -> types1 :: { [Type] } -> : type { [$1] } -> | types1 ',' type { $3 : $1 } - -> ktyvars :: { [TyVarBind] } -> : ktyvars ktyvar { $2 : $1 } -> | {- empty -} { [] } - -> ktyvar :: { TyVarBind } -> : tyvar { UnkindedVar $1 } -> | '(' tyvar '::' kind ')' { KindedVar $2 $4 } - -> tyvars :: { [Name] } -> : tyvars tyvar { $2 : $1 } -> | {- empty -} { [] } - - ------------------------------------------------------------------------------ -Functional Dependencies - -> fds :: { [FunDep] } -> : {- empty -} { [] } -> | '|' fds1 { reverse $2 } - -> fds1 :: { [FunDep] } -> : fds1 ',' fd { $3 : $1 } -> | fd { [$1] } - -> fd :: { FunDep } -> : tyvars '->' tyvars { FunDep (reverse $1) (reverse $3) } - ------------------------------------------------------------------------------ -Datatype declarations - -GADTs - -> gadtlist :: { [GadtDecl] } -> : '{' gadtconstrs1 '}' { $2 } -> | open gadtconstrs1 close { $2 } - -> gadtconstrs1 :: { [GadtDecl] } -> : optsemis gadtconstrs optsemis { $2 } - -> gadtconstrs :: { [GadtDecl] } -> : gadtconstrs semis gadtconstr { $3 : $1 } -> | gadtconstr { [$1] } - -> gadtconstr :: { GadtDecl } -> : srcloc qcon '::' ctype {% do { c <- checkUnQual $2; -> return $ GadtDecl $1 c $4 } } - -> constrs0 :: { [QualConDecl] } -> : {- empty -} { [] } -> | '=' constrs { $2 } - -> constrs :: { [QualConDecl] } -> : constrs '|' constr { $3 : $1 } -> | constr { [$1] } - -> constr :: { QualConDecl } -> : srcloc forall context '=>' constr1 { QualConDecl $1 $2 $3 $5 } -> | srcloc forall constr1 { QualConDecl $1 $2 [] $3 } - -> forall :: { [TyVarBind] } -> : 'forall' ktyvars '.' { $2 } -> | {- empty -} { [] } - -> constr1 :: { ConDecl } -> : scontype { ConDecl (fst $1) (snd $1) } -> | sbtype conop sbtype { ConDecl $2 [$1,$3] } -> | con '{' '}' { RecDecl $1 [] } -> | con '{' fielddecls '}' { RecDecl $1 (reverse $3) } - -> scontype :: { (Name, [BangType]) } -> : btype {% do { (c,ts) <- splitTyConApp $1; -> return (c,map UnBangedTy ts) } } -> | scontype1 { $1 } - -> scontype1 :: { (Name, [BangType]) } -> : btype '!' atype {% do { (c,ts) <- splitTyConApp $1; -> return (c,map UnBangedTy ts++ -> [BangedTy $3]) } } -> | btype '{-# UNPACK' '#-}' '!' atype {% do { (c,ts) <- splitTyConApp $1; -> return (c,map UnBangedTy ts++ -> [UnpackedTy $5]) } } -> | scontype1 satype { (fst $1, snd $1 ++ [$2] ) } - -> satype :: { BangType } -> : atype { UnBangedTy $1 } -> | '!' atype { BangedTy $2 } -> | '{-# UNPACK' '#-}' '!' atype { UnpackedTy $4 } - -> sbtype :: { BangType } -> : btype { UnBangedTy $1 } -> | '!' atype { BangedTy $2 } -> | '{-# UNPACK' '#-}' '!' atype { UnpackedTy $4 } - -> fielddecls :: { [([Name],BangType)] } -> : fielddecls ',' fielddecl { $3 : $1 } -> | fielddecl { [$1] } - -> fielddecl :: { ([Name],BangType) } -> : vars '::' stype { (reverse $1, $3) } - -> stype :: { BangType } -> : ctype { UnBangedTy $1 } -> | '!' atype { BangedTy $2 } -> | '{-# UNPACK' '#-}' '!' atype { UnpackedTy $4 } - -> deriving :: { [Deriving] } -> : {- empty -} { [] } -> | 'deriving' qtycls1 { [($2, [])] } -> | 'deriving' '(' ')' { [] } -> | 'deriving' '(' dclasses ')' { reverse $3 } - -> dclasses :: { [Deriving] } -> : dclasses ',' qtycls { $3 : $1 } -> | qtycls { [$1] } - -> qtycls :: { Deriving } -> : qtycls1 { ($1, []) } -> | qconid tyconvars { ($1, reverse $2) } - -> tyconvars :: { [QName] } -> : tyconvars tyconvar { $2 : $1 } -> | tyconvar { [$1] } - -> tyconvar :: { QName } -> : qconid { $1 } -> | qvarid { $1 } - -> qtycls1 :: { QName } -> : qconid { $1 } - - ------------------------------------------------------------------------------ -Kinds - -> kind :: { Kind } -> : akind { $1 } -> | akind '->' kind { KindFn $1 $3 } - -> akind :: { Kind } -> : '*' { KindStar } -> | '!' { KindBang } -> | '(' kind ')' { $2 } - -> optkind :: { Maybe Kind } -> : {-empty-} { Nothing } -> | '::' kind { Just $2 } ------------------------------------------------------------------------------ -Class declarations - -No implicit parameters in the where clause of a class declaration. -> optcbody :: { [ClassDecl] } -> : 'where' cldecllist {% checkClassBody $2 } -> | {- empty -} { [] } - -> cldecllist :: { [ClassDecl] } -> : '{' cldecls '}' { $2 } -> | open cldecls close { $2 } - -> cldecls :: { [ClassDecl] } -> : optsemis cldecls1 optsemis {% checkRevClsDecls $2 } -> | optsemis { [] } - -> cldecls1 :: { [ClassDecl] } -> : cldecls1 semis cldecl { $3 : $1 } -> | cldecl { [$1] } - -> cldecl :: { ClassDecl } -> : decl { ClsDecl $1 } -> | atdecl { $1 } - -> atdecl :: { ClassDecl } -> : srcloc 'type' type optkind -> {% do { (c,ts) <- checkSimpleType $3; -> return (ClsTyFam $1 c ts $4) } } -> | srcloc 'type' dtype '=' ctype -> { ClsTyDef $1 $3 $5 } -> | srcloc 'data' ctype optkind -> {% do { (cs,c,t) <- checkDataHeader $3; -> return (ClsDataFam $1 cs c t $4) } } - ------------------------------------------------------------------------------ -Instance declarations - -> optvaldefs :: { [InstDecl] } -> : 'where' '{' valdefs '}' {% checkInstBody $3 } -> | 'where' open valdefs close {% checkInstBody $3 } -> | {- empty -} { [] } - -> valdefs :: { [InstDecl] } -> : optsemis valdefs1 optsemis {% checkRevInstDecls $2 } -> | optsemis { [] } - -> valdefs1 :: { [InstDecl] } -> : valdefs1 semis insvaldef { $3 : $1 } -> | insvaldef { [$1] } - -> insvaldef :: { InstDecl } -> : valdef { InsDecl $1 } -> | atinst { $1 } -> | inlinst { $1 } - -> inlinst :: { InstDecl } -> : srcloc '{-# INLINE' activation qvar '#-}' { InsInline $1 $2 $3 $4 } - -> atinst :: { InstDecl } -> : srcloc 'type' dtype '=' ctype -> {% do { -- no checkSimpleType $4 since dtype may contain type patterns -> return (InsType $1 $3 $5) } } -> | srcloc data_or_newtype ctype constrs0 deriving -> {% do { -- (cs,c,t) <- checkDataHeader $4; -> checkDataOrNew $2 $4; -> return (InsData $1 $2 $3 (reverse $4) $5) } } -> | srcloc data_or_newtype ctype optkind 'where' gadtlist deriving -> {% do { -- (cs,c,t) <- checkDataHeader $4; -> checkDataOrNew $2 $6; -> return (InsGData $1 $2 $3 $4 (reverse $6) $7) } } - ------------------------------------------------------------------------------ -Value definitions - -> valdef :: { Decl } -> : srcloc exp0b optsig rhs optwhere {% checkValDef $1 $2 $3 $4 $5 } - -May bind implicit parameters -> optwhere :: { Binds } -> : 'where' binds { $2 } -> | {- empty -} { BDecls [] } - -> optsig :: { Maybe Type } -> : '::' ctype { Just $2 } -> | {- empty -} { Nothing } - -> rhs :: { Rhs } -> : '=' trueexp { UnGuardedRhs $2 } -> | gdrhs { GuardedRhss (reverse $1) } - -> gdrhs :: { [GuardedRhs] } -> : gdrhs gdrh { $2 : $1 } -> | gdrh { [$1] } - -Guards may contain patterns, hence quals instead of exp. -> gdrh :: { GuardedRhs } -> : srcloc '|' quals '=' trueexp { GuardedRhs $1 (reverse $3) $5 } - ------------------------------------------------------------------------------ -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). - -Ugly: We need non-parenthesized post-operators for HaRP, and to parse both -these and normal left sections, we parse both as PostOp and let the post pass -mangle them into the correct form depending on context. - -> trueexp :: { Exp } -> : exp {% checkExpr $1 } - -> exp :: { PExp } -> : exp0b '::' srcloc ctype { ExpTypeSig $3 $1 $4 } -> | exp0 { $1 } -> | exp0b qop { PostOp $1 $2 } - -> exp0 :: { PExp } -> : exp0a { $1 } -> | exp0b { $1 } - -> exp0a :: { PExp } -> : exp0b qop exp10a { InfixApp $1 $2 $3 } -> | exp10a { $1 } - -> exp0b :: { PExp } -> : exp0b qop exp10b { InfixApp $1 $2 $3 } -> | exp10b { $1 } - -> exp10a :: { PExp } -> : '\\' srcloc apats '->' exp { Lambda $2 (reverse $3) $5 } -A let may bind implicit parameters -> | 'let' binds 'in' exp { Let $2 $4 } -> | 'if' exp 'then' exp 'else' exp { If $2 $4 $6 } - -> exp10b :: { PExp } -> : 'case' exp 'of' altslist { Case $2 $4 } -> | '-' fexp { NegApp $2 } -> | 'do' stmtlist { Do $2 } -> | 'mdo' stmtlist { MDo $2 } -> | exppragma { $1 } -> | fexp { $1 } - -> exppragma :: { PExp } -> : '{-# CORE' STRING '#-}' { CorePragma $2 } -> | '{-# SCC' STRING '#-}' { SCCPragma $2 } -> | '{-# GENERATED' STRING INT ':' INT '-' INT ':' INT '#-}' -> { GenPragma $2 (fromInteger $3, fromInteger $5) -> (fromInteger $7, fromInteger $9) } -> | '{-# unknown' '#-}' { let (n, s) = $1 in UnknownExpPragma n s } - -> fexp :: { PExp } -> : fexp aexp { App $1 $2 } -> | aexp { $1 } - -> apats :: { [Pat] } -> : apats apat { $2 : $1 } -> | apat { [$1] } - -> apat :: { Pat } -> : 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 :: { PExp } -> : qvar '@' aexp {% do { n <- checkUnQual $1; -> return (AsPat n $3) } } -> | qvar '@:' aexp {% do { n <- checkUnQual $1; -> return (CAsRP n $3) } } -> | '~' aexp { IrrPat $2 } -> | aexp1 { $1 } - -Note: The first two alternatives of aexp1 are not necessarily record -updates: they could be labeled constructions. - -> aexp1 :: { PExp } -> : aexp1 '{' '}' {% mkRecConstrOrUpdate $1 [] } -> | aexp1 '{' fbinds '}' {% mkRecConstrOrUpdate $1 (reverse $3) } -> | aexp2 { $1 } - -According to the Report, the left section (e op) is legal iff (e op x) -parses equivalently to ((e) op x). Thus e must be an exp0b. -An implicit parameter can be used as an expression. - -> aexp2 :: { PExp } -> : ivar { IPVar $1 } -> | qvar { Var $1 } -> | gcon { $1 } -> | literal { Lit $1 } -> | '(' texp ')' { Paren $2 } -> | '(' texp ',' texps ')' { Tuple ($2 : reverse $4) } -> | '[' list ']' { $2 } -We parse left sections as PostOp instead, and post-mangle them, see above - | '(' exp0b rqop ')' { LeftSection $2 $3 } -> | '(' qopm exp0 ')' { RightSection $2 $3 } -> | '_' { WildCard } -> | '(' erpats ')' { $2 } -> | '(|' sexps '|)' { SeqRP $ reverse $2 } -> | '(|' exp '|' quals '|)' { GuardRP $2 $ reverse $4 } -This has to go here since we cannot know what precedes or follows it. -> | dvarexp { $1 } -> | xml { $1 } - -Template Haskell -> | IDSPLICE { SpliceExp $ IdSplice $1 } -> | '$(' trueexp ')' { SpliceExp $ ParenSplice $2 } -> | '[|' trueexp '|]' { BracketExp $ ExpBracket $2 } -> | '[p|' exp0 '|]' {% do { p <- checkPattern $2; -> return $ BracketExp $ PatBracket p } } -> | '[t|' ctype '|]' { BracketExp $ TypeBracket $2 } -> | '[d|' open topdecls close '|]' { BracketExp $ DeclBracket $3 } -> | VARQUOTE qvar { VarQuote $2 } -> | VARQUOTE qcon { VarQuote $2 } -> | TYPQUOTE tyvar { TypQuote (UnQual $2) } -> | TYPQUOTE gtycon { TypQuote $2 } -End Template Haskell - -> commas :: { Int } -> : commas ',' { $1 + 1 } -> | ',' { 1 } - -> texps :: { [PExp] } -> : texps ',' texp { $3 : $1 } -> | texp { [$1] } - -> texp :: { PExp } -> : exp { $1 } -> | exp '->' exp { ViewPat $1 $3 } - ------------------------------------------------------------------------------ -Harp Extensions - -> sexps :: { [PExp] } -> : sexps ',' exp { $3 : $1 } -> | exp { [$1] } - -Either patterns are left associative -> erpats :: { PExp } -> : exp '|' erpats { EitherRP $1 $3 } -> | exp '|' exp { EitherRP $1 $3 } - ------------------------------------------------------------------------------ -Hsx Extensions - -> xml :: { PExp } -> : srcloc '<' name attrs mattr '>' children '' {% do { n <- checkEqNames $3 $9; -> let { cn = reverse $7; -> as = reverse $4; }; -> return $ XTag $1 n as $5 cn } } -> | srcloc '<' name attrs mattr '/>' { XETag $1 $3 (reverse $4) $5 } -> | '<%' exp '%>' { XExpTag $2 } - -> children :: { [PExp] } -> : children child { $2 : $1 } -> | {- empty -} { [] } - -> child :: { PExp } -> : PCDATA { XPcdata $1 } -> | '<[' sexps ']>' { XRPats $ reverse $2 } -> | xml { $1 } - -> name :: { XName } -> : xmlname ':' xmlname { XDomName $1 $3 } -> | xmlname { XName $1 } - -> xmlname :: { String } -> : VARID { $1 } -> | CONID { $1 } -> | DVARID { mkDVar $1 } -> | 'type' { "type" } -> | 'class' { "class" } -> | 'data' { "data" } - -> attrs :: { [ParseXAttr] } -> : attrs attr { $2 : $1 } -> | {- empty -} { [] } - -> attr :: { ParseXAttr } -> : name '=' aexp { XAttr $1 $3 } - -> mattr :: { Maybe PExp } -> : aexp { Just $1 } -> | {-empty-} { Nothing } - -Turning dash variables into infix expressions with '-' -> dvarexp :: { PExp } -> : DVARID { DVar (map Ident $1) } - ------------------------------------------------------------------------------ -List expressions - -The rules below are little bit contorted to keep lexps left-recursive while -avoiding another shift/reduce-conflict. - -> list :: { PExp } -> : texp { List [$1] } -> | lexps { List (reverse $1) } -> | texp '..' { EnumFrom $1 } -> | texp ',' exp '..' { EnumFromThen $1 $3 } -> | texp '..' exp { EnumFromTo $1 $3 } -> | texp ',' exp '..' exp { EnumFromThenTo $1 $3 $5 } -> | texp '|' quals { ListComp $1 (reverse $3) } - -> lexps :: { [PExp] } -> : lexps ',' texp { $3 : $1 } -> | texp ',' texp { [$3,$1] } - ------------------------------------------------------------------------------ -List comprehensions - - quals :: { [Stmt] } - : quals1 {% mapM checkStmt $1 } - -> quals :: { [Stmt] } -> : quals ',' qual { $3 : $1 } -> | qual { [$1] } - -> qual :: { Stmt } -> : pat srcloc '<-' trueexp { Generator $2 $1 $4 } -> | trueexp { Qualifier $1 } -> | 'let' binds { LetStmt $2 } - ------------------------------------------------------------------------------ -Case alternatives - -> altslist :: { [Alt] } -> : '{' alts '}' { $2 } -> | open alts close { $2 } - -> alts :: { [Alt] } -> : optsemis alts1 optsemis { reverse $2 } - -> alts1 :: { [Alt] } -> : alts1 semis alt { $3 : $1 } -> | alt { [$1] } - -> alt :: { Alt } -> : srcloc pat ralt optwhere { Alt $1 $2 $3 $4 } - -> ralt :: { GuardedAlts } -> : '->' trueexp { UnGuardedAlt $2 } -> | gdpats { GuardedAlts (reverse $1) } - -> gdpats :: { [GuardedAlt] } -> : gdpats gdpat { $2 : $1 } -> | gdpat { [$1] } - -A guard can be a pattern guard, hence quals instead of exp0. -> gdpat :: { GuardedAlt } -> : srcloc '|' quals '->' trueexp { GuardedAlt $1 (reverse $3) $5 } - -> pat :: { Pat } -> : exp {% 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 :: { [Stmt] } -> : '{' stmts '}' { $2 } -> | open stmts close { $2 } - -A let statement may bind implicit parameters. -> stmts :: { [Stmt] } -> : 'let' binds ';' stmts { LetStmt $2 : $4 } -> | pat srcloc '<-' trueexp ';' stmts { Generator $2 $1 $4 : $6 } -> | trueexp ';' stmts { Qualifier $1 : $3 } -> | ';' stmts { $2 } -> | trueexp ';' { [Qualifier $1] } -> | trueexp { [Qualifier $1] } - ------------------------------------------------------------------------------ -Record Field Update/Construction - -> fbinds :: { [PFieldUpdate] } -> : fbinds ',' fbind { $3 : $1 } -> | fbind { [$1] } - -> fbind :: { PFieldUpdate } -> : qvar '=' exp { FieldUpdate $1 $3 } -> | var { FieldPun $1 } -> | '..' { FieldWildcard } - ------------------------------------------------------------------------------ -Implicit parameter bindings - -> ipbinds :: { [IPBind] } -> : optsemis ipbinds1 optsemis { reverse $2 } - -> ipbinds1 :: { [IPBind] } -> : ipbinds1 semis ipbind { $3 : $1 } -> | ipbind { [$1] } - -> ipbind :: { IPBind } -> : srcloc ivar '=' trueexp { IPBind $1 $2 $4 } - ------------------------------------------------------------------------------ -Variables, Constructors and Operators. - -> gcon :: { PExp } -> : '(' ')' { p_unit_con } -> | '[' ']' { List [] } -> | '(' commas ')' { p_tuple_con $2 } -> | qcon { Con $1 } - -> var :: { Name } -> : varid { $1 } -> | '(' varsym ')' { $2 } - -> var_no_safety :: { Name } -> : varid_no_safety { $1 } -> | '(' varsym ')' { $2 } - -> qvar :: { QName } -> : qvarid { $1 } -> | '(' qvarsym ')' { $2 } - -Implicit parameter -> ivar :: { IPName } -> : ivarid { $1 } - -> con :: { Name } -> : conid { $1 } -> | '(' consym ')' { $2 } - -> qcon :: { QName } -> : qconid { $1 } -> | '(' gconsym ')' { $2 } - -> varop :: { Name } -> : varsym { $1 } -> | '`' varid '`' { $2 } - -> qvarop :: { QName } -> : qvarsym { $1 } -> | '`' qvarid '`' { $2 } - -> qvaropm :: { QName } -> : qvarsymm { $1 } -> | '`' qvarid '`' { $2 } - -> conop :: { Name } -> : consym { $1 } -> | '`' conid '`' { $2 } - -> qconop :: { QName } -> : gconsym { $1 } -> | '`' qconid '`' { $2 } - -> op :: { Op } -> : varop { VarOp $1 } -> | conop { ConOp $1 } - -> qop :: { QOp } -> : qvarop { QVarOp $1 } -> | qconop { QConOp $1 } - -> qopm :: { QOp } -> : qvaropm { QVarOp $1 } -> | qconop { QConOp $1 } - -> gconsym :: { QName } -> : ':' { list_cons_name } -> | qconsym { $1 } - ------------------------------------------------------------------------------ -Identifiers and Symbols - -> qvarid :: { QName } -> : varid { UnQual $1 } -> | QVARID { Qual (ModuleName (fst $1)) (Ident (snd $1)) } - -> varid_no_safety :: { Name } -> : VARID { Ident $1 } -> | 'as' { as_name } -> | 'qualified' { qualified_name } -> | 'hiding' { hiding_name } -> | 'export' { export_name } -> | 'stdcall' { stdcall_name } -> | 'ccall' { ccall_name } - -> varid :: { Name } -> : varid_no_safety { $1 } -> | 'safe' { safe_name } -> | 'unsafe' { unsafe_name } -> | 'threadsafe' { threadsafe_name } - - -Implicit parameter -> ivarid :: { IPName } -> : IDUPID { IPDup $1 } -> | ILINID { IPLin $1 } - -> qconid :: { QName } -> : conid { UnQual $1 } -> | QCONID { Qual (ModuleName (fst $1)) (Ident (snd $1)) } - -> conid :: { Name } -> : CONID { Ident $1 } - -> qconsym :: { QName } -> : consym { UnQual $1 } -> | QCONSYM { Qual (ModuleName (fst $1)) (Symbol (snd $1)) } - -> consym :: { Name } -> : CONSYM { Symbol $1 } - -> qvarsym :: { QName } -> : varsym { UnQual $1 } -> | qvarsym1 { $1 } - -> qvarsymm :: { QName } -> : varsymm { UnQual $1 } -> | qvarsym1 { $1 } - -> varsym :: { Name } -> : VARSYM { Symbol $1 } -> | '-' { minus_name } -> | '!' { pling_name } -> | '.' { dot_name } -> | '*' { star_name } - -> varsymm :: { Name } -- varsym not including '-' -> : VARSYM { Symbol $1 } -> | '!' { pling_name } -> | '.' { dot_name } -> | '*' { star_name } - -> qvarsym1 :: { QName } -> : QVARSYM { Qual (ModuleName (fst $1)) (Symbol (snd $1)) } - -> literal :: { Literal } -> : INT { Int $1 } -> | CHAR { Char $1 } -> | RATIONAL { Frac $1 } -> | STRING { String $1 } -> | PRIMINT { PrimInt $1 } -> | PRIMWORD { PrimWord $1 } -> | PRIMFLOAT { PrimFloat $1 } -> | PRIMDOUBLE { PrimDouble $1 } -> | PRIMCHAR { PrimChar $1 } -> | PRIMSTRING { PrimString $1 } - - -> srcloc :: { SrcLoc } : {% getSrcLoc } - ------------------------------------------------------------------------------ -Layout - -> open :: { () } : {% pushCurrentContext } - -> close :: { () } -> : vccurly { () } -- context popped in lexer. -> | error {% popContext } - ------------------------------------------------------------------------------ -Miscellaneous (mostly renamings) - -> modid :: { ModuleName } -> : CONID { ModuleName $1 } -> | QCONID { ModuleName (fst $1 ++ '.':snd $1) } - -> tyconorcls :: { Name } -> : con { $1 } - - tycon :: { Name } - : conid { $1 } - -> qtyconorcls :: { QName } -> : qcon { $1 } - -> tyvar :: { Name } -> : varid { $1 } - -> qtyvarop :: { QName } -> qtyvarop : '`' tyvar '`' { UnQual $2 } -> | tyvarsym { UnQual $1 } - -> tyvarsym :: { Name } -> tyvarsym : VARSYM { Symbol $1 } - ------------------------------------------------------------------------------ - -> { -> happyError :: P a -> happyError = fail "Parse error" - -> -- | Parse of a string, which should contain a complete Haskell 98 module. -> parseModule :: String -> ParseResult Module -> parseModule = runParser parse - -> -- | Parse of a string, which should contain a complete Haskell 98 module. -> parseModuleWithMode :: ParseMode -> String -> ParseResult Module -> parseModuleWithMode mode = runParserWithMode mode parse -> } diff --git a/Language/Haskell/Exts/Pretty.hs b/Language/Haskell/Exts/Pretty.hs deleted file mode 100644 --- a/Language/Haskell/Exts/Pretty.hs +++ /dev/null @@ -1,1163 +0,0 @@ -{-# OPTIONS_GHC -w #-} ------------------------------------------------------------------------------ --- | --- Module : Language.Haskell.Exts.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.Exts.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.Exts.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 Module where - pretty (Module pos m os mbWarn mbExports imp decls) = - markLine pos $ - myVcat $ map pretty os ++ - (if m == ModuleName "" then id - else \x -> [topLevel (ppModuleHeader m mbWarn mbExports) x]) - (map pretty imp ++ map pretty decls) - --------------------------- Module Header ------------------------------ -ppModuleHeader :: ModuleName -> Maybe WarningText -> Maybe [ExportSpec] -> Doc -ppModuleHeader m mbWarn mbExportList = mySep [ - text "module", - pretty m, - maybePP ppWarnTxt mbWarn, - maybePP (parenList . map pretty) mbExportList, - text "where"] - -ppWarnTxt :: WarningText -> Doc -ppWarnTxt (DeprText s) = mySep [text "{-# DEPRECATED", text s, text "#-}"] -ppWarnTxt (WarnText s) = mySep [text "{-# WARNING", text s, text "#-}"] - -instance Pretty ModuleName where - pretty (ModuleName modName) = text modName - -instance Pretty ExportSpec where - pretty (EVar name) = pretty name - pretty (EAbs name) = pretty name - pretty (EThingAll name) = pretty name <> text "(..)" - pretty (EThingWith name nameList) = - pretty name <> (parenList . map pretty $ nameList) - pretty (EModuleContents m) = text "module" <+> pretty m - -instance Pretty ImportDecl where - pretty (ImportDecl pos m qual src mbName mbSpecs) = - markLine pos $ - mySep [text "import", - if src then text "{-# SOURCE #-}" else empty, - 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 ImportSpec where - pretty (IVar name) = pretty name - pretty (IAbs name) = pretty name - pretty (IThingAll name) = pretty name <> text "(..)" - pretty (IThingWith name nameList) = - pretty name <> (parenList . map pretty $ nameList) - -------------------------- Declarations ------------------------------ -instance Pretty Decl where - pretty (TypeDecl loc name nameList htype) = - blankline $ - markLine loc $ - mySep ( [text "type", pretty name] - ++ map pretty nameList - ++ [equals, pretty htype]) - - pretty (DataDecl loc don context name nameList constrList derives) = - blankline $ - markLine loc $ - mySep ( [pretty don, ppContext context, pretty name] - ++ map pretty nameList) - <+> (myVcat (zipWith (<+>) (equals : repeat (char '|')) - (map pretty constrList)) - $$$ ppDeriving derives) - - pretty (GDataDecl loc don context name nameList optkind gadtList derives) = - blankline $ - markLine loc $ - mySep ( [pretty don, ppContext context, pretty name] - ++ map pretty nameList ++ ppOptKind optkind ++ [text "where"]) - $$$ ppBody classIndent (map pretty gadtList) - $$$ ppDeriving derives - - pretty (TypeFamDecl loc name nameList optkind) = - blankline $ - markLine loc $ - mySep ([text "type", text "family", pretty name] - ++ map pretty nameList - ++ ppOptKind optkind) - - pretty (DataFamDecl loc context name nameList optkind) = - blankline $ - markLine loc $ - mySep ( [text "data", text "family", ppContext context, pretty name] - ++ map pretty nameList ++ ppOptKind optkind) - - pretty (TypeInsDecl loc ntype htype) = - blankline $ - markLine loc $ - mySep [text "type", text "instance", pretty ntype, equals, pretty htype] - - pretty (DataInsDecl loc don ntype constrList derives) = - blankline $ - markLine loc $ - mySep [pretty don, text "instance", pretty ntype] - <+> (myVcat (zipWith (<+>) (equals : repeat (char '|')) - (map pretty constrList)) - $$$ ppDeriving derives) - - pretty (GDataInsDecl loc don ntype optkind gadtList derives) = - blankline $ - markLine loc $ - mySep ( [pretty don, text "instance", pretty ntype] - ++ ppOptKind optkind ++ [text "where"]) - $$$ ppBody classIndent (map pretty gadtList) - $$$ ppDeriving derives - - --m{spacing=False} - -- special case for empty class declaration - pretty (ClassDecl pos context name nameList fundeps []) = - blankline $ - markLine pos $ - mySep ( [text "class", ppContext context, pretty name] - ++ map pretty nameList ++ [ppFunDeps fundeps]) - pretty (ClassDecl pos context name nameList fundeps declList) = - blankline $ - markLine pos $ - mySep ( [text "class", ppContext 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 (InstDecl pos context name args []) = - blankline $ - markLine pos $ - mySep ( [text "instance", ppContext context, pretty name] - ++ map ppAType args) - pretty (InstDecl pos context name args declList) = - blankline $ - markLine pos $ - mySep ( [text "instance", ppContext context, pretty name] - ++ map ppAType args ++ [text "where"]) - $$$ ppBody classIndent (map pretty declList) - - pretty (DerivDecl pos context name args) = - blankline $ - markLine pos $ - mySep ( [text "deriving", text "instance", ppContext context, pretty name] - ++ map ppAType args) - pretty (DefaultDecl pos htypes) = - blankline $ - markLine pos $ - text "default" <+> parenList (map pretty htypes) - - pretty (SpliceDecl pos splice) = - blankline $ - markLine pos $ - pretty splice - - pretty (TypeSig pos nameList qualType) = - blankline $ - markLine pos $ - mySep ((punctuate comma . map pretty $ nameList) - ++ [text "::", pretty qualType]) - - pretty (FunBind matches) = - foldr ($$$) empty (map pretty matches) - - pretty (PatBind pos pat optsig rhs whereBinds) = - markLine pos $ - myFsep [pretty pat, maybePP ppSig optsig, pretty rhs] $$$ ppWhere whereBinds - - pretty (InfixDecl pos assoc prec opList) = - blankline $ - markLine pos $ - mySep ([pretty assoc, int prec] - ++ (punctuate comma . map pretty $ opList)) - - pretty (ForImp 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 (ForExp pos cconv str name typ) = - blankline $ - markLine pos $ - mySep [text "foreign export", pretty cconv, - text (show str), pretty name, text "::", pretty typ] - - pretty (RulePragmaDecl pos rules) = - blankline $ - markLine pos $ - myVcat $ text "{-# RULES" : map pretty rules ++ [text " #-}"] - - pretty (DeprPragmaDecl pos deprs) = - blankline $ - markLine pos $ - myVcat $ text "{-# DEPRECATED" : map ppWarnDepr deprs ++ [text " #-}"] - - pretty (WarnPragmaDecl pos deprs) = - blankline $ - markLine pos $ - myVcat $ text "{-# WARNING" : map ppWarnDepr deprs ++ [text " #-}"] - - pretty (InlineSig pos inl activ name) = - blankline $ - markLine pos $ - mySep [text (if inl then "{-# INLINE" else "{-# NOINLINE"), pretty activ, pretty name, text "#-}"] - - pretty (SpecSig pos name types) = - blankline $ - markLine pos $ - mySep $ [text "{-# SPECIALISE", pretty name, text "::"] - ++ punctuate comma (map pretty types) ++ [text "#-}"] - - pretty (SpecInlineSig pos inl activ name types) = - blankline $ - markLine pos $ - mySep $ [text "{-# SPECIALISE", text (if inl then "INLINE" else "NOINLINE"), - pretty activ, pretty name, text "::"] - ++ (punctuate comma $ map pretty types) ++ [text "#-}"] - - pretty (InstSig pos context name args) = - blankline $ - markLine pos $ - mySep $ [text "{-# SPECIALISE", text "instance", ppContext context, pretty name] - ++ map ppAType args ++ [text "#-}"] - - pretty (UnknownDeclPragma pos n s) = - blankline $ - markLine pos $ - mySep $ [text "{-#", text n, text s, text "#-}"] - - -instance Pretty DataOrNew where - pretty DataType = text "data" - pretty NewType = text "newtype" - -instance Pretty Assoc where - pretty AssocNone = text "infix" - pretty AssocLeft = text "infixl" - pretty AssocRight = text "infixr" - -instance Pretty Match where - pretty (Match pos f ps optsig rhs whereBinds) = - markLine pos $ - myFsep (lhs ++ [maybePP ppSig optsig, pretty rhs]) - $$$ ppWhere whereBinds - where - lhs = case ps of - l:r:ps' | isSymbolName f -> - let hd = [pretty l, ppName f, pretty r] in - if null ps' then hd - else parens (myFsep hd) : map (prettyPrec 2) ps' - _ -> pretty f : map (prettyPrec 2) ps - -ppWhere :: Binds -> Doc -ppWhere (BDecls []) = empty -ppWhere (BDecls l) = nest 2 (text "where" $$$ ppBody whereIndent (map pretty l)) -ppWhere (IPBinds b) = nest 2 (text "where" $$$ ppBody whereIndent (map pretty b)) - -ppSig :: Type -> Doc -ppSig t = text "::" <+> pretty t - -instance Pretty ClassDecl where - pretty (ClsDecl decl) = pretty decl - - pretty (ClsDataFam loc context name nameList optkind) = - markLine loc $ - mySep ( [text "data", ppContext context, pretty name] - ++ map pretty nameList ++ ppOptKind optkind) - - pretty (ClsTyFam loc name nameList optkind) = - markLine loc $ - mySep ( [text "type", pretty name] - ++ map pretty nameList ++ ppOptKind optkind) - - pretty (ClsTyDef loc ntype htype) = - markLine loc $ - mySep [text "type", pretty ntype, equals, pretty htype] - -instance Pretty InstDecl where - pretty (InsDecl decl) = pretty decl - - pretty (InsType loc ntype htype) = - markLine loc $ - mySep [text "type", pretty ntype, equals, pretty htype] - - pretty (InsData loc don ntype constrList derives) = - markLine loc $ - mySep [pretty don, pretty ntype] - <+> (myVcat (zipWith (<+>) (equals : repeat (char '|')) - (map pretty constrList)) - $$$ ppDeriving derives) - - pretty (InsGData loc don ntype optkind gadtList derives) = - markLine loc $ - mySep ( [pretty don, pretty ntype] - ++ ppOptKind optkind ++ [text "where"]) - $$$ ppBody classIndent (map pretty gadtList) - $$$ ppDeriving derives - - pretty (InsInline loc inl activ name) = - markLine loc $ - mySep [text (if inl then "{-# INLINE" else "{-# NOINLINE"), pretty activ, pretty name, text "#-}"] - - -------------------------- FFI stuff ------------------------------------- -instance Pretty Safety where - pretty PlayRisky = text "unsafe" - pretty (PlaySafe b) = text $ if b then "threadsafe" else "safe" - -instance Pretty CallConv where - pretty StdCall = text "stdcall" - pretty CCall = text "ccall" - -------------------------- Pragmas --------------------------------------- -ppWarnDepr :: ([Name], String) -> Doc -ppWarnDepr (names, txt) = mySep $ (punctuate comma $ map pretty names) ++ [text $ show txt] - -instance Pretty Rule where - pretty (Rule tag activ rvs rhs lhs) = - mySep $ [text $ show tag, pretty activ, - maybePP ppRuleVars rvs, - pretty rhs, char '=', pretty lhs] - -ppRuleVars :: [RuleVar] -> Doc -ppRuleVars [] = empty -ppRuleVars rvs = mySep $ text "forall" : map pretty rvs ++ [char '.'] - -instance Pretty Activation where - pretty AlwaysActive = empty - pretty (ActiveFrom i) = char '[' <> int i <> char ']' - pretty (ActiveUntil i) = text "[~" <> int i <> char ']' - -instance Pretty RuleVar where - pretty (RuleVar n) = pretty n - pretty (TypedRuleVar n t) = mySep [pretty n, text "::", pretty t] - -instance Pretty OptionPragma where - pretty (LanguagePragma _ ns) = - myFsep $ text "{-# LANGUAGE" : map pretty ns ++ [text "#-}"] - pretty (IncludePragma _ s) = - myFsep $ [text "{-# INCLUDE", text s, text "#-}"] - pretty (CFilesPragma _ s) = - myFsep $ [text "{-# CFILES", text s, text "#-}"] - pretty (OptionsPragma _ (Just tool) s) = - myFsep $ [text "{-# OPTIONS_" <> pretty tool, text s, text "#-}"] - pretty (OptionsPragma _ _ s) = - myFsep $ [text "{-# OPTIONS", text s, text "#-}"] - pretty (UnknownTopPragma _ n s) = - myFsep $ map text ["{-#", n, s, "#-}"] - -instance Pretty Tool where - pretty (UnknownTool s) = text s - pretty t = text $ show t - -------------------------- Data & Newtype Bodies ------------------------- -instance Pretty QualConDecl where - pretty (QualConDecl _pos tvs ctxt con) = - myFsep [ppForall (Just tvs), ppContext ctxt, pretty con] - -instance Pretty GadtDecl where - pretty (GadtDecl _pos name ty) = - myFsep [pretty name, text "::", pretty ty] - -instance Pretty ConDecl where - pretty (RecDecl name fieldList) = - pretty name <> (braceList . map ppField $ fieldList) - - pretty (ConDecl name@(Symbol _) [l, r]) = - myFsep [prettyPrec prec_btype l, ppName name, - prettyPrec prec_btype r] - pretty (ConDecl name typeList) = - mySep $ ppName name : map (prettyPrec prec_atype) typeList - -ppField :: ([Name],BangType) -> Doc -ppField (names, ty) = - myFsepSimple $ (punctuate comma . map pretty $ names) ++ - [text "::", pretty ty] - -instance Pretty BangType where - prettyPrec _ (BangedTy ty) = char '!' <> ppAType ty - prettyPrec p (UnBangedTy ty) = prettyPrec p ty - prettyPrec p (UnpackedTy ty) = text "{-# UNPACK #-}" <+> char '!' <> prettyPrec p ty - -ppDeriving :: [Deriving] -> Doc -ppDeriving [] = empty -ppDeriving [(d, [])] = text "deriving" <+> ppQName d -ppDeriving ds = text "deriving" <+> parenList (map ppDer ds) - where ppDer :: (QName, [QName]) -> Doc - ppDer (x, xs) = mySep (map pretty (x:xs)) - -------------------------- Types ------------------------- -ppBType :: Type -> Doc -ppBType = prettyPrec prec_btype - -ppAType :: Type -> Doc -ppAType = 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 Type where - prettyPrec p (TyForall mtvs ctxt htype) = parensIf (p > 0) $ - myFsep [ppForall mtvs, ppContext ctxt, pretty htype] - prettyPrec p (TyFun a b) = parensIf (p > 0) $ - myFsep [ppBType a, text "->", pretty b] - prettyPrec _ (TyTuple bxd l) = - let ds = map pretty l - in case bxd of - Boxed -> parenList ds - Unboxed -> hashParenList ds - prettyPrec p (TyApp a b) - | a == list_tycon = brackets $ pretty b -- special case - | otherwise = parensIf (p > prec_btype) $ - myFsep [pretty a, ppAType b] - prettyPrec _ (TyVar name) = pretty name - prettyPrec _ (TyCon name) = pretty name - prettyPrec _ (TyPred asst) = pretty asst - prettyPrec _ (TyInfix a op b) = parens (myFsep [pretty op, pretty a, pretty b]) - prettyPrec _ (TyKind t k) = parens (myFsep [pretty t, text "::", pretty k]) - - -instance Pretty TyVarBind where - pretty (KindedVar var kind) = myFsep [pretty var, text "::", pretty kind] - pretty (UnkindedVar var) = pretty var - -ppForall :: Maybe [TyVarBind] -> Doc -ppForall Nothing = empty -ppForall (Just []) = empty -ppForall (Just vs) = myFsep (text "forall" : map pretty vs ++ [char '.']) - ----------------------------- Kinds ---------------------------- - -instance Pretty Kind where - pretty KindStar = text "*" - pretty KindBang = text "!" - pretty (KindFn a b) = myFsep [pretty a, text "->", pretty b] - -ppOptKind :: Maybe Kind -> [Doc] -ppOptKind Nothing = [] -ppOptKind (Just k) = [text "::", pretty k] - -------------------- Functional Dependencies ------------------- -instance Pretty FunDep where - pretty (FunDep from to) = - myFsep $ map pretty from ++ [text "->"] ++ map pretty to - - -ppFunDeps :: [FunDep] -> Doc -ppFunDeps [] = empty -ppFunDeps fds = myFsep $ (char '|':) . punctuate comma . map pretty $ fds - -------------------------- Expressions ------------------------- -instance Pretty Rhs where - pretty (UnGuardedRhs e) = equals <+> pretty e - pretty (GuardedRhss guardList) = myVcat . map pretty $ guardList - -instance Pretty GuardedRhs where - pretty (GuardedRhs _pos guards ppBody) = - myFsep $ [char '|'] ++ (punctuate comma . map pretty $ guards) ++ [equals, pretty ppBody] - -instance Pretty Literal where - pretty (Int i) = integer i - pretty (Char c) = text (show c) - pretty (String s) = text (show s) - pretty (Frac r) = double (fromRational r) - -- GHC unboxed literals: - pretty (PrimChar c) = text (show c) <> char '#' - pretty (PrimString s) = text (show s) <> char '#' - pretty (PrimInt i) = integer i <> char '#' - pretty (PrimWord w) = integer w <> text "##" - pretty (PrimFloat r) = float (fromRational r) <> char '#' - pretty (PrimDouble r) = double (fromRational r) <> text "##" - -instance Pretty Exp where - pretty (Lit l) = pretty l - -- lambda stuff - pretty (InfixApp a op b) = myFsep [pretty a, pretty op, pretty b] - pretty (NegApp e) = myFsep [char '-', pretty e] - pretty (App a b) = myFsep [pretty a, pretty b] - pretty (Lambda _loc expList ppBody) = myFsep $ - char '\\' : map pretty expList ++ [text "->", pretty ppBody] - -- keywords - -- two cases for lets - pretty (Let (BDecls declList) letBody) = - ppLetExp declList letBody - pretty (Let (IPBinds bindList) letBody) = - ppLetExp bindList letBody - - pretty (If cond thenexp elsexp) = - myFsep [text "if", pretty cond, - text "then", pretty thenexp, - text "else", pretty elsexp] - pretty (Case cond altList) = - myFsep [text "case", pretty cond, text "of"] - $$$ ppBody caseIndent (map pretty altList) - pretty (Do stmtList) = - text "do" $$$ ppBody doIndent (map pretty stmtList) - pretty (MDo stmtList) = - text "mdo" $$$ ppBody doIndent (map pretty stmtList) - -- Constructors & Vars - pretty (Var name) = pretty name - pretty (IPVar ipname) = pretty ipname - pretty (Con name) = pretty name - pretty (Tuple expList) = parenList . map pretty $ expList - -- weird stuff - pretty (Paren e) = parens . pretty $ e - pretty (LeftSection e op) = parens (pretty e <+> pretty op) - pretty (RightSection op e) = parens (pretty op <+> pretty e) - pretty (RecConstr c fieldList) = - pretty c <> (braceList . map pretty $ fieldList) - pretty (RecUpdate e fieldList) = - pretty e <> (braceList . map pretty $ fieldList) - -- Lists - pretty (List list) = - bracketList . punctuate comma . map pretty $ list - pretty (EnumFrom e) = - bracketList [pretty e, text ".."] - pretty (EnumFromTo from to) = - bracketList [pretty from, text "..", pretty to] - pretty (EnumFromThen from thenE) = - bracketList [pretty from <> comma, pretty thenE, text ".."] - pretty (EnumFromThenTo from thenE to) = - bracketList [pretty from <> comma, pretty thenE, - text "..", pretty to] - pretty (ListComp e stmtList) = - bracketList ([pretty e, char '|'] - ++ (punctuate comma . map pretty $ stmtList)) - pretty (ExpTypeSig _pos e ty) = - myFsep [pretty e, text "::", pretty ty] - -- Template Haskell - pretty (BracketExp b) = pretty b - pretty (SpliceExp s) = pretty s - pretty (TypQuote t) = text "\'\'" <> pretty t - pretty (VarQuote x) = text "\'" <> pretty x - -- Hsx - pretty (XTag _ 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 (XETag _ n attrs mattr) = - let ax = maybe [] (return . pretty) mattr - in myFsep $ (char '<' <> pretty n): map pretty attrs ++ ax ++ [text "/>"] - pretty (XPcdata s) = text s - pretty (XExpTag e) = - myFsep $ [text "<%", pretty e, text "%>"] - -- Pragmas - pretty (CorePragma s) = myFsep $ map text ["{-# CORE", show s, "#-}"] - pretty (SCCPragma s) = myFsep $ map text ["{-# SCC", show s, "#-}"] - pretty (GenPragma s (a,b) (c,d)) = - myFsep $ [text "{-# GENERATED", text $ show s, - int a, char ':', int b, char '-', - int c, char ':', int d, text "#-}"] - pretty (UnknownExpPragma n s) = - myFsep $ [text "{-#", text n, text s, text "#-}"] - -instance Pretty XAttr where - pretty (XAttr n v) = - myFsep [pretty n, char '=', pretty v] - -instance Pretty XName where - pretty (XName n) = text n - pretty (XDomName d n) = text d <> char ':' <> text n - ---ppLetExp :: [Decl] -> Exp -> 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 Bracket where - pretty (ExpBracket e) = ppBracket "[|" e - pretty (PatBracket p) = ppBracket "[p|" p - pretty (TypeBracket t) = ppBracket "[t|" t - pretty (DeclBracket d) = - myFsep $ text "[d|" : map pretty d ++ [text "|]"] - -ppBracket o x = myFsep [text o, pretty x, text "|]"] - -instance Pretty Splice where - pretty (IdSplice s) = char '$' <> text s - pretty (ParenSplice e) = - myFsep [text "$(", pretty e, char ')'] - -------------------------- Patterns ----------------------------- - -instance Pretty Pat where - prettyPrec _ (PVar name) = pretty name - prettyPrec _ (PLit lit) = pretty lit - prettyPrec _ (PNeg p) = myFsep [char '-', pretty p] - prettyPrec p (PInfixApp a op b) = parensIf (p > 0) $ - myFsep [pretty a, pretty (QConOp op), pretty b] - prettyPrec p (PApp n ps) = parensIf (p > 1) $ - myFsep (pretty n : map pretty ps) - prettyPrec _ (PTuple ps) = parenList . map pretty $ ps - prettyPrec _ (PList ps) = - bracketList . punctuate comma . map pretty $ ps - prettyPrec _ (PParen p) = parens . pretty $ p - prettyPrec _ (PRec c fields) = - pretty c <> (braceList . map pretty $ fields) - -- special case that would otherwise be buggy - prettyPrec _ (PAsPat name (PIrrPat pat)) = - myFsep [pretty name <> char '@', char '~' <> pretty pat] - prettyPrec _ (PAsPat name pat) = - hcat [pretty name, char '@', pretty pat] - prettyPrec _ PWildCard = char '_' - prettyPrec _ (PIrrPat pat) = char '~' <> pretty pat - prettyPrec _ (PatTypeSig _pos pat ty) = - myFsep [pretty pat, text "::", pretty ty] - prettyPrec _ (PViewPat e p) = - myFsep [pretty e, text "->", pretty p] - prettyPrec _ (PNPlusK n k) = - myFsep [pretty n, text "+", text $ show k] - -- HaRP - prettyPrec _ (PRPat rs) = - bracketList . punctuate comma . map pretty $ rs - -- Hsx - prettyPrec _ (PXTag _ 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 '>']): - map pretty cp ++ [myFsep $ [text " pretty n, char '>']] - prettyPrec _ (PXETag _ n attrs mattr) = - let ap = maybe [] (return . pretty) mattr - in myFsep $ (char '<' <> pretty n): map pretty attrs ++ ap ++ [text "/>"] - prettyPrec _ (PXPcdata s) = text s - prettyPrec _ (PXPatTag p) = - myFsep $ [text "<%", pretty p, text "%>"] - prettyPrec _ (PXRPats ps) = - myFsep $ text "<[" : map pretty ps ++ [text "%>"] - -instance Pretty PXAttr where - pretty (PXAttr n p) = - myFsep [pretty n, char '=', pretty p] - -instance Pretty PatField where - pretty (PFieldPat name pat) = - myFsep [pretty name, equals, pretty pat] - pretty (PFieldPun name) = pretty name - pretty (PFieldWildcard) = text ".." - ---------------------- Regular Patterns ------------------------- - -instance Pretty RPat where - pretty (RPOp r op) = pretty r <> pretty op - pretty (RPEither r1 r2) = parens . myFsep $ - [pretty r1, char '|', pretty r2] - pretty (RPSeq rs) = - myFsep $ text "(/" : map pretty rs ++ [text "/)"] - pretty (RPGuard r gs) = - myFsep $ text "(|" : pretty r : char '|' : map pretty gs ++ [text "|)"] - -- special case that would otherwise be buggy - pretty (RPCAs n (RPPat (PIrrPat p))) = - myFsep [pretty n <> text "@:", char '~' <> pretty p] - pretty (RPCAs n r) = hcat [pretty n, text "@:", pretty r] - -- special case that would otherwise be buggy - pretty (RPAs n (RPPat (PIrrPat p))) = - myFsep [pretty n <> text "@:", char '~' <> pretty p] - pretty (RPAs n r) = hcat [pretty n, char '@', pretty r] - pretty (RPPat p) = pretty p - pretty (RPParen rp) = parens . pretty $ rp - -instance Pretty RPatOp where - pretty RPStar = char '*' - pretty RPStarG = text "*!" - pretty RPPlus = char '+' - pretty RPPlusG = text "+!" - pretty RPOpt = char '?' - pretty RPOptG = text "?!" - -------------------------- Case bodies ------------------------- -instance Pretty Alt where - pretty (Alt _pos e gAlts binds) = - pretty e <+> pretty gAlts $$$ ppWhere binds - -instance Pretty GuardedAlts where - pretty (UnGuardedAlt e) = text "->" <+> pretty e - pretty (GuardedAlts altList) = myVcat . map pretty $ altList - -instance Pretty GuardedAlt where - pretty (GuardedAlt _pos guards body) = - myFsep $ char '|': (punctuate comma . map pretty $ guards) ++ [text "->", pretty body] - -------------------------- Statements in monads, guards & list comprehensions ----- -instance Pretty Stmt where - pretty (Generator _loc e from) = - pretty e <+> text "<-" <+> pretty from - pretty (Qualifier e) = pretty e - -- two cases for lets - pretty (LetStmt (BDecls declList)) = - ppLetStmt declList - pretty (LetStmt (IPBinds bindList)) = - ppLetStmt bindList - -ppLetStmt l = text "let" $$$ ppBody letIndent (map pretty l) - -------------------------- Record updates -instance Pretty FieldUpdate where - pretty (FieldUpdate name e) = - myFsep [pretty name, equals, pretty e] - pretty (FieldPun name) = pretty name - pretty (FieldWildcard) = text ".." - -------------------------- Names ------------------------- -instance Pretty QOp where - pretty (QVarOp n) = ppQNameInfix n - pretty (QConOp n) = ppQNameInfix n - -ppQNameInfix :: QName -> Doc -ppQNameInfix name - | isSymbolName (getName name) = ppQName name - | otherwise = char '`' <> ppQName name <> char '`' - -instance Pretty QName where - pretty name = case name of - UnQual (Symbol ('#':_)) -> char '(' <+> ppQName name <+> char ')' - _ -> parensIf (isSymbolName (getName name)) (ppQName name) - -ppQName :: QName -> Doc -ppQName (UnQual name) = ppName name -ppQName (Qual m name) = pretty m <> char '.' <> ppName name -ppQName (Special sym) = text (specialName sym) - -instance Pretty Op where - pretty (VarOp n) = ppNameInfix n - pretty (ConOp n) = ppNameInfix n - -ppNameInfix :: Name -> Doc -ppNameInfix name - | isSymbolName name = ppName name - | otherwise = char '`' <> ppName name <> char '`' - -instance Pretty Name where - pretty name = case name of - Symbol ('#':_) -> char '(' <+> ppName name <+> char ')' - _ -> parensIf (isSymbolName name) (ppName name) - -ppName :: Name -> Doc -ppName (Ident s) = text s -ppName (Symbol s) = text s - -instance Pretty IPName where - pretty (IPDup s) = char '?' <> text s - pretty (IPLin s) = char '%' <> text s - -instance Pretty IPBind where - pretty (IPBind _loc ipname exp) = - myFsep [pretty ipname, equals, pretty exp] - -instance Pretty CName where - pretty (VarName n) = pretty n - pretty (ConName n) = pretty n - -isSymbolName :: Name -> Bool -isSymbolName (Symbol _) = True -isSymbolName _ = False - -getName :: QName -> Name -getName (UnQual s) = s -getName (Qual _ s) = s -getName (Special Cons) = Symbol ":" -getName (Special FunCon) = Symbol "->" -getName (Special s) = Ident (specialName s) - -specialName :: SpecialCon -> String -specialName UnitCon = "()" -specialName ListCon = "[]" -specialName FunCon = "->" -specialName (TupleCon n) = "(" ++ replicate (n-1) ',' ++ ")" -specialName Cons = ":" - -ppContext :: Context -> Doc -ppContext [] = empty -ppContext context = mySep [parenList (map pretty context), text "=>"] - --- hacked for multi-parameter type classes -instance Pretty Asst where - pretty (ClassA a ts) = myFsep $ ppQName a : map ppAType ts - pretty (IParam i t) = myFsep $ [pretty i, text "::", pretty t] - pretty (EqualP t1 t2) = myFsep $ [pretty t1, text "~", pretty t2] - -------------------------- 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 - --- Pretty print a source location, useful for printing out error messages -instance Pretty SrcLoc where - pretty srcLoc = - return $ P.hsep [ colonFollow (P.text $ srcFilename srcLoc) - , colonFollow (P.int $ srcLine srcLoc) - , P.int $ srcColumn srcLoc - ] - where - colonFollow p = P.hcat [ p, P.colon ] diff --git a/Language/Haskell/Exts/Syntax.hs b/Language/Haskell/Exts/Syntax.hs deleted file mode 100644 --- a/Language/Haskell/Exts/Syntax.hs +++ /dev/null @@ -1,922 +0,0 @@ -{-# OPTIONS_GHC -fglasgow-exts -cpp #-} ------------------------------------------------------------------------------ --- | --- Module : Language.Haskell.Exts.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.Exts.Syntax ( - -- * Modules - Module(..), ExportSpec(..), - ImportDecl(..), ImportSpec(..), Assoc(..), - -- * Declarations - Decl(..), Binds(..), IPBind(..), - ClassDecl(..), InstDecl(..), Deriving, - GadtDecl(..), ConDecl(..), QualConDecl(..), BangType(..), - Match(..), Rhs(..), GuardedRhs(..), DataOrNew(..), - -- * Class Assertions and Contexts - Context, FunDep(..), Asst(..), - -- * Types - Type(..), Boxed(..), Kind(..), TyVarBind(..), - -- * Expressions - Exp(..), Stmt(..), FieldUpdate(..), - Alt(..), GuardedAlts(..), GuardedAlt(..), - -- * Patterns - Pat(..), PatField(..), - -- * Literals - Literal(..), - -- * Variables, Constructors and Operators - ModuleName(..), QName(..), Name(..), QOp(..), Op(..), - SpecialCon(..), CName(..), IPName(..), - - -- * Template Haskell - -- HsReify(..), - Bracket(..), Splice(..), - - -- * HaRP - RPat(..), RPatOp(..), - - -- * Hsx - XAttr(..), XName(..), PXAttr(..), - - -- * FFI - Safety(..), CallConv(..), - - -- * Pragmas - OptionPragma(..), Tool(..), WarningText(..), - Rule(..), RuleVar(..), Activation(..), - - -- * 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, star_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.Data -#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 ModuleName = ModuleName 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 SpecialCon - = UnitCon -- ^ unit type and data constructor @()@ - | ListCon -- ^ list type constructor @[]@ - | FunCon -- ^ function type constructor @->@ - | TupleCon Int -- ^ /n/-ary tuple type and data - -- constructors @(,)@ etc - | Cons -- ^ 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 QName - = Qual ModuleName Name -- ^ name qualified with a module name - | UnQual Name -- ^ unqualified name - | Special SpecialCon -- ^ 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 Name - = Ident String -- ^ /varid/ or /conid/. - | Symbol 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 IPName - = IPDup String -- ?x - | IPLin 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 QOp - = QVarOp QName -- ^ variable operator (/qvarop/) - | QConOp QName -- ^ constructor operator (/qconop/) -#ifdef __GLASGOW_HASKELL__ - deriving (Eq,Ord,Show,Typeable,Data) -#else - deriving (Eq,Ord,Show) -#endif - --- | Operators, appearing in @infix@ declarations. -data Op - = VarOp Name -- ^ variable operator (/varop/) - | ConOp Name -- ^ 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 CName - = VarName Name -- ^ name of a method or field - | ConName Name -- ^ 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 Module = Module SrcLoc ModuleName [OptionPragma] (Maybe WarningText) - (Maybe [ExportSpec]) [ImportDecl] [Decl] -#ifdef __GLASGOW_HASKELL__ - deriving (Show,Typeable,Data) -#else - deriving (Show) -#endif - --- | Export specification. -data ExportSpec - = EVar QName -- ^ variable - | EAbs QName -- ^ @T@: - -- a class or datatype exported abstractly, - -- or a type synonym. - | EThingAll QName -- ^ @T(..)@: - -- a class exported with all of its methods, or - -- a datatype exported with all of its constructors. - | EThingWith QName [CName] -- ^ @T(C_1,...,C_n)@: - -- a class exported with some of its methods, or - -- a datatype exported with some of its constructors. - | EModuleContents ModuleName -- ^ @module M@: - -- re-export a module. -#ifdef __GLASGOW_HASKELL__ - deriving (Eq,Show,Typeable,Data) -#else - deriving (Eq,Show) -#endif - --- | Import declaration. -data ImportDecl = ImportDecl - { importLoc :: SrcLoc -- ^ position of the @import@ keyword. - , importModule :: ModuleName -- ^ name of the module imported. - , importQualified :: Bool -- ^ imported @qualified@? - , importSrc :: Bool -- ^ imported with {-# SOURCE #-} - , importAs :: Maybe ModuleName -- ^ optional alias name in an - -- @as@ clause. - , importSpecs :: Maybe (Bool,[ImportSpec]) - -- ^ 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 ImportSpec - = IVar Name -- ^ variable - | IAbs Name -- ^ @T@: - -- the name of a class, datatype or type synonym. - | IThingAll Name -- ^ @T(..)@: - -- a class imported with all of its methods, or - -- a datatype imported with all of its constructors. - | IThingWith Name [CName] -- ^ @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 Assoc - = AssocNone -- ^ non-associative operator (declared with @infix@) - | AssocLeft -- ^ left-associative operator (declared with @infixl@). - | AssocRight -- ^ right-associative operator (declared with @infixr@) -#ifdef __GLASGOW_HASKELL__ - deriving (Eq,Show,Typeable,Data) -#else - deriving (Eq,Show) -#endif - -type Deriving = (QName, [QName]) - -data Decl - = TypeDecl SrcLoc Name [Name] Type - | DataDecl SrcLoc DataOrNew Context Name [Name] [QualConDecl] [Deriving] - | GDataDecl SrcLoc DataOrNew Context Name [Name] (Maybe Kind) [GadtDecl] [Deriving] - | TypeFamDecl SrcLoc Name [Name] (Maybe Kind) - | DataFamDecl SrcLoc Context Name [Name] (Maybe Kind) - | TypeInsDecl SrcLoc Type Type - | DataInsDecl SrcLoc DataOrNew Type [QualConDecl] [Deriving] - | GDataInsDecl SrcLoc DataOrNew Type (Maybe Kind) [GadtDecl] [Deriving] - | InfixDecl SrcLoc Assoc Int [Op] - | ClassDecl SrcLoc Context Name [Name] [FunDep] [ClassDecl] - | InstDecl SrcLoc Context QName [Type] [InstDecl] - | DerivDecl SrcLoc Context QName [Type] - | DefaultDecl SrcLoc [Type] - | SpliceDecl SrcLoc Splice - | TypeSig SrcLoc [Name] Type - | FunBind [Match] - | PatBind SrcLoc Pat (Maybe Type) Rhs {-where-} Binds - | ForImp SrcLoc CallConv Safety String Name Type - | ForExp SrcLoc CallConv String Name Type --- Pragmas - | RulePragmaDecl SrcLoc [Rule] - | DeprPragmaDecl SrcLoc [([Name], String)] - | WarnPragmaDecl SrcLoc [([Name], String)] - | InlineSig SrcLoc Bool Activation QName - | SpecSig SrcLoc QName [Type] - | SpecInlineSig SrcLoc Bool Activation QName [Type] - | InstSig SrcLoc Context QName [Type] - | UnknownDeclPragma SrcLoc String String -#ifdef __GLASGOW_HASKELL__ - deriving (Eq,Show,Typeable,Data) -#else - deriving (Eq,Show) -#endif - -data DataOrNew = DataType | NewType -#ifdef __GLASGOW_HASKELL__ - deriving (Eq,Show,Typeable,Data) -#else - deriving (Eq,Show) -#endif - -data Binds - = BDecls [Decl] - | IPBinds [IPBind] -#ifdef __GLASGOW_HASKELL__ - deriving (Eq,Show,Typeable,Data) -#else - deriving (Eq,Show) -#endif - -data IPBind = IPBind SrcLoc IPName Exp -#ifdef __GLASGOW_HASKELL__ - deriving (Eq,Show,Typeable,Data) -#else - deriving (Eq,Show) -#endif - --- | Clauses of a function binding. -data Match - = Match SrcLoc Name [Pat] (Maybe Type) Rhs {-where-} Binds -#ifdef __GLASGOW_HASKELL__ - deriving (Eq,Show,Typeable,Data) -#else - deriving (Eq,Show) -#endif - -data QualConDecl - = QualConDecl SrcLoc - {-forall-} [TyVarBind] {- . -} Context - {- => -} ConDecl -#ifdef __GLASGOW_HASKELL__ - deriving (Eq,Show,Typeable,Data) -#else - deriving (Eq,Show) -#endif - -data GadtDecl - = GadtDecl SrcLoc Name Type -#ifdef __GLASGOW_HASKELL__ - deriving (Eq,Show,Typeable,Data) -#else - deriving (Eq,Show) -#endif - --- | Declaration of a data constructor. -data ConDecl - = ConDecl Name [BangType] - -- ^ ordinary data constructor - | RecDecl Name [([Name],BangType)] - -- ^ record constructor -#ifdef __GLASGOW_HASKELL__ - deriving (Eq,Show,Typeable,Data) -#else - deriving (Eq,Show) -#endif - --- | Declarations inside a class declaration -data ClassDecl - = ClsDecl Decl - | ClsDataFam SrcLoc Context Name [Name] (Maybe Kind) - | ClsTyFam SrcLoc Name [Name] (Maybe Kind) - | ClsTyDef SrcLoc Type Type -#ifdef __GLASGOW_HASKELL__ - deriving (Eq,Show,Typeable,Data) -#else - deriving (Eq,Show) -#endif - --- | Declarations inside an instance declaration -data InstDecl - = InsDecl Decl - | InsType SrcLoc Type Type - | InsData SrcLoc DataOrNew Type [QualConDecl] [Deriving] - | InsGData SrcLoc DataOrNew Type (Maybe Kind) [GadtDecl] [Deriving] - | InsInline SrcLoc Bool Activation QName -#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 BangType - = BangedTy Type -- ^ strict component, marked with \"@!@\" - | UnBangedTy Type -- ^ non-strict component - | UnpackedTy Type -- ^ unboxed 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 Rhs - = UnGuardedRhs Exp -- ^ unguarded right hand side (/exp/) - | GuardedRhss [GuardedRhs] - -- ^ 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 GuardedRhs - = GuardedRhs SrcLoc [Stmt] Exp -#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 Type - = TyForall - (Maybe [TyVarBind]) - Context - Type - | TyFun Type Type -- ^ function type - | TyTuple Boxed [Type] -- ^ tuple type, possibly boxed - | TyApp Type Type -- ^ application of a type constructor - | TyVar Name -- ^ type variable - | TyCon QName -- ^ named type or type constructor - | TyPred Asst -- ^ assertion of an implicit parameter - | TyInfix Type QName Type -- ^ infix type constructor - | TyKind Type Kind -- ^ type with explicit kind signature -#ifdef __GLASGOW_HASKELL__ - deriving (Eq,Show,Typeable,Data) -#else - deriving (Eq,Show) -#endif - -data Boxed = Boxed | Unboxed -#ifdef __GLASGOW_HASKELL__ - deriving (Eq,Show,Typeable,Data) -#else - deriving (Eq,Show) -#endif - -data TyVarBind - = KindedVar Name Kind - | UnkindedVar Name -#ifdef __GLASGOW_HASKELL__ - deriving (Eq,Show,Typeable,Data) -#else - deriving (Eq,Show) -#endif - -data Kind - = KindStar - | KindBang - | KindFn Kind Kind -#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 FunDep - = FunDep [Name] [Name] -#ifdef __GLASGOW_HASKELL__ - deriving (Eq,Show,Typeable,Data) -#else - deriving (Eq,Show) -#endif - - -type Context = [Asst] - --- | 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 and equality constraints. -data Asst = ClassA QName [Type] - | IParam IPName Type - | EqualP Type Type -#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 Literal - = Char Char -- ^ character literal - | String String -- ^ string literal - | Int Integer -- ^ integer literal - | Frac Rational -- ^ floating point literal - | PrimInt Integer -- ^ GHC unboxed integer literal - | PrimWord Integer -- ^ GHC unboxed word literal - | PrimFloat Rational -- ^ GHC unboxed float literal - | PrimDouble Rational -- ^ GHC unboxed double literal - | PrimChar Char -- ^ GHC unboxed character literal - | PrimString String -- ^ GHC unboxed string 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 'InfixApp's associated to the left. --- --- * The 'Language.Haskell.Exts.Pretty.Pretty' instance for 'Exp' does not --- add parentheses in printing. - -data Exp - = Var QName -- ^ variable - | IPVar IPName -- ^ implicit parameter variable - | Con QName -- ^ data constructor - | Lit Literal -- ^ literal constant - | InfixApp Exp QOp Exp -- ^ infix application - | App Exp Exp -- ^ ordinary application - | NegApp Exp -- ^ negation expression @-@ /exp/ - | Lambda SrcLoc [Pat] Exp -- ^ lambda expression - | Let Binds Exp -- ^ local declarations with @let@ - | If Exp Exp Exp -- ^ @if@ /exp/ @then@ /exp/ @else@ /exp/ - | Case Exp [Alt] -- ^ @case@ /exp/ @of@ /alts/ - | Do [Stmt] -- ^ @do@-expression: - -- the last statement in the list - -- should be an expression. - | MDo [Stmt] -- ^ @mdo@-expression - | Tuple [Exp] -- ^ tuple expression - | List [Exp] -- ^ list expression - | Paren Exp -- ^ parenthesized expression - | LeftSection Exp QOp -- ^ left section @(@/exp/ /qop/@)@ - | RightSection QOp Exp -- ^ right section @(@/qop/ /exp/@)@ - | RecConstr QName [FieldUpdate] - -- ^ record construction expression - | RecUpdate Exp [FieldUpdate] - -- ^ record update expression - | EnumFrom Exp -- ^ unbounded arithmetic sequence, - -- incrementing by 1 - | EnumFromTo Exp Exp -- ^ bounded arithmetic sequence, - -- incrementing by 1 - | EnumFromThen Exp Exp -- ^ unbounded arithmetic sequence, - -- with first two elements given - | EnumFromThenTo Exp Exp Exp - -- ^ bounded arithmetic sequence, - -- with first two elements given - | ListComp Exp [Stmt] -- ^ list comprehension - | ExpTypeSig SrcLoc Exp Type - -- ^ expression type signature --- Template Haskell - | VarQuote QName -- ^ 'x - | TypQuote QName -- ^ ''T - | BracketExp Bracket - | SpliceExp Splice - --- Hsx - | XTag SrcLoc XName [XAttr] (Maybe Exp) [Exp] - | XETag SrcLoc XName [XAttr] (Maybe Exp) - | XPcdata String - | XExpTag Exp - --- Pragmas - | CorePragma String - | SCCPragma String - | GenPragma String (Int, Int) (Int, Int) - | UnknownExpPragma String String -#ifdef __GLASGOW_HASKELL__ - deriving (Eq,Show,Typeable,Data) -#else - deriving (Eq,Show) -#endif - -data XName - = XName String -- p) --- HaRP - | PRPat [RPat] -- ^ regular pattern (HaRP) --- Hsx - | PXTag SrcLoc XName [PXAttr] (Maybe Pat) [Pat] - -- ^ XML tag pattern - | PXETag SrcLoc XName [PXAttr] (Maybe Pat) - -- ^ XML singleton tag pattern - | PXPcdata String - -- ^ XML PCDATA pattern - | PXPatTag Pat - -- ^ XML embedded pattern - | PXRPats [RPat] - -- ^ XML regular list pattern -#ifdef __GLASGOW_HASKELL__ - deriving (Eq,Show,Typeable,Data) -#else - deriving (Eq,Show) -#endif - --- | An XML attribute in an XML tag pattern -data PXAttr = PXAttr XName Pat -#ifdef __GLASGOW_HASKELL__ - deriving (Eq,Show,Typeable,Data) -#else - deriving (Eq,Show) -#endif - --- | A regular pattern operator (HaRP) -data RPatOp - = RPStar - | RPStarG - | RPPlus - | RPPlusG - | RPOpt - | RPOptG -#ifdef __GLASGOW_HASKELL__ - deriving (Eq,Show,Typeable,Data) -#else - deriving (Eq,Show) -#endif - --- | An entity in a regular pattern (HaRP) -data RPat - = RPOp RPat RPatOp - | RPEither RPat RPat - | RPSeq [RPat] - | RPGuard Pat [Stmt] - | RPCAs Name RPat - | RPAs Name RPat - | RPParen RPat - | RPPat Pat -#ifdef __GLASGOW_HASKELL__ - deriving (Eq,Show,Typeable,Data) -#else - deriving (Eq,Show) -#endif - --- | An /fpat/ in a labeled record pattern. -data PatField - = PFieldPat QName Pat - | PFieldPun Name - | PFieldWildcard -#ifdef __GLASGOW_HASKELL__ - deriving (Eq,Show,Typeable,Data) -#else - deriving (Eq,Show) -#endif - --- | This type represents both /stmt/ in a @do@-expression, --- and /qual/ in a list comprehension, as well as /stmt/ --- in a pattern guard. -data Stmt - = Generator SrcLoc Pat Exp - -- ^ a generator /pat/ @<-@ /exp/ - | Qualifier Exp -- ^ an /exp/ by itself: in a @do@-expression, - -- an action whose result is discarded; - -- in a list comprehension, a guard expression - | LetStmt Binds -- ^ local bindings -#ifdef __GLASGOW_HASKELL__ - deriving (Eq,Show,Typeable,Data) -#else - deriving (Eq,Show) -#endif - --- | An /fbind/ in a labeled construction or update. -data FieldUpdate - = FieldUpdate QName Exp - | FieldPun Name - | FieldWildcard -#ifdef __GLASGOW_HASKELL__ - deriving (Eq,Show,Typeable,Data) -#else - deriving (Eq,Show) -#endif - --- | An /alt/ in a @case@ expression. -data Alt - = Alt SrcLoc Pat GuardedAlts Binds -#ifdef __GLASGOW_HASKELL__ - deriving (Eq,Show,Typeable,Data) -#else - deriving (Eq,Show) -#endif - -data GuardedAlts - = UnGuardedAlt Exp -- ^ @->@ /exp/ - | GuardedAlts [GuardedAlt] -- ^ /gdpat/ -#ifdef __GLASGOW_HASKELL__ - deriving (Eq,Show,Typeable,Data) -#else - deriving (Eq,Show) -#endif - --- | A guarded alternative @|@ /stmt/, ... , /stmt/ @->@ /exp/. -data GuardedAlt - = GuardedAlt SrcLoc [Stmt] Exp -#ifdef __GLASGOW_HASKELL__ - deriving (Eq,Show,Typeable,Data) -#else - deriving (Eq,Show) -#endif - ------------------------------------------------------------------------------ --- Builtin names. - -prelude_mod, main_mod :: ModuleName -prelude_mod = ModuleName "Prelude" -main_mod = ModuleName "Main" - -main_name :: Name -main_name = Ident "main" - -unit_con_name :: QName -unit_con_name = Special UnitCon - -tuple_con_name :: Int -> QName -tuple_con_name i = Special (TupleCon (i+1)) - -list_cons_name :: QName -list_cons_name = Special Cons - -unit_con :: Exp -unit_con = Con unit_con_name - -tuple_con :: Int -> Exp -tuple_con i = Con (tuple_con_name i) - -as_name, qualified_name, hiding_name, minus_name, pling_name, dot_name, star_name :: Name -as_name = Ident "as" -qualified_name = Ident "qualified" -hiding_name = Ident "hiding" -minus_name = Symbol "-" -pling_name = Symbol "!" -dot_name = Symbol "." -star_name = Symbol "*" - -export_name, safe_name, unsafe_name, threadsafe_name, stdcall_name, ccall_name :: Name -export_name = Ident "export" -safe_name = Ident "safe" -unsafe_name = Ident "unsafe" -threadsafe_name = Ident "threadsafe" -stdcall_name = Ident "stdcall" -ccall_name = Ident "ccall" - -unit_tycon_name, fun_tycon_name, list_tycon_name :: QName -unit_tycon_name = unit_con_name -fun_tycon_name = Special FunCon -list_tycon_name = Special ListCon - -tuple_tycon_name :: Int -> QName -tuple_tycon_name i = tuple_con_name i - -unit_tycon, fun_tycon, list_tycon :: Type -unit_tycon = TyCon unit_tycon_name -fun_tycon = TyCon fun_tycon_name -list_tycon = TyCon list_tycon_name - -tuple_tycon :: Int -> Type -tuple_tycon i = TyCon (tuple_tycon_name i) diff --git a/Setup.hs b/Setup.hs --- a/Setup.hs +++ b/Setup.hs @@ -1,2 +1,3 @@ import Distribution.Simple -main = defaultMain +import Test.Runner ( go ) +main = defaultMainWithHooks $ simpleUserHooks { runTests = \args _ _ _ -> go args } diff --git a/dist/build/Language/Haskell/Exts/Parser.hs b/dist/build/Language/Haskell/Exts/Parser.hs --- a/dist/build/Language/Haskell/Exts/Parser.hs +++ b/dist/build/Language/Haskell/Exts/Parser.hs @@ -1,6706 +1,7402 @@ -{-# OPTIONS -fglasgow-exts -cpp #-} ------------------------------------------------------------------------------ --- | --- Module : Language.Haskell.Exts.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.Exts.Parser ( - parseModule, parseModuleWithMode, - ParseMode(..), defaultParseMode, ParseResult(..)) where - -import Language.Haskell.Exts.Syntax hiding ( Exp(..), XAttr(..), FieldUpdate(..) ) -import Language.Haskell.Exts.Syntax ( Exp ) -import Language.Haskell.Exts.ParseMonad -import Language.Haskell.Exts.Lexer -import Language.Haskell.Exts.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 :: (Module) -> (HappyAbsSyn ) -happyIn4 x = unsafeCoerce# x -{-# INLINE happyIn4 #-} -happyOut4 :: (HappyAbsSyn ) -> (Module) -happyOut4 x = unsafeCoerce# x -{-# INLINE happyOut4 #-} -happyIn5 :: (PExp) -> (HappyAbsSyn ) -happyIn5 x = unsafeCoerce# x -{-# INLINE happyIn5 #-} -happyOut5 :: (HappyAbsSyn ) -> (PExp) -happyOut5 x = unsafeCoerce# x -{-# INLINE happyOut5 #-} -happyIn6 :: ([OptionPragma]) -> (HappyAbsSyn ) -happyIn6 x = unsafeCoerce# x -{-# INLINE happyIn6 #-} -happyOut6 :: (HappyAbsSyn ) -> ([OptionPragma]) -happyOut6 x = unsafeCoerce# x -{-# INLINE happyOut6 #-} -happyIn7 :: ([OptionPragma]) -> (HappyAbsSyn ) -happyIn7 x = unsafeCoerce# x -{-# INLINE happyIn7 #-} -happyOut7 :: (HappyAbsSyn ) -> ([OptionPragma]) -happyOut7 x = unsafeCoerce# x -{-# INLINE happyOut7 #-} -happyIn8 :: (OptionPragma) -> (HappyAbsSyn ) -happyIn8 x = unsafeCoerce# x -{-# INLINE happyIn8 #-} -happyOut8 :: (HappyAbsSyn ) -> (OptionPragma) -happyOut8 x = unsafeCoerce# x -{-# INLINE happyOut8 #-} -happyIn9 :: ([Name]) -> (HappyAbsSyn ) -happyIn9 x = unsafeCoerce# x -{-# INLINE happyIn9 #-} -happyOut9 :: (HappyAbsSyn ) -> ([Name]) -happyOut9 x = unsafeCoerce# x -{-# INLINE happyOut9 #-} -happyIn10 :: ([OptionPragma] -> Module) -> (HappyAbsSyn ) -happyIn10 x = unsafeCoerce# x -{-# INLINE happyIn10 #-} -happyOut10 :: (HappyAbsSyn ) -> ([OptionPragma] -> Module) -happyOut10 x = unsafeCoerce# x -{-# INLINE happyOut10 #-} -happyIn11 :: (Maybe WarningText) -> (HappyAbsSyn ) -happyIn11 x = unsafeCoerce# x -{-# INLINE happyIn11 #-} -happyOut11 :: (HappyAbsSyn ) -> (Maybe WarningText) -happyOut11 x = unsafeCoerce# x -{-# INLINE happyOut11 #-} -happyIn12 :: (([ImportDecl],[Decl])) -> (HappyAbsSyn ) -happyIn12 x = unsafeCoerce# x -{-# INLINE happyIn12 #-} -happyOut12 :: (HappyAbsSyn ) -> (([ImportDecl],[Decl])) -happyOut12 x = unsafeCoerce# x -{-# INLINE happyOut12 #-} -happyIn13 :: (([ImportDecl],[Decl])) -> (HappyAbsSyn ) -happyIn13 x = unsafeCoerce# x -{-# INLINE happyIn13 #-} -happyOut13 :: (HappyAbsSyn ) -> (([ImportDecl],[Decl])) -happyOut13 x = unsafeCoerce# x -{-# INLINE happyOut13 #-} -happyIn14 :: (()) -> (HappyAbsSyn ) -happyIn14 x = unsafeCoerce# x -{-# INLINE happyIn14 #-} -happyOut14 :: (HappyAbsSyn ) -> (()) -happyOut14 x = unsafeCoerce# x -{-# INLINE happyOut14 #-} -happyIn15 :: (()) -> (HappyAbsSyn ) -happyIn15 x = unsafeCoerce# x -{-# INLINE happyIn15 #-} -happyOut15 :: (HappyAbsSyn ) -> (()) -happyOut15 x = unsafeCoerce# x -{-# INLINE happyOut15 #-} -happyIn16 :: (Maybe [ExportSpec]) -> (HappyAbsSyn ) -happyIn16 x = unsafeCoerce# x -{-# INLINE happyIn16 #-} -happyOut16 :: (HappyAbsSyn ) -> (Maybe [ExportSpec]) -happyOut16 x = unsafeCoerce# x -{-# INLINE happyOut16 #-} -happyIn17 :: ([ExportSpec]) -> (HappyAbsSyn ) -happyIn17 x = unsafeCoerce# x -{-# INLINE happyIn17 #-} -happyOut17 :: (HappyAbsSyn ) -> ([ExportSpec]) -happyOut17 x = unsafeCoerce# x -{-# INLINE happyOut17 #-} -happyIn18 :: (()) -> (HappyAbsSyn ) -happyIn18 x = unsafeCoerce# x -{-# INLINE happyIn18 #-} -happyOut18 :: (HappyAbsSyn ) -> (()) -happyOut18 x = unsafeCoerce# x -{-# INLINE happyOut18 #-} -happyIn19 :: ([ExportSpec]) -> (HappyAbsSyn ) -happyIn19 x = unsafeCoerce# x -{-# INLINE happyIn19 #-} -happyOut19 :: (HappyAbsSyn ) -> ([ExportSpec]) -happyOut19 x = unsafeCoerce# x -{-# INLINE happyOut19 #-} -happyIn20 :: (ExportSpec) -> (HappyAbsSyn ) -happyIn20 x = unsafeCoerce# x -{-# INLINE happyIn20 #-} -happyOut20 :: (HappyAbsSyn ) -> (ExportSpec) -happyOut20 x = unsafeCoerce# x -{-# INLINE happyOut20 #-} -happyIn21 :: ([ImportDecl]) -> (HappyAbsSyn ) -happyIn21 x = unsafeCoerce# x -{-# INLINE happyIn21 #-} -happyOut21 :: (HappyAbsSyn ) -> ([ImportDecl]) -happyOut21 x = unsafeCoerce# x -{-# INLINE happyOut21 #-} -happyIn22 :: (ImportDecl) -> (HappyAbsSyn ) -happyIn22 x = unsafeCoerce# x -{-# INLINE happyIn22 #-} -happyOut22 :: (HappyAbsSyn ) -> (ImportDecl) -happyOut22 x = unsafeCoerce# x -{-# INLINE happyOut22 #-} -happyIn23 :: (Bool) -> (HappyAbsSyn ) -happyIn23 x = unsafeCoerce# x -{-# INLINE happyIn23 #-} -happyOut23 :: (HappyAbsSyn ) -> (Bool) -happyOut23 x = unsafeCoerce# x -{-# INLINE happyOut23 #-} -happyIn24 :: (Bool) -> (HappyAbsSyn ) -happyIn24 x = unsafeCoerce# x -{-# INLINE happyIn24 #-} -happyOut24 :: (HappyAbsSyn ) -> (Bool) -happyOut24 x = unsafeCoerce# x -{-# INLINE happyOut24 #-} -happyIn25 :: (Maybe ModuleName) -> (HappyAbsSyn ) -happyIn25 x = unsafeCoerce# x -{-# INLINE happyIn25 #-} -happyOut25 :: (HappyAbsSyn ) -> (Maybe ModuleName) -happyOut25 x = unsafeCoerce# x -{-# INLINE happyOut25 #-} -happyIn26 :: (Maybe (Bool, [ImportSpec])) -> (HappyAbsSyn ) -happyIn26 x = unsafeCoerce# x -{-# INLINE happyIn26 #-} -happyOut26 :: (HappyAbsSyn ) -> (Maybe (Bool, [ImportSpec])) -happyOut26 x = unsafeCoerce# x -{-# INLINE happyOut26 #-} -happyIn27 :: ((Bool, [ImportSpec])) -> (HappyAbsSyn ) -happyIn27 x = unsafeCoerce# x -{-# INLINE happyIn27 #-} -happyOut27 :: (HappyAbsSyn ) -> ((Bool, [ImportSpec])) -happyOut27 x = unsafeCoerce# x -{-# INLINE happyOut27 #-} -happyIn28 :: (Bool) -> (HappyAbsSyn ) -happyIn28 x = unsafeCoerce# x -{-# INLINE happyIn28 #-} -happyOut28 :: (HappyAbsSyn ) -> (Bool) -happyOut28 x = unsafeCoerce# x -{-# INLINE happyOut28 #-} -happyIn29 :: ([ImportSpec]) -> (HappyAbsSyn ) -happyIn29 x = unsafeCoerce# x -{-# INLINE happyIn29 #-} -happyOut29 :: (HappyAbsSyn ) -> ([ImportSpec]) -happyOut29 x = unsafeCoerce# x -{-# INLINE happyOut29 #-} -happyIn30 :: (ImportSpec) -> (HappyAbsSyn ) -happyIn30 x = unsafeCoerce# x -{-# INLINE happyIn30 #-} -happyOut30 :: (HappyAbsSyn ) -> (ImportSpec) -happyOut30 x = unsafeCoerce# x -{-# INLINE happyOut30 #-} -happyIn31 :: ([CName]) -> (HappyAbsSyn ) -happyIn31 x = unsafeCoerce# x -{-# INLINE happyIn31 #-} -happyOut31 :: (HappyAbsSyn ) -> ([CName]) -happyOut31 x = unsafeCoerce# x -{-# INLINE happyOut31 #-} -happyIn32 :: (CName) -> (HappyAbsSyn ) -happyIn32 x = unsafeCoerce# x -{-# INLINE happyIn32 #-} -happyOut32 :: (HappyAbsSyn ) -> (CName) -happyOut32 x = unsafeCoerce# x -{-# INLINE happyOut32 #-} -happyIn33 :: (Decl) -> (HappyAbsSyn ) -happyIn33 x = unsafeCoerce# x -{-# INLINE happyIn33 #-} -happyOut33 :: (HappyAbsSyn ) -> (Decl) -happyOut33 x = unsafeCoerce# x -{-# INLINE happyOut33 #-} -happyIn34 :: (Int) -> (HappyAbsSyn ) -happyIn34 x = unsafeCoerce# x -{-# INLINE happyIn34 #-} -happyOut34 :: (HappyAbsSyn ) -> (Int) -happyOut34 x = unsafeCoerce# x -{-# INLINE happyOut34 #-} -happyIn35 :: (Assoc) -> (HappyAbsSyn ) -happyIn35 x = unsafeCoerce# x -{-# INLINE happyIn35 #-} -happyOut35 :: (HappyAbsSyn ) -> (Assoc) -happyOut35 x = unsafeCoerce# x -{-# INLINE happyOut35 #-} -happyIn36 :: ([Op]) -> (HappyAbsSyn ) -happyIn36 x = unsafeCoerce# x -{-# INLINE happyIn36 #-} -happyOut36 :: (HappyAbsSyn ) -> ([Op]) -happyOut36 x = unsafeCoerce# x -{-# INLINE happyOut36 #-} -happyIn37 :: ([Decl]) -> (HappyAbsSyn ) -happyIn37 x = unsafeCoerce# x -{-# INLINE happyIn37 #-} -happyOut37 :: (HappyAbsSyn ) -> ([Decl]) -happyOut37 x = unsafeCoerce# x -{-# INLINE happyOut37 #-} -happyIn38 :: ([Decl]) -> (HappyAbsSyn ) -happyIn38 x = unsafeCoerce# x -{-# INLINE happyIn38 #-} -happyOut38 :: (HappyAbsSyn ) -> ([Decl]) -happyOut38 x = unsafeCoerce# x -{-# INLINE happyOut38 #-} -happyIn39 :: (Decl) -> (HappyAbsSyn ) -happyIn39 x = unsafeCoerce# x -{-# INLINE happyIn39 #-} -happyOut39 :: (HappyAbsSyn ) -> (Decl) -happyOut39 x = unsafeCoerce# x -{-# INLINE happyOut39 #-} -happyIn40 :: (DataOrNew) -> (HappyAbsSyn ) -happyIn40 x = unsafeCoerce# x -{-# INLINE happyIn40 #-} -happyOut40 :: (HappyAbsSyn ) -> (DataOrNew) -happyOut40 x = unsafeCoerce# x -{-# INLINE happyOut40 #-} -happyIn41 :: ([Type]) -> (HappyAbsSyn ) -happyIn41 x = unsafeCoerce# x -{-# INLINE happyIn41 #-} -happyOut41 :: (HappyAbsSyn ) -> ([Type]) -happyOut41 x = unsafeCoerce# x -{-# INLINE happyOut41 #-} -happyIn42 :: ([Decl]) -> (HappyAbsSyn ) -happyIn42 x = unsafeCoerce# x -{-# INLINE happyIn42 #-} -happyOut42 :: (HappyAbsSyn ) -> ([Decl]) -happyOut42 x = unsafeCoerce# x -{-# INLINE happyOut42 #-} -happyIn43 :: ([Decl]) -> (HappyAbsSyn ) -happyIn43 x = unsafeCoerce# x -{-# INLINE happyIn43 #-} -happyOut43 :: (HappyAbsSyn ) -> ([Decl]) -happyOut43 x = unsafeCoerce# x -{-# INLINE happyOut43 #-} -happyIn44 :: (Decl) -> (HappyAbsSyn ) -happyIn44 x = unsafeCoerce# x -{-# INLINE happyIn44 #-} -happyOut44 :: (HappyAbsSyn ) -> (Decl) -happyOut44 x = unsafeCoerce# x -{-# INLINE happyOut44 #-} -happyIn45 :: ([Decl]) -> (HappyAbsSyn ) -happyIn45 x = unsafeCoerce# x -{-# INLINE happyIn45 #-} -happyOut45 :: (HappyAbsSyn ) -> ([Decl]) -happyOut45 x = unsafeCoerce# x -{-# INLINE happyOut45 #-} -happyIn46 :: (Decl) -> (HappyAbsSyn ) -happyIn46 x = unsafeCoerce# x -{-# INLINE happyIn46 #-} -happyOut46 :: (HappyAbsSyn ) -> (Decl) -happyOut46 x = unsafeCoerce# x -{-# INLINE happyOut46 #-} -happyIn47 :: ([Type]) -> (HappyAbsSyn ) -happyIn47 x = unsafeCoerce# x -{-# INLINE happyIn47 #-} -happyOut47 :: (HappyAbsSyn ) -> ([Type]) -happyOut47 x = unsafeCoerce# x -{-# INLINE happyOut47 #-} -happyIn48 :: (Type) -> (HappyAbsSyn ) -happyIn48 x = unsafeCoerce# x -{-# INLINE happyIn48 #-} -happyOut48 :: (HappyAbsSyn ) -> (Type) -happyOut48 x = unsafeCoerce# x -{-# INLINE happyOut48 #-} -happyIn49 :: (Binds) -> (HappyAbsSyn ) -happyIn49 x = unsafeCoerce# x -{-# INLINE happyIn49 #-} -happyOut49 :: (HappyAbsSyn ) -> (Binds) -happyOut49 x = unsafeCoerce# x -{-# INLINE happyOut49 #-} -happyIn50 :: ([Name]) -> (HappyAbsSyn ) -happyIn50 x = unsafeCoerce# x -{-# INLINE happyIn50 #-} -happyOut50 :: (HappyAbsSyn ) -> ([Name]) -happyOut50 x = unsafeCoerce# x -{-# INLINE happyOut50 #-} -happyIn51 :: (CallConv) -> (HappyAbsSyn ) -happyIn51 x = unsafeCoerce# x -{-# INLINE happyIn51 #-} -happyOut51 :: (HappyAbsSyn ) -> (CallConv) -happyOut51 x = unsafeCoerce# x -{-# INLINE happyOut51 #-} -happyIn52 :: (Safety) -> (HappyAbsSyn ) -happyIn52 x = unsafeCoerce# x -{-# INLINE happyIn52 #-} -happyOut52 :: (HappyAbsSyn ) -> (Safety) -happyOut52 x = unsafeCoerce# x -{-# INLINE happyOut52 #-} -happyIn53 :: ((String, Name, Type)) -> (HappyAbsSyn ) -happyIn53 x = unsafeCoerce# x -{-# INLINE happyIn53 #-} -happyOut53 :: (HappyAbsSyn ) -> ((String, Name, Type)) -happyOut53 x = unsafeCoerce# x -{-# INLINE happyOut53 #-} -happyIn54 :: ([Rule]) -> (HappyAbsSyn ) -happyIn54 x = unsafeCoerce# x -{-# INLINE happyIn54 #-} -happyOut54 :: (HappyAbsSyn ) -> ([Rule]) -happyOut54 x = unsafeCoerce# x -{-# INLINE happyOut54 #-} -happyIn55 :: (Rule) -> (HappyAbsSyn ) -happyIn55 x = unsafeCoerce# x -{-# INLINE happyIn55 #-} -happyOut55 :: (HappyAbsSyn ) -> (Rule) -happyOut55 x = unsafeCoerce# x -{-# INLINE happyOut55 #-} -happyIn56 :: (Activation) -> (HappyAbsSyn ) -happyIn56 x = unsafeCoerce# x -{-# INLINE happyIn56 #-} -happyOut56 :: (HappyAbsSyn ) -> (Activation) -happyOut56 x = unsafeCoerce# x -{-# INLINE happyOut56 #-} -happyIn57 :: (Maybe [RuleVar]) -> (HappyAbsSyn ) -happyIn57 x = unsafeCoerce# x -{-# INLINE happyIn57 #-} -happyOut57 :: (HappyAbsSyn ) -> (Maybe [RuleVar]) -happyOut57 x = unsafeCoerce# x -{-# INLINE happyOut57 #-} -happyIn58 :: ([RuleVar]) -> (HappyAbsSyn ) -happyIn58 x = unsafeCoerce# x -{-# INLINE happyIn58 #-} -happyOut58 :: (HappyAbsSyn ) -> ([RuleVar]) -happyOut58 x = unsafeCoerce# x -{-# INLINE happyOut58 #-} -happyIn59 :: (RuleVar) -> (HappyAbsSyn ) -happyIn59 x = unsafeCoerce# x -{-# INLINE happyIn59 #-} -happyOut59 :: (HappyAbsSyn ) -> (RuleVar) -happyOut59 x = unsafeCoerce# x -{-# INLINE happyOut59 #-} -happyIn60 :: ([([Name],String)]) -> (HappyAbsSyn ) -happyIn60 x = unsafeCoerce# x -{-# INLINE happyIn60 #-} -happyOut60 :: (HappyAbsSyn ) -> ([([Name],String)]) -happyOut60 x = unsafeCoerce# x -{-# INLINE happyOut60 #-} -happyIn61 :: (([Name], String)) -> (HappyAbsSyn ) -happyIn61 x = unsafeCoerce# x -{-# INLINE happyIn61 #-} -happyOut61 :: (HappyAbsSyn ) -> (([Name], String)) -happyOut61 x = unsafeCoerce# x -{-# INLINE happyOut61 #-} -happyIn62 :: ([Name]) -> (HappyAbsSyn ) -happyIn62 x = unsafeCoerce# x -{-# INLINE happyIn62 #-} -happyOut62 :: (HappyAbsSyn ) -> ([Name]) -happyOut62 x = unsafeCoerce# x -{-# INLINE happyOut62 #-} -happyIn63 :: (Name) -> (HappyAbsSyn ) -happyIn63 x = unsafeCoerce# x -{-# INLINE happyIn63 #-} -happyOut63 :: (HappyAbsSyn ) -> (Name) -happyOut63 x = unsafeCoerce# x -{-# INLINE happyOut63 #-} -happyIn64 :: (Type) -> (HappyAbsSyn ) -happyIn64 x = unsafeCoerce# x -{-# INLINE happyIn64 #-} -happyOut64 :: (HappyAbsSyn ) -> (Type) -happyOut64 x = unsafeCoerce# x -{-# INLINE happyOut64 #-} -happyIn65 :: (Type) -> (HappyAbsSyn ) -happyIn65 x = unsafeCoerce# x -{-# INLINE happyIn65 #-} -happyOut65 :: (HappyAbsSyn ) -> (Type) -happyOut65 x = unsafeCoerce# x -{-# INLINE happyOut65 #-} -happyIn66 :: (Type) -> (HappyAbsSyn ) -happyIn66 x = unsafeCoerce# x -{-# INLINE happyIn66 #-} -happyOut66 :: (HappyAbsSyn ) -> (Type) -happyOut66 x = unsafeCoerce# x -{-# INLINE happyOut66 #-} -happyIn67 :: (Type) -> (HappyAbsSyn ) -happyIn67 x = unsafeCoerce# x -{-# INLINE happyIn67 #-} -happyOut67 :: (HappyAbsSyn ) -> (Type) -happyOut67 x = unsafeCoerce# x -{-# INLINE happyOut67 #-} -happyIn68 :: (QName) -> (HappyAbsSyn ) -happyIn68 x = unsafeCoerce# x -{-# INLINE happyIn68 #-} -happyOut68 :: (HappyAbsSyn ) -> (QName) -happyOut68 x = unsafeCoerce# x -{-# INLINE happyOut68 #-} -happyIn69 :: (QName) -> (HappyAbsSyn ) -happyIn69 x = unsafeCoerce# x -{-# INLINE happyIn69 #-} -happyOut69 :: (HappyAbsSyn ) -> (QName) -happyOut69 x = unsafeCoerce# x -{-# INLINE happyOut69 #-} -happyIn70 :: (Type) -> (HappyAbsSyn ) -happyIn70 x = unsafeCoerce# x -{-# INLINE happyIn70 #-} -happyOut70 :: (HappyAbsSyn ) -> (Type) -happyOut70 x = unsafeCoerce# x -{-# INLINE happyOut70 #-} -happyIn71 :: (Context) -> (HappyAbsSyn ) -happyIn71 x = unsafeCoerce# x -{-# INLINE happyIn71 #-} -happyOut71 :: (HappyAbsSyn ) -> (Context) -happyOut71 x = unsafeCoerce# x -{-# INLINE happyOut71 #-} -happyIn72 :: ([Type]) -> (HappyAbsSyn ) -happyIn72 x = unsafeCoerce# x -{-# INLINE happyIn72 #-} -happyOut72 :: (HappyAbsSyn ) -> ([Type]) -happyOut72 x = unsafeCoerce# x -{-# INLINE happyOut72 #-} -happyIn73 :: ([Type]) -> (HappyAbsSyn ) -happyIn73 x = unsafeCoerce# x -{-# INLINE happyIn73 #-} -happyOut73 :: (HappyAbsSyn ) -> ([Type]) -happyOut73 x = unsafeCoerce# x -{-# INLINE happyOut73 #-} -happyIn74 :: ([TyVarBind]) -> (HappyAbsSyn ) -happyIn74 x = unsafeCoerce# x -{-# INLINE happyIn74 #-} -happyOut74 :: (HappyAbsSyn ) -> ([TyVarBind]) -happyOut74 x = unsafeCoerce# x -{-# INLINE happyOut74 #-} -happyIn75 :: (TyVarBind) -> (HappyAbsSyn ) -happyIn75 x = unsafeCoerce# x -{-# INLINE happyIn75 #-} -happyOut75 :: (HappyAbsSyn ) -> (TyVarBind) -happyOut75 x = unsafeCoerce# x -{-# INLINE happyOut75 #-} -happyIn76 :: ([Name]) -> (HappyAbsSyn ) -happyIn76 x = unsafeCoerce# x -{-# INLINE happyIn76 #-} -happyOut76 :: (HappyAbsSyn ) -> ([Name]) -happyOut76 x = unsafeCoerce# x -{-# INLINE happyOut76 #-} -happyIn77 :: ([FunDep]) -> (HappyAbsSyn ) -happyIn77 x = unsafeCoerce# x -{-# INLINE happyIn77 #-} -happyOut77 :: (HappyAbsSyn ) -> ([FunDep]) -happyOut77 x = unsafeCoerce# x -{-# INLINE happyOut77 #-} -happyIn78 :: ([FunDep]) -> (HappyAbsSyn ) -happyIn78 x = unsafeCoerce# x -{-# INLINE happyIn78 #-} -happyOut78 :: (HappyAbsSyn ) -> ([FunDep]) -happyOut78 x = unsafeCoerce# x -{-# INLINE happyOut78 #-} -happyIn79 :: (FunDep) -> (HappyAbsSyn ) -happyIn79 x = unsafeCoerce# x -{-# INLINE happyIn79 #-} -happyOut79 :: (HappyAbsSyn ) -> (FunDep) -happyOut79 x = unsafeCoerce# x -{-# INLINE happyOut79 #-} -happyIn80 :: ([GadtDecl]) -> (HappyAbsSyn ) -happyIn80 x = unsafeCoerce# x -{-# INLINE happyIn80 #-} -happyOut80 :: (HappyAbsSyn ) -> ([GadtDecl]) -happyOut80 x = unsafeCoerce# x -{-# INLINE happyOut80 #-} -happyIn81 :: ([GadtDecl]) -> (HappyAbsSyn ) -happyIn81 x = unsafeCoerce# x -{-# INLINE happyIn81 #-} -happyOut81 :: (HappyAbsSyn ) -> ([GadtDecl]) -happyOut81 x = unsafeCoerce# x -{-# INLINE happyOut81 #-} -happyIn82 :: ([GadtDecl]) -> (HappyAbsSyn ) -happyIn82 x = unsafeCoerce# x -{-# INLINE happyIn82 #-} -happyOut82 :: (HappyAbsSyn ) -> ([GadtDecl]) -happyOut82 x = unsafeCoerce# x -{-# INLINE happyOut82 #-} -happyIn83 :: (GadtDecl) -> (HappyAbsSyn ) -happyIn83 x = unsafeCoerce# x -{-# INLINE happyIn83 #-} -happyOut83 :: (HappyAbsSyn ) -> (GadtDecl) -happyOut83 x = unsafeCoerce# x -{-# INLINE happyOut83 #-} -happyIn84 :: ([QualConDecl]) -> (HappyAbsSyn ) -happyIn84 x = unsafeCoerce# x -{-# INLINE happyIn84 #-} -happyOut84 :: (HappyAbsSyn ) -> ([QualConDecl]) -happyOut84 x = unsafeCoerce# x -{-# INLINE happyOut84 #-} -happyIn85 :: ([QualConDecl]) -> (HappyAbsSyn ) -happyIn85 x = unsafeCoerce# x -{-# INLINE happyIn85 #-} -happyOut85 :: (HappyAbsSyn ) -> ([QualConDecl]) -happyOut85 x = unsafeCoerce# x -{-# INLINE happyOut85 #-} -happyIn86 :: (QualConDecl) -> (HappyAbsSyn ) -happyIn86 x = unsafeCoerce# x -{-# INLINE happyIn86 #-} -happyOut86 :: (HappyAbsSyn ) -> (QualConDecl) -happyOut86 x = unsafeCoerce# x -{-# INLINE happyOut86 #-} -happyIn87 :: ([TyVarBind]) -> (HappyAbsSyn ) -happyIn87 x = unsafeCoerce# x -{-# INLINE happyIn87 #-} -happyOut87 :: (HappyAbsSyn ) -> ([TyVarBind]) -happyOut87 x = unsafeCoerce# x -{-# INLINE happyOut87 #-} -happyIn88 :: (ConDecl) -> (HappyAbsSyn ) -happyIn88 x = unsafeCoerce# x -{-# INLINE happyIn88 #-} -happyOut88 :: (HappyAbsSyn ) -> (ConDecl) -happyOut88 x = unsafeCoerce# x -{-# INLINE happyOut88 #-} -happyIn89 :: ((Name, [BangType])) -> (HappyAbsSyn ) -happyIn89 x = unsafeCoerce# x -{-# INLINE happyIn89 #-} -happyOut89 :: (HappyAbsSyn ) -> ((Name, [BangType])) -happyOut89 x = unsafeCoerce# x -{-# INLINE happyOut89 #-} -happyIn90 :: ((Name, [BangType])) -> (HappyAbsSyn ) -happyIn90 x = unsafeCoerce# x -{-# INLINE happyIn90 #-} -happyOut90 :: (HappyAbsSyn ) -> ((Name, [BangType])) -happyOut90 x = unsafeCoerce# x -{-# INLINE happyOut90 #-} -happyIn91 :: (BangType) -> (HappyAbsSyn ) -happyIn91 x = unsafeCoerce# x -{-# INLINE happyIn91 #-} -happyOut91 :: (HappyAbsSyn ) -> (BangType) -happyOut91 x = unsafeCoerce# x -{-# INLINE happyOut91 #-} -happyIn92 :: (BangType) -> (HappyAbsSyn ) -happyIn92 x = unsafeCoerce# x -{-# INLINE happyIn92 #-} -happyOut92 :: (HappyAbsSyn ) -> (BangType) -happyOut92 x = unsafeCoerce# x -{-# INLINE happyOut92 #-} -happyIn93 :: ([([Name],BangType)]) -> (HappyAbsSyn ) -happyIn93 x = unsafeCoerce# x -{-# INLINE happyIn93 #-} -happyOut93 :: (HappyAbsSyn ) -> ([([Name],BangType)]) -happyOut93 x = unsafeCoerce# x -{-# INLINE happyOut93 #-} -happyIn94 :: (([Name],BangType)) -> (HappyAbsSyn ) -happyIn94 x = unsafeCoerce# x -{-# INLINE happyIn94 #-} -happyOut94 :: (HappyAbsSyn ) -> (([Name],BangType)) -happyOut94 x = unsafeCoerce# x -{-# INLINE happyOut94 #-} -happyIn95 :: (BangType) -> (HappyAbsSyn ) -happyIn95 x = unsafeCoerce# x -{-# INLINE happyIn95 #-} -happyOut95 :: (HappyAbsSyn ) -> (BangType) -happyOut95 x = unsafeCoerce# x -{-# INLINE happyOut95 #-} -happyIn96 :: ([Deriving]) -> (HappyAbsSyn ) -happyIn96 x = unsafeCoerce# x -{-# INLINE happyIn96 #-} -happyOut96 :: (HappyAbsSyn ) -> ([Deriving]) -happyOut96 x = unsafeCoerce# x -{-# INLINE happyOut96 #-} -happyIn97 :: ([Deriving]) -> (HappyAbsSyn ) -happyIn97 x = unsafeCoerce# x -{-# INLINE happyIn97 #-} -happyOut97 :: (HappyAbsSyn ) -> ([Deriving]) -happyOut97 x = unsafeCoerce# x -{-# INLINE happyOut97 #-} -happyIn98 :: (Deriving) -> (HappyAbsSyn ) -happyIn98 x = unsafeCoerce# x -{-# INLINE happyIn98 #-} -happyOut98 :: (HappyAbsSyn ) -> (Deriving) -happyOut98 x = unsafeCoerce# x -{-# INLINE happyOut98 #-} -happyIn99 :: ([QName]) -> (HappyAbsSyn ) -happyIn99 x = unsafeCoerce# x -{-# INLINE happyIn99 #-} -happyOut99 :: (HappyAbsSyn ) -> ([QName]) -happyOut99 x = unsafeCoerce# x -{-# INLINE happyOut99 #-} -happyIn100 :: (QName) -> (HappyAbsSyn ) -happyIn100 x = unsafeCoerce# x -{-# INLINE happyIn100 #-} -happyOut100 :: (HappyAbsSyn ) -> (QName) -happyOut100 x = unsafeCoerce# x -{-# INLINE happyOut100 #-} -happyIn101 :: (QName) -> (HappyAbsSyn ) -happyIn101 x = unsafeCoerce# x -{-# INLINE happyIn101 #-} -happyOut101 :: (HappyAbsSyn ) -> (QName) -happyOut101 x = unsafeCoerce# x -{-# INLINE happyOut101 #-} -happyIn102 :: (Kind) -> (HappyAbsSyn ) -happyIn102 x = unsafeCoerce# x -{-# INLINE happyIn102 #-} -happyOut102 :: (HappyAbsSyn ) -> (Kind) -happyOut102 x = unsafeCoerce# x -{-# INLINE happyOut102 #-} -happyIn103 :: (Kind) -> (HappyAbsSyn ) -happyIn103 x = unsafeCoerce# x -{-# INLINE happyIn103 #-} -happyOut103 :: (HappyAbsSyn ) -> (Kind) -happyOut103 x = unsafeCoerce# x -{-# INLINE happyOut103 #-} -happyIn104 :: (Maybe Kind) -> (HappyAbsSyn ) -happyIn104 x = unsafeCoerce# x -{-# INLINE happyIn104 #-} -happyOut104 :: (HappyAbsSyn ) -> (Maybe Kind) -happyOut104 x = unsafeCoerce# x -{-# INLINE happyOut104 #-} -happyIn105 :: ([ClassDecl]) -> (HappyAbsSyn ) -happyIn105 x = unsafeCoerce# x -{-# INLINE happyIn105 #-} -happyOut105 :: (HappyAbsSyn ) -> ([ClassDecl]) -happyOut105 x = unsafeCoerce# x -{-# INLINE happyOut105 #-} -happyIn106 :: ([ClassDecl]) -> (HappyAbsSyn ) -happyIn106 x = unsafeCoerce# x -{-# INLINE happyIn106 #-} -happyOut106 :: (HappyAbsSyn ) -> ([ClassDecl]) -happyOut106 x = unsafeCoerce# x -{-# INLINE happyOut106 #-} -happyIn107 :: ([ClassDecl]) -> (HappyAbsSyn ) -happyIn107 x = unsafeCoerce# x -{-# INLINE happyIn107 #-} -happyOut107 :: (HappyAbsSyn ) -> ([ClassDecl]) -happyOut107 x = unsafeCoerce# x -{-# INLINE happyOut107 #-} -happyIn108 :: ([ClassDecl]) -> (HappyAbsSyn ) -happyIn108 x = unsafeCoerce# x -{-# INLINE happyIn108 #-} -happyOut108 :: (HappyAbsSyn ) -> ([ClassDecl]) -happyOut108 x = unsafeCoerce# x -{-# INLINE happyOut108 #-} -happyIn109 :: (ClassDecl) -> (HappyAbsSyn ) -happyIn109 x = unsafeCoerce# x -{-# INLINE happyIn109 #-} -happyOut109 :: (HappyAbsSyn ) -> (ClassDecl) -happyOut109 x = unsafeCoerce# x -{-# INLINE happyOut109 #-} -happyIn110 :: (ClassDecl) -> (HappyAbsSyn ) -happyIn110 x = unsafeCoerce# x -{-# INLINE happyIn110 #-} -happyOut110 :: (HappyAbsSyn ) -> (ClassDecl) -happyOut110 x = unsafeCoerce# x -{-# INLINE happyOut110 #-} -happyIn111 :: ([InstDecl]) -> (HappyAbsSyn ) -happyIn111 x = unsafeCoerce# x -{-# INLINE happyIn111 #-} -happyOut111 :: (HappyAbsSyn ) -> ([InstDecl]) -happyOut111 x = unsafeCoerce# x -{-# INLINE happyOut111 #-} -happyIn112 :: ([InstDecl]) -> (HappyAbsSyn ) -happyIn112 x = unsafeCoerce# x -{-# INLINE happyIn112 #-} -happyOut112 :: (HappyAbsSyn ) -> ([InstDecl]) -happyOut112 x = unsafeCoerce# x -{-# INLINE happyOut112 #-} -happyIn113 :: ([InstDecl]) -> (HappyAbsSyn ) -happyIn113 x = unsafeCoerce# x -{-# INLINE happyIn113 #-} -happyOut113 :: (HappyAbsSyn ) -> ([InstDecl]) -happyOut113 x = unsafeCoerce# x -{-# INLINE happyOut113 #-} -happyIn114 :: (InstDecl) -> (HappyAbsSyn ) -happyIn114 x = unsafeCoerce# x -{-# INLINE happyIn114 #-} -happyOut114 :: (HappyAbsSyn ) -> (InstDecl) -happyOut114 x = unsafeCoerce# x -{-# INLINE happyOut114 #-} -happyIn115 :: (InstDecl) -> (HappyAbsSyn ) -happyIn115 x = unsafeCoerce# x -{-# INLINE happyIn115 #-} -happyOut115 :: (HappyAbsSyn ) -> (InstDecl) -happyOut115 x = unsafeCoerce# x -{-# INLINE happyOut115 #-} -happyIn116 :: (InstDecl) -> (HappyAbsSyn ) -happyIn116 x = unsafeCoerce# x -{-# INLINE happyIn116 #-} -happyOut116 :: (HappyAbsSyn ) -> (InstDecl) -happyOut116 x = unsafeCoerce# x -{-# INLINE happyOut116 #-} -happyIn117 :: (Decl) -> (HappyAbsSyn ) -happyIn117 x = unsafeCoerce# x -{-# INLINE happyIn117 #-} -happyOut117 :: (HappyAbsSyn ) -> (Decl) -happyOut117 x = unsafeCoerce# x -{-# INLINE happyOut117 #-} -happyIn118 :: (Binds) -> (HappyAbsSyn ) -happyIn118 x = unsafeCoerce# x -{-# INLINE happyIn118 #-} -happyOut118 :: (HappyAbsSyn ) -> (Binds) -happyOut118 x = unsafeCoerce# x -{-# INLINE happyOut118 #-} -happyIn119 :: (Maybe Type) -> (HappyAbsSyn ) -happyIn119 x = unsafeCoerce# x -{-# INLINE happyIn119 #-} -happyOut119 :: (HappyAbsSyn ) -> (Maybe Type) -happyOut119 x = unsafeCoerce# x -{-# INLINE happyOut119 #-} -happyIn120 :: (Rhs) -> (HappyAbsSyn ) -happyIn120 x = unsafeCoerce# x -{-# INLINE happyIn120 #-} -happyOut120 :: (HappyAbsSyn ) -> (Rhs) -happyOut120 x = unsafeCoerce# x -{-# INLINE happyOut120 #-} -happyIn121 :: ([GuardedRhs]) -> (HappyAbsSyn ) -happyIn121 x = unsafeCoerce# x -{-# INLINE happyIn121 #-} -happyOut121 :: (HappyAbsSyn ) -> ([GuardedRhs]) -happyOut121 x = unsafeCoerce# x -{-# INLINE happyOut121 #-} -happyIn122 :: (GuardedRhs) -> (HappyAbsSyn ) -happyIn122 x = unsafeCoerce# x -{-# INLINE happyIn122 #-} -happyOut122 :: (HappyAbsSyn ) -> (GuardedRhs) -happyOut122 x = unsafeCoerce# x -{-# INLINE happyOut122 #-} -happyIn123 :: (Exp) -> (HappyAbsSyn ) -happyIn123 x = unsafeCoerce# x -{-# INLINE happyIn123 #-} -happyOut123 :: (HappyAbsSyn ) -> (Exp) -happyOut123 x = unsafeCoerce# x -{-# INLINE happyOut123 #-} -happyIn124 :: (PExp) -> (HappyAbsSyn ) -happyIn124 x = unsafeCoerce# x -{-# INLINE happyIn124 #-} -happyOut124 :: (HappyAbsSyn ) -> (PExp) -happyOut124 x = unsafeCoerce# x -{-# INLINE happyOut124 #-} -happyIn125 :: (PExp) -> (HappyAbsSyn ) -happyIn125 x = unsafeCoerce# x -{-# INLINE happyIn125 #-} -happyOut125 :: (HappyAbsSyn ) -> (PExp) -happyOut125 x = unsafeCoerce# x -{-# INLINE happyOut125 #-} -happyIn126 :: (PExp) -> (HappyAbsSyn ) -happyIn126 x = unsafeCoerce# x -{-# INLINE happyIn126 #-} -happyOut126 :: (HappyAbsSyn ) -> (PExp) -happyOut126 x = unsafeCoerce# x -{-# INLINE happyOut126 #-} -happyIn127 :: (PExp) -> (HappyAbsSyn ) -happyIn127 x = unsafeCoerce# x -{-# INLINE happyIn127 #-} -happyOut127 :: (HappyAbsSyn ) -> (PExp) -happyOut127 x = unsafeCoerce# x -{-# INLINE happyOut127 #-} -happyIn128 :: (PExp) -> (HappyAbsSyn ) -happyIn128 x = unsafeCoerce# x -{-# INLINE happyIn128 #-} -happyOut128 :: (HappyAbsSyn ) -> (PExp) -happyOut128 x = unsafeCoerce# x -{-# INLINE happyOut128 #-} -happyIn129 :: (PExp) -> (HappyAbsSyn ) -happyIn129 x = unsafeCoerce# x -{-# INLINE happyIn129 #-} -happyOut129 :: (HappyAbsSyn ) -> (PExp) -happyOut129 x = unsafeCoerce# x -{-# INLINE happyOut129 #-} -happyIn130 :: (PExp) -> (HappyAbsSyn ) -happyIn130 x = unsafeCoerce# x -{-# INLINE happyIn130 #-} -happyOut130 :: (HappyAbsSyn ) -> (PExp) -happyOut130 x = unsafeCoerce# x -{-# INLINE happyOut130 #-} -happyIn131 :: (PExp) -> (HappyAbsSyn ) -happyIn131 x = unsafeCoerce# x -{-# INLINE happyIn131 #-} -happyOut131 :: (HappyAbsSyn ) -> (PExp) -happyOut131 x = unsafeCoerce# x -{-# INLINE happyOut131 #-} -happyIn132 :: ([Pat]) -> (HappyAbsSyn ) -happyIn132 x = unsafeCoerce# x -{-# INLINE happyIn132 #-} -happyOut132 :: (HappyAbsSyn ) -> ([Pat]) -happyOut132 x = unsafeCoerce# x -{-# INLINE happyOut132 #-} -happyIn133 :: (Pat) -> (HappyAbsSyn ) -happyIn133 x = unsafeCoerce# x -{-# INLINE happyIn133 #-} -happyOut133 :: (HappyAbsSyn ) -> (Pat) -happyOut133 x = unsafeCoerce# x -{-# INLINE happyOut133 #-} -happyIn134 :: (PExp) -> (HappyAbsSyn ) -happyIn134 x = unsafeCoerce# x -{-# INLINE happyIn134 #-} -happyOut134 :: (HappyAbsSyn ) -> (PExp) -happyOut134 x = unsafeCoerce# x -{-# INLINE happyOut134 #-} -happyIn135 :: (PExp) -> (HappyAbsSyn ) -happyIn135 x = unsafeCoerce# x -{-# INLINE happyIn135 #-} -happyOut135 :: (HappyAbsSyn ) -> (PExp) -happyOut135 x = unsafeCoerce# x -{-# INLINE happyOut135 #-} -happyIn136 :: (PExp) -> (HappyAbsSyn ) -happyIn136 x = unsafeCoerce# x -{-# INLINE happyIn136 #-} -happyOut136 :: (HappyAbsSyn ) -> (PExp) -happyOut136 x = unsafeCoerce# x -{-# INLINE happyOut136 #-} -happyIn137 :: (Int) -> (HappyAbsSyn ) -happyIn137 x = unsafeCoerce# x -{-# INLINE happyIn137 #-} -happyOut137 :: (HappyAbsSyn ) -> (Int) -happyOut137 x = unsafeCoerce# x -{-# INLINE happyOut137 #-} -happyIn138 :: ([PExp]) -> (HappyAbsSyn ) -happyIn138 x = unsafeCoerce# x -{-# INLINE happyIn138 #-} -happyOut138 :: (HappyAbsSyn ) -> ([PExp]) -happyOut138 x = unsafeCoerce# x -{-# INLINE happyOut138 #-} -happyIn139 :: (PExp) -> (HappyAbsSyn ) -happyIn139 x = unsafeCoerce# x -{-# INLINE happyIn139 #-} -happyOut139 :: (HappyAbsSyn ) -> (PExp) -happyOut139 x = unsafeCoerce# x -{-# INLINE happyOut139 #-} -happyIn140 :: ([PExp]) -> (HappyAbsSyn ) -happyIn140 x = unsafeCoerce# x -{-# INLINE happyIn140 #-} -happyOut140 :: (HappyAbsSyn ) -> ([PExp]) -happyOut140 x = unsafeCoerce# x -{-# INLINE happyOut140 #-} -happyIn141 :: (PExp) -> (HappyAbsSyn ) -happyIn141 x = unsafeCoerce# x -{-# INLINE happyIn141 #-} -happyOut141 :: (HappyAbsSyn ) -> (PExp) -happyOut141 x = unsafeCoerce# x -{-# INLINE happyOut141 #-} -happyIn142 :: (PExp) -> (HappyAbsSyn ) -happyIn142 x = unsafeCoerce# x -{-# INLINE happyIn142 #-} -happyOut142 :: (HappyAbsSyn ) -> (PExp) -happyOut142 x = unsafeCoerce# x -{-# INLINE happyOut142 #-} -happyIn143 :: ([PExp]) -> (HappyAbsSyn ) -happyIn143 x = unsafeCoerce# x -{-# INLINE happyIn143 #-} -happyOut143 :: (HappyAbsSyn ) -> ([PExp]) -happyOut143 x = unsafeCoerce# x -{-# INLINE happyOut143 #-} -happyIn144 :: (PExp) -> (HappyAbsSyn ) -happyIn144 x = unsafeCoerce# x -{-# INLINE happyIn144 #-} -happyOut144 :: (HappyAbsSyn ) -> (PExp) -happyOut144 x = unsafeCoerce# x -{-# INLINE happyOut144 #-} -happyIn145 :: (XName) -> (HappyAbsSyn ) -happyIn145 x = unsafeCoerce# x -{-# INLINE happyIn145 #-} -happyOut145 :: (HappyAbsSyn ) -> (XName) -happyOut145 x = unsafeCoerce# x -{-# INLINE happyOut145 #-} -happyIn146 :: (String) -> (HappyAbsSyn ) -happyIn146 x = unsafeCoerce# x -{-# INLINE happyIn146 #-} -happyOut146 :: (HappyAbsSyn ) -> (String) -happyOut146 x = unsafeCoerce# x -{-# INLINE happyOut146 #-} -happyIn147 :: ([ParseXAttr]) -> (HappyAbsSyn ) -happyIn147 x = unsafeCoerce# x -{-# INLINE happyIn147 #-} -happyOut147 :: (HappyAbsSyn ) -> ([ParseXAttr]) -happyOut147 x = unsafeCoerce# x -{-# INLINE happyOut147 #-} -happyIn148 :: (ParseXAttr) -> (HappyAbsSyn ) -happyIn148 x = unsafeCoerce# x -{-# INLINE happyIn148 #-} -happyOut148 :: (HappyAbsSyn ) -> (ParseXAttr) -happyOut148 x = unsafeCoerce# x -{-# INLINE happyOut148 #-} -happyIn149 :: (Maybe PExp) -> (HappyAbsSyn ) -happyIn149 x = unsafeCoerce# x -{-# INLINE happyIn149 #-} -happyOut149 :: (HappyAbsSyn ) -> (Maybe PExp) -happyOut149 x = unsafeCoerce# x -{-# INLINE happyOut149 #-} -happyIn150 :: (PExp) -> (HappyAbsSyn ) -happyIn150 x = unsafeCoerce# x -{-# INLINE happyIn150 #-} -happyOut150 :: (HappyAbsSyn ) -> (PExp) -happyOut150 x = unsafeCoerce# x -{-# INLINE happyOut150 #-} -happyIn151 :: (PExp) -> (HappyAbsSyn ) -happyIn151 x = unsafeCoerce# x -{-# INLINE happyIn151 #-} -happyOut151 :: (HappyAbsSyn ) -> (PExp) -happyOut151 x = unsafeCoerce# x -{-# INLINE happyOut151 #-} -happyIn152 :: ([PExp]) -> (HappyAbsSyn ) -happyIn152 x = unsafeCoerce# x -{-# INLINE happyIn152 #-} -happyOut152 :: (HappyAbsSyn ) -> ([PExp]) -happyOut152 x = unsafeCoerce# x -{-# INLINE happyOut152 #-} -happyIn153 :: ([Stmt]) -> (HappyAbsSyn ) -happyIn153 x = unsafeCoerce# x -{-# INLINE happyIn153 #-} -happyOut153 :: (HappyAbsSyn ) -> ([Stmt]) -happyOut153 x = unsafeCoerce# x -{-# INLINE happyOut153 #-} -happyIn154 :: (Stmt) -> (HappyAbsSyn ) -happyIn154 x = unsafeCoerce# x -{-# INLINE happyIn154 #-} -happyOut154 :: (HappyAbsSyn ) -> (Stmt) -happyOut154 x = unsafeCoerce# x -{-# INLINE happyOut154 #-} -happyIn155 :: ([Alt]) -> (HappyAbsSyn ) -happyIn155 x = unsafeCoerce# x -{-# INLINE happyIn155 #-} -happyOut155 :: (HappyAbsSyn ) -> ([Alt]) -happyOut155 x = unsafeCoerce# x -{-# INLINE happyOut155 #-} -happyIn156 :: ([Alt]) -> (HappyAbsSyn ) -happyIn156 x = unsafeCoerce# x -{-# INLINE happyIn156 #-} -happyOut156 :: (HappyAbsSyn ) -> ([Alt]) -happyOut156 x = unsafeCoerce# x -{-# INLINE happyOut156 #-} -happyIn157 :: ([Alt]) -> (HappyAbsSyn ) -happyIn157 x = unsafeCoerce# x -{-# INLINE happyIn157 #-} -happyOut157 :: (HappyAbsSyn ) -> ([Alt]) -happyOut157 x = unsafeCoerce# x -{-# INLINE happyOut157 #-} -happyIn158 :: (Alt) -> (HappyAbsSyn ) -happyIn158 x = unsafeCoerce# x -{-# INLINE happyIn158 #-} -happyOut158 :: (HappyAbsSyn ) -> (Alt) -happyOut158 x = unsafeCoerce# x -{-# INLINE happyOut158 #-} -happyIn159 :: (GuardedAlts) -> (HappyAbsSyn ) -happyIn159 x = unsafeCoerce# x -{-# INLINE happyIn159 #-} -happyOut159 :: (HappyAbsSyn ) -> (GuardedAlts) -happyOut159 x = unsafeCoerce# x -{-# INLINE happyOut159 #-} -happyIn160 :: ([GuardedAlt]) -> (HappyAbsSyn ) -happyIn160 x = unsafeCoerce# x -{-# INLINE happyIn160 #-} -happyOut160 :: (HappyAbsSyn ) -> ([GuardedAlt]) -happyOut160 x = unsafeCoerce# x -{-# INLINE happyOut160 #-} -happyIn161 :: (GuardedAlt) -> (HappyAbsSyn ) -happyIn161 x = unsafeCoerce# x -{-# INLINE happyIn161 #-} -happyOut161 :: (HappyAbsSyn ) -> (GuardedAlt) -happyOut161 x = unsafeCoerce# x -{-# INLINE happyOut161 #-} -happyIn162 :: (Pat) -> (HappyAbsSyn ) -happyIn162 x = unsafeCoerce# x -{-# INLINE happyIn162 #-} -happyOut162 :: (HappyAbsSyn ) -> (Pat) -happyOut162 x = unsafeCoerce# x -{-# INLINE happyOut162 #-} -happyIn163 :: ([Stmt]) -> (HappyAbsSyn ) -happyIn163 x = unsafeCoerce# x -{-# INLINE happyIn163 #-} -happyOut163 :: (HappyAbsSyn ) -> ([Stmt]) -happyOut163 x = unsafeCoerce# x -{-# INLINE happyOut163 #-} -happyIn164 :: ([Stmt]) -> (HappyAbsSyn ) -happyIn164 x = unsafeCoerce# x -{-# INLINE happyIn164 #-} -happyOut164 :: (HappyAbsSyn ) -> ([Stmt]) -happyOut164 x = unsafeCoerce# x -{-# INLINE happyOut164 #-} -happyIn165 :: ([PFieldUpdate]) -> (HappyAbsSyn ) -happyIn165 x = unsafeCoerce# x -{-# INLINE happyIn165 #-} -happyOut165 :: (HappyAbsSyn ) -> ([PFieldUpdate]) -happyOut165 x = unsafeCoerce# x -{-# INLINE happyOut165 #-} -happyIn166 :: (PFieldUpdate) -> (HappyAbsSyn ) -happyIn166 x = unsafeCoerce# x -{-# INLINE happyIn166 #-} -happyOut166 :: (HappyAbsSyn ) -> (PFieldUpdate) -happyOut166 x = unsafeCoerce# x -{-# INLINE happyOut166 #-} -happyIn167 :: ([IPBind]) -> (HappyAbsSyn ) -happyIn167 x = unsafeCoerce# x -{-# INLINE happyIn167 #-} -happyOut167 :: (HappyAbsSyn ) -> ([IPBind]) -happyOut167 x = unsafeCoerce# x -{-# INLINE happyOut167 #-} -happyIn168 :: ([IPBind]) -> (HappyAbsSyn ) -happyIn168 x = unsafeCoerce# x -{-# INLINE happyIn168 #-} -happyOut168 :: (HappyAbsSyn ) -> ([IPBind]) -happyOut168 x = unsafeCoerce# x -{-# INLINE happyOut168 #-} -happyIn169 :: (IPBind) -> (HappyAbsSyn ) -happyIn169 x = unsafeCoerce# x -{-# INLINE happyIn169 #-} -happyOut169 :: (HappyAbsSyn ) -> (IPBind) -happyOut169 x = unsafeCoerce# x -{-# INLINE happyOut169 #-} -happyIn170 :: (PExp) -> (HappyAbsSyn ) -happyIn170 x = unsafeCoerce# x -{-# INLINE happyIn170 #-} -happyOut170 :: (HappyAbsSyn ) -> (PExp) -happyOut170 x = unsafeCoerce# x -{-# INLINE happyOut170 #-} -happyIn171 :: (Name) -> (HappyAbsSyn ) -happyIn171 x = unsafeCoerce# x -{-# INLINE happyIn171 #-} -happyOut171 :: (HappyAbsSyn ) -> (Name) -happyOut171 x = unsafeCoerce# x -{-# INLINE happyOut171 #-} -happyIn172 :: (Name) -> (HappyAbsSyn ) -happyIn172 x = unsafeCoerce# x -{-# INLINE happyIn172 #-} -happyOut172 :: (HappyAbsSyn ) -> (Name) -happyOut172 x = unsafeCoerce# x -{-# INLINE happyOut172 #-} -happyIn173 :: (QName) -> (HappyAbsSyn ) -happyIn173 x = unsafeCoerce# x -{-# INLINE happyIn173 #-} -happyOut173 :: (HappyAbsSyn ) -> (QName) -happyOut173 x = unsafeCoerce# x -{-# INLINE happyOut173 #-} -happyIn174 :: (IPName) -> (HappyAbsSyn ) -happyIn174 x = unsafeCoerce# x -{-# INLINE happyIn174 #-} -happyOut174 :: (HappyAbsSyn ) -> (IPName) -happyOut174 x = unsafeCoerce# x -{-# INLINE happyOut174 #-} -happyIn175 :: (Name) -> (HappyAbsSyn ) -happyIn175 x = unsafeCoerce# x -{-# INLINE happyIn175 #-} -happyOut175 :: (HappyAbsSyn ) -> (Name) -happyOut175 x = unsafeCoerce# x -{-# INLINE happyOut175 #-} -happyIn176 :: (QName) -> (HappyAbsSyn ) -happyIn176 x = unsafeCoerce# x -{-# INLINE happyIn176 #-} -happyOut176 :: (HappyAbsSyn ) -> (QName) -happyOut176 x = unsafeCoerce# x -{-# INLINE happyOut176 #-} -happyIn177 :: (Name) -> (HappyAbsSyn ) -happyIn177 x = unsafeCoerce# x -{-# INLINE happyIn177 #-} -happyOut177 :: (HappyAbsSyn ) -> (Name) -happyOut177 x = unsafeCoerce# x -{-# INLINE happyOut177 #-} -happyIn178 :: (QName) -> (HappyAbsSyn ) -happyIn178 x = unsafeCoerce# x -{-# INLINE happyIn178 #-} -happyOut178 :: (HappyAbsSyn ) -> (QName) -happyOut178 x = unsafeCoerce# x -{-# INLINE happyOut178 #-} -happyIn179 :: (QName) -> (HappyAbsSyn ) -happyIn179 x = unsafeCoerce# x -{-# INLINE happyIn179 #-} -happyOut179 :: (HappyAbsSyn ) -> (QName) -happyOut179 x = unsafeCoerce# x -{-# INLINE happyOut179 #-} -happyIn180 :: (Name) -> (HappyAbsSyn ) -happyIn180 x = unsafeCoerce# x -{-# INLINE happyIn180 #-} -happyOut180 :: (HappyAbsSyn ) -> (Name) -happyOut180 x = unsafeCoerce# x -{-# INLINE happyOut180 #-} -happyIn181 :: (QName) -> (HappyAbsSyn ) -happyIn181 x = unsafeCoerce# x -{-# INLINE happyIn181 #-} -happyOut181 :: (HappyAbsSyn ) -> (QName) -happyOut181 x = unsafeCoerce# x -{-# INLINE happyOut181 #-} -happyIn182 :: (Op) -> (HappyAbsSyn ) -happyIn182 x = unsafeCoerce# x -{-# INLINE happyIn182 #-} -happyOut182 :: (HappyAbsSyn ) -> (Op) -happyOut182 x = unsafeCoerce# x -{-# INLINE happyOut182 #-} -happyIn183 :: (QOp) -> (HappyAbsSyn ) -happyIn183 x = unsafeCoerce# x -{-# INLINE happyIn183 #-} -happyOut183 :: (HappyAbsSyn ) -> (QOp) -happyOut183 x = unsafeCoerce# x -{-# INLINE happyOut183 #-} -happyIn184 :: (QOp) -> (HappyAbsSyn ) -happyIn184 x = unsafeCoerce# x -{-# INLINE happyIn184 #-} -happyOut184 :: (HappyAbsSyn ) -> (QOp) -happyOut184 x = unsafeCoerce# x -{-# INLINE happyOut184 #-} -happyIn185 :: (QName) -> (HappyAbsSyn ) -happyIn185 x = unsafeCoerce# x -{-# INLINE happyIn185 #-} -happyOut185 :: (HappyAbsSyn ) -> (QName) -happyOut185 x = unsafeCoerce# x -{-# INLINE happyOut185 #-} -happyIn186 :: (QName) -> (HappyAbsSyn ) -happyIn186 x = unsafeCoerce# x -{-# INLINE happyIn186 #-} -happyOut186 :: (HappyAbsSyn ) -> (QName) -happyOut186 x = unsafeCoerce# x -{-# INLINE happyOut186 #-} -happyIn187 :: (Name) -> (HappyAbsSyn ) -happyIn187 x = unsafeCoerce# x -{-# INLINE happyIn187 #-} -happyOut187 :: (HappyAbsSyn ) -> (Name) -happyOut187 x = unsafeCoerce# x -{-# INLINE happyOut187 #-} -happyIn188 :: (Name) -> (HappyAbsSyn ) -happyIn188 x = unsafeCoerce# x -{-# INLINE happyIn188 #-} -happyOut188 :: (HappyAbsSyn ) -> (Name) -happyOut188 x = unsafeCoerce# x -{-# INLINE happyOut188 #-} -happyIn189 :: (IPName) -> (HappyAbsSyn ) -happyIn189 x = unsafeCoerce# x -{-# INLINE happyIn189 #-} -happyOut189 :: (HappyAbsSyn ) -> (IPName) -happyOut189 x = unsafeCoerce# x -{-# INLINE happyOut189 #-} -happyIn190 :: (QName) -> (HappyAbsSyn ) -happyIn190 x = unsafeCoerce# x -{-# INLINE happyIn190 #-} -happyOut190 :: (HappyAbsSyn ) -> (QName) -happyOut190 x = unsafeCoerce# x -{-# INLINE happyOut190 #-} -happyIn191 :: (Name) -> (HappyAbsSyn ) -happyIn191 x = unsafeCoerce# x -{-# INLINE happyIn191 #-} -happyOut191 :: (HappyAbsSyn ) -> (Name) -happyOut191 x = unsafeCoerce# x -{-# INLINE happyOut191 #-} -happyIn192 :: (QName) -> (HappyAbsSyn ) -happyIn192 x = unsafeCoerce# x -{-# INLINE happyIn192 #-} -happyOut192 :: (HappyAbsSyn ) -> (QName) -happyOut192 x = unsafeCoerce# x -{-# INLINE happyOut192 #-} -happyIn193 :: (Name) -> (HappyAbsSyn ) -happyIn193 x = unsafeCoerce# x -{-# INLINE happyIn193 #-} -happyOut193 :: (HappyAbsSyn ) -> (Name) -happyOut193 x = unsafeCoerce# x -{-# INLINE happyOut193 #-} -happyIn194 :: (QName) -> (HappyAbsSyn ) -happyIn194 x = unsafeCoerce# x -{-# INLINE happyIn194 #-} -happyOut194 :: (HappyAbsSyn ) -> (QName) -happyOut194 x = unsafeCoerce# x -{-# INLINE happyOut194 #-} -happyIn195 :: (QName) -> (HappyAbsSyn ) -happyIn195 x = unsafeCoerce# x -{-# INLINE happyIn195 #-} -happyOut195 :: (HappyAbsSyn ) -> (QName) -happyOut195 x = unsafeCoerce# x -{-# INLINE happyOut195 #-} -happyIn196 :: (Name) -> (HappyAbsSyn ) -happyIn196 x = unsafeCoerce# x -{-# INLINE happyIn196 #-} -happyOut196 :: (HappyAbsSyn ) -> (Name) -happyOut196 x = unsafeCoerce# x -{-# INLINE happyOut196 #-} -happyIn197 :: (Name) -> (HappyAbsSyn ) -happyIn197 x = unsafeCoerce# x -{-# INLINE happyIn197 #-} -happyOut197 :: (HappyAbsSyn ) -> (Name) -happyOut197 x = unsafeCoerce# x -{-# INLINE happyOut197 #-} -happyIn198 :: (QName) -> (HappyAbsSyn ) -happyIn198 x = unsafeCoerce# x -{-# INLINE happyIn198 #-} -happyOut198 :: (HappyAbsSyn ) -> (QName) -happyOut198 x = unsafeCoerce# x -{-# INLINE happyOut198 #-} -happyIn199 :: (Literal) -> (HappyAbsSyn ) -happyIn199 x = unsafeCoerce# x -{-# INLINE happyIn199 #-} -happyOut199 :: (HappyAbsSyn ) -> (Literal) -happyOut199 x = unsafeCoerce# x -{-# INLINE happyOut199 #-} -happyIn200 :: (SrcLoc) -> (HappyAbsSyn ) -happyIn200 x = unsafeCoerce# x -{-# INLINE happyIn200 #-} -happyOut200 :: (HappyAbsSyn ) -> (SrcLoc) -happyOut200 x = unsafeCoerce# x -{-# INLINE happyOut200 #-} -happyIn201 :: (()) -> (HappyAbsSyn ) -happyIn201 x = unsafeCoerce# x -{-# INLINE happyIn201 #-} -happyOut201 :: (HappyAbsSyn ) -> (()) -happyOut201 x = unsafeCoerce# x -{-# INLINE happyOut201 #-} -happyIn202 :: (()) -> (HappyAbsSyn ) -happyIn202 x = unsafeCoerce# x -{-# INLINE happyIn202 #-} -happyOut202 :: (HappyAbsSyn ) -> (()) -happyOut202 x = unsafeCoerce# x -{-# INLINE happyOut202 #-} -happyIn203 :: (ModuleName) -> (HappyAbsSyn ) -happyIn203 x = unsafeCoerce# x -{-# INLINE happyIn203 #-} -happyOut203 :: (HappyAbsSyn ) -> (ModuleName) -happyOut203 x = unsafeCoerce# x -{-# INLINE happyOut203 #-} -happyIn204 :: (Name) -> (HappyAbsSyn ) -happyIn204 x = unsafeCoerce# x -{-# INLINE happyIn204 #-} -happyOut204 :: (HappyAbsSyn ) -> (Name) -happyOut204 x = unsafeCoerce# x -{-# INLINE happyOut204 #-} -happyIn205 :: (QName) -> (HappyAbsSyn ) -happyIn205 x = unsafeCoerce# x -{-# INLINE happyIn205 #-} -happyOut205 :: (HappyAbsSyn ) -> (QName) -happyOut205 x = unsafeCoerce# x -{-# INLINE happyOut205 #-} -happyIn206 :: (Name) -> (HappyAbsSyn ) -happyIn206 x = unsafeCoerce# x -{-# INLINE happyIn206 #-} -happyOut206 :: (HappyAbsSyn ) -> (Name) -happyOut206 x = unsafeCoerce# x -{-# INLINE happyOut206 #-} -happyIn207 :: (QName) -> (HappyAbsSyn ) -happyIn207 x = unsafeCoerce# x -{-# INLINE happyIn207 #-} -happyOut207 :: (HappyAbsSyn ) -> (QName) -happyOut207 x = unsafeCoerce# x -{-# INLINE happyOut207 #-} -happyIn208 :: (Name) -> (HappyAbsSyn ) -happyIn208 x = unsafeCoerce# x -{-# INLINE happyIn208 #-} -happyOut208 :: (HappyAbsSyn ) -> (Name) -happyOut208 x = unsafeCoerce# x -{-# INLINE happyOut208 #-} -happyInTok :: Token -> (HappyAbsSyn ) -happyInTok x = unsafeCoerce# x -{-# INLINE happyInTok #-} -happyOutTok :: (HappyAbsSyn ) -> Token -happyOutTok x = unsafeCoerce# x -{-# INLINE happyOutTok #-} - - -happyActOffsets :: HappyAddr -happyActOffsets = HappyA# "\x00\x00\x00\x00\x00\x00\x62\x06\xe8\x07\x24\x08\x00\x00\x00\x00\xf0\x00\x00\x00\x71\x00\x41\x08\xa8\x05\x18\x08\xd6\x01\xe1\x07\xdf\x07\xdc\x07\x4d\x08\xd7\x07\xd8\x03\x00\x00\x00\x00\x00\x00\x05\x08\x24\x00\x00\x00\x00\x00\x00\x00\xb5\x05\x3a\x05\x00\x00\x00\x00\x2b\x08\x00\x00\x47\x06\x71\x00\x00\x00\x00\x00\x00\x00\xca\x07\x21\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd6\x01\xd7\x17\x2c\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x07\x00\x00\x00\x00\x1a\x08\x20\x08\x0c\x08\xa9\x07\x9d\x07\xad\x07\x00\x00\xee\x1a\x07\x08\xed\x19\x95\x1c\x00\x00\x00\x00\x82\x18\x00\x00\xf4\x07\x00\x00\x00\x00\x00\x00\x00\x00\x68\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd2\x07\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\x9f\x08\x7f\x10\x00\x00\xd0\x18\xd0\x18\x4f\x15\x00\x00\x4f\x15\x4f\x15\x4f\x15\x83\x1a\x00\x00\x64\x1b\x5d\x18\x4f\x15\x4a\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x15\x83\x1a\xb4\x07\xf2\x07\xa7\x07\xe9\x07\x00\x00\x99\x07\x00\x00\x00\x00\x00\x00\x83\x1a\xda\x07\x00\x00\xbe\x1a\x00\x00\xd6\x07\xb3\x17\xd6\x07\xe3\x07\xe2\x07\xe0\x07\xde\x07\x0a\x1c\x0a\x1c\x75\x07\x37\x07\xd0\x07\xbf\x06\xd0\x07\x00\x00\x00\x00\x00\x00\xbb\x07\x00\x00\x3d\x05\x42\x04\xf1\x03\xf5\x02\x4f\x15\x00\x00\xc8\x07\x00\x00\x00\x00\x00\x00\x80\x0a\x00\x00\x00\x00\x4f\x15\xc2\x07\x67\x07\x00\x00\x00\x00\xd0\x18\x00\x00\x00\x00\x00\x00\x27\x08\xca\x1d\x1c\x00\x00\x00\xcc\x07\xba\x07\x00\x00\x00\x00\x00\x00\x00\x00\x81\x05\x13\x00\xc3\x07\x59\x07\x58\x07\x10\x00\x00\x00\xb0\x07\xf6\x1b\x2b\x00\xa6\x07\x10\x07\x83\x1a\xf6\x1b\xa3\x07\x93\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcc\x19\x99\x1a\x4a\x1a\x99\x1a\x43\x1b\x00\x00\x0f\x10\x0f\x10\x00\x00\x00\x00\x1e\x19\x64\x07\x9b\x07\xa2\x07\x00\x00\x5f\x07\x4d\x07\x00\x00\x28\x1a\x99\x1a\x28\x1a\x90\x07\x56\x07\x0e\x05\x0e\x05\x74\x07\x00\x00\x00\x00\x2c\x02\x98\x07\x00\x00\x00\x00\x1b\x08\x00\x00\x73\x07\x72\x07\xf0\x0a\x71\x07\x94\x07\x81\x07\x25\x01\x82\x18\x00\x00\x78\x07\xc5\x02\x7f\x07\x7c\x07\x00\x00\xc4\x02\x02\x03\xf8\x02\x84\x07\x00\x00\x00\x00\x4f\x15\x82\x07\x00\x00\x00\x00\x80\x07\x00\x00\x00\x00\x00\x00\x7b\x07\x77\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x1b\x66\x07\x00\x00\x82\x18\x65\x07\x63\x07\xd6\x01\xd0\x18\xd0\x18\x22\x06\x00\x00\x52\x07\x00\x00\x00\x00\xbf\x15\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x1b\x6b\x1b\x00\x00\x28\x1a\x00\x00\x00\x00\x00\x00\x23\x01\x28\x1a\xd6\x05\x00\x00\x60\x07\x55\x07\x00\x00\x00\x00\x00\x00\x5c\x07\x00\x00\x67\x05\x4f\x07\x00\x00\x00\x00\x00\x00\x00\x00\x7c\x1b\x51\x07\xac\x18\x00\x00\x47\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9b\x06\x23\x01\x12\x07\xf2\x06\xf4\x01\x00\x00\x55\x02\x41\x07\x40\x07\x9c\x02\x00\x00\x00\x00\xef\x06\x31\x07\x00\x00\x2e\x07\x4f\x15\x0f\x03\x00\x00\x00\x00\x2d\x07\x2c\x07\x10\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x07\x00\x00\x00\x00\x3a\x07\x00\x00\x00\x00\x4f\x15\x00\x00\x00\x00\x4f\x15\x4f\x15\x4f\x15\x00\x00\x4f\x15\x9f\x0f\xdf\x14\x6f\x14\x00\x00\xff\x13\x89\x17\x00\x00\x8f\x13\x00\x00\x00\x00\x71\x00\x39\x07\x00\x00\xf6\x02\x00\x00\x38\x07\x00\x00\xff\x03\x00\x00\x00\x00\x41\x16\x33\x07\xcf\x06\x00\x00\x1c\x07\x1e\x07\x14\x07\x00\x00\x0b\x07\x00\x00\x00\x00\x67\x05\x00\x00\xe5\x1b\x3c\x1b\x99\x1a\x00\x00\x17\x07\x00\x00\x3c\x1b\x00\x00\x3c\x1b\x00\x00\x00\x00\x5e\x1a\x3c\x1b\x3c\x1b\x0c\x07\xfa\x06\x00\x00\x07\x07\x2f\x0f\x06\x07\x71\x00\xf8\x06\xf0\x06\xf6\x06\x00\x00\x09\x02\xe5\x06\xb8\x01\xed\x06\x3c\x1b\x28\x1a\x89\x06\x88\x06\x28\x1a\xe0\x06\xf1\x06\xcc\x06\xa3\x06\xe1\x06\x00\x00\x00\x00\x00\x00\xca\x06\xb9\x1b\x00\x00\xd6\x06\xd4\x06\xb9\x1b\x00\x00\x00\x00\x00\x00\x55\x05\x00\x00\x00\x00\x8f\x06\x00\x00\x00\x00\x7d\x06\xd0\x18\xbf\x0e\x00\x00\x00\x00\x28\x1a\x00\x00\x34\x18\x00\x00\x00\x00\x8f\x13\x5f\x0a\xc5\x06\xc3\x06\x71\x00\x71\x00\x8f\x13\x00\x00\x00\x00\x00\x00\xd6\x01\x8f\x13\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x06\x00\x00\x8f\x13\x3a\x1c\x28\x1a\xbc\x06\x00\x00\x65\x06\xa9\x06\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x1b\x00\x00\x00\x00\xf4\x01\x00\x00\x99\x1a\x00\x00\x00\x00\x28\x1a\x00\x00\x5a\x00\x00\x00\x00\x00\xa0\x06\x8f\x0c\xe7\x1a\x00\x00\xa6\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x07\x28\x1a\x79\x06\x99\x1a\x00\x00\x00\x00\x45\x19\x9e\x06\x00\x00\x00\x00\x9f\x06\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x06\x00\x00\x9e\x02\xb9\x01\x41\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x06\x00\x00\xa3\x00\x00\x00\x00\x00\x8e\x06\x00\x00\x82\x06\x00\x00\xfe\x00\x00\x00\x00\x00\x00\x00\x75\x06\x00\x00\xee\x02\x00\x00\x00\x00\x00\x00\xd7\x17\x86\x06\x8f\x13\x00\x00\x0f\x1a\x00\x00\x1f\x13\x00\x00\x00\x00\x72\x06\x33\x1c\x28\x1a\x00\x00\x00\x00\x63\x06\x00\x00\x34\x06\x00\x00\x5e\x06\xf4\x01\x00\x00\x00\x00\x6c\x06\x00\x00\x98\x03\x28\x06\x11\x06\x51\x06\x4f\x06\xd6\x05\x00\x00\x00\x00\xc3\x02\x00\x00\x00\x00\x00\x00\x00\x00\x52\x06\x00\x00\x00\x00\xb9\x1b\x00\x00\x00\x00\x00\x00\x4c\x06\x00\x00\x00\x00\x00\x00\xd4\x01\x13\x06\x00\x00\x00\x00\x4d\x06\xf4\x01\x16\x17\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x01\x00\x00\xcd\x00\x00\x00\x00\x00\x10\x05\x00\x00\xaf\x12\xbf\x0e\x3f\x12\x08\x06\x38\x06\x00\x00\x00\x00\x00\x00\x49\x06\x39\x06\x3c\x1b\x44\x06\x36\x06\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x31\x06\x38\x00\x44\x05\x00\x00\x2a\x06\xaf\x0b\x33\x06\x71\x00\x00\x00\x00\x00\xcf\x11\x4f\x0e\x00\x00\x00\x00\x2e\x06\x28\x1a\x00\x00\x00\x00\xc9\x05\x1d\x06\x21\x1c\x00\x00\x13\x07\x0a\x06\x0b\x06\x00\x00\x13\x01\xed\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3f\x0b\xd9\x05\x00\x00\xcf\x11\x00\x00\x00\x00\xcf\x11\x04\x06\x1e\x05\x0e\x06\xcf\x0a\x0e\x06\x00\x00\x00\x00\x15\x06\xcf\x11\x06\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdf\x0d\xf4\x01\x00\x00\x00\x00\x00\x00\x02\x06\x00\x00\x13\x07\x00\x00\x0f\x09\xfb\x05\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcf\x11\x00\x00\x3c\x1b\x00\x00\xcf\x11\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcf\x11\x00\x00\xd1\x1b\xfc\x15\xdf\x05\x00\x00\x00\x00\xda\x16\x48\x00\xfa\x05\xf9\x05\x57\x19\x3c\x1b\x95\x05\x00\x00\x00\x00\xf0\x05\xe7\x05\x71\x00\x00\x00\x93\x02\x00\x00\x00\x00\x8b\x07\x00\x00\xb1\x05\x00\x00\x00\x00\x8b\x07\x00\x00\x00\x00\x00\x00\x00\x00\xfa\x04\x00\x00\x00\x00\x00\x00\x00\x00\x70\x03\xcd\x05\x00\x00\x1d\x17\xb8\x16\xf2\x05\x00\x00\x00\x00\x3c\x1b\x83\x05\x7c\x16\x3c\x1b\x3c\x1b\x82\x05\x00\x00\x00\x00\x33\x05\x00\x00\x00\x00\x00\x00\xcb\x05\x6f\x0d\xda\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xef\x09\x32\x19\xdc\x05\x28\x1a\xc0\x08\x00\x00\x3c\x1b\xd1\x05\x1f\x0c\xcf\x05\xff\x0c\x28\x1a\x00\x00\xb3\x05\x00\x00\x3f\x0b\x00\x00\xe8\x04\xcf\x11\x00\x00\x00\x00\xb0\x05\xca\x05\xbe\x05\x00\x00\x00\x00\xa5\x1b\xac\x05\x28\x1a\x23\x01\x00\x00\xb7\x05\xaa\x05\x00\x00\x00\x00\x00\x00\xae\x05\x28\x1a\x99\x1a\x7f\x09\xa4\x05\x00\x00\x5a\x05\x94\x05\x00\x00\x85\x05\xcf\x11\xd6\x01\x84\x05\x00\x00\x3c\x1b\x5a\x16\x00\x00\x7d\x05\x00\x00\x3c\x1b\x00\x00\x2d\x02\x35\x02\x00\x00\x00\x00\x3c\x1b\x75\x05\x1f\x02\xce\x02\x87\x05\x00\x00\x00\x00\x00\x00\x28\x1a\x00\x00\x00\x00\xa5\x1b\x1e\x16\x3c\x1b\x3c\x1b\x57\x05\x00\x00\x5f\x11\x00\x00\x00\x00\x00\x00\x6b\x05\x5d\x05\x5d\x05\xf2\x16\x65\x05\x94\x1b\x00\x00\x35\x05\x12\x05\x00\x00\x28\x1a\xfe\x04\x00\x00\xf9\x04\x00\x00\x00\x00\x00\x00\x53\x05\x00\x00\x00\x00\x00\x00\x34\x02\x00\x00\x48\x05\x00\x00\x00\x00\x28\x1a\xec\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x1b\xde\x04\x00\x00\x00\x00\x13\x05\x00\x00\xef\x10\x00\x00\x00\x00\x00\x00\xdf\x04\x00\x00\x00\x00\x3c\x1b\x00\x00\x00\x00"# - -happyGotoOffsets :: HappyAddr -happyGotoOffsets = HappyA# "\x01\x00\x06\x00\x05\x00\x0a\x00\x00\x00\x03\x00\x00\x00\x00\x00\x0b\x00\xfc\xff\x75\x04\x00\x00\x00\x00\x00\x00\x55\x04\x00\x00\x00\x00\x00\x00\x18\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0b\x00\x00\x00\xe2\x03\x9d\x03\x71\x04\x1f\x05\x00\x00\x00\x00\x00\x00\x00\x00\x11\x00\x4b\x04\x68\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x04\xb7\x28\x17\x00\x00\x00\x04\x00\x00\x00\xcd\x04\x00\x00\x00\x00\x00\x00\xb3\x04\x00\x00\x00\x00\x00\x00\x00\x00\x7e\x00\x00\x00\x00\x00\x9d\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x21\x00\xd7\x04\xde\x03\x7f\x05\x00\x00\x00\x00\xaa\x29\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfe\x21\x4b\x22\x00\x00\x6f\x29\x0a\x28\x5b\x24\x00\x00\xb1\x21\x63\x21\x74\x27\xa7\x03\x1f\x04\xed\x08\xd0\xff\xef\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x26\x81\x03\x00\x00\x00\x00\x00\x00\x8f\x00\x00\x00\xcc\x04\x00\x00\x00\x00\x00\x00\x6d\x03\x53\x00\x00\x00\xd4\x04\x00\x00\xa7\x04\x7e\x04\x98\x04\x5c\x04\x00\x00\x00\x00\x00\x00\x7e\x05\x6f\x05\x00\x00\x32\x00\x00\x00\x23\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x21\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x08\x00\x00\x03\x04\x81\x26\x35\x00\x00\x00\x39\x04\x00\x00\x59\x29\x00\x00\x00\x00\x00\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x83\x04\x8d\x03\x00\x00\x00\x00\x0f\x05\x59\x03\x76\x03\x00\x00\x82\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd1\x01\x01\x04\x43\x04\x37\x04\x9e\x04\x00\x00\x38\x1f\xea\x1e\x00\x00\x00\x00\x82\x04\x46\x04\x00\x00\x00\x00\x6d\x04\x8e\x04\x00\x00\x00\x00\x4f\x03\x61\x01\x45\x03\x57\x04\x00\x00\x6c\x04\x62\x04\x00\x00\x00\x00\x00\x00\x05\x04\x00\x00\x00\x00\x00\x00\xa8\x03\x20\x00\x00\x00\x00\x00\x91\x07\x00\x00\x00\x00\x00\x00\x00\x00\x1e\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x27\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\x40\x03\x00\x00\x00\x00\x0a\x28\x00\x00\x00\x00\x19\x04\x08\x29\xcd\x28\x53\x08\x00\x00\xca\x00\x00\x00\x00\x00\xcd\x27\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x01\x03\x00\x00\x24\x03\x00\x00\x00\x00\x00\x00\xae\x01\x18\x03\xef\xff\x00\x00\x00\x00\x6b\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x03\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x03\x18\x01\x07\x04\x00\x00\x24\x04\xda\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfe\x03\xa9\xff\x00\x00\x00\x00\xf4\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x02\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x22\x00\x00\x00\x00\x0e\x24\x34\x26\xc1\x23\x00\x00\x74\x23\x13\x26\x16\x1d\xc6\x25\x00\x00\xc8\x1c\x00\x00\x00\x00\xb7\x27\x00\x00\x00\x00\x96\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdc\x03\x00\x00\x00\x00\x83\x00\x82\xff\xbd\x03\xc3\x03\xb1\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x03\x00\x00\x63\x00\x8a\x04\x2f\x04\x00\x00\x30\x03\x00\x00\x76\x04\x00\x00\x65\x04\x00\x00\x00\x00\xcb\x01\x5e\x04\xeb\x04\x00\x00\x00\x00\x13\x03\x00\x00\x9c\x1e\x29\x00\x0e\x03\x00\x00\x62\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe5\x04\x10\x03\x00\x00\x00\x00\xb5\x01\x00\x00\x00\x00\x00\x00\x7c\x03\x56\x03\x00\x00\x00\x00\x00\x00\x00\x00\x8c\x05\x00\x00\x00\x00\x00\x00\x29\x05\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x00\x00\x00\x00\x55\x00\x49\x00\x00\x00\x20\x28\xb7\x27\xd6\x02\x00\x00\xea\x02\x00\x00\x5b\x28\x00\x00\x00\x00\xa5\x25\x4b\x00\x00\x00\x00\x00\xcd\x02\xca\x02\x58\x25\x00\x00\x00\x00\x00\x00\xf0\x03\x53\x23\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x27\xaf\x00\x8e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x05\x00\x00\x00\x00\x22\x04\x00\x00\x1b\x04\x00\x00\x00\x00\xc0\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\x1e\x58\x05\x00\x00\x00\x00\x00\x00\x00\x00\x1b\x01\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x01\xb5\x02\x68\x03\x16\x04\x00\x00\x00\x00\xb3\x01\x00\x00\x00\x00\x00\x00\xc0\xff\x00\x00\x72\x00\x1e\x00\x00\x00\x00\x00\x00\x00\xa2\x01\x8b\x02\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xad\x02\xee\xff\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\x7c\x28\x00\x00\x37\x25\x00\x00\x05\x06\x00\x00\x7a\x1c\x00\x00\x00\x00\xeb\xff\x7a\x01\x8f\x02\x00\x00\x00\x00\x00\x00\x00\x00\x16\x03\x00\x00\x00\x00\xcd\x03\x00\x00\x00\x00\x15\x00\x00\x00\xa5\x00\xd2\x02\x00\x00\x00\x00\x00\x00\xc5\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\xf2\xff\x00\x00\x00\x00\x00\x00\x19\x01\xbb\x02\x44\x01\x27\x01\x00\x00\xc7\x03\x08\x05\xdd\x02\xd2\xff\x00\x00\x00\x00\x47\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x23\xea\x24\x00\x1e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x04\xe4\x00\x00\x00\x3b\x02\x00\x00\x07\x01\x76\x00\xbe\x01\x00\x00\x9f\x02\x00\x00\x17\x02\x1b\x02\x00\x00\x00\x00\x83\x03\x00\x00\xda\x01\x00\x00\x00\x00\xd3\x20\xb2\x1d\x00\x00\x00\x00\x00\x00\x86\x01\x00\x00\x00\x00\x00\x00\x00\x00\xdb\xff\x00\x00\x29\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc2\x03\x00\x00\x95\x03\x00\x00\xdf\x00\x00\x00\x00\x00\xc9\x24\x00\x00\x00\x00\x7c\x24\x00\x00\xac\x00\x00\x00\x33\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x03\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x01\xda\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x01\x00\x00\xfd\xff\x00\x00\xcc\x01\x00\x00\x00\x00\x2d\x03\x00\x00\xb9\x22\x00\x00\x4d\x04\x00\x00\x64\x20\x00\x00\x00\x00\x00\x00\xc3\x01\x00\x00\x16\x20\x00\x00\x63\x00\x58\x05\x00\x00\x00\x00\x00\x00\xc3\x04\xb9\xff\x00\x00\x00\x00\xbd\x01\x51\x05\x00\x00\x00\x00\x00\x00\x1d\x00\x00\x00\x30\x01\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x01\x00\x00\x57\x01\x00\x00\x00\x00\x05\x01\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\x00\xef\x02\x00\x00\xfb\x01\x00\x00\x00\x00\x36\x01\xfd\x00\xe0\x00\x00\x00\x00\x00\x47\x05\x00\x00\x11\x05\x1e\x03\x36\x05\x00\x00\x00\x00\x00\x00\x5f\x00\x00\x00\x00\x00\x00\x00\xcf\x00\x92\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd1\x02\x00\x00\x00\x00\xc9\x00\x07\x00\x00\x00\x87\x02\x7f\x05\x00\x00\x3c\x04\x47\x01\xaf\x01\x00\x00\x64\x1d\x7b\x02\x00\x00\x00\x00\x00\x00\xc9\x00\x00\x00\x82\x01\xf5\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbc\x02\x00\x00\x66\x02\xf3\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x02\xf5\x03\x2f\x00\x00\x00\x00\x00\xfb\x00\xac\xff\x00\x00\x00\x00\xa7\x1f\x32\x02\x00\x00\x00\x00\x30\x05\x30\x05\x00\x00\x00\x00\x00\x00\x30\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x05\x00\x00\xc4\x01\xed\xff\x00\x00\x00\x00\x00\x00\x00\x00\x51\x02\x00\x00\x00\x00\xf5\x01\xf7\x01\x22\x05\xca\x04\x00\x00\x00\x00\x2c\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x57\x00\x1b\x00\x5c\x00\x00\x00\xf0\xff\x00\x00\x27\x00\x00\x00\x00\x00\x26\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xca\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1e\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfb\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x1f\x00\x00\x00\x00\x00\x00\xde\xff\x00\x00\x00\x00\x66\x00\x00\x00\x00\x00"# - -happyDefActions :: HappyAddr -happyDefActions = HappyA# "\x05\xfe\x00\x00\x00\x00\xf7\xff\x00\x00\x06\xfe\xfe\xff\xfc\xff\x05\xfe\x06\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf7\xff\xf9\xff\x03\xfe\x04\xfe\x00\x00\x05\xfe\xee\xff\xe2\xff\xe2\xff\x00\x00\xeb\xff\x02\xfe\x01\xfe\x00\x00\xe3\xff\xe5\xff\x00\x00\x06\xfe\xf8\xff\xf2\xff\x00\x00\xf0\xff\x22\xfe\xf5\xff\xf3\xff\xf4\xff\x84\xfe\x8c\xfe\x8b\xfe\x8a\xfe\x89\xfe\x87\xfe\x86\xfe\x88\xfe\x00\x00\x06\xfe\x00\x00\xf6\xff\x06\xfe\xe9\xff\xe2\xff\xd2\xff\x90\xff\xe7\xff\xe2\xff\xaf\xff\x9b\xff\x91\xff\x8f\xff\x06\xfe\xe4\xff\xea\xff\xe0\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe1\xff\xdc\xff\xb8\xff\x00\x00\xe0\xfe\xd1\xfe\xc9\xfe\xc8\xfe\xc2\xfe\xbb\xfe\xb8\xfe\xaa\xfe\xab\xfe\xb5\xfe\xb6\xfe\xb7\xfe\x51\xfe\x4c\xfe\x2a\xfe\x33\xfe\x4a\xfe\x47\xfe\x24\xfe\xb4\xfe\x00\x00\x31\xfe\x32\xfe\x26\xfe\x25\xfe\x23\xfe\x80\xfe\x10\xfe\x0e\xfe\x0f\xfe\x0d\xfe\x0c\xfe\x0b\xfe\x0a\xfe\x09\xfe\x08\xfe\x07\xfe\x06\xfe\x06\xfe\xaf\xfe\x06\xfe\x06\xfe\x06\xfe\xa9\xfe\x06\xfe\x06\xfe\x06\xfe\x00\x00\x05\xfe\x00\x00\x00\x00\x06\xfe\x00\x00\x2d\xfe\x29\xfe\x28\xfe\x27\xfe\x2c\xfe\x2b\xfe\x30\xfe\x06\xfe\x00\x00\x9a\xff\x00\x00\x00\x00\x05\xfe\x2e\xfe\xcf\xff\xb6\xff\xb5\xff\xb4\xff\x00\x00\x05\xfe\x99\xff\x00\x00\x2f\xfe\x71\xff\x00\x00\x71\xff\x73\xff\x00\x00\x00\x00\x00\x00\x65\xff\x65\xff\x00\x00\xe3\xff\xb1\xff\xe3\xff\xe6\xff\xfd\xff\xf1\xff\x82\xfe\x00\x00\x85\xfe\x00\x00\x31\xfe\x22\xfe\x80\xfe\x06\xfe\x8d\xfe\x00\x00\xda\xfe\xd8\xfe\xd6\xfe\xd5\xfe\xd3\xfe\x06\xfe\x06\xfe\x05\xfe\x00\x00\x91\xfe\xfa\xff\x06\xfe\xd3\xff\xe8\xff\xb0\xff\x06\xfe\x9c\xff\x00\x00\x66\xff\x00\x00\x63\xff\x60\xff\x61\xff\x50\xfe\x49\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x74\xff\x71\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\xff\x57\xff\x56\xff\xfe\xfd\x4f\xff\x55\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xca\xfe\x06\xfe\x06\xfe\x59\xff\x47\xff\x5f\xff\xf0\xfe\x00\x00\x00\x00\x40\xff\xcd\xff\x00\x00\xcb\xfe\x00\x00\x96\xff\x00\x00\x3b\xff\x00\x00\x00\x00\x00\x00\x00\x00\xa0\xfe\xa1\xfe\x00\x00\x00\x00\xa3\xfe\xa2\xfe\x00\x00\x06\xfe\x00\x00\x00\x00\xd5\xfe\x00\x00\x00\x00\x98\xfe\x00\x00\xcc\xfe\xbc\xfe\x9b\xfe\x7f\xfe\x00\x00\x7e\xfe\x53\xfe\x9b\xfe\x00\x00\x00\x00\x00\x00\x37\xfe\x36\xfe\x06\xfe\x3d\xfe\x34\xfe\x21\xfe\x00\x00\x41\xfe\x1e\xfe\x1c\xfe\x1b\xfe\x15\xfe\x1f\xfe\x11\xfe\x20\xfe\x54\xfe\x9e\xfe\x00\x00\x13\xfe\x35\xfe\x19\xfe\x14\xfe\x12\xfe\x00\x00\x06\xfe\x06\xfe\x00\x00\xc3\xfe\x06\xfe\x39\xfe\x38\xfe\x06\xfe\x3d\xfe\x43\xfe\x1d\xfe\x1a\xfe\x00\x00\x00\x00\x17\xfe\x00\x00\x19\xfe\x18\xfe\x16\xfe\x30\xff\x00\x00\x00\x00\xb7\xff\x00\x00\xdc\xff\xda\xff\xd9\xff\xff\xfd\xd8\xff\xdd\xff\x00\x00\x05\xfe\xed\xff\xec\xff\xef\xff\xd4\xff\x00\x00\x00\x00\xdd\xff\xde\xff\xb9\xff\x3b\xfe\x3a\xfe\xb2\xff\x3f\xfe\x45\xfe\x00\x00\x30\xff\x13\xff\x00\x00\x00\x00\x06\xfe\x8c\xff\x00\x00\x00\x00\x00\x00\x7f\xff\xd2\xfe\xe2\xfe\xde\xfe\xdc\xfe\x00\x00\x06\xfe\x00\x00\x5c\xfe\x5a\xfe\x00\x00\x50\xfe\x00\x00\xba\xfe\x59\xfe\xbd\xfe\xbe\xfe\x84\xfe\x00\x00\x4b\xfe\x46\xfe\x00\x00\xae\xfe\xb3\xfe\x06\xfe\x52\xfe\x9f\xfe\x06\xfe\x06\xfe\x06\xfe\xb1\xfe\x06\xfe\x7d\xfe\x06\xfe\x06\xfe\xad\xfe\x06\xfe\xa2\xff\xa7\xfe\x06\xfe\xa6\xfe\xa5\xfe\x00\x00\x00\x00\x4c\xff\x00\x00\x4e\xff\x00\x00\x93\xfe\x79\xff\x7e\xff\x7d\xff\x00\x00\x05\xfe\xfe\xfe\x3c\xff\x01\xff\x00\x00\x97\xff\x98\xff\x00\x00\xa4\xff\xd0\xff\x00\x00\xce\xff\x00\x00\x00\x00\x00\x00\xa5\xff\x05\xfe\x58\xff\x00\x00\x4a\xff\x00\x00\xfc\xfd\xfb\xfd\x00\x00\x00\x00\x00\x00\x5e\xfe\xda\xfe\x06\xfe\x00\x00\x06\xfe\x05\xfe\x00\x00\x00\x00\x01\xff\x00\x00\x43\xff\x00\x00\x47\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\xff\x75\xff\x9f\xff\xc7\xfe\xc6\xfe\x00\x00\x67\xff\x9e\xff\x00\x00\x00\x00\x00\x00\x64\xff\x9d\xff\x83\xfe\x06\xfe\xc4\xfe\x83\xff\x00\x00\xe2\xff\xe2\xff\x00\x00\x06\xfe\xd7\xfe\x06\xfe\xa8\xfe\x00\x00\xd4\xfe\x06\xfe\xc0\xfe\xbf\xfe\x06\xfe\x94\xff\x00\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x8e\xfe\x92\xfe\x90\xfe\x00\x00\x06\xfe\x62\xff\x4f\xfe\x48\xfe\x68\xff\x00\x00\x76\xff\x06\xfe\x00\x00\x00\x00\x00\x00\x70\xff\x00\x00\x86\xff\x84\xff\x87\xff\x8a\xff\xae\xff\x5b\xff\x54\xff\x51\xff\x00\x00\x53\xff\x00\x00\x52\xff\xad\xff\x00\x00\x64\xfe\x00\x00\x60\xfe\x65\xfe\x00\x00\x5f\xfe\x5b\xff\x5c\xff\x00\x00\x5d\xff\x5e\xff\xe2\xff\xe2\xff\x48\xff\x5a\xff\x41\xff\x3f\xff\x00\x00\x00\x00\xcb\xff\x00\x00\xa3\xff\xa9\xff\x00\x00\x3a\xff\x38\xff\xa6\xff\x05\xfe\xcd\xfe\xe2\xff\xe2\xff\xa0\xff\x00\x00\x4e\xfe\x00\x00\x00\x00\x00\x00\x7c\xff\x7b\xff\x7a\xff\x4d\xff\x4b\xff\x00\x00\x73\xfe\x00\x00\x75\xfe\x06\xfe\x05\xfe\x99\xfe\x79\xfe\x7b\xfe\x9b\xfe\x77\xfe\x78\xfe\x9a\xfe\x96\xfe\x97\xfe\x00\x00\x9c\xfe\xb0\xfe\x40\xfe\x06\xfe\x00\x00\x06\xfe\xb9\xfe\x00\x00\xdf\xfe\x06\xfe\xdd\xfe\xe4\xfe\x05\xfe\x00\x00\x00\x00\x3c\xfe\x42\xfe\x2f\xff\x2d\xff\x29\xff\x00\xff\x06\xff\x00\x00\x03\xff\x04\xff\x05\xfe\xab\xff\x00\x00\x13\xff\x00\x00\x00\x00\x00\x00\x00\x00\xdb\xff\xdf\xff\x00\x00\xbc\xff\xbb\xff\xba\xff\xd6\xff\x00\x00\xd7\xff\xd5\xff\x00\x00\xb3\xff\x3e\xfe\x44\xfe\x05\xfe\xa8\xff\x12\xff\x07\xff\x00\x00\x13\xff\xe2\xff\xe2\xff\x00\x00\x00\x00\x00\x00\x40\xff\x06\xfe\x8b\xff\x80\xff\x00\x00\xe3\xfe\x00\x00\x5d\xfe\x5b\xfe\x00\x00\xb2\xfe\x06\xfe\x7c\xfe\x06\xfe\x72\xfe\x00\x00\xac\xfe\xa4\xfe\xa1\xff\x00\x00\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\xff\xfe\xe2\xff\xe2\xff\x3c\xff\x3d\xff\x3c\xff\x44\xff\xc9\xff\x00\x00\x49\xff\x00\x00\xee\xfe\x00\x00\x00\x00\xfd\xfd\x61\xfe\x06\xfe\x06\xfe\xac\xff\x42\xff\x00\x00\x00\x00\x89\xff\x6f\xff\x00\x00\x00\x00\x6c\xff\x6a\xff\x00\x00\x00\x00\x00\x00\x98\xfe\x00\x00\x00\x00\xcf\xfe\x81\xff\x8d\xff\x82\xff\x8e\xff\xe2\xff\x92\xff\xe2\xff\x56\xfe\x06\xfe\x00\x00\xc1\xfe\x06\xfe\xd9\xfe\xd0\xfe\x06\xfe\xb7\xfe\xe3\xff\x58\xfe\xe3\xff\x95\xff\xfb\xff\x8f\xfe\x00\x00\x06\xfe\x00\x00\x6b\xff\x6d\xff\x88\xff\x85\xff\x50\xff\x63\xfe\x00\x00\xf1\xfe\xf2\xfe\xe2\xff\xec\xfe\xe9\xfe\xea\xfe\xeb\xfe\x06\xfe\x00\x00\xcc\xff\xd1\xff\xca\xff\x00\x00\xc6\xff\x37\xff\x39\xff\xfa\xfe\x00\x00\x00\x00\x70\xfe\x71\xfe\xe2\xff\x6d\xfe\x06\xfe\x77\xff\x00\x00\x4d\xfe\x06\xfe\x76\xfe\x7a\xfe\x9d\xfe\x91\xfe\x94\xfe\x06\xfe\x2e\xff\x00\x00\x24\xff\x00\x00\x2b\xff\x28\xff\x23\xff\x00\x00\x00\x00\x24\xfe\x00\x00\x00\x00\x00\x00\x05\xff\x02\xff\x06\xfe\x00\x00\x00\x00\xaa\xff\x00\x00\x0e\xff\x0d\xff\x07\xff\x11\xff\x13\xff\xbd\xff\xa7\xff\x0c\xff\x0a\xff\x08\xff\x09\xff\x10\xff\x00\x00\x35\xff\x36\xff\xe2\xff\x32\xff\x00\x00\x00\x00\x1b\xff\x00\x00\x00\x00\x00\x00\x1f\xff\x20\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2a\xff\xdb\xfe\x06\xfe\x74\xfe\x78\xff\x66\xfe\x06\xfe\xe3\xff\x6f\xfe\xfc\xfe\xfd\xfe\xf7\xfe\xe2\xff\xf8\xfe\xf6\xfe\x06\xfe\xdc\xff\x00\x00\x00\x00\xe0\xfe\x9a\xff\x00\x00\x71\xff\xe3\xff\xef\xfe\x06\xfe\x00\x00\x72\xff\x00\x00\x93\xff\x06\xfe\x57\xfe\x00\x00\x06\xfe\xce\xfe\x55\xfe\x00\x00\x00\x00\x00\x00\x62\xfe\xed\xfe\x00\x00\x00\x00\x00\x00\x30\xff\x3e\xff\x00\x00\xdc\xff\xc3\xff\xc2\xff\x00\xfe\xc1\xff\x00\x00\x00\x00\xe3\xff\xfb\xfe\x6e\xfe\xe2\xfe\x6a\xfe\x68\xfe\x00\x00\x06\xfe\x00\x00\x00\x00\x22\xff\x45\xff\x24\xff\x2c\xff\x00\x00\x1e\xff\x1c\xff\x27\xff\x00\x00\x00\x00\x18\xff\x26\xff\x00\x00\x00\x00\x00\x00\xe3\xff\x34\xff\x0f\xff\x0b\xff\x33\xff\x00\x00\x1a\xff\x25\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\xfe\x06\xfe\x69\xfe\x6c\xfe\xf9\xfe\x59\xff\x01\xff\x01\xff\x00\x00\x00\x00\xdd\xff\xc7\xff\x13\xff\x00\x00\xe1\xfe\x00\x00\x00\x00\x69\xff\x00\x00\xc5\xfe\xe8\xfe\xe7\xfe\x05\xfe\xe6\xfe\xc4\xff\xc8\xff\x00\x00\xbf\xff\x00\x00\xf3\xfe\xf5\xfe\x00\x00\x00\x00\x95\xfe\x21\xff\x1d\xff\x16\xff\x17\xff\x00\x00\x00\x00\x19\xff\x31\xff\x00\x00\x15\xff\x06\xfe\xf4\xfe\xc0\xff\xbe\xff\x13\xff\xe5\xfe\x67\xfe\x00\x00\x14\xff"# - -happyCheck :: HappyAddr -happyCheck = HappyA# "\xff\xff\x00\x00\x06\x00\x02\x00\x01\x00\x01\x00\x01\x00\x08\x00\x02\x00\x06\x00\x1a\x00\x03\x00\x04\x00\x03\x00\x04\x00\x20\x00\x40\x00\x36\x00\x37\x00\x08\x00\x29\x00\x0e\x00\x4c\x00\x29\x00\x2d\x00\x97\x00\x1d\x00\x2d\x00\x05\x00\x05\x00\x1c\x00\x76\x00\x19\x00\x1a\x00\x11\x00\x12\x00\x52\x00\x28\x00\x66\x00\x2a\x00\x0a\x00\x0b\x00\x1a\x00\x51\x00\x52\x00\x1a\x00\x1d\x00\x0e\x00\x0f\x00\x10\x00\x21\x00\x22\x00\x23\x00\x12\x00\x1a\x00\x0c\x00\x10\x00\x28\x00\x5c\x00\x2a\x00\x4f\x00\x1d\x00\x4c\x00\x1b\x00\x1d\x00\x21\x00\x22\x00\x23\x00\x21\x00\x22\x00\x23\x00\xc5\x00\x28\x00\x9d\x00\x2a\x00\x28\x00\x1d\x00\x2a\x00\x16\x00\x1d\x00\x1d\x00\x09\x00\x29\x00\x0a\x00\x0b\x00\x23\x00\x2d\x00\x28\x00\x2d\x00\x2a\x00\x28\x00\x28\x00\x2a\x00\x2a\x00\x29\x00\x0a\x00\x0b\x00\x4c\x00\x2d\x00\x0a\x00\x0b\x00\x68\x00\x69\x00\x6a\x00\x1d\x00\xb0\x00\x22\x00\x4e\x00\x4f\x00\xc4\x00\x71\x00\x26\x00\xc4\x00\x00\x00\x27\x00\x28\x00\x1a\x00\x2a\x00\xbd\x00\x1b\x00\x1c\x00\x1b\x00\x1c\x00\x26\x00\x0a\x00\x0b\x00\x31\x00\x64\x00\x0a\x00\x0b\x00\x71\x00\x5c\x00\x2e\x00\xc5\x00\x62\x00\xb7\x00\xb8\x00\x79\x00\xba\x00\xbb\x00\x79\x00\x0e\x00\x1d\x00\xc5\x00\x58\x00\x71\x00\xb7\x00\xb8\x00\x71\x00\x79\x00\xc4\x00\xa7\x00\x69\x00\x6a\x00\xca\x00\xab\x00\xad\x00\x1f\x00\xc4\x00\xb0\x00\x71\x00\xb2\x00\x24\x00\x71\x00\x71\x00\x3f\x00\x40\x00\xb7\x00\xb8\x00\xa7\x00\x47\x00\xbb\x00\xbd\x00\xab\x00\xa7\x00\xc0\x00\xc5\x00\xc4\x00\xab\x00\xc5\x00\x31\x00\x5b\x00\x98\x00\xc5\x00\xc8\x00\xb7\x00\xb8\x00\x64\x00\x71\x00\xbb\x00\xb7\x00\xb8\x00\xc4\x00\xc4\x00\xbb\x00\x20\x00\xc5\x00\x6c\x00\xc5\x00\xc4\x00\xc4\x00\xc4\x00\xa9\x00\xc5\x00\xc4\x00\xac\x00\xc4\x00\xc8\x00\xc5\x00\xa9\x00\xbb\x00\xbb\x00\xac\x00\xc4\x00\x33\x00\xb6\x00\xb7\x00\xb8\x00\xc5\x00\xba\x00\xbb\x00\x67\x00\xb6\x00\xb7\x00\xb8\x00\xc4\x00\xba\x00\xbb\x00\xc4\x00\x36\x00\x37\x00\xc4\x00\x1f\x00\x8a\x00\xc9\x00\x8c\x00\xa3\x00\x20\x00\xc5\x00\xa4\x00\xa5\x00\xc9\x00\x9f\x00\xc4\x00\x27\x00\xa8\x00\xc4\x00\xc4\x00\xa3\x00\x7b\x00\xc5\x00\x7d\x00\x7e\x00\x7f\x00\x1f\x00\xa9\x00\x82\x00\x83\x00\x84\x00\xa7\x00\xb7\x00\xa7\x00\x61\x00\xab\x00\x8a\x00\xab\x00\x98\x00\x1b\x00\xb6\x00\xb7\x00\xb8\x00\xc4\x00\x92\x00\x0a\x00\x0b\x00\xb7\x00\xb8\x00\xb7\x00\xb8\x00\xbb\x00\xc5\x00\xbb\x00\xb7\x00\xb8\x00\x5e\x00\xb7\x00\xb8\x00\x61\x00\xba\x00\xbb\x00\x24\x00\xc4\x00\xa6\x00\x0a\x00\x0b\x00\xa9\x00\xaa\x00\x2b\x00\xac\x00\xa8\x00\x9a\x00\xca\x00\x9f\x00\x3f\x00\xca\x00\x0a\x00\x0b\x00\x20\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xb7\x00\x3e\x00\x3f\x00\x40\x00\x74\x00\x75\x00\x76\x00\xc3\x00\xc4\x00\x50\x00\x7b\x00\x20\x00\x7d\x00\x7e\x00\x7f\x00\x26\x00\x27\x00\x82\x00\x83\x00\x84\x00\x0a\x00\x0b\x00\x24\x00\xa5\x00\x62\x00\x8a\x00\xc5\x00\x58\x00\xc4\x00\x64\x00\x33\x00\x46\x00\x7b\x00\x92\x00\x7d\x00\x7e\x00\x7f\x00\xba\x00\xbb\x00\x82\x00\x83\x00\x84\x00\x2e\x00\x60\x00\xb7\x00\xb8\x00\x50\x00\x8a\x00\x9b\x00\x9c\x00\x9d\x00\x72\x00\x67\x00\xa6\x00\xc4\x00\x92\x00\xa9\x00\xaa\x00\x4d\x00\xac\x00\x5d\x00\x5e\x00\xba\x00\xbb\x00\x61\x00\x34\x00\x64\x00\x99\x00\x9a\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xa6\x00\x25\x00\x6c\x00\xa9\x00\xaa\x00\x67\x00\xac\x00\xc3\x00\xc4\x00\xc4\x00\x59\x00\x5a\x00\x4d\x00\x48\x00\xc4\x00\x2c\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbb\x00\x34\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xc3\x00\xc4\x00\x5a\x00\x44\x00\x45\x00\x7b\x00\xc4\x00\x7d\x00\x7e\x00\x7f\x00\x5f\x00\x60\x00\x82\x00\x83\x00\x84\x00\x2b\x00\x2c\x00\x5c\x00\xb7\x00\xb8\x00\x8a\x00\xba\x00\xbb\x00\x2b\x00\x2c\x00\xb6\x00\xb7\x00\xb8\x00\x92\x00\xba\x00\xbb\x00\x08\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xca\x00\x42\x00\x43\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x17\x00\x42\x00\x43\x00\xa6\x00\xba\x00\xbb\x00\xa9\x00\xaa\x00\x01\x00\xac\x00\x05\x00\x06\x00\x05\x00\x23\x00\x07\x00\x26\x00\xa9\x00\x2b\x00\x2c\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\x2f\x00\x30\x00\x31\x00\x17\x00\xb6\x00\xb7\x00\xb8\x00\xc3\x00\xc4\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xc6\x00\x42\x00\x43\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x50\x00\x42\x00\x43\x00\x44\x00\x45\x00\xb6\x00\xb7\x00\xb8\x00\x48\x00\xba\x00\xbb\x00\x4b\x00\x16\x00\xaa\x00\x20\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x64\x00\x42\x00\x43\x00\x44\x00\x45\x00\x2b\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\xa7\x00\x19\x00\x2e\x00\x30\x00\x31\x00\x50\x00\x51\x00\x09\x00\x20\x00\x0b\x00\xca\x00\xaa\x00\x16\x00\x17\x00\x18\x00\xaa\x00\xb7\x00\xb8\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xaa\x00\x42\x00\x43\x00\xb9\x00\x66\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\x85\x00\x17\x00\x25\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xa8\x00\x17\x00\x20\x00\x20\x00\x8b\x00\x5a\x00\xca\x00\x1c\x00\x5b\x00\x26\x00\x20\x00\x20\x00\x85\x00\x2b\x00\xca\x00\xb7\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xaa\x00\x42\x00\x43\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xaa\x00\x42\x00\x43\x00\xb7\x00\xb8\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xb7\x00\xb8\x00\xc4\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xb5\x00\xbd\x00\xaa\x00\x27\x00\xca\x00\x29\x00\xca\x00\xbc\x00\xbd\x00\xb7\x00\xb8\x00\xca\x00\xba\x00\xbb\x00\xca\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xc6\x00\x42\x00\x43\x00\xca\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xca\x00\x42\x00\x43\x00\xa9\x00\x01\x00\xc6\x00\xaa\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xac\x00\x42\x00\x43\x00\x17\x00\xb6\x00\xb7\x00\xb8\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\x20\x00\x16\x00\xba\x00\xbb\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x20\x00\x42\x00\x43\x00\x8d\x00\x8e\x00\xca\x00\x26\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xaa\x00\x42\x00\x43\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xaa\x00\x42\x00\x43\x00\x05\x00\x06\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\x17\x00\x0a\x00\x0b\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xc7\x00\x20\x00\x16\x00\x20\x00\x48\x00\x48\x00\xca\x00\x24\x00\x4c\x00\x4d\x00\x4e\x00\x29\x00\x29\x00\x2b\x00\xca\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x58\x00\x42\x00\x43\x00\x0a\x00\x0b\x00\xaa\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xc6\x00\x42\x00\x43\x00\xaa\x00\x17\x00\x68\x00\xc0\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\x17\x00\x20\x00\x17\x00\xaa\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\x20\x00\x5c\x00\x20\x00\x17\x00\x25\x00\xca\x00\x27\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\x20\x00\x46\x00\xca\x00\xaa\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x1c\x00\x42\x00\x43\x00\x5c\x00\x20\x00\xca\x00\xaa\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\x0a\x00\x0b\x00\xaa\x00\x3f\x00\x40\x00\x62\x00\x63\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\x0a\x00\x0b\x00\xca\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xc0\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xca\x00\x42\x00\x43\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xca\x00\x42\x00\x43\x00\x3e\x00\x3f\x00\x40\x00\xaa\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xa9\x00\x42\x00\x43\x00\xbd\x00\x53\x00\xaa\x00\xc0\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xc4\x00\xb6\x00\xb7\x00\xb8\x00\x05\x00\x06\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbe\x00\x15\x00\xc0\x00\xca\x00\xc2\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x16\x00\x42\x00\x43\x00\x33\x00\xca\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xc6\x00\x42\x00\x43\x00\xc6\x00\xaa\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xc4\x00\x42\x00\x43\x00\x05\x00\x06\x00\x0a\x00\x0b\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\x09\x00\x0a\x00\x0b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x16\x00\x42\x00\x43\x00\x35\x00\xb7\x00\xb8\x00\xca\x00\xba\x00\xbb\x00\xb6\x00\xb7\x00\xb8\x00\xaa\x00\xba\x00\xbb\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xaa\x00\x42\x00\x43\x00\xca\x00\x64\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\x0a\x00\x0b\x00\xaa\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xc6\x00\xb7\x00\xb8\x00\xc4\x00\xba\x00\xbb\x00\xca\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xb7\x00\xb8\x00\xca\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xca\x00\x42\x00\x43\x00\x09\x00\x0a\x00\x0b\x00\xca\x00\xaa\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\xc5\x00\xb6\x00\xb7\x00\xb8\x00\xaa\x00\xba\x00\xbb\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xb7\x00\xb8\x00\xaa\x00\xc7\x00\xbb\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\x48\x00\x30\x00\x4a\x00\x4b\x00\xca\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\x64\x00\x25\x00\xaa\x00\x27\x00\xca\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xa9\x00\x42\x00\x43\x00\x65\x00\xca\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\x62\x00\x63\x00\xaa\x00\xb6\x00\xb7\x00\xb8\x00\x62\x00\x63\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xa9\x00\xca\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x8f\x00\xb6\x00\xb7\x00\xb8\x00\x45\x00\xc4\x00\x49\x00\x4a\x00\x4b\x00\xca\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xaa\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xc6\x00\xb5\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\x5c\x00\xbc\x00\xbd\x00\xbe\x00\x25\x00\xc0\x00\x27\x00\xc2\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x72\x00\xca\x00\xc7\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x3c\x00\x0e\x00\x3e\x00\x3f\x00\x40\x00\x8d\x00\x8e\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x62\x00\x63\x00\x62\x00\x63\x00\xaa\x00\x3c\x00\x85\x00\x3e\x00\x3f\x00\x40\x00\x32\x00\x33\x00\x3c\x00\x2f\x00\x3e\x00\x3f\x00\x40\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\x3c\x00\x2f\x00\x3e\x00\x3f\x00\x40\x00\xaa\x00\x49\x00\x3c\x00\x14\x00\x3e\x00\x3f\x00\x40\x00\x8d\x00\x8e\x00\xca\x00\x0c\x00\x0d\x00\xaa\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\x6b\x00\x3c\x00\x46\x00\x3e\x00\x3f\x00\x40\x00\x34\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\x0a\x00\x0b\x00\xca\x00\xaa\x00\x3f\x00\x40\x00\x41\x00\x8b\x00\xaa\x00\x3c\x00\xc4\x00\x3e\x00\x3f\x00\x40\x00\xca\x00\x34\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\x0a\x00\x0b\x00\xaa\x00\x3c\x00\x34\x00\x3e\x00\x3f\x00\x40\x00\x13\x00\xca\x00\xaa\x00\x8d\x00\x8e\x00\xc5\x00\xca\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\x03\x00\x04\x00\xaa\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xb7\x00\xb8\x00\x1e\x00\xba\x00\xbb\x00\x8e\x00\xca\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\x05\x00\x06\x00\xca\x00\x3f\x00\x40\x00\xb7\x00\xb8\x00\xca\x00\xba\x00\xbb\x00\x3f\x00\x40\x00\xb7\x00\xb8\x00\xca\x00\xba\x00\xbb\x00\x3c\x00\xc6\x00\x3e\x00\x3f\x00\x40\x00\xb7\x00\xb8\x00\xca\x00\xba\x00\xbb\x00\x57\x00\x8f\x00\xb7\x00\xb8\x00\xca\x00\xba\x00\xbb\x00\x03\x00\x04\x00\x3e\x00\x3f\x00\x40\x00\x07\x00\xa9\x00\xca\x00\x3e\x00\x3f\x00\x40\x00\xc4\x00\xb7\x00\xb8\x00\xca\x00\xba\x00\xbb\x00\x53\x00\xb1\x00\xb6\x00\xb7\x00\xb8\x00\xb5\x00\xc7\x00\xb7\x00\xb8\x00\xc6\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xca\x00\xb7\x00\xb8\x00\x30\x00\xba\x00\xbb\x00\x3e\x00\x3f\x00\x40\x00\x05\x00\x06\x00\x43\x00\xca\x00\xcb\x00\xcc\x00\x3e\x00\x3f\x00\x40\x00\x42\x00\x43\x00\xca\x00\xb7\x00\xb8\x00\x79\x00\xba\x00\xbb\x00\x4c\x00\x4d\x00\x54\x00\x55\x00\x56\x00\x17\x00\x58\x00\x3f\x00\x40\x00\x3a\x00\x3b\x00\x54\x00\x55\x00\x56\x00\xca\x00\x58\x00\x3f\x00\x40\x00\x05\x00\x06\x00\x1b\x00\x3f\x00\x40\x00\x3e\x00\x79\x00\x40\x00\x41\x00\x3f\x00\x40\x00\x79\x00\x45\x00\x67\x00\xb7\x00\xb8\x00\x17\x00\xba\x00\xbb\x00\x42\x00\x43\x00\xb7\x00\xb8\x00\x26\x00\xba\x00\xbb\x00\x3f\x00\x40\x00\x53\x00\x08\x00\x09\x00\xb7\x00\xb8\x00\xca\x00\xba\x00\xbb\x00\x3f\x00\x40\x00\x27\x00\x3e\x00\xca\x00\x40\x00\x41\x00\x3f\x00\x40\x00\x42\x00\x45\x00\x26\x00\xb7\x00\xb8\x00\xca\x00\xba\x00\xbb\x00\x1a\x00\xb7\x00\xb8\x00\x23\x00\xba\x00\xbb\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x71\x00\x72\x00\x30\x00\x29\x00\xca\x00\x2f\x00\x30\x00\x31\x00\xab\x00\x30\x00\xca\x00\x38\x00\x39\x00\x3a\x00\x3b\x00\x05\x00\x06\x00\xab\x00\x29\x00\x1a\x00\xb7\x00\xb8\x00\x67\x00\xba\x00\xbb\x00\x16\x00\x39\x00\x3a\x00\x3b\x00\xb7\x00\xb8\x00\x20\x00\xba\x00\xbb\x00\xbe\x00\x17\x00\xc0\x00\xa7\x00\xc2\x00\xca\x00\x27\x00\xab\x00\x17\x00\x0c\x00\x27\x00\x25\x00\xb7\x00\xb8\x00\xca\x00\xba\x00\xbb\x00\x08\x00\x09\x00\xb7\x00\xb8\x00\xb7\x00\xb8\x00\xbb\x00\xba\x00\xbb\x00\xb7\x00\xb8\x00\x1a\x00\xba\x00\xbb\x00\xca\x00\xb7\x00\xb8\x00\x1e\x00\xba\x00\xbb\x00\x73\x00\x17\x00\x1a\x00\xca\x00\x2b\x00\x05\x00\x22\x00\x23\x00\xca\x00\x79\x00\x79\x00\x30\x00\xb7\x00\xb8\x00\xca\x00\xba\x00\xbb\x00\x1c\x00\x53\x00\x2f\x00\x30\x00\x31\x00\xb7\x00\xb8\x00\x1a\x00\xba\x00\xbb\x00\x2e\x00\x79\x00\xb7\x00\xb8\x00\xca\x00\xba\x00\xbb\x00\x1b\x00\x1b\x00\xa7\x00\x1c\x00\x16\x00\x1a\x00\xab\x00\xca\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x0c\x00\xca\x00\x01\x00\x02\x00\xa7\x00\xb7\x00\xb8\x00\x1a\x00\xab\x00\xbb\x00\x27\x00\x26\x00\xae\x00\x55\x00\x42\x00\xb1\x00\x27\x00\xb3\x00\xa7\x00\xb5\x00\xb7\x00\xb8\x00\xab\x00\x16\x00\xbb\x00\x2f\x00\xbc\x00\xbd\x00\xbe\x00\x1c\x00\xc0\x00\x23\x00\xc2\x00\x79\x00\xb7\x00\xb8\x00\x17\x00\x24\x00\xbb\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x1c\x00\x26\x00\x20\x00\x1c\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x1a\x00\x26\x00\x17\x00\x1a\x00\x2a\x00\x5b\x00\x17\x00\x1e\x00\x53\x00\x1b\x00\x21\x00\x17\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x22\x00\xad\x00\x22\x00\x2d\x00\xb0\x00\x2f\x00\xb2\x00\x67\x00\x32\x00\x58\x00\x53\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xbd\x00\x3c\x00\x3d\x00\xc0\x00\x3f\x00\x1b\x00\x41\x00\x2b\x00\x68\x00\x57\x00\x29\x00\x1b\x00\x47\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\x54\x00\x01\x00\x17\x00\x29\x00\x58\x00\x05\x00\x5a\x00\x20\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xa2\x00\x61\x00\x1b\x00\x63\x00\x3b\x00\xa7\x00\x66\x00\xa9\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x26\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x1b\x00\xb6\x00\xb7\x00\xb8\x00\x20\x00\x78\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x4e\x00\x22\x00\x20\x00\x2a\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x1f\x00\x0c\x00\x1e\x00\x79\x00\x1c\x00\x21\x00\x1c\x00\x65\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x5b\x00\x17\x00\x2d\x00\x17\x00\x2f\x00\x25\x00\x0f\x00\x32\x00\x26\x00\x58\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x57\x00\x3c\x00\x3d\x00\x0c\x00\x3f\x00\x1f\x00\x41\x00\x79\x00\x79\x00\x68\x00\x17\x00\x20\x00\x47\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\x54\x00\x01\x00\x1f\x00\x26\x00\x58\x00\x08\x00\x5a\x00\x0a\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x27\x00\x61\x00\x1b\x00\x63\x00\x1c\x00\x2a\x00\x66\x00\x1a\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x20\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x1b\x00\x23\x00\x20\x00\x17\x00\x67\x00\x78\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x2f\x00\x30\x00\x31\x00\x26\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x1b\x00\x17\x00\x17\x00\x17\x00\x22\x00\x27\x00\x27\x00\x1e\x00\x67\x00\x29\x00\x21\x00\x67\x00\x29\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x22\x00\x22\x00\x2d\x00\x53\x00\x2f\x00\x20\x00\x17\x00\x32\x00\x1b\x00\x58\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x16\x00\x3c\x00\x3d\x00\x20\x00\x3f\x00\x17\x00\x41\x00\x27\x00\x17\x00\x68\x00\x17\x00\x17\x00\x47\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\x54\x00\x01\x00\x02\x00\x17\x00\x58\x00\x05\x00\x06\x00\x17\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x17\x00\x61\x00\x17\x00\x63\x00\x17\x00\x20\x00\x66\x00\x1f\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x29\x00\x17\x00\x3b\x00\x3b\x00\x3b\x00\x78\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x1f\x00\x44\x00\x29\x00\x64\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x79\x00\x68\x00\x26\x00\x2e\x00\x27\x00\x67\x00\x26\x00\x1e\x00\x1e\x00\x0c\x00\x21\x00\x79\x00\x79\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x20\x00\x0f\x00\x2d\x00\x1b\x00\x2f\x00\x17\x00\x79\x00\x32\x00\x27\x00\x58\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x1a\x00\x3c\x00\x3d\x00\x0f\x00\x79\x00\x0f\x00\x41\x00\x0f\x00\x0f\x00\x68\x00\x1e\x00\x1b\x00\x47\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\x54\x00\x1b\x00\x6c\x00\x5f\x00\x58\x00\x16\x00\x5a\x00\x56\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x1b\x00\x61\x00\x3f\x00\x63\x00\x0c\x00\x67\x00\x66\x00\x79\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x0f\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x79\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x78\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x0f\x00\x16\x00\x05\x00\x25\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x23\x00\xae\x00\x25\x00\x20\x00\xb1\x00\x79\x00\xb3\x00\x1e\x00\xb5\x00\x1c\x00\x21\x00\x44\x00\x2f\x00\x30\x00\x31\x00\xbc\x00\xbd\x00\xbe\x00\x79\x00\xc0\x00\x05\x00\xc2\x00\x2d\x00\x79\x00\x2f\x00\x3f\x00\x79\x00\x32\x00\x79\x00\x1a\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x7a\x00\x3c\x00\x3d\x00\x41\x00\xff\xff\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x47\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\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\x5f\x00\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\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\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\x25\x00\xff\xff\xff\xff\x28\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x2d\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\x22\x00\x23\x00\xff\xff\x25\x00\x26\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x2f\x00\x30\x00\x31\x00\xff\xff\x54\x00\xa1\x00\xa2\x00\xff\xff\x58\x00\x59\x00\xff\xff\xa7\x00\xff\xff\xa9\x00\xff\xff\xff\xff\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xb6\x00\xb7\x00\xb8\x00\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xae\x00\xff\xff\x1a\x00\xb1\x00\xff\xff\xb3\x00\x1e\x00\xb5\x00\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xbc\x00\xbd\x00\xbe\x00\xff\xff\xc0\x00\xff\xff\xc2\x00\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\x51\x00\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xa9\x00\xff\xff\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xff\xff\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\x51\x00\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\x51\x00\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\x09\x00\x0a\x00\x0b\x00\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\xff\xff\x22\x00\x23\x00\xff\xff\x25\x00\x26\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x2f\x00\x30\x00\x31\x00\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x08\x00\x09\x00\x0a\x00\x0b\x00\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\xff\xff\x22\x00\x23\x00\xff\xff\x25\x00\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x2f\x00\x30\x00\x31\x00\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x5e\x00\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\x69\x00\x6a\x00\x6b\x00\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\x51\x00\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\x51\x00\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\x51\x00\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\xff\xff\x66\x00\xff\xff\x68\x00\x69\x00\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\x3f\x00\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\x1a\x00\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\x1f\x00\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x54\x00\xff\xff\xff\xff\xff\xff\x58\x00\x59\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x60\x00\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\x70\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x78\x00\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x01\x00\xff\xff\xff\xff\x41\x00\x05\x00\x06\x00\xff\xff\xff\xff\x09\x00\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\xff\xff\xff\xff\xff\xff\x16\x00\x54\x00\x18\x00\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\xff\xff\x22\x00\x01\x00\x61\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\x68\x00\xff\xff\x2d\x00\x2e\x00\xff\xff\x30\x00\x6e\x00\x6f\x00\x70\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\x78\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\xff\xff\xff\xff\x30\x00\xff\xff\x0f\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\x09\x00\x68\x00\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\xff\xff\x73\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\x57\x00\x58\x00\xff\xff\x1e\x00\xff\xff\xff\xff\xff\xff\x22\x00\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\x48\x00\x30\x00\xff\xff\xff\xff\x4c\x00\x4d\x00\x4e\x00\xff\xff\x73\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x68\x00\xff\xff\xff\xff\x30\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\xff\xff\x73\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\x30\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x73\x00\x16\x00\xff\xff\x18\x00\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\x16\x00\x17\x00\x30\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\x01\x00\x02\x00\x68\x00\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\xff\xff\x73\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x58\x00\x16\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\x30\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x73\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\x68\x00\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\x73\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\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1b\x00\xff\xff\xff\xff\x1e\x00\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\x25\x00\x26\x00\x27\x00\xff\xff\x29\x00\xff\xff\x01\x00\x02\x00\x2d\x00\xff\xff\x2f\x00\x30\x00\x31\x00\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\x3f\x00\x16\x00\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\x58\x00\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x32\x00\xff\xff\x58\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x5f\x00\x3c\x00\x3d\x00\xff\xff\xff\xff\xff\xff\x41\x00\x42\x00\x43\x00\x68\x00\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\x50\x00\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\x66\x00\xff\xff\x68\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x2b\x00\xff\xff\x2d\x00\x05\x00\x06\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\x16\x00\xff\xff\x41\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\x58\x00\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\x01\x00\x02\x00\x2d\x00\xff\xff\x05\x00\x06\x00\xff\xff\x32\x00\x58\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\xff\xff\x3f\x00\x16\x00\x41\x00\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\xff\xff\xff\xff\x58\x00\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\x21\x00\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x32\x00\xff\xff\x58\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\xff\xff\x3c\x00\x3d\x00\x62\x00\xff\xff\xff\xff\x41\x00\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\x08\x00\x09\x00\x58\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x16\x00\xff\xff\x18\x00\x05\x00\x68\x00\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\x25\x00\xff\xff\xff\xff\x01\x00\xff\xff\x16\x00\x2b\x00\xff\xff\x2d\x00\x2e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x16\x00\x17\x00\x18\x00\x2b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\x58\x00\x20\x00\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\x2b\x00\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\x68\x00\x08\x00\x09\x00\x58\x00\x0b\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\x68\x00\x57\x00\x58\x00\xff\xff\x1e\x00\xff\xff\xff\xff\xff\xff\x22\x00\xff\xff\xff\xff\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2b\x00\x68\x00\x2d\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\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\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x16\x00\x17\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\x58\x00\x20\x00\xff\xff\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\x2b\x00\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x16\x00\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\x68\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x5f\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\x01\x00\x16\x00\xff\xff\x18\x00\x05\x00\x06\x00\xff\xff\xff\xff\x58\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x16\x00\x01\x00\x18\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\x1e\x00\x58\x00\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\x68\x00\xff\xff\xff\xff\xff\xff\x58\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x57\x00\x58\x00\x1e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x01\x00\xff\xff\xff\xff\x68\x00\x05\x00\x06\x00\xff\xff\x01\x00\x02\x00\x58\x00\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\x68\x00\xff\xff\xff\xff\x16\x00\x1e\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\x2e\x00\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x01\x00\xff\xff\x58\x00\xff\xff\x05\x00\x06\x00\xff\xff\x01\x00\xff\xff\x58\x00\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\x62\x00\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\x68\x00\xff\xff\xff\xff\x16\x00\x1e\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x16\x00\x17\x00\x58\x00\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\x16\x00\x68\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x01\x00\x16\x00\x58\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\x68\x00\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\x01\x00\x68\x00\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\x68\x00\xff\xff\x01\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x23\x00\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\x16\x00\x68\x00\x58\x00\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x23\x00\xff\xff\xff\xff\x01\x00\x16\x00\x68\x00\xff\xff\x05\x00\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x16\x00\x68\x00\x01\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x01\x00\xff\xff\xff\xff\x16\x00\xff\xff\x68\x00\xff\xff\x01\x00\xff\xff\x58\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x68\x00\x58\x00\xff\xff\x16\x00\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x48\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x4d\x00\x4e\x00\x68\x00\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x58\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\x08\x00\x09\x00\x0a\x00\x0b\x00\xff\xff\x68\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x8a\x00\x22\x00\x23\x00\xff\xff\x25\x00\x26\x00\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\x95\x00\x96\x00\xff\xff\x2f\x00\x30\x00\x31\x00\xff\xff\xff\xff\xff\xff\x9e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\x95\x00\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\x95\x00\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\x95\x00\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\x20\x00\xff\xff\x22\x00\x23\x00\x8a\x00\x25\x00\x26\x00\x27\x00\xff\xff\x29\x00\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\x2f\x00\x30\x00\x31\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9e\x00\xff\xff\xa0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9e\x00\xff\xff\xa0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\x96\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9e\x00\xff\xff\xa0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9e\x00\xff\xff\xa0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9e\x00\xff\xff\xa0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9e\x00\xff\xff\xa0\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\x8a\x00\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\xff\xff\xff\xff\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\x8a\x00\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\xff\xff\xff\xff\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\x8a\x00\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\xff\xff\xff\xff\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\x8a\x00\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\xff\xff\xff\xff\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\x8a\x00\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\xff\xff\xff\xff\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x77\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\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\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\x87\x00\xff\xff\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\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\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xaf\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\xbd\x00\xbe\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\x87\x00\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\x93\x00\x94\x00\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xa6\x00\x86\x00\x87\x00\xa9\x00\xaa\x00\x8a\x00\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\xff\xff\xff\xff\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\x87\x00\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\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\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\x88\x00\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xa6\x00\xff\xff\x87\x00\xa9\x00\xaa\x00\x8a\x00\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\xff\xff\xff\xff\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\x87\x00\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\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\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\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\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\x88\x00\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\x8a\x00\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\xff\xff\xff\xff\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\x8a\x00\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\xff\xff\xff\xff\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\x8a\x00\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\xff\xff\xff\xff\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\x8a\x00\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\xff\xff\xff\xff\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\x8a\x00\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\xff\xff\xff\xff\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\x8a\x00\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\xff\xff\xff\xff\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x78\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\x8a\x00\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\xff\xff\xff\xff\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc3\x00\xc4\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\x8a\x00\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\xff\xff\xff\xff\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\x7c\x00\x7d\x00\x7e\x00\x7f\x00\xc3\x00\xc4\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\x7d\x00\x7e\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa6\x00\xff\xff\x92\x00\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\x7f\x00\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xc3\x00\xc4\x00\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa6\x00\xff\xff\x92\x00\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\x81\x00\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\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\x82\x00\x83\x00\x84\x00\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\x8a\x00\xac\x00\xff\xff\x8d\x00\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\xff\xff\xff\xff\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\x8e\x00\xff\xff\x90\x00\x91\x00\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa6\x00\xff\xff\x92\x00\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa6\x00\xff\xff\x92\x00\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa6\x00\xff\xff\x92\x00\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xc3\x00\xc4\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\x82\x00\x83\x00\x84\x00\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\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\xa6\x00\xff\xff\xff\xff\xa9\x00\xaa\x00\xff\xff\xac\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x00\xc4\x00\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\x18\x00\x05\x00\x06\x00\xac\x00\x06\x00\x54\x01\x02\x00\x07\x00\xad\x03\x26\x00\x0b\x00\x0a\x00\x0b\x00\x5a\x01\x00\x01\xdd\x02\xbb\x02\x1a\x00\xe0\x01\x67\x03\xc5\x03\xe0\x01\x8d\x02\x30\x02\x3e\x00\x96\x02\xad\x00\x28\x00\x1f\x03\x58\x02\x68\x03\x69\x03\x3c\x00\x3d\x00\x06\x03\x44\x03\xa1\x02\x43\x00\x22\x00\x9e\x02\xd2\x01\x5f\x02\x60\x02\xd7\x01\x3e\x00\x49\x01\x4a\x01\x4b\x01\x3f\x00\x40\x00\x41\x00\xc4\x00\xd7\x01\xce\x01\x6f\x02\x42\x00\xc6\x03\x43\x00\x8c\x03\x3e\x00\x1e\x03\x1d\x00\x3e\x00\x94\x01\x40\x00\x41\x00\xc5\x00\x40\x00\x41\x00\x31\x02\x42\x00\x97\x03\x43\x00\x42\x00\x3e\x00\x43\x00\xc5\xff\x3e\x00\x3e\x00\x27\x01\xe0\x01\x22\x00\xef\x01\xc6\x00\x15\x02\x44\x03\xcf\x01\x43\x00\x42\x00\x56\x03\x43\x00\x43\x00\xe0\x01\x22\x00\xef\x01\x82\x02\xe1\x01\x22\x00\xac\x02\x45\x03\x46\x03\x47\x03\x3e\x00\x2f\x03\x31\x03\x29\x03\x2a\x03\x6f\x01\x44\x00\xf0\x01\x75\x03\x17\x00\xc8\x02\xc9\x02\xb3\x02\x43\x00\x5e\x01\xaf\x03\x72\x02\x71\x02\x72\x02\xf2\x01\x22\x00\x9e\x02\x9a\x02\xb2\x03\x22\x00\xf4\x02\x44\x00\xac\x03\x69\x01\xa2\x02\x1e\x00\x60\x00\xe3\x00\xd3\x01\xe4\x00\x64\x00\xd8\x01\x9e\x03\x18\x00\x83\x02\xf2\x02\x44\x00\x60\x00\xbc\x02\x44\x00\xdd\x01\x61\x02\x6a\x03\x99\x03\x47\x03\x01\x01\x6b\x03\x5b\x01\x50\x00\x61\x02\x5c\x01\x44\x00\x5d\x01\x51\x00\x44\x00\x44\x00\xc9\x03\xe2\x00\x60\x00\xcf\x00\x73\x02\x23\x02\xd0\x00\x5e\x01\x74\x02\x6a\x03\x5f\x01\xe2\x01\x2b\x03\x6b\x03\xe2\x01\x33\x02\xf5\x01\x9f\x02\x83\x02\x6c\x03\x60\x00\xcf\x00\xb3\x03\x44\x00\xd0\x00\x60\x00\xcf\x00\x19\x00\x48\x03\xd0\x00\x96\x02\x1b\x00\xad\x02\x03\x00\x08\x00\x0d\x00\x0d\x00\x4c\x01\x03\x00\x0c\x00\x4d\x01\x0c\x00\x6c\x03\x1b\x00\x4c\x01\x29\x00\x29\x00\x4d\x01\x45\x00\x99\x02\x5f\x00\x60\x00\x61\x00\x83\x02\x63\x00\x64\x00\xf5\x02\x5f\x00\x60\x00\x61\x00\x2b\x03\x63\x00\x64\x00\xc7\x00\xba\x02\xbb\x02\x45\x00\x50\x00\xf5\x01\x4e\x01\xf6\x01\xf1\x01\x96\x02\xe2\x01\xca\x02\xcb\x02\x4e\x01\xeb\x00\x48\x03\x06\x03\x34\x02\xc7\x00\x57\x03\xf3\x01\x52\x00\xe2\x01\x53\x00\x54\x00\x55\x00\x50\x00\x6a\x01\x56\x00\x57\x00\x58\x00\x73\x02\x35\x02\x73\x02\x7f\x02\x74\x02\x59\x00\x74\x02\xa0\x02\x1d\x00\x5f\x00\x60\x00\x61\x00\xcc\x02\x5a\x00\x22\x00\xf4\x02\x60\x00\xcf\x00\x60\x00\xcf\x00\xd0\x00\xec\x00\xd0\x00\x60\x00\xe3\x00\x8a\x03\x60\x00\xe3\x00\x1b\x03\xe4\x00\x64\x00\x95\x02\x66\x00\x5b\x00\x22\x00\xac\x02\x5c\x00\x5d\x00\x87\x01\x5e\x00\x34\x02\x71\x03\x24\x02\xf7\x00\x0f\x00\xe5\x00\x22\x00\x15\x03\x8d\x01\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x35\x02\x7f\x03\xe1\x00\xe2\x00\x6c\x01\x6d\x01\x6e\x01\x65\x00\x66\x00\xa1\x03\x52\x00\x8d\x01\x53\x00\x54\x00\x55\x00\x65\x01\x66\x01\x56\x00\x57\x00\x58\x00\x22\x00\x15\x03\x4b\x03\x58\x03\x1e\x00\x59\x00\xec\x00\x80\x03\xfb\x02\xa2\x03\x8e\x01\xda\x02\x52\x00\x5a\x00\x53\x00\x54\x00\x55\x00\x80\x02\x64\x00\x56\x00\x57\x00\x58\x00\x81\x03\x8b\x03\x60\x00\xbc\x02\x6a\x02\x59\x00\x72\x03\x73\x03\x74\x03\x98\x03\xf6\x02\x5b\x00\x59\x03\x5a\x00\x5c\x00\x5d\x00\x16\x03\x5e\x00\x19\x03\x1a\x03\x1c\x03\x64\x00\x1b\x03\x62\x03\x6b\x02\xf9\x02\xfa\x02\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x5b\x00\xa3\x01\xae\x02\x5c\x00\xd3\x02\x01\xff\x5e\x00\x65\x00\x66\x00\x6f\x01\x82\x03\x83\x03\x17\x03\xfe\x00\x75\x03\x33\x01\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x6d\x02\x34\x01\xee\x00\xa4\x01\xe0\x00\xe1\x00\xe2\x00\x65\x00\x66\x00\xff\x00\xa5\x01\xa6\x01\x4c\x03\xfb\x02\x53\x00\x54\x00\x55\x00\x21\x03\x22\x03\x56\x00\x57\x00\x58\x00\xe0\x02\x06\x02\x20\x03\x60\x00\xe3\x00\x59\x00\xe4\x00\x64\x00\xb9\x02\x06\x02\x23\x03\x60\x00\x61\x00\x5a\x00\x24\x03\x64\x00\x3e\x01\xee\x00\xef\x00\xf0\x00\xe1\x00\xe2\x00\xe5\x00\x07\x02\xf2\x00\xee\x00\xef\x00\xf0\x00\xe1\x00\xe2\x00\x0e\x02\x07\x02\xf2\x00\x5b\x00\x1c\x03\x64\x00\x5c\x00\x5d\x00\x31\x00\x5e\x00\x2b\x00\x6c\x00\x32\x00\x41\x01\x33\x00\x0f\x02\x6a\x01\x05\x02\x06\x02\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x43\x01\x44\x01\x45\x01\x1e\x03\x5f\x00\x60\x00\x61\x00\x65\x00\x66\x00\xee\x00\xef\x00\xf0\x00\xe1\x00\xe2\x00\x27\x03\x07\x02\xf2\x00\xee\x00\xc5\x01\xf0\x00\xe1\x00\xe2\x00\x62\x01\xc6\x01\xf2\x00\xc7\x01\xa6\x01\x23\x03\x60\x00\x61\x00\x2b\x02\x24\x03\x64\x00\xf3\x02\x65\x02\xf3\x00\x96\x02\xee\x00\xc5\x01\xf0\x00\xe1\x00\xe2\x00\x63\x01\xc6\x01\xf2\x00\xc7\x01\xa6\x01\xc2\x03\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\x61\x03\xe8\x02\xe9\x02\xea\x02\x8b\x02\x10\x02\x81\x03\x66\x02\x67\x02\x34\x00\x35\x00\x27\x01\x11\x02\x29\x01\xe5\x00\x5d\x03\xee\x02\xef\x02\xf0\x02\xf3\x00\x60\x00\xcf\x00\xee\x00\xef\x00\xf0\x00\xe1\x00\xe2\x00\xf3\x00\xb9\x03\xf2\x00\x62\x00\x36\x00\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\x97\x01\x99\x01\x2e\x01\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\x9c\x02\xc5\x03\x2b\x01\x5c\x02\x3b\x03\xbd\x03\xe5\x00\x90\x03\xba\x03\x92\x03\x7a\x02\x91\x03\x97\x01\x9a\x01\xe5\x00\x35\x02\xee\x00\xef\x00\xf0\x00\xe1\x00\xe2\x00\xf3\x00\xc2\x03\xf2\x00\xee\x00\xef\x00\xf0\x00\xe1\x00\xe2\x00\xf3\x00\xaa\x03\xf2\x00\x60\x00\xe3\x00\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\x60\x00\xe3\x00\xeb\x02\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\x95\x01\xd8\x01\xf3\x00\xe1\xfe\xa5\x02\xe1\xfe\xe5\x00\x1e\x01\x1f\x01\x60\x00\xe3\x00\xab\x02\x68\x01\x64\x00\xe5\x00\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\xee\x00\xef\x00\xf0\x00\xe1\x00\xe2\x00\x42\x03\xbe\x03\xf2\x00\x1c\x02\xee\x00\xef\x00\xf0\x00\xe1\x00\xe2\x00\xe5\x00\x9c\x03\xf2\x00\x6a\x01\x68\x00\xe4\x02\xf3\x00\xee\x00\xef\x00\xf0\x00\xe1\x00\xe2\x00\x86\x03\xa3\x03\xf2\x00\x26\x03\x5f\x00\x60\x00\x61\x00\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\x27\x03\x38\x02\x63\x00\x64\x00\xee\x00\xef\x00\xf0\x00\xe1\x00\xe2\x00\x5c\x02\x5f\x03\xf2\x00\x94\x03\x2f\x00\xe5\x00\x5d\x02\xee\x00\xef\x00\xf0\x00\xe1\x00\xe2\x00\xf3\x00\x65\x03\xf2\x00\xee\x00\xef\x00\xf0\x00\xe1\x00\xe2\x00\xf3\x00\x8a\x02\xf2\x00\x06\xfe\x06\xfe\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\x79\x02\x6f\x03\x70\x03\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\xed\x02\x7a\x02\x06\xfe\x8a\x01\x88\x00\xf2\x02\xe5\x00\x8b\x01\x8c\x00\x8d\x00\x8e\x00\x86\x01\x8c\x01\x87\x01\xe5\x00\xee\x00\xef\x00\xf0\x00\xe1\x00\xe2\x00\x95\x00\xaa\x02\xf2\x00\x88\x03\x89\x03\xf3\x00\xee\x00\xef\x00\xf0\x00\xe1\x00\xe2\x00\xf7\x02\xb3\x02\xf2\x00\xf3\x00\x93\x02\x9e\x00\xd9\x01\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\x3e\x02\x94\x02\x82\x01\xf3\x00\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\x85\x01\x18\x03\x83\x01\x84\x01\x89\xfe\xe5\x00\x89\xfe\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\x85\x01\x07\x03\xe5\x00\xf3\x00\xee\x00\xef\x00\xf0\x00\xe1\x00\xe2\x00\x55\x02\xd0\x02\xf2\x00\x7e\x02\x56\x02\xe5\x00\xf3\x00\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\x40\x03\x41\x03\xf3\x00\xc0\x03\xe2\x00\x4a\x03\x63\x02\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\x50\x03\x51\x03\xe5\x00\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\x9b\x02\xee\x00\xef\x00\xf0\x00\xe1\x00\xe2\x00\xe5\x00\x0a\x02\xf2\x00\xee\x00\xef\x00\xf0\x00\xe1\x00\xe2\x00\xe5\x00\x61\x01\xf2\x00\x7a\x03\xe1\x00\xe2\x00\xf3\x00\xee\x00\xef\x00\xf0\x00\xe1\x00\xe2\x00\xa5\x03\x66\x01\xf2\x00\xd8\x01\x87\x02\xf3\x00\xd9\x01\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\x97\x02\x5f\x00\x60\x00\x61\x00\x2b\x00\x6c\x00\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\x20\x01\xa8\x02\x52\x02\xe5\x00\x3c\x01\xee\x00\xef\x00\xf0\x00\xe1\x00\xe2\x00\x88\x03\xa2\x01\xf2\x00\xff\x01\xe5\x00\xee\x00\xef\x00\xf0\x00\xe1\x00\xe2\x00\xc4\x02\xa7\x01\xf2\x00\xc5\x02\xf3\x00\xee\x00\xef\x00\xf0\x00\xe1\x00\xe2\x00\xe9\x01\xcb\x01\xf2\x00\x2b\x00\x6c\x00\xd4\x02\xd5\x02\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\x21\x00\x22\x00\x23\x00\xee\x00\xef\x00\xf0\x00\xe1\x00\xe2\x00\x82\x02\xf1\x00\xf2\x00\x00\x02\x60\x00\xe3\x00\xe5\x00\xe4\x00\x64\x00\x67\x01\x60\x00\x61\x00\xf3\x00\x68\x01\x64\x00\xee\x00\xef\x00\xf0\x00\xe1\x00\xe2\x00\xf3\x00\xfb\x00\xf2\x00\xe5\x00\x12\x02\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\xd6\x02\xd7\x02\xf3\x00\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\x14\x02\x60\x00\xe3\x00\x18\x02\xe4\x00\x64\x00\xe5\x00\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\x60\x00\xdc\x02\xe5\x00\xee\x00\xef\x00\xf0\x00\xe1\x00\xe2\x00\xe5\x00\x08\x01\xf2\x00\x24\x00\x22\x00\x23\x00\xe5\x00\xf3\x00\xe6\x02\xe7\x02\xe8\x02\xe9\x02\xea\x02\x1f\x02\x7c\x01\x60\x00\x61\x00\xf3\x00\x68\x01\x64\x00\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\x60\x00\x6c\x02\xf3\x00\x27\x02\x6d\x02\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\x2b\x02\x38\x02\x2c\x02\x2d\x02\xe5\x00\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\x2a\x02\x8a\xfe\xf3\x00\x8a\xfe\xe5\x00\xee\x00\xef\x00\xf0\x00\xe1\x00\xe2\x00\xca\x01\x45\x01\xf2\x00\x2e\x02\xe5\x00\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\x13\x03\x63\x02\xf3\x00\x5f\x00\x60\x00\x61\x00\x85\x02\x63\x02\x9a\x03\x9b\x03\xe0\x00\xe1\x00\xe2\x00\xcf\x01\xe5\x00\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\xee\x00\xc3\x01\xe0\x00\xe1\x00\xe2\x00\x51\x02\x5f\x00\x60\x00\x61\x00\xc4\x01\xeb\x02\x3a\x02\x3b\x02\x3c\x02\xe5\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\xf3\x00\xee\x00\xa7\x02\xe0\x00\xe1\x00\xe2\x00\xee\x00\xb4\x02\xe0\x00\xe1\x00\xe2\x00\x3e\x02\x95\x01\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\x68\x02\x1e\x01\x1f\x01\x20\x01\x8b\xfe\x22\x01\x8b\xfe\x3c\x01\xee\x00\x21\x02\xe0\x00\xe1\x00\xe2\x00\x59\x02\xe5\x00\x55\x01\xee\x00\xc1\x01\xe0\x00\xe1\x00\xe2\x00\x63\x03\x57\x01\xe0\x00\xe1\x00\xe2\x00\xc2\x02\x2f\x00\xee\x00\xc2\x01\xe0\x00\xe1\x00\xe2\x00\xb5\x02\x63\x02\x62\x02\x63\x02\xf3\x00\x3d\x03\x97\x01\xe0\x00\xe1\x00\xe2\x00\xd6\x00\xd7\x00\xfc\x02\x9b\x01\xe0\x00\xe1\x00\xe2\x00\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\x1b\x02\x9e\x01\xe0\x00\xe1\x00\xe2\x00\xf3\x00\xa0\x01\x1d\x02\xa9\x01\xe0\x00\xe1\x00\xe2\x00\x7b\x01\x2f\x00\xe5\x00\x4d\x00\x4e\x00\xf3\x00\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\xae\x01\x1e\x02\xab\x01\xe0\x00\xe1\x00\xe2\x00\xd0\x01\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\xa8\x00\xa9\x00\xe5\x00\xf3\x00\xb0\x01\xe2\x00\xb1\x01\xde\x01\xf3\x00\x22\x02\xe5\x01\xe0\x00\xe1\x00\xe2\x00\xe5\x00\xd9\x00\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\xaa\x00\xab\x00\xf3\x00\xc0\x01\xde\x00\xe0\x00\xe1\x00\xe2\x00\xf5\x00\xe5\x00\xf3\x00\x2e\x00\x2f\x00\x07\x01\xe5\x00\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\x6a\x00\x6b\x00\xf3\x00\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\x60\x00\xe3\x00\x47\x01\xe4\x00\x64\x00\xb6\x00\xe5\x00\x60\x00\xe3\x00\x62\x00\xe4\x00\x64\x00\x2b\x00\x6c\x00\xe5\x00\x31\x03\xe2\x00\x60\x00\xe3\x00\xe5\x00\xe4\x00\x64\x00\xb7\x03\xe2\x00\x60\x00\xe3\x00\xe5\x00\xe4\x00\x64\x00\xdf\x00\x3b\x00\xe0\x00\xe1\x00\xe2\x00\x60\x00\xe3\x00\xe5\x00\xe4\x00\x64\x00\x32\x03\x37\x00\x60\x00\xe3\x00\xe5\x00\xe4\x00\x64\x00\x06\xfe\x06\xfe\x0b\x02\xe1\x00\xe2\x00\x48\x00\xdb\x00\xe5\x00\x1a\x02\xe1\x00\xe2\x00\x3a\x00\x60\x00\xe3\x00\xe5\x00\xe4\x00\x64\x00\x6a\x02\xb2\x01\x5f\x00\x60\x00\x61\x00\x3a\x01\x1e\x00\x60\x00\xe3\x00\x15\x00\xe4\x00\x64\x00\x1e\x01\x1f\x01\xe5\x00\x60\x00\xe3\x00\xc9\x03\xe4\x00\x64\x00\x08\x03\xe1\x00\xe2\x00\x20\x00\x21\x00\x09\x03\xe5\x00\xb3\x01\xb4\x01\x7b\x03\xe1\x00\xe2\x00\x04\x03\x05\x03\xe5\x00\x60\x00\xe3\x00\xc0\x03\xe4\x00\x64\x00\x9d\x01\x9e\x01\x0a\x03\x0b\x03\x0c\x03\xc4\x03\x0d\x03\xb8\x03\xe2\x00\xfa\x01\xcc\x00\x7c\x03\x0b\x03\x0c\x03\xe5\x00\x0d\x03\x8e\x03\xe2\x00\x20\x00\x21\x00\x85\x02\xb0\x01\xe2\x00\xf8\x01\xa9\x03\x78\x03\x86\x00\x79\x03\xe2\x00\xaa\x03\xfa\x01\xac\x03\x60\x00\xe3\x00\xaf\x03\xe4\x00\x64\x00\xc2\x00\xc3\x00\x60\x00\xe3\x00\x65\x01\xe4\x00\x64\x00\x7e\x03\xe2\x00\x6a\x02\x3e\x01\x27\x01\x60\x00\xe3\x00\xe5\x00\xe4\x00\x64\x00\x2d\x03\xe2\x00\xb5\x03\xf8\x01\xe5\x00\xf9\x01\x86\x00\xb0\x01\xe2\x00\xb7\x03\xfa\x01\x8e\x03\x60\x00\xe3\x00\xe5\x00\xe4\x00\x64\x00\x47\x00\x60\x00\xe3\x00\x41\x01\xe4\x00\x64\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\x4a\x00\x4b\x00\x93\x03\x97\x03\xe5\x00\x43\x01\x44\x01\x45\x01\x0e\x03\x94\x03\xe5\x00\xd2\x00\xca\x00\xcb\x00\xcc\x00\x20\x00\x21\x00\x0e\x03\x06\xfe\x47\x00\x60\x00\xe3\x00\x5b\x02\xe4\x00\x0f\x03\x9e\x03\xfd\x01\xcb\x00\xcc\x00\x60\x00\xe3\x00\xa0\x03\xe4\x00\x0f\x03\x20\x01\xa1\x03\x22\x01\xcd\x00\x3c\x01\xe5\x00\xa5\x03\xce\x00\xa7\x03\xa8\x03\x5b\x03\x5f\x03\x60\x00\xe3\x00\xe5\x00\xe4\x00\x64\x00\x3e\x01\x27\x01\x60\x00\xcf\x00\x60\x00\xe3\x00\xd0\x00\xe4\x00\x64\x00\x60\x00\xe3\x00\x47\x00\xe4\x00\x64\x00\xe5\x00\x60\x00\xe3\x00\xdb\x00\xe4\x00\x64\x00\x36\x01\x67\x03\x47\x00\xe5\x00\x77\x03\x2b\x00\x61\x01\x41\x01\xe5\x00\x79\x03\x7e\x03\x86\x03\x60\x00\xe3\x00\xe5\x00\xe4\x00\x64\x00\x29\x03\x6a\x02\x43\x01\x44\x01\x45\x01\x60\x00\xe3\x00\x47\x00\xe4\x00\x64\x00\x36\x03\x2d\x03\x60\x00\xe3\x00\xe5\x00\xe4\x00\x64\x00\x49\xfe\x2f\x03\xcd\x00\x44\x03\x4a\x03\x53\x03\xce\x00\xe5\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x56\x03\xe5\x00\x68\x00\x69\x00\xcd\x00\x60\x00\xcf\x00\x47\x00\xce\x00\xd0\x00\x5b\x03\x54\x03\x37\x01\xd3\x02\xd9\x02\x38\x01\xdc\x02\x39\x01\xcd\x00\x3a\x01\x60\x00\xcf\x00\xce\x00\x77\x01\xd0\x00\xdb\x02\x1e\x01\x1f\x01\x3b\x01\x78\x01\x22\x01\xdf\x02\x3c\x01\xe0\x02\x60\x00\xcf\x00\xe2\x02\x79\x01\xd0\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\xe6\x02\xed\x02\x42\xff\xf9\x02\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x47\x00\xfe\x02\xff\x02\x47\x00\x00\x03\xf5\x01\x15\x03\x06\xfe\x6a\x02\x85\x02\x06\xfe\x78\x02\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x7c\x02\x5b\x01\x7d\x02\x06\xfe\x5c\x01\x06\xfe\x7a\x02\x7e\x02\x06\xfe\x95\x00\x6a\x02\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x5e\x01\x06\xfe\x06\xfe\x5f\x01\x06\xfe\x85\x02\x06\xfe\x87\x02\x9e\x00\x89\x02\x8a\x02\xe4\x01\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x68\x00\xfc\x01\x86\x01\x06\xfe\x2b\x00\x06\xfe\x96\x02\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x8f\x02\x06\xfe\xe4\x01\x06\xfe\x9a\x02\x73\x01\x06\xfe\x74\x01\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x9e\x02\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\xa4\x02\x5f\x00\x60\x00\x75\x01\xa5\x02\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\xaa\x02\xb0\x02\xb7\x02\xb2\x02\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\xb9\x02\xc0\x02\x06\xfe\xb8\x02\xc7\x02\x06\xfe\xc8\x02\xef\x01\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xf5\x01\xfc\x01\x06\xfe\xfd\x01\x06\xfe\xff\x01\xd9\x00\x06\xfe\x03\x02\x95\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x02\x02\x06\xfe\x06\xfe\x04\x02\x06\xfe\x05\x02\x06\xfe\x09\x02\x0a\x02\x9e\x00\x0d\x02\x43\xff\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x68\x00\x12\x02\x65\x01\x06\xfe\x3e\x01\x06\xfe\x28\x01\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x14\x02\x06\xfe\xe4\x01\x06\xfe\x18\x02\x66\xfe\x06\xfe\x1a\x02\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x29\x02\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x21\x02\x41\x01\x43\xff\x2a\x02\x30\x02\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x43\x01\x44\x01\x45\x01\x65\x01\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x33\x02\x3d\x02\x7f\x01\x50\x02\x51\x02\x33\xfe\x54\x02\x06\xfe\x5b\x02\x58\x02\x06\xfe\x68\x02\x06\xfe\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x5e\x02\x5f\x02\x06\xfe\x6a\x02\x06\xfe\x6f\x02\x71\x02\x06\xfe\x1d\x00\x95\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x57\x01\x06\xfe\x06\xfe\x59\x01\x06\xfe\x5a\x01\x06\xfe\x71\x01\x16\xfe\x9e\x00\x18\xfe\x17\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x68\x00\x69\x00\x1a\xfe\x06\xfe\x2b\x00\x6c\x00\x1d\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x7e\x01\x06\xfe\x7f\x01\x06\xfe\x81\x01\x88\x01\x06\xfe\x89\x01\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x87\x01\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x8f\x01\x90\x01\x91\x01\x93\x01\x94\x01\x06\xfe\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\x97\x01\x9b\x01\xa2\x01\xa0\x01\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\xa9\x01\xab\x01\xad\x01\xae\x01\xca\x01\xb0\x01\xcd\x01\x79\x00\xdb\x00\xd6\x01\x7a\x00\xd4\x01\xd5\x01\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xdb\x01\xdc\x01\x7b\x00\xe4\x01\x7c\x00\xe9\x01\xe0\x01\x7d\x00\xc4\x00\x95\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x47\x00\x84\x00\x85\x00\xd4\x00\xc9\x00\xd5\x00\x86\x00\xd6\x00\xd9\x00\x9e\x00\xdb\x00\xee\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\xee\x00\xf7\x00\xf9\x00\x95\x00\xfa\x00\x96\x00\xfb\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x35\x01\x9b\x00\x32\x01\x9c\x00\x49\x01\x52\x01\x9d\x00\x53\x01\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x4c\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\x54\x01\x3e\x01\x27\x01\x28\x01\x29\x01\xa8\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\x4d\x00\x50\x00\x2b\x00\x37\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x41\x01\x37\x01\x2e\x01\x39\x00\x38\x01\x3a\x00\x91\x01\x79\x00\x3a\x01\x48\x00\x7a\x00\x26\x00\x43\x01\x44\x01\x45\x01\x1e\x01\x1f\x01\x3b\x01\x28\x00\x22\x01\x2b\x00\x3c\x01\x7b\x00\x2c\x00\x7c\x00\x0f\x00\x2d\x00\x7d\x00\x2e\x00\x15\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\xff\xff\x84\x00\x85\x00\x0a\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x00\x00\x00\x00\x00\x00\x95\x00\x00\x00\x00\x00\x00\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x00\x00\x9b\x00\x00\x00\x9c\x00\x00\x00\x00\x00\x9d\x00\x00\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x00\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\x26\x01\x27\x01\x28\x01\x29\x01\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x2a\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x2b\x01\x7a\x00\x2c\x01\x2d\x01\x00\x00\x2e\x01\x00\x00\x00\x00\xbe\x00\x3e\x01\x27\x01\x28\x01\x29\x01\x7b\x00\x00\x00\x2f\x01\x30\x01\x31\x01\x7d\x00\x00\x00\x00\x00\x7e\x00\xb6\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x84\x00\x85\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x40\x01\x41\x01\x00\x00\x2e\x01\x65\x03\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x43\x01\x44\x01\x45\x01\x00\x00\x94\x00\x71\x01\x72\x01\x00\x00\x95\x00\xbf\x00\x00\x00\x73\x01\x00\x00\x74\x01\x00\x00\x00\x00\xc0\x00\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x5f\x00\x60\x00\x75\x01\x00\x00\xa3\x00\xa4\x00\xa5\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\xc1\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x00\x00\x37\x01\x00\x00\x47\x00\x38\x01\x00\x00\xe6\x01\x06\xfe\x3a\x01\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x1e\x01\x1f\x01\x3b\x01\x00\x00\x22\x01\x00\x00\x3c\x01\x06\xfe\x00\x00\x06\xfe\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x00\x00\x06\xfe\x06\xfe\x00\x00\x06\xfe\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x00\x00\x06\xfe\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x00\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x00\x00\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x04\x01\x00\x00\x00\x00\x05\x01\x00\x00\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x00\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x00\x00\x06\xfe\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x00\x00\x06\xfe\x06\xfe\x00\x00\x06\xfe\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x00\x00\x06\xfe\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x00\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7e\x00\xb6\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x84\x00\x85\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x6e\x03\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x95\x00\x00\x00\x00\x00\x00\x00\x97\x00\x98\x00\x99\x00\x00\x00\x00\x00\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x03\x00\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x00\x00\x00\x00\xa3\x00\xa4\x00\xa5\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\xc1\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x01\x27\x01\x28\x01\x29\x01\x06\xfe\x00\x00\x06\xfe\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x00\x00\x06\xfe\x06\xfe\x00\x00\x06\xfe\x00\x00\x06\xfe\x00\x00\x40\x01\x41\x01\x00\x00\x2e\x01\xe8\x01\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x43\x01\x44\x01\x45\x01\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x00\x00\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x01\x27\x01\x28\x01\x29\x01\x06\xfe\x00\x00\x06\xfe\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x00\x00\x06\xfe\x06\xfe\x00\x00\x06\xfe\x00\x00\x06\xfe\x00\x00\x40\x01\x41\x01\x00\x00\x2e\x01\x00\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x43\x01\x44\x01\x45\x01\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7e\x00\xb6\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x84\x00\x85\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x95\x00\x00\x00\x00\x00\x00\x00\x97\x00\x98\x00\x99\x00\x00\x00\x00\x00\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\x00\x00\x00\x00\xa3\x00\xa4\x00\xa5\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\xc1\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x00\x00\x06\xfe\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x00\x00\x06\xfe\x06\xfe\x00\x00\x06\xfe\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x00\x00\x06\xfe\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x00\x00\x06\xfe\x00\x00\x00\x00\x06\xfe\x00\x00\x06\xfe\x06\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x00\x00\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x00\x00\x06\xfe\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x00\x00\x06\xfe\x06\xfe\x00\x00\x06\xfe\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x00\x00\x06\xfe\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x00\x00\x06\xfe\x00\x00\x00\x00\x06\xfe\x00\x00\x06\xfe\x06\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\xbe\x01\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7e\x00\xb6\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x84\x00\x85\x00\x00\x00\x06\xfe\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x95\x00\xbf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbf\x01\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\xa4\x00\xa5\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\xc1\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\xbe\x01\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7e\x00\xb6\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x84\x00\x85\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x95\x00\xbf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbf\x01\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\xa4\x00\xa5\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\xc1\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x00\x00\x06\xfe\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x00\x00\x06\xfe\x06\xfe\x00\x00\x06\xfe\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x06\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x06\xfe\x06\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x06\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\xfe\x06\xfe\x06\xfe\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\x06\xfe\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7e\x00\xb6\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x84\x00\x85\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x4e\x03\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x95\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9b\x00\x00\x00\x9c\x00\x00\x00\x00\x00\x4f\x03\x00\x00\x9e\x00\x50\x03\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\xa4\x00\xa5\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\xc1\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\xbe\x01\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7e\x00\xb6\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x84\x00\x85\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x95\x00\xbf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbf\x01\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\xa4\x00\xa5\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\xc1\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7e\x00\xb6\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x84\x00\x85\x00\x00\x00\x06\xfe\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x95\x00\xbf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x00\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\xa4\x00\xa5\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\xc1\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\xbe\x01\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7e\x00\xb6\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x84\x00\x85\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x95\x00\xbf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbf\x01\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\xa4\x00\xa5\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\xc1\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7e\x00\xb6\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x84\x00\x85\x00\x00\x00\x06\xfe\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x95\x00\xbf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x00\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\xa4\x00\xa5\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\xc1\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\xbe\x01\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7e\x00\xb6\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x84\x00\x85\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x95\x00\xbf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbf\x01\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\xa4\x00\xa5\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\xc1\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x16\x01\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7e\x00\xb6\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x84\x00\x85\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x95\x00\xbf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x00\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\xa4\x00\xa5\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\xc1\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7e\x00\xb6\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x84\x00\x85\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x95\x00\xbf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x00\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\xa4\x00\xa5\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\xc1\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7e\x00\xb6\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x84\x00\x85\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x95\x00\xbf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x02\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\xa4\x00\xa5\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\xc1\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7e\x00\xb6\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x84\x00\x85\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x95\x00\xbf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x00\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\xa4\x00\xa5\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\xc1\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7e\x00\xb6\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x84\x00\x85\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x95\x00\xbf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x02\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\xa4\x00\xa5\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\xc1\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7e\x00\xb6\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x84\x00\x85\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x95\x00\xbf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x00\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\xa4\x00\xa5\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\xc1\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7e\x00\xb6\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x84\x00\x85\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x95\x00\xbf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x02\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\xa4\x00\xa5\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\xc1\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7e\x00\xb6\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x84\x00\x85\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x95\x00\xbf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x00\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\xa4\x00\xa5\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\xc1\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7e\x00\xb6\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x84\x00\x85\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x95\x00\xbf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x02\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\xa4\x00\xa5\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\xc1\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7e\x00\xb6\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x84\x00\x85\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x95\x00\xbf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x00\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\xa4\x00\xa5\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\xc1\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7e\x00\xb6\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x84\x00\x85\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x95\x00\xbf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x02\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\xa4\x00\xa5\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\xc1\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7e\x00\xb6\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x84\x00\x85\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x95\x00\xbf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x00\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\xa4\x00\xa5\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\xc1\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x7c\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7e\x00\xb6\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x84\x00\x85\x00\x68\x00\x00\x00\x00\x00\x86\x00\x2b\x00\x6c\x00\x00\x00\x00\x00\x1c\xff\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x8f\x00\x00\x00\x00\x00\x00\x00\xe7\x00\x94\x00\xe8\x00\x00\x00\x00\x00\x95\x00\x00\x00\x00\x00\xe9\x00\x00\x00\x00\x00\x00\x00\x1c\xff\x68\x00\x9b\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x37\x03\x46\xff\x00\x00\x38\x03\xa3\x00\xa4\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe7\x00\x00\x00\xe8\x00\xc1\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x00\x00\x00\x00\xbc\x03\x00\x00\x37\x02\x00\x00\x00\x00\x00\x00\x95\x00\x00\x00\x00\x00\x38\x02\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x6c\x00\x00\x00\x00\x00\x1c\xff\x9e\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x00\x00\x39\x03\xe7\x00\x00\x00\xe8\x00\x00\x00\x00\x00\xf5\x00\x95\x00\x00\x00\xe9\x00\x00\x00\x00\x00\x00\x00\x1c\xff\x68\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x6c\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x88\x00\x38\x03\x00\x00\x00\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\xbd\x03\x11\x03\x00\x00\xe8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x95\x00\xe9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x9e\x00\x00\x00\x00\x00\x12\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x95\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x6c\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x00\x00\x39\x03\xe7\x00\x00\x00\xe8\x00\x00\x00\x00\x00\x00\x00\x95\x00\x00\x00\xe9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x6c\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x12\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x03\xe7\x00\x00\x00\xe8\x00\x68\x00\x00\x00\x00\x00\x00\x00\x2b\x00\xe9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\xd2\x00\xb1\x03\x34\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x95\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb2\x03\x68\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x6c\x00\x00\x00\x68\x00\x69\x00\x9e\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x00\x00\x13\x03\x11\x03\x00\x00\xe8\x00\x00\x00\x00\x00\x00\x00\x95\x00\xdd\x00\xe9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x03\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x12\x03\x00\x00\x00\x00\x00\x00\x95\x00\x00\x00\x00\x00\x35\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\x9e\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x00\x00\x95\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x95\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x13\x03\xa8\xfe\xa8\xfe\xa8\xfe\xa8\xfe\xa8\xfe\xa8\xfe\xa8\xfe\xa8\xfe\xa8\xfe\xa8\xfe\xa8\xfe\xa8\xfe\xa8\xfe\xa8\xfe\xa8\xfe\xa8\xfe\xa8\xfe\xa8\xfe\xa8\xfe\xa8\xfe\xa8\xfe\xa8\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xa8\xfe\x00\x00\x00\x00\xa8\xfe\x00\x00\xa8\xfe\xa8\xfe\xa8\xfe\xa8\xfe\x00\x00\xa8\xfe\xa8\xfe\xa8\xfe\x00\x00\xa8\xfe\x00\x00\x68\x00\x69\x00\xa8\xfe\x00\x00\xa8\xfe\xa8\xfe\xa8\xfe\xa8\xfe\x00\x00\x00\x00\xa8\xfe\xa8\xfe\xa8\xfe\xa8\xfe\xa8\xfe\xa8\xfe\x00\x00\xa8\xfe\xa8\xfe\x00\x00\xa8\xfe\xdd\x00\xa8\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\xfe\xa8\xfe\xa8\xfe\xa8\xfe\xa8\xfe\xa8\xfe\xa8\xfe\xb3\x00\x69\x00\x6a\x00\x6b\x00\xb4\x00\x6c\x00\xb5\x00\x00\x00\x00\x00\xa8\xfe\x00\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\xa8\xfe\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x95\x00\x7e\x00\xb6\x00\x80\x00\x81\x00\x82\x00\x83\x00\xde\x00\x84\x00\x85\x00\x00\x00\x00\x00\x00\x00\x86\x00\x81\xfe\x81\xfe\x9e\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x34\x00\x35\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x95\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\x00\x00\x36\x00\x00\x00\x9e\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\xd0\x02\x00\x00\x7b\x00\x2b\x00\x6c\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x00\x00\x7e\x00\xb6\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x84\x00\x85\x00\x00\x00\x03\x01\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x01\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\x00\x00\x00\x00\x95\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x68\x00\x69\x00\x7b\x00\x00\x00\x2b\x00\x6c\x00\x00\x00\x7d\x00\x95\x00\x00\x00\x7e\x00\xb6\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x84\x00\x85\x00\x00\x00\x06\xfe\x07\x01\x86\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x6d\x00\x00\x00\x00\x00\x95\x00\x00\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\x78\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7d\x00\x00\x00\x95\x00\x7e\x00\xb6\x00\x80\x00\x81\x00\x82\x00\x83\x00\x00\x00\x84\x00\x85\x00\x51\x01\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x68\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x6c\x00\x00\x00\xb6\x01\x27\x01\x95\x00\x29\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\xe7\x00\x00\x00\xe8\x00\x2b\x00\x9e\x00\x00\x00\x00\x00\x00\x00\xe9\x00\x00\x00\x00\x00\x00\x00\xb7\x01\x00\x00\x00\x00\x2e\x01\x00\x00\x00\x00\x68\x00\x00\x00\xd2\x00\xb8\x01\x00\x00\xb9\x01\x46\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x50\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x00\x00\x00\x00\x27\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xe7\x00\x99\x01\xe8\x00\xa7\x02\x00\x00\x00\x00\x00\x00\x00\x00\xe9\x00\x95\x00\x2b\x01\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x9a\x01\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x95\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x68\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x6c\x00\x9e\x00\xb6\x01\x27\x01\x95\x00\x29\x01\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x00\x00\x00\x00\xe7\x00\x00\x00\xe8\x00\x00\x00\x9e\x00\xf5\x00\x95\x00\x00\x00\xe9\x00\x00\x00\x00\x00\x00\x00\xb7\x01\x00\x00\x00\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x01\x9e\x00\xc9\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xe7\x00\x99\x01\xe8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\x00\x95\x00\x2b\x01\x00\x00\x68\x00\x00\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x00\x00\x00\x00\x00\x00\x9a\x01\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe7\x00\x00\x00\xe8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\x69\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf5\x00\x95\x00\x77\x01\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x01\x9e\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x00\x00\xe7\x00\x00\x00\xe8\x00\x00\x00\x00\x00\x00\x00\xf5\x00\x95\x00\xe9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\x47\x01\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x68\x00\xe7\x00\x00\x00\xe8\x00\x2b\x00\x6c\x00\x00\x00\x00\x00\x95\x00\xe9\x00\x97\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf5\x00\x95\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xe7\x00\x68\x00\xe8\x00\x6a\x00\x6b\x00\x2b\x00\x6c\x00\x00\x00\xe9\x00\x95\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x00\x00\xe7\x00\x00\x00\xe8\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x95\x00\xe9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x6c\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x00\x00\xe7\x00\x00\x00\xe8\x00\x00\x00\x00\x00\x00\x00\xf5\x00\x95\x00\xe9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x68\x00\x00\x00\x00\x00\x9e\x00\x2b\x00\x6c\x00\x00\x00\x68\x00\x69\x00\x95\x00\x00\x00\x2b\x00\x6c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe7\x00\x00\x00\xe8\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x07\x01\xe9\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x50\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xea\x00\x45\xff\x95\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xeb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x68\x00\x00\x00\x95\x00\x00\x00\x2b\x00\x6c\x00\x00\x00\x68\x00\x00\x00\x95\x00\x00\x00\x2b\x00\x6c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x51\x01\x00\x00\xe7\x00\x00\x00\xe8\x00\x00\x00\x9e\x00\x00\x00\x00\x00\xe7\x00\xe9\x00\xe8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\x00\x00\x00\x00\x00\x00\x00\x68\x00\x69\x00\x00\x00\x00\x00\x2b\x00\x6c\x00\x00\x00\x68\x00\x69\x00\x00\x00\x00\x00\x2b\x00\x6c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x01\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xd2\x00\x76\x02\x95\x00\x68\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x95\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x02\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x68\x00\x69\x00\x00\x00\x00\x00\xd2\x00\x9e\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x68\x00\xdd\x00\x95\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x95\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x9e\x00\x00\x00\x00\x00\xd2\x00\x00\x00\x00\x00\x68\x00\x9e\x00\x95\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x9e\x00\x00\x00\x68\x00\x26\x02\x00\x00\x00\x00\x00\x00\x00\x00\x95\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x3a\x03\x00\x00\x00\x00\x68\x00\x69\x00\x00\x00\x00\x00\x26\x02\x9e\x00\x95\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x27\x02\x00\x00\x00\x00\x68\x00\xdd\x00\x9e\x00\x00\x00\x2b\x00\x00\x00\x95\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\xd2\x00\x9e\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x95\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x68\x00\x00\x00\x00\x00\xbe\x02\x00\x00\x9e\x00\x00\x00\x68\x00\x00\x00\x95\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x02\x00\x00\x00\x00\x00\x00\x9e\x00\x95\x00\x00\x00\xbe\x02\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x95\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x95\x00\x00\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x88\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x8d\x00\x8e\x00\x9e\x00\x00\x00\x95\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x95\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x3e\x01\x27\x01\x28\x01\x29\x01\x00\x00\x9e\x00\x3f\x02\xba\x01\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3f\x01\x59\x00\x40\x01\x41\x01\x00\x00\x2e\x01\x42\x01\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\xb5\x03\x41\x02\x00\x00\x43\x01\x44\x01\x45\x01\x00\x00\x00\x00\x00\x00\x42\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x3f\x02\xba\x01\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x8e\x02\x41\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x3f\x02\xba\x01\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x40\x02\x41\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x3f\x02\xba\x01\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x45\x02\x41\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\xc4\xfe\xc4\xfe\xc4\xfe\xc4\xfe\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\xb9\x01\xba\x01\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\xc4\xfe\x00\x00\xc4\xfe\xc4\xfe\x59\x00\xc4\xfe\xc4\xfe\xc4\xfe\x00\x00\xc4\xfe\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\xc4\xfe\xc4\xfe\xc4\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x01\x00\x00\x60\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\xb9\x01\xba\x01\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x01\x00\x00\xe2\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x3f\x02\xba\x01\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\xb9\x01\xba\x01\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x01\x00\x00\xb0\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\xb9\x01\xba\x01\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x01\x00\x00\x16\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\xb9\x01\xba\x01\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x01\x00\x00\xbc\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\xb9\x01\xba\x01\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x01\x00\x00\xbf\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\xc7\x03\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x95\x03\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x59\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x5c\x03\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x03\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x59\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x3c\x03\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x03\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x59\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\xe3\x02\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x02\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x59\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\xb7\x00\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0b\x01\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x59\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x0c\x01\xb8\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\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\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x16\x01\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x17\x01\x00\x00\x18\x01\x00\x00\x19\x01\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\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\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x1a\x01\x00\x00\x1b\x01\x00\x00\x00\x00\x1c\x01\x1d\x01\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x1e\x01\x1f\x01\x20\x01\x21\x01\x22\x01\x23\x01\x24\x01\x65\x00\x66\x00\x11\x01\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x12\x01\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x13\x01\x14\x01\x00\x00\x00\x00\x00\x00\x00\x00\x11\x01\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x5b\x00\x4d\x02\x4e\x02\x5c\x00\x5d\x00\x59\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x3e\x03\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3f\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x11\x01\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x02\x03\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\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\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\xc0\x02\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\xc1\x02\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x02\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x5b\x00\x00\x00\x48\x02\x5c\x00\x5d\x00\x59\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x11\x01\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x49\x02\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\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\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x4b\x02\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x02\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\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\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x0d\x01\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x0e\x01\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x03\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x59\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\xd1\x02\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x03\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x59\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x90\x02\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x02\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x59\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\xcd\x02\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x02\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x59\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x46\x02\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x02\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x59\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\xe4\x01\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfc\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x59\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\xff\x00\xb9\x00\xba\x00\xbb\x00\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x02\xba\x00\x0a\x01\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x59\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x7f\x01\xba\x00\x0a\x01\xbc\x00\x53\x00\x54\x00\x55\x00\x65\x00\x66\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\x01\xba\x00\x0a\x01\xbc\x00\x53\x00\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x59\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\xea\x01\x6b\x01\x54\x00\x55\x00\x65\x00\x66\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x6b\x01\x54\x00\x55\x00\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5a\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x0f\x01\x00\x00\x00\x00\x56\x00\x57\x00\x58\x00\x00\x00\x65\x00\x66\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\xeb\x01\xec\x01\xed\x01\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5a\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\xce\x02\xed\x01\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\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\xae\x00\x57\x00\x58\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x59\x00\x5e\x00\x00\x00\xaf\x00\x2f\x00\x00\x00\xb0\x00\x91\x02\x5a\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\xae\x00\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x59\x00\x00\x00\x00\x00\xaf\x00\x2f\x00\x00\x00\xb0\x00\xb1\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x01\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5a\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x7a\x01\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x35\x01\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5a\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\xdd\x01\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x01\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5a\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x35\x01\x57\x00\x58\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\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\x5b\x00\x00\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x65\x00\x66\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"# - -happyReduceArr = array (1, 516) [ - (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), - (414 , happyReduce_414), - (415 , happyReduce_415), - (416 , happyReduce_416), - (417 , happyReduce_417), - (418 , happyReduce_418), - (419 , happyReduce_419), - (420 , happyReduce_420), - (421 , happyReduce_421), - (422 , happyReduce_422), - (423 , happyReduce_423), - (424 , happyReduce_424), - (425 , happyReduce_425), - (426 , happyReduce_426), - (427 , happyReduce_427), - (428 , happyReduce_428), - (429 , happyReduce_429), - (430 , happyReduce_430), - (431 , happyReduce_431), - (432 , happyReduce_432), - (433 , happyReduce_433), - (434 , happyReduce_434), - (435 , happyReduce_435), - (436 , happyReduce_436), - (437 , happyReduce_437), - (438 , happyReduce_438), - (439 , happyReduce_439), - (440 , happyReduce_440), - (441 , happyReduce_441), - (442 , happyReduce_442), - (443 , happyReduce_443), - (444 , happyReduce_444), - (445 , happyReduce_445), - (446 , happyReduce_446), - (447 , happyReduce_447), - (448 , happyReduce_448), - (449 , happyReduce_449), - (450 , happyReduce_450), - (451 , happyReduce_451), - (452 , happyReduce_452), - (453 , happyReduce_453), - (454 , happyReduce_454), - (455 , happyReduce_455), - (456 , happyReduce_456), - (457 , happyReduce_457), - (458 , happyReduce_458), - (459 , happyReduce_459), - (460 , happyReduce_460), - (461 , happyReduce_461), - (462 , happyReduce_462), - (463 , happyReduce_463), - (464 , happyReduce_464), - (465 , happyReduce_465), - (466 , happyReduce_466), - (467 , happyReduce_467), - (468 , happyReduce_468), - (469 , happyReduce_469), - (470 , happyReduce_470), - (471 , happyReduce_471), - (472 , happyReduce_472), - (473 , happyReduce_473), - (474 , happyReduce_474), - (475 , happyReduce_475), - (476 , happyReduce_476), - (477 , happyReduce_477), - (478 , happyReduce_478), - (479 , happyReduce_479), - (480 , happyReduce_480), - (481 , happyReduce_481), - (482 , happyReduce_482), - (483 , happyReduce_483), - (484 , happyReduce_484), - (485 , happyReduce_485), - (486 , happyReduce_486), - (487 , happyReduce_487), - (488 , happyReduce_488), - (489 , happyReduce_489), - (490 , happyReduce_490), - (491 , happyReduce_491), - (492 , happyReduce_492), - (493 , happyReduce_493), - (494 , happyReduce_494), - (495 , happyReduce_495), - (496 , happyReduce_496), - (497 , happyReduce_497), - (498 , happyReduce_498), - (499 , happyReduce_499), - (500 , happyReduce_500), - (501 , happyReduce_501), - (502 , happyReduce_502), - (503 , happyReduce_503), - (504 , happyReduce_504), - (505 , happyReduce_505), - (506 , happyReduce_506), - (507 , happyReduce_507), - (508 , happyReduce_508), - (509 , happyReduce_509), - (510 , happyReduce_510), - (511 , happyReduce_511), - (512 , happyReduce_512), - (513 , happyReduce_513), - (514 , happyReduce_514), - (515 , happyReduce_515), - (516 , happyReduce_516) - ] - -happy_n_terms = 123 :: Int -happy_n_nonterms = 205 :: Int - -happyReduce_1 = happyMonadReduce 2# 0# happyReduction_1 -happyReduction_1 (happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut6 happy_x_1 of { happy_var_1 -> - case happyOut5 happy_x_2 of { happy_var_2 -> - ( checkExpr happy_var_2 >>= mkPageModule happy_var_1)}} - ) (\r -> happyReturn (happyIn4 r)) - -happyReduce_2 = happyMonadReduce 6# 0# happyReduction_2 -happyReduction_2 (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 happyOut6 happy_x_1 of { happy_var_1 -> - case happyOut10 happy_x_3 of { happy_var_3 -> - case happyOut200 happy_x_5 of { happy_var_5 -> - case happyOut5 happy_x_6 of { happy_var_6 -> - ( checkExpr happy_var_6 >>= \x -> mkPage (happy_var_3 happy_var_1) happy_var_5 x)}}}} - ) (\r -> happyReturn (happyIn4 r)) - -happyReduce_3 = happySpecReduce_2 0# happyReduction_3 -happyReduction_3 happy_x_2 - happy_x_1 - = case happyOut6 happy_x_1 of { happy_var_1 -> - case happyOut10 happy_x_2 of { happy_var_2 -> - happyIn4 - (happy_var_2 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 happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut145 happy_x_3 of { happy_var_3 -> - case happyOut147 happy_x_4 of { happy_var_4 -> - case happyOut149 happy_x_5 of { happy_var_5 -> - case happyOut143 happy_x_7 of { happy_var_7 -> - case happyOut145 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 $ XTag 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 happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut145 happy_x_3 of { happy_var_3 -> - case happyOut147 happy_x_4 of { happy_var_4 -> - case happyOut149 happy_x_5 of { happy_var_5 -> - happyIn5 - (XETag happy_var_1 happy_var_3 (reverse happy_var_4) happy_var_5 - ) `HappyStk` happyRest}}}} - -happyReduce_6 = happySpecReduce_3 2# happyReduction_6 -happyReduction_6 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut7 happy_x_2 of { happy_var_2 -> - happyIn6 - (happy_var_2 - )} - -happyReduce_7 = happySpecReduce_3 3# happyReduction_7 -happyReduction_7 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut8 happy_x_1 of { happy_var_1 -> - case happyOut7 happy_x_3 of { happy_var_3 -> - happyIn7 - (happy_var_1 : happy_var_3 - )}} - -happyReduce_8 = happySpecReduce_0 3# happyReduction_8 -happyReduction_8 = happyIn7 - ([] - ) - -happyReduce_9 = happyReduce 4# 4# happyReduction_9 -happyReduction_9 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut9 happy_x_3 of { happy_var_3 -> - happyIn8 - (LanguagePragma happy_var_1 happy_var_3 - ) `HappyStk` happyRest}} - -happyReduce_10 = happySpecReduce_3 4# happyReduction_10 -happyReduction_10 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { (INCLUDE happy_var_2) -> - happyIn8 - (IncludePragma happy_var_1 happy_var_2 - )}} - -happyReduce_11 = happySpecReduce_3 4# happyReduction_11 -happyReduction_11 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { (OPTIONS happy_var_2) -> - happyIn8 - (let (mc, s) = happy_var_2 in OptionsPragma happy_var_1 (readTool mc) s - )}} - -happyReduce_12 = happySpecReduce_3 4# happyReduction_12 -happyReduction_12 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { (CFILES happy_var_2) -> - happyIn8 - (CFilesPragma happy_var_1 happy_var_2 - )}} - -happyReduce_13 = happySpecReduce_3 4# happyReduction_13 -happyReduction_13 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { (PragmaUnknown happy_var_2) -> - happyIn8 - (let (n, s) = happy_var_2 in UnknownTopPragma happy_var_1 n s - )}} - -happyReduce_14 = happySpecReduce_3 5# happyReduction_14 -happyReduction_14 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut191 happy_x_1 of { happy_var_1 -> - case happyOut9 happy_x_3 of { happy_var_3 -> - happyIn9 - (happy_var_1 : happy_var_3 - )}} - -happyReduce_15 = happySpecReduce_1 5# happyReduction_15 -happyReduction_15 happy_x_1 - = case happyOut191 happy_x_1 of { happy_var_1 -> - happyIn9 - ([happy_var_1] - )} - -happyReduce_16 = happyReduce 7# 6# happyReduction_16 -happyReduction_16 (happy_x_7 `HappyStk` - happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut203 happy_x_3 of { happy_var_3 -> - case happyOut11 happy_x_4 of { happy_var_4 -> - case happyOut16 happy_x_5 of { happy_var_5 -> - case happyOut12 happy_x_7 of { happy_var_7 -> - happyIn10 - (\os -> Module happy_var_1 happy_var_3 os happy_var_4 happy_var_5 (fst happy_var_7) (snd happy_var_7) - ) `HappyStk` happyRest}}}}} - -happyReduce_17 = happySpecReduce_2 6# happyReduction_17 -happyReduction_17 happy_x_2 - happy_x_1 - = case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut12 happy_x_2 of { happy_var_2 -> - happyIn10 - (\os -> Module happy_var_1 main_mod os Nothing (Just [EVar (UnQual main_name)]) - (fst happy_var_2) (snd happy_var_2) - )}} - -happyReduce_18 = happySpecReduce_3 7# happyReduction_18 -happyReduction_18 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_2 of { (StringTok happy_var_2) -> - happyIn11 - (Just $ DeprText happy_var_2 - )} - -happyReduce_19 = happySpecReduce_3 7# happyReduction_19 -happyReduction_19 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_2 of { (StringTok happy_var_2) -> - happyIn11 - (Just $ WarnText happy_var_2 - )} - -happyReduce_20 = happySpecReduce_0 7# happyReduction_20 -happyReduction_20 = happyIn11 - (Nothing - ) - -happyReduce_21 = happySpecReduce_3 8# happyReduction_21 -happyReduction_21 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_2 of { happy_var_2 -> - happyIn12 - (happy_var_2 - )} - -happyReduce_22 = happySpecReduce_3 8# happyReduction_22 -happyReduction_22 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut13 happy_x_2 of { happy_var_2 -> - happyIn12 - (happy_var_2 - )} - -happyReduce_23 = happyReduce 4# 9# happyReduction_23 -happyReduction_23 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut21 happy_x_2 of { happy_var_2 -> - case happyOut37 happy_x_4 of { happy_var_4 -> - happyIn13 - ((reverse happy_var_2, happy_var_4) - ) `HappyStk` happyRest}} - -happyReduce_24 = happySpecReduce_2 9# happyReduction_24 -happyReduction_24 happy_x_2 - happy_x_1 - = case happyOut37 happy_x_2 of { happy_var_2 -> - happyIn13 - (([], happy_var_2) - )} - -happyReduce_25 = happySpecReduce_3 9# happyReduction_25 -happyReduction_25 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut21 happy_x_2 of { happy_var_2 -> - happyIn13 - ((reverse happy_var_2, []) - )} - -happyReduce_26 = happySpecReduce_1 9# happyReduction_26 -happyReduction_26 happy_x_1 - = happyIn13 - (([], []) - ) - -happyReduce_27 = happySpecReduce_2 10# happyReduction_27 -happyReduction_27 happy_x_2 - happy_x_1 - = happyIn14 - (() - ) - -happyReduce_28 = happySpecReduce_1 11# happyReduction_28 -happyReduction_28 happy_x_1 - = happyIn15 - (() - ) - -happyReduce_29 = happySpecReduce_0 11# happyReduction_29 -happyReduction_29 = happyIn15 - (() - ) - -happyReduce_30 = happySpecReduce_1 12# happyReduction_30 -happyReduction_30 happy_x_1 - = case happyOut17 happy_x_1 of { happy_var_1 -> - happyIn16 - (Just happy_var_1 - )} - -happyReduce_31 = happySpecReduce_0 12# happyReduction_31 -happyReduction_31 = happyIn16 - (Nothing - ) - -happyReduce_32 = happyReduce 4# 13# happyReduction_32 -happyReduction_32 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut19 happy_x_2 of { happy_var_2 -> - happyIn17 - (reverse happy_var_2 - ) `HappyStk` happyRest} - -happyReduce_33 = happySpecReduce_3 13# happyReduction_33 -happyReduction_33 happy_x_3 - happy_x_2 - happy_x_1 - = happyIn17 - ([] - ) - -happyReduce_34 = happySpecReduce_1 14# happyReduction_34 -happyReduction_34 happy_x_1 - = happyIn18 - (() - ) - -happyReduce_35 = happySpecReduce_0 14# happyReduction_35 -happyReduction_35 = happyIn18 - (() - ) - -happyReduce_36 = happySpecReduce_3 15# happyReduction_36 -happyReduction_36 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut19 happy_x_1 of { happy_var_1 -> - case happyOut20 happy_x_3 of { happy_var_3 -> - happyIn19 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_37 = happySpecReduce_1 15# happyReduction_37 -happyReduction_37 happy_x_1 - = case happyOut20 happy_x_1 of { happy_var_1 -> - happyIn19 - ([happy_var_1] - )} - -happyReduce_38 = happySpecReduce_1 16# happyReduction_38 -happyReduction_38 happy_x_1 - = case happyOut173 happy_x_1 of { happy_var_1 -> - happyIn20 - (EVar happy_var_1 - )} - -happyReduce_39 = happySpecReduce_1 16# happyReduction_39 -happyReduction_39 happy_x_1 - = case happyOut205 happy_x_1 of { happy_var_1 -> - happyIn20 - (EAbs happy_var_1 - )} - -happyReduce_40 = happyReduce 4# 16# happyReduction_40 -happyReduction_40 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut205 happy_x_1 of { happy_var_1 -> - happyIn20 - (EThingAll happy_var_1 - ) `HappyStk` happyRest} - -happyReduce_41 = happySpecReduce_3 16# happyReduction_41 -happyReduction_41 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut205 happy_x_1 of { happy_var_1 -> - happyIn20 - (EThingWith happy_var_1 [] - )} - -happyReduce_42 = happyReduce 4# 16# happyReduction_42 -happyReduction_42 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut205 happy_x_1 of { happy_var_1 -> - case happyOut31 happy_x_3 of { happy_var_3 -> - happyIn20 - (EThingWith happy_var_1 (reverse happy_var_3) - ) `HappyStk` happyRest}} - -happyReduce_43 = happySpecReduce_2 16# happyReduction_43 -happyReduction_43 happy_x_2 - happy_x_1 - = case happyOut203 happy_x_2 of { happy_var_2 -> - happyIn20 - (EModuleContents happy_var_2 - )} - -happyReduce_44 = happySpecReduce_3 17# happyReduction_44 -happyReduction_44 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut21 happy_x_1 of { happy_var_1 -> - case happyOut22 happy_x_3 of { happy_var_3 -> - happyIn21 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_45 = happySpecReduce_1 17# happyReduction_45 -happyReduction_45 happy_x_1 - = case happyOut22 happy_x_1 of { happy_var_1 -> - happyIn21 - ([happy_var_1] - )} - -happyReduce_46 = happyReduce 7# 18# happyReduction_46 -happyReduction_46 (happy_x_7 `HappyStk` - happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut23 happy_x_3 of { happy_var_3 -> - case happyOut24 happy_x_4 of { happy_var_4 -> - case happyOut203 happy_x_5 of { happy_var_5 -> - case happyOut25 happy_x_6 of { happy_var_6 -> - case happyOut26 happy_x_7 of { happy_var_7 -> - happyIn22 - (ImportDecl happy_var_1 happy_var_5 happy_var_4 happy_var_3 happy_var_6 happy_var_7 - ) `HappyStk` happyRest}}}}}} - -happyReduce_47 = happySpecReduce_2 19# happyReduction_47 -happyReduction_47 happy_x_2 - happy_x_1 - = happyIn23 - (True - ) - -happyReduce_48 = happySpecReduce_0 19# happyReduction_48 -happyReduction_48 = happyIn23 - (False - ) - -happyReduce_49 = happySpecReduce_1 20# happyReduction_49 -happyReduction_49 happy_x_1 - = happyIn24 - (True - ) - -happyReduce_50 = happySpecReduce_0 20# happyReduction_50 -happyReduction_50 = happyIn24 - (False - ) - -happyReduce_51 = happySpecReduce_2 21# happyReduction_51 -happyReduction_51 happy_x_2 - happy_x_1 - = case happyOut203 happy_x_2 of { happy_var_2 -> - happyIn25 - (Just happy_var_2 - )} - -happyReduce_52 = happySpecReduce_0 21# happyReduction_52 -happyReduction_52 = happyIn25 - (Nothing - ) - -happyReduce_53 = happySpecReduce_1 22# happyReduction_53 -happyReduction_53 happy_x_1 - = case happyOut27 happy_x_1 of { happy_var_1 -> - happyIn26 - (Just happy_var_1 - )} - -happyReduce_54 = happySpecReduce_0 22# happyReduction_54 -happyReduction_54 = happyIn26 - (Nothing - ) - -happyReduce_55 = happyReduce 5# 23# happyReduction_55 -happyReduction_55 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut28 happy_x_1 of { happy_var_1 -> - case happyOut29 happy_x_3 of { happy_var_3 -> - happyIn27 - ((happy_var_1, reverse happy_var_3) - ) `HappyStk` happyRest}} - -happyReduce_56 = happyReduce 4# 23# happyReduction_56 -happyReduction_56 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut28 happy_x_1 of { happy_var_1 -> - happyIn27 - ((happy_var_1, []) - ) `HappyStk` happyRest} - -happyReduce_57 = happySpecReduce_1 24# happyReduction_57 -happyReduction_57 happy_x_1 - = happyIn28 - (True - ) - -happyReduce_58 = happySpecReduce_0 24# happyReduction_58 -happyReduction_58 = happyIn28 - (False - ) - -happyReduce_59 = happySpecReduce_3 25# happyReduction_59 -happyReduction_59 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut29 happy_x_1 of { happy_var_1 -> - case happyOut30 happy_x_3 of { happy_var_3 -> - happyIn29 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_60 = happySpecReduce_1 25# happyReduction_60 -happyReduction_60 happy_x_1 - = case happyOut30 happy_x_1 of { happy_var_1 -> - happyIn29 - ([happy_var_1] - )} - -happyReduce_61 = happySpecReduce_1 26# happyReduction_61 -happyReduction_61 happy_x_1 - = case happyOut171 happy_x_1 of { happy_var_1 -> - happyIn30 - (IVar happy_var_1 - )} - -happyReduce_62 = happySpecReduce_1 26# happyReduction_62 -happyReduction_62 happy_x_1 - = case happyOut204 happy_x_1 of { happy_var_1 -> - happyIn30 - (IAbs happy_var_1 - )} - -happyReduce_63 = happyReduce 4# 26# happyReduction_63 -happyReduction_63 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut204 happy_x_1 of { happy_var_1 -> - happyIn30 - (IThingAll happy_var_1 - ) `HappyStk` happyRest} - -happyReduce_64 = happySpecReduce_3 26# happyReduction_64 -happyReduction_64 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut204 happy_x_1 of { happy_var_1 -> - happyIn30 - (IThingWith happy_var_1 [] - )} - -happyReduce_65 = happyReduce 4# 26# happyReduction_65 -happyReduction_65 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut204 happy_x_1 of { happy_var_1 -> - case happyOut31 happy_x_3 of { happy_var_3 -> - happyIn30 - (IThingWith happy_var_1 (reverse happy_var_3) - ) `HappyStk` happyRest}} - -happyReduce_66 = happySpecReduce_3 27# happyReduction_66 -happyReduction_66 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut31 happy_x_1 of { happy_var_1 -> - case happyOut32 happy_x_3 of { happy_var_3 -> - happyIn31 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_67 = happySpecReduce_1 27# happyReduction_67 -happyReduction_67 happy_x_1 - = case happyOut32 happy_x_1 of { happy_var_1 -> - happyIn31 - ([happy_var_1] - )} - -happyReduce_68 = happySpecReduce_1 28# happyReduction_68 -happyReduction_68 happy_x_1 - = case happyOut171 happy_x_1 of { happy_var_1 -> - happyIn32 - (VarName happy_var_1 - )} - -happyReduce_69 = happySpecReduce_1 28# happyReduction_69 -happyReduction_69 happy_x_1 - = case happyOut175 happy_x_1 of { happy_var_1 -> - happyIn32 - (ConName happy_var_1 - )} - -happyReduce_70 = happyReduce 4# 29# happyReduction_70 -happyReduction_70 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut35 happy_x_2 of { happy_var_2 -> - case happyOut34 happy_x_3 of { happy_var_3 -> - case happyOut36 happy_x_4 of { happy_var_4 -> - happyIn33 - (InfixDecl happy_var_1 happy_var_2 happy_var_3 (reverse happy_var_4) - ) `HappyStk` happyRest}}}} - -happyReduce_71 = happySpecReduce_0 30# happyReduction_71 -happyReduction_71 = happyIn34 - (9 - ) - -happyReduce_72 = happyMonadReduce 1# 30# happyReduction_72 -happyReduction_72 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOutTok happy_x_1 of { (IntTok happy_var_1) -> - ( checkPrec happy_var_1)} - ) (\r -> happyReturn (happyIn34 r)) - -happyReduce_73 = happySpecReduce_1 31# happyReduction_73 -happyReduction_73 happy_x_1 - = happyIn35 - (AssocNone - ) - -happyReduce_74 = happySpecReduce_1 31# happyReduction_74 -happyReduction_74 happy_x_1 - = happyIn35 - (AssocLeft - ) - -happyReduce_75 = happySpecReduce_1 31# happyReduction_75 -happyReduction_75 happy_x_1 - = happyIn35 - (AssocRight - ) - -happyReduce_76 = happySpecReduce_3 32# happyReduction_76 -happyReduction_76 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut36 happy_x_1 of { happy_var_1 -> - case happyOut182 happy_x_3 of { happy_var_3 -> - happyIn36 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_77 = happySpecReduce_1 32# happyReduction_77 -happyReduction_77 happy_x_1 - = case happyOut182 happy_x_1 of { happy_var_1 -> - happyIn36 - ([happy_var_1] - )} - -happyReduce_78 = happyMonadReduce 2# 33# happyReduction_78 -happyReduction_78 (happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut38 happy_x_1 of { happy_var_1 -> - ( checkRevDecls happy_var_1)} - ) (\r -> happyReturn (happyIn37 r)) - -happyReduce_79 = happySpecReduce_3 34# happyReduction_79 -happyReduction_79 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut38 happy_x_1 of { happy_var_1 -> - case happyOut39 happy_x_3 of { happy_var_3 -> - happyIn38 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_80 = happySpecReduce_1 34# happyReduction_80 -happyReduction_80 happy_x_1 - = case happyOut39 happy_x_1 of { happy_var_1 -> - happyIn38 - ([happy_var_1] - )} - -happyReduce_81 = happyMonadReduce 5# 35# happyReduction_81 -happyReduction_81 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut64 happy_x_3 of { happy_var_3 -> - case happyOut70 happy_x_5 of { happy_var_5 -> - ( do { (c,ts) <- checkSimpleType happy_var_3; - return (TypeDecl happy_var_1 c ts happy_var_5) })}}} - ) (\r -> happyReturn (happyIn39 r)) - -happyReduce_82 = happyMonadReduce 5# 35# happyReduction_82 -happyReduction_82 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut65 happy_x_4 of { happy_var_4 -> - case happyOut104 happy_x_5 of { happy_var_5 -> - ( do { (c,ts) <- checkSimpleType happy_var_4; - return (TypeFamDecl happy_var_1 c ts happy_var_5) })}}} - ) (\r -> happyReturn (happyIn39 r)) - -happyReduce_83 = happyMonadReduce 6# 35# happyReduction_83 -happyReduction_83 (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 happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut64 happy_x_4 of { happy_var_4 -> - case happyOut70 happy_x_6 of { happy_var_6 -> - ( do { -- no checkSimpleType happy_var_4 since dtype may contain type patterns - return (TypeInsDecl happy_var_1 happy_var_4 happy_var_6) })}}} - ) (\r -> happyReturn (happyIn39 r)) - -happyReduce_84 = happyMonadReduce 5# 35# happyReduction_84 -happyReduction_84 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut40 happy_x_2 of { happy_var_2 -> - case happyOut70 happy_x_3 of { happy_var_3 -> - case happyOut84 happy_x_4 of { happy_var_4 -> - case happyOut96 happy_x_5 of { happy_var_5 -> - ( do { (cs,c,t) <- checkDataHeader happy_var_3; - checkDataOrNew happy_var_2 happy_var_4; - return (DataDecl happy_var_1 happy_var_2 cs c t (reverse happy_var_4) happy_var_5) })}}}}} - ) (\r -> happyReturn (happyIn39 r)) - -happyReduce_85 = happyMonadReduce 7# 35# happyReduction_85 -happyReduction_85 (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 happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut40 happy_x_2 of { happy_var_2 -> - case happyOut70 happy_x_3 of { happy_var_3 -> - case happyOut104 happy_x_4 of { happy_var_4 -> - case happyOut80 happy_x_6 of { happy_var_6 -> - case happyOut96 happy_x_7 of { happy_var_7 -> - ( do { (cs,c,t) <- checkDataHeader happy_var_3; - checkDataOrNew happy_var_2 happy_var_6; - return (GDataDecl happy_var_1 happy_var_2 cs c t happy_var_4 (reverse happy_var_6) happy_var_7) })}}}}}} - ) (\r -> happyReturn (happyIn39 r)) - -happyReduce_86 = happyMonadReduce 5# 35# happyReduction_86 -happyReduction_86 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut70 happy_x_4 of { happy_var_4 -> - case happyOut104 happy_x_5 of { happy_var_5 -> - ( do { (cs,c,t) <- checkDataHeader happy_var_4; - return (DataFamDecl happy_var_1 cs c t happy_var_5) })}}} - ) (\r -> happyReturn (happyIn39 r)) - -happyReduce_87 = happyMonadReduce 6# 35# happyReduction_87 -happyReduction_87 (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 happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut40 happy_x_2 of { happy_var_2 -> - case happyOut70 happy_x_4 of { happy_var_4 -> - case happyOut84 happy_x_5 of { happy_var_5 -> - case happyOut96 happy_x_6 of { happy_var_6 -> - ( do { -- (cs,c,t) <- checkDataHeader happy_var_4; - checkDataOrNew happy_var_2 happy_var_5; - return (DataInsDecl happy_var_1 happy_var_2 happy_var_4 (reverse happy_var_5) happy_var_6) })}}}}} - ) (\r -> happyReturn (happyIn39 r)) - -happyReduce_88 = happyMonadReduce 8# 35# happyReduction_88 -happyReduction_88 (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 happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut40 happy_x_2 of { happy_var_2 -> - case happyOut70 happy_x_4 of { happy_var_4 -> - case happyOut104 happy_x_5 of { happy_var_5 -> - case happyOut80 happy_x_7 of { happy_var_7 -> - case happyOut96 happy_x_8 of { happy_var_8 -> - ( do { -- (cs,c,t) <- checkDataHeader happy_var_4; - checkDataOrNew happy_var_2 happy_var_7; - return (GDataInsDecl happy_var_1 happy_var_2 happy_var_4 happy_var_5 (reverse happy_var_7) happy_var_8) })}}}}}} - ) (\r -> happyReturn (happyIn39 r)) - -happyReduce_89 = happyMonadReduce 5# 35# happyReduction_89 -happyReduction_89 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut70 happy_x_3 of { happy_var_3 -> - case happyOut77 happy_x_4 of { happy_var_4 -> - case happyOut105 happy_x_5 of { happy_var_5 -> - ( do { (cs,c,vs) <- checkClassHeader happy_var_3; - return (ClassDecl happy_var_1 cs c vs happy_var_4 happy_var_5) })}}}} - ) (\r -> happyReturn (happyIn39 r)) - -happyReduce_90 = happyMonadReduce 4# 35# happyReduction_90 -happyReduction_90 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut70 happy_x_3 of { happy_var_3 -> - case happyOut111 happy_x_4 of { happy_var_4 -> - ( do { (cs,c,ts) <- checkInstHeader happy_var_3; - return (InstDecl happy_var_1 cs c ts happy_var_4) })}}} - ) (\r -> happyReturn (happyIn39 r)) - -happyReduce_91 = happyMonadReduce 4# 35# happyReduction_91 -happyReduction_91 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut70 happy_x_4 of { happy_var_4 -> - ( do { (cs, c, ts) <- checkInstHeader happy_var_4; - return (DerivDecl happy_var_1 cs c ts) })}} - ) (\r -> happyReturn (happyIn39 r)) - -happyReduce_92 = happyReduce 5# 35# happyReduction_92 -happyReduction_92 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut41 happy_x_4 of { happy_var_4 -> - happyIn39 - (DefaultDecl happy_var_1 happy_var_4 - ) `HappyStk` happyRest}} - -happyReduce_93 = happyReduce 4# 35# happyReduction_93 -happyReduction_93 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut123 happy_x_3 of { happy_var_3 -> - happyIn39 - (SpliceDecl happy_var_1 $ ParenSplice happy_var_3 - ) `HappyStk` happyRest}} - -happyReduce_94 = happyReduce 6# 35# happyReduction_94 -happyReduction_94 (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 happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut51 happy_x_4 of { happy_var_4 -> - case happyOut52 happy_x_5 of { happy_var_5 -> - case happyOut53 happy_x_6 of { happy_var_6 -> - happyIn39 - (let (s,n,t) = happy_var_6 in ForImp happy_var_1 happy_var_4 happy_var_5 s n t - ) `HappyStk` happyRest}}}} - -happyReduce_95 = happyReduce 5# 35# happyReduction_95 -happyReduction_95 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut51 happy_x_4 of { happy_var_4 -> - case happyOut53 happy_x_5 of { happy_var_5 -> - happyIn39 - (let (s,n,t) = happy_var_5 in ForExp happy_var_1 happy_var_4 s n t - ) `HappyStk` happyRest}}} - -happyReduce_96 = happyReduce 4# 35# happyReduction_96 -happyReduction_96 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut54 happy_x_3 of { happy_var_3 -> - happyIn39 - (RulePragmaDecl happy_var_1 $ reverse happy_var_3 - ) `HappyStk` happyRest}} - -happyReduce_97 = happyReduce 4# 35# happyReduction_97 -happyReduction_97 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut60 happy_x_3 of { happy_var_3 -> - happyIn39 - (DeprPragmaDecl happy_var_1 $ reverse happy_var_3 - ) `HappyStk` happyRest}} - -happyReduce_98 = happyReduce 4# 35# happyReduction_98 -happyReduction_98 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut60 happy_x_3 of { happy_var_3 -> - happyIn39 - (WarnPragmaDecl happy_var_1 $ reverse happy_var_3 - ) `HappyStk` happyRest}} - -happyReduce_99 = happySpecReduce_3 35# happyReduction_99 -happyReduction_99 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { (PragmaUnknown happy_var_2) -> - happyIn39 - (let (n, s) = happy_var_2 in UnknownDeclPragma happy_var_1 n s - )}} - -happyReduce_100 = happySpecReduce_1 35# happyReduction_100 -happyReduction_100 happy_x_1 - = case happyOut44 happy_x_1 of { happy_var_1 -> - happyIn39 - (happy_var_1 - )} - -happyReduce_101 = happySpecReduce_1 36# happyReduction_101 -happyReduction_101 happy_x_1 - = happyIn40 - (DataType - ) - -happyReduce_102 = happySpecReduce_1 36# happyReduction_102 -happyReduction_102 happy_x_1 - = happyIn40 - (NewType - ) - -happyReduce_103 = happySpecReduce_1 37# happyReduction_103 -happyReduction_103 happy_x_1 - = case happyOut72 happy_x_1 of { happy_var_1 -> - happyIn41 - (reverse happy_var_1 - )} - -happyReduce_104 = happySpecReduce_1 37# happyReduction_104 -happyReduction_104 happy_x_1 - = case happyOut65 happy_x_1 of { happy_var_1 -> - happyIn41 - ([happy_var_1] - )} - -happyReduce_105 = happySpecReduce_0 37# happyReduction_105 -happyReduction_105 = happyIn41 - ([] - ) - -happyReduce_106 = happyMonadReduce 3# 38# happyReduction_106 -happyReduction_106 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut43 happy_x_2 of { happy_var_2 -> - ( checkRevDecls happy_var_2)} - ) (\r -> happyReturn (happyIn42 r)) - -happyReduce_107 = happySpecReduce_1 38# happyReduction_107 -happyReduction_107 happy_x_1 - = happyIn42 - ([] - ) - -happyReduce_108 = happySpecReduce_3 39# happyReduction_108 -happyReduction_108 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut43 happy_x_1 of { happy_var_1 -> - case happyOut44 happy_x_3 of { happy_var_3 -> - happyIn43 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_109 = happySpecReduce_1 39# happyReduction_109 -happyReduction_109 happy_x_1 - = case happyOut44 happy_x_1 of { happy_var_1 -> - happyIn43 - ([happy_var_1] - )} - -happyReduce_110 = happySpecReduce_1 40# happyReduction_110 -happyReduction_110 happy_x_1 - = case happyOut46 happy_x_1 of { happy_var_1 -> - happyIn44 - (happy_var_1 - )} - -happyReduce_111 = happySpecReduce_1 40# happyReduction_111 -happyReduction_111 happy_x_1 - = case happyOut33 happy_x_1 of { happy_var_1 -> - happyIn44 - (happy_var_1 - )} - -happyReduce_112 = happySpecReduce_1 40# happyReduction_112 -happyReduction_112 happy_x_1 - = case happyOut117 happy_x_1 of { happy_var_1 -> - happyIn44 - (happy_var_1 - )} - -happyReduce_113 = happySpecReduce_3 41# happyReduction_113 -happyReduction_113 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut42 happy_x_2 of { happy_var_2 -> - happyIn45 - (happy_var_2 - )} - -happyReduce_114 = happySpecReduce_3 41# happyReduction_114 -happyReduction_114 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut42 happy_x_2 of { happy_var_2 -> - happyIn45 - (happy_var_2 - )} - -happyReduce_115 = happyMonadReduce 4# 42# happyReduction_115 -happyReduction_115 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut127 happy_x_2 of { happy_var_2 -> - case happyOut70 happy_x_4 of { happy_var_4 -> - ( do { v <- checkSigVar happy_var_2; - return $ TypeSig happy_var_1 [v] happy_var_4 })}}} - ) (\r -> happyReturn (happyIn46 r)) - -happyReduce_116 = happyMonadReduce 6# 42# happyReduction_116 -happyReduction_116 (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 happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut127 happy_x_2 of { happy_var_2 -> - case happyOut50 happy_x_4 of { happy_var_4 -> - case happyOut70 happy_x_6 of { happy_var_6 -> - ( do { v <- checkSigVar happy_var_2; - return $ TypeSig happy_var_1 (v : reverse happy_var_4) happy_var_6 })}}}} - ) (\r -> happyReturn (happyIn46 r)) - -happyReduce_117 = happyReduce 5# 42# happyReduction_117 -happyReduction_117 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { (INLINE happy_var_2) -> - case happyOut56 happy_x_3 of { happy_var_3 -> - case happyOut173 happy_x_4 of { happy_var_4 -> - happyIn46 - (InlineSig happy_var_1 happy_var_2 happy_var_3 happy_var_4 - ) `HappyStk` happyRest}}}} - -happyReduce_118 = happyReduce 6# 42# happyReduction_118 -happyReduction_118 (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 happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut173 happy_x_3 of { happy_var_3 -> - case happyOut47 happy_x_5 of { happy_var_5 -> - happyIn46 - (SpecSig happy_var_1 happy_var_3 happy_var_5 - ) `HappyStk` happyRest}}} - -happyReduce_119 = happyReduce 7# 42# happyReduction_119 -happyReduction_119 (happy_x_7 `HappyStk` - happy_x_6 `HappyStk` - happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { (SPECIALISE_INLINE happy_var_2) -> - case happyOut56 happy_x_3 of { happy_var_3 -> - case happyOut173 happy_x_4 of { happy_var_4 -> - case happyOut47 happy_x_6 of { happy_var_6 -> - happyIn46 - (SpecInlineSig happy_var_1 happy_var_2 happy_var_3 happy_var_4 happy_var_6 - ) `HappyStk` happyRest}}}}} - -happyReduce_120 = happyMonadReduce 5# 42# happyReduction_120 -happyReduction_120 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut70 happy_x_4 of { happy_var_4 -> - ( do { (cs,c,ts) <- checkInstHeader happy_var_4; - return $ InstSig happy_var_1 cs c ts })}} - ) (\r -> happyReturn (happyIn46 r)) - -happyReduce_121 = happySpecReduce_1 43# happyReduction_121 -happyReduction_121 happy_x_1 - = case happyOut48 happy_x_1 of { happy_var_1 -> - happyIn47 - ([ happy_var_1 ] - )} - -happyReduce_122 = happySpecReduce_3 43# happyReduction_122 -happyReduction_122 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut48 happy_x_1 of { happy_var_1 -> - case happyOut47 happy_x_3 of { happy_var_3 -> - happyIn47 - (happy_var_1 : happy_var_3 - )}} - -happyReduce_123 = happySpecReduce_1 44# happyReduction_123 -happyReduction_123 happy_x_1 - = case happyOut70 happy_x_1 of { happy_var_1 -> - happyIn48 - (mkTyForall Nothing [] happy_var_1 - )} - -happyReduce_124 = happySpecReduce_1 45# happyReduction_124 -happyReduction_124 happy_x_1 - = case happyOut45 happy_x_1 of { happy_var_1 -> - happyIn49 - (BDecls happy_var_1 - )} - -happyReduce_125 = happySpecReduce_3 45# happyReduction_125 -happyReduction_125 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut167 happy_x_2 of { happy_var_2 -> - happyIn49 - (IPBinds happy_var_2 - )} - -happyReduce_126 = happySpecReduce_3 45# happyReduction_126 -happyReduction_126 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut167 happy_x_2 of { happy_var_2 -> - happyIn49 - (IPBinds happy_var_2 - )} - -happyReduce_127 = happySpecReduce_3 46# happyReduction_127 -happyReduction_127 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut50 happy_x_1 of { happy_var_1 -> - case happyOut171 happy_x_3 of { happy_var_3 -> - happyIn50 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_128 = happyMonadReduce 1# 46# happyReduction_128 -happyReduction_128 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut173 happy_x_1 of { happy_var_1 -> - ( do { n <- checkUnQual happy_var_1; - return [n] })} - ) (\r -> happyReturn (happyIn50 r)) - -happyReduce_129 = happySpecReduce_1 47# happyReduction_129 -happyReduction_129 happy_x_1 - = happyIn51 - (StdCall - ) - -happyReduce_130 = happySpecReduce_1 47# happyReduction_130 -happyReduction_130 happy_x_1 - = happyIn51 - (CCall - ) - -happyReduce_131 = happySpecReduce_1 48# happyReduction_131 -happyReduction_131 happy_x_1 - = happyIn52 - (PlaySafe False - ) - -happyReduce_132 = happySpecReduce_1 48# happyReduction_132 -happyReduction_132 happy_x_1 - = happyIn52 - (PlayRisky - ) - -happyReduce_133 = happySpecReduce_1 48# happyReduction_133 -happyReduction_133 happy_x_1 - = happyIn52 - (PlaySafe True - ) - -happyReduce_134 = happySpecReduce_0 48# happyReduction_134 -happyReduction_134 = happyIn52 - (PlaySafe False - ) - -happyReduce_135 = happyReduce 4# 49# happyReduction_135 -happyReduction_135 (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 happyOut172 happy_x_2 of { happy_var_2 -> - case happyOut64 happy_x_4 of { happy_var_4 -> - happyIn53 - ((happy_var_1, happy_var_2, happy_var_4) - ) `HappyStk` happyRest}}} - -happyReduce_136 = happySpecReduce_3 49# happyReduction_136 -happyReduction_136 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut172 happy_x_1 of { happy_var_1 -> - case happyOut64 happy_x_3 of { happy_var_3 -> - happyIn53 - (("", happy_var_1, happy_var_3) - )}} - -happyReduce_137 = happySpecReduce_3 50# happyReduction_137 -happyReduction_137 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut54 happy_x_1 of { happy_var_1 -> - case happyOut55 happy_x_3 of { happy_var_3 -> - happyIn54 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_138 = happySpecReduce_2 50# happyReduction_138 -happyReduction_138 happy_x_2 - happy_x_1 - = case happyOut54 happy_x_1 of { happy_var_1 -> - happyIn54 - (happy_var_1 - )} - -happyReduce_139 = happySpecReduce_1 50# happyReduction_139 -happyReduction_139 happy_x_1 - = case happyOut55 happy_x_1 of { happy_var_1 -> - happyIn54 - ([happy_var_1] - )} - -happyReduce_140 = happySpecReduce_0 50# happyReduction_140 -happyReduction_140 = happyIn54 - ([] - ) - -happyReduce_141 = happyMonadReduce 6# 51# happyReduction_141 -happyReduction_141 (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 happyOutTok happy_x_1 of { (StringTok happy_var_1) -> - case happyOut56 happy_x_2 of { happy_var_2 -> - case happyOut57 happy_x_3 of { happy_var_3 -> - case happyOut125 happy_x_4 of { happy_var_4 -> - case happyOut123 happy_x_6 of { happy_var_6 -> - ( do { e <- checkRuleExpr happy_var_4; - return $ Rule happy_var_1 happy_var_2 happy_var_3 e happy_var_6 })}}}}} - ) (\r -> happyReturn (happyIn55 r)) - -happyReduce_142 = happySpecReduce_0 52# happyReduction_142 -happyReduction_142 = happyIn56 - (AlwaysActive - ) - -happyReduce_143 = happySpecReduce_3 52# happyReduction_143 -happyReduction_143 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_2 of { (IntTok happy_var_2) -> - happyIn56 - (ActiveFrom (fromInteger happy_var_2) - )} - -happyReduce_144 = happyReduce 4# 52# happyReduction_144 -happyReduction_144 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_3 of { (IntTok happy_var_3) -> - happyIn56 - (ActiveUntil (fromInteger happy_var_3) - ) `HappyStk` happyRest} - -happyReduce_145 = happySpecReduce_0 53# happyReduction_145 -happyReduction_145 = happyIn57 - (Nothing - ) - -happyReduce_146 = happySpecReduce_3 53# happyReduction_146 -happyReduction_146 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut58 happy_x_2 of { happy_var_2 -> - happyIn57 - (Just happy_var_2 - )} - -happyReduce_147 = happySpecReduce_1 54# happyReduction_147 -happyReduction_147 happy_x_1 - = case happyOut59 happy_x_1 of { happy_var_1 -> - happyIn58 - ([happy_var_1] - )} - -happyReduce_148 = happySpecReduce_2 54# happyReduction_148 -happyReduction_148 happy_x_2 - happy_x_1 - = case happyOut59 happy_x_1 of { happy_var_1 -> - case happyOut58 happy_x_2 of { happy_var_2 -> - happyIn58 - (happy_var_1 : happy_var_2 - )}} - -happyReduce_149 = happySpecReduce_1 55# happyReduction_149 -happyReduction_149 happy_x_1 - = case happyOut188 happy_x_1 of { happy_var_1 -> - happyIn59 - (RuleVar happy_var_1 - )} - -happyReduce_150 = happyReduce 5# 55# happyReduction_150 -happyReduction_150 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut188 happy_x_2 of { happy_var_2 -> - case happyOut70 happy_x_4 of { happy_var_4 -> - happyIn59 - (TypedRuleVar happy_var_2 happy_var_4 - ) `HappyStk` happyRest}} - -happyReduce_151 = happySpecReduce_3 56# happyReduction_151 -happyReduction_151 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut60 happy_x_1 of { happy_var_1 -> - case happyOut61 happy_x_3 of { happy_var_3 -> - happyIn60 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_152 = happySpecReduce_2 56# happyReduction_152 -happyReduction_152 happy_x_2 - happy_x_1 - = case happyOut60 happy_x_1 of { happy_var_1 -> - happyIn60 - (happy_var_1 - )} - -happyReduce_153 = happySpecReduce_1 56# happyReduction_153 -happyReduction_153 happy_x_1 - = case happyOut61 happy_x_1 of { happy_var_1 -> - happyIn60 - ([happy_var_1] - )} - -happyReduce_154 = happySpecReduce_0 56# happyReduction_154 -happyReduction_154 = happyIn60 - ([] - ) - -happyReduce_155 = happySpecReduce_2 57# happyReduction_155 -happyReduction_155 happy_x_2 - happy_x_1 - = case happyOut62 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { (StringTok happy_var_2) -> - happyIn61 - ((happy_var_1,happy_var_2) - )}} - -happyReduce_156 = happySpecReduce_1 58# happyReduction_156 -happyReduction_156 happy_x_1 - = case happyOut63 happy_x_1 of { happy_var_1 -> - happyIn62 - ([happy_var_1] - )} - -happyReduce_157 = happySpecReduce_3 58# happyReduction_157 -happyReduction_157 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut63 happy_x_1 of { happy_var_1 -> - case happyOut62 happy_x_3 of { happy_var_3 -> - happyIn62 - (happy_var_1 : happy_var_3 - )}} - -happyReduce_158 = happySpecReduce_1 59# happyReduction_158 -happyReduction_158 happy_x_1 - = case happyOut175 happy_x_1 of { happy_var_1 -> - happyIn63 - (happy_var_1 - )} - -happyReduce_159 = happySpecReduce_1 59# happyReduction_159 -happyReduction_159 happy_x_1 - = case happyOut171 happy_x_1 of { happy_var_1 -> - happyIn63 - (happy_var_1 - )} - -happyReduce_160 = happySpecReduce_1 60# happyReduction_160 -happyReduction_160 happy_x_1 - = case happyOut66 happy_x_1 of { happy_var_1 -> - happyIn64 - (happy_var_1 - )} - -happyReduce_161 = happySpecReduce_3 60# happyReduction_161 -happyReduction_161 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut66 happy_x_1 of { happy_var_1 -> - case happyOut69 happy_x_2 of { happy_var_2 -> - case happyOut64 happy_x_3 of { happy_var_3 -> - happyIn64 - (TyInfix happy_var_1 happy_var_2 happy_var_3 - )}}} - -happyReduce_162 = happySpecReduce_3 60# happyReduction_162 -happyReduction_162 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut66 happy_x_1 of { happy_var_1 -> - case happyOut207 happy_x_2 of { happy_var_2 -> - case happyOut64 happy_x_3 of { happy_var_3 -> - happyIn64 - (TyInfix happy_var_1 happy_var_2 happy_var_3 - )}}} - -happyReduce_163 = happySpecReduce_3 60# happyReduction_163 -happyReduction_163 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut66 happy_x_1 of { happy_var_1 -> - case happyOut64 happy_x_3 of { happy_var_3 -> - happyIn64 - (TyFun happy_var_1 happy_var_3 - )}} - -happyReduce_164 = happySpecReduce_3 60# happyReduction_164 -happyReduction_164 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut66 happy_x_1 of { happy_var_1 -> - case happyOut66 happy_x_3 of { happy_var_3 -> - happyIn64 - (TyPred $ EqualP happy_var_1 happy_var_3 - )}} - -happyReduce_165 = happySpecReduce_3 61# happyReduction_165 -happyReduction_165 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut174 happy_x_1 of { happy_var_1 -> - case happyOut64 happy_x_3 of { happy_var_3 -> - happyIn65 - (TyPred $ IParam happy_var_1 happy_var_3 - )}} - -happyReduce_166 = happySpecReduce_1 61# happyReduction_166 -happyReduction_166 happy_x_1 - = case happyOut64 happy_x_1 of { happy_var_1 -> - happyIn65 - (happy_var_1 - )} - -happyReduce_167 = happySpecReduce_2 62# happyReduction_167 -happyReduction_167 happy_x_2 - happy_x_1 - = case happyOut66 happy_x_1 of { happy_var_1 -> - case happyOut67 happy_x_2 of { happy_var_2 -> - happyIn66 - (TyApp happy_var_1 happy_var_2 - )}} - -happyReduce_168 = happySpecReduce_1 62# happyReduction_168 -happyReduction_168 happy_x_1 - = case happyOut67 happy_x_1 of { happy_var_1 -> - happyIn66 - (happy_var_1 - )} - -happyReduce_169 = happySpecReduce_1 63# happyReduction_169 -happyReduction_169 happy_x_1 - = case happyOut68 happy_x_1 of { happy_var_1 -> - happyIn67 - (TyCon happy_var_1 - )} - -happyReduce_170 = happySpecReduce_1 63# happyReduction_170 -happyReduction_170 happy_x_1 - = case happyOut206 happy_x_1 of { happy_var_1 -> - happyIn67 - (TyVar happy_var_1 - )} - -happyReduce_171 = happySpecReduce_3 63# happyReduction_171 -happyReduction_171 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut72 happy_x_2 of { happy_var_2 -> - happyIn67 - (TyTuple Boxed (reverse happy_var_2) - )} - -happyReduce_172 = happySpecReduce_3 63# happyReduction_172 -happyReduction_172 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut73 happy_x_2 of { happy_var_2 -> - happyIn67 - (TyTuple Unboxed (reverse happy_var_2) - )} - -happyReduce_173 = happySpecReduce_3 63# happyReduction_173 -happyReduction_173 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut65 happy_x_2 of { happy_var_2 -> - happyIn67 - (TyApp list_tycon happy_var_2 - )} - -happyReduce_174 = happySpecReduce_3 63# happyReduction_174 -happyReduction_174 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut70 happy_x_2 of { happy_var_2 -> - happyIn67 - (happy_var_2 - )} - -happyReduce_175 = happyReduce 5# 63# happyReduction_175 -happyReduction_175 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut70 happy_x_2 of { happy_var_2 -> - case happyOut102 happy_x_4 of { happy_var_4 -> - happyIn67 - (TyKind happy_var_2 happy_var_4 - ) `HappyStk` happyRest}} - -happyReduce_176 = happySpecReduce_1 64# happyReduction_176 -happyReduction_176 happy_x_1 - = case happyOut190 happy_x_1 of { happy_var_1 -> - happyIn68 - (happy_var_1 - )} - -happyReduce_177 = happySpecReduce_2 64# happyReduction_177 -happyReduction_177 happy_x_2 - happy_x_1 - = happyIn68 - (unit_tycon_name - ) - -happyReduce_178 = happySpecReduce_3 64# happyReduction_178 -happyReduction_178 happy_x_3 - happy_x_2 - happy_x_1 - = happyIn68 - (fun_tycon_name - ) - -happyReduce_179 = happySpecReduce_2 64# happyReduction_179 -happyReduction_179 happy_x_2 - happy_x_1 - = happyIn68 - (list_tycon_name - ) - -happyReduce_180 = happySpecReduce_3 64# happyReduction_180 -happyReduction_180 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut137 happy_x_2 of { happy_var_2 -> - happyIn68 - (tuple_tycon_name happy_var_2 - )} - -happyReduce_181 = happySpecReduce_1 65# happyReduction_181 -happyReduction_181 happy_x_1 - = case happyOut181 happy_x_1 of { happy_var_1 -> - happyIn69 - (happy_var_1 - )} - -happyReduce_182 = happyReduce 4# 66# happyReduction_182 -happyReduction_182 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut74 happy_x_2 of { happy_var_2 -> - case happyOut70 happy_x_4 of { happy_var_4 -> - happyIn70 - (mkTyForall (Just happy_var_2) [] happy_var_4 - ) `HappyStk` happyRest}} - -happyReduce_183 = happySpecReduce_3 66# happyReduction_183 -happyReduction_183 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut71 happy_x_1 of { happy_var_1 -> - case happyOut65 happy_x_3 of { happy_var_3 -> - happyIn70 - (mkTyForall Nothing happy_var_1 happy_var_3 - )}} - -happyReduce_184 = happySpecReduce_1 66# happyReduction_184 -happyReduction_184 happy_x_1 - = case happyOut65 happy_x_1 of { happy_var_1 -> - happyIn70 - (happy_var_1 - )} - -happyReduce_185 = happyMonadReduce 1# 67# happyReduction_185 -happyReduction_185 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut66 happy_x_1 of { happy_var_1 -> - ( checkContext happy_var_1)} - ) (\r -> happyReturn (happyIn71 r)) - -happyReduce_186 = happyMonadReduce 3# 67# happyReduction_186 -happyReduction_186 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut66 happy_x_1 of { happy_var_1 -> - case happyOut66 happy_x_3 of { happy_var_3 -> - ( checkContext (TyPred $ EqualP happy_var_1 happy_var_3))}} - ) (\r -> happyReturn (happyIn71 r)) - -happyReduce_187 = happySpecReduce_3 68# happyReduction_187 -happyReduction_187 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut73 happy_x_1 of { happy_var_1 -> - case happyOut65 happy_x_3 of { happy_var_3 -> - happyIn72 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_188 = happySpecReduce_1 69# happyReduction_188 -happyReduction_188 happy_x_1 - = case happyOut65 happy_x_1 of { happy_var_1 -> - happyIn73 - ([happy_var_1] - )} - -happyReduce_189 = happySpecReduce_3 69# happyReduction_189 -happyReduction_189 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut73 happy_x_1 of { happy_var_1 -> - case happyOut65 happy_x_3 of { happy_var_3 -> - happyIn73 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_190 = happySpecReduce_2 70# happyReduction_190 -happyReduction_190 happy_x_2 - happy_x_1 - = case happyOut74 happy_x_1 of { happy_var_1 -> - case happyOut75 happy_x_2 of { happy_var_2 -> - happyIn74 - (happy_var_2 : happy_var_1 - )}} - -happyReduce_191 = happySpecReduce_0 70# happyReduction_191 -happyReduction_191 = happyIn74 - ([] - ) - -happyReduce_192 = happySpecReduce_1 71# happyReduction_192 -happyReduction_192 happy_x_1 - = case happyOut206 happy_x_1 of { happy_var_1 -> - happyIn75 - (UnkindedVar happy_var_1 - )} - -happyReduce_193 = happyReduce 5# 71# happyReduction_193 -happyReduction_193 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut206 happy_x_2 of { happy_var_2 -> - case happyOut102 happy_x_4 of { happy_var_4 -> - happyIn75 - (KindedVar happy_var_2 happy_var_4 - ) `HappyStk` happyRest}} - -happyReduce_194 = happySpecReduce_2 72# happyReduction_194 -happyReduction_194 happy_x_2 - happy_x_1 - = case happyOut76 happy_x_1 of { happy_var_1 -> - case happyOut206 happy_x_2 of { happy_var_2 -> - happyIn76 - (happy_var_2 : happy_var_1 - )}} - -happyReduce_195 = happySpecReduce_0 72# happyReduction_195 -happyReduction_195 = happyIn76 - ([] - ) - -happyReduce_196 = happySpecReduce_0 73# happyReduction_196 -happyReduction_196 = happyIn77 - ([] - ) - -happyReduce_197 = happySpecReduce_2 73# happyReduction_197 -happyReduction_197 happy_x_2 - happy_x_1 - = case happyOut78 happy_x_2 of { happy_var_2 -> - happyIn77 - (reverse happy_var_2 - )} - -happyReduce_198 = happySpecReduce_3 74# happyReduction_198 -happyReduction_198 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut78 happy_x_1 of { happy_var_1 -> - case happyOut79 happy_x_3 of { happy_var_3 -> - happyIn78 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_199 = happySpecReduce_1 74# happyReduction_199 -happyReduction_199 happy_x_1 - = case happyOut79 happy_x_1 of { happy_var_1 -> - happyIn78 - ([happy_var_1] - )} - -happyReduce_200 = happySpecReduce_3 75# happyReduction_200 -happyReduction_200 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut76 happy_x_1 of { happy_var_1 -> - case happyOut76 happy_x_3 of { happy_var_3 -> - happyIn79 - (FunDep (reverse happy_var_1) (reverse happy_var_3) - )}} - -happyReduce_201 = happySpecReduce_3 76# happyReduction_201 -happyReduction_201 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut81 happy_x_2 of { happy_var_2 -> - happyIn80 - (happy_var_2 - )} - -happyReduce_202 = happySpecReduce_3 76# happyReduction_202 -happyReduction_202 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut81 happy_x_2 of { happy_var_2 -> - happyIn80 - (happy_var_2 - )} - -happyReduce_203 = happySpecReduce_3 77# happyReduction_203 -happyReduction_203 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut82 happy_x_2 of { happy_var_2 -> - happyIn81 - (happy_var_2 - )} - -happyReduce_204 = happySpecReduce_3 78# happyReduction_204 -happyReduction_204 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut82 happy_x_1 of { happy_var_1 -> - case happyOut83 happy_x_3 of { happy_var_3 -> - happyIn82 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_205 = happySpecReduce_1 78# happyReduction_205 -happyReduction_205 happy_x_1 - = case happyOut83 happy_x_1 of { happy_var_1 -> - happyIn82 - ([happy_var_1] - )} - -happyReduce_206 = happyMonadReduce 4# 79# happyReduction_206 -happyReduction_206 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut176 happy_x_2 of { happy_var_2 -> - case happyOut70 happy_x_4 of { happy_var_4 -> - ( do { c <- checkUnQual happy_var_2; - return $ GadtDecl happy_var_1 c happy_var_4 })}}} - ) (\r -> happyReturn (happyIn83 r)) - -happyReduce_207 = happySpecReduce_0 80# happyReduction_207 -happyReduction_207 = happyIn84 - ([] - ) - -happyReduce_208 = happySpecReduce_2 80# happyReduction_208 -happyReduction_208 happy_x_2 - happy_x_1 - = case happyOut85 happy_x_2 of { happy_var_2 -> - happyIn84 - (happy_var_2 - )} - -happyReduce_209 = happySpecReduce_3 81# happyReduction_209 -happyReduction_209 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut85 happy_x_1 of { happy_var_1 -> - case happyOut86 happy_x_3 of { happy_var_3 -> - happyIn85 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_210 = happySpecReduce_1 81# happyReduction_210 -happyReduction_210 happy_x_1 - = case happyOut86 happy_x_1 of { happy_var_1 -> - happyIn85 - ([happy_var_1] - )} - -happyReduce_211 = happyReduce 5# 82# happyReduction_211 -happyReduction_211 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut87 happy_x_2 of { happy_var_2 -> - case happyOut71 happy_x_3 of { happy_var_3 -> - case happyOut88 happy_x_5 of { happy_var_5 -> - happyIn86 - (QualConDecl happy_var_1 happy_var_2 happy_var_3 happy_var_5 - ) `HappyStk` happyRest}}}} - -happyReduce_212 = happySpecReduce_3 82# happyReduction_212 -happyReduction_212 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut87 happy_x_2 of { happy_var_2 -> - case happyOut88 happy_x_3 of { happy_var_3 -> - happyIn86 - (QualConDecl happy_var_1 happy_var_2 [] happy_var_3 - )}}} - -happyReduce_213 = happySpecReduce_3 83# happyReduction_213 -happyReduction_213 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut74 happy_x_2 of { happy_var_2 -> - happyIn87 - (happy_var_2 - )} - -happyReduce_214 = happySpecReduce_0 83# happyReduction_214 -happyReduction_214 = happyIn87 - ([] - ) - -happyReduce_215 = happySpecReduce_1 84# happyReduction_215 -happyReduction_215 happy_x_1 - = case happyOut89 happy_x_1 of { happy_var_1 -> - happyIn88 - (ConDecl (fst happy_var_1) (snd happy_var_1) - )} - -happyReduce_216 = happySpecReduce_3 84# happyReduction_216 -happyReduction_216 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut92 happy_x_1 of { happy_var_1 -> - case happyOut180 happy_x_2 of { happy_var_2 -> - case happyOut92 happy_x_3 of { happy_var_3 -> - happyIn88 - (ConDecl happy_var_2 [happy_var_1,happy_var_3] - )}}} - -happyReduce_217 = happySpecReduce_3 84# happyReduction_217 -happyReduction_217 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut175 happy_x_1 of { happy_var_1 -> - happyIn88 - (RecDecl happy_var_1 [] - )} - -happyReduce_218 = happyReduce 4# 84# happyReduction_218 -happyReduction_218 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut175 happy_x_1 of { happy_var_1 -> - case happyOut93 happy_x_3 of { happy_var_3 -> - happyIn88 - (RecDecl happy_var_1 (reverse happy_var_3) - ) `HappyStk` happyRest}} - -happyReduce_219 = happyMonadReduce 1# 85# happyReduction_219 -happyReduction_219 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut66 happy_x_1 of { happy_var_1 -> - ( do { (c,ts) <- splitTyConApp happy_var_1; - return (c,map UnBangedTy ts) })} - ) (\r -> happyReturn (happyIn89 r)) - -happyReduce_220 = happySpecReduce_1 85# happyReduction_220 -happyReduction_220 happy_x_1 - = case happyOut90 happy_x_1 of { happy_var_1 -> - happyIn89 - (happy_var_1 - )} - -happyReduce_221 = happyMonadReduce 3# 86# happyReduction_221 -happyReduction_221 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut66 happy_x_1 of { happy_var_1 -> - case happyOut67 happy_x_3 of { happy_var_3 -> - ( do { (c,ts) <- splitTyConApp happy_var_1; - return (c,map UnBangedTy ts++ - [BangedTy happy_var_3]) })}} - ) (\r -> happyReturn (happyIn90 r)) - -happyReduce_222 = happyMonadReduce 5# 86# happyReduction_222 -happyReduction_222 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut66 happy_x_1 of { happy_var_1 -> - case happyOut67 happy_x_5 of { happy_var_5 -> - ( do { (c,ts) <- splitTyConApp happy_var_1; - return (c,map UnBangedTy ts++ - [UnpackedTy happy_var_5]) })}} - ) (\r -> happyReturn (happyIn90 r)) - -happyReduce_223 = happySpecReduce_2 86# happyReduction_223 -happyReduction_223 happy_x_2 - happy_x_1 - = case happyOut90 happy_x_1 of { happy_var_1 -> - case happyOut91 happy_x_2 of { happy_var_2 -> - happyIn90 - ((fst happy_var_1, snd happy_var_1 ++ [happy_var_2] ) - )}} - -happyReduce_224 = happySpecReduce_1 87# happyReduction_224 -happyReduction_224 happy_x_1 - = case happyOut67 happy_x_1 of { happy_var_1 -> - happyIn91 - (UnBangedTy happy_var_1 - )} - -happyReduce_225 = happySpecReduce_2 87# happyReduction_225 -happyReduction_225 happy_x_2 - happy_x_1 - = case happyOut67 happy_x_2 of { happy_var_2 -> - happyIn91 - (BangedTy happy_var_2 - )} - -happyReduce_226 = happyReduce 4# 87# happyReduction_226 -happyReduction_226 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut67 happy_x_4 of { happy_var_4 -> - happyIn91 - (UnpackedTy happy_var_4 - ) `HappyStk` happyRest} - -happyReduce_227 = happySpecReduce_1 88# happyReduction_227 -happyReduction_227 happy_x_1 - = case happyOut66 happy_x_1 of { happy_var_1 -> - happyIn92 - (UnBangedTy happy_var_1 - )} - -happyReduce_228 = happySpecReduce_2 88# happyReduction_228 -happyReduction_228 happy_x_2 - happy_x_1 - = case happyOut67 happy_x_2 of { happy_var_2 -> - happyIn92 - (BangedTy happy_var_2 - )} - -happyReduce_229 = happyReduce 4# 88# happyReduction_229 -happyReduction_229 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut67 happy_x_4 of { happy_var_4 -> - happyIn92 - (UnpackedTy happy_var_4 - ) `HappyStk` happyRest} - -happyReduce_230 = happySpecReduce_3 89# happyReduction_230 -happyReduction_230 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut93 happy_x_1 of { happy_var_1 -> - case happyOut94 happy_x_3 of { happy_var_3 -> - happyIn93 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_231 = happySpecReduce_1 89# happyReduction_231 -happyReduction_231 happy_x_1 - = case happyOut94 happy_x_1 of { happy_var_1 -> - happyIn93 - ([happy_var_1] - )} - -happyReduce_232 = happySpecReduce_3 90# happyReduction_232 -happyReduction_232 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut50 happy_x_1 of { happy_var_1 -> - case happyOut95 happy_x_3 of { happy_var_3 -> - happyIn94 - ((reverse happy_var_1, happy_var_3) - )}} - -happyReduce_233 = happySpecReduce_1 91# happyReduction_233 -happyReduction_233 happy_x_1 - = case happyOut70 happy_x_1 of { happy_var_1 -> - happyIn95 - (UnBangedTy happy_var_1 - )} - -happyReduce_234 = happySpecReduce_2 91# happyReduction_234 -happyReduction_234 happy_x_2 - happy_x_1 - = case happyOut67 happy_x_2 of { happy_var_2 -> - happyIn95 - (BangedTy happy_var_2 - )} - -happyReduce_235 = happyReduce 4# 91# happyReduction_235 -happyReduction_235 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut67 happy_x_4 of { happy_var_4 -> - happyIn95 - (UnpackedTy happy_var_4 - ) `HappyStk` happyRest} - -happyReduce_236 = happySpecReduce_0 92# happyReduction_236 -happyReduction_236 = happyIn96 - ([] - ) - -happyReduce_237 = happySpecReduce_2 92# happyReduction_237 -happyReduction_237 happy_x_2 - happy_x_1 - = case happyOut101 happy_x_2 of { happy_var_2 -> - happyIn96 - ([(happy_var_2, [])] - )} - -happyReduce_238 = happySpecReduce_3 92# happyReduction_238 -happyReduction_238 happy_x_3 - happy_x_2 - happy_x_1 - = happyIn96 - ([] - ) - -happyReduce_239 = happyReduce 4# 92# happyReduction_239 -happyReduction_239 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut97 happy_x_3 of { happy_var_3 -> - happyIn96 - (reverse happy_var_3 - ) `HappyStk` happyRest} - -happyReduce_240 = happySpecReduce_3 93# happyReduction_240 -happyReduction_240 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut97 happy_x_1 of { happy_var_1 -> - case happyOut98 happy_x_3 of { happy_var_3 -> - happyIn97 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_241 = happySpecReduce_1 93# happyReduction_241 -happyReduction_241 happy_x_1 - = case happyOut98 happy_x_1 of { happy_var_1 -> - happyIn97 - ([happy_var_1] - )} - -happyReduce_242 = happySpecReduce_1 94# happyReduction_242 -happyReduction_242 happy_x_1 - = case happyOut101 happy_x_1 of { happy_var_1 -> - happyIn98 - ((happy_var_1, []) - )} - -happyReduce_243 = happySpecReduce_2 94# happyReduction_243 -happyReduction_243 happy_x_2 - happy_x_1 - = case happyOut190 happy_x_1 of { happy_var_1 -> - case happyOut99 happy_x_2 of { happy_var_2 -> - happyIn98 - ((happy_var_1, reverse happy_var_2) - )}} - -happyReduce_244 = happySpecReduce_2 95# happyReduction_244 -happyReduction_244 happy_x_2 - happy_x_1 - = case happyOut99 happy_x_1 of { happy_var_1 -> - case happyOut100 happy_x_2 of { happy_var_2 -> - happyIn99 - (happy_var_2 : happy_var_1 - )}} - -happyReduce_245 = happySpecReduce_1 95# happyReduction_245 -happyReduction_245 happy_x_1 - = case happyOut100 happy_x_1 of { happy_var_1 -> - happyIn99 - ([happy_var_1] - )} - -happyReduce_246 = happySpecReduce_1 96# happyReduction_246 -happyReduction_246 happy_x_1 - = case happyOut190 happy_x_1 of { happy_var_1 -> - happyIn100 - (happy_var_1 - )} - -happyReduce_247 = happySpecReduce_1 96# happyReduction_247 -happyReduction_247 happy_x_1 - = case happyOut186 happy_x_1 of { happy_var_1 -> - happyIn100 - (happy_var_1 - )} - -happyReduce_248 = happySpecReduce_1 97# happyReduction_248 -happyReduction_248 happy_x_1 - = case happyOut190 happy_x_1 of { happy_var_1 -> - happyIn101 - (happy_var_1 - )} - -happyReduce_249 = happySpecReduce_1 98# happyReduction_249 -happyReduction_249 happy_x_1 - = case happyOut103 happy_x_1 of { happy_var_1 -> - happyIn102 - (happy_var_1 - )} - -happyReduce_250 = happySpecReduce_3 98# happyReduction_250 -happyReduction_250 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut103 happy_x_1 of { happy_var_1 -> - case happyOut102 happy_x_3 of { happy_var_3 -> - happyIn102 - (KindFn happy_var_1 happy_var_3 - )}} - -happyReduce_251 = happySpecReduce_1 99# happyReduction_251 -happyReduction_251 happy_x_1 - = happyIn103 - (KindStar - ) - -happyReduce_252 = happySpecReduce_1 99# happyReduction_252 -happyReduction_252 happy_x_1 - = happyIn103 - (KindBang - ) - -happyReduce_253 = happySpecReduce_3 99# happyReduction_253 -happyReduction_253 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut102 happy_x_2 of { happy_var_2 -> - happyIn103 - (happy_var_2 - )} - -happyReduce_254 = happySpecReduce_0 100# happyReduction_254 -happyReduction_254 = happyIn104 - (Nothing - ) - -happyReduce_255 = happySpecReduce_2 100# happyReduction_255 -happyReduction_255 happy_x_2 - happy_x_1 - = case happyOut102 happy_x_2 of { happy_var_2 -> - happyIn104 - (Just happy_var_2 - )} - -happyReduce_256 = happyMonadReduce 2# 101# happyReduction_256 -happyReduction_256 (happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut106 happy_x_2 of { happy_var_2 -> - ( checkClassBody happy_var_2)} - ) (\r -> happyReturn (happyIn105 r)) - -happyReduce_257 = happySpecReduce_0 101# happyReduction_257 -happyReduction_257 = happyIn105 - ([] - ) - -happyReduce_258 = happySpecReduce_3 102# happyReduction_258 -happyReduction_258 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut107 happy_x_2 of { happy_var_2 -> - happyIn106 - (happy_var_2 - )} - -happyReduce_259 = happySpecReduce_3 102# happyReduction_259 -happyReduction_259 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut107 happy_x_2 of { happy_var_2 -> - happyIn106 - (happy_var_2 - )} - -happyReduce_260 = happyMonadReduce 3# 103# happyReduction_260 -happyReduction_260 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut108 happy_x_2 of { happy_var_2 -> - ( checkRevClsDecls happy_var_2)} - ) (\r -> happyReturn (happyIn107 r)) - -happyReduce_261 = happySpecReduce_1 103# happyReduction_261 -happyReduction_261 happy_x_1 - = happyIn107 - ([] - ) - -happyReduce_262 = happySpecReduce_3 104# happyReduction_262 -happyReduction_262 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut108 happy_x_1 of { happy_var_1 -> - case happyOut109 happy_x_3 of { happy_var_3 -> - happyIn108 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_263 = happySpecReduce_1 104# happyReduction_263 -happyReduction_263 happy_x_1 - = case happyOut109 happy_x_1 of { happy_var_1 -> - happyIn108 - ([happy_var_1] - )} - -happyReduce_264 = happySpecReduce_1 105# happyReduction_264 -happyReduction_264 happy_x_1 - = case happyOut44 happy_x_1 of { happy_var_1 -> - happyIn109 - (ClsDecl happy_var_1 - )} - -happyReduce_265 = happySpecReduce_1 105# happyReduction_265 -happyReduction_265 happy_x_1 - = case happyOut110 happy_x_1 of { happy_var_1 -> - happyIn109 - (happy_var_1 - )} - -happyReduce_266 = happyMonadReduce 4# 106# happyReduction_266 -happyReduction_266 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut65 happy_x_3 of { happy_var_3 -> - case happyOut104 happy_x_4 of { happy_var_4 -> - ( do { (c,ts) <- checkSimpleType happy_var_3; - return (ClsTyFam happy_var_1 c ts happy_var_4) })}}} - ) (\r -> happyReturn (happyIn110 r)) - -happyReduce_267 = happyReduce 5# 106# happyReduction_267 -happyReduction_267 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut64 happy_x_3 of { happy_var_3 -> - case happyOut70 happy_x_5 of { happy_var_5 -> - happyIn110 - (ClsTyDef happy_var_1 happy_var_3 happy_var_5 - ) `HappyStk` happyRest}}} - -happyReduce_268 = happyMonadReduce 4# 106# happyReduction_268 -happyReduction_268 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut70 happy_x_3 of { happy_var_3 -> - case happyOut104 happy_x_4 of { happy_var_4 -> - ( do { (cs,c,t) <- checkDataHeader happy_var_3; - return (ClsDataFam happy_var_1 cs c t happy_var_4) })}}} - ) (\r -> happyReturn (happyIn110 r)) - -happyReduce_269 = happyMonadReduce 4# 107# happyReduction_269 -happyReduction_269 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut112 happy_x_3 of { happy_var_3 -> - ( checkInstBody happy_var_3)} - ) (\r -> happyReturn (happyIn111 r)) - -happyReduce_270 = happyMonadReduce 4# 107# happyReduction_270 -happyReduction_270 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut112 happy_x_3 of { happy_var_3 -> - ( checkInstBody happy_var_3)} - ) (\r -> happyReturn (happyIn111 r)) - -happyReduce_271 = happySpecReduce_0 107# happyReduction_271 -happyReduction_271 = happyIn111 - ([] - ) - -happyReduce_272 = happyMonadReduce 3# 108# happyReduction_272 -happyReduction_272 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut113 happy_x_2 of { happy_var_2 -> - ( checkRevInstDecls happy_var_2)} - ) (\r -> happyReturn (happyIn112 r)) - -happyReduce_273 = happySpecReduce_1 108# happyReduction_273 -happyReduction_273 happy_x_1 - = happyIn112 - ([] - ) - -happyReduce_274 = happySpecReduce_3 109# happyReduction_274 -happyReduction_274 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut113 happy_x_1 of { happy_var_1 -> - case happyOut114 happy_x_3 of { happy_var_3 -> - happyIn113 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_275 = happySpecReduce_1 109# happyReduction_275 -happyReduction_275 happy_x_1 - = case happyOut114 happy_x_1 of { happy_var_1 -> - happyIn113 - ([happy_var_1] - )} - -happyReduce_276 = happySpecReduce_1 110# happyReduction_276 -happyReduction_276 happy_x_1 - = case happyOut117 happy_x_1 of { happy_var_1 -> - happyIn114 - (InsDecl happy_var_1 - )} - -happyReduce_277 = happySpecReduce_1 110# happyReduction_277 -happyReduction_277 happy_x_1 - = case happyOut116 happy_x_1 of { happy_var_1 -> - happyIn114 - (happy_var_1 - )} - -happyReduce_278 = happySpecReduce_1 110# happyReduction_278 -happyReduction_278 happy_x_1 - = case happyOut115 happy_x_1 of { happy_var_1 -> - happyIn114 - (happy_var_1 - )} - -happyReduce_279 = happyReduce 5# 111# happyReduction_279 -happyReduction_279 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { (INLINE happy_var_2) -> - case happyOut56 happy_x_3 of { happy_var_3 -> - case happyOut173 happy_x_4 of { happy_var_4 -> - happyIn115 - (InsInline happy_var_1 happy_var_2 happy_var_3 happy_var_4 - ) `HappyStk` happyRest}}}} - -happyReduce_280 = happyMonadReduce 5# 112# happyReduction_280 -happyReduction_280 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut64 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { happy_var_4 -> - case happyOut70 happy_x_5 of { happy_var_5 -> - ( do { -- no checkSimpleType happy_var_4 since dtype may contain type patterns - return (InsType happy_var_1 happy_var_3 happy_var_5) })}}}} - ) (\r -> happyReturn (happyIn116 r)) - -happyReduce_281 = happyMonadReduce 5# 112# happyReduction_281 -happyReduction_281 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut40 happy_x_2 of { happy_var_2 -> - case happyOut70 happy_x_3 of { happy_var_3 -> - case happyOut84 happy_x_4 of { happy_var_4 -> - case happyOut96 happy_x_5 of { happy_var_5 -> - ( do { -- (cs,c,t) <- checkDataHeader happy_var_4; - checkDataOrNew happy_var_2 happy_var_4; - return (InsData happy_var_1 happy_var_2 happy_var_3 (reverse happy_var_4) happy_var_5) })}}}}} - ) (\r -> happyReturn (happyIn116 r)) - -happyReduce_282 = happyMonadReduce 7# 112# happyReduction_282 -happyReduction_282 (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 happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut40 happy_x_2 of { happy_var_2 -> - case happyOut70 happy_x_3 of { happy_var_3 -> - case happyOut104 happy_x_4 of { happy_var_4 -> - case happyOut80 happy_x_6 of { happy_var_6 -> - case happyOut96 happy_x_7 of { happy_var_7 -> - ( do { -- (cs,c,t) <- checkDataHeader happy_var_4; - checkDataOrNew happy_var_2 happy_var_6; - return (InsGData happy_var_1 happy_var_2 happy_var_3 happy_var_4 (reverse happy_var_6) happy_var_7) })}}}}}} - ) (\r -> happyReturn (happyIn116 r)) - -happyReduce_283 = happyMonadReduce 5# 113# happyReduction_283 -happyReduction_283 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut127 happy_x_2 of { happy_var_2 -> - case happyOut119 happy_x_3 of { happy_var_3 -> - case happyOut120 happy_x_4 of { happy_var_4 -> - case happyOut118 happy_x_5 of { happy_var_5 -> - ( checkValDef happy_var_1 happy_var_2 happy_var_3 happy_var_4 happy_var_5)}}}}} - ) (\r -> happyReturn (happyIn117 r)) - -happyReduce_284 = happySpecReduce_2 114# happyReduction_284 -happyReduction_284 happy_x_2 - happy_x_1 - = case happyOut49 happy_x_2 of { happy_var_2 -> - happyIn118 - (happy_var_2 - )} - -happyReduce_285 = happySpecReduce_0 114# happyReduction_285 -happyReduction_285 = happyIn118 - (BDecls [] - ) - -happyReduce_286 = happySpecReduce_2 115# happyReduction_286 -happyReduction_286 happy_x_2 - happy_x_1 - = case happyOut70 happy_x_2 of { happy_var_2 -> - happyIn119 - (Just happy_var_2 - )} - -happyReduce_287 = happySpecReduce_0 115# happyReduction_287 -happyReduction_287 = happyIn119 - (Nothing - ) - -happyReduce_288 = happySpecReduce_2 116# happyReduction_288 -happyReduction_288 happy_x_2 - happy_x_1 - = case happyOut123 happy_x_2 of { happy_var_2 -> - happyIn120 - (UnGuardedRhs happy_var_2 - )} - -happyReduce_289 = happySpecReduce_1 116# happyReduction_289 -happyReduction_289 happy_x_1 - = case happyOut121 happy_x_1 of { happy_var_1 -> - happyIn120 - (GuardedRhss (reverse happy_var_1) - )} - -happyReduce_290 = happySpecReduce_2 117# happyReduction_290 -happyReduction_290 happy_x_2 - happy_x_1 - = case happyOut121 happy_x_1 of { happy_var_1 -> - case happyOut122 happy_x_2 of { happy_var_2 -> - happyIn121 - (happy_var_2 : happy_var_1 - )}} - -happyReduce_291 = happySpecReduce_1 117# happyReduction_291 -happyReduction_291 happy_x_1 - = case happyOut122 happy_x_1 of { happy_var_1 -> - happyIn121 - ([happy_var_1] - )} - -happyReduce_292 = happyReduce 5# 118# 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 happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut153 happy_x_3 of { happy_var_3 -> - case happyOut123 happy_x_5 of { happy_var_5 -> - happyIn122 - (GuardedRhs happy_var_1 (reverse happy_var_3) happy_var_5 - ) `HappyStk` happyRest}}} - -happyReduce_293 = happyMonadReduce 1# 119# happyReduction_293 -happyReduction_293 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut124 happy_x_1 of { happy_var_1 -> - ( checkExpr happy_var_1)} - ) (\r -> happyReturn (happyIn123 r)) - -happyReduce_294 = happyReduce 4# 120# happyReduction_294 -happyReduction_294 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut127 happy_x_1 of { happy_var_1 -> - case happyOut200 happy_x_3 of { happy_var_3 -> - case happyOut70 happy_x_4 of { happy_var_4 -> - happyIn124 - (ExpTypeSig happy_var_3 happy_var_1 happy_var_4 - ) `HappyStk` happyRest}}} - -happyReduce_295 = happySpecReduce_1 120# happyReduction_295 -happyReduction_295 happy_x_1 - = case happyOut125 happy_x_1 of { happy_var_1 -> - happyIn124 - (happy_var_1 - )} - -happyReduce_296 = happySpecReduce_2 120# happyReduction_296 -happyReduction_296 happy_x_2 - happy_x_1 - = case happyOut127 happy_x_1 of { happy_var_1 -> - case happyOut183 happy_x_2 of { happy_var_2 -> - happyIn124 - (PostOp happy_var_1 happy_var_2 - )}} - -happyReduce_297 = happySpecReduce_1 121# happyReduction_297 -happyReduction_297 happy_x_1 - = case happyOut126 happy_x_1 of { happy_var_1 -> - happyIn125 - (happy_var_1 - )} - -happyReduce_298 = happySpecReduce_1 121# happyReduction_298 -happyReduction_298 happy_x_1 - = case happyOut127 happy_x_1 of { happy_var_1 -> - happyIn125 - (happy_var_1 - )} - -happyReduce_299 = happySpecReduce_3 122# happyReduction_299 -happyReduction_299 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut127 happy_x_1 of { happy_var_1 -> - case happyOut183 happy_x_2 of { happy_var_2 -> - case happyOut128 happy_x_3 of { happy_var_3 -> - happyIn126 - (InfixApp happy_var_1 happy_var_2 happy_var_3 - )}}} - -happyReduce_300 = happySpecReduce_1 122# happyReduction_300 -happyReduction_300 happy_x_1 - = case happyOut128 happy_x_1 of { happy_var_1 -> - happyIn126 - (happy_var_1 - )} - -happyReduce_301 = happySpecReduce_3 123# happyReduction_301 -happyReduction_301 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut127 happy_x_1 of { happy_var_1 -> - case happyOut183 happy_x_2 of { happy_var_2 -> - case happyOut129 happy_x_3 of { happy_var_3 -> - happyIn127 - (InfixApp happy_var_1 happy_var_2 happy_var_3 - )}}} - -happyReduce_302 = happySpecReduce_1 123# happyReduction_302 -happyReduction_302 happy_x_1 - = case happyOut129 happy_x_1 of { happy_var_1 -> - happyIn127 - (happy_var_1 - )} - -happyReduce_303 = happyReduce 5# 124# happyReduction_303 -happyReduction_303 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut200 happy_x_2 of { happy_var_2 -> - case happyOut132 happy_x_3 of { happy_var_3 -> - case happyOut124 happy_x_5 of { happy_var_5 -> - happyIn128 - (Lambda happy_var_2 (reverse happy_var_3) happy_var_5 - ) `HappyStk` happyRest}}} - -happyReduce_304 = happyReduce 4# 124# happyReduction_304 -happyReduction_304 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut49 happy_x_2 of { happy_var_2 -> - case happyOut124 happy_x_4 of { happy_var_4 -> - happyIn128 - (Let happy_var_2 happy_var_4 - ) `HappyStk` happyRest}} - -happyReduce_305 = happyReduce 6# 124# happyReduction_305 -happyReduction_305 (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 happyOut124 happy_x_2 of { happy_var_2 -> - case happyOut124 happy_x_4 of { happy_var_4 -> - case happyOut124 happy_x_6 of { happy_var_6 -> - happyIn128 - (If happy_var_2 happy_var_4 happy_var_6 - ) `HappyStk` happyRest}}} - -happyReduce_306 = happyReduce 4# 125# happyReduction_306 -happyReduction_306 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut124 happy_x_2 of { happy_var_2 -> - case happyOut155 happy_x_4 of { happy_var_4 -> - happyIn129 - (Case happy_var_2 happy_var_4 - ) `HappyStk` happyRest}} - -happyReduce_307 = happySpecReduce_2 125# happyReduction_307 -happyReduction_307 happy_x_2 - happy_x_1 - = case happyOut131 happy_x_2 of { happy_var_2 -> - happyIn129 - (NegApp happy_var_2 - )} - -happyReduce_308 = happySpecReduce_2 125# happyReduction_308 -happyReduction_308 happy_x_2 - happy_x_1 - = case happyOut163 happy_x_2 of { happy_var_2 -> - happyIn129 - (Do happy_var_2 - )} - -happyReduce_309 = happySpecReduce_2 125# happyReduction_309 -happyReduction_309 happy_x_2 - happy_x_1 - = case happyOut163 happy_x_2 of { happy_var_2 -> - happyIn129 - (MDo happy_var_2 - )} - -happyReduce_310 = happySpecReduce_1 125# happyReduction_310 -happyReduction_310 happy_x_1 - = case happyOut130 happy_x_1 of { happy_var_1 -> - happyIn129 - (happy_var_1 - )} - -happyReduce_311 = happySpecReduce_1 125# happyReduction_311 -happyReduction_311 happy_x_1 - = case happyOut131 happy_x_1 of { happy_var_1 -> - happyIn129 - (happy_var_1 - )} - -happyReduce_312 = happySpecReduce_3 126# happyReduction_312 -happyReduction_312 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_2 of { (StringTok happy_var_2) -> - happyIn130 - (CorePragma happy_var_2 - )} - -happyReduce_313 = happySpecReduce_3 126# happyReduction_313 -happyReduction_313 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_2 of { (StringTok happy_var_2) -> - happyIn130 - (SCCPragma happy_var_2 - )} - -happyReduce_314 = happyReduce 10# 126# happyReduction_314 -happyReduction_314 (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) - = case happyOutTok happy_x_2 of { (StringTok happy_var_2) -> - case happyOutTok happy_x_3 of { (IntTok happy_var_3) -> - case happyOutTok happy_x_5 of { (IntTok happy_var_5) -> - case happyOutTok happy_x_7 of { (IntTok happy_var_7) -> - case happyOutTok happy_x_9 of { (IntTok happy_var_9) -> - happyIn130 - (GenPragma happy_var_2 (fromInteger happy_var_3, fromInteger happy_var_5) - (fromInteger happy_var_7, fromInteger happy_var_9) - ) `HappyStk` happyRest}}}}} - -happyReduce_315 = happySpecReduce_2 126# happyReduction_315 -happyReduction_315 happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (PragmaUnknown happy_var_1) -> - happyIn130 - (let (n, s) = happy_var_1 in UnknownExpPragma n s - )} - -happyReduce_316 = happySpecReduce_2 127# happyReduction_316 -happyReduction_316 happy_x_2 - happy_x_1 - = case happyOut131 happy_x_1 of { happy_var_1 -> - case happyOut134 happy_x_2 of { happy_var_2 -> - happyIn131 - (App happy_var_1 happy_var_2 - )}} - -happyReduce_317 = happySpecReduce_1 127# happyReduction_317 -happyReduction_317 happy_x_1 - = case happyOut134 happy_x_1 of { happy_var_1 -> - happyIn131 - (happy_var_1 - )} - -happyReduce_318 = happySpecReduce_2 128# happyReduction_318 -happyReduction_318 happy_x_2 - happy_x_1 - = case happyOut132 happy_x_1 of { happy_var_1 -> - case happyOut133 happy_x_2 of { happy_var_2 -> - happyIn132 - (happy_var_2 : happy_var_1 - )}} - -happyReduce_319 = happySpecReduce_1 128# happyReduction_319 -happyReduction_319 happy_x_1 - = case happyOut133 happy_x_1 of { happy_var_1 -> - happyIn132 - ([happy_var_1] - )} - -happyReduce_320 = happyMonadReduce 1# 129# happyReduction_320 -happyReduction_320 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut134 happy_x_1 of { happy_var_1 -> - ( checkPattern happy_var_1)} - ) (\r -> happyReturn (happyIn133 r)) - -happyReduce_321 = happyMonadReduce 3# 130# happyReduction_321 -happyReduction_321 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut173 happy_x_1 of { happy_var_1 -> - case happyOut134 happy_x_3 of { happy_var_3 -> - ( do { n <- checkUnQual happy_var_1; - return (AsPat n happy_var_3) })}} - ) (\r -> happyReturn (happyIn134 r)) - -happyReduce_322 = happyMonadReduce 3# 130# happyReduction_322 -happyReduction_322 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut173 happy_x_1 of { happy_var_1 -> - case happyOut134 happy_x_3 of { happy_var_3 -> - ( do { n <- checkUnQual happy_var_1; - return (CAsRP n happy_var_3) })}} - ) (\r -> happyReturn (happyIn134 r)) - -happyReduce_323 = happySpecReduce_2 130# happyReduction_323 -happyReduction_323 happy_x_2 - happy_x_1 - = case happyOut134 happy_x_2 of { happy_var_2 -> - happyIn134 - (IrrPat happy_var_2 - )} - -happyReduce_324 = happySpecReduce_1 130# happyReduction_324 -happyReduction_324 happy_x_1 - = case happyOut135 happy_x_1 of { happy_var_1 -> - happyIn134 - (happy_var_1 - )} - -happyReduce_325 = happyMonadReduce 3# 131# happyReduction_325 -happyReduction_325 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut135 happy_x_1 of { happy_var_1 -> - ( mkRecConstrOrUpdate happy_var_1 [])} - ) (\r -> happyReturn (happyIn135 r)) - -happyReduce_326 = happyMonadReduce 4# 131# happyReduction_326 -happyReduction_326 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut135 happy_x_1 of { happy_var_1 -> - case happyOut165 happy_x_3 of { happy_var_3 -> - ( mkRecConstrOrUpdate happy_var_1 (reverse happy_var_3))}} - ) (\r -> happyReturn (happyIn135 r)) - -happyReduce_327 = happySpecReduce_1 131# happyReduction_327 -happyReduction_327 happy_x_1 - = case happyOut136 happy_x_1 of { happy_var_1 -> - happyIn135 - (happy_var_1 - )} - -happyReduce_328 = happySpecReduce_1 132# happyReduction_328 -happyReduction_328 happy_x_1 - = case happyOut174 happy_x_1 of { happy_var_1 -> - happyIn136 - (IPVar happy_var_1 - )} - -happyReduce_329 = happySpecReduce_1 132# happyReduction_329 -happyReduction_329 happy_x_1 - = case happyOut173 happy_x_1 of { happy_var_1 -> - happyIn136 - (Var happy_var_1 - )} - -happyReduce_330 = happySpecReduce_1 132# happyReduction_330 -happyReduction_330 happy_x_1 - = case happyOut170 happy_x_1 of { happy_var_1 -> - happyIn136 - (happy_var_1 - )} - -happyReduce_331 = happySpecReduce_1 132# happyReduction_331 -happyReduction_331 happy_x_1 - = case happyOut199 happy_x_1 of { happy_var_1 -> - happyIn136 - (Lit happy_var_1 - )} - -happyReduce_332 = happySpecReduce_3 132# happyReduction_332 -happyReduction_332 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut139 happy_x_2 of { happy_var_2 -> - happyIn136 - (Paren happy_var_2 - )} - -happyReduce_333 = happyReduce 5# 132# happyReduction_333 -happyReduction_333 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut139 happy_x_2 of { happy_var_2 -> - case happyOut138 happy_x_4 of { happy_var_4 -> - happyIn136 - (Tuple (happy_var_2 : reverse happy_var_4) - ) `HappyStk` happyRest}} - -happyReduce_334 = happySpecReduce_3 132# happyReduction_334 -happyReduction_334 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut151 happy_x_2 of { happy_var_2 -> - happyIn136 - (happy_var_2 - )} - -happyReduce_335 = happyReduce 4# 132# happyReduction_335 -happyReduction_335 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut184 happy_x_2 of { happy_var_2 -> - case happyOut125 happy_x_3 of { happy_var_3 -> - happyIn136 - (RightSection happy_var_2 happy_var_3 - ) `HappyStk` happyRest}} - -happyReduce_336 = happySpecReduce_1 132# happyReduction_336 -happyReduction_336 happy_x_1 - = happyIn136 - (WildCard - ) - -happyReduce_337 = happySpecReduce_3 132# happyReduction_337 -happyReduction_337 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut141 happy_x_2 of { happy_var_2 -> - happyIn136 - (happy_var_2 - )} - -happyReduce_338 = happySpecReduce_3 132# happyReduction_338 -happyReduction_338 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut140 happy_x_2 of { happy_var_2 -> - happyIn136 - (SeqRP $ reverse happy_var_2 - )} - -happyReduce_339 = happyReduce 5# 132# happyReduction_339 -happyReduction_339 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut124 happy_x_2 of { happy_var_2 -> - case happyOut153 happy_x_4 of { happy_var_4 -> - happyIn136 - (GuardRP happy_var_2 $ reverse happy_var_4 - ) `HappyStk` happyRest}} - -happyReduce_340 = happySpecReduce_1 132# happyReduction_340 -happyReduction_340 happy_x_1 - = case happyOut150 happy_x_1 of { happy_var_1 -> - happyIn136 - (happy_var_1 - )} - -happyReduce_341 = happySpecReduce_1 132# happyReduction_341 -happyReduction_341 happy_x_1 - = case happyOut142 happy_x_1 of { happy_var_1 -> - happyIn136 - (happy_var_1 - )} - -happyReduce_342 = happySpecReduce_1 132# happyReduction_342 -happyReduction_342 happy_x_1 - = case happyOutTok happy_x_1 of { (THIdEscape happy_var_1) -> - happyIn136 - (SpliceExp $ IdSplice happy_var_1 - )} - -happyReduce_343 = happySpecReduce_3 132# happyReduction_343 -happyReduction_343 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut123 happy_x_2 of { happy_var_2 -> - happyIn136 - (SpliceExp $ ParenSplice happy_var_2 - )} - -happyReduce_344 = happySpecReduce_3 132# happyReduction_344 -happyReduction_344 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut123 happy_x_2 of { happy_var_2 -> - happyIn136 - (BracketExp $ ExpBracket happy_var_2 - )} - -happyReduce_345 = happyMonadReduce 3# 132# happyReduction_345 -happyReduction_345 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut125 happy_x_2 of { happy_var_2 -> - ( do { p <- checkPattern happy_var_2; - return $ BracketExp $ PatBracket p })} - ) (\r -> happyReturn (happyIn136 r)) - -happyReduce_346 = happySpecReduce_3 132# happyReduction_346 -happyReduction_346 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut70 happy_x_2 of { happy_var_2 -> - happyIn136 - (BracketExp $ TypeBracket happy_var_2 - )} - -happyReduce_347 = happyReduce 5# 132# happyReduction_347 -happyReduction_347 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut37 happy_x_3 of { happy_var_3 -> - happyIn136 - (BracketExp $ DeclBracket happy_var_3 - ) `HappyStk` happyRest} - -happyReduce_348 = happySpecReduce_2 132# happyReduction_348 -happyReduction_348 happy_x_2 - happy_x_1 - = case happyOut173 happy_x_2 of { happy_var_2 -> - happyIn136 - (VarQuote happy_var_2 - )} - -happyReduce_349 = happySpecReduce_2 132# happyReduction_349 -happyReduction_349 happy_x_2 - happy_x_1 - = case happyOut176 happy_x_2 of { happy_var_2 -> - happyIn136 - (VarQuote happy_var_2 - )} - -happyReduce_350 = happySpecReduce_2 132# happyReduction_350 -happyReduction_350 happy_x_2 - happy_x_1 - = case happyOut206 happy_x_2 of { happy_var_2 -> - happyIn136 - (TypQuote (UnQual happy_var_2) - )} - -happyReduce_351 = happySpecReduce_2 132# happyReduction_351 -happyReduction_351 happy_x_2 - happy_x_1 - = case happyOut68 happy_x_2 of { happy_var_2 -> - happyIn136 - (TypQuote happy_var_2 - )} - -happyReduce_352 = happySpecReduce_2 133# happyReduction_352 -happyReduction_352 happy_x_2 - happy_x_1 - = case happyOut137 happy_x_1 of { happy_var_1 -> - happyIn137 - (happy_var_1 + 1 - )} - -happyReduce_353 = happySpecReduce_1 133# happyReduction_353 -happyReduction_353 happy_x_1 - = happyIn137 - (1 - ) - -happyReduce_354 = happySpecReduce_3 134# happyReduction_354 -happyReduction_354 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut138 happy_x_1 of { happy_var_1 -> - case happyOut139 happy_x_3 of { happy_var_3 -> - happyIn138 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_355 = happySpecReduce_1 134# happyReduction_355 -happyReduction_355 happy_x_1 - = case happyOut139 happy_x_1 of { happy_var_1 -> - happyIn138 - ([happy_var_1] - )} - -happyReduce_356 = happySpecReduce_1 135# happyReduction_356 -happyReduction_356 happy_x_1 - = case happyOut124 happy_x_1 of { happy_var_1 -> - happyIn139 - (happy_var_1 - )} - -happyReduce_357 = happySpecReduce_3 135# happyReduction_357 -happyReduction_357 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut124 happy_x_1 of { happy_var_1 -> - case happyOut124 happy_x_3 of { happy_var_3 -> - happyIn139 - (ViewPat happy_var_1 happy_var_3 - )}} - -happyReduce_358 = happySpecReduce_3 136# happyReduction_358 -happyReduction_358 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut140 happy_x_1 of { happy_var_1 -> - case happyOut124 happy_x_3 of { happy_var_3 -> - happyIn140 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_359 = happySpecReduce_1 136# happyReduction_359 -happyReduction_359 happy_x_1 - = case happyOut124 happy_x_1 of { happy_var_1 -> - happyIn140 - ([happy_var_1] - )} - -happyReduce_360 = happySpecReduce_3 137# happyReduction_360 -happyReduction_360 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut124 happy_x_1 of { happy_var_1 -> - case happyOut141 happy_x_3 of { happy_var_3 -> - happyIn141 - (EitherRP happy_var_1 happy_var_3 - )}} - -happyReduce_361 = happySpecReduce_3 137# happyReduction_361 -happyReduction_361 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut124 happy_x_1 of { happy_var_1 -> - case happyOut124 happy_x_3 of { happy_var_3 -> - happyIn141 - (EitherRP happy_var_1 happy_var_3 - )}} - -happyReduce_362 = happyMonadReduce 10# 138# happyReduction_362 -happyReduction_362 (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 happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut145 happy_x_3 of { happy_var_3 -> - case happyOut147 happy_x_4 of { happy_var_4 -> - case happyOut149 happy_x_5 of { happy_var_5 -> - case happyOut143 happy_x_7 of { happy_var_7 -> - case happyOut145 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 $ XTag happy_var_1 n as happy_var_5 cn })}}}}}} - ) (\r -> happyReturn (happyIn142 r)) - -happyReduce_363 = happyReduce 6# 138# happyReduction_363 -happyReduction_363 (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 happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut145 happy_x_3 of { happy_var_3 -> - case happyOut147 happy_x_4 of { happy_var_4 -> - case happyOut149 happy_x_5 of { happy_var_5 -> - happyIn142 - (XETag happy_var_1 happy_var_3 (reverse happy_var_4) happy_var_5 - ) `HappyStk` happyRest}}}} - -happyReduce_364 = happySpecReduce_3 138# happyReduction_364 -happyReduction_364 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut124 happy_x_2 of { happy_var_2 -> - happyIn142 - (XExpTag happy_var_2 - )} - -happyReduce_365 = happySpecReduce_2 139# happyReduction_365 -happyReduction_365 happy_x_2 - happy_x_1 - = case happyOut143 happy_x_1 of { happy_var_1 -> - case happyOut144 happy_x_2 of { happy_var_2 -> - happyIn143 - (happy_var_2 : happy_var_1 - )}} - -happyReduce_366 = happySpecReduce_0 139# happyReduction_366 -happyReduction_366 = happyIn143 - ([] - ) - -happyReduce_367 = happySpecReduce_1 140# happyReduction_367 -happyReduction_367 happy_x_1 - = case happyOutTok happy_x_1 of { (XPCDATA happy_var_1) -> - happyIn144 - (XPcdata happy_var_1 - )} - -happyReduce_368 = happySpecReduce_3 140# happyReduction_368 -happyReduction_368 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut140 happy_x_2 of { happy_var_2 -> - happyIn144 - (XRPats $ reverse happy_var_2 - )} - -happyReduce_369 = happySpecReduce_1 140# happyReduction_369 -happyReduction_369 happy_x_1 - = case happyOut142 happy_x_1 of { happy_var_1 -> - happyIn144 - (happy_var_1 - )} - -happyReduce_370 = happySpecReduce_3 141# happyReduction_370 -happyReduction_370 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut146 happy_x_1 of { happy_var_1 -> - case happyOut146 happy_x_3 of { happy_var_3 -> - happyIn145 - (XDomName happy_var_1 happy_var_3 - )}} - -happyReduce_371 = happySpecReduce_1 141# happyReduction_371 -happyReduction_371 happy_x_1 - = case happyOut146 happy_x_1 of { happy_var_1 -> - happyIn145 - (XName happy_var_1 - )} - -happyReduce_372 = happySpecReduce_1 142# happyReduction_372 -happyReduction_372 happy_x_1 - = case happyOutTok happy_x_1 of { (VarId happy_var_1) -> - happyIn146 - (happy_var_1 - )} - -happyReduce_373 = happySpecReduce_1 142# happyReduction_373 -happyReduction_373 happy_x_1 - = case happyOutTok happy_x_1 of { (ConId happy_var_1) -> - happyIn146 - (happy_var_1 - )} - -happyReduce_374 = happySpecReduce_1 142# happyReduction_374 -happyReduction_374 happy_x_1 - = case happyOutTok happy_x_1 of { (DVarId happy_var_1) -> - happyIn146 - (mkDVar happy_var_1 - )} - -happyReduce_375 = happySpecReduce_1 142# happyReduction_375 -happyReduction_375 happy_x_1 - = happyIn146 - ("type" - ) - -happyReduce_376 = happySpecReduce_1 142# happyReduction_376 -happyReduction_376 happy_x_1 - = happyIn146 - ("class" - ) - -happyReduce_377 = happySpecReduce_1 142# happyReduction_377 -happyReduction_377 happy_x_1 - = happyIn146 - ("data" - ) - -happyReduce_378 = happySpecReduce_2 143# happyReduction_378 -happyReduction_378 happy_x_2 - happy_x_1 - = case happyOut147 happy_x_1 of { happy_var_1 -> - case happyOut148 happy_x_2 of { happy_var_2 -> - happyIn147 - (happy_var_2 : happy_var_1 - )}} - -happyReduce_379 = happySpecReduce_0 143# happyReduction_379 -happyReduction_379 = happyIn147 - ([] - ) - -happyReduce_380 = happySpecReduce_3 144# happyReduction_380 -happyReduction_380 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut145 happy_x_1 of { happy_var_1 -> - case happyOut134 happy_x_3 of { happy_var_3 -> - happyIn148 - (XAttr happy_var_1 happy_var_3 - )}} - -happyReduce_381 = happySpecReduce_1 145# happyReduction_381 -happyReduction_381 happy_x_1 - = case happyOut134 happy_x_1 of { happy_var_1 -> - happyIn149 - (Just happy_var_1 - )} - -happyReduce_382 = happySpecReduce_0 145# happyReduction_382 -happyReduction_382 = happyIn149 - (Nothing - ) - -happyReduce_383 = happySpecReduce_1 146# happyReduction_383 -happyReduction_383 happy_x_1 - = case happyOutTok happy_x_1 of { (DVarId happy_var_1) -> - happyIn150 - (DVar (map Ident happy_var_1) - )} - -happyReduce_384 = happySpecReduce_1 147# happyReduction_384 -happyReduction_384 happy_x_1 - = case happyOut139 happy_x_1 of { happy_var_1 -> - happyIn151 - (List [happy_var_1] - )} - -happyReduce_385 = happySpecReduce_1 147# happyReduction_385 -happyReduction_385 happy_x_1 - = case happyOut152 happy_x_1 of { happy_var_1 -> - happyIn151 - (List (reverse happy_var_1) - )} - -happyReduce_386 = happySpecReduce_2 147# happyReduction_386 -happyReduction_386 happy_x_2 - happy_x_1 - = case happyOut139 happy_x_1 of { happy_var_1 -> - happyIn151 - (EnumFrom happy_var_1 - )} - -happyReduce_387 = happyReduce 4# 147# happyReduction_387 -happyReduction_387 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut139 happy_x_1 of { happy_var_1 -> - case happyOut124 happy_x_3 of { happy_var_3 -> - happyIn151 - (EnumFromThen happy_var_1 happy_var_3 - ) `HappyStk` happyRest}} - -happyReduce_388 = happySpecReduce_3 147# happyReduction_388 -happyReduction_388 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut139 happy_x_1 of { happy_var_1 -> - case happyOut124 happy_x_3 of { happy_var_3 -> - happyIn151 - (EnumFromTo happy_var_1 happy_var_3 - )}} - -happyReduce_389 = happyReduce 5# 147# happyReduction_389 -happyReduction_389 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut139 happy_x_1 of { happy_var_1 -> - case happyOut124 happy_x_3 of { happy_var_3 -> - case happyOut124 happy_x_5 of { happy_var_5 -> - happyIn151 - (EnumFromThenTo happy_var_1 happy_var_3 happy_var_5 - ) `HappyStk` happyRest}}} - -happyReduce_390 = happySpecReduce_3 147# happyReduction_390 -happyReduction_390 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut139 happy_x_1 of { happy_var_1 -> - case happyOut153 happy_x_3 of { happy_var_3 -> - happyIn151 - (ListComp happy_var_1 (reverse happy_var_3) - )}} - -happyReduce_391 = happySpecReduce_3 148# happyReduction_391 -happyReduction_391 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut152 happy_x_1 of { happy_var_1 -> - case happyOut139 happy_x_3 of { happy_var_3 -> - happyIn152 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_392 = happySpecReduce_3 148# happyReduction_392 -happyReduction_392 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut139 happy_x_1 of { happy_var_1 -> - case happyOut139 happy_x_3 of { happy_var_3 -> - happyIn152 - ([happy_var_3,happy_var_1] - )}} - -happyReduce_393 = happySpecReduce_3 149# happyReduction_393 -happyReduction_393 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut153 happy_x_1 of { happy_var_1 -> - case happyOut154 happy_x_3 of { happy_var_3 -> - happyIn153 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_394 = happySpecReduce_1 149# happyReduction_394 -happyReduction_394 happy_x_1 - = case happyOut154 happy_x_1 of { happy_var_1 -> - happyIn153 - ([happy_var_1] - )} - -happyReduce_395 = happyReduce 4# 150# happyReduction_395 -happyReduction_395 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut162 happy_x_1 of { happy_var_1 -> - case happyOut200 happy_x_2 of { happy_var_2 -> - case happyOut123 happy_x_4 of { happy_var_4 -> - happyIn154 - (Generator happy_var_2 happy_var_1 happy_var_4 - ) `HappyStk` happyRest}}} - -happyReduce_396 = happySpecReduce_1 150# happyReduction_396 -happyReduction_396 happy_x_1 - = case happyOut123 happy_x_1 of { happy_var_1 -> - happyIn154 - (Qualifier happy_var_1 - )} - -happyReduce_397 = happySpecReduce_2 150# happyReduction_397 -happyReduction_397 happy_x_2 - happy_x_1 - = case happyOut49 happy_x_2 of { happy_var_2 -> - happyIn154 - (LetStmt happy_var_2 - )} - -happyReduce_398 = happySpecReduce_3 151# happyReduction_398 -happyReduction_398 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut156 happy_x_2 of { happy_var_2 -> - happyIn155 - (happy_var_2 - )} - -happyReduce_399 = happySpecReduce_3 151# happyReduction_399 -happyReduction_399 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut156 happy_x_2 of { happy_var_2 -> - happyIn155 - (happy_var_2 - )} - -happyReduce_400 = happySpecReduce_3 152# happyReduction_400 -happyReduction_400 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut157 happy_x_2 of { happy_var_2 -> - happyIn156 - (reverse happy_var_2 - )} - -happyReduce_401 = happySpecReduce_3 153# happyReduction_401 -happyReduction_401 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut157 happy_x_1 of { happy_var_1 -> - case happyOut158 happy_x_3 of { happy_var_3 -> - happyIn157 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_402 = happySpecReduce_1 153# happyReduction_402 -happyReduction_402 happy_x_1 - = case happyOut158 happy_x_1 of { happy_var_1 -> - happyIn157 - ([happy_var_1] - )} - -happyReduce_403 = happyReduce 4# 154# happyReduction_403 -happyReduction_403 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut162 happy_x_2 of { happy_var_2 -> - case happyOut159 happy_x_3 of { happy_var_3 -> - case happyOut118 happy_x_4 of { happy_var_4 -> - happyIn158 - (Alt happy_var_1 happy_var_2 happy_var_3 happy_var_4 - ) `HappyStk` happyRest}}}} - -happyReduce_404 = happySpecReduce_2 155# happyReduction_404 -happyReduction_404 happy_x_2 - happy_x_1 - = case happyOut123 happy_x_2 of { happy_var_2 -> - happyIn159 - (UnGuardedAlt happy_var_2 - )} - -happyReduce_405 = happySpecReduce_1 155# happyReduction_405 -happyReduction_405 happy_x_1 - = case happyOut160 happy_x_1 of { happy_var_1 -> - happyIn159 - (GuardedAlts (reverse happy_var_1) - )} - -happyReduce_406 = happySpecReduce_2 156# happyReduction_406 -happyReduction_406 happy_x_2 - happy_x_1 - = case happyOut160 happy_x_1 of { happy_var_1 -> - case happyOut161 happy_x_2 of { happy_var_2 -> - happyIn160 - (happy_var_2 : happy_var_1 - )}} - -happyReduce_407 = happySpecReduce_1 156# happyReduction_407 -happyReduction_407 happy_x_1 - = case happyOut161 happy_x_1 of { happy_var_1 -> - happyIn160 - ([happy_var_1] - )} - -happyReduce_408 = happyReduce 5# 157# happyReduction_408 -happyReduction_408 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut153 happy_x_3 of { happy_var_3 -> - case happyOut123 happy_x_5 of { happy_var_5 -> - happyIn161 - (GuardedAlt happy_var_1 (reverse happy_var_3) happy_var_5 - ) `HappyStk` happyRest}}} - -happyReduce_409 = happyMonadReduce 1# 158# happyReduction_409 -happyReduction_409 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen (case happyOut124 happy_x_1 of { happy_var_1 -> - ( checkPattern happy_var_1)} - ) (\r -> happyReturn (happyIn162 r)) - -happyReduce_410 = happySpecReduce_3 159# happyReduction_410 -happyReduction_410 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut164 happy_x_2 of { happy_var_2 -> - happyIn163 - (happy_var_2 - )} - -happyReduce_411 = happySpecReduce_3 159# happyReduction_411 -happyReduction_411 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut164 happy_x_2 of { happy_var_2 -> - happyIn163 - (happy_var_2 - )} - -happyReduce_412 = happyReduce 4# 160# happyReduction_412 -happyReduction_412 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut49 happy_x_2 of { happy_var_2 -> - case happyOut164 happy_x_4 of { happy_var_4 -> - happyIn164 - (LetStmt happy_var_2 : happy_var_4 - ) `HappyStk` happyRest}} - -happyReduce_413 = happyReduce 6# 160# happyReduction_413 -happyReduction_413 (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 happyOut162 happy_x_1 of { happy_var_1 -> - case happyOut200 happy_x_2 of { happy_var_2 -> - case happyOut123 happy_x_4 of { happy_var_4 -> - case happyOut164 happy_x_6 of { happy_var_6 -> - happyIn164 - (Generator happy_var_2 happy_var_1 happy_var_4 : happy_var_6 - ) `HappyStk` happyRest}}}} - -happyReduce_414 = happySpecReduce_3 160# happyReduction_414 -happyReduction_414 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut123 happy_x_1 of { happy_var_1 -> - case happyOut164 happy_x_3 of { happy_var_3 -> - happyIn164 - (Qualifier happy_var_1 : happy_var_3 - )}} - -happyReduce_415 = happySpecReduce_2 160# happyReduction_415 -happyReduction_415 happy_x_2 - happy_x_1 - = case happyOut164 happy_x_2 of { happy_var_2 -> - happyIn164 - (happy_var_2 - )} - -happyReduce_416 = happySpecReduce_2 160# happyReduction_416 -happyReduction_416 happy_x_2 - happy_x_1 - = case happyOut123 happy_x_1 of { happy_var_1 -> - happyIn164 - ([Qualifier happy_var_1] - )} - -happyReduce_417 = happySpecReduce_1 160# happyReduction_417 -happyReduction_417 happy_x_1 - = case happyOut123 happy_x_1 of { happy_var_1 -> - happyIn164 - ([Qualifier happy_var_1] - )} - -happyReduce_418 = happySpecReduce_3 161# happyReduction_418 -happyReduction_418 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut165 happy_x_1 of { happy_var_1 -> - case happyOut166 happy_x_3 of { happy_var_3 -> - happyIn165 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_419 = happySpecReduce_1 161# happyReduction_419 -happyReduction_419 happy_x_1 - = case happyOut166 happy_x_1 of { happy_var_1 -> - happyIn165 - ([happy_var_1] - )} - -happyReduce_420 = happySpecReduce_3 162# happyReduction_420 -happyReduction_420 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut173 happy_x_1 of { happy_var_1 -> - case happyOut124 happy_x_3 of { happy_var_3 -> - happyIn166 - (FieldUpdate happy_var_1 happy_var_3 - )}} - -happyReduce_421 = happySpecReduce_1 162# happyReduction_421 -happyReduction_421 happy_x_1 - = case happyOut171 happy_x_1 of { happy_var_1 -> - happyIn166 - (FieldPun happy_var_1 - )} - -happyReduce_422 = happySpecReduce_1 162# happyReduction_422 -happyReduction_422 happy_x_1 - = happyIn166 - (FieldWildcard - ) - -happyReduce_423 = happySpecReduce_3 163# happyReduction_423 -happyReduction_423 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut168 happy_x_2 of { happy_var_2 -> - happyIn167 - (reverse happy_var_2 - )} - -happyReduce_424 = happySpecReduce_3 164# happyReduction_424 -happyReduction_424 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut168 happy_x_1 of { happy_var_1 -> - case happyOut169 happy_x_3 of { happy_var_3 -> - happyIn168 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_425 = happySpecReduce_1 164# happyReduction_425 -happyReduction_425 happy_x_1 - = case happyOut169 happy_x_1 of { happy_var_1 -> - happyIn168 - ([happy_var_1] - )} - -happyReduce_426 = happyReduce 4# 165# happyReduction_426 -happyReduction_426 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut200 happy_x_1 of { happy_var_1 -> - case happyOut174 happy_x_2 of { happy_var_2 -> - case happyOut123 happy_x_4 of { happy_var_4 -> - happyIn169 - (IPBind happy_var_1 happy_var_2 happy_var_4 - ) `HappyStk` happyRest}}} - -happyReduce_427 = happySpecReduce_2 166# happyReduction_427 -happyReduction_427 happy_x_2 - happy_x_1 - = happyIn170 - (p_unit_con - ) - -happyReduce_428 = happySpecReduce_2 166# happyReduction_428 -happyReduction_428 happy_x_2 - happy_x_1 - = happyIn170 - (List [] - ) - -happyReduce_429 = happySpecReduce_3 166# happyReduction_429 -happyReduction_429 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut137 happy_x_2 of { happy_var_2 -> - happyIn170 - (p_tuple_con happy_var_2 - )} - -happyReduce_430 = happySpecReduce_1 166# happyReduction_430 -happyReduction_430 happy_x_1 - = case happyOut176 happy_x_1 of { happy_var_1 -> - happyIn170 - (Con happy_var_1 - )} - -happyReduce_431 = happySpecReduce_1 167# happyReduction_431 -happyReduction_431 happy_x_1 - = case happyOut188 happy_x_1 of { happy_var_1 -> - happyIn171 - (happy_var_1 - )} - -happyReduce_432 = happySpecReduce_3 167# happyReduction_432 -happyReduction_432 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut196 happy_x_2 of { happy_var_2 -> - happyIn171 - (happy_var_2 - )} - -happyReduce_433 = happySpecReduce_1 168# happyReduction_433 -happyReduction_433 happy_x_1 - = case happyOut187 happy_x_1 of { happy_var_1 -> - happyIn172 - (happy_var_1 - )} - -happyReduce_434 = happySpecReduce_3 168# happyReduction_434 -happyReduction_434 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut196 happy_x_2 of { happy_var_2 -> - happyIn172 - (happy_var_2 - )} - -happyReduce_435 = happySpecReduce_1 169# happyReduction_435 -happyReduction_435 happy_x_1 - = case happyOut186 happy_x_1 of { happy_var_1 -> - happyIn173 - (happy_var_1 - )} - -happyReduce_436 = happySpecReduce_3 169# happyReduction_436 -happyReduction_436 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut194 happy_x_2 of { happy_var_2 -> - happyIn173 - (happy_var_2 - )} - -happyReduce_437 = happySpecReduce_1 170# happyReduction_437 -happyReduction_437 happy_x_1 - = case happyOut189 happy_x_1 of { happy_var_1 -> - happyIn174 - (happy_var_1 - )} - -happyReduce_438 = happySpecReduce_1 171# happyReduction_438 -happyReduction_438 happy_x_1 - = case happyOut191 happy_x_1 of { happy_var_1 -> - happyIn175 - (happy_var_1 - )} - -happyReduce_439 = happySpecReduce_3 171# happyReduction_439 -happyReduction_439 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut193 happy_x_2 of { happy_var_2 -> - happyIn175 - (happy_var_2 - )} - -happyReduce_440 = happySpecReduce_1 172# happyReduction_440 -happyReduction_440 happy_x_1 - = case happyOut190 happy_x_1 of { happy_var_1 -> - happyIn176 - (happy_var_1 - )} - -happyReduce_441 = happySpecReduce_3 172# happyReduction_441 -happyReduction_441 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut185 happy_x_2 of { happy_var_2 -> - happyIn176 - (happy_var_2 - )} - -happyReduce_442 = happySpecReduce_1 173# happyReduction_442 -happyReduction_442 happy_x_1 - = case happyOut196 happy_x_1 of { happy_var_1 -> - happyIn177 - (happy_var_1 - )} - -happyReduce_443 = happySpecReduce_3 173# happyReduction_443 -happyReduction_443 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut188 happy_x_2 of { happy_var_2 -> - happyIn177 - (happy_var_2 - )} - -happyReduce_444 = happySpecReduce_1 174# happyReduction_444 -happyReduction_444 happy_x_1 - = case happyOut194 happy_x_1 of { happy_var_1 -> - happyIn178 - (happy_var_1 - )} - -happyReduce_445 = happySpecReduce_3 174# happyReduction_445 -happyReduction_445 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut186 happy_x_2 of { happy_var_2 -> - happyIn178 - (happy_var_2 - )} - -happyReduce_446 = happySpecReduce_1 175# happyReduction_446 -happyReduction_446 happy_x_1 - = case happyOut195 happy_x_1 of { happy_var_1 -> - happyIn179 - (happy_var_1 - )} - -happyReduce_447 = happySpecReduce_3 175# happyReduction_447 -happyReduction_447 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut186 happy_x_2 of { happy_var_2 -> - happyIn179 - (happy_var_2 - )} - -happyReduce_448 = happySpecReduce_1 176# happyReduction_448 -happyReduction_448 happy_x_1 - = case happyOut193 happy_x_1 of { happy_var_1 -> - happyIn180 - (happy_var_1 - )} - -happyReduce_449 = happySpecReduce_3 176# happyReduction_449 -happyReduction_449 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut191 happy_x_2 of { happy_var_2 -> - happyIn180 - (happy_var_2 - )} - -happyReduce_450 = happySpecReduce_1 177# happyReduction_450 -happyReduction_450 happy_x_1 - = case happyOut185 happy_x_1 of { happy_var_1 -> - happyIn181 - (happy_var_1 - )} - -happyReduce_451 = happySpecReduce_3 177# happyReduction_451 -happyReduction_451 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut190 happy_x_2 of { happy_var_2 -> - happyIn181 - (happy_var_2 - )} - -happyReduce_452 = happySpecReduce_1 178# happyReduction_452 -happyReduction_452 happy_x_1 - = case happyOut177 happy_x_1 of { happy_var_1 -> - happyIn182 - (VarOp happy_var_1 - )} - -happyReduce_453 = happySpecReduce_1 178# happyReduction_453 -happyReduction_453 happy_x_1 - = case happyOut180 happy_x_1 of { happy_var_1 -> - happyIn182 - (ConOp happy_var_1 - )} - -happyReduce_454 = happySpecReduce_1 179# happyReduction_454 -happyReduction_454 happy_x_1 - = case happyOut178 happy_x_1 of { happy_var_1 -> - happyIn183 - (QVarOp happy_var_1 - )} - -happyReduce_455 = happySpecReduce_1 179# happyReduction_455 -happyReduction_455 happy_x_1 - = case happyOut181 happy_x_1 of { happy_var_1 -> - happyIn183 - (QConOp happy_var_1 - )} - -happyReduce_456 = happySpecReduce_1 180# happyReduction_456 -happyReduction_456 happy_x_1 - = case happyOut179 happy_x_1 of { happy_var_1 -> - happyIn184 - (QVarOp happy_var_1 - )} - -happyReduce_457 = happySpecReduce_1 180# happyReduction_457 -happyReduction_457 happy_x_1 - = case happyOut181 happy_x_1 of { happy_var_1 -> - happyIn184 - (QConOp happy_var_1 - )} - -happyReduce_458 = happySpecReduce_1 181# happyReduction_458 -happyReduction_458 happy_x_1 - = happyIn185 - (list_cons_name - ) - -happyReduce_459 = happySpecReduce_1 181# happyReduction_459 -happyReduction_459 happy_x_1 - = case happyOut192 happy_x_1 of { happy_var_1 -> - happyIn185 - (happy_var_1 - )} - -happyReduce_460 = happySpecReduce_1 182# happyReduction_460 -happyReduction_460 happy_x_1 - = case happyOut188 happy_x_1 of { happy_var_1 -> - happyIn186 - (UnQual happy_var_1 - )} - -happyReduce_461 = happySpecReduce_1 182# happyReduction_461 -happyReduction_461 happy_x_1 - = case happyOutTok happy_x_1 of { (QVarId happy_var_1) -> - happyIn186 - (Qual (ModuleName (fst happy_var_1)) (Ident (snd happy_var_1)) - )} - -happyReduce_462 = happySpecReduce_1 183# happyReduction_462 -happyReduction_462 happy_x_1 - = case happyOutTok happy_x_1 of { (VarId happy_var_1) -> - happyIn187 - (Ident happy_var_1 - )} - -happyReduce_463 = happySpecReduce_1 183# happyReduction_463 -happyReduction_463 happy_x_1 - = happyIn187 - (as_name - ) - -happyReduce_464 = happySpecReduce_1 183# happyReduction_464 -happyReduction_464 happy_x_1 - = happyIn187 - (qualified_name - ) - -happyReduce_465 = happySpecReduce_1 183# happyReduction_465 -happyReduction_465 happy_x_1 - = happyIn187 - (hiding_name - ) - -happyReduce_466 = happySpecReduce_1 183# happyReduction_466 -happyReduction_466 happy_x_1 - = happyIn187 - (export_name - ) - -happyReduce_467 = happySpecReduce_1 183# happyReduction_467 -happyReduction_467 happy_x_1 - = happyIn187 - (stdcall_name - ) - -happyReduce_468 = happySpecReduce_1 183# happyReduction_468 -happyReduction_468 happy_x_1 - = happyIn187 - (ccall_name - ) - -happyReduce_469 = happySpecReduce_1 184# happyReduction_469 -happyReduction_469 happy_x_1 - = case happyOut187 happy_x_1 of { happy_var_1 -> - happyIn188 - (happy_var_1 - )} - -happyReduce_470 = happySpecReduce_1 184# happyReduction_470 -happyReduction_470 happy_x_1 - = happyIn188 - (safe_name - ) - -happyReduce_471 = happySpecReduce_1 184# happyReduction_471 -happyReduction_471 happy_x_1 - = happyIn188 - (unsafe_name - ) - -happyReduce_472 = happySpecReduce_1 184# happyReduction_472 -happyReduction_472 happy_x_1 - = happyIn188 - (threadsafe_name - ) - -happyReduce_473 = happySpecReduce_1 185# happyReduction_473 -happyReduction_473 happy_x_1 - = case happyOutTok happy_x_1 of { (IDupVarId happy_var_1) -> - happyIn189 - (IPDup happy_var_1 - )} - -happyReduce_474 = happySpecReduce_1 185# happyReduction_474 -happyReduction_474 happy_x_1 - = case happyOutTok happy_x_1 of { (ILinVarId happy_var_1) -> - happyIn189 - (IPLin happy_var_1 - )} - -happyReduce_475 = happySpecReduce_1 186# happyReduction_475 -happyReduction_475 happy_x_1 - = case happyOut191 happy_x_1 of { happy_var_1 -> - happyIn190 - (UnQual happy_var_1 - )} - -happyReduce_476 = happySpecReduce_1 186# happyReduction_476 -happyReduction_476 happy_x_1 - = case happyOutTok happy_x_1 of { (QConId happy_var_1) -> - happyIn190 - (Qual (ModuleName (fst happy_var_1)) (Ident (snd happy_var_1)) - )} - -happyReduce_477 = happySpecReduce_1 187# happyReduction_477 -happyReduction_477 happy_x_1 - = case happyOutTok happy_x_1 of { (ConId happy_var_1) -> - happyIn191 - (Ident happy_var_1 - )} - -happyReduce_478 = happySpecReduce_1 188# happyReduction_478 -happyReduction_478 happy_x_1 - = case happyOut193 happy_x_1 of { happy_var_1 -> - happyIn192 - (UnQual happy_var_1 - )} - -happyReduce_479 = happySpecReduce_1 188# happyReduction_479 -happyReduction_479 happy_x_1 - = case happyOutTok happy_x_1 of { (QConSym happy_var_1) -> - happyIn192 - (Qual (ModuleName (fst happy_var_1)) (Symbol (snd happy_var_1)) - )} - -happyReduce_480 = happySpecReduce_1 189# happyReduction_480 -happyReduction_480 happy_x_1 - = case happyOutTok happy_x_1 of { (ConSym happy_var_1) -> - happyIn193 - (Symbol happy_var_1 - )} - -happyReduce_481 = happySpecReduce_1 190# happyReduction_481 -happyReduction_481 happy_x_1 - = case happyOut196 happy_x_1 of { happy_var_1 -> - happyIn194 - (UnQual happy_var_1 - )} - -happyReduce_482 = happySpecReduce_1 190# happyReduction_482 -happyReduction_482 happy_x_1 - = case happyOut198 happy_x_1 of { happy_var_1 -> - happyIn194 - (happy_var_1 - )} - -happyReduce_483 = happySpecReduce_1 191# happyReduction_483 -happyReduction_483 happy_x_1 - = case happyOut197 happy_x_1 of { happy_var_1 -> - happyIn195 - (UnQual happy_var_1 - )} - -happyReduce_484 = happySpecReduce_1 191# happyReduction_484 -happyReduction_484 happy_x_1 - = case happyOut198 happy_x_1 of { happy_var_1 -> - happyIn195 - (happy_var_1 - )} - -happyReduce_485 = happySpecReduce_1 192# happyReduction_485 -happyReduction_485 happy_x_1 - = case happyOutTok happy_x_1 of { (VarSym happy_var_1) -> - happyIn196 - (Symbol happy_var_1 - )} - -happyReduce_486 = happySpecReduce_1 192# happyReduction_486 -happyReduction_486 happy_x_1 - = happyIn196 - (minus_name - ) - -happyReduce_487 = happySpecReduce_1 192# happyReduction_487 -happyReduction_487 happy_x_1 - = happyIn196 - (pling_name - ) - -happyReduce_488 = happySpecReduce_1 192# happyReduction_488 -happyReduction_488 happy_x_1 - = happyIn196 - (dot_name - ) - -happyReduce_489 = happySpecReduce_1 192# happyReduction_489 -happyReduction_489 happy_x_1 - = happyIn196 - (star_name - ) - -happyReduce_490 = happySpecReduce_1 193# happyReduction_490 -happyReduction_490 happy_x_1 - = case happyOutTok happy_x_1 of { (VarSym happy_var_1) -> - happyIn197 - (Symbol happy_var_1 - )} - -happyReduce_491 = happySpecReduce_1 193# happyReduction_491 -happyReduction_491 happy_x_1 - = happyIn197 - (pling_name - ) - -happyReduce_492 = happySpecReduce_1 193# happyReduction_492 -happyReduction_492 happy_x_1 - = happyIn197 - (dot_name - ) - -happyReduce_493 = happySpecReduce_1 193# happyReduction_493 -happyReduction_493 happy_x_1 - = happyIn197 - (star_name - ) - -happyReduce_494 = happySpecReduce_1 194# happyReduction_494 -happyReduction_494 happy_x_1 - = case happyOutTok happy_x_1 of { (QVarSym happy_var_1) -> - happyIn198 - (Qual (ModuleName (fst happy_var_1)) (Symbol (snd happy_var_1)) - )} - -happyReduce_495 = happySpecReduce_1 195# happyReduction_495 -happyReduction_495 happy_x_1 - = case happyOutTok happy_x_1 of { (IntTok happy_var_1) -> - happyIn199 - (Int happy_var_1 - )} - -happyReduce_496 = happySpecReduce_1 195# happyReduction_496 -happyReduction_496 happy_x_1 - = case happyOutTok happy_x_1 of { (Character happy_var_1) -> - happyIn199 - (Char happy_var_1 - )} - -happyReduce_497 = happySpecReduce_1 195# happyReduction_497 -happyReduction_497 happy_x_1 - = case happyOutTok happy_x_1 of { (FloatTok happy_var_1) -> - happyIn199 - (Frac happy_var_1 - )} - -happyReduce_498 = happySpecReduce_1 195# happyReduction_498 -happyReduction_498 happy_x_1 - = case happyOutTok happy_x_1 of { (StringTok happy_var_1) -> - happyIn199 - (String happy_var_1 - )} - -happyReduce_499 = happySpecReduce_1 195# happyReduction_499 -happyReduction_499 happy_x_1 - = case happyOutTok happy_x_1 of { (IntTokHash happy_var_1) -> - happyIn199 - (PrimInt happy_var_1 - )} - -happyReduce_500 = happySpecReduce_1 195# happyReduction_500 -happyReduction_500 happy_x_1 - = case happyOutTok happy_x_1 of { (WordTokHash happy_var_1) -> - happyIn199 - (PrimWord happy_var_1 - )} - -happyReduce_501 = happySpecReduce_1 195# happyReduction_501 -happyReduction_501 happy_x_1 - = case happyOutTok happy_x_1 of { (FloatTokHash happy_var_1) -> - happyIn199 - (PrimFloat happy_var_1 - )} - -happyReduce_502 = happySpecReduce_1 195# happyReduction_502 -happyReduction_502 happy_x_1 - = case happyOutTok happy_x_1 of { (DoubleTokHash happy_var_1) -> - happyIn199 - (PrimDouble happy_var_1 - )} - -happyReduce_503 = happySpecReduce_1 195# happyReduction_503 -happyReduction_503 happy_x_1 - = case happyOutTok happy_x_1 of { (CharacterHash happy_var_1) -> - happyIn199 - (PrimChar happy_var_1 - )} - -happyReduce_504 = happySpecReduce_1 195# happyReduction_504 -happyReduction_504 happy_x_1 - = case happyOutTok happy_x_1 of { (StringHash happy_var_1) -> - happyIn199 - (PrimString happy_var_1 - )} - -happyReduce_505 = happyMonadReduce 0# 196# happyReduction_505 -happyReduction_505 (happyRest) tk - = happyThen (( getSrcLoc) - ) (\r -> happyReturn (happyIn200 r)) - -happyReduce_506 = happyMonadReduce 0# 197# happyReduction_506 -happyReduction_506 (happyRest) tk - = happyThen (( pushCurrentContext) - ) (\r -> happyReturn (happyIn201 r)) - -happyReduce_507 = happySpecReduce_1 198# happyReduction_507 -happyReduction_507 happy_x_1 - = happyIn202 - (() - ) - -happyReduce_508 = happyMonadReduce 1# 198# happyReduction_508 -happyReduction_508 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen (( popContext) - ) (\r -> happyReturn (happyIn202 r)) - -happyReduce_509 = happySpecReduce_1 199# happyReduction_509 -happyReduction_509 happy_x_1 - = case happyOutTok happy_x_1 of { (ConId happy_var_1) -> - happyIn203 - (ModuleName happy_var_1 - )} - -happyReduce_510 = happySpecReduce_1 199# happyReduction_510 -happyReduction_510 happy_x_1 - = case happyOutTok happy_x_1 of { (QConId happy_var_1) -> - happyIn203 - (ModuleName (fst happy_var_1 ++ '.':snd happy_var_1) - )} - -happyReduce_511 = happySpecReduce_1 200# happyReduction_511 -happyReduction_511 happy_x_1 - = case happyOut175 happy_x_1 of { happy_var_1 -> - happyIn204 - (happy_var_1 - )} - -happyReduce_512 = happySpecReduce_1 201# happyReduction_512 -happyReduction_512 happy_x_1 - = case happyOut176 happy_x_1 of { happy_var_1 -> - happyIn205 - (happy_var_1 - )} - -happyReduce_513 = happySpecReduce_1 202# happyReduction_513 -happyReduction_513 happy_x_1 - = case happyOut188 happy_x_1 of { happy_var_1 -> - happyIn206 - (happy_var_1 - )} - -happyReduce_514 = happySpecReduce_3 203# happyReduction_514 -happyReduction_514 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut206 happy_x_2 of { happy_var_2 -> - happyIn207 - (UnQual happy_var_2 - )} - -happyReduce_515 = happySpecReduce_1 203# happyReduction_515 -happyReduction_515 happy_x_1 - = case happyOut208 happy_x_1 of { happy_var_1 -> - happyIn207 - (UnQual happy_var_1 - )} - -happyReduce_516 = happySpecReduce_1 204# happyReduction_516 -happyReduction_516 happy_x_1 - = case happyOutTok happy_x_1 of { (VarSym happy_var_1) -> - happyIn208 - (Symbol happy_var_1 - )} - -happyNewToken action sts stk - = lexer(\tk -> - let cont i = happyDoAction i tk action sts stk in - case tk of { - EOF -> happyDoAction 122# 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#; - IntTokHash happy_dollar_dollar -> cont 16#; - WordTokHash happy_dollar_dollar -> cont 17#; - FloatTokHash happy_dollar_dollar -> cont 18#; - DoubleTokHash happy_dollar_dollar -> cont 19#; - CharacterHash happy_dollar_dollar -> cont 20#; - StringHash happy_dollar_dollar -> cont 21#; - LeftParen -> cont 22#; - RightParen -> cont 23#; - LeftHashParen -> cont 24#; - RightHashParen -> cont 25#; - SemiColon -> cont 26#; - LeftCurly -> cont 27#; - RightCurly -> cont 28#; - VRightCurly -> cont 29#; - LeftSquare -> cont 30#; - RightSquare -> cont 31#; - Comma -> cont 32#; - Underscore -> cont 33#; - BackQuote -> cont 34#; - Dot -> cont 35#; - DotDot -> cont 36#; - Colon -> cont 37#; - DoubleColon -> cont 38#; - Equals -> cont 39#; - Backslash -> cont 40#; - Bar -> cont 41#; - LeftArrow -> cont 42#; - RightArrow -> cont 43#; - At -> cont 44#; - Tilde -> cont 45#; - DoubleArrow -> cont 46#; - Minus -> cont 47#; - Exclamation -> cont 48#; - Star -> cont 49#; - RPGuardOpen -> cont 50#; - RPGuardClose -> cont 51#; - RPCAt -> cont 52#; - THIdEscape happy_dollar_dollar -> cont 53#; - THParenEscape -> cont 54#; - THExpQuote -> cont 55#; - THPatQuote -> cont 56#; - THTypQuote -> cont 57#; - THDecQuote -> cont 58#; - THCloseQuote -> cont 59#; - THVarQuote -> cont 60#; - THTyQuote -> cont 61#; - XPCDATA happy_dollar_dollar -> cont 62#; - XStdTagOpen -> cont 63#; - XCloseTagOpen -> cont 64#; - XCodeTagOpen -> cont 65#; - XStdTagClose -> cont 66#; - XEmptyTagClose -> cont 67#; - XCodeTagClose -> cont 68#; - XRPatOpen -> cont 69#; - XRPatClose -> cont 70#; - KW_Foreign -> cont 71#; - KW_Export -> cont 72#; - KW_Safe -> cont 73#; - KW_Unsafe -> cont 74#; - KW_Threadsafe -> cont 75#; - KW_StdCall -> cont 76#; - KW_CCall -> cont 77#; - KW_As -> cont 78#; - KW_Case -> cont 79#; - KW_Class -> cont 80#; - KW_Data -> cont 81#; - KW_Default -> cont 82#; - KW_Deriving -> cont 83#; - KW_Do -> cont 84#; - KW_Else -> cont 85#; - KW_Family -> cont 86#; - KW_Forall -> cont 87#; - KW_Hiding -> cont 88#; - KW_If -> cont 89#; - KW_Import -> cont 90#; - KW_In -> cont 91#; - KW_Infix -> cont 92#; - KW_InfixL -> cont 93#; - KW_InfixR -> cont 94#; - KW_Instance -> cont 95#; - KW_Let -> cont 96#; - KW_MDo -> cont 97#; - KW_Module -> cont 98#; - KW_NewType -> cont 99#; - KW_Of -> cont 100#; - KW_Then -> cont 101#; - KW_Type -> cont 102#; - KW_Where -> cont 103#; - KW_Qualified -> cont 104#; - INLINE happy_dollar_dollar -> cont 105#; - SPECIALISE -> cont 106#; - SPECIALISE_INLINE happy_dollar_dollar -> cont 107#; - SOURCE -> cont 108#; - RULES -> cont 109#; - CORE -> cont 110#; - SCC -> cont 111#; - GENERATED -> cont 112#; - DEPRECATED -> cont 113#; - WARNING -> cont 114#; - UNPACK -> cont 115#; - OPTIONS happy_dollar_dollar -> cont 116#; - CFILES happy_dollar_dollar -> cont 117#; - INCLUDE happy_dollar_dollar -> cont 118#; - LANGUAGE -> cont 119#; - PragmaUnknown happy_dollar_dollar -> cont 120#; - PragmaEnd -> cont 121#; - _ -> 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 Module -parseModule = runParser parse - --- | Parse of a string, which should contain a complete Haskell 98 module. -parseModuleWithMode :: ParseMode -> String -> ParseResult Module -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 +{-# OPTIONS_GHC -fno-warn-overlapping-patterns #-} +{-# OPTIONS -fglasgow-exts -cpp #-} +----------------------------------------------------------------------------- +-- | +-- Module : Language.Haskell.Exts.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.Exts.Parser ( + Parseable(..), + parseModule, parseModuleWithMode, + parseExp, parseExpWithMode, + parsePat, parsePatWithMode, + parseDecl, parseDeclWithMode, + parseType, parseTypeWithMode, + getTopPragmas, + ParseMode(..), defaultParseMode, ParseResult(..) + ) where +import Language.Haskell.Exts.Syntax hiding ( Type(..), Exp(..), Asst(..), XAttr(..), FieldUpdate(..) ) +import Language.Haskell.Exts.Syntax ( Type, Exp, Asst ) +import Language.Haskell.Exts.ParseMonad +import Language.Haskell.Exts.Lexer +import Language.Haskell.Exts.ParseUtils +import Language.Haskell.Exts.Extension +import Language.Haskell.Exts.Fixity +#if __GLASGOW_HASKELL__ >= 503 +import qualified Data.Array as Happy_Data_Array +#else +import qualified Array as Happy_Data_Array +#endif +#if __GLASGOW_HASKELL__ >= 503 +import qualified GHC.Exts as Happy_GHC_Exts +#else +import qualified GlaExts as Happy_GHC_Exts +#endif + +-- parser produced by Happy Version 1.18.4 + +newtype HappyAbsSyn = HappyAbsSyn HappyAny +#if __GLASGOW_HASKELL__ >= 607 +type HappyAny = Happy_GHC_Exts.Any +#else +type HappyAny = forall a . a +#endif +happyIn9 :: (Module) -> (HappyAbsSyn ) +happyIn9 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn9 #-} +happyOut9 :: (HappyAbsSyn ) -> (Module) +happyOut9 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut9 #-} +happyIn10 :: (PExp) -> (HappyAbsSyn ) +happyIn10 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn10 #-} +happyOut10 :: (HappyAbsSyn ) -> (PExp) +happyOut10 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut10 #-} +happyIn11 :: ([OptionPragma]) -> (HappyAbsSyn ) +happyIn11 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn11 #-} +happyOut11 :: (HappyAbsSyn ) -> ([OptionPragma]) +happyOut11 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut11 #-} +happyIn12 :: ([OptionPragma]) -> (HappyAbsSyn ) +happyIn12 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn12 #-} +happyOut12 :: (HappyAbsSyn ) -> ([OptionPragma]) +happyOut12 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut12 #-} +happyIn13 :: (OptionPragma) -> (HappyAbsSyn ) +happyIn13 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn13 #-} +happyOut13 :: (HappyAbsSyn ) -> (OptionPragma) +happyOut13 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut13 #-} +happyIn14 :: ([Name]) -> (HappyAbsSyn ) +happyIn14 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn14 #-} +happyOut14 :: (HappyAbsSyn ) -> ([Name]) +happyOut14 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut14 #-} +happyIn15 :: ([OptionPragma] -> Module) -> (HappyAbsSyn ) +happyIn15 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn15 #-} +happyOut15 :: (HappyAbsSyn ) -> ([OptionPragma] -> Module) +happyOut15 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut15 #-} +happyIn16 :: (Maybe WarningText) -> (HappyAbsSyn ) +happyIn16 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn16 #-} +happyOut16 :: (HappyAbsSyn ) -> (Maybe WarningText) +happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut16 #-} +happyIn17 :: (([ImportDecl],[Decl])) -> (HappyAbsSyn ) +happyIn17 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn17 #-} +happyOut17 :: (HappyAbsSyn ) -> (([ImportDecl],[Decl])) +happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut17 #-} +happyIn18 :: (([ImportDecl],[Decl])) -> (HappyAbsSyn ) +happyIn18 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn18 #-} +happyOut18 :: (HappyAbsSyn ) -> (([ImportDecl],[Decl])) +happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut18 #-} +happyIn19 :: (()) -> (HappyAbsSyn ) +happyIn19 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn19 #-} +happyOut19 :: (HappyAbsSyn ) -> (()) +happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut19 #-} +happyIn20 :: (()) -> (HappyAbsSyn ) +happyIn20 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn20 #-} +happyOut20 :: (HappyAbsSyn ) -> (()) +happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut20 #-} +happyIn21 :: (Maybe [ExportSpec]) -> (HappyAbsSyn ) +happyIn21 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn21 #-} +happyOut21 :: (HappyAbsSyn ) -> (Maybe [ExportSpec]) +happyOut21 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut21 #-} +happyIn22 :: ([ExportSpec]) -> (HappyAbsSyn ) +happyIn22 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn22 #-} +happyOut22 :: (HappyAbsSyn ) -> ([ExportSpec]) +happyOut22 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut22 #-} +happyIn23 :: (()) -> (HappyAbsSyn ) +happyIn23 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn23 #-} +happyOut23 :: (HappyAbsSyn ) -> (()) +happyOut23 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut23 #-} +happyIn24 :: ([ExportSpec]) -> (HappyAbsSyn ) +happyIn24 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn24 #-} +happyOut24 :: (HappyAbsSyn ) -> ([ExportSpec]) +happyOut24 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut24 #-} +happyIn25 :: (ExportSpec) -> (HappyAbsSyn ) +happyIn25 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn25 #-} +happyOut25 :: (HappyAbsSyn ) -> (ExportSpec) +happyOut25 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut25 #-} +happyIn26 :: ([ImportDecl]) -> (HappyAbsSyn ) +happyIn26 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn26 #-} +happyOut26 :: (HappyAbsSyn ) -> ([ImportDecl]) +happyOut26 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut26 #-} +happyIn27 :: (ImportDecl) -> (HappyAbsSyn ) +happyIn27 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn27 #-} +happyOut27 :: (HappyAbsSyn ) -> (ImportDecl) +happyOut27 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut27 #-} +happyIn28 :: (Bool) -> (HappyAbsSyn ) +happyIn28 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn28 #-} +happyOut28 :: (HappyAbsSyn ) -> (Bool) +happyOut28 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut28 #-} +happyIn29 :: (Bool) -> (HappyAbsSyn ) +happyIn29 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn29 #-} +happyOut29 :: (HappyAbsSyn ) -> (Bool) +happyOut29 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut29 #-} +happyIn30 :: (Maybe String) -> (HappyAbsSyn ) +happyIn30 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn30 #-} +happyOut30 :: (HappyAbsSyn ) -> (Maybe String) +happyOut30 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut30 #-} +happyIn31 :: (Maybe ModuleName) -> (HappyAbsSyn ) +happyIn31 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn31 #-} +happyOut31 :: (HappyAbsSyn ) -> (Maybe ModuleName) +happyOut31 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut31 #-} +happyIn32 :: (Maybe (Bool, [ImportSpec])) -> (HappyAbsSyn ) +happyIn32 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn32 #-} +happyOut32 :: (HappyAbsSyn ) -> (Maybe (Bool, [ImportSpec])) +happyOut32 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut32 #-} +happyIn33 :: ((Bool, [ImportSpec])) -> (HappyAbsSyn ) +happyIn33 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn33 #-} +happyOut33 :: (HappyAbsSyn ) -> ((Bool, [ImportSpec])) +happyOut33 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut33 #-} +happyIn34 :: (Bool) -> (HappyAbsSyn ) +happyIn34 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn34 #-} +happyOut34 :: (HappyAbsSyn ) -> (Bool) +happyOut34 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut34 #-} +happyIn35 :: ([ImportSpec]) -> (HappyAbsSyn ) +happyIn35 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn35 #-} +happyOut35 :: (HappyAbsSyn ) -> ([ImportSpec]) +happyOut35 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut35 #-} +happyIn36 :: (ImportSpec) -> (HappyAbsSyn ) +happyIn36 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn36 #-} +happyOut36 :: (HappyAbsSyn ) -> (ImportSpec) +happyOut36 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut36 #-} +happyIn37 :: ([CName]) -> (HappyAbsSyn ) +happyIn37 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn37 #-} +happyOut37 :: (HappyAbsSyn ) -> ([CName]) +happyOut37 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut37 #-} +happyIn38 :: (CName) -> (HappyAbsSyn ) +happyIn38 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn38 #-} +happyOut38 :: (HappyAbsSyn ) -> (CName) +happyOut38 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut38 #-} +happyIn39 :: (Decl) -> (HappyAbsSyn ) +happyIn39 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn39 #-} +happyOut39 :: (HappyAbsSyn ) -> (Decl) +happyOut39 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut39 #-} +happyIn40 :: (Int) -> (HappyAbsSyn ) +happyIn40 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn40 #-} +happyOut40 :: (HappyAbsSyn ) -> (Int) +happyOut40 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut40 #-} +happyIn41 :: (Assoc) -> (HappyAbsSyn ) +happyIn41 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn41 #-} +happyOut41 :: (HappyAbsSyn ) -> (Assoc) +happyOut41 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut41 #-} +happyIn42 :: ([Op]) -> (HappyAbsSyn ) +happyIn42 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn42 #-} +happyOut42 :: (HappyAbsSyn ) -> ([Op]) +happyOut42 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut42 #-} +happyIn43 :: ([Decl]) -> (HappyAbsSyn ) +happyIn43 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn43 #-} +happyOut43 :: (HappyAbsSyn ) -> ([Decl]) +happyOut43 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut43 #-} +happyIn44 :: ([Decl]) -> (HappyAbsSyn ) +happyIn44 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn44 #-} +happyOut44 :: (HappyAbsSyn ) -> ([Decl]) +happyOut44 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut44 #-} +happyIn45 :: (Decl) -> (HappyAbsSyn ) +happyIn45 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn45 #-} +happyOut45 :: (HappyAbsSyn ) -> (Decl) +happyOut45 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut45 #-} +happyIn46 :: (DataOrNew) -> (HappyAbsSyn ) +happyIn46 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn46 #-} +happyOut46 :: (HappyAbsSyn ) -> (DataOrNew) +happyOut46 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut46 #-} +happyIn47 :: ([Type]) -> (HappyAbsSyn ) +happyIn47 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn47 #-} +happyOut47 :: (HappyAbsSyn ) -> ([Type]) +happyOut47 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut47 #-} +happyIn48 :: ([Decl]) -> (HappyAbsSyn ) +happyIn48 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn48 #-} +happyOut48 :: (HappyAbsSyn ) -> ([Decl]) +happyOut48 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut48 #-} +happyIn49 :: ([Decl]) -> (HappyAbsSyn ) +happyIn49 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn49 #-} +happyOut49 :: (HappyAbsSyn ) -> ([Decl]) +happyOut49 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut49 #-} +happyIn50 :: (Decl) -> (HappyAbsSyn ) +happyIn50 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn50 #-} +happyOut50 :: (HappyAbsSyn ) -> (Decl) +happyOut50 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut50 #-} +happyIn51 :: ([Decl]) -> (HappyAbsSyn ) +happyIn51 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn51 #-} +happyOut51 :: (HappyAbsSyn ) -> ([Decl]) +happyOut51 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut51 #-} +happyIn52 :: (Decl) -> (HappyAbsSyn ) +happyIn52 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn52 #-} +happyOut52 :: (HappyAbsSyn ) -> (Decl) +happyOut52 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut52 #-} +happyIn53 :: ([Type]) -> (HappyAbsSyn ) +happyIn53 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn53 #-} +happyOut53 :: (HappyAbsSyn ) -> ([Type]) +happyOut53 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut53 #-} +happyIn54 :: (Type) -> (HappyAbsSyn ) +happyIn54 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn54 #-} +happyOut54 :: (HappyAbsSyn ) -> (Type) +happyOut54 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut54 #-} +happyIn55 :: (Binds) -> (HappyAbsSyn ) +happyIn55 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn55 #-} +happyOut55 :: (HappyAbsSyn ) -> (Binds) +happyOut55 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut55 #-} +happyIn56 :: ([Name]) -> (HappyAbsSyn ) +happyIn56 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn56 #-} +happyOut56 :: (HappyAbsSyn ) -> ([Name]) +happyOut56 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut56 #-} +happyIn57 :: (CallConv) -> (HappyAbsSyn ) +happyIn57 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn57 #-} +happyOut57 :: (HappyAbsSyn ) -> (CallConv) +happyOut57 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut57 #-} +happyIn58 :: (Safety) -> (HappyAbsSyn ) +happyIn58 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn58 #-} +happyOut58 :: (HappyAbsSyn ) -> (Safety) +happyOut58 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut58 #-} +happyIn59 :: ((String, Name, Type)) -> (HappyAbsSyn ) +happyIn59 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn59 #-} +happyOut59 :: (HappyAbsSyn ) -> ((String, Name, Type)) +happyOut59 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut59 #-} +happyIn60 :: ([Rule]) -> (HappyAbsSyn ) +happyIn60 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn60 #-} +happyOut60 :: (HappyAbsSyn ) -> ([Rule]) +happyOut60 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut60 #-} +happyIn61 :: (Rule) -> (HappyAbsSyn ) +happyIn61 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn61 #-} +happyOut61 :: (HappyAbsSyn ) -> (Rule) +happyOut61 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut61 #-} +happyIn62 :: (Activation) -> (HappyAbsSyn ) +happyIn62 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn62 #-} +happyOut62 :: (HappyAbsSyn ) -> (Activation) +happyOut62 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut62 #-} +happyIn63 :: (Maybe [RuleVar]) -> (HappyAbsSyn ) +happyIn63 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn63 #-} +happyOut63 :: (HappyAbsSyn ) -> (Maybe [RuleVar]) +happyOut63 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut63 #-} +happyIn64 :: ([RuleVar]) -> (HappyAbsSyn ) +happyIn64 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn64 #-} +happyOut64 :: (HappyAbsSyn ) -> ([RuleVar]) +happyOut64 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut64 #-} +happyIn65 :: (RuleVar) -> (HappyAbsSyn ) +happyIn65 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn65 #-} +happyOut65 :: (HappyAbsSyn ) -> (RuleVar) +happyOut65 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut65 #-} +happyIn66 :: ([([Name],String)]) -> (HappyAbsSyn ) +happyIn66 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn66 #-} +happyOut66 :: (HappyAbsSyn ) -> ([([Name],String)]) +happyOut66 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut66 #-} +happyIn67 :: (([Name], String)) -> (HappyAbsSyn ) +happyIn67 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn67 #-} +happyOut67 :: (HappyAbsSyn ) -> (([Name], String)) +happyOut67 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut67 #-} +happyIn68 :: ([Name]) -> (HappyAbsSyn ) +happyIn68 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn68 #-} +happyOut68 :: (HappyAbsSyn ) -> ([Name]) +happyOut68 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut68 #-} +happyIn69 :: (Name) -> (HappyAbsSyn ) +happyIn69 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn69 #-} +happyOut69 :: (HappyAbsSyn ) -> (Name) +happyOut69 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut69 #-} +happyIn70 :: (Type) -> (HappyAbsSyn ) +happyIn70 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn70 #-} +happyOut70 :: (HappyAbsSyn ) -> (Type) +happyOut70 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut70 #-} +happyIn71 :: (PType) -> (HappyAbsSyn ) +happyIn71 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn71 #-} +happyOut71 :: (HappyAbsSyn ) -> (PType) +happyOut71 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut71 #-} +happyIn72 :: (Type) -> (HappyAbsSyn ) +happyIn72 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn72 #-} +happyOut72 :: (HappyAbsSyn ) -> (Type) +happyOut72 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut72 #-} +happyIn73 :: (PType) -> (HappyAbsSyn ) +happyIn73 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn73 #-} +happyOut73 :: (HappyAbsSyn ) -> (PType) +happyOut73 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut73 #-} +happyIn74 :: (Type) -> (HappyAbsSyn ) +happyIn74 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn74 #-} +happyOut74 :: (HappyAbsSyn ) -> (Type) +happyOut74 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut74 #-} +happyIn75 :: (PType) -> (HappyAbsSyn ) +happyIn75 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn75 #-} +happyOut75 :: (HappyAbsSyn ) -> (PType) +happyOut75 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut75 #-} +happyIn76 :: (Type) -> (HappyAbsSyn ) +happyIn76 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn76 #-} +happyOut76 :: (HappyAbsSyn ) -> (Type) +happyOut76 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut76 #-} +happyIn77 :: (PType) -> (HappyAbsSyn ) +happyIn77 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn77 #-} +happyOut77 :: (HappyAbsSyn ) -> (PType) +happyOut77 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut77 #-} +happyIn78 :: (QName) -> (HappyAbsSyn ) +happyIn78 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn78 #-} +happyOut78 :: (HappyAbsSyn ) -> (QName) +happyOut78 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut78 #-} +happyIn79 :: (QName) -> (HappyAbsSyn ) +happyIn79 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn79 #-} +happyOut79 :: (HappyAbsSyn ) -> (QName) +happyOut79 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut79 #-} +happyIn80 :: (QName) -> (HappyAbsSyn ) +happyIn80 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn80 #-} +happyOut80 :: (HappyAbsSyn ) -> (QName) +happyOut80 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut80 #-} +happyIn81 :: (Type) -> (HappyAbsSyn ) +happyIn81 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn81 #-} +happyOut81 :: (HappyAbsSyn ) -> (Type) +happyOut81 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut81 #-} +happyIn82 :: (PType) -> (HappyAbsSyn ) +happyIn82 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn82 #-} +happyOut82 :: (HappyAbsSyn ) -> (PType) +happyOut82 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut82 #-} +happyIn83 :: (PContext) -> (HappyAbsSyn ) +happyIn83 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn83 #-} +happyOut83 :: (HappyAbsSyn ) -> (PContext) +happyOut83 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut83 #-} +happyIn84 :: ([PType]) -> (HappyAbsSyn ) +happyIn84 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn84 #-} +happyOut84 :: (HappyAbsSyn ) -> ([PType]) +happyOut84 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut84 #-} +happyIn85 :: ([PType]) -> (HappyAbsSyn ) +happyIn85 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn85 #-} +happyOut85 :: (HappyAbsSyn ) -> ([PType]) +happyOut85 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut85 #-} +happyIn86 :: ([TyVarBind]) -> (HappyAbsSyn ) +happyIn86 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn86 #-} +happyOut86 :: (HappyAbsSyn ) -> ([TyVarBind]) +happyOut86 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut86 #-} +happyIn87 :: (TyVarBind) -> (HappyAbsSyn ) +happyIn87 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn87 #-} +happyOut87 :: (HappyAbsSyn ) -> (TyVarBind) +happyOut87 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut87 #-} +happyIn88 :: ([Name]) -> (HappyAbsSyn ) +happyIn88 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn88 #-} +happyOut88 :: (HappyAbsSyn ) -> ([Name]) +happyOut88 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut88 #-} +happyIn89 :: ([FunDep]) -> (HappyAbsSyn ) +happyIn89 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn89 #-} +happyOut89 :: (HappyAbsSyn ) -> ([FunDep]) +happyOut89 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut89 #-} +happyIn90 :: ([FunDep]) -> (HappyAbsSyn ) +happyIn90 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn90 #-} +happyOut90 :: (HappyAbsSyn ) -> ([FunDep]) +happyOut90 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut90 #-} +happyIn91 :: (FunDep) -> (HappyAbsSyn ) +happyIn91 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn91 #-} +happyOut91 :: (HappyAbsSyn ) -> (FunDep) +happyOut91 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut91 #-} +happyIn92 :: ([GadtDecl]) -> (HappyAbsSyn ) +happyIn92 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn92 #-} +happyOut92 :: (HappyAbsSyn ) -> ([GadtDecl]) +happyOut92 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut92 #-} +happyIn93 :: ([GadtDecl]) -> (HappyAbsSyn ) +happyIn93 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn93 #-} +happyOut93 :: (HappyAbsSyn ) -> ([GadtDecl]) +happyOut93 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut93 #-} +happyIn94 :: ([GadtDecl]) -> (HappyAbsSyn ) +happyIn94 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn94 #-} +happyOut94 :: (HappyAbsSyn ) -> ([GadtDecl]) +happyOut94 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut94 #-} +happyIn95 :: ([GadtDecl]) -> (HappyAbsSyn ) +happyIn95 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn95 #-} +happyOut95 :: (HappyAbsSyn ) -> ([GadtDecl]) +happyOut95 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut95 #-} +happyIn96 :: (GadtDecl) -> (HappyAbsSyn ) +happyIn96 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn96 #-} +happyOut96 :: (HappyAbsSyn ) -> (GadtDecl) +happyOut96 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut96 #-} +happyIn97 :: ([QualConDecl]) -> (HappyAbsSyn ) +happyIn97 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn97 #-} +happyOut97 :: (HappyAbsSyn ) -> ([QualConDecl]) +happyOut97 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut97 #-} +happyIn98 :: ([QualConDecl]) -> (HappyAbsSyn ) +happyIn98 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn98 #-} +happyOut98 :: (HappyAbsSyn ) -> ([QualConDecl]) +happyOut98 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut98 #-} +happyIn99 :: (QualConDecl) -> (HappyAbsSyn ) +happyIn99 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn99 #-} +happyOut99 :: (HappyAbsSyn ) -> (QualConDecl) +happyOut99 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut99 #-} +happyIn100 :: ([TyVarBind]) -> (HappyAbsSyn ) +happyIn100 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn100 #-} +happyOut100 :: (HappyAbsSyn ) -> ([TyVarBind]) +happyOut100 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut100 #-} +happyIn101 :: (ConDecl) -> (HappyAbsSyn ) +happyIn101 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn101 #-} +happyOut101 :: (HappyAbsSyn ) -> (ConDecl) +happyOut101 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut101 #-} +happyIn102 :: ((Name, [BangType])) -> (HappyAbsSyn ) +happyIn102 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn102 #-} +happyOut102 :: (HappyAbsSyn ) -> ((Name, [BangType])) +happyOut102 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut102 #-} +happyIn103 :: ((Name, [BangType])) -> (HappyAbsSyn ) +happyIn103 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn103 #-} +happyOut103 :: (HappyAbsSyn ) -> ((Name, [BangType])) +happyOut103 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut103 #-} +happyIn104 :: (BangType) -> (HappyAbsSyn ) +happyIn104 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn104 #-} +happyOut104 :: (HappyAbsSyn ) -> (BangType) +happyOut104 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut104 #-} +happyIn105 :: (BangType) -> (HappyAbsSyn ) +happyIn105 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn105 #-} +happyOut105 :: (HappyAbsSyn ) -> (BangType) +happyOut105 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut105 #-} +happyIn106 :: ([([Name],BangType)]) -> (HappyAbsSyn ) +happyIn106 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn106 #-} +happyOut106 :: (HappyAbsSyn ) -> ([([Name],BangType)]) +happyOut106 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut106 #-} +happyIn107 :: (([Name],BangType)) -> (HappyAbsSyn ) +happyIn107 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn107 #-} +happyOut107 :: (HappyAbsSyn ) -> (([Name],BangType)) +happyOut107 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut107 #-} +happyIn108 :: (BangType) -> (HappyAbsSyn ) +happyIn108 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn108 #-} +happyOut108 :: (HappyAbsSyn ) -> (BangType) +happyOut108 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut108 #-} +happyIn109 :: ([Deriving]) -> (HappyAbsSyn ) +happyIn109 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn109 #-} +happyOut109 :: (HappyAbsSyn ) -> ([Deriving]) +happyOut109 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut109 #-} +happyIn110 :: ([Deriving]) -> (HappyAbsSyn ) +happyIn110 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn110 #-} +happyOut110 :: (HappyAbsSyn ) -> ([Deriving]) +happyOut110 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut110 #-} +happyIn111 :: (QName) -> (HappyAbsSyn ) +happyIn111 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn111 #-} +happyOut111 :: (HappyAbsSyn ) -> (QName) +happyOut111 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut111 #-} +happyIn112 :: (Kind) -> (HappyAbsSyn ) +happyIn112 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn112 #-} +happyOut112 :: (HappyAbsSyn ) -> (Kind) +happyOut112 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut112 #-} +happyIn113 :: (Kind) -> (HappyAbsSyn ) +happyIn113 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn113 #-} +happyOut113 :: (HappyAbsSyn ) -> (Kind) +happyOut113 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut113 #-} +happyIn114 :: (Kind) -> (HappyAbsSyn ) +happyIn114 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn114 #-} +happyOut114 :: (HappyAbsSyn ) -> (Kind) +happyOut114 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut114 #-} +happyIn115 :: (Maybe Kind) -> (HappyAbsSyn ) +happyIn115 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn115 #-} +happyOut115 :: (HappyAbsSyn ) -> (Maybe Kind) +happyOut115 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut115 #-} +happyIn116 :: ([ClassDecl]) -> (HappyAbsSyn ) +happyIn116 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn116 #-} +happyOut116 :: (HappyAbsSyn ) -> ([ClassDecl]) +happyOut116 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut116 #-} +happyIn117 :: ([ClassDecl]) -> (HappyAbsSyn ) +happyIn117 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn117 #-} +happyOut117 :: (HappyAbsSyn ) -> ([ClassDecl]) +happyOut117 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut117 #-} +happyIn118 :: ([ClassDecl]) -> (HappyAbsSyn ) +happyIn118 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn118 #-} +happyOut118 :: (HappyAbsSyn ) -> ([ClassDecl]) +happyOut118 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut118 #-} +happyIn119 :: ([ClassDecl]) -> (HappyAbsSyn ) +happyIn119 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn119 #-} +happyOut119 :: (HappyAbsSyn ) -> ([ClassDecl]) +happyOut119 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut119 #-} +happyIn120 :: (ClassDecl) -> (HappyAbsSyn ) +happyIn120 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn120 #-} +happyOut120 :: (HappyAbsSyn ) -> (ClassDecl) +happyOut120 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut120 #-} +happyIn121 :: (ClassDecl) -> (HappyAbsSyn ) +happyIn121 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn121 #-} +happyOut121 :: (HappyAbsSyn ) -> (ClassDecl) +happyOut121 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut121 #-} +happyIn122 :: ([InstDecl]) -> (HappyAbsSyn ) +happyIn122 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn122 #-} +happyOut122 :: (HappyAbsSyn ) -> ([InstDecl]) +happyOut122 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut122 #-} +happyIn123 :: ([InstDecl]) -> (HappyAbsSyn ) +happyIn123 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn123 #-} +happyOut123 :: (HappyAbsSyn ) -> ([InstDecl]) +happyOut123 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut123 #-} +happyIn124 :: ([InstDecl]) -> (HappyAbsSyn ) +happyIn124 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn124 #-} +happyOut124 :: (HappyAbsSyn ) -> ([InstDecl]) +happyOut124 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut124 #-} +happyIn125 :: (InstDecl) -> (HappyAbsSyn ) +happyIn125 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn125 #-} +happyOut125 :: (HappyAbsSyn ) -> (InstDecl) +happyOut125 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut125 #-} +happyIn126 :: (InstDecl) -> (HappyAbsSyn ) +happyIn126 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn126 #-} +happyOut126 :: (HappyAbsSyn ) -> (InstDecl) +happyOut126 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut126 #-} +happyIn127 :: (InstDecl) -> (HappyAbsSyn ) +happyIn127 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn127 #-} +happyOut127 :: (HappyAbsSyn ) -> (InstDecl) +happyOut127 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut127 #-} +happyIn128 :: (Decl) -> (HappyAbsSyn ) +happyIn128 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn128 #-} +happyOut128 :: (HappyAbsSyn ) -> (Decl) +happyOut128 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut128 #-} +happyIn129 :: (Binds) -> (HappyAbsSyn ) +happyIn129 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn129 #-} +happyOut129 :: (HappyAbsSyn ) -> (Binds) +happyOut129 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut129 #-} +happyIn130 :: (Maybe Type) -> (HappyAbsSyn ) +happyIn130 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn130 #-} +happyOut130 :: (HappyAbsSyn ) -> (Maybe Type) +happyOut130 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut130 #-} +happyIn131 :: (Rhs) -> (HappyAbsSyn ) +happyIn131 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn131 #-} +happyOut131 :: (HappyAbsSyn ) -> (Rhs) +happyOut131 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut131 #-} +happyIn132 :: ([GuardedRhs]) -> (HappyAbsSyn ) +happyIn132 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn132 #-} +happyOut132 :: (HappyAbsSyn ) -> ([GuardedRhs]) +happyOut132 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut132 #-} +happyIn133 :: (GuardedRhs) -> (HappyAbsSyn ) +happyIn133 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn133 #-} +happyOut133 :: (HappyAbsSyn ) -> (GuardedRhs) +happyOut133 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut133 #-} +happyIn134 :: (Exp) -> (HappyAbsSyn ) +happyIn134 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn134 #-} +happyOut134 :: (HappyAbsSyn ) -> (Exp) +happyOut134 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut134 #-} +happyIn135 :: (PExp) -> (HappyAbsSyn ) +happyIn135 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn135 #-} +happyOut135 :: (HappyAbsSyn ) -> (PExp) +happyOut135 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut135 #-} +happyIn136 :: (PExp) -> (HappyAbsSyn ) +happyIn136 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn136 #-} +happyOut136 :: (HappyAbsSyn ) -> (PExp) +happyOut136 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut136 #-} +happyIn137 :: (PExp) -> (HappyAbsSyn ) +happyIn137 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn137 #-} +happyOut137 :: (HappyAbsSyn ) -> (PExp) +happyOut137 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut137 #-} +happyIn138 :: (PExp) -> (HappyAbsSyn ) +happyIn138 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn138 #-} +happyOut138 :: (HappyAbsSyn ) -> (PExp) +happyOut138 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut138 #-} +happyIn139 :: (PExp) -> (HappyAbsSyn ) +happyIn139 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn139 #-} +happyOut139 :: (HappyAbsSyn ) -> (PExp) +happyOut139 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut139 #-} +happyIn140 :: (PExp) -> (HappyAbsSyn ) +happyIn140 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn140 #-} +happyOut140 :: (HappyAbsSyn ) -> (PExp) +happyOut140 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut140 #-} +happyIn141 :: (PExp) -> (HappyAbsSyn ) +happyIn141 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn141 #-} +happyOut141 :: (HappyAbsSyn ) -> (PExp) +happyOut141 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut141 #-} +happyIn142 :: (PExp) -> (HappyAbsSyn ) +happyIn142 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn142 #-} +happyOut142 :: (HappyAbsSyn ) -> (PExp) +happyOut142 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut142 #-} +happyIn143 :: ([Pat]) -> (HappyAbsSyn ) +happyIn143 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn143 #-} +happyOut143 :: (HappyAbsSyn ) -> ([Pat]) +happyOut143 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut143 #-} +happyIn144 :: (Pat) -> (HappyAbsSyn ) +happyIn144 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn144 #-} +happyOut144 :: (HappyAbsSyn ) -> (Pat) +happyOut144 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut144 #-} +happyIn145 :: (PExp) -> (HappyAbsSyn ) +happyIn145 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn145 #-} +happyOut145 :: (HappyAbsSyn ) -> (PExp) +happyOut145 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut145 #-} +happyIn146 :: (PExp) -> (HappyAbsSyn ) +happyIn146 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn146 #-} +happyOut146 :: (HappyAbsSyn ) -> (PExp) +happyOut146 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut146 #-} +happyIn147 :: (PExp) -> (HappyAbsSyn ) +happyIn147 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn147 #-} +happyOut147 :: (HappyAbsSyn ) -> (PExp) +happyOut147 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut147 #-} +happyIn148 :: (Int) -> (HappyAbsSyn ) +happyIn148 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn148 #-} +happyOut148 :: (HappyAbsSyn ) -> (Int) +happyOut148 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut148 #-} +happyIn149 :: ([PExp]) -> (HappyAbsSyn ) +happyIn149 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn149 #-} +happyOut149 :: (HappyAbsSyn ) -> ([PExp]) +happyOut149 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut149 #-} +happyIn150 :: (PExp) -> (HappyAbsSyn ) +happyIn150 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn150 #-} +happyOut150 :: (HappyAbsSyn ) -> (PExp) +happyOut150 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut150 #-} +happyIn151 :: ([PExp]) -> (HappyAbsSyn ) +happyIn151 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn151 #-} +happyOut151 :: (HappyAbsSyn ) -> ([PExp]) +happyOut151 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut151 #-} +happyIn152 :: (PExp) -> (HappyAbsSyn ) +happyIn152 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn152 #-} +happyOut152 :: (HappyAbsSyn ) -> (PExp) +happyOut152 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut152 #-} +happyIn153 :: (PExp) -> (HappyAbsSyn ) +happyIn153 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn153 #-} +happyOut153 :: (HappyAbsSyn ) -> (PExp) +happyOut153 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut153 #-} +happyIn154 :: ([PExp]) -> (HappyAbsSyn ) +happyIn154 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn154 #-} +happyOut154 :: (HappyAbsSyn ) -> ([PExp]) +happyOut154 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut154 #-} +happyIn155 :: (PExp) -> (HappyAbsSyn ) +happyIn155 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn155 #-} +happyOut155 :: (HappyAbsSyn ) -> (PExp) +happyOut155 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut155 #-} +happyIn156 :: (XName) -> (HappyAbsSyn ) +happyIn156 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn156 #-} +happyOut156 :: (HappyAbsSyn ) -> (XName) +happyOut156 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut156 #-} +happyIn157 :: (String) -> (HappyAbsSyn ) +happyIn157 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn157 #-} +happyOut157 :: (HappyAbsSyn ) -> (String) +happyOut157 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut157 #-} +happyIn158 :: (String) -> (HappyAbsSyn ) +happyIn158 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn158 #-} +happyOut158 :: (HappyAbsSyn ) -> (String) +happyOut158 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut158 #-} +happyIn159 :: ([ParseXAttr]) -> (HappyAbsSyn ) +happyIn159 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn159 #-} +happyOut159 :: (HappyAbsSyn ) -> ([ParseXAttr]) +happyOut159 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut159 #-} +happyIn160 :: (ParseXAttr) -> (HappyAbsSyn ) +happyIn160 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn160 #-} +happyOut160 :: (HappyAbsSyn ) -> (ParseXAttr) +happyOut160 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut160 #-} +happyIn161 :: (Maybe PExp) -> (HappyAbsSyn ) +happyIn161 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn161 #-} +happyOut161 :: (HappyAbsSyn ) -> (Maybe PExp) +happyOut161 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut161 #-} +happyIn162 :: (PExp) -> (HappyAbsSyn ) +happyIn162 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn162 #-} +happyOut162 :: (HappyAbsSyn ) -> (PExp) +happyOut162 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut162 #-} +happyIn163 :: (PExp) -> (HappyAbsSyn ) +happyIn163 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn163 #-} +happyOut163 :: (HappyAbsSyn ) -> (PExp) +happyOut163 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut163 #-} +happyIn164 :: ([PExp]) -> (HappyAbsSyn ) +happyIn164 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn164 #-} +happyOut164 :: (HappyAbsSyn ) -> ([PExp]) +happyOut164 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut164 #-} +happyIn165 :: ([[QualStmt]]) -> (HappyAbsSyn ) +happyIn165 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn165 #-} +happyOut165 :: (HappyAbsSyn ) -> ([[QualStmt]]) +happyOut165 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut165 #-} +happyIn166 :: ([QualStmt]) -> (HappyAbsSyn ) +happyIn166 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn166 #-} +happyOut166 :: (HappyAbsSyn ) -> ([QualStmt]) +happyOut166 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut166 #-} +happyIn167 :: (QualStmt) -> (HappyAbsSyn ) +happyIn167 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn167 #-} +happyOut167 :: (HappyAbsSyn ) -> (QualStmt) +happyOut167 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut167 #-} +happyIn168 :: (QualStmt) -> (HappyAbsSyn ) +happyIn168 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn168 #-} +happyOut168 :: (HappyAbsSyn ) -> (QualStmt) +happyOut168 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut168 #-} +happyIn169 :: ([Stmt]) -> (HappyAbsSyn ) +happyIn169 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn169 #-} +happyOut169 :: (HappyAbsSyn ) -> ([Stmt]) +happyOut169 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut169 #-} +happyIn170 :: (Stmt) -> (HappyAbsSyn ) +happyIn170 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn170 #-} +happyOut170 :: (HappyAbsSyn ) -> (Stmt) +happyOut170 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut170 #-} +happyIn171 :: ([Alt]) -> (HappyAbsSyn ) +happyIn171 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn171 #-} +happyOut171 :: (HappyAbsSyn ) -> ([Alt]) +happyOut171 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut171 #-} +happyIn172 :: ([Alt]) -> (HappyAbsSyn ) +happyIn172 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn172 #-} +happyOut172 :: (HappyAbsSyn ) -> ([Alt]) +happyOut172 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut172 #-} +happyIn173 :: ([Alt]) -> (HappyAbsSyn ) +happyIn173 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn173 #-} +happyOut173 :: (HappyAbsSyn ) -> ([Alt]) +happyOut173 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut173 #-} +happyIn174 :: (Alt) -> (HappyAbsSyn ) +happyIn174 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn174 #-} +happyOut174 :: (HappyAbsSyn ) -> (Alt) +happyOut174 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut174 #-} +happyIn175 :: (GuardedAlts) -> (HappyAbsSyn ) +happyIn175 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn175 #-} +happyOut175 :: (HappyAbsSyn ) -> (GuardedAlts) +happyOut175 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut175 #-} +happyIn176 :: ([GuardedAlt]) -> (HappyAbsSyn ) +happyIn176 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn176 #-} +happyOut176 :: (HappyAbsSyn ) -> ([GuardedAlt]) +happyOut176 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut176 #-} +happyIn177 :: (GuardedAlt) -> (HappyAbsSyn ) +happyIn177 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn177 #-} +happyOut177 :: (HappyAbsSyn ) -> (GuardedAlt) +happyOut177 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut177 #-} +happyIn178 :: (Pat) -> (HappyAbsSyn ) +happyIn178 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn178 #-} +happyOut178 :: (HappyAbsSyn ) -> (Pat) +happyOut178 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut178 #-} +happyIn179 :: ([Stmt]) -> (HappyAbsSyn ) +happyIn179 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn179 #-} +happyOut179 :: (HappyAbsSyn ) -> ([Stmt]) +happyOut179 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut179 #-} +happyIn180 :: ([Stmt]) -> (HappyAbsSyn ) +happyIn180 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn180 #-} +happyOut180 :: (HappyAbsSyn ) -> ([Stmt]) +happyOut180 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut180 #-} +happyIn181 :: ([PFieldUpdate]) -> (HappyAbsSyn ) +happyIn181 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn181 #-} +happyOut181 :: (HappyAbsSyn ) -> ([PFieldUpdate]) +happyOut181 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut181 #-} +happyIn182 :: (PFieldUpdate) -> (HappyAbsSyn ) +happyIn182 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn182 #-} +happyOut182 :: (HappyAbsSyn ) -> (PFieldUpdate) +happyOut182 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut182 #-} +happyIn183 :: ([IPBind]) -> (HappyAbsSyn ) +happyIn183 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn183 #-} +happyOut183 :: (HappyAbsSyn ) -> ([IPBind]) +happyOut183 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut183 #-} +happyIn184 :: ([IPBind]) -> (HappyAbsSyn ) +happyIn184 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn184 #-} +happyOut184 :: (HappyAbsSyn ) -> ([IPBind]) +happyOut184 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut184 #-} +happyIn185 :: (IPBind) -> (HappyAbsSyn ) +happyIn185 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn185 #-} +happyOut185 :: (HappyAbsSyn ) -> (IPBind) +happyOut185 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut185 #-} +happyIn186 :: (PExp) -> (HappyAbsSyn ) +happyIn186 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn186 #-} +happyOut186 :: (HappyAbsSyn ) -> (PExp) +happyOut186 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut186 #-} +happyIn187 :: (Name) -> (HappyAbsSyn ) +happyIn187 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn187 #-} +happyOut187 :: (HappyAbsSyn ) -> (Name) +happyOut187 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut187 #-} +happyIn188 :: (Name) -> (HappyAbsSyn ) +happyIn188 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn188 #-} +happyOut188 :: (HappyAbsSyn ) -> (Name) +happyOut188 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut188 #-} +happyIn189 :: (QName) -> (HappyAbsSyn ) +happyIn189 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn189 #-} +happyOut189 :: (HappyAbsSyn ) -> (QName) +happyOut189 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut189 #-} +happyIn190 :: (IPName) -> (HappyAbsSyn ) +happyIn190 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn190 #-} +happyOut190 :: (HappyAbsSyn ) -> (IPName) +happyOut190 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut190 #-} +happyIn191 :: (Name) -> (HappyAbsSyn ) +happyIn191 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn191 #-} +happyOut191 :: (HappyAbsSyn ) -> (Name) +happyOut191 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut191 #-} +happyIn192 :: (QName) -> (HappyAbsSyn ) +happyIn192 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn192 #-} +happyOut192 :: (HappyAbsSyn ) -> (QName) +happyOut192 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut192 #-} +happyIn193 :: (Name) -> (HappyAbsSyn ) +happyIn193 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn193 #-} +happyOut193 :: (HappyAbsSyn ) -> (Name) +happyOut193 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut193 #-} +happyIn194 :: (QName) -> (HappyAbsSyn ) +happyIn194 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn194 #-} +happyOut194 :: (HappyAbsSyn ) -> (QName) +happyOut194 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut194 #-} +happyIn195 :: (QName) -> (HappyAbsSyn ) +happyIn195 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn195 #-} +happyOut195 :: (HappyAbsSyn ) -> (QName) +happyOut195 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut195 #-} +happyIn196 :: (Name) -> (HappyAbsSyn ) +happyIn196 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn196 #-} +happyOut196 :: (HappyAbsSyn ) -> (Name) +happyOut196 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut196 #-} +happyIn197 :: (QName) -> (HappyAbsSyn ) +happyIn197 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn197 #-} +happyOut197 :: (HappyAbsSyn ) -> (QName) +happyOut197 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut197 #-} +happyIn198 :: (Op) -> (HappyAbsSyn ) +happyIn198 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn198 #-} +happyOut198 :: (HappyAbsSyn ) -> (Op) +happyOut198 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut198 #-} +happyIn199 :: (QOp) -> (HappyAbsSyn ) +happyIn199 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn199 #-} +happyOut199 :: (HappyAbsSyn ) -> (QOp) +happyOut199 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut199 #-} +happyIn200 :: (QOp) -> (HappyAbsSyn ) +happyIn200 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn200 #-} +happyOut200 :: (HappyAbsSyn ) -> (QOp) +happyOut200 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut200 #-} +happyIn201 :: (QName) -> (HappyAbsSyn ) +happyIn201 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn201 #-} +happyOut201 :: (HappyAbsSyn ) -> (QName) +happyOut201 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut201 #-} +happyIn202 :: (QName) -> (HappyAbsSyn ) +happyIn202 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn202 #-} +happyOut202 :: (HappyAbsSyn ) -> (QName) +happyOut202 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut202 #-} +happyIn203 :: (Name) -> (HappyAbsSyn ) +happyIn203 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn203 #-} +happyOut203 :: (HappyAbsSyn ) -> (Name) +happyOut203 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut203 #-} +happyIn204 :: (Name) -> (HappyAbsSyn ) +happyIn204 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn204 #-} +happyOut204 :: (HappyAbsSyn ) -> (Name) +happyOut204 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut204 #-} +happyIn205 :: (IPName) -> (HappyAbsSyn ) +happyIn205 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn205 #-} +happyOut205 :: (HappyAbsSyn ) -> (IPName) +happyOut205 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut205 #-} +happyIn206 :: (QName) -> (HappyAbsSyn ) +happyIn206 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn206 #-} +happyOut206 :: (HappyAbsSyn ) -> (QName) +happyOut206 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut206 #-} +happyIn207 :: (Name) -> (HappyAbsSyn ) +happyIn207 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn207 #-} +happyOut207 :: (HappyAbsSyn ) -> (Name) +happyOut207 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut207 #-} +happyIn208 :: (QName) -> (HappyAbsSyn ) +happyIn208 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn208 #-} +happyOut208 :: (HappyAbsSyn ) -> (QName) +happyOut208 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut208 #-} +happyIn209 :: (Name) -> (HappyAbsSyn ) +happyIn209 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn209 #-} +happyOut209 :: (HappyAbsSyn ) -> (Name) +happyOut209 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut209 #-} +happyIn210 :: (QName) -> (HappyAbsSyn ) +happyIn210 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn210 #-} +happyOut210 :: (HappyAbsSyn ) -> (QName) +happyOut210 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut210 #-} +happyIn211 :: (QName) -> (HappyAbsSyn ) +happyIn211 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn211 #-} +happyOut211 :: (HappyAbsSyn ) -> (QName) +happyOut211 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut211 #-} +happyIn212 :: (Name) -> (HappyAbsSyn ) +happyIn212 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn212 #-} +happyOut212 :: (HappyAbsSyn ) -> (Name) +happyOut212 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut212 #-} +happyIn213 :: (Name) -> (HappyAbsSyn ) +happyIn213 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn213 #-} +happyOut213 :: (HappyAbsSyn ) -> (Name) +happyOut213 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut213 #-} +happyIn214 :: (QName) -> (HappyAbsSyn ) +happyIn214 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn214 #-} +happyOut214 :: (HappyAbsSyn ) -> (QName) +happyOut214 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut214 #-} +happyIn215 :: (Literal) -> (HappyAbsSyn ) +happyIn215 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn215 #-} +happyOut215 :: (HappyAbsSyn ) -> (Literal) +happyOut215 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut215 #-} +happyIn216 :: (SrcLoc) -> (HappyAbsSyn ) +happyIn216 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn216 #-} +happyOut216 :: (HappyAbsSyn ) -> (SrcLoc) +happyOut216 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut216 #-} +happyIn217 :: (()) -> (HappyAbsSyn ) +happyIn217 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn217 #-} +happyOut217 :: (HappyAbsSyn ) -> (()) +happyOut217 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut217 #-} +happyIn218 :: (()) -> (HappyAbsSyn ) +happyIn218 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn218 #-} +happyOut218 :: (HappyAbsSyn ) -> (()) +happyOut218 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut218 #-} +happyIn219 :: (ModuleName) -> (HappyAbsSyn ) +happyIn219 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn219 #-} +happyOut219 :: (HappyAbsSyn ) -> (ModuleName) +happyOut219 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut219 #-} +happyIn220 :: (Name) -> (HappyAbsSyn ) +happyIn220 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn220 #-} +happyOut220 :: (HappyAbsSyn ) -> (Name) +happyOut220 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut220 #-} +happyIn221 :: (QName) -> (HappyAbsSyn ) +happyIn221 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn221 #-} +happyOut221 :: (HappyAbsSyn ) -> (QName) +happyOut221 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut221 #-} +happyIn222 :: (Name) -> (HappyAbsSyn ) +happyIn222 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn222 #-} +happyOut222 :: (HappyAbsSyn ) -> (Name) +happyOut222 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut222 #-} +happyIn223 :: (QName) -> (HappyAbsSyn ) +happyIn223 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn223 #-} +happyOut223 :: (HappyAbsSyn ) -> (QName) +happyOut223 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut223 #-} +happyIn224 :: (Name) -> (HappyAbsSyn ) +happyIn224 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyIn224 #-} +happyOut224 :: (HappyAbsSyn ) -> (Name) +happyOut224 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut224 #-} +happyInTok :: (Token) -> (HappyAbsSyn ) +happyInTok x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyInTok #-} +happyOutTok :: (HappyAbsSyn ) -> (Token) +happyOutTok x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOutTok #-} + + +happyActOffsets :: HappyAddr +happyActOffsets = HappyA# "\x00\x00\xc7\x18\x53\x17\x00\x00\x85\x1e\x00\x00\x00\x00\x00\x00\x66\x05\xda\x08\x00\x00\x00\x00\xd9\x1d\x00\x00\x00\x00\x00\x00\x57\x08\x00\x00\x9e\x08\xa5\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x1d\x14\x1a\x74\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x08\x00\x00\x00\x00\x00\x00\x3d\x0a\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\xf8\x1c\x00\x00\xae\x08\x00\x00\x00\x00\x00\x00\x38\x08\x00\x00\x83\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x0a\x36\x04\xd7\x16\x00\x00\x00\x00\x4e\x1d\x4e\x1d\x4e\x1d\xc7\x18\x00\x00\xc7\x18\xc7\x18\xc7\x18\x6f\x1e\x00\x00\xcb\x1b\x1a\x1f\x00\x00\xc7\x18\xc7\x18\x9b\x08\xc7\x18\x9a\x08\x97\x08\xa2\x1c\xa3\x08\xa1\x08\x96\x08\x24\x08\x00\x00\x24\x08\x5f\x08\x00\x00\x00\x00\xa9\x01\x00\x00\x98\x08\x2f\x08\x2a\x08\x75\x08\x00\x00\x4e\x1d\x00\x00\x8b\x10\x8b\x10\x00\x00\x3f\x08\x00\x00\x00\x00\x2b\x08\x00\x00\x23\x08\x46\x08\x00\x00\x00\x00\x2a\x02\x22\x04\x65\x08\x00\x00\x00\x00\xb4\x07\x00\x00\x51\x08\x4e\x08\xa2\x20\x4d\x08\x68\x08\x61\x08\x98\x01\x00\x00\x4c\x1c\x00\x00\xf6\x1b\x5d\x08\xae\x04\x5a\x08\x53\x08\x00\x00\xc6\x03\x00\x00\x00\x00\x7f\x04\xb2\x03\x46\x03\x5c\x08\x00\x00\x00\x00\xc7\x18\x5b\x08\x00\x00\x00\x00\x59\x08\x00\x00\x00\x00\x00\x00\x55\x08\x54\x08\x00\x00\x00\x00\x00\x00\x00\x00\xd1\x1c\x52\x08\x00\x00\xa0\x1b\x50\x08\x4f\x08\x2c\x1b\xd0\x12\x4e\x1d\x4e\x1d\x36\x1f\x00\x00\x00\x00\x00\x00\x4b\x18\x00\x00\x00\x00\x00\x00\x00\x00\xd1\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcf\x17\xcf\x17\xcf\x17\xcf\x17\x58\x08\x2f\x1e\xaa\x1d\x4e\x1d\xcf\x17\x67\x01\x6f\x1e\x04\x08\x4a\x08\xf7\x07\x00\x00\x00\x00\x00\x00\x6f\x1e\x00\x00\xe0\x10\x3e\x08\x7b\x1c\x3e\x08\x40\x08\xbb\x1f\xbb\x1f\xa7\x1f\x3b\x08\x19\x1e\x00\x00\x00\x00\xa4\x00\x56\x00\x00\x00\x2c\x08\x69\x01\x36\x08\x16\x08\x3d\x03\x2e\x08\x00\x00\x25\x08\x06\x1f\xe8\x0f\x00\x00\x06\x1f\x00\x00\x06\x1f\x00\x00\x00\x00\x00\x0d\x6f\x1e\x06\x1f\xa9\x00\x21\x08\xce\x04\xf5\x07\x2c\x1b\xb6\x07\xb5\x07\xa9\x07\x27\x08\xba\x04\x00\x00\x00\x00\x00\x00\x98\x19\x00\x00\x0c\x08\x0b\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\x0f\x00\x00\x00\x00\xfc\x01\x00\x00\x00\x00\xe8\x0f\x06\x1f\x00\x00\x00\x00\x00\x00\x75\x1b\x6f\x1e\x41\x00\x00\x00\x1c\x08\x08\x08\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x06\x1a\x00\xfe\xff\x00\x00\x09\x08\x8e\x1f\x6f\x01\xfe\x07\xd5\x02\x6f\x1e\x8e\x1f\xf6\x07\xe8\x0f\x06\x1f\xa7\x07\x6f\x1e\xe8\x0f\x6f\x1e\xf0\x07\xed\x06\xed\x06\x02\x08\xee\x07\xee\x07\xbf\x19\x8e\x1f\x6f\x1e\x57\x02\x6f\x1e\x8d\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x1e\xf2\x07\x00\x00\x00\x00\x53\x02\x00\x00\x00\x00\xeb\x07\xe9\x07\xd5\x02\x00\x00\x00\x00\x00\x00\x00\x00\xf1\x07\x00\x00\x00\x00\xd6\x07\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\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\xe2\x07\x00\x00\x00\x00\xe5\x07\x00\x00\x00\x00\xcf\x17\x00\x00\xcf\x17\xcf\x17\x00\x00\xcf\x17\x00\x00\xcf\x17\x5b\x16\xff\x11\x05\x1b\x00\x00\xcf\x17\x00\x00\xdf\x15\x00\x00\x00\x00\x43\x19\x00\x00\x00\x00\xa9\x00\x00\x00\x00\x00\xe1\x07\x00\x00\xde\x07\xcf\x17\x00\x00\xab\x0c\xdb\x07\xd9\x07\xa9\x00\xa9\x00\xcf\x17\xda\x07\xc6\x07\x00\x00\xd1\x07\x8b\x10\xd4\x07\xc7\x07\xa9\x00\x00\x00\xcf\x17\x00\x00\x00\x00\xbc\x07\x94\x07\x1e\x00\x00\x00\x00\x00\x00\x00\x11\x07\x5b\x06\x00\x00\x00\x00\xc4\x07\x45\x08\xa9\x00\x00\x00\xd2\x07\x00\x00\x00\x00\xc1\x07\x6a\x00\x00\x00\x00\x00\xae\x07\xa3\x0d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x10\x00\x00\x7a\x07\x00\x00\x00\x00\x00\x00\xbf\x09\xba\x07\x9b\x07\x00\x00\xd3\x00\x00\x00\x00\x00\xb8\x07\x00\x00\x00\x00\xcf\x17\xa5\x07\xa8\x07\x00\x00\x00\x00\x00\x00\x63\x15\x00\x00\x5d\x02\x00\x00\x00\x00\x00\x00\xa1\x07\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x2c\x1b\x3b\x1a\x00\x00\xb2\x07\xcf\x17\x00\x00\xe1\x06\x00\x00\x00\x00\xa6\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xec\x1f\x57\x02\x69\x07\x50\x07\xfc\x01\x00\x00\x0b\x04\xed\x00\x00\x00\x4f\x07\x96\x07\x00\x00\x95\x07\xcf\x17\x48\x07\xaf\x1a\x25\x07\x00\x00\x00\x00\x12\x07\x45\x07\x00\x00\x8f\x07\x9f\x07\x00\x00\x7e\x07\x00\x00\x00\x00\x00\x00\x80\x07\x89\x07\x00\x00\x74\x07\x6f\x1e\x17\x07\x15\x07\x6f\x1e\x77\x07\x85\x07\x65\x07\x2d\x07\x7b\x07\x00\x00\x84\x0c\x00\x00\x72\x07\x70\x07\x84\x0c\x00\x00\x00\x00\x00\x00\x5b\x07\x06\x1f\x00\x00\x6b\x07\x00\x00\x51\x07\xfc\x01\x00\x00\x00\x00\x5a\x07\x00\x00\x00\x00\x00\x00\xea\x06\x56\x07\x00\x00\x00\x00\x00\x00\x00\x00\x3b\x1a\x5f\x07\x00\x00\x4c\x07\xfc\x01\x00\x00\xfc\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcf\x17\xd8\x1f\x6f\x1e\x3b\x07\x00\x00\xdc\x06\x37\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x1e\x00\x00\x00\x00\x00\x00\x00\x00\x99\x1d\x32\x07\x00\x00\x00\x00\x35\x07\x00\x00\x1b\x07\x00\x00\x7f\x07\x40\x04\x12\x07\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x07\x00\x00\xe7\x14\x00\x00\x00\x00\xc2\x1f\x6f\x1e\x01\x07\x00\x00\xc7\x06\x00\x00\x06\x07\x00\x00\x72\x03\xc2\x06\xac\x06\xf6\x06\xe6\x06\x8d\x05\x00\x00\x00\x00\x00\x00\xe8\x06\x00\x00\x2d\x06\xf9\x03\xe5\x03\x83\x03\x6f\x03\x5b\x03\x4d\x03\x23\x03\xf7\x02\xcf\x02\xce\x01\x63\x01\x00\x00\x00\x00\xcf\x17\x6b\x14\xb6\x06\xec\x00\xff\x11\xff\x11\x00\x00\x9f\x06\xd0\x06\xef\x13\x00\x00\x00\x00\x00\x00\xdd\x06\xd5\x06\xa9\x00\xcf\x17\xc4\x06\x6d\x06\xcb\x06\x27\x0d\xcb\x06\x00\x00\xcf\x17\x93\x0f\x93\x0f\xb3\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x09\x00\x00\xc6\x06\xc5\x06\xb4\x06\x39\x06\x35\x06\x40\x06\x00\x00\xaf\x1e\x36\x06\xc3\x08\x8e\x06\x00\x00\x90\x06\x00\x00\x00\x00\x78\x06\x00\x00\x17\x0f\x00\x00\x3c\x06\xcf\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x13\x00\x00\xcf\x17\x68\x06\x00\x00\xcf\x17\xcf\x17\xcf\x17\x00\x00\x00\x00\x00\x00\x00\x00\x4e\x1d\x00\x00\x00\x00\x00\x00\x74\x06\x00\x00\x00\x00\x00\x00\x10\x0b\x33\x06\x00\x00\x00\x00\x00\x00\xef\x07\x00\x00\x00\x00\x00\x00\x00\x00\x40\x04\x42\x02\x00\x00\x00\x00\x6e\x06\x57\x06\x06\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9b\x0e\x5f\x06\xa9\x00\x00\x00\x59\x1e\x00\x00\x00\x00\xfe\x05\x38\x06\x46\x06\x00\x00\x75\x1b\x51\x06\x42\x06\x00\x00\x00\x00\x00\x00\xf3\x05\x00\x00\x00\x00\x00\x00\xcf\x17\x24\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf7\x12\x75\x1b\x00\x00\x37\x0b\x1c\x06\xa9\x00\x00\x00\x06\x1f\x00\x00\xcf\x17\x00\x00\x02\x1e\x00\x00\xf5\x06\x16\x06\x00\x00\x00\x00\xaf\x07\xab\x01\x34\x06\x10\x06\xa3\x1d\x06\x1f\xa2\x05\xf5\x05\xf7\x05\xa9\x00\x00\x00\xfc\x05\xf4\x05\x00\x00\xb2\x05\x00\x00\x32\x05\x00\x00\x00\x00\x7a\x05\x00\x00\xbd\x05\x83\x11\xc1\x05\x00\x00\xaf\x05\x1f\x0e\xac\x05\x00\x00\x00\x00\x4e\x05\x36\x05\x9c\x05\x84\x05\x00\x00\x00\x00\x00\x00\x9a\x05\x00\x00\x1d\x06\x8f\x05\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x1f\x88\x05\xf2\x1e\x00\x00\x00\x00\x89\x05\x00\x00\x86\x05\x00\x00\x00\x00\x14\x05\x5a\x05\x00\x00\x58\x05\xcf\x17\xcf\x17\x00\x00\x00\x00\x00\x00\x2c\x1b\xcf\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x03\x4f\x05\x00\x00\x00\x00\x68\x05\x25\x1c\x99\x07\x78\x05\x00\x00\x00\x00\xda\x1e\xf4\x04\x52\x07\xda\x1e\xda\x1e\xef\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2f\x0c\x59\x1e\x51\x20\x00\x00\xda\x1e\x51\x05\x07\x11\x53\x05\x59\x1e\x00\x00\x28\x04\x2c\x1b\x56\x05\x00\x00\x76\x1f\x3e\x05\x59\x1e\x57\x02\x59\x1e\xe8\x0f\xb3\x0b\x43\x05\x2b\x05\x00\x00\xda\x1e\x59\x07\x00\x00\x18\x05\x00\x00\xda\x1e\x00\x00\x4f\x00\x52\x00\x00\x00\x00\x00\x27\x05\xda\x1e\x20\x05\x56\x01\x40\x03\x04\x05\x00\x00\xe1\x00\xed\x04\x00\x00\x00\x00\x7b\x12\x00\x00\x00\x00\xb0\x04\x1d\x06\x00\x00\x00\x00\x00\x00\xc5\x02\x00\x00\x00\x00\x00\x00\x00\x00\x19\x05\x00\x00\x00\x00\x08\x0c\xc7\x04\x00\x00\x6e\x02\x00\x00\x00\x00\x00\x00\x59\x1e\x00\x00\x00\x00\x27\x1d\xfc\x06\xda\x1e\xda\x1e\x00\x00\xfe\x04\xf9\x04\xe6\x04\xe6\x04\xad\x04\x80\x04\x00\x00\x59\x1e\x6a\x04\x00\x00\xa0\x04\x00\x00\x00\x00\x00\x00\xca\x04\x00\x00\x00\x00\x00\x00\x59\x1e\x00\x00\x00\x00\x00\x00\x00\x00\xda\x1e\x61\x04\x00\x00\x00\x00\xcf\x17\x15\x00\x1d\x06\x00\x00\x00\x00\x00\x00\x00\x00\xc2\x04\x00\x00\x00\x00\x9c\x04\x00\x00\x00\x00\x65\x04\x00\x00\xda\x1e\xf0\x0e\xa7\x04\x98\x04\x00\x00\x00\x00\x00\x00\x90\x04\x00\x00\x4a\x1f\x81\x04\x8c\x0b\x00\x00\x00\x00\x00\x00\x41\x02\x00\x00\x7b\x04\x00\x00\x00\x00\x00\x00"# + +happyGotoOffsets :: HappyAddr +happyGotoOffsets = HappyA# "\x01\x00\xe0\x27\x34\x2a\x4a\x00\xdf\x03\x08\x00\x06\x00\x05\x00\x0c\x00\x00\x00\x00\x00\x00\x00\xef\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\x8b\x02\x30\x05\x44\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3f\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x78\x00\x00\x00\x00\x00\x00\x00\xb1\x07\x00\x00\x00\x00\x00\x00\x8e\x31\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\x00\x00\x00\x00\x00\x00\x00\xff\x27\xfe\x03\x51\x28\x00\x00\xb5\x03\x4e\x31\x34\x2f\x38\x31\x15\x2a\x00\x00\x8d\x27\x6e\x27\x94\x2e\xcb\x03\xae\x03\xd1\x06\xbf\x01\x00\x00\x0e\x2e\xbc\x2d\xa5\x00\x9d\x2d\x28\x00\x22\x00\xa0\x2f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x0d\x00\xfc\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x30\x00\x00\xfd\x23\xaa\x23\x00\x00\x00\x00\x6f\x00\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf1\x00\xe1\x03\x00\x00\x00\x00\x00\x00\x20\x08\x36\x00\x00\x00\x00\x00\x55\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe2\x30\x00\x00\x4a\x2f\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\x75\x2e\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\x76\x06\x00\x00\x00\x00\x34\x2f\x00\x00\x00\x00\xd8\x06\xf2\x01\xa2\x30\x8c\x30\x58\x02\x00\x00\x00\x00\x00\x00\xdc\x2e\x00\x00\x00\x00\x00\x00\x00\x00\x29\x06\x00\x00\x98\x03\x00\x00\x00\x00\x00\x00\x4b\x2d\x2c\x2d\xda\x2c\xbb\x2c\x45\x04\xcb\x04\x62\x06\x4c\x30\x1b\x27\x00\x00\xa6\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x91\x04\x00\x00\x90\x05\x2b\x04\x3c\x05\x27\x04\xb0\x05\xa8\x03\x08\x03\xe9\x00\x00\x00\xef\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\x7f\x05\x1c\x05\x00\x00\x69\x05\x00\x00\x55\x05\x00\x00\x00\x00\xf9\x05\x7d\x04\xca\x05\x88\x03\x00\x00\x00\x00\x00\x00\xaa\x06\x00\x00\x00\x00\x00\x00\x0f\x00\x0a\x00\x00\x00\x00\x00\x00\x00\x6a\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x05\x00\x00\x00\x00\xa7\x06\x00\x00\x00\x00\xf3\x04\xa9\x05\x00\x00\x00\x00\x00\x00\xf7\x01\x69\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x96\x02\x00\x00\x00\x00\x00\x00\x19\x04\x3d\x04\x00\x00\x00\x00\x69\x02\x55\x04\x3e\x03\x00\x00\xdf\x04\xdd\x01\xd9\x03\x41\x04\x2e\x01\x07\x04\xea\x03\xf6\x03\xe2\x03\x00\x00\xdb\x00\xd0\xff\xf2\x2e\xe3\xff\xb3\x03\xb4\x01\x91\x03\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7d\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x64\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\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\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\x70\x28\x00\x00\xc3\x29\x69\x2c\x00\x00\xa4\x29\x00\x00\x52\x29\x4a\x2c\xc6\x1f\x8a\x2f\x00\x00\xf8\x2b\x00\x00\x65\x21\x00\x00\x00\x00\xdc\x2e\x00\x00\x00\x00\x5f\x03\xc5\x05\x00\x00\x00\x00\x00\x00\x96\xff\xd9\x2b\x00\x00\xfb\xff\x00\x00\x00\x00\x4b\x03\x37\x03\x87\x2b\x00\x00\x00\x00\x25\x03\x00\x00\x57\x23\x17\x00\xe0\xff\x31\x03\x00\x00\x68\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x00\x00\xc8\x06\xb7\x06\x1e\x03\xd5\x03\x00\x00\x00\x00\x00\x00\x1b\x00\xfb\x02\xf5\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x23\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbc\x05\x00\x00\x81\x05\x00\x00\xdf\x00\x00\x00\x00\x00\x00\x00\x1f\x00\x11\x00\x37\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf1\x02\x12\x00\x00\x00\x00\x00\x16\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfc\x26\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x05\xf6\x2f\x00\x00\x00\x00\xf7\x2a\x00\x00\xcd\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x35\x04\x8f\x01\x58\x03\x00\x00\x3b\x06\x2b\x00\x00\x00\x00\x00\x00\x00\x38\x03\xb2\xff\x00\x00\x00\x00\xa9\x26\x2e\x03\x00\x00\x6b\x03\x00\x00\x00\x00\x2c\x00\x05\x03\xd7\x04\x14\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc2\x02\x00\x00\x00\x00\xd4\x02\x69\x03\x00\x00\x00\x00\xd3\x01\x00\x00\x00\x00\x00\x00\x26\x03\x06\x03\x00\x00\x05\x01\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x02\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x02\xe0\x2f\x07\x00\x00\x00\x00\x00\x5c\x04\x00\x00\xfb\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2d\x2e\x48\x00\xb8\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x55\x03\x20\x01\x71\x00\x00\x00\x00\x00\xd0\x01\x00\x00\x00\x00\x00\x00\xb3\xff\x00\x00\x00\x00\x00\x00\x1f\x02\x5b\x02\xf0\xff\x00\x00\x00\x00\x00\x00\x00\x00\xf7\xff\x00\x00\x12\x21\x00\x00\x00\x00\x8b\x01\x41\x03\x00\x00\x00\x00\xbd\x02\x00\x00\x4e\x00\x00\x00\xbf\x00\xae\x02\x00\x00\x00\x00\x00\x00\x15\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x33\x29\xa5\x2a\x00\x00\x00\x00\x6c\x20\x19\x20\x00\x00\x00\x00\x00\x00\xb1\x22\x00\x00\x00\x00\x00\x00\xc6\x00\x00\x00\x3d\x02\x86\x2a\x00\x00\xd8\xff\x00\x00\x3e\x00\x00\x00\x00\x00\x8a\x26\x5e\x22\x0b\x22\x00\x00\x04\x00\x00\x00\x08\x05\x00\x00\x00\x00\x78\x00\x00\x00\xa4\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\xa8\x02\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\x00\x00\x00\x0a\x02\x37\x26\x00\x00\x00\x00\x00\x00\xf7\x04\x00\x00\xe1\x28\x00\x00\x18\x26\x00\x00\x00\x00\xc5\x25\xa6\x25\x53\x25\x00\x00\x00\x00\x71\x02\x00\x00\x36\x30\x00\x00\x00\x00\x00\x00\x46\x00\x00\x00\x00\x00\x00\x00\x1d\x04\x9a\x02\x00\x00\x4f\x02\x45\x02\xb6\x05\x7b\x02\xbc\xff\x00\x00\x00\x00\xdb\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc9\x01\x00\x00\x3a\x01\x73\x00\x0f\x02\x00\x00\x52\x02\x78\x02\x00\x00\x7a\x01\x00\x00\x90\x01\x00\x00\x00\x00\x00\x00\x00\x00\xf8\xff\x00\x00\x27\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x01\x00\x00\x00\x00\x34\x25\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\x04\x00\x00\x00\x00\x00\x00\x00\x00\xfe\x00\xd0\x01\x00\x00\xf5\xff\x00\x00\x4f\x01\x00\x00\xa4\x01\x00\x00\xe1\x24\x00\x00\xe9\x00\x00\x00\x6a\x02\x00\x00\x00\x00\x00\x00\x37\x04\xa0\x01\x00\x00\x00\x00\xfe\x01\x43\x06\x00\x00\xd1\xff\x00\x00\x3f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x79\x01\x00\x00\xc1\xff\x00\x00\x00\x00\x00\x00\x00\x00\x93\x01\xa8\x00\x00\x00\x00\x00\x00\x00\xb8\x21\x00\x00\x00\x00\x00\x00\x02\x02\x00\x00\x00\x00\xc5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf3\x00\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x72\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x91\x01\x00\x00\x00\x00\x00\x00\x00\x00\x38\x01\xa2\x00\x00\x00\x00\x00\xc2\x24\x6f\x24\x00\x00\x00\x00\x00\x00\x9d\x05\xc2\x28\x00\x00\x00\x00\x00\x00\x00\x00\x92\x04\x00\x00\x65\x02\x00\x00\x00\x00\x00\x00\x00\x00\x47\x01\xe3\x05\xd2\x00\x00\x00\x00\x00\x2f\x06\x00\x00\xdb\x05\x95\x05\x23\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7c\x02\x00\x00\x00\x00\x97\x00\x29\x03\x62\x06\x00\x00\x9a\x01\xa7\x00\x77\x01\x00\x00\xf3\x02\x00\x00\xc1\xff\x09\x05\x00\x00\x00\x00\x24\x03\x00\x00\xdf\x02\x71\x01\xf3\x03\xe7\x01\x24\x00\x00\x00\x00\x00\x00\x00\x6a\x02\x6a\x02\x00\x00\x00\x00\x00\x00\x6a\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1b\x06\x00\x00\x2d\x04\xc6\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbf\x20\x00\x00\x00\x00\x00\x00\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x00\x33\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcb\x02\x00\x00\x00\x00\x8f\x00\x2e\x02\x0a\x06\x05\x06\x00\x00\x00\x00\x00\x00\x14\x01\xc7\x00\xac\x00\x00\x00\x00\x00\xb7\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe1\xff\x00\x00\x00\x00\x00\x00\xa0\x02\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x05\x00\x00\x00\x00\x00\x00\x50\x24\x4c\x05\xe4\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2d\x00\x00\x00\x95\x02\xfd\xff\x00\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x70\x00\x00\x00\xf6\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"# + +happyDefActions :: HappyAddr +happyDefActions = HappyA# "\xc0\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc0\xfd\x00\x00\x00\x00\xf2\xff\x00\x00\x52\xff\x39\xff\x59\xff\x4f\xff\x4d\xff\x46\xff\x00\x00\x3c\xff\x00\x00\x00\x00\xe5\xfd\xb9\xfd\x05\xfe\x3f\xff\xdf\xfd\x4c\xff\xec\xfd\xe1\xfd\xe0\xfd\xdd\xfd\xde\xfd\x00\x00\x00\x00\x00\x00\xe8\xfd\xe4\xfd\xe3\xfd\xe2\xfd\xe7\xfd\xe6\xfd\xeb\xfd\x32\xff\xe9\xfd\xea\xfd\x8b\xff\x00\x00\x96\xff\x8c\xff\x8a\xff\xc1\xfd\x25\xfe\xce\xfe\xc8\xfe\xc7\xfe\xc5\xfe\xc2\xfe\xb9\xfe\xb8\xfe\xb3\xfe\xab\xfe\xa7\xfe\x9a\xfe\xc3\xfe\x00\x00\xa4\xfe\xa5\xfe\xa6\xfe\x0c\xfe\x07\xfe\xee\xfd\x02\xfe\xa3\xfe\x00\x00\xed\xfd\x4a\xfe\xcb\xfd\xc9\xfd\xca\xfd\xc8\xfd\xc7\xfd\xc6\xfd\xc5\xfd\xc4\xfd\xc3\xfd\xc2\xfd\xc1\xfd\x00\x00\xc1\xfd\x9e\xfe\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x99\xfe\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc0\xfd\x00\x00\x00\x00\x8f\xfe\xc1\xfd\xc1\xfd\xc0\xfd\xc1\xfd\xc0\xfd\xc0\xfd\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xd0\xfe\x00\x00\xc1\xfd\xf9\xff\xf7\xff\xc0\xfd\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xb0\xfe\xc1\xfd\xba\xfe\xc1\xfd\xc1\xfd\x7e\xff\x00\x00\xde\xff\xde\xff\x00\x00\xbb\xfe\x00\x00\x00\x00\x90\xfe\x91\xfe\x00\x00\x00\x00\x00\x00\x93\xfe\x92\xfe\x00\x00\xc1\xfd\x00\x00\x00\x00\xc7\xfe\x00\x00\x00\x00\x87\xfe\x00\x00\x24\xfe\xbc\xfe\xac\xfe\xc1\xfd\x8a\xfe\x49\xfe\x00\x00\x48\xfe\x10\xfe\x00\x00\x0e\xfe\x8d\xfe\x8a\xfe\x00\x00\x00\x00\x00\x00\xf2\xfd\xf1\xfd\xc1\xfd\xf8\xfd\xef\xfd\xdc\xfd\x00\x00\xfc\xfd\xd9\xfd\xd7\xfd\xd6\xfd\xd0\xfd\xda\xfd\xcc\xfd\xdb\xfd\x11\xfe\x00\x00\xce\xfd\xf0\xfd\xd4\xfd\xcf\xfd\xcd\xfd\x00\x00\x00\x00\xc1\xfd\xc1\xfd\x00\x00\xb4\xfe\xf4\xfd\xf3\xfd\xcd\xfe\xf8\xfd\xfe\xfd\xd8\xfd\xd5\xfd\x00\x00\xd2\xfd\xc1\xfd\xd4\xfd\xd3\xfd\xd1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xb2\xff\x00\x00\xd6\xfe\xc1\xfd\xc1\xfd\x00\x00\x00\x00\x95\xff\x00\x00\x00\x00\xb0\xff\xaf\xff\xae\xff\x00\x00\x94\xff\x00\x00\x6c\xff\x00\x00\x6c\xff\x6e\xff\x60\xff\x60\xff\x00\x00\x00\x00\x59\xff\x43\xff\x35\xff\x00\x00\x00\x00\x41\xff\x39\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x45\xff\x00\x00\x00\x00\x00\x00\x50\xff\x00\x00\x3d\xff\x00\x00\xb7\xfd\xb6\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf2\xff\xf4\xff\xbe\xfd\xbf\xfd\x55\xff\x56\xff\x00\x00\x00\x00\x57\xff\x58\xff\x3a\xff\x53\xff\x44\xff\x3e\xff\x42\xff\x8e\xfe\x00\x00\x4b\xff\x48\xff\x00\x00\x40\xff\x4a\xff\x00\x00\x00\x00\x49\xff\x33\xff\x31\xff\x00\x00\x00\x00\x00\x00\x61\xff\x00\x00\x5e\xff\x5b\xff\x5c\xff\x0b\xfe\x04\xfe\x00\x00\x00\x00\x00\x00\x6f\xff\x6c\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe7\xfe\x00\x00\x91\xff\x00\x00\x2d\xff\x00\x00\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\x00\x00\x21\xff\x00\x00\x00\x00\xb1\xff\xc9\xfe\xca\xfe\xcb\xfe\xcc\xfe\x00\x00\x00\x00\xc6\xfe\xc4\xfe\x00\x00\x19\xfe\x17\xfe\x00\x00\x0b\xfe\x00\x00\xaa\xfe\x16\xfe\xad\xfe\xae\xfe\x00\x00\x54\xff\x4e\xfe\x7b\xfe\x77\xfe\x7a\xfe\x79\xfe\x78\xfe\x73\xfe\x72\xfe\x71\xfe\x70\xfe\x6f\xfe\x6e\xfe\x6d\xfe\x6c\xfe\x6b\xfe\x6a\xfe\x75\xfe\x74\xfe\x69\xfe\x68\xfe\x67\xfe\x66\xfe\x65\xfe\x64\xfe\x63\xfe\x62\xfe\x61\xfe\x60\xfe\x5f\xfe\x5e\xfe\x5d\xfe\x5c\xfe\x5b\xfe\x5a\xfe\x59\xfe\x58\xfe\x57\xfe\x56\xfe\x55\xfe\x54\xfe\x53\xfe\x76\xfe\x52\xfe\x51\xfe\x50\xfe\x00\x00\x06\xfe\x01\xfe\x00\x00\x9d\xfe\xa2\xfe\xc1\xfd\x0f\xfe\xc1\xfd\xc1\xfd\x0d\xfe\xc1\xfd\xa0\xfe\xc1\xfd\x47\xfe\xc1\xfd\xc1\xfd\xb1\xfe\xc1\xfd\x9c\xfe\xc1\xfd\x98\xfe\x97\xfe\xc1\xfd\x96\xfe\x95\xfe\x00\x00\xde\xff\xa9\xff\x00\x00\x82\xfe\xc0\xfd\xc1\xfd\xdf\xff\x8f\xff\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x1c\xfe\xd0\xfe\xc1\xfd\x00\x00\xc1\xfd\xc0\xfd\xc0\xfd\x00\x00\xaf\xfe\xc1\xfd\xb7\xfe\xb6\xfe\x00\x00\x00\x00\xc0\xfd\xea\xff\xde\xff\xde\xff\x00\x00\xe7\xff\xbd\xfd\xbc\xfd\x00\x00\xe1\xff\x00\x00\xc1\xfd\x00\x00\xbe\xfe\x22\xfe\x00\x00\x00\x00\x1e\xfe\x23\xfe\x00\x00\x1d\xfe\xc0\xfe\x7c\xff\x88\xff\x7d\xff\x89\xff\xde\xff\x8d\xff\xde\xff\x13\xfe\xc1\xfd\xe0\xff\x00\x00\xbd\xfe\xde\xff\xde\xff\xdf\xff\xab\xff\x00\x00\x32\xfe\x00\x00\x34\xfe\xc1\xfd\xc0\xfd\x88\xfe\xb2\xfe\xc1\xfd\x43\xfe\x3f\xfe\x3d\xfe\x3c\xfe\x3b\xfe\xc1\xfd\x45\xfe\x8a\xfe\x41\xfe\x42\xfe\x89\xfe\x85\xfe\x86\xfe\x00\x00\x8b\xfe\x9f\xfe\xfb\xfd\x00\x00\xc1\xfd\xa8\xfe\x00\x00\xc1\xfd\xa9\xfe\x00\x00\xfd\xfd\xcf\xfe\xb3\xff\xf6\xfd\xf5\xfd\xac\xff\xfa\xfd\x00\xfe\x00\x00\x21\xff\x04\xff\x00\x00\x00\x00\xc1\xfd\x87\xff\x00\x00\x7a\xff\xd8\xfe\xd4\xfe\xd2\xfe\x00\x00\xc1\xfd\xd8\xfe\x9c\xff\x74\xff\x79\xff\x78\xff\x00\x00\xf5\xfe\x2e\xff\xf8\xfe\x00\x00\x92\xff\x54\xff\x93\xff\x9e\xff\x9f\xff\xc0\xfd\x00\x00\x5a\xff\xf8\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\xff\x70\xff\x99\xff\x62\xff\x98\xff\x00\x00\x00\x00\x00\x00\x5f\xff\x97\xff\x3b\xff\x00\x00\x55\xff\x34\xff\x00\x00\xfe\xfe\xfd\xfe\x00\x00\xfa\xfe\xfb\xfe\x36\xff\xb8\xfd\xf7\xfd\xf3\xff\x00\x00\xec\xff\xf0\xff\xee\xff\xef\xff\x4e\xfe\xc1\xfd\x00\x00\xf1\xff\x00\x00\x00\x00\x47\xff\x00\x00\x5d\xff\x0a\xfe\x03\xfe\x63\xff\x71\xff\xc1\xfd\x00\x00\x00\x00\x00\x00\x6b\xff\x00\x00\x81\xff\x7f\xff\x82\xff\x85\xff\xa8\xff\xa7\xff\x00\x00\xde\xff\xde\xff\x9d\xff\xa3\xff\x00\x00\x2c\xff\x2a\xff\xa0\xff\xc0\xfd\x9a\xff\x00\x00\x09\xfe\x00\x00\x00\x00\x00\x00\x77\xff\x76\xff\x75\xff\xda\xfe\xc0\xfd\xd5\xfe\xc1\xfd\xd3\xfe\xdb\xfe\x00\x00\x00\x00\x20\xff\x1e\xff\x1a\xff\xf7\xfe\xc0\xfd\xa5\xff\x00\x00\x04\xff\x00\x00\x00\x00\x00\x00\x00\x00\x1a\xfe\x18\xfe\x4c\xfe\x00\x00\x4f\xfe\x00\x00\xec\xfd\xdd\xfd\xe8\xfd\xe4\xfd\xe3\xfd\xe2\xfd\xe7\xfd\xe6\xfd\xeb\xfd\xe9\xfd\xea\xfd\x7c\xfe\xa1\xfe\xc1\xfd\x46\xfe\x3a\xfe\x00\x00\xc1\xfd\xc1\xfd\xc1\xfe\x31\xfe\x00\x00\xc1\xfd\x9b\xfe\x94\xfe\xaa\xff\xc1\xfd\x00\x00\x00\x00\xc1\xfd\xa6\xfe\xdf\xff\x15\xfe\xdf\xff\x90\xff\x1f\xfe\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\xe5\xff\xde\xff\xce\xff\xe3\xff\xc1\xfd\xe6\xff\xdc\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\xff\xd8\xff\xcb\xff\xdf\xff\xe2\xff\xf8\xff\x00\x00\x1b\xfe\x21\xfe\x00\x00\x8e\xff\xc1\xfd\x14\xfe\x00\x00\xc1\xfd\xbf\xfe\x2f\xfe\x30\xfe\xde\xff\x2c\xfe\xc1\xfd\x35\xfe\xc1\xfd\x40\xfe\x3e\xfe\xc1\xfd\xc1\xfd\xc1\xfd\x44\xfe\x8c\xfe\x80\xfe\x83\xfe\xc1\xfd\xad\xff\xf9\xfd\xff\xfd\xc0\xfd\xa2\xff\x03\xff\xff\xfe\x00\x00\x04\xff\x28\xff\xde\xff\xde\xff\x00\x00\x32\xff\xc1\xfd\x86\xff\x7b\xff\x00\x00\x00\x00\xd9\xfe\x9b\xff\x00\x00\x00\x00\x00\x00\xf6\xfe\xde\xff\xde\xff\x2e\xff\x2f\xff\x2e\xff\xe5\xfe\x00\x00\x00\x00\xa6\xff\x00\x00\x84\xff\x6a\xff\x00\x00\x00\x00\x67\xff\x65\xff\x00\x00\x00\x00\x00\x00\xfc\xfe\xf9\xfe\xed\xff\x00\x00\x80\xfe\xf5\xff\x30\xff\xc1\xfd\x00\x00\x66\xff\x68\xff\x83\xff\x80\xff\xe8\xfe\xe9\xfe\xde\xff\xe3\xfe\xe0\xfe\xe1\xfe\xe2\xfe\xc1\xfd\x29\xff\x2b\xff\xf1\xfe\x00\x00\x00\x00\x72\xff\x00\x00\x08\xfe\xc1\xfd\x1f\xff\x00\x00\x0d\xff\x15\xff\x00\x00\x1c\xff\x19\xff\x14\xff\x00\x00\x00\x00\x3f\xff\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\xa4\xff\x00\xff\x00\x00\x02\xff\x04\xff\x4d\xfe\xc1\xfd\x39\xfe\x37\xfe\x38\xfe\x33\xfe\xc1\xfd\xdf\xff\x2e\xfe\x12\xfe\x00\x00\xc1\xfd\x00\x00\xcf\xff\xe4\xff\xc9\xff\x00\x00\x00\x00\xd8\xff\xd6\xff\xd5\xff\xba\xfd\xd4\xff\xd9\xff\x00\x00\xc0\xfd\xe9\xff\xe8\xff\xeb\xff\xd0\xff\x00\x00\x00\x00\xd9\xff\xda\xff\xcc\xff\xc7\xff\xca\xff\x00\x00\x20\xfe\x2d\xfe\xd8\xfe\x29\xfe\x27\xfe\x00\x00\xc1\xfd\xc1\xfd\x7d\xfe\x81\xfe\x7f\xfe\x00\x00\xc1\xfd\xa1\xff\x01\xff\x26\xff\x27\xff\xde\xff\x23\xff\x00\x00\x00\x00\x0c\xff\x4e\xff\x00\x00\x00\x00\x00\x00\x00\x00\x10\xff\x11\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1b\xff\xd1\xfe\x73\xff\xf3\xfe\xf4\xfe\xee\xfe\xde\xff\xef\xfe\xed\xfe\xc1\xfd\x00\x00\xd6\xfe\x95\xff\x00\x00\x6c\xff\xdf\xff\xe6\xfe\x00\x00\x6d\xff\xc1\xfd\x00\x00\x00\x00\xe4\xfe\x00\x00\x00\x00\x00\x00\x21\xff\x00\x00\x00\x00\xdf\xff\xf2\xfe\x00\x00\x13\xff\x37\xff\x15\xff\x1d\xff\x00\x00\x0f\xff\x51\xff\x18\xff\x00\x00\x00\x00\x09\xff\x17\xff\x3e\xff\x00\x00\x00\x00\x00\x00\xdf\xff\x25\xff\x87\xfe\x00\x00\x00\x00\x36\xfe\x2a\xfe\xc1\xfd\x28\xfe\x2b\xfe\x00\x00\x00\x00\xc8\xff\xd7\xff\xdb\xff\x00\x00\xb6\xff\xb5\xff\xb4\xff\xd2\xff\x00\x00\xd3\xff\xd1\xff\x00\x00\xc5\xff\xb5\xfe\x00\x00\x84\xfe\x7e\xfe\x24\xff\x00\x00\x0b\xff\x16\xff\x00\x00\x00\x00\x00\x00\x00\x00\xf0\xfe\x00\x00\x52\xff\xf8\xfe\xf8\xfe\x04\xff\x00\x00\xd7\xfe\x00\x00\x00\x00\x64\xff\x00\x00\xf6\xff\xdf\xfe\xde\xfe\xc0\xfd\xdd\xfe\xea\xfe\xec\xfe\x00\x00\x12\xff\x0e\xff\x07\xff\x08\xff\x00\x00\x00\x00\x0a\xff\x22\xff\xc1\xfd\xc3\xff\x00\x00\xb7\xff\xc6\xff\xcd\xff\xc4\xff\x00\x00\xc0\xff\x26\xfe\x00\x00\x06\xff\xeb\xfe\x04\xff\xdc\xfe\x00\x00\xd8\xff\x00\x00\xd8\xff\xbd\xff\xbc\xff\xbb\xfd\xbb\xff\x05\xff\x00\x00\x00\x00\xd9\xff\xc1\xff\xbe\xff\xc2\xff\x00\x00\xb9\xff\x00\x00\xba\xff\xb8\xff"# + +happyCheck :: HappyAddr +happyCheck = HappyA# "\xff\xff\x00\x00\x06\x00\x02\x00\x01\x00\x01\x00\x01\x00\x08\x00\x02\x00\x06\x00\x02\x00\x0e\x00\x05\x00\x03\x00\x04\x00\x03\x00\x04\x00\x1b\x00\x2f\x00\x1e\x00\x05\x00\x08\x00\x5a\x00\x1a\x00\x1b\x00\x1e\x00\x1c\x00\x0a\x00\x0b\x00\x57\x00\x29\x00\x6c\x00\x2b\x00\x2a\x00\x32\x00\x28\x00\x29\x00\x2e\x00\x2b\x00\x56\x00\x57\x00\x0a\x00\x0b\x00\x16\x00\x11\x00\x12\x00\x7c\x00\x37\x00\x38\x00\x0e\x00\x0f\x00\x10\x00\x53\x00\x54\x00\x1c\x00\x12\x00\xa2\x00\x1e\x00\x10\x00\x1d\x00\x2a\x00\x22\x00\x23\x00\x24\x00\x2e\x00\x2a\x00\x1e\x00\x1e\x00\x29\x00\x2e\x00\x2b\x00\x22\x00\x23\x00\x24\x00\x7a\x00\x7b\x00\x7c\x00\x29\x00\x29\x00\x2b\x00\x2b\x00\x90\x00\x2a\x00\x92\x00\x1e\x00\x1e\x00\x2e\x00\x0e\x00\x22\x00\x23\x00\x24\x00\x24\x00\x1e\x00\x1c\x00\x32\x00\x29\x00\x29\x00\x2b\x00\x2b\x00\x6e\x00\x6f\x00\x70\x00\xd0\x00\x29\x00\x1e\x00\x2b\x00\x0a\x00\x0b\x00\x77\x00\x21\x00\x24\x00\x19\x00\x1e\x00\x22\x00\x77\x00\x29\x00\x22\x00\x2b\x00\x61\x00\x28\x00\x22\x00\x0a\x00\x0b\x00\x0a\x00\x0b\x00\x0a\x00\x0b\x00\x37\x00\x38\x00\xcf\x00\x84\x00\xd0\x00\x59\x00\x5a\x00\x1c\x00\x27\x00\xb0\x00\x6b\x00\xaa\x00\xcf\x00\x1c\x00\x1d\x00\x1c\x00\x1d\x00\xcf\x00\x64\x00\x77\x00\x6f\x00\x70\x00\xcf\x00\x27\x00\xb4\x00\x20\x00\x53\x00\x54\x00\x77\x00\x77\x00\x25\x00\x84\x00\xcf\x00\xcf\x00\x53\x00\x54\x00\xb3\x00\xc1\x00\xc2\x00\xc3\x00\xcf\x00\xb2\x00\x00\x00\xaf\x00\xb0\x00\xb6\x00\x77\x00\x77\x00\xb2\x00\xd0\x00\xd0\x00\xc2\x00\xb6\x00\xa3\x00\x77\x00\xd2\x00\x20\x00\xc2\x00\xc3\x00\xc2\x00\xc3\x00\xc6\x00\x19\x00\x2f\x00\xc2\x00\xc3\x00\x77\x00\xa3\x00\xc6\x00\xcf\x00\x84\x00\x22\x00\xd0\x00\x1f\x00\xd3\x00\xcf\x00\xcf\x00\xaa\x00\xc6\x00\x64\x00\xd0\x00\xd3\x00\xd0\x00\xcf\x00\xcf\x00\xcf\x00\xc6\x00\xd0\x00\xb4\x00\xd0\x00\xcf\x00\xb7\x00\xcf\x00\x35\x00\xd0\x00\xb4\x00\xb3\x00\x6d\x00\xb7\x00\xd0\x00\x72\x00\xc1\x00\xc2\x00\xc3\x00\xd0\x00\xc5\x00\xc6\x00\xcf\x00\xc1\x00\xc2\x00\xc3\x00\xc2\x00\xc5\x00\xc6\x00\x62\x00\xd0\x00\xcf\x00\xcf\x00\x22\x00\x1d\x00\xd4\x00\xd0\x00\x81\x00\xcf\x00\x83\x00\x84\x00\x85\x00\xd4\x00\x20\x00\x88\x00\x89\x00\x8a\x00\x22\x00\xb8\x00\xcf\x00\xcf\x00\xbb\x00\x90\x00\xbd\x00\xc2\x00\xc3\x00\x39\x00\xcf\x00\xae\x00\x22\x00\x64\x00\x99\x00\x3b\x00\x3c\x00\xc8\x00\x28\x00\xd0\x00\xcb\x00\x81\x00\xcf\x00\x83\x00\x84\x00\x85\x00\xae\x00\xd0\x00\x88\x00\x89\x00\x8a\x00\xb2\x00\x25\x00\xb2\x00\x66\x00\xb6\x00\x90\x00\xb6\x00\xb1\x00\x0a\x00\x0b\x00\xb4\x00\xb5\x00\x4d\x00\xb7\x00\x99\x00\x6a\x00\xc2\x00\xc3\x00\xc2\x00\xc3\x00\xc6\x00\x4e\x00\xc6\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x3a\x00\x3b\x00\x3c\x00\x56\x00\xb4\x00\x0a\x00\x0b\x00\xce\x00\xcf\x00\xb1\x00\x16\x00\xa8\x00\xb4\x00\xb5\x00\xa5\x00\xb7\x00\xaa\x00\xc1\x00\xc2\x00\xc3\x00\xd2\x00\x26\x00\x7a\x00\x7b\x00\x7c\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x72\x00\x09\x00\x81\x00\x0b\x00\x83\x00\x84\x00\x85\x00\xce\x00\xcf\x00\x88\x00\x89\x00\x8a\x00\xa4\x00\xa5\x00\x3e\x00\x3f\x00\x40\x00\x90\x00\x42\x00\xcf\x00\x44\x00\x45\x00\x46\x00\xd0\x00\x2f\x00\xcf\x00\x99\x00\x4b\x00\x4c\x00\x0c\x00\x8b\x00\x27\x00\x6a\x00\x81\x00\x17\x00\x83\x00\x84\x00\x85\x00\xc5\x00\xc6\x00\x88\x00\x89\x00\x8a\x00\xb2\x00\x27\x00\xb2\x00\x29\x00\xb6\x00\x90\x00\xb6\x00\xb1\x00\x28\x00\x72\x00\xb4\x00\xb5\x00\xcf\x00\xb7\x00\x99\x00\xc6\x00\xc2\x00\xc3\x00\xc2\x00\xc3\x00\xc6\x00\x2f\x00\xc6\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x15\x00\x6d\x00\x61\x00\x62\x00\xcf\x00\xc2\x00\xc3\x00\xce\x00\xcf\x00\xb1\x00\x78\x00\xc0\x00\xb4\x00\xb5\x00\x09\x00\xb7\x00\x4f\x00\xb2\x00\xc7\x00\xc8\x00\x22\x00\xb6\x00\x2c\x00\x2d\x00\xd5\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xd2\x00\x1d\x00\xc2\x00\xc3\x00\x58\x00\x63\x00\xc6\x00\xce\x00\xcf\x00\x3e\x00\x24\x00\x40\x00\x39\x00\x42\x00\x0e\x00\x44\x00\x45\x00\x46\x00\x3d\x00\x3e\x00\x49\x00\x4a\x00\x6a\x00\x42\x00\x64\x00\x44\x00\x45\x00\x46\x00\x3d\x00\x3e\x00\xb5\x00\x2c\x00\x2d\x00\x42\x00\x58\x00\x44\x00\x45\x00\x46\x00\x74\x00\x75\x00\x76\x00\x77\x00\x46\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x27\x00\x3e\x00\x29\x00\x40\x00\x6a\x00\x42\x00\xb4\x00\x44\x00\x45\x00\x46\x00\x2c\x00\x2d\x00\x49\x00\x4a\x00\xd5\x00\x45\x00\x46\x00\x3d\x00\x3e\x00\xc1\x00\xc2\x00\xc3\x00\x42\x00\x58\x00\x44\x00\x45\x00\x46\x00\xd1\x00\x3e\x00\x16\x00\x40\x00\x6b\x00\x42\x00\x14\x00\x44\x00\x45\x00\x46\x00\x3d\x00\x3e\x00\x49\x00\x4a\x00\x6a\x00\x42\x00\xd1\x00\x44\x00\x45\x00\x46\x00\x3d\x00\x3e\x00\xc9\x00\x40\x00\xcb\x00\x42\x00\xcd\x00\x44\x00\x45\x00\x46\x00\x32\x00\x33\x00\x3e\x00\x3f\x00\x40\x00\x09\x00\x42\x00\x0b\x00\x44\x00\x45\x00\x46\x00\xa6\x00\xa7\x00\xa8\x00\x3e\x00\xb2\x00\x40\x00\x91\x00\x42\x00\x17\x00\x44\x00\x45\x00\x46\x00\xb5\x00\xcf\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\xd1\x00\x22\x00\xc2\x00\xc3\x00\x0a\x00\x0b\x00\x27\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x2d\x00\x17\x00\x0a\x00\x0b\x00\xbb\x00\xc2\x00\xc3\x00\x4f\x00\xc5\x00\xc6\x00\x52\x00\xcf\x00\x22\x00\x22\x00\xd5\x00\xc2\x00\xc3\x00\xc8\x00\xc5\x00\xc6\x00\x29\x00\x3e\x00\xb5\x00\x40\x00\xd5\x00\x42\x00\x1e\x00\x44\x00\x45\x00\x46\x00\x22\x00\x48\x00\x49\x00\x4a\x00\xd5\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x28\x00\x29\x00\xc2\x00\xc3\x00\x26\x00\xc5\x00\xc6\x00\x0a\x00\x0b\x00\xb5\x00\x8b\x00\x2d\x00\xc2\x00\xc3\x00\xd5\x00\xc5\x00\xc6\x00\x22\x00\x63\x00\xc2\x00\xc3\x00\xd5\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x55\x00\x2d\x00\xb5\x00\x1a\x00\xd5\x00\xc2\x00\xc3\x00\x4f\x00\xc5\x00\xc6\x00\x55\x00\xd5\x00\xcb\x00\xb5\x00\xd5\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x44\x00\x45\x00\x46\x00\x2e\x00\xd5\x00\xb5\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc2\x00\xc3\x00\x13\x00\xd5\x00\x3a\x00\xc0\x00\xb5\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xd5\x00\x4d\x00\x3e\x00\x73\x00\x40\x00\xd5\x00\x42\x00\xc4\x00\x44\x00\x45\x00\x46\x00\xb3\x00\xd5\x00\x49\x00\x4a\x00\x4b\x00\x4c\x00\x43\x00\x44\x00\x45\x00\x46\x00\x17\x00\x08\x00\x3e\x00\x0a\x00\x40\x00\xc2\x00\x42\x00\xb5\x00\x44\x00\x45\x00\x46\x00\x22\x00\x48\x00\x49\x00\x4a\x00\x73\x00\x74\x00\x75\x00\x76\x00\x77\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x3e\x00\x27\x00\x40\x00\x29\x00\x42\x00\x25\x00\x44\x00\x45\x00\x46\x00\x64\x00\x48\x00\x49\x00\x4a\x00\x91\x00\xd5\x00\xac\x00\xad\x00\x31\x00\x32\x00\x33\x00\x3e\x00\xb2\x00\x40\x00\xb4\x00\x42\x00\xd1\x00\x44\x00\x45\x00\x46\x00\x64\x00\x48\x00\x49\x00\x4a\x00\x8b\x00\x17\x00\x5b\x00\xc1\x00\xc2\x00\xc3\x00\xb7\x00\x3e\x00\x27\x00\x40\x00\x29\x00\x42\x00\x22\x00\x44\x00\x45\x00\x46\x00\xcb\x00\x48\x00\x49\x00\x4a\x00\xc5\x00\xc6\x00\xc2\x00\xc3\x00\x96\x00\xc5\x00\xc6\x00\x3e\x00\xc9\x00\x40\x00\xcb\x00\x42\x00\xcd\x00\x44\x00\x45\x00\x46\x00\x34\x00\x48\x00\x49\x00\x4a\x00\x6a\x00\xd5\x00\xb5\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\x05\x00\x06\x00\xcf\x00\x05\x00\x06\x00\x27\x00\xc0\x00\x29\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\x17\x00\xb5\x00\x16\x00\xc2\x00\xc3\x00\x16\x00\xc5\x00\xc6\x00\x36\x00\x17\x00\xc8\x00\x22\x00\xd5\x00\xcb\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x3e\x00\x22\x00\x40\x00\xd5\x00\x42\x00\xb5\x00\x44\x00\x45\x00\x46\x00\x6b\x00\x48\x00\x49\x00\x4a\x00\x27\x00\xd5\x00\x29\x00\x05\x00\x06\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x6a\x00\x3e\x00\xb5\x00\x40\x00\x27\x00\x42\x00\x29\x00\x44\x00\x45\x00\x46\x00\x16\x00\x48\x00\x49\x00\x4a\x00\xd5\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xd0\x00\x3e\x00\xb5\x00\x40\x00\x27\x00\x42\x00\x29\x00\x44\x00\x45\x00\x46\x00\x31\x00\x48\x00\x49\x00\x4a\x00\xd5\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x78\x00\x3e\x00\xb5\x00\x40\x00\x27\x00\x42\x00\x29\x00\x44\x00\x45\x00\x46\x00\x78\x00\x48\x00\x49\x00\x4a\x00\xd5\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xb2\x00\x3e\x00\x64\x00\x40\x00\xb6\x00\x42\x00\xcf\x00\x44\x00\x45\x00\x46\x00\xcf\x00\x48\x00\x49\x00\x4a\x00\xd5\x00\x17\x00\xc2\x00\xc3\x00\xd1\x00\xb8\x00\xc6\x00\x3e\x00\xbb\x00\x40\x00\xbd\x00\x42\x00\x22\x00\x44\x00\x45\x00\x46\x00\xb4\x00\x48\x00\x49\x00\x4a\x00\x07\x00\xc8\x00\xb5\x00\x19\x00\xcb\x00\x39\x00\x3a\x00\x3b\x00\x3c\x00\xc1\x00\xc2\x00\xc3\x00\x22\x00\xc2\x00\xc3\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xd2\x00\x3e\x00\xb4\x00\x40\x00\xcf\x00\x42\x00\xb5\x00\x44\x00\x45\x00\x46\x00\x96\x00\x48\x00\x49\x00\x4a\x00\xd5\x00\xc1\x00\xc2\x00\xc3\x00\xd1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xd1\x00\x3e\x00\xb5\x00\x40\x00\x27\x00\x42\x00\x29\x00\x44\x00\x45\x00\x46\x00\x30\x00\x48\x00\x49\x00\x4a\x00\xd5\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xd1\x00\x3e\x00\xb5\x00\x40\x00\x27\x00\x42\x00\x29\x00\x44\x00\x45\x00\x46\x00\x30\x00\x48\x00\x49\x00\x4a\x00\xd5\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xd1\x00\x3e\x00\xb5\x00\x40\x00\x29\x00\x42\x00\x2b\x00\x44\x00\x45\x00\x46\x00\x50\x00\x19\x00\x49\x00\x4a\x00\xd5\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x22\x00\x3e\x00\xb5\x00\x40\x00\x08\x00\x42\x00\x71\x00\x44\x00\x45\x00\x46\x00\x35\x00\x19\x00\x49\x00\x4a\x00\xd5\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x22\x00\xd1\x00\xb2\x00\x3e\x00\x35\x00\x40\x00\xb6\x00\x42\x00\x35\x00\x44\x00\x45\x00\x46\x00\x1f\x00\x25\x00\xd5\x00\xcf\x00\xb5\x00\x4c\x00\xc2\x00\xc3\x00\x8b\x00\x45\x00\xc6\x00\x47\x00\x48\x00\x31\x00\x32\x00\x33\x00\x4c\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x43\x00\x44\x00\x45\x00\x46\x00\xd0\x00\x3e\x00\xb5\x00\x40\x00\x65\x00\x42\x00\xcf\x00\x44\x00\x45\x00\x46\x00\xd5\x00\x8b\x00\x49\x00\x4a\x00\x4d\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x17\x00\x3e\x00\xb5\x00\x40\x00\x5f\x00\x42\x00\x17\x00\x44\x00\x45\x00\x46\x00\x0a\x00\x0b\x00\x49\x00\x4a\x00\xd5\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x16\x00\x3e\x00\xb5\x00\x40\x00\x2b\x00\x42\x00\x2d\x00\x44\x00\x45\x00\x46\x00\x0c\x00\x0d\x00\x49\x00\x4a\x00\xd5\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x22\x00\x3e\x00\xb5\x00\x40\x00\x17\x00\x42\x00\x5b\x00\x44\x00\x45\x00\x46\x00\x68\x00\x69\x00\x49\x00\x4a\x00\xd5\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x32\x00\x3e\x00\x22\x00\x40\x00\xb5\x00\x42\x00\x26\x00\x44\x00\x45\x00\x46\x00\x16\x00\x2b\x00\x49\x00\x4a\x00\xd5\x00\x0a\x00\x0b\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x3e\x00\x84\x00\x40\x00\x1d\x00\x42\x00\x49\x00\x44\x00\x45\x00\x46\x00\xc0\x00\x84\x00\x49\x00\x4a\x00\xb4\x00\xd5\x00\x73\x00\xc7\x00\xc8\x00\xb5\x00\xc2\x00\xc3\x00\xc2\x00\xc3\x00\xc6\x00\xc5\x00\xc6\x00\xc1\x00\xc2\x00\xc3\x00\x0a\x00\x0b\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x5b\x00\x3e\x00\xb5\x00\x40\x00\xd5\x00\x42\x00\x28\x00\x44\x00\x45\x00\x46\x00\x0a\x00\x0b\x00\x49\x00\x4a\x00\xd5\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x55\x00\x3e\x00\xb5\x00\x40\x00\x1c\x00\x42\x00\x29\x00\x44\x00\x45\x00\x46\x00\x4f\x00\x29\x00\x51\x00\x52\x00\xd5\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x17\x00\x3e\x00\xb5\x00\x40\x00\x84\x00\x42\x00\x49\x00\x44\x00\x45\x00\x46\x00\x80\x00\x81\x00\x82\x00\x83\x00\xd5\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x1d\x00\x3e\x00\xb5\x00\x40\x00\x28\x00\x42\x00\x32\x00\x44\x00\x45\x00\x46\x00\x80\x00\x81\x00\x82\x00\x83\x00\xd5\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x68\x00\x69\x00\x3e\x00\xb5\x00\x40\x00\x32\x00\x42\x00\x1c\x00\x44\x00\x45\x00\x46\x00\x17\x00\x18\x00\x19\x00\xd5\x00\x29\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x17\x00\x3e\x00\x1c\x00\x40\x00\x20\x00\x42\x00\x84\x00\x44\x00\x45\x00\x46\x00\x45\x00\x84\x00\x47\x00\x48\x00\xd5\x00\x4c\x00\x05\x00\x4c\x00\x17\x00\xb5\x00\x32\x00\x3e\x00\x2b\x00\x40\x00\x2b\x00\x42\x00\x73\x00\x44\x00\x45\x00\x46\x00\x0a\x00\x0b\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x0c\x00\x3e\x00\xb5\x00\x08\x00\x09\x00\x42\x00\x0f\x00\x44\x00\x45\x00\x46\x00\x93\x00\x94\x00\x95\x00\x17\x00\xd5\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x22\x00\x3e\x00\xb5\x00\x94\x00\x95\x00\x42\x00\x1d\x00\x44\x00\x45\x00\x46\x00\x16\x00\x24\x00\x25\x00\x17\x00\xd5\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x84\x00\x8b\x00\xb5\x00\x3e\x00\x31\x00\x32\x00\x33\x00\x42\x00\x74\x00\x44\x00\x45\x00\x46\x00\x0a\x00\x0b\x00\xd5\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x3e\x00\x0a\x00\x0b\x00\xb5\x00\x42\x00\x27\x00\x44\x00\x45\x00\x46\x00\x42\x00\x29\x00\x44\x00\x45\x00\x46\x00\xd5\x00\x1c\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x33\x00\x34\x00\xb5\x00\x80\x00\x81\x00\x82\x00\x83\x00\x2d\x00\x42\x00\x72\x00\x44\x00\x45\x00\x46\x00\xb4\x00\xd5\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x41\x00\x42\x00\xb5\x00\x44\x00\x45\x00\x46\x00\xc1\x00\xc2\x00\xc3\x00\x4a\x00\x43\x00\x44\x00\x45\x00\x46\x00\xd5\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x17\x00\x42\x00\x5b\x00\x44\x00\x45\x00\x46\x00\x1c\x00\x5c\x00\x5d\x00\x5e\x00\x1e\x00\x60\x00\xc2\x00\xc3\x00\xd5\x00\xc5\x00\xc6\x00\x41\x00\x42\x00\x22\x00\x44\x00\x45\x00\x46\x00\x05\x00\x06\x00\x41\x00\x42\x00\x84\x00\x44\x00\x45\x00\x46\x00\xd5\x00\xc2\x00\xc3\x00\x1d\x00\xc5\x00\xc6\x00\x93\x00\x94\x00\x95\x00\x44\x00\x45\x00\x46\x00\x47\x00\x5c\x00\x5d\x00\x5e\x00\x1e\x00\x60\x00\x49\x00\x4a\x00\xd5\x00\x03\x00\x04\x00\xc2\x00\xc3\x00\x60\x00\xc5\x00\xc6\x00\x30\x00\x01\x00\x43\x00\x44\x00\x45\x00\x46\x00\x28\x00\x43\x00\x44\x00\x45\x00\x46\x00\x1d\x00\xc2\x00\xc3\x00\xd5\x00\xc5\x00\xc6\x00\xc2\x00\xc3\x00\x17\x00\xc5\x00\xc6\x00\x16\x00\x25\x00\x43\x00\x44\x00\x45\x00\x46\x00\x67\x00\x68\x00\x69\x00\xd5\x00\x43\x00\x44\x00\x45\x00\x46\x00\xd5\x00\xc2\x00\xc3\x00\xb7\x00\xc5\x00\xc6\x00\x03\x00\x04\x00\x43\x00\x44\x00\x45\x00\x46\x00\x49\x00\x4a\x00\xc2\x00\xc3\x00\x29\x00\xc5\x00\xc6\x00\x1e\x00\xd5\x00\x28\x00\xc2\x00\xc3\x00\x84\x00\xc5\x00\xc6\x00\x17\x00\x43\x00\x44\x00\x45\x00\x46\x00\x22\x00\xd5\x00\xc2\x00\xc3\x00\x5b\x00\xc5\x00\xc6\x00\x1d\x00\xb7\x00\xd5\x00\x1c\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x0c\x00\xc2\x00\xc3\x00\xd5\x00\xc5\x00\xc6\x00\x67\x00\x68\x00\x69\x00\xc2\x00\xc3\x00\x61\x00\xc5\x00\xc6\x00\x1c\x00\xbc\x00\x08\x00\x09\x00\x78\x00\xc0\x00\xd5\x00\xc2\x00\xc3\x00\x73\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xd5\x00\x84\x00\x74\x00\xc2\x00\xc3\x00\x84\x00\xc5\x00\xc6\x00\x09\x00\x0a\x00\x0b\x00\x0f\x00\xd5\x00\xd6\x00\xd7\x00\xc2\x00\xc3\x00\x25\x00\xc5\x00\xc6\x00\xc2\x00\xc3\x00\xd5\x00\xc5\x00\xc6\x00\x09\x00\x0a\x00\x0b\x00\x0f\x00\x31\x00\x32\x00\x33\x00\x7d\x00\x7e\x00\xd5\x00\x79\x00\x16\x00\xc2\x00\xc3\x00\xd5\x00\xc5\x00\xc6\x00\x01\x00\x02\x00\x31\x00\xc2\x00\xc3\x00\x1c\x00\xc5\x00\xc6\x00\xc1\x00\xc2\x00\xc3\x00\x29\x00\xc5\x00\xc6\x00\xd5\x00\xc2\x00\xc3\x00\x1e\x00\xc5\x00\xc6\x00\x01\x00\x16\x00\xd5\x00\x1c\x00\x05\x00\x06\x00\x2c\x00\x01\x00\x09\x00\x03\x00\x04\x00\x05\x00\x06\x00\x64\x00\xd5\x00\xc2\x00\xc3\x00\x26\x00\xc5\x00\xc6\x00\x24\x00\x16\x00\x56\x00\x18\x00\x67\x00\x68\x00\x69\x00\x29\x00\x16\x00\x01\x00\x18\x00\x20\x00\x05\x00\x06\x00\xd5\x00\x24\x00\x24\x00\xb9\x00\x20\x00\x5b\x00\xbc\x00\x73\x00\xbe\x00\x0f\x00\xc0\x00\x1d\x00\x2f\x00\x30\x00\x5f\x00\x32\x00\x16\x00\xc7\x00\xc8\x00\xc9\x00\x2b\x00\xcb\x00\x32\x00\xcd\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xc1\x00\xc2\x00\xc3\x00\x1d\x00\xc5\x00\xc6\x00\x93\x00\x94\x00\x95\x00\x53\x00\x54\x00\x61\x00\x28\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x1d\x00\x01\x00\x22\x00\x74\x00\x61\x00\x05\x00\x06\x00\x22\x00\x01\x00\x5f\x00\x21\x00\x61\x00\x05\x00\x06\x00\x84\x00\x4f\x00\x09\x00\x17\x00\x05\x00\x53\x00\x54\x00\x55\x00\x16\x00\x74\x00\x18\x00\x93\x00\x94\x00\x95\x00\x84\x00\x16\x00\x74\x00\x18\x00\x20\x00\x61\x00\x7f\x00\x50\x00\x51\x00\x52\x00\x22\x00\x20\x00\xad\x00\x7f\x00\x22\x00\x24\x00\x2d\x00\xb2\x00\x01\x00\xb4\x00\x17\x00\x28\x00\x32\x00\xb4\x00\x74\x00\x17\x00\xb7\x00\x17\x00\x0f\x00\x32\x00\x5f\x00\x28\x00\xc1\x00\xc2\x00\xc3\x00\x0c\x00\xc1\x00\xc2\x00\xc3\x00\x16\x00\xc5\x00\xc6\x00\x21\x00\x84\x00\x01\x00\x84\x00\x28\x00\x1d\x00\x05\x00\x06\x00\x22\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x16\x00\x01\x00\x18\x00\x29\x00\x61\x00\x05\x00\x06\x00\x17\x00\x28\x00\x73\x00\x20\x00\x61\x00\x73\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x2b\x00\x2b\x00\x73\x00\x73\x00\x5b\x00\x16\x00\x74\x00\x18\x00\x22\x00\x17\x00\x22\x00\x32\x00\x2b\x00\x74\x00\x4f\x00\x20\x00\x2b\x00\x7f\x00\x53\x00\x54\x00\x55\x00\x1d\x00\x1c\x00\x5d\x00\x7f\x00\x25\x00\x2c\x00\x27\x00\x41\x00\x1c\x00\x0c\x00\x4b\x00\x61\x00\x32\x00\x1e\x00\x27\x00\x1d\x00\x31\x00\x32\x00\x33\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x1e\x00\x01\x00\x1d\x00\x2c\x00\x74\x00\x05\x00\x06\x00\x1c\x00\x1e\x00\x17\x00\x1e\x00\x61\x00\x1d\x00\x17\x00\x27\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x16\x00\x24\x00\x18\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x1b\x00\x74\x00\xb9\x00\x20\x00\x61\x00\xbc\x00\x29\x00\xbe\x00\x29\x00\xc0\x00\x24\x00\x29\x00\x7f\x00\x17\x00\x73\x00\x2b\x00\xc7\x00\xc8\x00\xc9\x00\x29\x00\xcb\x00\x32\x00\xcd\x00\x74\x00\x24\x00\x25\x00\x28\x00\x27\x00\x28\x00\x20\x00\x22\x00\x0f\x00\x05\x00\x84\x00\x7f\x00\x24\x00\x24\x00\x31\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x22\x00\x84\x00\x84\x00\x46\x00\x17\x00\x1c\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x17\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x17\x00\x22\x00\x0f\x00\x61\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x21\x00\x18\x00\x20\x00\x68\x00\x16\x00\x1c\x00\x5e\x00\x74\x00\x0c\x00\x20\x00\x17\x00\x17\x00\x23\x00\x17\x00\xb9\x00\x17\x00\x17\x00\xbc\x00\x7f\x00\xbe\x00\x17\x00\xc0\x00\x17\x00\x17\x00\x2f\x00\x22\x00\x31\x00\x32\x00\xc7\x00\xc8\x00\xc9\x00\x21\x00\xcb\x00\x38\x00\xcd\x00\x17\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x21\x00\x42\x00\x43\x00\x44\x00\x2d\x00\x46\x00\x2b\x00\x48\x00\x41\x00\x41\x00\x6d\x00\x4b\x00\x41\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x70\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x2d\x00\x64\x00\x0c\x00\x0f\x00\x61\x00\x48\x00\x63\x00\x85\x00\x65\x00\x66\x00\x67\x00\x68\x00\x84\x00\x6a\x00\x0f\x00\x6c\x00\x0f\x00\x84\x00\x1d\x00\x46\x00\x71\x00\x1d\x00\x1d\x00\x74\x00\x75\x00\x76\x00\x77\x00\x85\x00\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x1d\x00\x85\x00\x28\x00\x30\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x00\x00\x18\x00\x85\x00\xff\xff\xff\xff\xff\xff\xc0\x00\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xc7\x00\xc8\x00\xc9\x00\xff\xff\xcb\x00\xff\xff\xcd\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\x67\x00\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\x77\x00\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\xff\xff\x65\x00\x66\x00\x67\x00\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\x77\x00\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\x67\x00\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\x77\x00\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\x67\x00\x68\x00\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\x77\x00\xff\xff\x79\x00\x7a\x00\x7b\x00\x7c\x00\x7d\x00\x7e\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\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x01\x00\x57\x00\x03\x00\x04\x00\x05\x00\x06\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\x16\x00\x17\x00\x18\x00\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\x61\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x01\x00\x57\x00\xff\xff\x59\x00\x05\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\x67\x00\xff\xff\xff\xff\x6a\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\x61\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x01\x00\x57\x00\xff\xff\x59\x00\x05\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\x67\x00\xff\xff\xff\xff\x6a\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\x61\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x01\x00\x57\x00\xff\xff\x59\x00\x05\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\x67\x00\xff\xff\xff\xff\x6a\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\x61\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x01\x00\x57\x00\xff\xff\xff\xff\x05\x00\x06\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\x67\x00\xff\xff\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\x61\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\x67\x00\xff\xff\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x6e\x00\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x01\x00\x57\x00\x03\x00\x04\x00\x05\x00\x06\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\x16\x00\xff\xff\x18\x00\x6e\x00\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\x61\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x01\x00\x57\x00\xff\xff\x59\x00\x05\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6a\x00\x16\x00\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\xff\xff\xff\xff\x74\x00\x75\x00\xff\xff\x22\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\x61\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\x67\x00\xff\xff\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x01\x00\x57\x00\x03\x00\x04\x00\x05\x00\x06\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\x16\x00\xff\xff\x18\x00\x6e\x00\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\x61\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\x65\x00\x66\x00\x67\x00\xff\xff\xff\xff\x6a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x75\x00\x76\x00\x77\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\x1c\x00\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x01\x00\x57\x00\xff\xff\xff\xff\x05\x00\x06\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\x16\x00\xff\xff\x18\x00\x6e\x00\x6f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5e\x00\x38\x00\xff\xff\x61\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x68\x00\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x57\x00\xff\xff\x59\x00\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\xff\xff\xff\xff\x74\x00\x75\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\x70\x00\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x01\x00\x57\x00\x03\x00\x04\x00\x05\x00\x06\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\x16\x00\xff\xff\x18\x00\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\x61\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x57\x00\xff\xff\x59\x00\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6a\x00\xff\xff\x6c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x71\x00\xff\xff\xff\xff\x74\x00\x75\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\x60\x00\x61\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x57\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\xff\xff\xff\xff\xff\xff\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x01\x00\x57\x00\xff\xff\xff\xff\x05\x00\x06\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x62\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x69\x00\x6a\x00\x16\x00\xff\xff\x18\x00\x6e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x20\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\x30\x00\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x2f\x00\xff\xff\x31\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\x61\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x01\x00\x57\x00\x03\x00\x04\x00\x05\x00\x06\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6a\x00\x16\x00\xff\xff\x18\x00\x19\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\x7a\x00\x7b\x00\x7c\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\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\x61\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\x49\x00\x4a\x00\xff\xff\xff\xff\x74\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1d\x00\xff\xff\xff\xff\x20\x00\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x29\x00\xff\xff\x2b\x00\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\x31\x00\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x2d\x00\x07\x00\x2f\x00\xff\xff\xff\xff\x32\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\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\x01\x00\xff\xff\xff\xff\x74\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x57\x00\x58\x00\x59\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x65\x00\x66\x00\x67\x00\x68\x00\x69\x00\x6a\x00\x6b\x00\x6c\x00\x6d\x00\x6e\x00\x6f\x00\x70\x00\x71\x00\x72\x00\x73\x00\x74\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x01\x00\x02\x00\xff\xff\x2f\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x16\x00\x42\x00\x43\x00\x44\x00\xff\xff\x46\x00\xff\xff\x48\x00\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\x01\x00\x02\x00\x32\x00\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x38\x00\xff\xff\xff\xff\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\x16\x00\xff\xff\xff\xff\x48\x00\x74\x00\xff\xff\xff\xff\xff\xff\x1e\x00\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x2f\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\x61\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\x16\x00\x46\x00\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x2f\x00\x01\x00\x02\x00\x32\x00\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\x38\x00\xff\xff\x61\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\x68\x00\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x2f\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\x61\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\x16\x00\x46\x00\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\x20\x00\xff\xff\xff\xff\x23\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\x61\x00\x3b\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xff\xff\x42\x00\x43\x00\x44\x00\xff\xff\xff\xff\xff\xff\x48\x00\xff\xff\xff\xff\xff\xff\x01\x00\x74\x00\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\x09\x00\xff\xff\x0b\x00\x61\x00\xff\xff\xff\xff\x08\x00\x09\x00\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\x16\x00\x17\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x20\x00\xff\xff\x22\x00\x2d\x00\xff\xff\xff\xff\xff\xff\x27\x00\xff\xff\x22\x00\xff\xff\x24\x00\x25\x00\x2d\x00\x27\x00\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x31\x00\x32\x00\x33\x00\x05\x00\x06\x00\xff\xff\x08\x00\x09\x00\xff\xff\x0b\x00\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x16\x00\xff\xff\x18\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x20\x00\x61\x00\xff\xff\xff\xff\x24\x00\xff\xff\xff\xff\x27\x00\xff\xff\x5f\x00\x01\x00\x61\x00\xff\xff\x2d\x00\xff\xff\x2f\x00\x30\x00\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x16\x00\xff\xff\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\x08\x00\x09\x00\xff\xff\x0b\x00\xff\xff\xff\xff\x25\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x16\x00\x01\x00\x18\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\x20\x00\x61\x00\xff\xff\xff\xff\x24\x00\xff\xff\xff\xff\x27\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x2d\x00\x18\x00\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\x20\x00\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\x01\x00\xff\xff\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x16\x00\x01\x00\x18\x00\x03\x00\x04\x00\x05\x00\x06\x00\x74\x00\xff\xff\xff\xff\x20\x00\x61\x00\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x16\x00\x01\x00\x18\x00\x03\x00\x04\x00\x05\x00\x06\x00\xff\xff\x74\x00\x5f\x00\x20\x00\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x68\x00\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\x20\x00\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x01\x00\x02\x00\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\x5f\x00\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x16\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\x5f\x00\xff\xff\x61\x00\x22\x00\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x01\x00\xff\xff\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\x74\x00\x5f\x00\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\x18\x00\x01\x00\x02\x00\xff\xff\xff\xff\x05\x00\x06\x00\x74\x00\x20\x00\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\x01\x00\x16\x00\xff\xff\xff\xff\x05\x00\x06\x00\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x6b\x00\x01\x00\x16\x00\xff\xff\x18\x00\x05\x00\x06\x00\xff\xff\xff\xff\x74\x00\xff\xff\xff\xff\x20\x00\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x16\x00\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x02\x00\xff\xff\x20\x00\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\xff\xff\x01\x00\x16\x00\xff\xff\x74\x00\x05\x00\xff\xff\xff\xff\xff\xff\x61\x00\x1e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x26\x00\x6b\x00\xff\xff\x01\x00\x16\x00\x17\x00\xff\xff\x05\x00\xff\xff\xff\xff\x74\x00\x61\x00\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x26\x00\xff\xff\xff\xff\xff\xff\x16\x00\x17\x00\xff\xff\x01\x00\x02\x00\xff\xff\x74\x00\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x26\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x16\x00\xff\xff\x74\x00\x01\x00\x02\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\xff\xff\xff\xff\xff\xff\x01\x00\xff\xff\x74\x00\x61\x00\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x00\x16\x00\x74\x00\x61\x00\x05\x00\xff\xff\xff\xff\x01\x00\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x25\x00\xff\xff\xff\xff\xff\xff\xff\xff\x16\x00\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\x16\x00\x01\x00\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\xff\xff\x01\x00\x16\x00\x61\x00\xff\xff\x05\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\xff\xff\xff\xff\x74\x00\x61\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\xff\xff\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x74\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x74\x00\xff\xff\xff\xff\x61\x00\xff\xff\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\x74\x00\x61\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\x08\x00\x09\x00\x0a\x00\x0b\x00\xff\xff\xff\xff\x99\x00\x74\x00\xff\xff\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xff\xff\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\x25\x00\xb1\x00\x27\x00\x28\x00\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\xff\xff\xff\xff\xff\xff\x9d\x00\x9e\x00\x9f\x00\xff\xff\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x00\xff\xff\xff\xff\xff\xff\x24\x00\x25\x00\xff\xff\x27\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\x31\x00\x32\x00\x33\x00\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\x9e\x00\x9f\x00\xff\xff\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\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\xa9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\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\xa9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\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\xa9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\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\xa9\x00\xff\xff\xab\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\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\xa9\x00\xff\xff\xab\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\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\xa9\x00\xff\xff\xab\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa1\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\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\xa9\x00\xff\xff\xab\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\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\xa9\x00\xff\xff\xab\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\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\xa9\x00\xff\xff\xab\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\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\xa9\x00\xff\xff\xab\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\xff\xff\xff\xff\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7d\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\xff\xff\xff\xff\xff\xff\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\x8b\x00\xff\xff\x8d\x00\xff\xff\x8f\x00\x90\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xba\x00\xff\xff\xbc\x00\xff\xff\xff\xff\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\x9a\x00\x9b\x00\xff\xff\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\x8c\x00\x8d\x00\xff\xff\xff\xff\x90\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\xff\xff\xff\xff\xff\xff\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xa9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\xff\xff\xff\xff\xff\xff\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\xff\xff\xff\xff\x90\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\x8d\x00\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\xff\xff\xff\xff\xff\xff\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x00\x90\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\x8e\x00\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\xff\xff\xff\xff\xff\xff\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xa9\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\xff\xff\xff\xff\xff\xff\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\xff\xff\xff\xff\xff\xff\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\xff\xff\xff\xff\xff\xff\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\xff\xff\xff\xff\xff\xff\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\xff\xff\xff\xff\xff\xff\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\xff\xff\xff\xff\xff\xff\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\xff\xff\xff\xff\xff\xff\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\xff\xff\xff\xff\xff\xff\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x7e\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xce\x00\xcf\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\x7f\x00\x80\x00\x81\x00\x82\x00\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\x99\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\x82\x00\x83\x00\x84\x00\x85\x00\xce\x00\xcf\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x00\x84\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xce\x00\xcf\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x85\x00\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xce\x00\xcf\x00\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x86\x00\x87\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xce\x00\xcf\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\x87\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x90\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\x87\x00\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xce\x00\xcf\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x90\x00\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\x93\x00\x94\x00\x95\x00\xff\xff\x97\x00\x98\x00\xff\xff\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xce\x00\xcf\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x90\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\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xce\x00\xcf\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x90\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\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xce\x00\xcf\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x90\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\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xce\x00\xcf\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x90\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\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xce\x00\xcf\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\x88\x00\x89\x00\x8a\x00\xff\xff\xff\xff\xff\xff\xce\x00\xcf\x00\x90\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb1\x00\xff\xff\xff\xff\xb4\x00\xb5\x00\xff\xff\xb7\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x00\xcf\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"# + +happyTable :: HappyAddr +happyTable = HappyA# "\x00\x00\x73\x00\xcb\x01\x74\x00\x75\x00\xe0\x02\x75\x00\x78\x03\x07\x00\x76\x00\x09\x00\x27\x04\x2a\x03\x5a\x02\x09\x01\x08\x01\x09\x01\x32\x04\x22\x02\x2c\x00\x5b\x02\xcd\x01\x46\x03\x28\x04\x29\x04\x2c\x00\x45\x02\xb7\x01\xc0\x02\xf2\x03\xaa\x03\x14\x03\x2f\x00\x82\x00\x10\x03\xe6\x01\xe7\x01\x0f\x03\x2f\x00\x93\x03\x94\x03\xb7\x01\xc0\x02\xbf\xff\xd0\x02\xd1\x02\x90\x02\x31\x03\x23\x03\x6d\x03\x6e\x03\x6f\x03\x23\x04\x05\x03\x47\x02\x69\x03\xed\x01\x2c\x00\xe2\x03\xd0\x01\x82\x00\xd2\x02\xb1\x01\xb2\x01\xba\x02\x82\x00\x2c\x00\x2c\x00\x2e\x00\xdc\x01\x2f\x00\x6a\x03\xb1\x01\xb2\x01\x24\x02\x25\x02\x26\x02\xaa\x03\x2e\x00\x2f\x00\x2f\x00\x8a\x03\x82\x00\x8b\x03\x2c\x00\x2c\x00\x83\x00\x2f\x04\xb0\x01\xb1\x01\xb2\x01\xbf\x02\x2c\x00\x47\x02\x83\x02\x2e\x00\x2e\x00\x2f\x00\x2f\x00\xab\x03\xac\x03\xad\x03\xee\x01\xe5\x02\x2c\x00\x2f\x00\xb7\x01\xb8\x01\x30\x00\x15\x02\x2d\x00\x26\x01\xf6\x03\x93\x02\x30\x00\x2e\x00\xf7\x03\x2f\x00\x1f\x04\xf8\x03\x21\x01\xb7\x01\xb8\x01\xb7\x01\x1a\x03\xb7\x01\x3f\x03\x22\x03\x23\x03\x27\x02\x46\x02\x15\x03\x94\x02\x95\x02\xcc\x02\xb9\x01\xe7\x02\xd1\x01\xdb\x01\x96\x02\x34\x04\xe5\x03\xe4\x03\xe5\x03\x48\x00\x24\x04\x30\x00\xfa\x03\xad\x03\x95\x03\xbb\x01\x23\x02\xd7\x00\x5b\x03\x05\x03\x30\x00\x30\x00\xd8\x00\x48\x02\x27\x02\x95\x03\x04\x03\x05\x03\x84\x02\x44\x00\x14\x00\x45\x00\xe8\x02\x2a\x04\x14\x01\xe8\x01\xe9\x01\x2b\x04\x30\x00\x30\x00\x2a\x04\x80\x00\x06\x03\x85\x02\x2b\x04\xc1\x02\x30\x00\x1a\x04\xd7\x00\x14\x00\x34\x01\x14\x00\x24\x03\x35\x01\x27\x01\xcd\x03\x14\x00\x34\x01\x30\x00\xc2\x02\x35\x01\xae\x03\x4d\x02\x28\x01\x84\x00\x15\x01\x2c\x04\xea\x01\xcc\x01\x7f\x00\x5c\x02\xbe\x01\xce\x01\x2c\x04\x08\x00\x77\x00\x0b\x01\x0b\x01\x5c\x02\x08\x00\x70\x03\x08\x00\x0a\x01\x71\x03\x0a\x01\xbc\x03\xce\x01\x70\x03\x84\x02\x40\x03\x71\x03\x84\x00\x1b\x03\x44\x00\x14\x00\x45\x00\x84\x00\x46\x00\x18\x00\xd3\x02\x44\x00\x14\x00\x45\x00\x85\x02\x46\x00\x18\x00\x14\x04\x80\x00\xae\x03\xd3\x02\xbd\x02\x19\x04\x72\x03\x84\x00\xd9\x00\x96\x02\x37\x00\x38\x00\x39\x00\x72\x03\xd7\x00\x3a\x00\x3b\x00\x3c\x00\xa9\x01\x16\x02\x31\x00\x31\x00\x17\x02\x3d\x00\x18\x02\x14\x00\x24\x03\xbe\x02\xe6\x02\xba\x01\x93\x02\x0a\x04\x3e\x00\x68\x02\x31\x01\x19\x02\x94\x02\x06\x03\x1a\x02\xd9\x00\x31\x00\x37\x00\x38\x00\x39\x00\xbc\x01\x06\x03\x3a\x00\x3b\x00\x3c\x00\xe6\x03\xaf\x03\xe6\x03\x01\x03\xe7\x03\x3d\x00\xe7\x03\x40\x00\xb7\x01\x1a\x03\x41\x00\x42\x00\xf2\x03\x43\x00\x3e\x00\x0b\x04\x14\x00\x34\x01\x14\x00\x34\x01\x35\x01\x2a\x01\x35\x01\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x6b\x02\x30\x01\x31\x01\xf5\x02\x23\x02\xb7\x01\x3f\x03\x47\x00\x48\x00\x40\x00\x17\x04\xdd\x03\x41\x00\x42\x00\x83\x03\x43\x00\x87\x00\x44\x00\x14\x00\x45\x00\xed\x03\x32\x02\x29\x02\x25\x02\x26\x02\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\xf6\x02\xb7\x00\xd9\x00\xb9\x00\x37\x00\x38\x00\x39\x00\x47\x00\x48\x00\x3a\x00\x3b\x00\x3c\x00\xed\x02\xee\x02\x0a\x00\x33\x02\x34\x02\x3d\x00\xef\x00\x87\x03\x0d\x00\x0e\x00\x0f\x00\x80\x00\xcd\x03\xef\x02\x3e\x00\x35\x02\xf8\x00\x41\x02\xf9\x00\xbd\x00\x0c\x04\xb0\x03\x24\x01\x37\x00\x38\x00\x39\x00\x02\x03\x18\x00\x3a\x00\x3b\x00\x3c\x00\x32\x01\x50\xfe\xe6\x03\x50\xfe\x33\x01\x3d\x00\xe7\x03\x40\x00\x25\x01\x1c\x03\x41\x00\xc4\x02\xef\x02\x43\x00\x3e\x00\x9e\x02\x14\x00\x34\x01\x14\x00\x34\x01\x35\x01\x42\x02\x35\x01\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\xe0\x03\x41\x03\xce\x03\xcf\x03\x27\x02\x14\x00\x15\x00\x47\x00\x48\x00\x40\x00\xde\x03\xfa\x00\x41\x00\x42\x00\xb7\x00\x43\x00\x4a\x01\x32\x01\xae\x00\xaf\x00\xa9\x01\x33\x01\x34\x03\x73\x02\x2b\x01\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x79\x03\xd0\x01\x14\x00\x34\x01\xff\x03\x4b\x01\x35\x01\x47\x00\x48\x00\x0a\x00\x9d\x03\x0b\x00\xaa\x01\x0c\x00\x7b\x03\x0d\x00\x0e\x00\x0f\x00\xbd\x03\x3a\x02\x74\x02\x12\x00\x00\x04\xef\x00\x8f\x03\x0d\x00\x0e\x00\x0f\x00\xa7\x03\x3a\x02\x13\x00\x21\x03\x73\x02\xef\x00\x9b\x02\x0d\x00\x0e\x00\x0f\x00\xbb\x03\x39\x03\x3a\x03\x3b\x03\x0d\x01\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x62\xfe\x0a\x00\x62\xfe\x0b\x00\x9c\x02\x0c\x00\x23\x02\x0d\x00\x0e\x00\x0f\x00\x72\x02\x73\x02\x74\x02\x12\x00\x19\x00\x8a\x00\x0f\x00\x42\x03\x3a\x02\x44\x00\x14\x00\x45\x00\xef\x00\x1d\x02\x0d\x00\x0e\x00\x0f\x00\x91\x03\x0a\x00\x55\x02\x0b\x00\xd1\x01\x0c\x00\x7f\x03\x0d\x00\x0e\x00\x0f\x00\x39\x02\x3a\x02\x74\x02\x12\x00\x1e\x02\xef\x00\xa8\x03\x0d\x00\x0e\x00\x0f\x00\xfb\x03\xfc\x03\xb0\x00\xfd\x03\x0f\x02\xef\x00\xcb\x00\x0d\x00\x0e\x00\x0f\x00\x56\x02\x57\x02\x0a\x00\x67\x01\x68\x01\xb7\x00\xef\x00\xb9\x00\x0d\x00\x0e\x00\x0f\x00\x84\x03\x85\x03\x86\x03\x0a\x00\x0c\x03\xf5\x00\xb8\x03\x0c\x00\xfc\x00\x0d\x00\x0e\x00\x0f\x00\x13\x00\x3c\x03\xf6\x00\x12\x00\xf7\x00\xf8\x00\x35\x03\xa6\x00\x14\x00\x34\x01\xb7\x01\x54\x03\xbd\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\xfd\x00\x39\x04\xb7\x01\x54\x03\x9b\x03\x14\x00\x15\x00\x7e\x02\x17\x00\x18\x00\x3e\x03\x87\x03\xed\x03\xbd\x02\x19\x00\x14\x00\x15\x00\x19\x02\x17\x00\x18\x00\x46\x03\x0a\x00\x13\x00\x0b\x00\x19\x00\x0c\x00\x12\x02\x0d\x00\x0e\x00\x0f\x00\x13\x02\x10\x04\x11\x00\x12\x00\x19\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x20\x02\x21\x02\x14\x00\x15\x00\xb5\x02\x17\x00\x18\x00\xc2\x03\xc3\x03\x13\x00\xf9\x00\xa0\x01\x14\x00\x15\x00\x19\x00\x17\x00\x18\x00\xbd\x02\x11\x04\x14\x00\x15\x00\x8b\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x55\x03\x17\x04\x13\x00\xc2\x00\x19\x00\x14\x00\x15\x00\x3d\x03\x17\x00\x18\x00\x56\x03\x18\x03\x49\x02\x13\x00\x19\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\xff\x00\x0e\x00\x0f\x00\xc3\x00\x19\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x14\x00\x15\x00\x6b\x03\x19\x00\xc4\x00\x99\x03\x66\x03\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\xae\x00\xaf\x00\x19\x00\x47\x03\x0a\x00\xf8\xfe\xf5\x00\x4e\x02\x0c\x00\x16\x00\x0d\x00\x0e\x00\x0f\x00\x12\x03\x19\x00\xf6\x00\x12\x00\xf7\x00\xf8\x00\x2d\x04\x98\x03\x0e\x00\x0f\x00\xec\x03\xcd\x00\x0a\x00\xb8\x00\x0b\x00\x85\x02\x0c\x00\x13\x00\x0d\x00\x0e\x00\x0f\x00\xed\x03\x22\x04\x11\x00\x12\x00\x37\x03\x38\x03\x39\x03\x3a\x03\x3b\x03\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x0a\x00\x6c\xfe\x0b\x00\x6c\xfe\x0c\x00\xcf\x00\x0d\x00\x0e\x00\x0f\x00\x57\x03\x08\x04\x11\x00\x12\x00\x5d\x03\x19\x00\x5d\x01\x5e\x01\xd1\x00\xd2\x00\xd3\x00\x0a\x00\x5f\x01\x0b\x00\x60\x01\x0c\x00\xeb\x02\x0d\x00\x0e\x00\x0f\x00\x00\x03\x15\x04\x11\x00\x12\x00\xf9\x00\xb3\x02\x08\x03\x44\x00\x14\x00\x61\x01\xd3\x03\x0a\x00\x6d\xfe\x0b\x00\x6d\xfe\x0c\x00\xb4\x02\x0d\x00\x0e\x00\x0f\x00\x11\x03\x01\x04\x11\x00\x12\x00\x46\x00\x18\x00\x14\x00\x15\x00\x61\x02\x17\x00\x18\x00\x0a\x00\xb0\x00\x0b\x00\xb2\x00\x0c\x00\xcb\x00\x0d\x00\x0e\x00\x0f\x00\x6c\x02\xba\x03\x11\x00\x12\x00\x78\x02\x19\x00\x13\x00\x2e\x01\x2f\x01\x30\x01\x31\x01\xc1\xfd\xc1\xfd\x3c\x03\x1e\x00\x1f\x00\x6e\xfe\xfa\x00\x6e\xfe\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\xae\x00\xaf\x00\x20\x01\x13\x00\xc1\xfd\x14\x00\x15\x00\xd5\x03\x17\x00\x18\x00\x6d\x02\x9c\x01\x48\x02\x21\x01\x19\x00\x49\x02\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x0a\x00\x9d\x01\x0b\x00\x19\x00\x0c\x00\x13\x00\x0d\x00\x0e\x00\x0f\x00\x81\x02\xbf\x03\x11\x00\x12\x00\x6f\xfe\x19\x00\x6f\xfe\x1e\x00\x1f\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x7d\x02\x0a\x00\x13\x00\x0b\x00\x70\xfe\x0c\x00\x70\xfe\x0d\x00\x0e\x00\x0f\x00\x04\x03\x0b\x03\x11\x00\x12\x00\x19\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x7a\x02\x0a\x00\x13\x00\x0b\x00\x71\xfe\x0c\x00\x71\xfe\x0d\x00\x0e\x00\x0f\x00\x88\x02\x1d\x03\x11\x00\x12\x00\x19\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x8c\x02\x0a\x00\x13\x00\x0b\x00\x72\xfe\x0c\x00\x72\xfe\x0d\x00\x0e\x00\x0f\x00\x91\x02\x77\x02\x11\x00\x12\x00\x19\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x32\x01\x0a\x00\x99\x02\x0b\x00\x33\x01\x0c\x00\xbb\x02\x0d\x00\x0e\x00\x0f\x00\xce\x02\x14\x02\x11\x00\x12\x00\x19\x00\x9e\x01\x14\x00\x34\x01\xcf\x02\x16\x02\x35\x01\x0a\x00\x17\x02\x0b\x00\xfc\x02\x0c\x00\x21\x01\x0d\x00\x0e\x00\x0f\x00\x03\x04\x1c\x02\x11\x00\x12\x00\xd5\x02\x19\x02\x13\x00\xa1\x01\x1a\x02\x37\x01\x2f\x01\x30\x01\x31\x01\x44\x00\x14\x00\x45\x00\x21\x01\x14\x00\x30\x03\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\xd1\x01\x0a\x00\x3d\x02\x0b\x00\xdf\x01\x0c\x00\x13\x00\x0d\x00\x0e\x00\x0f\x00\x0d\x02\x21\x02\x11\x00\x12\x00\x19\x00\x44\x00\x14\x00\x45\x00\xda\x01\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\xe2\x01\x0a\x00\x13\x00\x0b\x00\x79\xfe\x0c\x00\x79\xfe\x0d\x00\x0e\x00\x0f\x00\x2b\x02\x93\x00\x11\x00\x12\x00\x19\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\xe3\x01\x0a\x00\x13\x00\x0b\x00\x7a\xfe\x0c\x00\x7a\xfe\x0d\x00\x0e\x00\x0f\x00\x2e\x02\x10\x00\x11\x00\x12\x00\x19\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\xf2\x01\x0a\x00\x13\x00\x0b\x00\xd7\xfe\x0c\x00\xd7\xfe\x0d\x00\x0e\x00\x0f\x00\x2f\x02\xf5\x00\xfe\x03\x12\x00\x19\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\xa6\x00\x0a\x00\x13\x00\x0b\x00\xcd\x00\x0c\x00\x37\x02\x0d\x00\x0e\x00\x0f\x00\x43\x02\xa5\x00\x31\x02\x12\x00\x19\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\xa6\x00\x12\x01\x32\x01\x0a\x00\x3b\x01\xf1\x00\x33\x01\xef\x00\x40\x01\x0d\x00\x0e\x00\x0f\x00\x53\x01\xcf\x00\x19\x00\x59\x01\x13\x00\x58\x03\x14\x00\x34\x01\xf3\x00\x8d\x03\x35\x01\xba\x03\x68\x00\xd1\x00\xd2\x00\xd3\x00\x8f\x03\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x9d\x03\x98\x03\x0e\x00\x0f\x00\x92\x00\x0a\x00\x13\x00\x0b\x00\x59\x03\x0c\x00\x9d\x00\x0d\x00\x0e\x00\x0f\x00\x19\x00\xa3\x00\x36\x02\x12\x00\xed\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x38\x04\x0a\x00\x13\x00\x0b\x00\x9e\x03\x0c\x00\x34\x04\x0d\x00\x0e\x00\x0f\x00\xd5\x03\xd6\x03\x3e\x02\x12\x00\x19\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x2f\x04\x0a\x00\x13\x00\x0b\x00\x9f\x01\x0c\x00\xa0\x01\x0d\x00\x0e\x00\x0f\x00\xda\x02\xdb\x02\x4d\x02\x12\x00\x19\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x31\x04\x0a\x00\x13\x00\x0b\x00\x32\x04\x0c\x00\x9b\x02\x0d\x00\x0e\x00\x0f\x00\x28\x03\x53\x02\x16\x01\x12\x00\x19\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x26\x04\x0a\x00\xa4\x01\x0b\x00\x13\x00\x0c\x00\xa5\x01\x0d\x00\x0e\x00\x0f\x00\x27\x04\xa6\x01\x44\x01\x12\x00\x19\x00\xb4\x03\xb5\x03\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x0a\x00\x21\x04\x0b\x00\x08\x03\x0c\x00\x07\x04\x0d\x00\x0e\x00\x0f\x00\xb3\x01\x08\x04\x48\x01\x12\x00\x42\x02\x19\x00\x0a\x04\xae\x00\xaf\x00\x13\x00\x14\x00\x9d\x02\x14\x00\x15\x00\x9e\x02\x17\x00\x18\x00\x44\x00\x14\x00\x45\x00\x63\x03\x64\x03\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x9b\x02\x0a\x00\x13\x00\x0b\x00\x19\x00\x0c\x00\x20\x02\x0d\x00\x0e\x00\x0f\x00\xde\x02\xdf\x02\x51\x01\x12\x00\x19\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x04\x0a\x00\x13\x00\x3b\x02\xec\x01\xef\x00\x5a\xff\x0d\x00\x0e\x00\x0f\x00\x7e\x02\x0e\x04\x7f\x02\x80\x02\x19\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\xeb\x03\x0a\x00\x13\x00\x50\x02\xef\x03\xef\x00\xf1\x03\x0d\x00\x0e\x00\x0f\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x19\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x01\xfe\x0a\x00\x13\x00\x57\x02\xf4\x03\xef\x00\xf9\x03\x0d\x00\x0e\x00\x0f\x00\x0e\x01\x0f\x01\x10\x01\x11\x01\x19\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x64\x02\x53\x02\x0a\x00\x13\x00\x1b\x01\xfa\x03\xef\x00\xec\x01\x0d\x00\x0e\x00\x0f\x00\x1b\x04\x1c\x04\x1d\x04\x19\x00\x03\x04\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x05\x04\x0a\x00\xec\x01\xf1\x00\x3d\x01\xef\x00\xc5\x03\x0d\x00\x0e\x00\x0f\x00\x8d\x03\xca\x03\x8e\x03\x68\x00\x19\x00\xf2\x00\x1e\x00\x8f\x03\xd2\x03\x13\x00\xd3\x03\x0a\x00\xdd\x03\xee\x00\xc1\xfd\xef\x00\x8e\x02\x0d\x00\x0e\x00\x0f\x00\xc5\x02\xc6\x02\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\xe0\x03\x19\x01\x13\x00\xcd\x00\xb7\x00\xef\x00\xe2\x03\x0d\x00\x0e\x00\x0f\x00\x05\x04\x6a\x01\x6b\x01\xe4\x03\x19\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x7d\x03\x1a\x01\x13\x00\xb1\x02\x6b\x01\xef\x00\xd0\x01\x0d\x00\x0e\x00\x0f\x00\x7b\x03\x1c\x02\xcf\x00\x7e\x03\x19\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x7f\x03\xf3\x00\x13\x00\x1c\x01\xd1\x00\xd2\x00\xd3\x00\xef\x00\x81\x03\x0d\x00\x0e\x00\x0f\x00\xc7\x02\xc8\x02\x19\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x41\x01\xf0\x01\xf1\x01\x13\x00\xef\x00\x82\x03\x0d\x00\x0e\x00\x0f\x00\xc6\x03\xea\x02\x0d\x00\x0e\x00\x0f\x00\x19\x00\xec\x01\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x38\x01\x39\x01\x13\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x89\x03\x4f\x02\x8a\x03\x0d\x00\x0e\x00\x0f\x00\x3d\x01\x19\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x48\x03\x49\x03\x13\x00\x0d\x00\x0e\x00\x0f\x00\x44\x00\x14\x00\x45\x00\x4a\x03\x21\x04\x98\x03\x0e\x00\x0f\x00\x19\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x91\x03\x15\x01\x9b\x02\x0d\x00\x0e\x00\x0f\x00\xec\x01\x4b\x03\x4c\x03\x4d\x03\x93\x03\x4e\x03\x14\x00\x15\x00\x19\x00\x17\x00\x18\x00\x48\x03\xc7\x03\x28\x01\x0d\x00\x0e\x00\x0f\x00\xd3\x01\xd4\x01\x48\x03\xcb\x03\x97\x03\x0d\x00\x0e\x00\x0f\x00\x19\x00\x14\x00\x15\x00\x02\xfe\x17\x00\x18\x00\xd9\x03\x6a\x01\x6b\x01\xff\x00\x0e\x00\x0f\x00\x00\x01\xc8\x03\x4c\x03\x4d\x03\xaa\x03\x4e\x03\x2d\x03\x2e\x03\x19\x00\x1c\x00\x1d\x00\x14\x00\x15\x00\xcc\x03\x17\x00\x18\x00\xa2\x03\x1b\x00\x0e\x04\x98\x03\x0e\x00\x0f\x00\xb7\x03\x0f\x04\x98\x03\x0e\x00\x0f\x00\x9b\x03\x14\x00\x15\x00\x19\x00\x17\x00\x18\x00\x14\x00\x15\x00\x2f\x03\x17\x00\x18\x00\x26\x03\x33\x03\xf4\x03\x98\x03\x0e\x00\x0f\x00\x27\x03\x52\x02\x53\x02\x19\x00\xc5\x03\x98\x03\x0e\x00\x0f\x00\x19\x00\x14\x00\x15\x00\x4f\x03\x17\x00\x18\x00\xc1\xfd\xc1\xfd\xca\x03\x98\x03\x0e\x00\x0f\x00\xfa\x02\xfb\x02\x14\x00\x15\x00\x30\x03\x50\x03\x18\x00\x37\x03\x19\x00\x44\x03\x14\x00\x15\x00\x34\x03\x17\x00\x18\x00\x45\x03\x97\x03\x98\x03\x0e\x00\x0f\x00\xb8\x02\x19\x00\x14\x00\x15\x00\x9b\x02\x17\x00\x18\x00\x08\x03\x4f\x03\x19\x00\x68\x03\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x69\x03\x14\x00\x15\x00\x19\x00\x50\x03\x18\x00\x97\x02\x52\x02\x53\x02\x14\x00\x15\x00\x2b\x00\x17\x00\x18\x00\xec\x01\x01\x01\xcd\x00\xb7\x00\x6d\x03\xc9\x00\x19\x00\x14\x00\x15\x00\x76\x03\x17\x00\x18\x00\xae\x00\xaf\x00\x19\x00\x77\x03\x2c\x00\x14\x00\x15\x00\x78\x03\x17\x01\x18\x00\xd4\x01\xb7\x01\xd5\x01\xd9\x02\x19\x00\x02\x01\x03\x01\x14\x00\x15\x00\xcf\x00\x17\x00\x18\x00\x14\x00\x15\x00\x18\x01\x17\x00\x18\x00\xd6\x01\xb7\x01\xd5\x01\xda\x02\xd1\x00\xd2\x00\xd3\x00\xd7\x02\xd8\x02\x19\x00\x4d\x01\xdd\x02\x14\x00\x15\x00\x19\x00\x17\x00\x18\x00\x1b\x00\x4a\x00\xe2\x02\x14\x00\x15\x00\xec\x01\x17\x00\x18\x00\x5a\x01\x14\x00\x45\x00\xea\x02\x17\x01\x18\x00\x19\x00\x14\x00\x15\x00\xed\x02\x17\x00\x18\x00\x1b\x00\x63\x01\x19\x00\xec\x01\x1e\x00\x1f\x00\xf2\x02\x1b\x00\x51\xff\x1c\x00\x1d\x00\x1e\x00\x1f\x00\xbe\x01\x19\x00\x14\x00\x15\x00\x65\x01\x17\x00\x18\x00\xfe\x02\x20\x00\xf7\x02\x21\x00\x51\x02\x52\x02\x53\x02\xfc\x02\x20\x00\x1b\x00\x21\x00\x22\x00\xd3\x01\xd4\x01\x19\x00\x51\xff\xff\x02\xc6\x00\x22\x00\x9b\x02\xc7\x00\x00\x03\x4e\x01\x87\x02\xc9\x00\x08\x03\xa3\x03\x38\xff\x0a\x03\xa4\x03\x88\x02\xae\x00\xaf\x00\xca\x00\x0b\x03\xb2\x00\x13\x04\xcb\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x96\x01\x14\x00\x45\x00\x86\x00\x17\x01\x18\x00\x60\x02\x6a\x01\x6b\x01\x2d\x02\x2e\x02\x2b\x00\x14\x03\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x17\x03\x1b\x00\x18\x03\x2c\x00\x2b\x00\x1e\x00\x1f\x00\x1f\x03\x1b\x00\x2a\x00\x21\x03\x2b\x00\x1e\x00\x1f\x00\x20\x03\x23\x00\x51\xff\x2a\x03\x1e\x00\x27\x00\x28\x00\x29\x00\x52\x03\x2c\x00\x21\x00\x69\x01\x6a\x01\x6b\x01\x64\x02\x20\x00\x2c\x00\x21\x00\x22\x00\x2b\x00\xa5\x03\x8a\x02\x8b\x02\x8c\x02\x63\x02\x22\x00\xa0\x02\x14\x04\x34\xff\x51\xff\x66\x02\x5f\x01\x1b\x00\x60\x01\x67\x02\x68\x02\x53\x03\x8f\x00\x2c\x00\x6a\x02\x90\x00\x6b\x02\x3b\x01\xa4\x03\x6f\x02\x70\x02\x44\x00\x14\x00\x61\x01\x71\x02\x44\x00\x14\x00\x45\x00\x88\x02\x46\x00\x18\x00\x72\x02\x76\x02\x1b\x00\x77\x02\x20\x02\x7c\x02\x1e\x00\x1f\x00\x35\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x20\x00\x1b\x00\x21\x00\x7a\x02\x2b\x00\x1e\x00\x1f\x00\x7d\x02\x20\x02\x83\x02\x22\x00\x2b\x00\x8e\x02\xcd\x00\xb7\x00\xb8\x00\xb9\x00\x90\x02\xc1\xfd\x8e\x02\x99\x02\x9b\x02\x20\x00\x2c\x00\x21\x00\xa0\x02\x6a\x02\xb8\x02\x53\x03\x9f\x01\x2c\x00\x23\x00\x22\x00\xb9\x02\x54\x03\x27\x00\x28\x00\x29\x00\x86\x00\xec\x01\xc4\x02\xa5\x03\xcf\x00\xcb\x02\xbd\x00\xbf\x02\xcd\x02\xce\x02\xd8\x01\x2b\x00\xa0\x03\xd5\x02\xd9\x01\x82\x00\xd1\x00\xd2\x00\xd3\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xdf\x01\x1b\x00\x86\x00\x25\xfe\x2c\x00\x1e\x00\x1f\x00\xe1\x01\xe5\x01\x99\x01\xe6\x01\x2b\x00\xf0\x01\x0b\x02\x0d\x02\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x52\x03\x0c\x02\x21\x00\xcd\x00\xb7\x00\xb8\x00\xb9\x00\x0f\x02\x2c\x00\xc6\x00\x22\x00\x2b\x00\xc7\x00\xee\xfd\xad\x01\x11\x02\xc9\x00\x14\x02\x29\x02\x54\x03\x2b\x02\x39\x02\x31\x02\xae\x00\xaf\x00\xca\x00\x3d\x02\xb2\x00\x53\x03\xcb\x00\x2c\x00\xce\x00\xcf\x00\x40\x02\xbd\x00\xd0\x00\x3d\x01\x4b\x02\x4c\x02\x1e\x00\x5e\x02\xa1\x03\x59\x02\x5a\x02\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\x22\x01\x5f\x02\x60\x02\x0d\x01\x1e\x01\x12\x01\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x1f\x01\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x23\x01\x35\xff\x3b\x01\x2b\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x2a\x01\xc1\xfd\x3d\x01\x46\x01\x47\x01\xec\x01\x48\x01\x2c\x00\x55\x01\xc1\xfd\xd1\xfd\xd3\xfd\xc1\xfd\xd2\xfd\xc6\x00\xd5\xfd\xd8\xfd\xc7\x00\x54\x03\xc8\x00\x98\x01\xc9\x00\x99\x01\x9b\x01\xc1\xfd\xa2\x01\xc1\xfd\xc1\xfd\xae\x00\xaf\x00\xca\x00\xa3\x01\xb2\x00\xc1\xfd\xcb\x00\xac\x01\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xf1\x00\xc1\xfd\xc1\xfd\xc1\xfd\xa0\x01\xc1\xfd\xab\x01\xc1\xfd\xad\x01\xaf\x01\xb6\x01\xb5\x01\xb0\x01\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xb7\x01\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc8\x01\xbe\x01\xcb\x01\x7a\x00\xc1\xfd\x79\x00\xc1\xfd\xff\xff\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc9\x01\xc1\xfd\x7b\x00\xc1\xfd\x7c\x00\xca\x01\x82\x00\xc1\x00\xc1\xfd\x86\x00\x82\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xff\xff\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc5\x00\xff\xff\xfe\x00\xff\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xff\xff\xc1\xfd\xff\xff\x00\x00\x00\x00\x00\x00\xb3\x01\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\xc1\xfd\xae\x00\xaf\x00\xb0\x00\x00\x00\xb2\x00\x00\x00\xcb\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\xc1\xfd\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\xc1\xfd\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\xdb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x5f\x00\xdc\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x69\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\xde\x02\x00\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\x00\x00\x6d\x00\x00\x00\xe6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe7\x00\x00\x00\x00\x00\x2c\x00\xe8\x00\xe9\x00\xea\x00\x00\x00\xeb\x00\x6f\x00\x70\x00\x71\x00\xec\x00\xed\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\xc1\xfd\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\xdb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x5f\x00\xdc\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdd\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x69\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\x00\x00\x6d\x00\x00\x00\xe6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe7\x00\x00\x00\x00\x00\x2c\x00\xe8\x00\xe9\x00\xea\x00\x00\x00\xeb\x00\x6f\x00\x70\x00\x71\x00\xec\x00\xed\x00\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x4b\x00\xb6\x00\xb7\x00\xb8\x00\xb9\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\xba\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\xa6\x00\x59\x00\xbb\x00\xbc\x00\x00\x00\xbd\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\xbe\x00\xbf\x00\xc0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x1b\x00\x69\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x00\x6d\x00\x20\x00\x5b\x03\x21\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x71\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\xec\x01\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xc1\xfd\x00\x00\xc1\xfd\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x2b\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x1b\x00\xc1\xfd\x00\x00\xc1\xfd\x1e\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\x00\x00\xc1\xfd\x37\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xc1\xfd\x00\x00\xc1\xfd\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x2b\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x1b\x00\xc1\xfd\x00\x00\xc1\xfd\x1e\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\x00\x00\xc1\xfd\x37\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x5b\x00\x00\x00\x5c\x00\xdb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x2b\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x1b\x00\x69\x00\x00\x00\xc1\x03\x1e\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\xe2\x00\xe3\x00\xe4\x00\x00\x00\x00\x00\x6d\x00\x37\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc2\x03\x00\x00\x00\x00\x2c\x00\xe8\x00\xe9\x00\xea\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x71\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\xec\x01\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xc1\xfd\x00\x00\xc1\xfd\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x2b\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x1b\x00\xc1\xfd\x00\x00\x00\x00\x1e\x00\x1f\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xc1\xfd\x00\x00\xc1\xfd\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x2b\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\xc3\x01\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\xc1\xfd\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc4\x01\x6d\x00\x00\x00\x00\x00\x00\x00\x6e\x00\xc5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x71\x00\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\xc3\x01\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x1b\x00\x69\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc4\x01\x6d\x00\x20\x00\x00\x00\x21\x00\x6e\x00\xc5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x22\x00\xf1\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x71\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\xec\x01\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xc1\xfd\x00\x00\xc1\xfd\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x2b\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x1b\x00\xc1\xfd\x00\x00\xc1\xfd\x1e\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x37\x01\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\xc1\xfd\xc1\xfd\x00\x00\x74\x03\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x5b\x00\x00\x00\x5c\x00\xdb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x2b\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\xe2\x00\xe3\x00\xe4\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\xe8\x00\xe9\x00\xea\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x71\x00\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\xc3\x01\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x1b\x00\x69\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc4\x01\x6d\x00\x20\x00\x00\x00\x21\x00\x6e\x00\xc5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x71\x00\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x5b\x00\x00\x00\x5c\x00\xdb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x2b\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\xe2\x00\xe3\x00\xe4\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\xe8\x00\xe9\x00\xea\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x71\x00\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\xc3\x01\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x1b\x00\x69\x00\x00\x00\x00\x00\x1e\x00\x1f\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc4\x01\x6d\x00\x20\x00\x00\x00\x21\x00\x6e\x00\xc5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x71\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\xc1\xfd\x00\x00\xc1\xfd\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x43\x01\xc1\xfd\x00\x00\x2b\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x44\x01\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\x00\x00\xc1\xfd\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\xc1\xfd\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\xc1\xfd\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\xc1\xfd\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\xc1\xfd\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\xfd\xc1\xfd\xc1\xfd\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x01\x6d\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x01\x02\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x71\x00\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x1b\x00\x69\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x01\x6d\x00\x20\x00\x00\x00\x21\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x71\x00\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x5b\x00\x00\x00\x5c\x00\xdb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x2b\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x69\x00\x00\x00\xb2\x03\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\xe6\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x03\x00\x00\x00\x00\x2c\x00\xb4\x03\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x71\x00\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x71\x00\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x01\x6d\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x71\x00\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\xc1\xfd\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x71\x00\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x01\x6d\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x71\x00\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\xb7\x02\x2b\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x71\x00\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x01\x6d\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x71\x00\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\xc1\xfd\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x71\x00\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\xa3\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x71\x00\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x5d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x71\x00\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x71\x00\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\xc1\xfd\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x71\x00\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x71\x00\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x1b\x00\x69\x00\x00\x00\x00\x00\x1e\x00\x1f\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x00\x6d\x00\x20\x00\x00\x00\x21\x00\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x22\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x71\x00\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x00\x00\x00\x00\x37\xff\x00\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x5b\x00\x00\x00\x5c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x2b\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x1b\x00\x69\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x20\x00\x00\x00\x21\x00\xf5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x22\x00\x00\x00\xa6\x00\x00\x00\x00\x00\x6f\x00\x70\x00\x71\x00\xa7\x02\x4a\x00\x1c\x00\x1d\x00\xa8\x02\x1f\x00\x6f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x2b\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x68\x00\x4b\xfe\x4b\xfe\x00\x00\x00\x00\x2c\x00\x70\x01\xa9\x02\xaa\x02\xab\x02\xac\x02\xad\x02\xae\x02\xaf\x02\x78\x01\x79\x01\x7a\x01\x7b\x01\x7c\x01\x7d\x01\x7e\x01\x7f\x01\x80\x01\x81\x01\x82\x01\xb0\x02\x84\x01\x85\x01\x86\x01\x87\x01\x88\x01\x89\x01\x8a\x01\x8b\x01\x8c\x01\x8d\x01\x8e\x01\x8f\x01\x90\x01\x91\x01\x92\x01\x93\x01\x94\x01\x95\x01\xb1\x02\x98\xfe\x98\xfe\x98\xfe\x98\xfe\x98\xfe\x98\xfe\x00\x00\x98\xfe\x98\xfe\x98\xfe\x98\xfe\x98\xfe\x98\xfe\x98\xfe\x98\xfe\x98\xfe\x98\xfe\x98\xfe\x98\xfe\x98\xfe\x98\xfe\x98\xfe\x00\x00\x98\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x98\xfe\x00\x00\x00\x00\x98\xfe\x00\x00\x98\xfe\x98\xfe\x98\xfe\x98\xfe\x00\x00\x98\xfe\x98\xfe\x98\xfe\x00\x00\x98\xfe\x00\x00\x00\x00\x00\x00\x98\xfe\x00\x00\x98\xfe\x98\xfe\x98\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x98\xfe\x00\x00\x00\x00\x98\xfe\x98\xfe\x98\xfe\x98\xfe\x98\xfe\x98\xfe\x00\x00\x98\xfe\x98\xfe\x98\xfe\x00\x00\x98\xfe\x00\x00\x98\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\xfe\x98\xfe\x98\xfe\x98\xfe\x98\xfe\x98\xfe\x98\xfe\x00\x00\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\xfe\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\xfe\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x01\x00\x00\x00\x00\x00\x00\x6e\x01\xfb\x01\x6f\x01\x5b\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\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\x1b\x00\x00\x00\x00\x00\x2c\x00\x70\x01\x71\x01\x72\x01\x73\x01\x74\x01\x75\x01\x76\x01\x77\x01\x78\x01\x79\x01\x7a\x01\x7b\x01\x7c\x01\x7d\x01\x7e\x01\x7f\x01\x80\x01\x81\x01\x82\x01\x83\x01\x84\x01\x85\x01\x86\x01\x87\x01\x88\x01\x89\x01\x8a\x01\x8b\x01\x8c\x01\x8d\x01\x8e\x01\x8f\x01\x90\x01\x91\x01\x92\x01\x93\x01\x94\x01\x95\x01\x96\x01\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x1b\x00\x4a\x00\x00\x00\x5b\x00\x1e\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x92\x00\x65\x00\x66\x00\x67\x00\x00\x00\xc1\xfd\x00\x00\x68\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x1b\x00\x4a\x00\x7f\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x5e\x00\x00\x00\x00\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x3f\x01\x00\x00\x00\x00\x68\x00\x2c\x00\x00\x00\x00\x00\x00\x00\xd1\x03\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x5b\x00\x1b\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x2b\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x3f\x01\xc1\xfd\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x5b\x00\x1b\x00\x4a\x00\x7f\x00\x00\x00\x1e\x00\x1f\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x2b\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x40\x01\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x5b\x00\x1b\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x2b\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x3f\x01\xc1\xfd\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x1b\x00\x4a\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x54\x00\x55\x00\x56\x00\x00\x00\x57\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x58\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x00\x00\x00\x2b\x00\x5f\x00\x60\x00\x61\x00\x62\x00\x63\x00\x64\x00\x00\x00\x65\x00\x66\x00\x67\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x2c\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x1b\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x00\x00\x00\x00\xb7\x00\x00\x00\xb9\x00\x2b\x00\x00\x00\x00\x00\xcd\x00\xb7\x00\xb8\x00\xb9\x00\x00\x00\x00\x00\x00\x00\x20\x00\xfc\x00\x21\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x22\x00\x00\x00\xa6\x00\x1a\x03\x00\x00\x00\x00\x00\x00\xbd\x00\x00\x00\x50\x01\x00\x00\xce\x00\xcf\x00\xfd\x00\xbd\x00\x51\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1b\x00\xd1\x00\xd2\x00\xd3\x00\x1e\x00\x1f\x00\x00\x00\x05\x01\xb7\x00\x00\x00\xb9\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x20\x00\x00\x00\x21\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x22\x00\x2b\x00\x00\x00\x00\x00\x06\x01\x00\x00\x00\x00\xbd\x00\x00\x00\x2a\x00\x1b\x00\x2b\x00\x00\x00\x07\x01\x00\x00\x08\x01\x38\xff\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x01\x00\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x1e\x00\x1f\x00\x00\x00\x05\x01\xb7\x00\x00\x00\xb9\x00\x00\x00\x00\x00\xa6\x03\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x20\x00\x1b\x00\x21\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x22\x00\x2b\x00\x00\x00\x00\x00\x06\x01\x00\x00\x00\x00\xbd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x07\x01\x21\x00\x29\x01\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x22\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x20\x00\x1b\x00\x21\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x2c\x00\x00\x00\x00\x00\x22\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x20\x00\x1b\x00\x21\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x00\x00\x2c\x00\x2a\x00\x22\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x01\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x21\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x22\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x1b\x00\x4a\x00\x00\x00\x00\x00\x1e\x00\x1f\x00\x00\x00\x00\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x92\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2a\x00\x00\x00\x2b\x00\x74\x03\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x1e\x00\x1f\x00\x00\x00\x00\x00\x2c\x00\x2a\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x00\x00\x00\x21\x00\x1b\x00\x4a\x00\x00\x00\x00\x00\x1e\x00\x1f\x00\x2c\x00\x22\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x1b\x00\x92\x00\x00\x00\x00\x00\x1e\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x75\x03\x1b\x00\x20\x00\x00\x00\x21\x00\x1e\x00\x1f\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x22\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x8d\x00\x00\x00\x8e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x4a\x00\x00\x00\x8f\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x63\x01\x00\x00\x2c\x00\x1e\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x64\x01\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x65\x01\x75\x03\x00\x00\x1b\x00\x37\x01\x36\x04\x00\x00\x1e\x00\x00\x00\x00\x00\x2c\x00\x2b\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x37\x04\x00\x00\x00\x00\x00\x00\x37\x01\xe9\x03\x00\x00\x1b\x00\x4a\x00\x00\x00\x2c\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xea\x03\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x3f\x01\x00\x00\x2c\x00\x1b\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3f\x01\x00\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x2c\x00\x2b\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1b\x00\x2d\x01\x2c\x00\x2b\x00\x1e\x00\x00\x00\x00\x00\x1b\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x2e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x37\x01\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x0e\x03\x1b\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x1b\x00\x26\x03\x2b\x00\x00\x00\x1e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\x28\x00\x29\x00\x00\x00\xf3\x01\xbf\x01\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x2c\x00\x2b\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\xcd\x00\xb7\x00\xb8\x00\xb9\x00\x00\x00\x00\x00\x3e\x00\x2c\x00\x00\x00\xfb\x01\xfc\x01\xfd\x01\xfe\x01\x00\x00\xff\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xce\x00\xcf\x00\x40\x00\xbd\x00\xbf\x03\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd1\x00\xd2\x00\xd3\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\xf3\x01\xbf\x01\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\xcd\x00\xb7\x00\xb8\x00\xb9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\xf2\x02\xfd\x01\xfe\x01\x00\x00\xff\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x01\x00\x00\x00\x00\x00\x00\xce\x00\xcf\x00\x00\x00\xbd\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\xd1\x00\xd2\x00\xd3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\xf3\x01\xbf\x01\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf3\x02\xfe\x01\x00\x00\xff\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\xf3\x01\xbf\x01\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xef\x03\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\xf3\x01\xbf\x01\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0e\x03\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\xf3\x01\xbf\x01\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf4\x01\xf5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\xbe\x01\xbf\x01\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\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\xc0\x01\x00\x00\x82\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\xbe\x01\xbf\x01\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\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\xc0\x01\x00\x00\xe2\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\xbe\x01\xbf\x01\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\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\xc0\x01\x00\x00\xe3\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\xf3\x01\xbf\x01\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf6\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\xbe\x01\xbf\x01\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\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\xc0\x01\x00\x00\xc9\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\xbe\x01\xbf\x01\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\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\xc0\x01\x00\x00\xdd\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\xbe\x01\xbf\x01\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\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\xc0\x01\x00\x00\xc1\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\xbe\x01\xbf\x01\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\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\xc0\x01\x00\x00\xc5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x1f\x04\x72\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\xda\x03\x72\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\xdb\x03\x72\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\xa6\x03\x72\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\xb7\x03\x72\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x5e\x03\x72\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x5f\x03\x72\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x60\x03\x72\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x61\x03\x72\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x65\x03\x72\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\xe4\x02\x72\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x8e\x02\x72\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\xb5\x02\x72\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x4b\x01\x72\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x96\x00\x72\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x97\x00\x72\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x71\x00\x72\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\xa6\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\xa7\x00\x00\x00\xa8\x00\x00\x00\xa9\x00\x3d\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\xaa\x00\x00\x00\xab\x00\x00\x00\x00\x00\xac\x00\xad\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\x47\x00\x48\x00\x9e\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x9f\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\xa0\x00\xa1\x00\x00\x00\x9e\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x08\x02\x09\x02\x00\x00\x00\x00\x3d\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\xd7\x03\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\xd8\x03\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x62\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x9e\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\xf8\x02\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x02\x02\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x03\x02\x00\x00\x00\x00\x3d\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x9e\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x04\x02\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x06\x02\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x02\x3d\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x98\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x99\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x32\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\xea\x02\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\xf7\x02\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\xa1\x02\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\xb9\x02\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\xd9\x01\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\xe1\x01\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\xec\x01\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\xf8\x01\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x01\x02\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x05\x02\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x55\x01\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x56\x01\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x57\x01\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x58\x01\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x86\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x88\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x89\x00\x33\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x03\x34\x00\x95\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x99\x01\x34\x00\x95\x00\x36\x00\x37\x00\x38\x00\x39\x00\x47\x00\x48\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x34\x00\x95\x00\x36\x00\x37\x00\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x3e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x5b\x01\x5c\x01\x38\x00\x39\x00\x47\x00\x48\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x01\x38\x00\x39\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x9b\x00\x00\x00\x00\x00\x3a\x00\x3b\x00\x3c\x00\x00\x00\x47\x00\x48\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\x01\xa7\x01\x7d\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\xf9\x01\x7d\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x3d\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\x7c\x00\x7d\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\xa2\x02\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x3d\x00\x00\x00\x00\x00\xa3\x02\x6a\x01\x6b\x01\x00\x00\xa4\x02\x2b\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x02\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\xa3\x02\x6a\x01\x6b\x01\x00\x00\xa4\x02\xa5\x02\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x5c\x03\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x3d\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\x4c\x01\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x65\x01\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x3d\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\x66\x01\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\xc5\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x3d\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\xc6\x01\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x9a\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x3d\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\x9c\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x47\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\xc5\x00\x3b\x00\x3c\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\x00\x3d\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x41\x00\x42\x00\x00\x00\x43\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x00\x14\x00\x45\x00\x16\x00\x46\x00\x18\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x48\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"# + +happyReduceArr = Happy_Data_Array.array (6, 585) [ + (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), + (414 , happyReduce_414), + (415 , happyReduce_415), + (416 , happyReduce_416), + (417 , happyReduce_417), + (418 , happyReduce_418), + (419 , happyReduce_419), + (420 , happyReduce_420), + (421 , happyReduce_421), + (422 , happyReduce_422), + (423 , happyReduce_423), + (424 , happyReduce_424), + (425 , happyReduce_425), + (426 , happyReduce_426), + (427 , happyReduce_427), + (428 , happyReduce_428), + (429 , happyReduce_429), + (430 , happyReduce_430), + (431 , happyReduce_431), + (432 , happyReduce_432), + (433 , happyReduce_433), + (434 , happyReduce_434), + (435 , happyReduce_435), + (436 , happyReduce_436), + (437 , happyReduce_437), + (438 , happyReduce_438), + (439 , happyReduce_439), + (440 , happyReduce_440), + (441 , happyReduce_441), + (442 , happyReduce_442), + (443 , happyReduce_443), + (444 , happyReduce_444), + (445 , happyReduce_445), + (446 , happyReduce_446), + (447 , happyReduce_447), + (448 , happyReduce_448), + (449 , happyReduce_449), + (450 , happyReduce_450), + (451 , happyReduce_451), + (452 , happyReduce_452), + (453 , happyReduce_453), + (454 , happyReduce_454), + (455 , happyReduce_455), + (456 , happyReduce_456), + (457 , happyReduce_457), + (458 , happyReduce_458), + (459 , happyReduce_459), + (460 , happyReduce_460), + (461 , happyReduce_461), + (462 , happyReduce_462), + (463 , happyReduce_463), + (464 , happyReduce_464), + (465 , happyReduce_465), + (466 , happyReduce_466), + (467 , happyReduce_467), + (468 , happyReduce_468), + (469 , happyReduce_469), + (470 , happyReduce_470), + (471 , happyReduce_471), + (472 , happyReduce_472), + (473 , happyReduce_473), + (474 , happyReduce_474), + (475 , happyReduce_475), + (476 , happyReduce_476), + (477 , happyReduce_477), + (478 , happyReduce_478), + (479 , happyReduce_479), + (480 , happyReduce_480), + (481 , happyReduce_481), + (482 , happyReduce_482), + (483 , happyReduce_483), + (484 , happyReduce_484), + (485 , happyReduce_485), + (486 , happyReduce_486), + (487 , happyReduce_487), + (488 , happyReduce_488), + (489 , happyReduce_489), + (490 , happyReduce_490), + (491 , happyReduce_491), + (492 , happyReduce_492), + (493 , happyReduce_493), + (494 , happyReduce_494), + (495 , happyReduce_495), + (496 , happyReduce_496), + (497 , happyReduce_497), + (498 , happyReduce_498), + (499 , happyReduce_499), + (500 , happyReduce_500), + (501 , happyReduce_501), + (502 , happyReduce_502), + (503 , happyReduce_503), + (504 , happyReduce_504), + (505 , happyReduce_505), + (506 , happyReduce_506), + (507 , happyReduce_507), + (508 , happyReduce_508), + (509 , happyReduce_509), + (510 , happyReduce_510), + (511 , happyReduce_511), + (512 , happyReduce_512), + (513 , happyReduce_513), + (514 , happyReduce_514), + (515 , happyReduce_515), + (516 , happyReduce_516), + (517 , happyReduce_517), + (518 , happyReduce_518), + (519 , happyReduce_519), + (520 , happyReduce_520), + (521 , happyReduce_521), + (522 , happyReduce_522), + (523 , happyReduce_523), + (524 , happyReduce_524), + (525 , happyReduce_525), + (526 , happyReduce_526), + (527 , happyReduce_527), + (528 , happyReduce_528), + (529 , happyReduce_529), + (530 , happyReduce_530), + (531 , happyReduce_531), + (532 , happyReduce_532), + (533 , happyReduce_533), + (534 , happyReduce_534), + (535 , happyReduce_535), + (536 , happyReduce_536), + (537 , happyReduce_537), + (538 , happyReduce_538), + (539 , happyReduce_539), + (540 , happyReduce_540), + (541 , happyReduce_541), + (542 , happyReduce_542), + (543 , happyReduce_543), + (544 , happyReduce_544), + (545 , happyReduce_545), + (546 , happyReduce_546), + (547 , happyReduce_547), + (548 , happyReduce_548), + (549 , happyReduce_549), + (550 , happyReduce_550), + (551 , happyReduce_551), + (552 , happyReduce_552), + (553 , happyReduce_553), + (554 , happyReduce_554), + (555 , happyReduce_555), + (556 , happyReduce_556), + (557 , happyReduce_557), + (558 , happyReduce_558), + (559 , happyReduce_559), + (560 , happyReduce_560), + (561 , happyReduce_561), + (562 , happyReduce_562), + (563 , happyReduce_563), + (564 , happyReduce_564), + (565 , happyReduce_565), + (566 , happyReduce_566), + (567 , happyReduce_567), + (568 , happyReduce_568), + (569 , happyReduce_569), + (570 , happyReduce_570), + (571 , happyReduce_571), + (572 , happyReduce_572), + (573 , happyReduce_573), + (574 , happyReduce_574), + (575 , happyReduce_575), + (576 , happyReduce_576), + (577 , happyReduce_577), + (578 , happyReduce_578), + (579 , happyReduce_579), + (580 , happyReduce_580), + (581 , happyReduce_581), + (582 , happyReduce_582), + (583 , happyReduce_583), + (584 , happyReduce_584), + (585 , happyReduce_585) + ] + +happy_n_terms = 134 :: Int +happy_n_nonterms = 216 :: Int + +happyReduce_6 = happyMonadReduce 2# 0# happyReduction_6 +happyReduction_6 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut11 happy_x_1 of { happy_var_1 -> + case happyOut10 happy_x_2 of { happy_var_2 -> + ( checkExpr happy_var_2 >>= mkPageModule happy_var_1)}} + ) (\r -> happyReturn (happyIn9 r)) + +happyReduce_7 = happyMonadReduce 6# 0# happyReduction_7 +happyReduction_7 (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 happyOut11 happy_x_1 of { happy_var_1 -> + case happyOut15 happy_x_3 of { happy_var_3 -> + case happyOut216 happy_x_5 of { happy_var_5 -> + case happyOut10 happy_x_6 of { happy_var_6 -> + ( checkExpr happy_var_6 >>= \x -> mkPage (happy_var_3 happy_var_1) happy_var_5 x)}}}} + ) (\r -> happyReturn (happyIn9 r)) + +happyReduce_8 = happySpecReduce_2 0# happyReduction_8 +happyReduction_8 happy_x_2 + happy_x_1 + = case happyOut11 happy_x_1 of { happy_var_1 -> + case happyOut15 happy_x_2 of { happy_var_2 -> + happyIn9 + (happy_var_2 happy_var_1 + )}} + +happyReduce_9 = happyMonadReduce 10# 1# happyReduction_9 +happyReduction_9 (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 happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut156 happy_x_3 of { happy_var_3 -> + case happyOut159 happy_x_4 of { happy_var_4 -> + case happyOut161 happy_x_5 of { happy_var_5 -> + case happyOut154 happy_x_7 of { happy_var_7 -> + case happyOut156 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 $ XTag happy_var_1 n as happy_var_5 cn })}}}}}} + ) (\r -> happyReturn (happyIn10 r)) + +happyReduce_10 = happyReduce 6# 1# happyReduction_10 +happyReduction_10 (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 happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut156 happy_x_3 of { happy_var_3 -> + case happyOut159 happy_x_4 of { happy_var_4 -> + case happyOut161 happy_x_5 of { happy_var_5 -> + happyIn10 + (XETag happy_var_1 happy_var_3 (reverse happy_var_4) happy_var_5 + ) `HappyStk` happyRest}}}} + +happyReduce_11 = happySpecReduce_3 2# happyReduction_11 +happyReduction_11 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut12 happy_x_2 of { happy_var_2 -> + happyIn11 + (happy_var_2 + )} + +happyReduce_12 = happySpecReduce_3 3# happyReduction_12 +happyReduction_12 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut13 happy_x_1 of { happy_var_1 -> + case happyOut12 happy_x_3 of { happy_var_3 -> + happyIn12 + (happy_var_1 : happy_var_3 + )}} + +happyReduce_13 = happySpecReduce_0 3# happyReduction_13 +happyReduction_13 = happyIn12 + ([] + ) + +happyReduce_14 = happyReduce 4# 4# happyReduction_14 +happyReduction_14 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut14 happy_x_3 of { happy_var_3 -> + happyIn13 + (LanguagePragma happy_var_1 happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_15 = happySpecReduce_3 4# happyReduction_15 +happyReduction_15 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (INCLUDE happy_var_2) -> + happyIn13 + (IncludePragma happy_var_1 happy_var_2 + )}} + +happyReduce_16 = happySpecReduce_3 4# happyReduction_16 +happyReduction_16 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (OPTIONS happy_var_2) -> + happyIn13 + (let (mc, s) = happy_var_2 in OptionsPragma happy_var_1 (readTool mc) s + )}} + +happyReduce_17 = happySpecReduce_3 4# happyReduction_17 +happyReduction_17 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (CFILES happy_var_2) -> + happyIn13 + (CFilesPragma happy_var_1 happy_var_2 + )}} + +happyReduce_18 = happySpecReduce_3 5# happyReduction_18 +happyReduction_18 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut207 happy_x_1 of { happy_var_1 -> + case happyOut14 happy_x_3 of { happy_var_3 -> + happyIn14 + (happy_var_1 : happy_var_3 + )}} + +happyReduce_19 = happySpecReduce_1 5# happyReduction_19 +happyReduction_19 happy_x_1 + = case happyOut207 happy_x_1 of { happy_var_1 -> + happyIn14 + ([happy_var_1] + )} + +happyReduce_20 = happyReduce 7# 6# happyReduction_20 +happyReduction_20 (happy_x_7 `HappyStk` + happy_x_6 `HappyStk` + happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut219 happy_x_3 of { happy_var_3 -> + case happyOut16 happy_x_4 of { happy_var_4 -> + case happyOut21 happy_x_5 of { happy_var_5 -> + case happyOut17 happy_x_7 of { happy_var_7 -> + happyIn15 + (\os -> Module happy_var_1 happy_var_3 os happy_var_4 happy_var_5 (fst happy_var_7) (snd happy_var_7) + ) `HappyStk` happyRest}}}}} + +happyReduce_21 = happySpecReduce_2 6# happyReduction_21 +happyReduction_21 happy_x_2 + happy_x_1 + = case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut17 happy_x_2 of { happy_var_2 -> + happyIn15 + (\os -> Module happy_var_1 main_mod os Nothing (Just [EVar (UnQual main_name)]) + (fst happy_var_2) (snd happy_var_2) + )}} + +happyReduce_22 = happySpecReduce_3 7# happyReduction_22 +happyReduction_22 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_2 of { (StringTok happy_var_2) -> + happyIn16 + (Just $ DeprText happy_var_2 + )} + +happyReduce_23 = happySpecReduce_3 7# happyReduction_23 +happyReduction_23 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_2 of { (StringTok happy_var_2) -> + happyIn16 + (Just $ WarnText happy_var_2 + )} + +happyReduce_24 = happySpecReduce_0 7# happyReduction_24 +happyReduction_24 = happyIn16 + (Nothing + ) + +happyReduce_25 = happySpecReduce_3 8# happyReduction_25 +happyReduction_25 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut18 happy_x_2 of { happy_var_2 -> + happyIn17 + (happy_var_2 + )} + +happyReduce_26 = happySpecReduce_3 8# happyReduction_26 +happyReduction_26 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut18 happy_x_2 of { happy_var_2 -> + happyIn17 + (happy_var_2 + )} + +happyReduce_27 = happyReduce 4# 9# happyReduction_27 +happyReduction_27 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut26 happy_x_2 of { happy_var_2 -> + case happyOut43 happy_x_4 of { happy_var_4 -> + happyIn18 + ((reverse happy_var_2, happy_var_4) + ) `HappyStk` happyRest}} + +happyReduce_28 = happySpecReduce_2 9# happyReduction_28 +happyReduction_28 happy_x_2 + happy_x_1 + = case happyOut43 happy_x_2 of { happy_var_2 -> + happyIn18 + (([], happy_var_2) + )} + +happyReduce_29 = happySpecReduce_3 9# happyReduction_29 +happyReduction_29 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut26 happy_x_2 of { happy_var_2 -> + happyIn18 + ((reverse happy_var_2, []) + )} + +happyReduce_30 = happySpecReduce_1 9# happyReduction_30 +happyReduction_30 happy_x_1 + = happyIn18 + (([], []) + ) + +happyReduce_31 = happySpecReduce_2 10# happyReduction_31 +happyReduction_31 happy_x_2 + happy_x_1 + = happyIn19 + (() + ) + +happyReduce_32 = happySpecReduce_1 11# happyReduction_32 +happyReduction_32 happy_x_1 + = happyIn20 + (() + ) + +happyReduce_33 = happySpecReduce_0 11# happyReduction_33 +happyReduction_33 = happyIn20 + (() + ) + +happyReduce_34 = happySpecReduce_1 12# happyReduction_34 +happyReduction_34 happy_x_1 + = case happyOut22 happy_x_1 of { happy_var_1 -> + happyIn21 + (Just happy_var_1 + )} + +happyReduce_35 = happySpecReduce_0 12# happyReduction_35 +happyReduction_35 = happyIn21 + (Nothing + ) + +happyReduce_36 = happyReduce 4# 13# happyReduction_36 +happyReduction_36 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut24 happy_x_2 of { happy_var_2 -> + happyIn22 + (reverse happy_var_2 + ) `HappyStk` happyRest} + +happyReduce_37 = happySpecReduce_3 13# happyReduction_37 +happyReduction_37 happy_x_3 + happy_x_2 + happy_x_1 + = happyIn22 + ([] + ) + +happyReduce_38 = happySpecReduce_1 14# happyReduction_38 +happyReduction_38 happy_x_1 + = happyIn23 + (() + ) + +happyReduce_39 = happySpecReduce_0 14# happyReduction_39 +happyReduction_39 = happyIn23 + (() + ) + +happyReduce_40 = happySpecReduce_3 15# happyReduction_40 +happyReduction_40 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut24 happy_x_1 of { happy_var_1 -> + case happyOut25 happy_x_3 of { happy_var_3 -> + happyIn24 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_41 = happySpecReduce_1 15# happyReduction_41 +happyReduction_41 happy_x_1 + = case happyOut25 happy_x_1 of { happy_var_1 -> + happyIn24 + ([happy_var_1] + )} + +happyReduce_42 = happySpecReduce_1 16# happyReduction_42 +happyReduction_42 happy_x_1 + = case happyOut189 happy_x_1 of { happy_var_1 -> + happyIn25 + (EVar happy_var_1 + )} + +happyReduce_43 = happySpecReduce_1 16# happyReduction_43 +happyReduction_43 happy_x_1 + = case happyOut221 happy_x_1 of { happy_var_1 -> + happyIn25 + (EAbs happy_var_1 + )} + +happyReduce_44 = happyReduce 4# 16# happyReduction_44 +happyReduction_44 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut221 happy_x_1 of { happy_var_1 -> + happyIn25 + (EThingAll happy_var_1 + ) `HappyStk` happyRest} + +happyReduce_45 = happySpecReduce_3 16# happyReduction_45 +happyReduction_45 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut221 happy_x_1 of { happy_var_1 -> + happyIn25 + (EThingWith happy_var_1 [] + )} + +happyReduce_46 = happyReduce 4# 16# happyReduction_46 +happyReduction_46 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut221 happy_x_1 of { happy_var_1 -> + case happyOut37 happy_x_3 of { happy_var_3 -> + happyIn25 + (EThingWith happy_var_1 (reverse happy_var_3) + ) `HappyStk` happyRest}} + +happyReduce_47 = happySpecReduce_2 16# happyReduction_47 +happyReduction_47 happy_x_2 + happy_x_1 + = case happyOut219 happy_x_2 of { happy_var_2 -> + happyIn25 + (EModuleContents happy_var_2 + )} + +happyReduce_48 = happySpecReduce_3 17# happyReduction_48 +happyReduction_48 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut26 happy_x_1 of { happy_var_1 -> + case happyOut27 happy_x_3 of { happy_var_3 -> + happyIn26 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_49 = happySpecReduce_1 17# happyReduction_49 +happyReduction_49 happy_x_1 + = case happyOut27 happy_x_1 of { happy_var_1 -> + happyIn26 + ([happy_var_1] + )} + +happyReduce_50 = happyReduce 8# 18# happyReduction_50 +happyReduction_50 (happy_x_8 `HappyStk` + happy_x_7 `HappyStk` + happy_x_6 `HappyStk` + happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut28 happy_x_3 of { happy_var_3 -> + case happyOut29 happy_x_4 of { happy_var_4 -> + case happyOut30 happy_x_5 of { happy_var_5 -> + case happyOut219 happy_x_6 of { happy_var_6 -> + case happyOut31 happy_x_7 of { happy_var_7 -> + case happyOut32 happy_x_8 of { happy_var_8 -> + happyIn27 + (ImportDecl happy_var_1 happy_var_6 happy_var_4 happy_var_3 happy_var_5 happy_var_7 happy_var_8 + ) `HappyStk` happyRest}}}}}}} + +happyReduce_51 = happySpecReduce_2 19# happyReduction_51 +happyReduction_51 happy_x_2 + happy_x_1 + = happyIn28 + (True + ) + +happyReduce_52 = happySpecReduce_0 19# happyReduction_52 +happyReduction_52 = happyIn28 + (False + ) + +happyReduce_53 = happySpecReduce_1 20# happyReduction_53 +happyReduction_53 happy_x_1 + = happyIn29 + (True + ) + +happyReduce_54 = happySpecReduce_0 20# happyReduction_54 +happyReduction_54 = happyIn29 + (False + ) + +happyReduce_55 = happyMonadReduce 1# 21# happyReduction_55 +happyReduction_55 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { (StringTok happy_var_1) -> + ( do { checkEnabled PackageImports ; + return $ Just happy_var_1 })} + ) (\r -> happyReturn (happyIn30 r)) + +happyReduce_56 = happySpecReduce_0 21# happyReduction_56 +happyReduction_56 = happyIn30 + (Nothing + ) + +happyReduce_57 = happySpecReduce_2 22# happyReduction_57 +happyReduction_57 happy_x_2 + happy_x_1 + = case happyOut219 happy_x_2 of { happy_var_2 -> + happyIn31 + (Just happy_var_2 + )} + +happyReduce_58 = happySpecReduce_0 22# happyReduction_58 +happyReduction_58 = happyIn31 + (Nothing + ) + +happyReduce_59 = happySpecReduce_1 23# happyReduction_59 +happyReduction_59 happy_x_1 + = case happyOut33 happy_x_1 of { happy_var_1 -> + happyIn32 + (Just happy_var_1 + )} + +happyReduce_60 = happySpecReduce_0 23# happyReduction_60 +happyReduction_60 = happyIn32 + (Nothing + ) + +happyReduce_61 = happyReduce 5# 24# happyReduction_61 +happyReduction_61 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut34 happy_x_1 of { happy_var_1 -> + case happyOut35 happy_x_3 of { happy_var_3 -> + happyIn33 + ((happy_var_1, reverse happy_var_3) + ) `HappyStk` happyRest}} + +happyReduce_62 = happyReduce 4# 24# happyReduction_62 +happyReduction_62 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut34 happy_x_1 of { happy_var_1 -> + happyIn33 + ((happy_var_1, []) + ) `HappyStk` happyRest} + +happyReduce_63 = happySpecReduce_1 25# happyReduction_63 +happyReduction_63 happy_x_1 + = happyIn34 + (True + ) + +happyReduce_64 = happySpecReduce_0 25# happyReduction_64 +happyReduction_64 = happyIn34 + (False + ) + +happyReduce_65 = happySpecReduce_3 26# happyReduction_65 +happyReduction_65 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut35 happy_x_1 of { happy_var_1 -> + case happyOut36 happy_x_3 of { happy_var_3 -> + happyIn35 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_66 = happySpecReduce_1 26# happyReduction_66 +happyReduction_66 happy_x_1 + = case happyOut36 happy_x_1 of { happy_var_1 -> + happyIn35 + ([happy_var_1] + )} + +happyReduce_67 = happySpecReduce_1 27# happyReduction_67 +happyReduction_67 happy_x_1 + = case happyOut187 happy_x_1 of { happy_var_1 -> + happyIn36 + (IVar happy_var_1 + )} + +happyReduce_68 = happySpecReduce_1 27# happyReduction_68 +happyReduction_68 happy_x_1 + = case happyOut220 happy_x_1 of { happy_var_1 -> + happyIn36 + (IAbs happy_var_1 + )} + +happyReduce_69 = happyReduce 4# 27# happyReduction_69 +happyReduction_69 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut220 happy_x_1 of { happy_var_1 -> + happyIn36 + (IThingAll happy_var_1 + ) `HappyStk` happyRest} + +happyReduce_70 = happySpecReduce_3 27# happyReduction_70 +happyReduction_70 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut220 happy_x_1 of { happy_var_1 -> + happyIn36 + (IThingWith happy_var_1 [] + )} + +happyReduce_71 = happyReduce 4# 27# happyReduction_71 +happyReduction_71 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut220 happy_x_1 of { happy_var_1 -> + case happyOut37 happy_x_3 of { happy_var_3 -> + happyIn36 + (IThingWith happy_var_1 (reverse happy_var_3) + ) `HappyStk` happyRest}} + +happyReduce_72 = happySpecReduce_3 28# happyReduction_72 +happyReduction_72 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut37 happy_x_1 of { happy_var_1 -> + case happyOut38 happy_x_3 of { happy_var_3 -> + happyIn37 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_73 = happySpecReduce_1 28# happyReduction_73 +happyReduction_73 happy_x_1 + = case happyOut38 happy_x_1 of { happy_var_1 -> + happyIn37 + ([happy_var_1] + )} + +happyReduce_74 = happySpecReduce_1 29# happyReduction_74 +happyReduction_74 happy_x_1 + = case happyOut187 happy_x_1 of { happy_var_1 -> + happyIn38 + (VarName happy_var_1 + )} + +happyReduce_75 = happySpecReduce_1 29# happyReduction_75 +happyReduction_75 happy_x_1 + = case happyOut191 happy_x_1 of { happy_var_1 -> + happyIn38 + (ConName happy_var_1 + )} + +happyReduce_76 = happyReduce 4# 30# happyReduction_76 +happyReduction_76 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut41 happy_x_2 of { happy_var_2 -> + case happyOut40 happy_x_3 of { happy_var_3 -> + case happyOut42 happy_x_4 of { happy_var_4 -> + happyIn39 + (InfixDecl happy_var_1 happy_var_2 happy_var_3 (reverse happy_var_4) + ) `HappyStk` happyRest}}}} + +happyReduce_77 = happySpecReduce_0 31# happyReduction_77 +happyReduction_77 = happyIn40 + (9 + ) + +happyReduce_78 = happyMonadReduce 1# 31# happyReduction_78 +happyReduction_78 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOutTok happy_x_1 of { (IntTok happy_var_1) -> + ( checkPrec happy_var_1)} + ) (\r -> happyReturn (happyIn40 r)) + +happyReduce_79 = happySpecReduce_1 32# happyReduction_79 +happyReduction_79 happy_x_1 + = happyIn41 + (AssocNone + ) + +happyReduce_80 = happySpecReduce_1 32# happyReduction_80 +happyReduction_80 happy_x_1 + = happyIn41 + (AssocLeft + ) + +happyReduce_81 = happySpecReduce_1 32# happyReduction_81 +happyReduction_81 happy_x_1 + = happyIn41 + (AssocRight + ) + +happyReduce_82 = happySpecReduce_3 33# happyReduction_82 +happyReduction_82 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut42 happy_x_1 of { happy_var_1 -> + case happyOut198 happy_x_3 of { happy_var_3 -> + happyIn42 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_83 = happySpecReduce_1 33# happyReduction_83 +happyReduction_83 happy_x_1 + = case happyOut198 happy_x_1 of { happy_var_1 -> + happyIn42 + ([happy_var_1] + )} + +happyReduce_84 = happyMonadReduce 2# 34# happyReduction_84 +happyReduction_84 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut44 happy_x_1 of { happy_var_1 -> + ( checkRevDecls happy_var_1)} + ) (\r -> happyReturn (happyIn43 r)) + +happyReduce_85 = happySpecReduce_3 35# happyReduction_85 +happyReduction_85 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut44 happy_x_1 of { happy_var_1 -> + case happyOut45 happy_x_3 of { happy_var_3 -> + happyIn44 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_86 = happySpecReduce_1 35# happyReduction_86 +happyReduction_86 happy_x_1 + = case happyOut45 happy_x_1 of { happy_var_1 -> + happyIn44 + ([happy_var_1] + )} + +happyReduce_87 = happyMonadReduce 5# 36# happyReduction_87 +happyReduction_87 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut71 happy_x_3 of { happy_var_3 -> + case happyOut81 happy_x_5 of { happy_var_5 -> + ( do { (c,ts) <- checkSimpleType happy_var_3; + return (TypeDecl happy_var_1 c ts happy_var_5) })}}} + ) (\r -> happyReturn (happyIn45 r)) + +happyReduce_88 = happyMonadReduce 5# 36# happyReduction_88 +happyReduction_88 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut73 happy_x_4 of { happy_var_4 -> + case happyOut115 happy_x_5 of { happy_var_5 -> + ( do { (c,ts) <- checkSimpleType happy_var_4; + return (TypeFamDecl happy_var_1 c ts happy_var_5) })}}} + ) (\r -> happyReturn (happyIn45 r)) + +happyReduce_89 = happyMonadReduce 6# 36# happyReduction_89 +happyReduction_89 (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 happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut70 happy_x_4 of { happy_var_4 -> + case happyOut81 happy_x_6 of { happy_var_6 -> + ( do { -- no checkSimpleType happy_var_4 since dtype may contain type patterns + checkEnabled TypeFamilies ; + return (TypeInsDecl happy_var_1 happy_var_4 happy_var_6) })}}} + ) (\r -> happyReturn (happyIn45 r)) + +happyReduce_90 = happyMonadReduce 5# 36# happyReduction_90 +happyReduction_90 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut46 happy_x_2 of { happy_var_2 -> + case happyOut82 happy_x_3 of { happy_var_3 -> + case happyOut97 happy_x_4 of { happy_var_4 -> + case happyOut109 happy_x_5 of { happy_var_5 -> + ( do { (cs,c,t) <- checkDataHeader happy_var_3; + checkDataOrNew happy_var_2 happy_var_4; + return (DataDecl happy_var_1 happy_var_2 cs c t (reverse happy_var_4) happy_var_5) })}}}}} + ) (\r -> happyReturn (happyIn45 r)) + +happyReduce_91 = happyMonadReduce 7# 36# happyReduction_91 +happyReduction_91 (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 happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut46 happy_x_2 of { happy_var_2 -> + case happyOut82 happy_x_3 of { happy_var_3 -> + case happyOut115 happy_x_4 of { happy_var_4 -> + case happyOut92 happy_x_6 of { happy_var_6 -> + case happyOut109 happy_x_7 of { happy_var_7 -> + ( do { (cs,c,t) <- checkDataHeader happy_var_3; + checkDataOrNew happy_var_2 happy_var_6; + return (GDataDecl happy_var_1 happy_var_2 cs c t happy_var_4 (reverse happy_var_6) happy_var_7) })}}}}}} + ) (\r -> happyReturn (happyIn45 r)) + +happyReduce_92 = happyMonadReduce 5# 36# happyReduction_92 +happyReduction_92 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut82 happy_x_4 of { happy_var_4 -> + case happyOut115 happy_x_5 of { happy_var_5 -> + ( do { (cs,c,t) <- checkDataHeader happy_var_4; + return (DataFamDecl happy_var_1 cs c t happy_var_5) })}}} + ) (\r -> happyReturn (happyIn45 r)) + +happyReduce_93 = happyMonadReduce 6# 36# happyReduction_93 +happyReduction_93 (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 happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut46 happy_x_2 of { happy_var_2 -> + case happyOut81 happy_x_4 of { happy_var_4 -> + case happyOut97 happy_x_5 of { happy_var_5 -> + case happyOut109 happy_x_6 of { happy_var_6 -> + ( do { -- (cs,c,t) <- checkDataHeader happy_var_4; + checkEnabled TypeFamilies ; + checkDataOrNew happy_var_2 happy_var_5; + return (DataInsDecl happy_var_1 happy_var_2 happy_var_4 (reverse happy_var_5) happy_var_6) })}}}}} + ) (\r -> happyReturn (happyIn45 r)) + +happyReduce_94 = happyMonadReduce 8# 36# happyReduction_94 +happyReduction_94 (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 happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut46 happy_x_2 of { happy_var_2 -> + case happyOut81 happy_x_4 of { happy_var_4 -> + case happyOut115 happy_x_5 of { happy_var_5 -> + case happyOut92 happy_x_7 of { happy_var_7 -> + case happyOut109 happy_x_8 of { happy_var_8 -> + ( do { -- (cs,c,t) <- checkDataHeader happy_var_4; + checkEnabled TypeFamilies ; + checkDataOrNew happy_var_2 happy_var_7; + return (GDataInsDecl happy_var_1 happy_var_2 happy_var_4 happy_var_5 (reverse happy_var_7) happy_var_8) })}}}}}} + ) (\r -> happyReturn (happyIn45 r)) + +happyReduce_95 = happyMonadReduce 5# 36# happyReduction_95 +happyReduction_95 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut82 happy_x_3 of { happy_var_3 -> + case happyOut89 happy_x_4 of { happy_var_4 -> + case happyOut116 happy_x_5 of { happy_var_5 -> + ( do { (cs,c,vs) <- checkClassHeader happy_var_3; + return (ClassDecl happy_var_1 cs c vs happy_var_4 happy_var_5) })}}}} + ) (\r -> happyReturn (happyIn45 r)) + +happyReduce_96 = happyMonadReduce 4# 36# happyReduction_96 +happyReduction_96 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut82 happy_x_3 of { happy_var_3 -> + case happyOut122 happy_x_4 of { happy_var_4 -> + ( do { (cs,c,ts) <- checkInstHeader happy_var_3; + return (InstDecl happy_var_1 cs c ts happy_var_4) })}}} + ) (\r -> happyReturn (happyIn45 r)) + +happyReduce_97 = happyMonadReduce 4# 36# happyReduction_97 +happyReduction_97 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut82 happy_x_4 of { happy_var_4 -> + ( do { checkEnabled StandaloneDeriving ; + (cs, c, ts) <- checkInstHeader happy_var_4; + return (DerivDecl happy_var_1 cs c ts) })}} + ) (\r -> happyReturn (happyIn45 r)) + +happyReduce_98 = happyReduce 5# 36# happyReduction_98 +happyReduction_98 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut47 happy_x_4 of { happy_var_4 -> + happyIn45 + (DefaultDecl happy_var_1 happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_99 = happyReduce 4# 36# happyReduction_99 +happyReduction_99 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut134 happy_x_3 of { happy_var_3 -> + happyIn45 + (SpliceDecl happy_var_1 $ ParenSplice happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_100 = happyReduce 6# 36# happyReduction_100 +happyReduction_100 (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 happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut57 happy_x_4 of { happy_var_4 -> + case happyOut58 happy_x_5 of { happy_var_5 -> + case happyOut59 happy_x_6 of { happy_var_6 -> + happyIn45 + (let (s,n,t) = happy_var_6 in ForImp happy_var_1 happy_var_4 happy_var_5 s n t + ) `HappyStk` happyRest}}}} + +happyReduce_101 = happyReduce 5# 36# happyReduction_101 +happyReduction_101 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut57 happy_x_4 of { happy_var_4 -> + case happyOut59 happy_x_5 of { happy_var_5 -> + happyIn45 + (let (s,n,t) = happy_var_5 in ForExp happy_var_1 happy_var_4 s n t + ) `HappyStk` happyRest}}} + +happyReduce_102 = happyReduce 4# 36# happyReduction_102 +happyReduction_102 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut60 happy_x_3 of { happy_var_3 -> + happyIn45 + (RulePragmaDecl happy_var_1 $ reverse happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_103 = happyReduce 4# 36# happyReduction_103 +happyReduction_103 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut66 happy_x_3 of { happy_var_3 -> + happyIn45 + (DeprPragmaDecl happy_var_1 $ reverse happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_104 = happyReduce 4# 36# happyReduction_104 +happyReduction_104 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut66 happy_x_3 of { happy_var_3 -> + happyIn45 + (WarnPragmaDecl happy_var_1 $ reverse happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_105 = happySpecReduce_1 36# happyReduction_105 +happyReduction_105 happy_x_1 + = case happyOut50 happy_x_1 of { happy_var_1 -> + happyIn45 + (happy_var_1 + )} + +happyReduce_106 = happySpecReduce_1 37# happyReduction_106 +happyReduction_106 happy_x_1 + = happyIn46 + (DataType + ) + +happyReduce_107 = happySpecReduce_1 37# happyReduction_107 +happyReduction_107 happy_x_1 + = happyIn46 + (NewType + ) + +happyReduce_108 = happyMonadReduce 1# 38# happyReduction_108 +happyReduction_108 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut84 happy_x_1 of { happy_var_1 -> + ( do { ts <- mapM checkType happy_var_1; + return $ reverse ts })} + ) (\r -> happyReturn (happyIn47 r)) + +happyReduce_109 = happySpecReduce_1 38# happyReduction_109 +happyReduction_109 happy_x_1 + = case happyOut72 happy_x_1 of { happy_var_1 -> + happyIn47 + ([happy_var_1] + )} + +happyReduce_110 = happySpecReduce_0 38# happyReduction_110 +happyReduction_110 = happyIn47 + ([] + ) + +happyReduce_111 = happyMonadReduce 3# 39# happyReduction_111 +happyReduction_111 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut49 happy_x_2 of { happy_var_2 -> + ( checkRevDecls happy_var_2)} + ) (\r -> happyReturn (happyIn48 r)) + +happyReduce_112 = happySpecReduce_1 39# happyReduction_112 +happyReduction_112 happy_x_1 + = happyIn48 + ([] + ) + +happyReduce_113 = happySpecReduce_3 40# happyReduction_113 +happyReduction_113 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut49 happy_x_1 of { happy_var_1 -> + case happyOut50 happy_x_3 of { happy_var_3 -> + happyIn49 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_114 = happySpecReduce_1 40# happyReduction_114 +happyReduction_114 happy_x_1 + = case happyOut50 happy_x_1 of { happy_var_1 -> + happyIn49 + ([happy_var_1] + )} + +happyReduce_115 = happySpecReduce_1 41# happyReduction_115 +happyReduction_115 happy_x_1 + = case happyOut52 happy_x_1 of { happy_var_1 -> + happyIn50 + (happy_var_1 + )} + +happyReduce_116 = happySpecReduce_1 41# happyReduction_116 +happyReduction_116 happy_x_1 + = case happyOut39 happy_x_1 of { happy_var_1 -> + happyIn50 + (happy_var_1 + )} + +happyReduce_117 = happySpecReduce_1 41# happyReduction_117 +happyReduction_117 happy_x_1 + = case happyOut128 happy_x_1 of { happy_var_1 -> + happyIn50 + (happy_var_1 + )} + +happyReduce_118 = happySpecReduce_3 42# happyReduction_118 +happyReduction_118 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut48 happy_x_2 of { happy_var_2 -> + happyIn51 + (happy_var_2 + )} + +happyReduce_119 = happySpecReduce_3 42# happyReduction_119 +happyReduction_119 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut48 happy_x_2 of { happy_var_2 -> + happyIn51 + (happy_var_2 + )} + +happyReduce_120 = happyMonadReduce 4# 43# happyReduction_120 +happyReduction_120 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut138 happy_x_2 of { happy_var_2 -> + case happyOut81 happy_x_4 of { happy_var_4 -> + ( do { v <- checkSigVar happy_var_2; + return $ TypeSig happy_var_1 [v] happy_var_4 })}}} + ) (\r -> happyReturn (happyIn52 r)) + +happyReduce_121 = happyMonadReduce 6# 43# happyReduction_121 +happyReduction_121 (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 happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut138 happy_x_2 of { happy_var_2 -> + case happyOut56 happy_x_4 of { happy_var_4 -> + case happyOut81 happy_x_6 of { happy_var_6 -> + ( do { v <- checkSigVar happy_var_2; + return $ TypeSig happy_var_1 (v : reverse happy_var_4) happy_var_6 })}}}} + ) (\r -> happyReturn (happyIn52 r)) + +happyReduce_122 = happyReduce 5# 43# happyReduction_122 +happyReduction_122 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (INLINE happy_var_2) -> + case happyOut62 happy_x_3 of { happy_var_3 -> + case happyOut189 happy_x_4 of { happy_var_4 -> + happyIn52 + (InlineSig happy_var_1 happy_var_2 happy_var_3 happy_var_4 + ) `HappyStk` happyRest}}}} + +happyReduce_123 = happyReduce 6# 43# happyReduction_123 +happyReduction_123 (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 happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut189 happy_x_3 of { happy_var_3 -> + case happyOut53 happy_x_5 of { happy_var_5 -> + happyIn52 + (SpecSig happy_var_1 happy_var_3 happy_var_5 + ) `HappyStk` happyRest}}} + +happyReduce_124 = happyReduce 7# 43# happyReduction_124 +happyReduction_124 (happy_x_7 `HappyStk` + happy_x_6 `HappyStk` + happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (SPECIALISE_INLINE happy_var_2) -> + case happyOut62 happy_x_3 of { happy_var_3 -> + case happyOut189 happy_x_4 of { happy_var_4 -> + case happyOut53 happy_x_6 of { happy_var_6 -> + happyIn52 + (SpecInlineSig happy_var_1 happy_var_2 happy_var_3 happy_var_4 happy_var_6 + ) `HappyStk` happyRest}}}}} + +happyReduce_125 = happyMonadReduce 5# 43# happyReduction_125 +happyReduction_125 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut82 happy_x_4 of { happy_var_4 -> + ( do { (cs,c,ts) <- checkInstHeader happy_var_4; + return $ InstSig happy_var_1 cs c ts })}} + ) (\r -> happyReturn (happyIn52 r)) + +happyReduce_126 = happySpecReduce_1 44# happyReduction_126 +happyReduction_126 happy_x_1 + = case happyOut54 happy_x_1 of { happy_var_1 -> + happyIn53 + ([ happy_var_1 ] + )} + +happyReduce_127 = happySpecReduce_3 44# happyReduction_127 +happyReduction_127 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut54 happy_x_1 of { happy_var_1 -> + case happyOut53 happy_x_3 of { happy_var_3 -> + happyIn53 + (happy_var_1 : happy_var_3 + )}} + +happyReduce_128 = happyMonadReduce 1# 45# happyReduction_128 +happyReduction_128 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut82 happy_x_1 of { happy_var_1 -> + ( checkType $ mkTyForall Nothing [] happy_var_1)} + ) (\r -> happyReturn (happyIn54 r)) + +happyReduce_129 = happySpecReduce_1 46# happyReduction_129 +happyReduction_129 happy_x_1 + = case happyOut51 happy_x_1 of { happy_var_1 -> + happyIn55 + (BDecls happy_var_1 + )} + +happyReduce_130 = happySpecReduce_3 46# happyReduction_130 +happyReduction_130 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut183 happy_x_2 of { happy_var_2 -> + happyIn55 + (IPBinds happy_var_2 + )} + +happyReduce_131 = happySpecReduce_3 46# happyReduction_131 +happyReduction_131 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut183 happy_x_2 of { happy_var_2 -> + happyIn55 + (IPBinds happy_var_2 + )} + +happyReduce_132 = happySpecReduce_3 47# happyReduction_132 +happyReduction_132 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut56 happy_x_1 of { happy_var_1 -> + case happyOut187 happy_x_3 of { happy_var_3 -> + happyIn56 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_133 = happyMonadReduce 1# 47# happyReduction_133 +happyReduction_133 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut189 happy_x_1 of { happy_var_1 -> + ( do { n <- checkUnQual happy_var_1; + return [n] })} + ) (\r -> happyReturn (happyIn56 r)) + +happyReduce_134 = happySpecReduce_1 48# happyReduction_134 +happyReduction_134 happy_x_1 + = happyIn57 + (StdCall + ) + +happyReduce_135 = happySpecReduce_1 48# happyReduction_135 +happyReduction_135 happy_x_1 + = happyIn57 + (CCall + ) + +happyReduce_136 = happySpecReduce_1 49# happyReduction_136 +happyReduction_136 happy_x_1 + = happyIn58 + (PlaySafe False + ) + +happyReduce_137 = happySpecReduce_1 49# happyReduction_137 +happyReduction_137 happy_x_1 + = happyIn58 + (PlayRisky + ) + +happyReduce_138 = happySpecReduce_1 49# happyReduction_138 +happyReduction_138 happy_x_1 + = happyIn58 + (PlaySafe True + ) + +happyReduce_139 = happySpecReduce_0 49# happyReduction_139 +happyReduction_139 = happyIn58 + (PlaySafe False + ) + +happyReduce_140 = happyReduce 4# 50# happyReduction_140 +happyReduction_140 (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 happyOut188 happy_x_2 of { happy_var_2 -> + case happyOut70 happy_x_4 of { happy_var_4 -> + happyIn59 + ((happy_var_1, happy_var_2, happy_var_4) + ) `HappyStk` happyRest}}} + +happyReduce_141 = happySpecReduce_3 50# happyReduction_141 +happyReduction_141 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut188 happy_x_1 of { happy_var_1 -> + case happyOut70 happy_x_3 of { happy_var_3 -> + happyIn59 + (("", happy_var_1, happy_var_3) + )}} + +happyReduce_142 = happySpecReduce_3 51# happyReduction_142 +happyReduction_142 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut60 happy_x_1 of { happy_var_1 -> + case happyOut61 happy_x_3 of { happy_var_3 -> + happyIn60 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_143 = happySpecReduce_2 51# happyReduction_143 +happyReduction_143 happy_x_2 + happy_x_1 + = case happyOut60 happy_x_1 of { happy_var_1 -> + happyIn60 + (happy_var_1 + )} + +happyReduce_144 = happySpecReduce_1 51# happyReduction_144 +happyReduction_144 happy_x_1 + = case happyOut61 happy_x_1 of { happy_var_1 -> + happyIn60 + ([happy_var_1] + )} + +happyReduce_145 = happySpecReduce_0 51# happyReduction_145 +happyReduction_145 = happyIn60 + ([] + ) + +happyReduce_146 = happyMonadReduce 6# 52# happyReduction_146 +happyReduction_146 (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 happyOutTok happy_x_1 of { (StringTok happy_var_1) -> + case happyOut62 happy_x_2 of { happy_var_2 -> + case happyOut63 happy_x_3 of { happy_var_3 -> + case happyOut136 happy_x_4 of { happy_var_4 -> + case happyOut134 happy_x_6 of { happy_var_6 -> + ( do { e <- checkRuleExpr happy_var_4; + return $ Rule happy_var_1 happy_var_2 happy_var_3 e happy_var_6 })}}}}} + ) (\r -> happyReturn (happyIn61 r)) + +happyReduce_147 = happySpecReduce_0 53# happyReduction_147 +happyReduction_147 = happyIn62 + (AlwaysActive + ) + +happyReduce_148 = happySpecReduce_3 53# happyReduction_148 +happyReduction_148 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_2 of { (IntTok happy_var_2) -> + happyIn62 + (ActiveFrom (fromInteger happy_var_2) + )} + +happyReduce_149 = happyReduce 4# 53# happyReduction_149 +happyReduction_149 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOutTok happy_x_3 of { (IntTok happy_var_3) -> + happyIn62 + (ActiveUntil (fromInteger happy_var_3) + ) `HappyStk` happyRest} + +happyReduce_150 = happySpecReduce_0 54# happyReduction_150 +happyReduction_150 = happyIn63 + (Nothing + ) + +happyReduce_151 = happySpecReduce_3 54# happyReduction_151 +happyReduction_151 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut64 happy_x_2 of { happy_var_2 -> + happyIn63 + (Just happy_var_2 + )} + +happyReduce_152 = happySpecReduce_1 55# happyReduction_152 +happyReduction_152 happy_x_1 + = case happyOut65 happy_x_1 of { happy_var_1 -> + happyIn64 + ([happy_var_1] + )} + +happyReduce_153 = happySpecReduce_2 55# happyReduction_153 +happyReduction_153 happy_x_2 + happy_x_1 + = case happyOut65 happy_x_1 of { happy_var_1 -> + case happyOut64 happy_x_2 of { happy_var_2 -> + happyIn64 + (happy_var_1 : happy_var_2 + )}} + +happyReduce_154 = happySpecReduce_1 56# happyReduction_154 +happyReduction_154 happy_x_1 + = case happyOut204 happy_x_1 of { happy_var_1 -> + happyIn65 + (RuleVar happy_var_1 + )} + +happyReduce_155 = happyReduce 5# 56# happyReduction_155 +happyReduction_155 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut204 happy_x_2 of { happy_var_2 -> + case happyOut81 happy_x_4 of { happy_var_4 -> + happyIn65 + (TypedRuleVar happy_var_2 happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_156 = happySpecReduce_3 57# happyReduction_156 +happyReduction_156 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut66 happy_x_1 of { happy_var_1 -> + case happyOut67 happy_x_3 of { happy_var_3 -> + happyIn66 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_157 = happySpecReduce_2 57# happyReduction_157 +happyReduction_157 happy_x_2 + happy_x_1 + = case happyOut66 happy_x_1 of { happy_var_1 -> + happyIn66 + (happy_var_1 + )} + +happyReduce_158 = happySpecReduce_1 57# happyReduction_158 +happyReduction_158 happy_x_1 + = case happyOut67 happy_x_1 of { happy_var_1 -> + happyIn66 + ([happy_var_1] + )} + +happyReduce_159 = happySpecReduce_0 57# happyReduction_159 +happyReduction_159 = happyIn66 + ([] + ) + +happyReduce_160 = happySpecReduce_2 58# happyReduction_160 +happyReduction_160 happy_x_2 + happy_x_1 + = case happyOut68 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (StringTok happy_var_2) -> + happyIn67 + ((happy_var_1,happy_var_2) + )}} + +happyReduce_161 = happySpecReduce_1 59# happyReduction_161 +happyReduction_161 happy_x_1 + = case happyOut69 happy_x_1 of { happy_var_1 -> + happyIn68 + ([happy_var_1] + )} + +happyReduce_162 = happySpecReduce_3 59# happyReduction_162 +happyReduction_162 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut69 happy_x_1 of { happy_var_1 -> + case happyOut68 happy_x_3 of { happy_var_3 -> + happyIn68 + (happy_var_1 : happy_var_3 + )}} + +happyReduce_163 = happySpecReduce_1 60# happyReduction_163 +happyReduction_163 happy_x_1 + = case happyOut191 happy_x_1 of { happy_var_1 -> + happyIn69 + (happy_var_1 + )} + +happyReduce_164 = happySpecReduce_1 60# happyReduction_164 +happyReduction_164 happy_x_1 + = case happyOut187 happy_x_1 of { happy_var_1 -> + happyIn69 + (happy_var_1 + )} + +happyReduce_165 = happyMonadReduce 1# 61# happyReduction_165 +happyReduction_165 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut71 happy_x_1 of { happy_var_1 -> + ( checkType happy_var_1)} + ) (\r -> happyReturn (happyIn70 r)) + +happyReduce_166 = happySpecReduce_1 62# happyReduction_166 +happyReduction_166 happy_x_1 + = case happyOut75 happy_x_1 of { happy_var_1 -> + happyIn71 + (happy_var_1 + )} + +happyReduce_167 = happySpecReduce_3 62# happyReduction_167 +happyReduction_167 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut75 happy_x_1 of { happy_var_1 -> + case happyOut80 happy_x_2 of { happy_var_2 -> + case happyOut71 happy_x_3 of { happy_var_3 -> + happyIn71 + (TyInfix happy_var_1 happy_var_2 happy_var_3 + )}}} + +happyReduce_168 = happySpecReduce_3 62# happyReduction_168 +happyReduction_168 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut75 happy_x_1 of { happy_var_1 -> + case happyOut223 happy_x_2 of { happy_var_2 -> + case happyOut71 happy_x_3 of { happy_var_3 -> + happyIn71 + (TyInfix happy_var_1 happy_var_2 happy_var_3 + )}}} + +happyReduce_169 = happySpecReduce_3 62# happyReduction_169 +happyReduction_169 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut75 happy_x_1 of { happy_var_1 -> + case happyOut82 happy_x_3 of { happy_var_3 -> + happyIn71 + (TyFun happy_var_1 happy_var_3 + )}} + +happyReduce_170 = happyMonadReduce 3# 62# happyReduction_170 +happyReduction_170 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut75 happy_x_1 of { happy_var_1 -> + case happyOut75 happy_x_3 of { happy_var_3 -> + ( do { checkEnabled TypeFamilies ; + return $ TyPred $ EqualP happy_var_1 happy_var_3 })}} + ) (\r -> happyReturn (happyIn71 r)) + +happyReduce_171 = happyMonadReduce 1# 63# happyReduction_171 +happyReduction_171 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut73 happy_x_1 of { happy_var_1 -> + ( checkType happy_var_1)} + ) (\r -> happyReturn (happyIn72 r)) + +happyReduce_172 = happySpecReduce_3 64# happyReduction_172 +happyReduction_172 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut190 happy_x_1 of { happy_var_1 -> + case happyOut71 happy_x_3 of { happy_var_3 -> + happyIn73 + (TyPred $ IParam happy_var_1 happy_var_3 + )}} + +happyReduce_173 = happySpecReduce_1 64# happyReduction_173 +happyReduction_173 happy_x_1 + = case happyOut71 happy_x_1 of { happy_var_1 -> + happyIn73 + (happy_var_1 + )} + +happyReduce_174 = happyMonadReduce 1# 65# happyReduction_174 +happyReduction_174 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut75 happy_x_1 of { happy_var_1 -> + ( checkType happy_var_1)} + ) (\r -> happyReturn (happyIn74 r)) + +happyReduce_175 = happySpecReduce_2 66# happyReduction_175 +happyReduction_175 happy_x_2 + happy_x_1 + = case happyOut75 happy_x_1 of { happy_var_1 -> + case happyOut77 happy_x_2 of { happy_var_2 -> + happyIn75 + (TyApp happy_var_1 happy_var_2 + )}} + +happyReduce_176 = happySpecReduce_1 66# happyReduction_176 +happyReduction_176 happy_x_1 + = case happyOut77 happy_x_1 of { happy_var_1 -> + happyIn75 + (happy_var_1 + )} + +happyReduce_177 = happyMonadReduce 1# 67# happyReduction_177 +happyReduction_177 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut77 happy_x_1 of { happy_var_1 -> + ( checkType happy_var_1)} + ) (\r -> happyReturn (happyIn76 r)) + +happyReduce_178 = happySpecReduce_1 68# happyReduction_178 +happyReduction_178 happy_x_1 + = case happyOut78 happy_x_1 of { happy_var_1 -> + happyIn77 + (TyCon happy_var_1 + )} + +happyReduce_179 = happySpecReduce_1 68# happyReduction_179 +happyReduction_179 happy_x_1 + = case happyOut222 happy_x_1 of { happy_var_1 -> + happyIn77 + (TyVar happy_var_1 + )} + +happyReduce_180 = happySpecReduce_3 68# happyReduction_180 +happyReduction_180 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut84 happy_x_2 of { happy_var_2 -> + happyIn77 + (TyTuple Boxed (reverse happy_var_2) + )} + +happyReduce_181 = happySpecReduce_3 68# happyReduction_181 +happyReduction_181 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut85 happy_x_2 of { happy_var_2 -> + happyIn77 + (TyTuple Unboxed (reverse happy_var_2) + )} + +happyReduce_182 = happySpecReduce_3 68# happyReduction_182 +happyReduction_182 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut73 happy_x_2 of { happy_var_2 -> + happyIn77 + (TyApp (TyCon list_tycon_name) happy_var_2 + )} + +happyReduce_183 = happySpecReduce_3 68# happyReduction_183 +happyReduction_183 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut82 happy_x_2 of { happy_var_2 -> + happyIn77 + (TyParen happy_var_2 + )} + +happyReduce_184 = happyReduce 5# 68# happyReduction_184 +happyReduction_184 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut82 happy_x_2 of { happy_var_2 -> + case happyOut112 happy_x_4 of { happy_var_4 -> + happyIn77 + (TyKind happy_var_2 happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_185 = happySpecReduce_1 69# happyReduction_185 +happyReduction_185 happy_x_1 + = case happyOut79 happy_x_1 of { happy_var_1 -> + happyIn78 + (happy_var_1 + )} + +happyReduce_186 = happySpecReduce_2 69# happyReduction_186 +happyReduction_186 happy_x_2 + happy_x_1 + = happyIn78 + (unit_tycon_name + ) + +happyReduce_187 = happySpecReduce_3 69# happyReduction_187 +happyReduction_187 happy_x_3 + happy_x_2 + happy_x_1 + = happyIn78 + (fun_tycon_name + ) + +happyReduce_188 = happySpecReduce_2 69# happyReduction_188 +happyReduction_188 happy_x_2 + happy_x_1 + = happyIn78 + (list_tycon_name + ) + +happyReduce_189 = happySpecReduce_3 69# happyReduction_189 +happyReduction_189 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut148 happy_x_2 of { happy_var_2 -> + happyIn78 + (tuple_tycon_name Boxed happy_var_2 + )} + +happyReduce_190 = happySpecReduce_2 69# happyReduction_190 +happyReduction_190 happy_x_2 + happy_x_1 + = happyIn78 + (unboxed_singleton_tycon_name + ) + +happyReduce_191 = happySpecReduce_3 69# happyReduction_191 +happyReduction_191 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut148 happy_x_2 of { happy_var_2 -> + happyIn78 + (tuple_tycon_name Unboxed happy_var_2 + )} + +happyReduce_192 = happySpecReduce_1 70# happyReduction_192 +happyReduction_192 happy_x_1 + = case happyOut206 happy_x_1 of { happy_var_1 -> + happyIn79 + (happy_var_1 + )} + +happyReduce_193 = happySpecReduce_3 70# happyReduction_193 +happyReduction_193 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut201 happy_x_2 of { happy_var_2 -> + happyIn79 + (happy_var_2 + )} + +happyReduce_194 = happySpecReduce_1 71# happyReduction_194 +happyReduction_194 happy_x_1 + = case happyOut197 happy_x_1 of { happy_var_1 -> + happyIn80 + (happy_var_1 + )} + +happyReduce_195 = happyMonadReduce 1# 72# happyReduction_195 +happyReduction_195 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut82 happy_x_1 of { happy_var_1 -> + ( checkType happy_var_1)} + ) (\r -> happyReturn (happyIn81 r)) + +happyReduce_196 = happyReduce 4# 73# happyReduction_196 +happyReduction_196 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut86 happy_x_2 of { happy_var_2 -> + case happyOut82 happy_x_4 of { happy_var_4 -> + happyIn82 + (mkTyForall (Just happy_var_2) [] happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_197 = happySpecReduce_3 73# happyReduction_197 +happyReduction_197 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut83 happy_x_1 of { happy_var_1 -> + case happyOut73 happy_x_3 of { happy_var_3 -> + happyIn82 + (mkTyForall Nothing happy_var_1 happy_var_3 + )}} + +happyReduce_198 = happySpecReduce_1 73# happyReduction_198 +happyReduction_198 happy_x_1 + = case happyOut73 happy_x_1 of { happy_var_1 -> + happyIn82 + (happy_var_1 + )} + +happyReduce_199 = happyMonadReduce 1# 74# happyReduction_199 +happyReduction_199 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut75 happy_x_1 of { happy_var_1 -> + ( checkPContext happy_var_1)} + ) (\r -> happyReturn (happyIn83 r)) + +happyReduce_200 = happyMonadReduce 3# 74# happyReduction_200 +happyReduction_200 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut75 happy_x_1 of { happy_var_1 -> + case happyOut75 happy_x_3 of { happy_var_3 -> + ( checkEnabled TypeFamilies >> checkPContext (TyPred $ EqualP happy_var_1 happy_var_3))}} + ) (\r -> happyReturn (happyIn83 r)) + +happyReduce_201 = happySpecReduce_3 75# happyReduction_201 +happyReduction_201 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut85 happy_x_1 of { happy_var_1 -> + case happyOut73 happy_x_3 of { happy_var_3 -> + happyIn84 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_202 = happySpecReduce_1 76# happyReduction_202 +happyReduction_202 happy_x_1 + = case happyOut73 happy_x_1 of { happy_var_1 -> + happyIn85 + ([happy_var_1] + )} + +happyReduce_203 = happySpecReduce_3 76# happyReduction_203 +happyReduction_203 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut85 happy_x_1 of { happy_var_1 -> + case happyOut73 happy_x_3 of { happy_var_3 -> + happyIn85 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_204 = happySpecReduce_2 77# happyReduction_204 +happyReduction_204 happy_x_2 + happy_x_1 + = case happyOut86 happy_x_1 of { happy_var_1 -> + case happyOut87 happy_x_2 of { happy_var_2 -> + happyIn86 + (happy_var_2 : happy_var_1 + )}} + +happyReduce_205 = happySpecReduce_0 77# happyReduction_205 +happyReduction_205 = happyIn86 + ([] + ) + +happyReduce_206 = happySpecReduce_1 78# happyReduction_206 +happyReduction_206 happy_x_1 + = case happyOut222 happy_x_1 of { happy_var_1 -> + happyIn87 + (UnkindedVar happy_var_1 + )} + +happyReduce_207 = happyReduce 5# 78# happyReduction_207 +happyReduction_207 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut222 happy_x_2 of { happy_var_2 -> + case happyOut112 happy_x_4 of { happy_var_4 -> + happyIn87 + (KindedVar happy_var_2 happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_208 = happySpecReduce_2 79# happyReduction_208 +happyReduction_208 happy_x_2 + happy_x_1 + = case happyOut88 happy_x_1 of { happy_var_1 -> + case happyOut222 happy_x_2 of { happy_var_2 -> + happyIn88 + (happy_var_2 : happy_var_1 + )}} + +happyReduce_209 = happySpecReduce_0 79# happyReduction_209 +happyReduction_209 = happyIn88 + ([] + ) + +happyReduce_210 = happySpecReduce_0 80# happyReduction_210 +happyReduction_210 = happyIn89 + ([] + ) + +happyReduce_211 = happyMonadReduce 2# 80# happyReduction_211 +happyReduction_211 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut90 happy_x_2 of { happy_var_2 -> + ( checkEnabled FunctionalDependencies >> return (reverse happy_var_2))} + ) (\r -> happyReturn (happyIn89 r)) + +happyReduce_212 = happySpecReduce_3 81# happyReduction_212 +happyReduction_212 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut90 happy_x_1 of { happy_var_1 -> + case happyOut91 happy_x_3 of { happy_var_3 -> + happyIn90 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_213 = happySpecReduce_1 81# happyReduction_213 +happyReduction_213 happy_x_1 + = case happyOut91 happy_x_1 of { happy_var_1 -> + happyIn90 + ([happy_var_1] + )} + +happyReduce_214 = happySpecReduce_3 82# happyReduction_214 +happyReduction_214 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut88 happy_x_1 of { happy_var_1 -> + case happyOut88 happy_x_3 of { happy_var_3 -> + happyIn91 + (FunDep (reverse happy_var_1) (reverse happy_var_3) + )}} + +happyReduce_215 = happyMonadReduce 1# 83# happyReduction_215 +happyReduction_215 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut93 happy_x_1 of { happy_var_1 -> + ( checkEnabled GADTs >> return happy_var_1)} + ) (\r -> happyReturn (happyIn92 r)) + +happyReduce_216 = happySpecReduce_3 84# happyReduction_216 +happyReduction_216 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut94 happy_x_2 of { happy_var_2 -> + happyIn93 + (happy_var_2 + )} + +happyReduce_217 = happySpecReduce_3 84# happyReduction_217 +happyReduction_217 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut94 happy_x_2 of { happy_var_2 -> + happyIn93 + (happy_var_2 + )} + +happyReduce_218 = happySpecReduce_3 85# happyReduction_218 +happyReduction_218 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut95 happy_x_2 of { happy_var_2 -> + happyIn94 + (happy_var_2 + )} + +happyReduce_219 = happySpecReduce_3 86# happyReduction_219 +happyReduction_219 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut95 happy_x_1 of { happy_var_1 -> + case happyOut96 happy_x_3 of { happy_var_3 -> + happyIn95 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_220 = happySpecReduce_1 86# happyReduction_220 +happyReduction_220 happy_x_1 + = case happyOut96 happy_x_1 of { happy_var_1 -> + happyIn95 + ([happy_var_1] + )} + +happyReduce_221 = happyMonadReduce 4# 87# happyReduction_221 +happyReduction_221 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut192 happy_x_2 of { happy_var_2 -> + case happyOut81 happy_x_4 of { happy_var_4 -> + ( do { c <- checkUnQual happy_var_2; + return $ GadtDecl happy_var_1 c happy_var_4 })}}} + ) (\r -> happyReturn (happyIn96 r)) + +happyReduce_222 = happyMonadReduce 0# 88# happyReduction_222 +happyReduction_222 (happyRest) tk + = happyThen (( checkEnabled EmptyDataDecls >> return []) + ) (\r -> happyReturn (happyIn97 r)) + +happyReduce_223 = happySpecReduce_2 88# happyReduction_223 +happyReduction_223 happy_x_2 + happy_x_1 + = case happyOut98 happy_x_2 of { happy_var_2 -> + happyIn97 + (happy_var_2 + )} + +happyReduce_224 = happySpecReduce_3 89# happyReduction_224 +happyReduction_224 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut98 happy_x_1 of { happy_var_1 -> + case happyOut99 happy_x_3 of { happy_var_3 -> + happyIn98 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_225 = happySpecReduce_1 89# happyReduction_225 +happyReduction_225 happy_x_1 + = case happyOut99 happy_x_1 of { happy_var_1 -> + happyIn98 + ([happy_var_1] + )} + +happyReduce_226 = happyMonadReduce 5# 90# happyReduction_226 +happyReduction_226 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut100 happy_x_2 of { happy_var_2 -> + case happyOut83 happy_x_3 of { happy_var_3 -> + case happyOut101 happy_x_5 of { happy_var_5 -> + ( do { checkEnabled ExistentialQuantification ; + ctxt <- checkContext happy_var_3 ; + return $ QualConDecl happy_var_1 happy_var_2 ctxt happy_var_5 })}}}} + ) (\r -> happyReturn (happyIn99 r)) + +happyReduce_227 = happySpecReduce_3 90# happyReduction_227 +happyReduction_227 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut100 happy_x_2 of { happy_var_2 -> + case happyOut101 happy_x_3 of { happy_var_3 -> + happyIn99 + (QualConDecl happy_var_1 happy_var_2 [] happy_var_3 + )}}} + +happyReduce_228 = happyMonadReduce 3# 91# happyReduction_228 +happyReduction_228 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut86 happy_x_2 of { happy_var_2 -> + ( checkEnabled ExistentialQuantification >> return happy_var_2)} + ) (\r -> happyReturn (happyIn100 r)) + +happyReduce_229 = happySpecReduce_0 91# happyReduction_229 +happyReduction_229 = happyIn100 + ([] + ) + +happyReduce_230 = happySpecReduce_1 92# happyReduction_230 +happyReduction_230 happy_x_1 + = case happyOut102 happy_x_1 of { happy_var_1 -> + happyIn101 + (ConDecl (fst happy_var_1) (snd happy_var_1) + )} + +happyReduce_231 = happySpecReduce_3 92# happyReduction_231 +happyReduction_231 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut105 happy_x_1 of { happy_var_1 -> + case happyOut196 happy_x_2 of { happy_var_2 -> + case happyOut105 happy_x_3 of { happy_var_3 -> + happyIn101 + (InfixConDecl happy_var_1 happy_var_2 happy_var_3 + )}}} + +happyReduce_232 = happyMonadReduce 3# 92# happyReduction_232 +happyReduction_232 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut192 happy_x_1 of { happy_var_1 -> + ( do { c <- checkUnQual happy_var_1; return $ RecDecl c [] })} + ) (\r -> happyReturn (happyIn101 r)) + +happyReduce_233 = happyMonadReduce 4# 92# happyReduction_233 +happyReduction_233 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut192 happy_x_1 of { happy_var_1 -> + case happyOut106 happy_x_3 of { happy_var_3 -> + ( do { c <- checkUnQual happy_var_1; return $ RecDecl c (reverse happy_var_3) })}} + ) (\r -> happyReturn (happyIn101 r)) + +happyReduce_234 = happyMonadReduce 1# 93# happyReduction_234 +happyReduction_234 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut75 happy_x_1 of { happy_var_1 -> + ( do { (c,ts) <- splitTyConApp happy_var_1; + return (c,map UnBangedTy ts) })} + ) (\r -> happyReturn (happyIn102 r)) + +happyReduce_235 = happySpecReduce_1 93# happyReduction_235 +happyReduction_235 happy_x_1 + = case happyOut103 happy_x_1 of { happy_var_1 -> + happyIn102 + (happy_var_1 + )} + +happyReduce_236 = happyMonadReduce 3# 94# happyReduction_236 +happyReduction_236 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut75 happy_x_1 of { happy_var_1 -> + case happyOut76 happy_x_3 of { happy_var_3 -> + ( do { (c,ts) <- splitTyConApp happy_var_1; + return (c,map UnBangedTy ts++ + [BangedTy happy_var_3]) })}} + ) (\r -> happyReturn (happyIn103 r)) + +happyReduce_237 = happyMonadReduce 5# 94# happyReduction_237 +happyReduction_237 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut75 happy_x_1 of { happy_var_1 -> + case happyOut76 happy_x_5 of { happy_var_5 -> + ( do { (c,ts) <- splitTyConApp happy_var_1; + return (c,map UnBangedTy ts++ + [UnpackedTy happy_var_5]) })}} + ) (\r -> happyReturn (happyIn103 r)) + +happyReduce_238 = happySpecReduce_2 94# happyReduction_238 +happyReduction_238 happy_x_2 + happy_x_1 + = case happyOut103 happy_x_1 of { happy_var_1 -> + case happyOut104 happy_x_2 of { happy_var_2 -> + happyIn103 + ((fst happy_var_1, snd happy_var_1 ++ [happy_var_2] ) + )}} + +happyReduce_239 = happySpecReduce_1 95# happyReduction_239 +happyReduction_239 happy_x_1 + = case happyOut76 happy_x_1 of { happy_var_1 -> + happyIn104 + (UnBangedTy happy_var_1 + )} + +happyReduce_240 = happySpecReduce_2 95# happyReduction_240 +happyReduction_240 happy_x_2 + happy_x_1 + = case happyOut76 happy_x_2 of { happy_var_2 -> + happyIn104 + (BangedTy happy_var_2 + )} + +happyReduce_241 = happyReduce 4# 95# happyReduction_241 +happyReduction_241 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut76 happy_x_4 of { happy_var_4 -> + happyIn104 + (UnpackedTy happy_var_4 + ) `HappyStk` happyRest} + +happyReduce_242 = happySpecReduce_1 96# happyReduction_242 +happyReduction_242 happy_x_1 + = case happyOut74 happy_x_1 of { happy_var_1 -> + happyIn105 + (UnBangedTy happy_var_1 + )} + +happyReduce_243 = happySpecReduce_2 96# happyReduction_243 +happyReduction_243 happy_x_2 + happy_x_1 + = case happyOut76 happy_x_2 of { happy_var_2 -> + happyIn105 + (BangedTy happy_var_2 + )} + +happyReduce_244 = happyReduce 4# 96# happyReduction_244 +happyReduction_244 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut76 happy_x_4 of { happy_var_4 -> + happyIn105 + (UnpackedTy happy_var_4 + ) `HappyStk` happyRest} + +happyReduce_245 = happySpecReduce_3 97# happyReduction_245 +happyReduction_245 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut106 happy_x_1 of { happy_var_1 -> + case happyOut107 happy_x_3 of { happy_var_3 -> + happyIn106 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_246 = happySpecReduce_1 97# happyReduction_246 +happyReduction_246 happy_x_1 + = case happyOut107 happy_x_1 of { happy_var_1 -> + happyIn106 + ([happy_var_1] + )} + +happyReduce_247 = happySpecReduce_3 98# happyReduction_247 +happyReduction_247 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut56 happy_x_1 of { happy_var_1 -> + case happyOut108 happy_x_3 of { happy_var_3 -> + happyIn107 + ((reverse happy_var_1, happy_var_3) + )}} + +happyReduce_248 = happySpecReduce_1 99# happyReduction_248 +happyReduction_248 happy_x_1 + = case happyOut81 happy_x_1 of { happy_var_1 -> + happyIn108 + (UnBangedTy happy_var_1 + )} + +happyReduce_249 = happySpecReduce_2 99# happyReduction_249 +happyReduction_249 happy_x_2 + happy_x_1 + = case happyOut76 happy_x_2 of { happy_var_2 -> + happyIn108 + (BangedTy happy_var_2 + )} + +happyReduce_250 = happyReduce 4# 99# happyReduction_250 +happyReduction_250 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut76 happy_x_4 of { happy_var_4 -> + happyIn108 + (UnpackedTy happy_var_4 + ) `HappyStk` happyRest} + +happyReduce_251 = happySpecReduce_0 100# happyReduction_251 +happyReduction_251 = happyIn109 + ([] + ) + +happyReduce_252 = happySpecReduce_2 100# happyReduction_252 +happyReduction_252 happy_x_2 + happy_x_1 + = case happyOut111 happy_x_2 of { happy_var_2 -> + happyIn109 + ([(happy_var_2, [])] + )} + +happyReduce_253 = happySpecReduce_3 100# happyReduction_253 +happyReduction_253 happy_x_3 + happy_x_2 + happy_x_1 + = happyIn109 + ([] + ) + +happyReduce_254 = happyReduce 4# 100# happyReduction_254 +happyReduction_254 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut110 happy_x_3 of { happy_var_3 -> + happyIn109 + (reverse happy_var_3 + ) `HappyStk` happyRest} + +happyReduce_255 = happyMonadReduce 1# 101# happyReduction_255 +happyReduction_255 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut85 happy_x_1 of { happy_var_1 -> + ( checkDeriving happy_var_1)} + ) (\r -> happyReturn (happyIn110 r)) + +happyReduce_256 = happySpecReduce_1 102# happyReduction_256 +happyReduction_256 happy_x_1 + = case happyOut206 happy_x_1 of { happy_var_1 -> + happyIn111 + (happy_var_1 + )} + +happyReduce_257 = happyMonadReduce 1# 103# happyReduction_257 +happyReduction_257 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut113 happy_x_1 of { happy_var_1 -> + ( checkEnabled KindSignatures >> return happy_var_1)} + ) (\r -> happyReturn (happyIn112 r)) + +happyReduce_258 = happySpecReduce_1 104# happyReduction_258 +happyReduction_258 happy_x_1 + = case happyOut114 happy_x_1 of { happy_var_1 -> + happyIn113 + (happy_var_1 + )} + +happyReduce_259 = happySpecReduce_3 104# happyReduction_259 +happyReduction_259 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut114 happy_x_1 of { happy_var_1 -> + case happyOut113 happy_x_3 of { happy_var_3 -> + happyIn113 + (KindFn happy_var_1 happy_var_3 + )}} + +happyReduce_260 = happySpecReduce_1 105# happyReduction_260 +happyReduction_260 happy_x_1 + = happyIn114 + (KindStar + ) + +happyReduce_261 = happySpecReduce_1 105# happyReduction_261 +happyReduction_261 happy_x_1 + = happyIn114 + (KindBang + ) + +happyReduce_262 = happySpecReduce_3 105# happyReduction_262 +happyReduction_262 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut113 happy_x_2 of { happy_var_2 -> + happyIn114 + (happy_var_2 + )} + +happyReduce_263 = happySpecReduce_0 106# happyReduction_263 +happyReduction_263 = happyIn115 + (Nothing + ) + +happyReduce_264 = happySpecReduce_2 106# happyReduction_264 +happyReduction_264 happy_x_2 + happy_x_1 + = case happyOut112 happy_x_2 of { happy_var_2 -> + happyIn115 + (Just happy_var_2 + )} + +happyReduce_265 = happyMonadReduce 2# 107# happyReduction_265 +happyReduction_265 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut117 happy_x_2 of { happy_var_2 -> + ( checkClassBody happy_var_2)} + ) (\r -> happyReturn (happyIn116 r)) + +happyReduce_266 = happySpecReduce_0 107# happyReduction_266 +happyReduction_266 = happyIn116 + ([] + ) + +happyReduce_267 = happySpecReduce_3 108# happyReduction_267 +happyReduction_267 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut118 happy_x_2 of { happy_var_2 -> + happyIn117 + (happy_var_2 + )} + +happyReduce_268 = happySpecReduce_3 108# happyReduction_268 +happyReduction_268 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut118 happy_x_2 of { happy_var_2 -> + happyIn117 + (happy_var_2 + )} + +happyReduce_269 = happyMonadReduce 3# 109# happyReduction_269 +happyReduction_269 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut119 happy_x_2 of { happy_var_2 -> + ( checkRevClsDecls happy_var_2)} + ) (\r -> happyReturn (happyIn118 r)) + +happyReduce_270 = happySpecReduce_1 109# happyReduction_270 +happyReduction_270 happy_x_1 + = happyIn118 + ([] + ) + +happyReduce_271 = happySpecReduce_3 110# happyReduction_271 +happyReduction_271 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut119 happy_x_1 of { happy_var_1 -> + case happyOut120 happy_x_3 of { happy_var_3 -> + happyIn119 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_272 = happySpecReduce_1 110# happyReduction_272 +happyReduction_272 happy_x_1 + = case happyOut120 happy_x_1 of { happy_var_1 -> + happyIn119 + ([happy_var_1] + )} + +happyReduce_273 = happySpecReduce_1 111# happyReduction_273 +happyReduction_273 happy_x_1 + = case happyOut50 happy_x_1 of { happy_var_1 -> + happyIn120 + (ClsDecl happy_var_1 + )} + +happyReduce_274 = happyMonadReduce 1# 111# happyReduction_274 +happyReduction_274 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut121 happy_x_1 of { happy_var_1 -> + ( checkEnabled TypeFamilies >> return happy_var_1)} + ) (\r -> happyReturn (happyIn120 r)) + +happyReduce_275 = happyMonadReduce 4# 112# happyReduction_275 +happyReduction_275 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut73 happy_x_3 of { happy_var_3 -> + case happyOut115 happy_x_4 of { happy_var_4 -> + ( do { (c,ts) <- checkSimpleType happy_var_3; + return (ClsTyFam happy_var_1 c ts happy_var_4) })}}} + ) (\r -> happyReturn (happyIn121 r)) + +happyReduce_276 = happyReduce 5# 112# happyReduction_276 +happyReduction_276 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut70 happy_x_3 of { happy_var_3 -> + case happyOut81 happy_x_5 of { happy_var_5 -> + happyIn121 + (ClsTyDef happy_var_1 happy_var_3 happy_var_5 + ) `HappyStk` happyRest}}} + +happyReduce_277 = happyMonadReduce 4# 112# happyReduction_277 +happyReduction_277 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut82 happy_x_3 of { happy_var_3 -> + case happyOut115 happy_x_4 of { happy_var_4 -> + ( do { (cs,c,t) <- checkDataHeader happy_var_3; + return (ClsDataFam happy_var_1 cs c t happy_var_4) })}}} + ) (\r -> happyReturn (happyIn121 r)) + +happyReduce_278 = happyMonadReduce 4# 113# happyReduction_278 +happyReduction_278 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut123 happy_x_3 of { happy_var_3 -> + ( checkInstBody happy_var_3)} + ) (\r -> happyReturn (happyIn122 r)) + +happyReduce_279 = happyMonadReduce 4# 113# happyReduction_279 +happyReduction_279 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut123 happy_x_3 of { happy_var_3 -> + ( checkInstBody happy_var_3)} + ) (\r -> happyReturn (happyIn122 r)) + +happyReduce_280 = happySpecReduce_0 113# happyReduction_280 +happyReduction_280 = happyIn122 + ([] + ) + +happyReduce_281 = happyMonadReduce 3# 114# happyReduction_281 +happyReduction_281 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut124 happy_x_2 of { happy_var_2 -> + ( checkRevInstDecls happy_var_2)} + ) (\r -> happyReturn (happyIn123 r)) + +happyReduce_282 = happySpecReduce_1 114# happyReduction_282 +happyReduction_282 happy_x_1 + = happyIn123 + ([] + ) + +happyReduce_283 = happySpecReduce_3 115# happyReduction_283 +happyReduction_283 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut124 happy_x_1 of { happy_var_1 -> + case happyOut125 happy_x_3 of { happy_var_3 -> + happyIn124 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_284 = happySpecReduce_1 115# happyReduction_284 +happyReduction_284 happy_x_1 + = case happyOut125 happy_x_1 of { happy_var_1 -> + happyIn124 + ([happy_var_1] + )} + +happyReduce_285 = happySpecReduce_1 116# happyReduction_285 +happyReduction_285 happy_x_1 + = case happyOut128 happy_x_1 of { happy_var_1 -> + happyIn125 + (InsDecl happy_var_1 + )} + +happyReduce_286 = happyMonadReduce 1# 116# happyReduction_286 +happyReduction_286 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut127 happy_x_1 of { happy_var_1 -> + ( checkEnabled TypeFamilies >> return happy_var_1)} + ) (\r -> happyReturn (happyIn125 r)) + +happyReduce_287 = happySpecReduce_1 116# happyReduction_287 +happyReduction_287 happy_x_1 + = case happyOut126 happy_x_1 of { happy_var_1 -> + happyIn125 + (happy_var_1 + )} + +happyReduce_288 = happyReduce 5# 117# happyReduction_288 +happyReduction_288 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOutTok happy_x_2 of { (INLINE happy_var_2) -> + case happyOut62 happy_x_3 of { happy_var_3 -> + case happyOut189 happy_x_4 of { happy_var_4 -> + happyIn126 + (InsInline happy_var_1 happy_var_2 happy_var_3 happy_var_4 + ) `HappyStk` happyRest}}}} + +happyReduce_289 = happyMonadReduce 5# 118# happyReduction_289 +happyReduction_289 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut70 happy_x_3 of { happy_var_3 -> + case happyOutTok happy_x_4 of { happy_var_4 -> + case happyOut81 happy_x_5 of { happy_var_5 -> + ( do { -- no checkSimpleType happy_var_4 since dtype may contain type patterns + return (InsType happy_var_1 happy_var_3 happy_var_5) })}}}} + ) (\r -> happyReturn (happyIn127 r)) + +happyReduce_290 = happyMonadReduce 5# 118# happyReduction_290 +happyReduction_290 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut46 happy_x_2 of { happy_var_2 -> + case happyOut81 happy_x_3 of { happy_var_3 -> + case happyOut97 happy_x_4 of { happy_var_4 -> + case happyOut109 happy_x_5 of { happy_var_5 -> + ( do { -- (cs,c,t) <- checkDataHeader happy_var_4; + checkDataOrNew happy_var_2 happy_var_4; + return (InsData happy_var_1 happy_var_2 happy_var_3 (reverse happy_var_4) happy_var_5) })}}}}} + ) (\r -> happyReturn (happyIn127 r)) + +happyReduce_291 = happyMonadReduce 7# 118# happyReduction_291 +happyReduction_291 (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 happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut46 happy_x_2 of { happy_var_2 -> + case happyOut81 happy_x_3 of { happy_var_3 -> + case happyOut115 happy_x_4 of { happy_var_4 -> + case happyOut92 happy_x_6 of { happy_var_6 -> + case happyOut109 happy_x_7 of { happy_var_7 -> + ( do { -- (cs,c,t) <- checkDataHeader happy_var_4; + checkDataOrNew happy_var_2 happy_var_6; + return (InsGData happy_var_1 happy_var_2 happy_var_3 happy_var_4 (reverse happy_var_6) happy_var_7) })}}}}}} + ) (\r -> happyReturn (happyIn127 r)) + +happyReduce_292 = happyMonadReduce 5# 119# 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) tk + = happyThen (case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut138 happy_x_2 of { happy_var_2 -> + case happyOut130 happy_x_3 of { happy_var_3 -> + case happyOut131 happy_x_4 of { happy_var_4 -> + case happyOut129 happy_x_5 of { happy_var_5 -> + ( checkValDef happy_var_1 happy_var_2 happy_var_3 happy_var_4 happy_var_5)}}}}} + ) (\r -> happyReturn (happyIn128 r)) + +happyReduce_293 = happyMonadReduce 5# 119# happyReduction_293 +happyReduction_293 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut145 happy_x_3 of { happy_var_3 -> + case happyOut131 happy_x_4 of { happy_var_4 -> + case happyOut129 happy_x_5 of { happy_var_5 -> + ( do { checkEnabled BangPatterns ; + p <- checkPattern happy_var_3; + return $ PatBind happy_var_1 p Nothing happy_var_4 happy_var_5 })}}}} + ) (\r -> happyReturn (happyIn128 r)) + +happyReduce_294 = happySpecReduce_2 120# happyReduction_294 +happyReduction_294 happy_x_2 + happy_x_1 + = case happyOut55 happy_x_2 of { happy_var_2 -> + happyIn129 + (happy_var_2 + )} + +happyReduce_295 = happySpecReduce_0 120# happyReduction_295 +happyReduction_295 = happyIn129 + (BDecls [] + ) + +happyReduce_296 = happyMonadReduce 2# 121# happyReduction_296 +happyReduction_296 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut81 happy_x_2 of { happy_var_2 -> + ( checkEnabled ScopedTypeVariables >> return (Just happy_var_2))} + ) (\r -> happyReturn (happyIn130 r)) + +happyReduce_297 = happySpecReduce_0 121# happyReduction_297 +happyReduction_297 = happyIn130 + (Nothing + ) + +happyReduce_298 = happySpecReduce_2 122# happyReduction_298 +happyReduction_298 happy_x_2 + happy_x_1 + = case happyOut134 happy_x_2 of { happy_var_2 -> + happyIn131 + (UnGuardedRhs happy_var_2 + )} + +happyReduce_299 = happySpecReduce_1 122# happyReduction_299 +happyReduction_299 happy_x_1 + = case happyOut132 happy_x_1 of { happy_var_1 -> + happyIn131 + (GuardedRhss (reverse happy_var_1) + )} + +happyReduce_300 = happySpecReduce_2 123# happyReduction_300 +happyReduction_300 happy_x_2 + happy_x_1 + = case happyOut132 happy_x_1 of { happy_var_1 -> + case happyOut133 happy_x_2 of { happy_var_2 -> + happyIn132 + (happy_var_2 : happy_var_1 + )}} + +happyReduce_301 = happySpecReduce_1 123# happyReduction_301 +happyReduction_301 happy_x_1 + = case happyOut133 happy_x_1 of { happy_var_1 -> + happyIn132 + ([happy_var_1] + )} + +happyReduce_302 = happyMonadReduce 5# 124# happyReduction_302 +happyReduction_302 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut169 happy_x_3 of { happy_var_3 -> + case happyOut134 happy_x_5 of { happy_var_5 -> + ( checkPatternGuards happy_var_3 >> return (GuardedRhs happy_var_1 (reverse happy_var_3) happy_var_5))}}} + ) (\r -> happyReturn (happyIn133 r)) + +happyReduce_303 = happyMonadReduce 1# 125# happyReduction_303 +happyReduction_303 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut135 happy_x_1 of { happy_var_1 -> + ( checkExpr happy_var_1)} + ) (\r -> happyReturn (happyIn134 r)) + +happyReduce_304 = happyReduce 4# 126# happyReduction_304 +happyReduction_304 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut138 happy_x_1 of { happy_var_1 -> + case happyOut216 happy_x_3 of { happy_var_3 -> + case happyOut81 happy_x_4 of { happy_var_4 -> + happyIn135 + (ExpTypeSig happy_var_3 happy_var_1 happy_var_4 + ) `HappyStk` happyRest}}} + +happyReduce_305 = happySpecReduce_1 126# happyReduction_305 +happyReduction_305 happy_x_1 + = case happyOut136 happy_x_1 of { happy_var_1 -> + happyIn135 + (happy_var_1 + )} + +happyReduce_306 = happySpecReduce_2 126# happyReduction_306 +happyReduction_306 happy_x_2 + happy_x_1 + = case happyOut138 happy_x_1 of { happy_var_1 -> + case happyOut199 happy_x_2 of { happy_var_2 -> + happyIn135 + (PostOp happy_var_1 happy_var_2 + )}} + +happyReduce_307 = happySpecReduce_3 126# happyReduction_307 +happyReduction_307 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut138 happy_x_1 of { happy_var_1 -> + case happyOut135 happy_x_3 of { happy_var_3 -> + happyIn135 + (LeftArrApp happy_var_1 happy_var_3 + )}} + +happyReduce_308 = happySpecReduce_3 126# happyReduction_308 +happyReduction_308 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut138 happy_x_1 of { happy_var_1 -> + case happyOut135 happy_x_3 of { happy_var_3 -> + happyIn135 + (RightArrApp happy_var_1 happy_var_3 + )}} + +happyReduce_309 = happySpecReduce_3 126# happyReduction_309 +happyReduction_309 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut138 happy_x_1 of { happy_var_1 -> + case happyOut135 happy_x_3 of { happy_var_3 -> + happyIn135 + (LeftArrHighApp happy_var_1 happy_var_3 + )}} + +happyReduce_310 = happySpecReduce_3 126# happyReduction_310 +happyReduction_310 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut138 happy_x_1 of { happy_var_1 -> + case happyOut135 happy_x_3 of { happy_var_3 -> + happyIn135 + (RightArrHighApp happy_var_1 happy_var_3 + )}} + +happyReduce_311 = happySpecReduce_1 127# happyReduction_311 +happyReduction_311 happy_x_1 + = case happyOut137 happy_x_1 of { happy_var_1 -> + happyIn136 + (happy_var_1 + )} + +happyReduce_312 = happySpecReduce_1 127# happyReduction_312 +happyReduction_312 happy_x_1 + = case happyOut138 happy_x_1 of { happy_var_1 -> + happyIn136 + (happy_var_1 + )} + +happyReduce_313 = happySpecReduce_3 128# happyReduction_313 +happyReduction_313 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut138 happy_x_1 of { happy_var_1 -> + case happyOut199 happy_x_2 of { happy_var_2 -> + case happyOut139 happy_x_3 of { happy_var_3 -> + happyIn137 + (InfixApp happy_var_1 happy_var_2 happy_var_3 + )}}} + +happyReduce_314 = happySpecReduce_1 128# happyReduction_314 +happyReduction_314 happy_x_1 + = case happyOut139 happy_x_1 of { happy_var_1 -> + happyIn137 + (happy_var_1 + )} + +happyReduce_315 = happySpecReduce_3 129# happyReduction_315 +happyReduction_315 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut138 happy_x_1 of { happy_var_1 -> + case happyOut199 happy_x_2 of { happy_var_2 -> + case happyOut140 happy_x_3 of { happy_var_3 -> + happyIn138 + (InfixApp happy_var_1 happy_var_2 happy_var_3 + )}}} + +happyReduce_316 = happySpecReduce_1 129# happyReduction_316 +happyReduction_316 happy_x_1 + = case happyOut162 happy_x_1 of { happy_var_1 -> + happyIn138 + (happy_var_1 + )} + +happyReduce_317 = happySpecReduce_1 129# happyReduction_317 +happyReduction_317 happy_x_1 + = case happyOut140 happy_x_1 of { happy_var_1 -> + happyIn138 + (happy_var_1 + )} + +happyReduce_318 = happyReduce 5# 130# happyReduction_318 +happyReduction_318 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut216 happy_x_2 of { happy_var_2 -> + case happyOut143 happy_x_3 of { happy_var_3 -> + case happyOut135 happy_x_5 of { happy_var_5 -> + happyIn139 + (Lambda happy_var_2 (reverse happy_var_3) happy_var_5 + ) `HappyStk` happyRest}}} + +happyReduce_319 = happyReduce 4# 130# happyReduction_319 +happyReduction_319 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut55 happy_x_2 of { happy_var_2 -> + case happyOut135 happy_x_4 of { happy_var_4 -> + happyIn139 + (Let happy_var_2 happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_320 = happyReduce 6# 130# happyReduction_320 +happyReduction_320 (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 happyOut135 happy_x_2 of { happy_var_2 -> + case happyOut135 happy_x_4 of { happy_var_4 -> + case happyOut135 happy_x_6 of { happy_var_6 -> + happyIn139 + (If happy_var_2 happy_var_4 happy_var_6 + ) `HappyStk` happyRest}}} + +happyReduce_321 = happyReduce 4# 130# happyReduction_321 +happyReduction_321 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut144 happy_x_2 of { happy_var_2 -> + case happyOut135 happy_x_4 of { happy_var_4 -> + happyIn139 + (Proc happy_var_2 happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_322 = happyReduce 4# 131# happyReduction_322 +happyReduction_322 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut135 happy_x_2 of { happy_var_2 -> + case happyOut171 happy_x_4 of { happy_var_4 -> + happyIn140 + (Case happy_var_2 happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_323 = happySpecReduce_2 131# happyReduction_323 +happyReduction_323 happy_x_2 + happy_x_1 + = case happyOut142 happy_x_2 of { happy_var_2 -> + happyIn140 + (NegApp happy_var_2 + )} + +happyReduce_324 = happySpecReduce_2 131# happyReduction_324 +happyReduction_324 happy_x_2 + happy_x_1 + = case happyOut179 happy_x_2 of { happy_var_2 -> + happyIn140 + (Do happy_var_2 + )} + +happyReduce_325 = happySpecReduce_2 131# happyReduction_325 +happyReduction_325 happy_x_2 + happy_x_1 + = case happyOut179 happy_x_2 of { happy_var_2 -> + happyIn140 + (MDo happy_var_2 + )} + +happyReduce_326 = happySpecReduce_1 131# happyReduction_326 +happyReduction_326 happy_x_1 + = case happyOut141 happy_x_1 of { happy_var_1 -> + happyIn140 + (happy_var_1 + )} + +happyReduce_327 = happySpecReduce_1 131# happyReduction_327 +happyReduction_327 happy_x_1 + = case happyOut142 happy_x_1 of { happy_var_1 -> + happyIn140 + (happy_var_1 + )} + +happyReduce_328 = happySpecReduce_3 132# happyReduction_328 +happyReduction_328 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_2 of { (StringTok happy_var_2) -> + happyIn141 + (CorePragma happy_var_2 + )} + +happyReduce_329 = happySpecReduce_3 132# happyReduction_329 +happyReduction_329 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_2 of { (StringTok happy_var_2) -> + happyIn141 + (SCCPragma happy_var_2 + )} + +happyReduce_330 = happyReduce 10# 132# happyReduction_330 +happyReduction_330 (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) + = case happyOutTok happy_x_2 of { (StringTok happy_var_2) -> + case happyOutTok happy_x_3 of { (IntTok happy_var_3) -> + case happyOutTok happy_x_5 of { (IntTok happy_var_5) -> + case happyOutTok happy_x_7 of { (IntTok happy_var_7) -> + case happyOutTok happy_x_9 of { (IntTok happy_var_9) -> + happyIn141 + (GenPragma happy_var_2 (fromInteger happy_var_3, fromInteger happy_var_5) + (fromInteger happy_var_7, fromInteger happy_var_9) + ) `HappyStk` happyRest}}}}} + +happyReduce_331 = happySpecReduce_2 133# happyReduction_331 +happyReduction_331 happy_x_2 + happy_x_1 + = case happyOut142 happy_x_1 of { happy_var_1 -> + case happyOut145 happy_x_2 of { happy_var_2 -> + happyIn142 + (App happy_var_1 happy_var_2 + )}} + +happyReduce_332 = happySpecReduce_1 133# happyReduction_332 +happyReduction_332 happy_x_1 + = case happyOut145 happy_x_1 of { happy_var_1 -> + happyIn142 + (happy_var_1 + )} + +happyReduce_333 = happySpecReduce_2 134# happyReduction_333 +happyReduction_333 happy_x_2 + happy_x_1 + = case happyOut143 happy_x_1 of { happy_var_1 -> + case happyOut144 happy_x_2 of { happy_var_2 -> + happyIn143 + (happy_var_2 : happy_var_1 + )}} + +happyReduce_334 = happySpecReduce_1 134# happyReduction_334 +happyReduction_334 happy_x_1 + = case happyOut144 happy_x_1 of { happy_var_1 -> + happyIn143 + ([happy_var_1] + )} + +happyReduce_335 = happyMonadReduce 1# 135# happyReduction_335 +happyReduction_335 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut145 happy_x_1 of { happy_var_1 -> + ( checkPattern happy_var_1)} + ) (\r -> happyReturn (happyIn144 r)) + +happyReduce_336 = happyMonadReduce 2# 135# happyReduction_336 +happyReduction_336 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut145 happy_x_2 of { happy_var_2 -> + ( checkPattern (BangPat happy_var_2))} + ) (\r -> happyReturn (happyIn144 r)) + +happyReduce_337 = happyMonadReduce 3# 136# happyReduction_337 +happyReduction_337 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut189 happy_x_1 of { happy_var_1 -> + case happyOut145 happy_x_3 of { happy_var_3 -> + ( do { n <- checkUnQual happy_var_1; + return (AsPat n happy_var_3) })}} + ) (\r -> happyReturn (happyIn145 r)) + +happyReduce_338 = happyMonadReduce 3# 136# happyReduction_338 +happyReduction_338 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut189 happy_x_1 of { happy_var_1 -> + case happyOut145 happy_x_3 of { happy_var_3 -> + ( do { n <- checkUnQual happy_var_1; + return (CAsRP n happy_var_3) })}} + ) (\r -> happyReturn (happyIn145 r)) + +happyReduce_339 = happySpecReduce_2 136# happyReduction_339 +happyReduction_339 happy_x_2 + happy_x_1 + = case happyOut145 happy_x_2 of { happy_var_2 -> + happyIn145 + (IrrPat happy_var_2 + )} + +happyReduce_340 = happySpecReduce_1 136# happyReduction_340 +happyReduction_340 happy_x_1 + = case happyOut146 happy_x_1 of { happy_var_1 -> + happyIn145 + (happy_var_1 + )} + +happyReduce_341 = happyMonadReduce 3# 137# happyReduction_341 +happyReduction_341 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut146 happy_x_1 of { happy_var_1 -> + ( mkRecConstrOrUpdate happy_var_1 [])} + ) (\r -> happyReturn (happyIn146 r)) + +happyReduce_342 = happyMonadReduce 4# 137# happyReduction_342 +happyReduction_342 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut146 happy_x_1 of { happy_var_1 -> + case happyOut181 happy_x_3 of { happy_var_3 -> + ( mkRecConstrOrUpdate happy_var_1 (reverse happy_var_3))}} + ) (\r -> happyReturn (happyIn146 r)) + +happyReduce_343 = happyReduce 4# 137# happyReduction_343 +happyReduction_343 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut189 happy_x_1 of { happy_var_1 -> + case happyOut72 happy_x_3 of { happy_var_3 -> + happyIn146 + (ExplTypeArg happy_var_1 happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_344 = happySpecReduce_1 137# happyReduction_344 +happyReduction_344 happy_x_1 + = case happyOut147 happy_x_1 of { happy_var_1 -> + happyIn146 + (happy_var_1 + )} + +happyReduce_345 = happySpecReduce_1 138# happyReduction_345 +happyReduction_345 happy_x_1 + = case happyOut190 happy_x_1 of { happy_var_1 -> + happyIn147 + (IPVar happy_var_1 + )} + +happyReduce_346 = happySpecReduce_1 138# happyReduction_346 +happyReduction_346 happy_x_1 + = case happyOut189 happy_x_1 of { happy_var_1 -> + happyIn147 + (Var happy_var_1 + )} + +happyReduce_347 = happySpecReduce_1 138# happyReduction_347 +happyReduction_347 happy_x_1 + = case happyOut186 happy_x_1 of { happy_var_1 -> + happyIn147 + (happy_var_1 + )} + +happyReduce_348 = happySpecReduce_1 138# happyReduction_348 +happyReduction_348 happy_x_1 + = case happyOut215 happy_x_1 of { happy_var_1 -> + happyIn147 + (Lit happy_var_1 + )} + +happyReduce_349 = happySpecReduce_3 138# happyReduction_349 +happyReduction_349 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut150 happy_x_2 of { happy_var_2 -> + happyIn147 + (Paren happy_var_2 + )} + +happyReduce_350 = happyReduce 5# 138# happyReduction_350 +happyReduction_350 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut150 happy_x_2 of { happy_var_2 -> + case happyOut149 happy_x_4 of { happy_var_4 -> + happyIn147 + (Tuple (happy_var_2 : reverse happy_var_4) + ) `HappyStk` happyRest}} + +happyReduce_351 = happySpecReduce_3 138# happyReduction_351 +happyReduction_351 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut163 happy_x_2 of { happy_var_2 -> + happyIn147 + (happy_var_2 + )} + +happyReduce_352 = happyReduce 4# 138# happyReduction_352 +happyReduction_352 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut200 happy_x_2 of { happy_var_2 -> + case happyOut136 happy_x_3 of { happy_var_3 -> + happyIn147 + (RightSection happy_var_2 happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_353 = happySpecReduce_1 138# happyReduction_353 +happyReduction_353 happy_x_1 + = happyIn147 + (WildCard + ) + +happyReduce_354 = happyMonadReduce 3# 138# happyReduction_354 +happyReduction_354 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut152 happy_x_2 of { happy_var_2 -> + ( checkEnabled RegularPatterns >> return happy_var_2)} + ) (\r -> happyReturn (happyIn147 r)) + +happyReduce_355 = happySpecReduce_3 138# happyReduction_355 +happyReduction_355 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut151 happy_x_2 of { happy_var_2 -> + happyIn147 + (SeqRP $ reverse happy_var_2 + )} + +happyReduce_356 = happyReduce 5# 138# happyReduction_356 +happyReduction_356 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut135 happy_x_2 of { happy_var_2 -> + case happyOut169 happy_x_4 of { happy_var_4 -> + happyIn147 + (GuardRP happy_var_2 $ reverse happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_357 = happySpecReduce_1 138# happyReduction_357 +happyReduction_357 happy_x_1 + = case happyOut153 happy_x_1 of { happy_var_1 -> + happyIn147 + (happy_var_1 + )} + +happyReduce_358 = happySpecReduce_1 138# happyReduction_358 +happyReduction_358 happy_x_1 + = case happyOutTok happy_x_1 of { (THIdEscape happy_var_1) -> + happyIn147 + (SpliceExp $ IdSplice happy_var_1 + )} + +happyReduce_359 = happySpecReduce_3 138# happyReduction_359 +happyReduction_359 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut134 happy_x_2 of { happy_var_2 -> + happyIn147 + (SpliceExp $ ParenSplice happy_var_2 + )} + +happyReduce_360 = happySpecReduce_3 138# happyReduction_360 +happyReduction_360 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut134 happy_x_2 of { happy_var_2 -> + happyIn147 + (BracketExp $ ExpBracket happy_var_2 + )} + +happyReduce_361 = happyMonadReduce 3# 138# happyReduction_361 +happyReduction_361 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut136 happy_x_2 of { happy_var_2 -> + ( do { p <- checkPattern happy_var_2; + return $ BracketExp $ PatBracket p })} + ) (\r -> happyReturn (happyIn147 r)) + +happyReduce_362 = happySpecReduce_3 138# happyReduction_362 +happyReduction_362 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut81 happy_x_2 of { happy_var_2 -> + happyIn147 + (BracketExp $ TypeBracket happy_var_2 + )} + +happyReduce_363 = happyReduce 5# 138# happyReduction_363 +happyReduction_363 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut43 happy_x_3 of { happy_var_3 -> + happyIn147 + (BracketExp $ DeclBracket happy_var_3 + ) `HappyStk` happyRest} + +happyReduce_364 = happySpecReduce_2 138# happyReduction_364 +happyReduction_364 happy_x_2 + happy_x_1 + = case happyOut189 happy_x_2 of { happy_var_2 -> + happyIn147 + (VarQuote happy_var_2 + )} + +happyReduce_365 = happySpecReduce_2 138# happyReduction_365 +happyReduction_365 happy_x_2 + happy_x_1 + = case happyOut192 happy_x_2 of { happy_var_2 -> + happyIn147 + (VarQuote happy_var_2 + )} + +happyReduce_366 = happySpecReduce_2 138# happyReduction_366 +happyReduction_366 happy_x_2 + happy_x_1 + = case happyOut222 happy_x_2 of { happy_var_2 -> + happyIn147 + (TypQuote (UnQual happy_var_2) + )} + +happyReduce_367 = happySpecReduce_2 138# happyReduction_367 +happyReduction_367 happy_x_2 + happy_x_1 + = case happyOut78 happy_x_2 of { happy_var_2 -> + happyIn147 + (TypQuote happy_var_2 + )} + +happyReduce_368 = happySpecReduce_1 138# happyReduction_368 +happyReduction_368 happy_x_1 + = case happyOutTok happy_x_1 of { (THQuasiQuote happy_var_1) -> + happyIn147 + (let (n,q) = happy_var_1 in QuasiQuote n q + )} + +happyReduce_369 = happySpecReduce_2 139# happyReduction_369 +happyReduction_369 happy_x_2 + happy_x_1 + = case happyOut148 happy_x_1 of { happy_var_1 -> + happyIn148 + (happy_var_1 + 1 + )} + +happyReduce_370 = happySpecReduce_1 139# happyReduction_370 +happyReduction_370 happy_x_1 + = happyIn148 + (1 + ) + +happyReduce_371 = happySpecReduce_3 140# happyReduction_371 +happyReduction_371 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut149 happy_x_1 of { happy_var_1 -> + case happyOut150 happy_x_3 of { happy_var_3 -> + happyIn149 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_372 = happySpecReduce_1 140# happyReduction_372 +happyReduction_372 happy_x_1 + = case happyOut150 happy_x_1 of { happy_var_1 -> + happyIn149 + ([happy_var_1] + )} + +happyReduce_373 = happySpecReduce_1 141# happyReduction_373 +happyReduction_373 happy_x_1 + = case happyOut135 happy_x_1 of { happy_var_1 -> + happyIn150 + (happy_var_1 + )} + +happyReduce_374 = happyMonadReduce 3# 141# happyReduction_374 +happyReduction_374 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut135 happy_x_1 of { happy_var_1 -> + case happyOut135 happy_x_3 of { happy_var_3 -> + ( checkEnabled ViewPatterns >> return (ViewPat happy_var_1 happy_var_3))}} + ) (\r -> happyReturn (happyIn150 r)) + +happyReduce_375 = happySpecReduce_3 142# happyReduction_375 +happyReduction_375 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut151 happy_x_1 of { happy_var_1 -> + case happyOut135 happy_x_3 of { happy_var_3 -> + happyIn151 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_376 = happySpecReduce_1 142# happyReduction_376 +happyReduction_376 happy_x_1 + = case happyOut135 happy_x_1 of { happy_var_1 -> + happyIn151 + ([happy_var_1] + )} + +happyReduce_377 = happySpecReduce_3 143# happyReduction_377 +happyReduction_377 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut135 happy_x_1 of { happy_var_1 -> + case happyOut152 happy_x_3 of { happy_var_3 -> + happyIn152 + (EitherRP happy_var_1 happy_var_3 + )}} + +happyReduce_378 = happySpecReduce_3 143# happyReduction_378 +happyReduction_378 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut135 happy_x_1 of { happy_var_1 -> + case happyOut135 happy_x_3 of { happy_var_3 -> + happyIn152 + (EitherRP happy_var_1 happy_var_3 + )}} + +happyReduce_379 = happyMonadReduce 10# 144# happyReduction_379 +happyReduction_379 (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 happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut156 happy_x_3 of { happy_var_3 -> + case happyOut159 happy_x_4 of { happy_var_4 -> + case happyOut161 happy_x_5 of { happy_var_5 -> + case happyOut154 happy_x_7 of { happy_var_7 -> + case happyOut156 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 $ XTag happy_var_1 n as happy_var_5 cn })}}}}}} + ) (\r -> happyReturn (happyIn153 r)) + +happyReduce_380 = happyReduce 6# 144# happyReduction_380 +happyReduction_380 (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 happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut156 happy_x_3 of { happy_var_3 -> + case happyOut159 happy_x_4 of { happy_var_4 -> + case happyOut161 happy_x_5 of { happy_var_5 -> + happyIn153 + (XETag happy_var_1 happy_var_3 (reverse happy_var_4) happy_var_5 + ) `HappyStk` happyRest}}}} + +happyReduce_381 = happySpecReduce_3 144# happyReduction_381 +happyReduction_381 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut135 happy_x_2 of { happy_var_2 -> + happyIn153 + (XExpTag happy_var_2 + )} + +happyReduce_382 = happySpecReduce_2 145# happyReduction_382 +happyReduction_382 happy_x_2 + happy_x_1 + = case happyOut154 happy_x_1 of { happy_var_1 -> + case happyOut155 happy_x_2 of { happy_var_2 -> + happyIn154 + (happy_var_2 : happy_var_1 + )}} + +happyReduce_383 = happySpecReduce_0 145# happyReduction_383 +happyReduction_383 = happyIn154 + ([] + ) + +happyReduce_384 = happySpecReduce_1 146# happyReduction_384 +happyReduction_384 happy_x_1 + = case happyOutTok happy_x_1 of { (XPCDATA happy_var_1) -> + happyIn155 + (XPcdata happy_var_1 + )} + +happyReduce_385 = happySpecReduce_3 146# happyReduction_385 +happyReduction_385 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut151 happy_x_2 of { happy_var_2 -> + happyIn155 + (XRPats $ reverse happy_var_2 + )} + +happyReduce_386 = happySpecReduce_1 146# happyReduction_386 +happyReduction_386 happy_x_1 + = case happyOut153 happy_x_1 of { happy_var_1 -> + happyIn155 + (happy_var_1 + )} + +happyReduce_387 = happySpecReduce_3 147# happyReduction_387 +happyReduction_387 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut157 happy_x_1 of { happy_var_1 -> + case happyOut157 happy_x_3 of { happy_var_3 -> + happyIn156 + (XDomName happy_var_1 happy_var_3 + )}} + +happyReduce_388 = happySpecReduce_1 147# happyReduction_388 +happyReduction_388 happy_x_1 + = case happyOut157 happy_x_1 of { happy_var_1 -> + happyIn156 + (XName happy_var_1 + )} + +happyReduce_389 = happySpecReduce_1 148# happyReduction_389 +happyReduction_389 happy_x_1 + = case happyOutTok happy_x_1 of { (VarId happy_var_1) -> + happyIn157 + (happy_var_1 + )} + +happyReduce_390 = happySpecReduce_1 148# happyReduction_390 +happyReduction_390 happy_x_1 + = case happyOutTok happy_x_1 of { (ConId happy_var_1) -> + happyIn157 + (happy_var_1 + )} + +happyReduce_391 = happySpecReduce_1 148# happyReduction_391 +happyReduction_391 happy_x_1 + = case happyOutTok happy_x_1 of { (DVarId happy_var_1) -> + happyIn157 + (mkDVar happy_var_1 + )} + +happyReduce_392 = happySpecReduce_1 148# happyReduction_392 +happyReduction_392 happy_x_1 + = case happyOut158 happy_x_1 of { happy_var_1 -> + happyIn157 + (happy_var_1 + )} + +happyReduce_393 = happySpecReduce_1 149# happyReduction_393 +happyReduction_393 happy_x_1 + = happyIn158 + ("type" + ) + +happyReduce_394 = happySpecReduce_1 149# happyReduction_394 +happyReduction_394 happy_x_1 + = happyIn158 + ("class" + ) + +happyReduce_395 = happySpecReduce_1 149# happyReduction_395 +happyReduction_395 happy_x_1 + = happyIn158 + ("data" + ) + +happyReduce_396 = happySpecReduce_1 149# happyReduction_396 +happyReduction_396 happy_x_1 + = happyIn158 + ("foreign" + ) + +happyReduce_397 = happySpecReduce_1 149# happyReduction_397 +happyReduction_397 happy_x_1 + = happyIn158 + ("export" + ) + +happyReduce_398 = happySpecReduce_1 149# happyReduction_398 +happyReduction_398 happy_x_1 + = happyIn158 + ("safe" + ) + +happyReduce_399 = happySpecReduce_1 149# happyReduction_399 +happyReduction_399 happy_x_1 + = happyIn158 + ("unsafe" + ) + +happyReduce_400 = happySpecReduce_1 149# happyReduction_400 +happyReduction_400 happy_x_1 + = happyIn158 + ("threadsafe" + ) + +happyReduce_401 = happySpecReduce_1 149# happyReduction_401 +happyReduction_401 happy_x_1 + = happyIn158 + ("stdcall" + ) + +happyReduce_402 = happySpecReduce_1 149# happyReduction_402 +happyReduction_402 happy_x_1 + = happyIn158 + ("ccall" + ) + +happyReduce_403 = happySpecReduce_1 149# happyReduction_403 +happyReduction_403 happy_x_1 + = happyIn158 + ("as" + ) + +happyReduce_404 = happySpecReduce_1 149# happyReduction_404 +happyReduction_404 happy_x_1 + = happyIn158 + ("by" + ) + +happyReduce_405 = happySpecReduce_1 149# happyReduction_405 +happyReduction_405 happy_x_1 + = happyIn158 + ("case" + ) + +happyReduce_406 = happySpecReduce_1 149# happyReduction_406 +happyReduction_406 happy_x_1 + = happyIn158 + ("default" + ) + +happyReduce_407 = happySpecReduce_1 149# happyReduction_407 +happyReduction_407 happy_x_1 + = happyIn158 + ("deriving" + ) + +happyReduce_408 = happySpecReduce_1 149# happyReduction_408 +happyReduction_408 happy_x_1 + = happyIn158 + ("do" + ) + +happyReduce_409 = happySpecReduce_1 149# happyReduction_409 +happyReduction_409 happy_x_1 + = happyIn158 + ("else" + ) + +happyReduce_410 = happySpecReduce_1 149# happyReduction_410 +happyReduction_410 happy_x_1 + = happyIn158 + ("family" + ) + +happyReduce_411 = happySpecReduce_1 149# happyReduction_411 +happyReduction_411 happy_x_1 + = happyIn158 + ("forall" + ) + +happyReduce_412 = happySpecReduce_1 149# happyReduction_412 +happyReduction_412 happy_x_1 + = happyIn158 + ("group" + ) + +happyReduce_413 = happySpecReduce_1 149# happyReduction_413 +happyReduction_413 happy_x_1 + = happyIn158 + ("hiding" + ) + +happyReduce_414 = happySpecReduce_1 149# happyReduction_414 +happyReduction_414 happy_x_1 + = happyIn158 + ("if" + ) + +happyReduce_415 = happySpecReduce_1 149# happyReduction_415 +happyReduction_415 happy_x_1 + = happyIn158 + ("import" + ) + +happyReduce_416 = happySpecReduce_1 149# happyReduction_416 +happyReduction_416 happy_x_1 + = happyIn158 + ("in" + ) + +happyReduce_417 = happySpecReduce_1 149# happyReduction_417 +happyReduction_417 happy_x_1 + = happyIn158 + ("infix" + ) + +happyReduce_418 = happySpecReduce_1 149# happyReduction_418 +happyReduction_418 happy_x_1 + = happyIn158 + ("infixl" + ) + +happyReduce_419 = happySpecReduce_1 149# happyReduction_419 +happyReduction_419 happy_x_1 + = happyIn158 + ("infixr" + ) + +happyReduce_420 = happySpecReduce_1 149# happyReduction_420 +happyReduction_420 happy_x_1 + = happyIn158 + ("instance" + ) + +happyReduce_421 = happySpecReduce_1 149# happyReduction_421 +happyReduction_421 happy_x_1 + = happyIn158 + ("let" + ) + +happyReduce_422 = happySpecReduce_1 149# happyReduction_422 +happyReduction_422 happy_x_1 + = happyIn158 + ("mdo" + ) + +happyReduce_423 = happySpecReduce_1 149# happyReduction_423 +happyReduction_423 happy_x_1 + = happyIn158 + ("module" + ) + +happyReduce_424 = happySpecReduce_1 149# happyReduction_424 +happyReduction_424 happy_x_1 + = happyIn158 + ("newtype" + ) + +happyReduce_425 = happySpecReduce_1 149# happyReduction_425 +happyReduction_425 happy_x_1 + = happyIn158 + ("of" + ) + +happyReduce_426 = happySpecReduce_1 149# happyReduction_426 +happyReduction_426 happy_x_1 + = happyIn158 + ("proc" + ) + +happyReduce_427 = happySpecReduce_1 149# happyReduction_427 +happyReduction_427 happy_x_1 + = happyIn158 + ("rec" + ) + +happyReduce_428 = happySpecReduce_1 149# happyReduction_428 +happyReduction_428 happy_x_1 + = happyIn158 + ("then" + ) + +happyReduce_429 = happySpecReduce_1 149# happyReduction_429 +happyReduction_429 happy_x_1 + = happyIn158 + ("using" + ) + +happyReduce_430 = happySpecReduce_1 149# happyReduction_430 +happyReduction_430 happy_x_1 + = happyIn158 + ("where" + ) + +happyReduce_431 = happySpecReduce_1 149# happyReduction_431 +happyReduction_431 happy_x_1 + = happyIn158 + ("qualified" + ) + +happyReduce_432 = happySpecReduce_2 150# happyReduction_432 +happyReduction_432 happy_x_2 + happy_x_1 + = case happyOut159 happy_x_1 of { happy_var_1 -> + case happyOut160 happy_x_2 of { happy_var_2 -> + happyIn159 + (happy_var_2 : happy_var_1 + )}} + +happyReduce_433 = happySpecReduce_0 150# happyReduction_433 +happyReduction_433 = happyIn159 + ([] + ) + +happyReduce_434 = happySpecReduce_3 151# happyReduction_434 +happyReduction_434 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut156 happy_x_1 of { happy_var_1 -> + case happyOut145 happy_x_3 of { happy_var_3 -> + happyIn160 + (XAttr happy_var_1 happy_var_3 + )}} + +happyReduce_435 = happySpecReduce_1 152# happyReduction_435 +happyReduction_435 happy_x_1 + = case happyOut145 happy_x_1 of { happy_var_1 -> + happyIn161 + (Just happy_var_1 + )} + +happyReduce_436 = happySpecReduce_0 152# happyReduction_436 +happyReduction_436 = happyIn161 + (Nothing + ) + +happyReduce_437 = happySpecReduce_1 153# happyReduction_437 +happyReduction_437 happy_x_1 + = case happyOutTok happy_x_1 of { (DVarId happy_var_1) -> + happyIn162 + (mkDVarExpr happy_var_1 + )} + +happyReduce_438 = happySpecReduce_1 154# happyReduction_438 +happyReduction_438 happy_x_1 + = case happyOut150 happy_x_1 of { happy_var_1 -> + happyIn163 + (List [happy_var_1] + )} + +happyReduce_439 = happySpecReduce_1 154# happyReduction_439 +happyReduction_439 happy_x_1 + = case happyOut164 happy_x_1 of { happy_var_1 -> + happyIn163 + (List (reverse happy_var_1) + )} + +happyReduce_440 = happySpecReduce_2 154# happyReduction_440 +happyReduction_440 happy_x_2 + happy_x_1 + = case happyOut150 happy_x_1 of { happy_var_1 -> + happyIn163 + (EnumFrom happy_var_1 + )} + +happyReduce_441 = happyReduce 4# 154# happyReduction_441 +happyReduction_441 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut150 happy_x_1 of { happy_var_1 -> + case happyOut135 happy_x_3 of { happy_var_3 -> + happyIn163 + (EnumFromThen happy_var_1 happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_442 = happySpecReduce_3 154# happyReduction_442 +happyReduction_442 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut150 happy_x_1 of { happy_var_1 -> + case happyOut135 happy_x_3 of { happy_var_3 -> + happyIn163 + (EnumFromTo happy_var_1 happy_var_3 + )}} + +happyReduce_443 = happyReduce 5# 154# happyReduction_443 +happyReduction_443 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut150 happy_x_1 of { happy_var_1 -> + case happyOut135 happy_x_3 of { happy_var_3 -> + case happyOut135 happy_x_5 of { happy_var_5 -> + happyIn163 + (EnumFromThenTo happy_var_1 happy_var_3 happy_var_5 + ) `HappyStk` happyRest}}} + +happyReduce_444 = happySpecReduce_3 154# happyReduction_444 +happyReduction_444 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut150 happy_x_1 of { happy_var_1 -> + case happyOut165 happy_x_3 of { happy_var_3 -> + happyIn163 + (ParComp happy_var_1 (reverse happy_var_3) + )}} + +happyReduce_445 = happySpecReduce_3 155# happyReduction_445 +happyReduction_445 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut164 happy_x_1 of { happy_var_1 -> + case happyOut150 happy_x_3 of { happy_var_3 -> + happyIn164 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_446 = happySpecReduce_3 155# happyReduction_446 +happyReduction_446 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut150 happy_x_1 of { happy_var_1 -> + case happyOut150 happy_x_3 of { happy_var_3 -> + happyIn164 + ([happy_var_3,happy_var_1] + )}} + +happyReduce_447 = happySpecReduce_3 156# happyReduction_447 +happyReduction_447 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut165 happy_x_1 of { happy_var_1 -> + case happyOut166 happy_x_3 of { happy_var_3 -> + happyIn165 + (reverse happy_var_3 : happy_var_1 + )}} + +happyReduce_448 = happySpecReduce_1 156# happyReduction_448 +happyReduction_448 happy_x_1 + = case happyOut166 happy_x_1 of { happy_var_1 -> + happyIn165 + ([happy_var_1] + )} + +happyReduce_449 = happySpecReduce_3 157# happyReduction_449 +happyReduction_449 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut166 happy_x_1 of { happy_var_1 -> + case happyOut167 happy_x_3 of { happy_var_3 -> + happyIn166 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_450 = happySpecReduce_1 157# happyReduction_450 +happyReduction_450 happy_x_1 + = case happyOut167 happy_x_1 of { happy_var_1 -> + happyIn166 + ([happy_var_1] + )} + +happyReduce_451 = happySpecReduce_1 158# happyReduction_451 +happyReduction_451 happy_x_1 + = case happyOut168 happy_x_1 of { happy_var_1 -> + happyIn167 + (happy_var_1 + )} + +happyReduce_452 = happySpecReduce_1 158# happyReduction_452 +happyReduction_452 happy_x_1 + = case happyOut170 happy_x_1 of { happy_var_1 -> + happyIn167 + (QualStmt happy_var_1 + )} + +happyReduce_453 = happySpecReduce_2 159# happyReduction_453 +happyReduction_453 happy_x_2 + happy_x_1 + = case happyOut134 happy_x_2 of { happy_var_2 -> + happyIn168 + (ThenTrans happy_var_2 + )} + +happyReduce_454 = happyReduce 4# 159# happyReduction_454 +happyReduction_454 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut134 happy_x_2 of { happy_var_2 -> + case happyOut134 happy_x_4 of { happy_var_4 -> + happyIn168 + (ThenBy happy_var_2 happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_455 = happyReduce 4# 159# happyReduction_455 +happyReduction_455 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut134 happy_x_4 of { happy_var_4 -> + happyIn168 + (GroupBy happy_var_4 + ) `HappyStk` happyRest} + +happyReduce_456 = happyReduce 4# 159# happyReduction_456 +happyReduction_456 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut134 happy_x_4 of { happy_var_4 -> + happyIn168 + (GroupUsing happy_var_4 + ) `HappyStk` happyRest} + +happyReduce_457 = happyReduce 6# 159# happyReduction_457 +happyReduction_457 (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 happyOut134 happy_x_4 of { happy_var_4 -> + case happyOut134 happy_x_6 of { happy_var_6 -> + happyIn168 + (GroupByUsing happy_var_4 happy_var_6 + ) `HappyStk` happyRest}} + +happyReduce_458 = happySpecReduce_3 160# happyReduction_458 +happyReduction_458 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut169 happy_x_1 of { happy_var_1 -> + case happyOut170 happy_x_3 of { happy_var_3 -> + happyIn169 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_459 = happySpecReduce_1 160# happyReduction_459 +happyReduction_459 happy_x_1 + = case happyOut170 happy_x_1 of { happy_var_1 -> + happyIn169 + ([happy_var_1] + )} + +happyReduce_460 = happyReduce 4# 161# happyReduction_460 +happyReduction_460 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut178 happy_x_1 of { happy_var_1 -> + case happyOut216 happy_x_2 of { happy_var_2 -> + case happyOut134 happy_x_4 of { happy_var_4 -> + happyIn170 + (Generator happy_var_2 happy_var_1 happy_var_4 + ) `HappyStk` happyRest}}} + +happyReduce_461 = happySpecReduce_1 161# happyReduction_461 +happyReduction_461 happy_x_1 + = case happyOut134 happy_x_1 of { happy_var_1 -> + happyIn170 + (Qualifier happy_var_1 + )} + +happyReduce_462 = happySpecReduce_2 161# happyReduction_462 +happyReduction_462 happy_x_2 + happy_x_1 + = case happyOut55 happy_x_2 of { happy_var_2 -> + happyIn170 + (LetStmt happy_var_2 + )} + +happyReduce_463 = happySpecReduce_3 162# happyReduction_463 +happyReduction_463 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut172 happy_x_2 of { happy_var_2 -> + happyIn171 + (happy_var_2 + )} + +happyReduce_464 = happySpecReduce_3 162# happyReduction_464 +happyReduction_464 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut172 happy_x_2 of { happy_var_2 -> + happyIn171 + (happy_var_2 + )} + +happyReduce_465 = happySpecReduce_3 163# happyReduction_465 +happyReduction_465 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut173 happy_x_2 of { happy_var_2 -> + happyIn172 + (reverse happy_var_2 + )} + +happyReduce_466 = happySpecReduce_3 164# happyReduction_466 +happyReduction_466 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut173 happy_x_1 of { happy_var_1 -> + case happyOut174 happy_x_3 of { happy_var_3 -> + happyIn173 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_467 = happySpecReduce_1 164# happyReduction_467 +happyReduction_467 happy_x_1 + = case happyOut174 happy_x_1 of { happy_var_1 -> + happyIn173 + ([happy_var_1] + )} + +happyReduce_468 = happyReduce 4# 165# happyReduction_468 +happyReduction_468 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut178 happy_x_2 of { happy_var_2 -> + case happyOut175 happy_x_3 of { happy_var_3 -> + case happyOut129 happy_x_4 of { happy_var_4 -> + happyIn174 + (Alt happy_var_1 happy_var_2 happy_var_3 happy_var_4 + ) `HappyStk` happyRest}}}} + +happyReduce_469 = happySpecReduce_2 166# happyReduction_469 +happyReduction_469 happy_x_2 + happy_x_1 + = case happyOut134 happy_x_2 of { happy_var_2 -> + happyIn175 + (UnGuardedAlt happy_var_2 + )} + +happyReduce_470 = happySpecReduce_1 166# happyReduction_470 +happyReduction_470 happy_x_1 + = case happyOut176 happy_x_1 of { happy_var_1 -> + happyIn175 + (GuardedAlts (reverse happy_var_1) + )} + +happyReduce_471 = happySpecReduce_2 167# happyReduction_471 +happyReduction_471 happy_x_2 + happy_x_1 + = case happyOut176 happy_x_1 of { happy_var_1 -> + case happyOut177 happy_x_2 of { happy_var_2 -> + happyIn176 + (happy_var_2 : happy_var_1 + )}} + +happyReduce_472 = happySpecReduce_1 167# happyReduction_472 +happyReduction_472 happy_x_1 + = case happyOut177 happy_x_1 of { happy_var_1 -> + happyIn176 + ([happy_var_1] + )} + +happyReduce_473 = happyMonadReduce 5# 168# happyReduction_473 +happyReduction_473 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut169 happy_x_3 of { happy_var_3 -> + case happyOut134 happy_x_5 of { happy_var_5 -> + ( do { checkPatternGuards happy_var_3; + return (GuardedAlt happy_var_1 (reverse happy_var_3) happy_var_5) })}}} + ) (\r -> happyReturn (happyIn177 r)) + +happyReduce_474 = happyMonadReduce 1# 169# happyReduction_474 +happyReduction_474 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut135 happy_x_1 of { happy_var_1 -> + ( checkPattern happy_var_1)} + ) (\r -> happyReturn (happyIn178 r)) + +happyReduce_475 = happyMonadReduce 2# 169# happyReduction_475 +happyReduction_475 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut145 happy_x_2 of { happy_var_2 -> + ( checkPattern (BangPat happy_var_2))} + ) (\r -> happyReturn (happyIn178 r)) + +happyReduce_476 = happySpecReduce_3 170# happyReduction_476 +happyReduction_476 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut180 happy_x_2 of { happy_var_2 -> + happyIn179 + (happy_var_2 + )} + +happyReduce_477 = happySpecReduce_3 170# happyReduction_477 +happyReduction_477 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut180 happy_x_2 of { happy_var_2 -> + happyIn179 + (happy_var_2 + )} + +happyReduce_478 = happyReduce 4# 171# happyReduction_478 +happyReduction_478 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut55 happy_x_2 of { happy_var_2 -> + case happyOut180 happy_x_4 of { happy_var_4 -> + happyIn180 + (LetStmt happy_var_2 : happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_479 = happyReduce 6# 171# happyReduction_479 +happyReduction_479 (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 happyOut178 happy_x_1 of { happy_var_1 -> + case happyOut216 happy_x_2 of { happy_var_2 -> + case happyOut134 happy_x_4 of { happy_var_4 -> + case happyOut180 happy_x_6 of { happy_var_6 -> + happyIn180 + (Generator happy_var_2 happy_var_1 happy_var_4 : happy_var_6 + ) `HappyStk` happyRest}}}} + +happyReduce_480 = happySpecReduce_3 171# happyReduction_480 +happyReduction_480 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut134 happy_x_1 of { happy_var_1 -> + case happyOut180 happy_x_3 of { happy_var_3 -> + happyIn180 + (Qualifier happy_var_1 : happy_var_3 + )}} + +happyReduce_481 = happySpecReduce_2 171# happyReduction_481 +happyReduction_481 happy_x_2 + happy_x_1 + = case happyOut180 happy_x_2 of { happy_var_2 -> + happyIn180 + (happy_var_2 + )} + +happyReduce_482 = happySpecReduce_2 171# happyReduction_482 +happyReduction_482 happy_x_2 + happy_x_1 + = case happyOut134 happy_x_1 of { happy_var_1 -> + happyIn180 + ([Qualifier happy_var_1] + )} + +happyReduce_483 = happySpecReduce_1 171# happyReduction_483 +happyReduction_483 happy_x_1 + = case happyOut134 happy_x_1 of { happy_var_1 -> + happyIn180 + ([Qualifier happy_var_1] + )} + +happyReduce_484 = happyReduce 4# 171# happyReduction_484 +happyReduction_484 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut179 happy_x_2 of { happy_var_2 -> + case happyOut180 happy_x_4 of { happy_var_4 -> + happyIn180 + (RecStmt happy_var_2 : happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_485 = happySpecReduce_3 172# happyReduction_485 +happyReduction_485 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut181 happy_x_1 of { happy_var_1 -> + case happyOut182 happy_x_3 of { happy_var_3 -> + happyIn181 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_486 = happySpecReduce_1 172# happyReduction_486 +happyReduction_486 happy_x_1 + = case happyOut182 happy_x_1 of { happy_var_1 -> + happyIn181 + ([happy_var_1] + )} + +happyReduce_487 = happySpecReduce_3 173# happyReduction_487 +happyReduction_487 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut189 happy_x_1 of { happy_var_1 -> + case happyOut135 happy_x_3 of { happy_var_3 -> + happyIn182 + (FieldUpdate happy_var_1 happy_var_3 + )}} + +happyReduce_488 = happyMonadReduce 1# 173# happyReduction_488 +happyReduction_488 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (case happyOut187 happy_x_1 of { happy_var_1 -> + ( checkEnabled NamedFieldPuns >> return (FieldPun happy_var_1))} + ) (\r -> happyReturn (happyIn182 r)) + +happyReduce_489 = happyMonadReduce 1# 173# happyReduction_489 +happyReduction_489 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (( checkEnabled RecordWildCards >> return FieldWildcard) + ) (\r -> happyReturn (happyIn182 r)) + +happyReduce_490 = happySpecReduce_3 174# happyReduction_490 +happyReduction_490 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut184 happy_x_2 of { happy_var_2 -> + happyIn183 + (reverse happy_var_2 + )} + +happyReduce_491 = happySpecReduce_3 175# happyReduction_491 +happyReduction_491 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut184 happy_x_1 of { happy_var_1 -> + case happyOut185 happy_x_3 of { happy_var_3 -> + happyIn184 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_492 = happySpecReduce_1 175# happyReduction_492 +happyReduction_492 happy_x_1 + = case happyOut185 happy_x_1 of { happy_var_1 -> + happyIn184 + ([happy_var_1] + )} + +happyReduce_493 = happyReduce 4# 176# happyReduction_493 +happyReduction_493 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut216 happy_x_1 of { happy_var_1 -> + case happyOut190 happy_x_2 of { happy_var_2 -> + case happyOut134 happy_x_4 of { happy_var_4 -> + happyIn185 + (IPBind happy_var_1 happy_var_2 happy_var_4 + ) `HappyStk` happyRest}}} + +happyReduce_494 = happySpecReduce_2 177# happyReduction_494 +happyReduction_494 happy_x_2 + happy_x_1 + = happyIn186 + (p_unit_con + ) + +happyReduce_495 = happySpecReduce_2 177# happyReduction_495 +happyReduction_495 happy_x_2 + happy_x_1 + = happyIn186 + (List [] + ) + +happyReduce_496 = happySpecReduce_3 177# happyReduction_496 +happyReduction_496 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut148 happy_x_2 of { happy_var_2 -> + happyIn186 + (p_tuple_con Boxed happy_var_2 + )} + +happyReduce_497 = happySpecReduce_2 177# happyReduction_497 +happyReduction_497 happy_x_2 + happy_x_1 + = happyIn186 + (p_unboxed_singleton_con + ) + +happyReduce_498 = happySpecReduce_3 177# happyReduction_498 +happyReduction_498 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut148 happy_x_2 of { happy_var_2 -> + happyIn186 + (p_tuple_con Unboxed happy_var_2 + )} + +happyReduce_499 = happySpecReduce_1 177# happyReduction_499 +happyReduction_499 happy_x_1 + = case happyOut192 happy_x_1 of { happy_var_1 -> + happyIn186 + (Con happy_var_1 + )} + +happyReduce_500 = happySpecReduce_1 178# happyReduction_500 +happyReduction_500 happy_x_1 + = case happyOut204 happy_x_1 of { happy_var_1 -> + happyIn187 + (happy_var_1 + )} + +happyReduce_501 = happySpecReduce_3 178# happyReduction_501 +happyReduction_501 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut212 happy_x_2 of { happy_var_2 -> + happyIn187 + (happy_var_2 + )} + +happyReduce_502 = happySpecReduce_1 179# happyReduction_502 +happyReduction_502 happy_x_1 + = case happyOut203 happy_x_1 of { happy_var_1 -> + happyIn188 + (happy_var_1 + )} + +happyReduce_503 = happySpecReduce_3 179# happyReduction_503 +happyReduction_503 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut212 happy_x_2 of { happy_var_2 -> + happyIn188 + (happy_var_2 + )} + +happyReduce_504 = happySpecReduce_1 180# happyReduction_504 +happyReduction_504 happy_x_1 + = case happyOut202 happy_x_1 of { happy_var_1 -> + happyIn189 + (happy_var_1 + )} + +happyReduce_505 = happySpecReduce_3 180# happyReduction_505 +happyReduction_505 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut210 happy_x_2 of { happy_var_2 -> + happyIn189 + (happy_var_2 + )} + +happyReduce_506 = happySpecReduce_1 181# happyReduction_506 +happyReduction_506 happy_x_1 + = case happyOut205 happy_x_1 of { happy_var_1 -> + happyIn190 + (happy_var_1 + )} + +happyReduce_507 = happySpecReduce_1 182# happyReduction_507 +happyReduction_507 happy_x_1 + = case happyOut207 happy_x_1 of { happy_var_1 -> + happyIn191 + (happy_var_1 + )} + +happyReduce_508 = happySpecReduce_3 182# happyReduction_508 +happyReduction_508 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut209 happy_x_2 of { happy_var_2 -> + happyIn191 + (happy_var_2 + )} + +happyReduce_509 = happySpecReduce_1 183# happyReduction_509 +happyReduction_509 happy_x_1 + = case happyOut206 happy_x_1 of { happy_var_1 -> + happyIn192 + (happy_var_1 + )} + +happyReduce_510 = happySpecReduce_3 183# happyReduction_510 +happyReduction_510 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut201 happy_x_2 of { happy_var_2 -> + happyIn192 + (happy_var_2 + )} + +happyReduce_511 = happySpecReduce_1 184# happyReduction_511 +happyReduction_511 happy_x_1 + = case happyOut212 happy_x_1 of { happy_var_1 -> + happyIn193 + (happy_var_1 + )} + +happyReduce_512 = happySpecReduce_3 184# happyReduction_512 +happyReduction_512 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut204 happy_x_2 of { happy_var_2 -> + happyIn193 + (happy_var_2 + )} + +happyReduce_513 = happySpecReduce_1 185# happyReduction_513 +happyReduction_513 happy_x_1 + = case happyOut210 happy_x_1 of { happy_var_1 -> + happyIn194 + (happy_var_1 + )} + +happyReduce_514 = happySpecReduce_3 185# happyReduction_514 +happyReduction_514 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut202 happy_x_2 of { happy_var_2 -> + happyIn194 + (happy_var_2 + )} + +happyReduce_515 = happySpecReduce_1 186# happyReduction_515 +happyReduction_515 happy_x_1 + = case happyOut211 happy_x_1 of { happy_var_1 -> + happyIn195 + (happy_var_1 + )} + +happyReduce_516 = happySpecReduce_3 186# happyReduction_516 +happyReduction_516 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut202 happy_x_2 of { happy_var_2 -> + happyIn195 + (happy_var_2 + )} + +happyReduce_517 = happySpecReduce_1 187# happyReduction_517 +happyReduction_517 happy_x_1 + = case happyOut209 happy_x_1 of { happy_var_1 -> + happyIn196 + (happy_var_1 + )} + +happyReduce_518 = happySpecReduce_3 187# happyReduction_518 +happyReduction_518 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut207 happy_x_2 of { happy_var_2 -> + happyIn196 + (happy_var_2 + )} + +happyReduce_519 = happySpecReduce_1 188# happyReduction_519 +happyReduction_519 happy_x_1 + = case happyOut201 happy_x_1 of { happy_var_1 -> + happyIn197 + (happy_var_1 + )} + +happyReduce_520 = happySpecReduce_3 188# happyReduction_520 +happyReduction_520 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut206 happy_x_2 of { happy_var_2 -> + happyIn197 + (happy_var_2 + )} + +happyReduce_521 = happySpecReduce_1 189# happyReduction_521 +happyReduction_521 happy_x_1 + = case happyOut193 happy_x_1 of { happy_var_1 -> + happyIn198 + (VarOp happy_var_1 + )} + +happyReduce_522 = happySpecReduce_1 189# happyReduction_522 +happyReduction_522 happy_x_1 + = case happyOut196 happy_x_1 of { happy_var_1 -> + happyIn198 + (ConOp happy_var_1 + )} + +happyReduce_523 = happySpecReduce_1 190# happyReduction_523 +happyReduction_523 happy_x_1 + = case happyOut194 happy_x_1 of { happy_var_1 -> + happyIn199 + (QVarOp happy_var_1 + )} + +happyReduce_524 = happySpecReduce_1 190# happyReduction_524 +happyReduction_524 happy_x_1 + = case happyOut197 happy_x_1 of { happy_var_1 -> + happyIn199 + (QConOp happy_var_1 + )} + +happyReduce_525 = happySpecReduce_1 191# happyReduction_525 +happyReduction_525 happy_x_1 + = case happyOut195 happy_x_1 of { happy_var_1 -> + happyIn200 + (QVarOp happy_var_1 + )} + +happyReduce_526 = happySpecReduce_1 191# happyReduction_526 +happyReduction_526 happy_x_1 + = case happyOut197 happy_x_1 of { happy_var_1 -> + happyIn200 + (QConOp happy_var_1 + )} + +happyReduce_527 = happySpecReduce_1 192# happyReduction_527 +happyReduction_527 happy_x_1 + = happyIn201 + (list_cons_name + ) + +happyReduce_528 = happySpecReduce_1 192# happyReduction_528 +happyReduction_528 happy_x_1 + = case happyOut208 happy_x_1 of { happy_var_1 -> + happyIn201 + (happy_var_1 + )} + +happyReduce_529 = happySpecReduce_1 193# happyReduction_529 +happyReduction_529 happy_x_1 + = case happyOut204 happy_x_1 of { happy_var_1 -> + happyIn202 + (UnQual happy_var_1 + )} + +happyReduce_530 = happySpecReduce_1 193# happyReduction_530 +happyReduction_530 happy_x_1 + = case happyOutTok happy_x_1 of { (QVarId happy_var_1) -> + happyIn202 + (Qual (ModuleName (fst happy_var_1)) (Ident (snd happy_var_1)) + )} + +happyReduce_531 = happySpecReduce_1 194# happyReduction_531 +happyReduction_531 happy_x_1 + = case happyOutTok happy_x_1 of { (VarId happy_var_1) -> + happyIn203 + (Ident happy_var_1 + )} + +happyReduce_532 = happySpecReduce_1 194# happyReduction_532 +happyReduction_532 happy_x_1 + = happyIn203 + (as_name + ) + +happyReduce_533 = happySpecReduce_1 194# happyReduction_533 +happyReduction_533 happy_x_1 + = happyIn203 + (qualified_name + ) + +happyReduce_534 = happySpecReduce_1 194# happyReduction_534 +happyReduction_534 happy_x_1 + = happyIn203 + (hiding_name + ) + +happyReduce_535 = happySpecReduce_1 194# happyReduction_535 +happyReduction_535 happy_x_1 + = happyIn203 + (export_name + ) + +happyReduce_536 = happySpecReduce_1 194# happyReduction_536 +happyReduction_536 happy_x_1 + = happyIn203 + (stdcall_name + ) + +happyReduce_537 = happySpecReduce_1 194# happyReduction_537 +happyReduction_537 happy_x_1 + = happyIn203 + (ccall_name + ) + +happyReduce_538 = happySpecReduce_1 195# happyReduction_538 +happyReduction_538 happy_x_1 + = case happyOut203 happy_x_1 of { happy_var_1 -> + happyIn204 + (happy_var_1 + )} + +happyReduce_539 = happySpecReduce_1 195# happyReduction_539 +happyReduction_539 happy_x_1 + = happyIn204 + (safe_name + ) + +happyReduce_540 = happySpecReduce_1 195# happyReduction_540 +happyReduction_540 happy_x_1 + = happyIn204 + (unsafe_name + ) + +happyReduce_541 = happySpecReduce_1 195# happyReduction_541 +happyReduction_541 happy_x_1 + = happyIn204 + (threadsafe_name + ) + +happyReduce_542 = happySpecReduce_1 196# happyReduction_542 +happyReduction_542 happy_x_1 + = case happyOutTok happy_x_1 of { (IDupVarId happy_var_1) -> + happyIn205 + (IPDup happy_var_1 + )} + +happyReduce_543 = happySpecReduce_1 196# happyReduction_543 +happyReduction_543 happy_x_1 + = case happyOutTok happy_x_1 of { (ILinVarId happy_var_1) -> + happyIn205 + (IPLin happy_var_1 + )} + +happyReduce_544 = happySpecReduce_1 197# happyReduction_544 +happyReduction_544 happy_x_1 + = case happyOut207 happy_x_1 of { happy_var_1 -> + happyIn206 + (UnQual happy_var_1 + )} + +happyReduce_545 = happySpecReduce_1 197# happyReduction_545 +happyReduction_545 happy_x_1 + = case happyOutTok happy_x_1 of { (QConId happy_var_1) -> + happyIn206 + (Qual (ModuleName (fst happy_var_1)) (Ident (snd happy_var_1)) + )} + +happyReduce_546 = happySpecReduce_1 198# happyReduction_546 +happyReduction_546 happy_x_1 + = case happyOutTok happy_x_1 of { (ConId happy_var_1) -> + happyIn207 + (Ident happy_var_1 + )} + +happyReduce_547 = happySpecReduce_1 199# happyReduction_547 +happyReduction_547 happy_x_1 + = case happyOut209 happy_x_1 of { happy_var_1 -> + happyIn208 + (UnQual happy_var_1 + )} + +happyReduce_548 = happySpecReduce_1 199# happyReduction_548 +happyReduction_548 happy_x_1 + = case happyOutTok happy_x_1 of { (QConSym happy_var_1) -> + happyIn208 + (Qual (ModuleName (fst happy_var_1)) (Symbol (snd happy_var_1)) + )} + +happyReduce_549 = happySpecReduce_1 200# happyReduction_549 +happyReduction_549 happy_x_1 + = case happyOutTok happy_x_1 of { (ConSym happy_var_1) -> + happyIn209 + (Symbol happy_var_1 + )} + +happyReduce_550 = happySpecReduce_1 201# happyReduction_550 +happyReduction_550 happy_x_1 + = case happyOut212 happy_x_1 of { happy_var_1 -> + happyIn210 + (UnQual happy_var_1 + )} + +happyReduce_551 = happySpecReduce_1 201# happyReduction_551 +happyReduction_551 happy_x_1 + = case happyOut214 happy_x_1 of { happy_var_1 -> + happyIn210 + (happy_var_1 + )} + +happyReduce_552 = happySpecReduce_1 202# happyReduction_552 +happyReduction_552 happy_x_1 + = case happyOut213 happy_x_1 of { happy_var_1 -> + happyIn211 + (UnQual happy_var_1 + )} + +happyReduce_553 = happySpecReduce_1 202# happyReduction_553 +happyReduction_553 happy_x_1 + = case happyOut214 happy_x_1 of { happy_var_1 -> + happyIn211 + (happy_var_1 + )} + +happyReduce_554 = happySpecReduce_1 203# happyReduction_554 +happyReduction_554 happy_x_1 + = case happyOutTok happy_x_1 of { (VarSym happy_var_1) -> + happyIn212 + (Symbol happy_var_1 + )} + +happyReduce_555 = happySpecReduce_1 203# happyReduction_555 +happyReduction_555 happy_x_1 + = happyIn212 + (minus_name + ) + +happyReduce_556 = happySpecReduce_1 203# happyReduction_556 +happyReduction_556 happy_x_1 + = happyIn212 + (bang_name + ) + +happyReduce_557 = happySpecReduce_1 203# happyReduction_557 +happyReduction_557 happy_x_1 + = happyIn212 + (dot_name + ) + +happyReduce_558 = happySpecReduce_1 203# happyReduction_558 +happyReduction_558 happy_x_1 + = happyIn212 + (star_name + ) + +happyReduce_559 = happySpecReduce_1 204# happyReduction_559 +happyReduction_559 happy_x_1 + = case happyOutTok happy_x_1 of { (VarSym happy_var_1) -> + happyIn213 + (Symbol happy_var_1 + )} + +happyReduce_560 = happySpecReduce_1 204# happyReduction_560 +happyReduction_560 happy_x_1 + = happyIn213 + (bang_name + ) + +happyReduce_561 = happySpecReduce_1 204# happyReduction_561 +happyReduction_561 happy_x_1 + = happyIn213 + (dot_name + ) + +happyReduce_562 = happySpecReduce_1 204# happyReduction_562 +happyReduction_562 happy_x_1 + = happyIn213 + (star_name + ) + +happyReduce_563 = happySpecReduce_1 205# happyReduction_563 +happyReduction_563 happy_x_1 + = case happyOutTok happy_x_1 of { (QVarSym happy_var_1) -> + happyIn214 + (Qual (ModuleName (fst happy_var_1)) (Symbol (snd happy_var_1)) + )} + +happyReduce_564 = happySpecReduce_1 206# happyReduction_564 +happyReduction_564 happy_x_1 + = case happyOutTok happy_x_1 of { (IntTok happy_var_1) -> + happyIn215 + (Int happy_var_1 + )} + +happyReduce_565 = happySpecReduce_1 206# happyReduction_565 +happyReduction_565 happy_x_1 + = case happyOutTok happy_x_1 of { (Character happy_var_1) -> + happyIn215 + (Char happy_var_1 + )} + +happyReduce_566 = happySpecReduce_1 206# happyReduction_566 +happyReduction_566 happy_x_1 + = case happyOutTok happy_x_1 of { (FloatTok happy_var_1) -> + happyIn215 + (Frac happy_var_1 + )} + +happyReduce_567 = happySpecReduce_1 206# happyReduction_567 +happyReduction_567 happy_x_1 + = case happyOutTok happy_x_1 of { (StringTok happy_var_1) -> + happyIn215 + (String happy_var_1 + )} + +happyReduce_568 = happySpecReduce_1 206# happyReduction_568 +happyReduction_568 happy_x_1 + = case happyOutTok happy_x_1 of { (IntTokHash happy_var_1) -> + happyIn215 + (PrimInt happy_var_1 + )} + +happyReduce_569 = happySpecReduce_1 206# happyReduction_569 +happyReduction_569 happy_x_1 + = case happyOutTok happy_x_1 of { (WordTokHash happy_var_1) -> + happyIn215 + (PrimWord happy_var_1 + )} + +happyReduce_570 = happySpecReduce_1 206# happyReduction_570 +happyReduction_570 happy_x_1 + = case happyOutTok happy_x_1 of { (FloatTokHash happy_var_1) -> + happyIn215 + (PrimFloat happy_var_1 + )} + +happyReduce_571 = happySpecReduce_1 206# happyReduction_571 +happyReduction_571 happy_x_1 + = case happyOutTok happy_x_1 of { (DoubleTokHash happy_var_1) -> + happyIn215 + (PrimDouble happy_var_1 + )} + +happyReduce_572 = happySpecReduce_1 206# happyReduction_572 +happyReduction_572 happy_x_1 + = case happyOutTok happy_x_1 of { (CharacterHash happy_var_1) -> + happyIn215 + (PrimChar happy_var_1 + )} + +happyReduce_573 = happySpecReduce_1 206# happyReduction_573 +happyReduction_573 happy_x_1 + = case happyOutTok happy_x_1 of { (StringHash happy_var_1) -> + happyIn215 + (PrimString happy_var_1 + )} + +happyReduce_574 = happyMonadReduce 0# 207# happyReduction_574 +happyReduction_574 (happyRest) tk + = happyThen (( getSrcLoc) + ) (\r -> happyReturn (happyIn216 r)) + +happyReduce_575 = happyMonadReduce 0# 208# happyReduction_575 +happyReduction_575 (happyRest) tk + = happyThen (( pushCurrentContext {- >>= \x -> trace (show x) (return x) -}) + ) (\r -> happyReturn (happyIn217 r)) + +happyReduce_576 = happyMonadReduce 1# 209# happyReduction_576 +happyReduction_576 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (( return () {- >>= \x -> trace (show x ++ show x ++ show x) (return x) -}) + ) (\r -> happyReturn (happyIn218 r)) + +happyReduce_577 = happyMonadReduce 1# 209# happyReduction_577 +happyReduction_577 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen (( popContext {- >>= \x -> trace (show x ++ show x) (return x) -}) + ) (\r -> happyReturn (happyIn218 r)) + +happyReduce_578 = happySpecReduce_1 210# happyReduction_578 +happyReduction_578 happy_x_1 + = case happyOutTok happy_x_1 of { (ConId happy_var_1) -> + happyIn219 + (ModuleName happy_var_1 + )} + +happyReduce_579 = happySpecReduce_1 210# happyReduction_579 +happyReduction_579 happy_x_1 + = case happyOutTok happy_x_1 of { (QConId happy_var_1) -> + happyIn219 + (ModuleName (fst happy_var_1 ++ '.':snd happy_var_1) + )} + +happyReduce_580 = happySpecReduce_1 211# happyReduction_580 +happyReduction_580 happy_x_1 + = case happyOut191 happy_x_1 of { happy_var_1 -> + happyIn220 + (happy_var_1 + )} + +happyReduce_581 = happySpecReduce_1 212# happyReduction_581 +happyReduction_581 happy_x_1 + = case happyOut192 happy_x_1 of { happy_var_1 -> + happyIn221 + (happy_var_1 + )} + +happyReduce_582 = happySpecReduce_1 213# happyReduction_582 +happyReduction_582 happy_x_1 + = case happyOut204 happy_x_1 of { happy_var_1 -> + happyIn222 + (happy_var_1 + )} + +happyReduce_583 = happySpecReduce_3 214# happyReduction_583 +happyReduction_583 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut222 happy_x_2 of { happy_var_2 -> + happyIn223 + (UnQual happy_var_2 + )} + +happyReduce_584 = happySpecReduce_1 214# happyReduction_584 +happyReduction_584 happy_x_1 + = case happyOut224 happy_x_1 of { happy_var_1 -> + happyIn223 + (UnQual happy_var_1 + )} + +happyReduce_585 = happySpecReduce_1 215# happyReduction_585 +happyReduction_585 happy_x_1 + = case happyOutTok happy_x_1 of { (VarSym happy_var_1) -> + happyIn224 + (Symbol happy_var_1 + )} + +happyNewToken action sts stk + = lexer(\tk -> + let cont i = happyDoAction i tk action sts stk in + case tk of { + EOF -> happyDoAction 133# 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#; + IntTokHash happy_dollar_dollar -> cont 16#; + WordTokHash happy_dollar_dollar -> cont 17#; + FloatTokHash happy_dollar_dollar -> cont 18#; + DoubleTokHash happy_dollar_dollar -> cont 19#; + CharacterHash happy_dollar_dollar -> cont 20#; + StringHash happy_dollar_dollar -> cont 21#; + LeftParen -> cont 22#; + RightParen -> cont 23#; + LeftHashParen -> cont 24#; + RightHashParen -> cont 25#; + LeftCurlyBar -> cont 26#; + RightCurlyBar -> cont 27#; + SemiColon -> cont 28#; + LeftCurly -> cont 29#; + RightCurly -> cont 30#; + VRightCurly -> cont 31#; + LeftSquare -> cont 32#; + RightSquare -> cont 33#; + Comma -> cont 34#; + Underscore -> cont 35#; + BackQuote -> cont 36#; + Dot -> cont 37#; + DotDot -> cont 38#; + Colon -> cont 39#; + DoubleColon -> cont 40#; + Equals -> cont 41#; + Backslash -> cont 42#; + Bar -> cont 43#; + LeftArrow -> cont 44#; + RightArrow -> cont 45#; + At -> cont 46#; + Tilde -> cont 47#; + DoubleArrow -> cont 48#; + Minus -> cont 49#; + Exclamation -> cont 50#; + Star -> cont 51#; + LeftArrowTail -> cont 52#; + RightArrowTail -> cont 53#; + LeftDblArrowTail -> cont 54#; + RightDblArrowTail -> cont 55#; + RPGuardOpen -> cont 56#; + RPGuardClose -> cont 57#; + RPCAt -> cont 58#; + THIdEscape happy_dollar_dollar -> cont 59#; + THParenEscape -> cont 60#; + THExpQuote -> cont 61#; + THPatQuote -> cont 62#; + THTypQuote -> cont 63#; + THDecQuote -> cont 64#; + THCloseQuote -> cont 65#; + THVarQuote -> cont 66#; + THTyQuote -> cont 67#; + THQuasiQuote happy_dollar_dollar -> cont 68#; + XPCDATA happy_dollar_dollar -> cont 69#; + XStdTagOpen -> cont 70#; + XCloseTagOpen -> cont 71#; + XCodeTagOpen -> cont 72#; + XStdTagClose -> cont 73#; + XEmptyTagClose -> cont 74#; + XCodeTagClose -> cont 75#; + XRPatOpen -> cont 76#; + XRPatClose -> cont 77#; + KW_Foreign -> cont 78#; + KW_Export -> cont 79#; + KW_Safe -> cont 80#; + KW_Unsafe -> cont 81#; + KW_Threadsafe -> cont 82#; + KW_StdCall -> cont 83#; + KW_CCall -> cont 84#; + KW_As -> cont 85#; + KW_By -> cont 86#; + KW_Case -> cont 87#; + KW_Class -> cont 88#; + KW_Data -> cont 89#; + KW_Default -> cont 90#; + KW_Deriving -> cont 91#; + KW_Do -> cont 92#; + KW_Else -> cont 93#; + KW_Family -> cont 94#; + KW_Forall -> cont 95#; + KW_Group -> cont 96#; + KW_Hiding -> cont 97#; + KW_If -> cont 98#; + KW_Import -> cont 99#; + KW_In -> cont 100#; + KW_Infix -> cont 101#; + KW_InfixL -> cont 102#; + KW_InfixR -> cont 103#; + KW_Instance -> cont 104#; + KW_Let -> cont 105#; + KW_MDo -> cont 106#; + KW_Module -> cont 107#; + KW_NewType -> cont 108#; + KW_Of -> cont 109#; + KW_Proc -> cont 110#; + KW_Rec -> cont 111#; + KW_Then -> cont 112#; + KW_Type -> cont 113#; + KW_Using -> cont 114#; + KW_Where -> cont 115#; + KW_Qualified -> cont 116#; + INLINE happy_dollar_dollar -> cont 117#; + SPECIALISE -> cont 118#; + SPECIALISE_INLINE happy_dollar_dollar -> cont 119#; + SOURCE -> cont 120#; + RULES -> cont 121#; + CORE -> cont 122#; + SCC -> cont 123#; + GENERATED -> cont 124#; + DEPRECATED -> cont 125#; + WARNING -> cont 126#; + UNPACK -> cont 127#; + OPTIONS happy_dollar_dollar -> cont 128#; + CFILES happy_dollar_dollar -> cont 129#; + INCLUDE happy_dollar_dollar -> cont 130#; + LANGUAGE -> cont 131#; + PragmaEnd -> cont 132#; + _ -> 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 + +mparseModule = happySomeParser where + happySomeParser = happyThen (happyParse 0#) (\x -> happyReturn (happyOut9 x)) + +mparseExp = happySomeParser where + happySomeParser = happyThen (happyParse 1#) (\x -> happyReturn (happyOut134 x)) + +mparsePat = happySomeParser where + happySomeParser = happyThen (happyParse 2#) (\x -> happyReturn (happyOut178 x)) + +mparseDecl = happySomeParser where + happySomeParser = happyThen (happyParse 3#) (\x -> happyReturn (happyOut45 x)) + +mparseType = happySomeParser where + happySomeParser = happyThen (happyParse 4#) (\x -> happyReturn (happyOut81 x)) + +mfindOptPragmas = happySomeParser where + happySomeParser = happyThen (happyParse 5#) (\x -> happyReturn (happyOut11 x)) + +happySeq = happyDontSeq + + +happyError :: P a +happyError = fail "Parse error" + +-- | Parse of a string, which should contain a complete Haskell module. +parseModule :: String -> ParseResult Module +parseModule = fmap (applyFixities preludeFixities) . runParser mparseModule + +-- | Parse of a string, which should contain a complete Haskell 98 module. +parseModuleWithMode :: ParseMode -> String -> ParseResult Module +parseModuleWithMode mode = fmap (applyFixities (fixities mode)) . runParserWithMode mode mparseModule + +-- | Parse of a string containing a Haskell expression. +parseExp :: String -> ParseResult Exp +parseExp = fmap (applyFixities preludeFixities) . runParser mparseExp + +-- | Parse of a string, which should contain a complete Haskell 98 module. +parseExpWithMode :: ParseMode -> String -> ParseResult Exp +parseExpWithMode mode = fmap (applyFixities (fixities mode)) . runParserWithMode mode mparseExp + +-- | Parse of a string containing a Haskell pattern. +parsePat :: String -> ParseResult Pat +parsePat = fmap (applyFixities preludeFixities) . runParser mparsePat + +-- | Parse of a string, which should contain a complete Haskell 98 module. +parsePatWithMode :: ParseMode -> String -> ParseResult Pat +parsePatWithMode mode = fmap (applyFixities (fixities mode)) . runParserWithMode mode mparsePat + +-- | Parse of a string containing a Haskell top-level declaration. +parseDecl :: String -> ParseResult Decl +parseDecl = fmap (applyFixities preludeFixities) . runParser mparseDecl + +-- | Parse of a string, which should contain a complete Haskell 98 module. +parseDeclWithMode :: ParseMode -> String -> ParseResult Decl +parseDeclWithMode mode = fmap (applyFixities (fixities mode)) . runParserWithMode mode mparseDecl + +-- | Parse of a string containing a Haskell type. +parseType :: String -> ParseResult Type +parseType = runParser mparseType + +-- | Parse of a string, which should contain a complete Haskell 98 module. +parseTypeWithMode :: ParseMode -> String -> ParseResult Type +parseTypeWithMode mode = runParserWithMode mode mparseType + +-- | Parse of a string starting with a series of top-level option pragmas. +getTopPragmas :: String -> ParseResult [OptionPragma] +getTopPragmas = runParser mfindOptPragmas + +-- | Class to reuse the parse function at many different types +class Parseable ast where + parse :: String -> ParseResult ast + parseWithMode :: ParseMode -> String -> ParseResult ast +instance Parseable Module where + parse = parseModule + parseWithMode = parseModuleWithMode +instance Parseable Exp where + parse = parseExp + parseWithMode = parseExpWithMode +instance Parseable Pat where + parse = parsePat + parseWithMode = parsePatWithMode +instance Parseable Decl where + parse = parseDecl + parseWithMode = parseDeclWithMode +instance Parseable Type where + parse = parseType + parseWithMode = parseTypeWithMode +{-# 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 Happy_GHC_Exts.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 Happy_GHC_Exts.<# (0# :: Happy_GHC_Exts.Int#)) -> {- nothing -} + + (happyReduceArr Happy_Data_Array.! rule) i tk st + where rule = (Happy_GHC_Exts.I# ((Happy_GHC_Exts.negateInt# ((n Happy_GHC_Exts.+# (1# :: Happy_GHC_Exts.Int#)))))) + n -> {- nothing -} + + + happyShift new_state i tk st + where new_state = (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) + where off = indexShortOffAddr happyActOffsets st + off_i = (off Happy_GHC_Exts.+# i) + check = if (off_i Happy_GHC_Exts.>=# (0# :: Happy_GHC_Exts.Int#)) + then (indexShortOffAddr happyCheck off_i Happy_GHC_Exts.==# 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 + Happy_GHC_Exts.narrow16Int# i +#elif __GLASGOW_HASKELL__ == 500 + Happy_GHC_Exts.intToInt16# i +#else + Happy_GHC_Exts.iShiftRA# (Happy_GHC_Exts.iShiftL# i 16#) 16# +#endif + where +#if __GLASGOW_HASKELL__ >= 503 + i = Happy_GHC_Exts.word2Int# (Happy_GHC_Exts.or# (Happy_GHC_Exts.uncheckedShiftL# high 8#) low) +#else + i = Happy_GHC_Exts.word2Int# (Happy_GHC_Exts.or# (Happy_GHC_Exts.shiftL# high 8#) low) +#endif + high = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr (off' Happy_GHC_Exts.+# 1#))) + low = Happy_GHC_Exts.int2Word# (Happy_GHC_Exts.ord# (Happy_GHC_Exts.indexCharOffAddr# arr off')) + off' = off Happy_GHC_Exts.*# 2# + + + + + +data HappyAddr = HappyA# Happy_GHC_Exts.Addr# + + + + +----------------------------------------------------------------------------- +-- HappyState data type (not arrays) + +{-# LINE 170 "templates\\GenericTemplate.hs" #-} + +----------------------------------------------------------------------------- +-- Shifting a token + +happyShift new_state 0# tk st sts stk@(x `HappyStk` _) = + let i = (case Happy_GHC_Exts.unsafeCoerce# x of { (Happy_GHC_Exts.I# (i)) -> i }) in +-- trace "shifting the error token" $ + happyDoAction i tk new_state (HappyCons (st) (sts)) (stk) + +happyShift new_state i tk st sts stk = + happyNewToken new_state (HappyCons (st) (sts)) ((happyInTok (tk))`HappyStk`stk) + +-- happyReduce is specialised for the common cases. + +happySpecReduce_0 i fn 0# tk st sts stk + = happyFail 0# tk st sts stk +happySpecReduce_0 nt fn j tk st@((action)) sts stk + = happyGoto nt j tk st (HappyCons (st) (sts)) (fn `HappyStk` stk) + +happySpecReduce_1 i fn 0# tk st sts stk + = happyFail 0# tk st sts stk +happySpecReduce_1 nt fn j tk _ sts@((HappyCons (st@(action)) (_))) (v1`HappyStk`stk') + = let r = fn v1 in + happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) + +happySpecReduce_2 i fn 0# tk st sts stk + = happyFail 0# tk st sts stk +happySpecReduce_2 nt fn j tk _ (HappyCons (_) (sts@((HappyCons (st@(action)) (_))))) (v1`HappyStk`v2`HappyStk`stk') + = let r = fn v1 v2 in + happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) + +happySpecReduce_3 i fn 0# tk st sts stk + = happyFail 0# tk st sts stk +happySpecReduce_3 nt fn j tk _ (HappyCons (_) ((HappyCons (_) (sts@((HappyCons (st@(action)) (_))))))) (v1`HappyStk`v2`HappyStk`v3`HappyStk`stk') + = let r = fn v1 v2 v3 in + happySeq r (happyGoto nt j tk st sts (r `HappyStk` stk')) + +happyReduce k i fn 0# tk st sts stk + = happyFail 0# tk st sts stk +happyReduce k nt fn j tk st sts stk + = case happyDrop (k Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) sts of + sts1@((HappyCons (st1@(action)) (_))) -> + let r = fn stk in -- it doesn't hurt to always seq here... + happyDoSeq r (happyGoto nt j tk st1 sts1 r) + +happyMonadReduce k nt fn 0# tk st sts stk + = happyFail 0# tk st sts stk +happyMonadReduce k nt fn j tk st sts stk = + 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 Happy_GHC_Exts.+# nt) + new_state = indexShortOffAddr happyTable off_i + + + + +happyDrop 0# l = l +happyDrop n (HappyCons (_) (t)) = happyDrop (n Happy_GHC_Exts.-# (1# :: Happy_GHC_Exts.Int#)) t + +happyDropStk 0# l = l +happyDropStk n (x `HappyStk` xs) = happyDropStk (n Happy_GHC_Exts.-# (1#::Happy_GHC_Exts.Int#)) xs + +----------------------------------------------------------------------------- +-- Moving to a new state after a reduction + + +happyGoto nt j tk st = + {- nothing -} + happyDoAction j tk new_state + where off = indexShortOffAddr happyGotoOffsets st + off_i = (off Happy_GHC_Exts.+# nt) + new_state = indexShortOffAddr happyTable off_i + + + + +----------------------------------------------------------------------------- +-- Error recovery (0# is the error token) + +-- parse error if we are in recovery and we fail again +happyFail 0# tk old_st _ stk = +-- 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 ( (Happy_GHC_Exts.unsafeCoerce# (Happy_GHC_Exts.I# (i))) `HappyStk` stk) + +-- Internal happy errors: + +notHappyAtAll = error "Internal Happy error\n" + +----------------------------------------------------------------------------- +-- Hack to get the typechecker to accept our action functions + + +happyTcHack :: Happy_GHC_Exts.Int# -> a -> a happyTcHack x y = y {-# INLINE happyTcHack #-} diff --git a/haskell-src-exts.cabal b/haskell-src-exts.cabal --- a/haskell-src-exts.cabal +++ b/haskell-src-exts.cabal @@ -1,5 +1,5 @@ Name: haskell-src-exts -Version: 0.4.8 +Version: 0.5.2 License: BSD3 License-File: LICENSE Author: Niklas Broberg @@ -8,7 +8,7 @@ Synopsis: Manipulating Haskell source: abstract syntax, lexer, parser, and pretty-printer Description: Haskell-Source with Extensions (HSE, haskell-src-exts) is an extension of the standard haskell-src package, - and handles most common syntactic extensions to Haskell, including: + and handles most registered syntactic extensions to Haskell, including: . * Multi-parameter type classes with functional dependencies . @@ -22,26 +22,38 @@ . * Template Haskell . - and a few more. Apart from these standard extensions, + and a few more. All extensions implemented in GHC are supported. + Apart from these standard extensions, it also handles regular patterns as per the HaRP extension as well as HSX-style embedded XML syntax. . For details on usage, please see the website. Homepage: http://www.cs.chalmers.se/~d00nibro/haskell-src-exts/ Stability: Stable -Tested-with: GHC==6.10.1 -Build-Type: Simple +Tested-with: GHC==6.10.2 +Build-Type: Custom Cabal-Version: >= 1.2 +Flag base4 + Library Build-Tools: happy >= 1.17 - Build-Depends: base >= 4, array >= 0.1, pretty >= 1.0, cpphs >= 1.3 + Build-Depends: array >= 0.1, pretty >= 1.0, cpphs >= 1.3 + if flag(base4) + Build-depends: base >= 4 && < 5 + cpp-options: -DBASE4 + else + Build-depends: base >= 3 && < 4 + Exposed-modules: Language.Haskell.Exts, Language.Haskell.Exts.Parser, Language.Haskell.Exts.Pretty, Language.Haskell.Exts.Syntax, - Language.Haskell.Exts.Build + Language.Haskell.Exts.Extension, + Language.Haskell.Exts.Build, + Language.Haskell.Exts.Fixity Other-modules: Language.Haskell.Exts.ParseMonad, Language.Haskell.Exts.Lexer, Language.Haskell.Exts.ParseUtils + Hs-source-dirs: src diff --git a/src/Language/Haskell/Exts.hs b/src/Language/Haskell/Exts.hs new file mode 100644 --- /dev/null +++ b/src/Language/Haskell/Exts.hs @@ -0,0 +1,63 @@ +module Language.Haskell.Exts ( + module Language.Haskell.Exts.Syntax + , module Language.Haskell.Exts.Build + , module Language.Haskell.Exts.Parser + , module Language.Haskell.Exts.Pretty + , module Language.Haskell.Exts.Extension + , module Language.Haskell.Exts.Fixity + , parseFileContents + , parseFileContentsWithMode + , parseFile + , parseFileWithExts + , readExtensions + ) where + +import Language.Haskell.Exts.Build +import Language.Haskell.Exts.Syntax +import Language.Haskell.Exts.Parser +import Language.Haskell.Exts.Pretty +import Language.Haskell.Exts.Extension +import Language.Haskell.Exts.Fixity + +import Data.List +import Language.Preprocessor.Unlit + +parseFile :: FilePath -> IO (ParseResult Module) +parseFile fp = do + fc <- readFile fp + let md = delit fp $ ppContents fc + exts = case readExtensions md of + Just exts -> exts + Nothing -> [] + return $ parseModuleWithMode (ParseMode fp exts preludeFixities) md + +parseFileWithExts :: [Extension] -> FilePath -> IO (ParseResult Module) +parseFileWithExts exts fp = parseFileWithMode (ParseMode fp exts preludeFixities) fp + +parseFileWithMode :: ParseMode -> FilePath -> IO (ParseResult Module) +parseFileWithMode p fp = readFile fp >>= (return . parseFileContentsWithMode p) + +parseFileContents :: String -> ParseResult Module +parseFileContents = parseFileContentsWithMode defaultParseMode + +parseFileContentsWithMode :: ParseMode -> String -> ParseResult Module +parseFileContentsWithMode p rawStr = parseModuleWithMode p (delit filename $ ppContents rawStr) + where filename = parseFilename p + +readExtensions :: String -> Maybe [Extension] +readExtensions str = case getTopPragmas str of + ParseOk pgms -> Just (concatMap getExts pgms) + _ -> Nothing + where getExts :: OptionPragma -> [Extension] + getExts (LanguagePragma _ ns) = map readExt ns + getExts _ = [] + + readExt (Ident e) = read e + +ppContents :: String -> String +ppContents = unlines . map f . lines + where f ('#':_) = "" + f x = x + +delit :: String -> String -> String +delit fn = if ".lhs" `isSuffixOf` fn then unlit fn else id diff --git a/src/Language/Haskell/Exts/Build.hs b/src/Language/Haskell/Exts/Build.hs new file mode 100644 --- /dev/null +++ b/src/Language/Haskell/Exts/Build.hs @@ -0,0 +1,235 @@ +----------------------------------------------------------------------------- +-- | +-- Module : Language.Haskell.Exts.Build +-- 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 +-- +----------------------------------------------------------------------------- + +-- This module badly needs Haddock documentation. +module Language.Haskell.Exts.Build ( + + -- * Syntax building functions + name, -- :: String -> Name + sym, -- :: String -> Name + var, -- :: Name -> Exp + op, -- :: Name -> QOp + qvar, -- :: Module -> Name -> Exp + pvar, -- :: Name -> Pat + app, -- :: Exp -> Exp -> Exp + infixApp, -- :: Exp -> QOp -> Exp -> Exp + appFun, -- :: Exp -> [Exp] -> Exp + pApp, -- :: Name -> [Pat] -> Pat + tuple, -- :: [Exp] -> Exp + pTuple, -- :: [Pat] -> Pat + varTuple, -- :: [Name] -> Exp + pvarTuple, -- :: [Name] -> Pat + function, -- :: String -> Exp + strE, -- :: String -> Exp + charE, -- :: Char -> Exp + intE, -- :: Integer -> Exp + strP, -- :: String -> Pat + charP, -- :: Char -> Pat + intP, -- :: Integer -> Pat + doE, -- :: [Stmt] -> Exp + lamE, -- :: SrcLoc -> [Pat] -> Exp -> Exp + letE, -- :: [Decl] -> Exp -> Exp + caseE, -- :: Exp -> [Alt] -> Exp + alt, -- :: SrcLoc -> Pat -> Exp -> Alt + altGW, -- :: SrcLoc -> Pat -> [Stmt] -> Exp -> Binds -> Alt + listE, -- :: [Exp] -> Exp + eList, -- :: Exp + peList, -- :: Pat + paren, -- :: Exp -> Exp + pParen, -- :: Pat -> Pat + qualStmt, -- :: Exp -> Stmt + genStmt, -- :: SrcLoc -> Pat -> Exp -> Stmt + letStmt, -- :: [Decl] -> Stmt + binds, -- :: [Decl] -> Binds + noBinds, -- :: Binds + wildcard, -- :: Pat + genNames, -- :: String -> Int -> [Name] + + -- * More advanced building + sfun, -- :: SrcLoc -> Name -> [Name] -> Rhs -> Binds -> Decl + simpleFun, -- :: SrcLoc -> Name -> Name -> Exp -> Decl + patBind, -- :: SrcLoc -> Pat -> Exp -> Decl + patBindWhere, -- :: SrcLoc -> Pat -> Exp -> [Decl] -> Decl + nameBind, -- :: SrcLoc -> Name -> Exp -> Decl + metaFunction, -- :: String -> [Exp] -> Exp + metaConPat -- :: String -> [Pat] -> Pat + ) where + +import Language.Haskell.Exts.Syntax + +----------------------------------------------------------------------------- +-- Help functions for Abstract syntax + +name :: String -> Name +name = Ident + +sym :: String -> Name +sym = Symbol + +var :: Name -> Exp +var = Var . UnQual + +op :: Name -> QOp +op = QVarOp . UnQual + +qvar :: ModuleName -> Name -> Exp +qvar m n = Var $ Qual m n + +pvar :: Name -> Pat +pvar = PVar + +app :: Exp -> Exp -> Exp +app = App + +infixApp :: Exp -> QOp -> Exp -> Exp +infixApp = InfixApp + +appFun :: Exp -> [Exp] -> Exp +appFun f [] = f +appFun f (a:as) = appFun (app f a) as + +pApp :: Name -> [Pat] -> Pat +pApp n ps = PApp (UnQual n) ps + +tuple :: [Exp] -> Exp +tuple = Tuple + +pTuple :: [Pat] -> Pat +pTuple = PTuple + +varTuple :: [Name] -> Exp +varTuple ns = tuple $ map var ns + +pvarTuple :: [Name] -> Pat +pvarTuple ns = pTuple $ map pvar ns + +function :: String -> Exp +function = var . Ident + +strE :: String -> Exp +strE = Lit . String + +charE :: Char -> Exp +charE = Lit . Char + +intE :: Integer -> Exp +intE = Lit . Int + +strP :: String -> Pat +strP = PLit . String + +charP :: Char -> Pat +charP = PLit . Char + +intP :: Integer -> Pat +intP = PLit . Int + +doE :: [Stmt] -> Exp +doE = Do + +lamE :: SrcLoc -> [Pat] -> Exp -> Exp +lamE = Lambda + +letE :: [Decl] -> Exp -> Exp +letE ds e = Let (binds ds) e + +caseE :: Exp -> [Alt] -> Exp +caseE = Case + +alt :: SrcLoc -> Pat -> Exp -> Alt +alt s p e = Alt s p (UnGuardedAlt e) noBinds + +altGW :: SrcLoc -> Pat -> [Stmt] -> Exp -> Binds -> Alt +altGW s p gs e w = Alt s p (gAlt s gs e) w + +unGAlt :: Exp -> GuardedAlts +unGAlt = UnGuardedAlt + +gAlts :: SrcLoc -> [([Stmt],Exp)] -> GuardedAlts +gAlts s as = GuardedAlts $ map (\(gs,e) -> GuardedAlt s gs e) as + +gAlt :: SrcLoc -> [Stmt] -> Exp -> GuardedAlts +gAlt s gs e = gAlts s [(gs,e)] + +listE :: [Exp] -> Exp +listE = List + +eList :: Exp +eList = List [] + +peList :: Pat +peList = PList [] + +paren :: Exp -> Exp +paren = Paren + +pParen :: Pat -> Pat +pParen = PParen + +qualStmt :: Exp -> Stmt +qualStmt = Qualifier + +genStmt :: SrcLoc -> Pat -> Exp -> Stmt +genStmt = Generator + +letStmt :: [Decl] -> Stmt +letStmt ds = LetStmt $ binds ds + +binds :: [Decl] -> Binds +binds = BDecls + +noBinds :: Binds +noBinds = binds [] + +wildcard :: Pat +wildcard = PWildCard + +genNames :: String -> Int -> [Name] +genNames s k = [ Ident $ s ++ show i | i <- [1..k] ] + +------------------------------------------------------------------------------- +-- Some more specialised help functions + +-- | A function with a single "match" +sfun :: SrcLoc -> Name -> [Name] -> Rhs -> Binds -> Decl +sfun s f pvs rhs bs = FunBind [Match s f (map pvar pvs) Nothing rhs bs] + +-- | A function with a single "match", a single argument, no guards +-- and no where declarations +simpleFun :: SrcLoc -> Name -> Name -> Exp -> Decl +simpleFun s f a e = let rhs = UnGuardedRhs 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 -> Pat -> Exp -> Decl +patBind s p e = let rhs = UnGuardedRhs e + in PatBind s p Nothing rhs noBinds + +patBindWhere :: SrcLoc -> Pat -> Exp -> [Decl] -> Decl +patBindWhere s p e ds = let rhs = UnGuardedRhs e + in PatBind s p Nothing rhs (binds ds) + +nameBind :: SrcLoc -> Name -> Exp -> Decl +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 -> [Exp] -> Exp +metaFunction s es = mf s (reverse es) + where mf s [] = var $ name s + mf s (e:es) = app (mf s es) e + + +metaConPat :: String -> [Pat] -> Pat +metaConPat s ps = pApp (name s) ps diff --git a/src/Language/Haskell/Exts/Extension.hs b/src/Language/Haskell/Exts/Extension.hs new file mode 100644 --- /dev/null +++ b/src/Language/Haskell/Exts/Extension.hs @@ -0,0 +1,120 @@ +{- + This module is a temporary fix to use until Cabal + supports XmlSyntax and RegularPatterns. +-} + +module Language.Haskell.Exts.Extension ( + + Extension(..), + + ExtScheme(..), Enabled(..) + + ) where + +-- We want to import this list from cabal, but we're waiting for a version +-- with the xml-syntax and regular-patterns patch to be applied. +-- import Language.Haskell.Extension + +{- This datatype should be imported from Cabal instead. -} +data Extension + = OverlappingInstances + | UndecidableInstances + | IncoherentInstances + | RecursiveDo + | ParallelListComp + | MultiParamTypeClasses + | NoMonomorphismRestriction + | FunctionalDependencies + | Rank2Types + | RankNTypes + | PolymorphicComponents + | ExistentialQuantification + | ScopedTypeVariables + | ImplicitParams + | FlexibleContexts + | FlexibleInstances + | EmptyDataDecls + | CPP + + | KindSignatures + | BangPatterns + | TypeSynonymInstances + | TemplateHaskell + | ForeignFunctionInterface + | Arrows + | Generics + | NoImplicitPrelude + | NamedFieldPuns + | PatternGuards + | GeneralizedNewtypeDeriving + + | ExtensibleRecords + | RestrictedTypeSynonyms + | HereDocuments + | MagicHash + | TypeFamilies + | StandaloneDeriving + + | UnicodeSyntax + | PatternSignatures + | UnliftedFFITypes + | LiberalTypeSynonyms + | TypeOperators +--PArr -- not ready yet, and will probably be renamed to ParallelArrays + | RecordWildCards + | RecordPuns + | DisambiguateRecordFields + | OverloadedStrings + | GADTs + | MonoPatBinds + | RelaxedPolyRec + | ExtendedDefaultRules + | UnboxedTuples + | DeriveDataTypeable + | ConstrainedClassMethods + + -- | Allow imports to be qualified by the package name that the module + -- is intended to be imported from, e.g. + -- + -- > import "network" Network.Socket + | PackageImports + + | ImpredicativeTypes + | NewQualifiedOperators + | PostfixOperators + | QuasiQuotes + | TransformListComp + | ViewPatterns + + -- | Allow concrete XML syntax to be used in expressions and patterns, + -- as per the Haskell Server Pages extension language: + -- . The ideas behind it are + -- discussed in the paper "Haskell Server Pages through Dynamic Loading" + -- by Niklas Broberg, from Haskell Workshop '05. + | XmlSyntax + + -- | Allow regular pattern matching over lists, as discussed in the + -- paper "Regular Expression Patterns" by Niklas Broberg, Andreas Farre + -- and Josef Svenningsson, from ICFP '04. + | RegularPatterns + deriving (Eq, Show, Read) +-- -} + +data ExtScheme = Any [Extension] | All [Extension] + deriving (Eq,Show) + +type MExtScheme = Maybe ExtScheme + +class Enabled a where + isEnabled :: a -> [Extension] -> Bool + +instance Enabled Extension where + isEnabled = elem + +instance Enabled ExtScheme where + isEnabled (Any exts) enabled = any (`elem` enabled) exts + isEnabled (All exts) enabled = all (`elem` enabled) exts + +instance Enabled a => Enabled (Maybe a) where + isEnabled Nothing = const True + isEnabled (Just a) = isEnabled a diff --git a/src/Language/Haskell/Exts/Fixity.hs b/src/Language/Haskell/Exts/Fixity.hs new file mode 100644 --- /dev/null +++ b/src/Language/Haskell/Exts/Fixity.hs @@ -0,0 +1,287 @@ +module Language.Haskell.Exts.Fixity where + +import Language.Haskell.Exts.Syntax + +import Data.Char (isUpper) + +------------------------------------------------------------ +-- + +data Fixity = Fixity Assoc Int Op + +class AppFixity ast where + applyFixities :: [Fixity] -> ast -> ast + + +instance AppFixity Exp where + -- This is the real meat case. We can assume a left-associative list to begin with. + applyFixities fixs (InfixApp a op2 z) = + let e = applyFixities fixs a + in case e of + InfixApp x op1 y -> + let (a1,p1) = askFixity fixs op1 + (a2,p2) = askFixity fixs op2 + in if (p1 == p2 && (a1 /= a2 || a1 == AssocNone)) -- Ambiguous infix expression! + || (p1 > p2 || p1 == p2 && (a1 == AssocLeft || a2 == AssocNone)) -- Already right order + then InfixApp e op2 z + else InfixApp x op1 (applyFixities fixs $ InfixApp y op2 z) + _ -> InfixApp e op2 z + -- the boilerplate + applyFixities fixs e = appFixExp fixs e + +askFixity :: [Fixity] -> QOp -> (Assoc, Int) +askFixity xs = \k -> lookupWithDefault (AssocLeft, 9) (f k) mp + where + lookupWithDefault def k mp = case lookup k mp of + Nothing -> def + Just x -> x + + mp = [(x,(a,p)) | Fixity a p x <- xs] + + f (QVarOp x) = VarOp (g x) + f (QConOp x) = ConOp (g x) + + g (Qual _ x) = x + g (UnQual x) = x + g (Special Cons) = Symbol ":" + + +preludeFixities :: [Fixity] +preludeFixities = concat + [infixr_ 9 ["."] + ,infixl_ 9 ["!!"] + ,infixr_ 8 ["^","^^","**"] + ,infixl_ 7 ["*","/","`quot`","`rem`","`div`","`mod`",":%","%"] + ,infixl_ 6 ["+","-"] + ,infixr_ 5 [":","++"] + ,infix_ 4 ["==","/=","<","<=",">=",">","`elem`","`notElem`"] + ,infixr_ 3 ["&&"] + ,infixr_ 2 ["||"] + ,infixl_ 1 [">>",">>="] + ,infixr_ 1 ["=<<"] + ,infixr_ 0 ["$","$!","`seq`"] + ] + +baseFixities :: [Fixity] +baseFixities = preludeFixities ++ concat + [infixl_ 9 ["!","//","!:"] + ,infixl_ 8 ["`shift`","`rotate`","`shiftL`","`shiftR`","`rotateL`","`rotateR`"] + ,infixl_ 7 [".&."] + ,infixl_ 6 ["`xor`"] + ,infix_ 6 [":+"] + ,infixl_ 5 [".|."] + ,infixr_ 5 ["+:+","<++","<+>"] -- fixity conflict for +++ between ReadP and Arrow + ,infix_ 5 ["\\\\"] + ,infixl_ 4 ["<$>","<$","<*>","<*","*>","<**>"] + ,infix_ 4 ["`elemP`","`notElemP`"] + ,infixl_ 3 ["<|>"] + ,infixr_ 3 ["&&&","***"] + ,infixr_ 2 ["+++","|||"] + ,infixr_ 1 ["<=<",">=>",">>>","<<<","^<<","<<^","^>>",">>^"] + ,infixl_ 0 ["`on`"] + ,infixr_ 0 ["`par`","`pseq`"] + ] + + +infixr_ = fixity AssocRight +infixl_ = fixity AssocLeft +infix_ = fixity AssocNone + +fixity :: Assoc -> Int -> [String] -> [Fixity] +fixity a p = map (Fixity a p . op) + where + op ('`':xs) = (if isUpper (head xs) then ConOp else VarOp) $ Ident $ init xs + op xs = (if head xs == ':' then ConOp else VarOp) $ Symbol xs + + + + + + +------------------------------------------------------------------- +-- Boilerplate - yuck!! + +instance AppFixity Module where + applyFixities fixs (Module loc n prs mwt ext imp decls) = + Module loc n prs mwt ext imp $ appFixDecls fixs decls + +instance AppFixity Decl where + applyFixities fixs decl = case decl of + ClassDecl loc ctxt n vars deps cdecls -> ClassDecl loc ctxt n vars deps $ map fix cdecls + InstDecl loc ctxt n ts idecls -> InstDecl loc ctxt n ts $ map fix idecls + SpliceDecl loc spl -> SpliceDecl loc $ fix spl + FunBind matches -> FunBind $ map fix matches + PatBind loc p mt rhs bs -> PatBind loc (fix p) mt (fix rhs) (fix bs) + _ -> decl + where fix x = applyFixities fixs x + +appFixDecls :: [Fixity] -> [Decl] -> [Decl] +appFixDecls fixs decls = + let extraFixs = getFixities decls + in map (applyFixities (fixs++extraFixs)) decls + where getFixities = concatMap getFixity + getFixity (InfixDecl _ a p ops) = map (Fixity a p) ops + getFixity _ = [] + +instance AppFixity ClassDecl where + applyFixities fixs (ClsDecl decl) = ClsDecl $ applyFixities fixs decl + applyFixities _ cdecl = cdecl + +instance AppFixity InstDecl where + applyFixities fixs (InsDecl decl) = InsDecl $ applyFixities fixs decl + applyFixities _ idecl = idecl + +instance AppFixity Match where + applyFixities fixs (Match loc n ps mt rhs bs) = Match loc n (map fix ps) mt (fix rhs) (fix bs) + where fix x = applyFixities fixs x + +instance AppFixity Rhs where + applyFixities fixs rhs = case rhs of + UnGuardedRhs e -> UnGuardedRhs $ fix e + GuardedRhss grhss -> GuardedRhss $ map fix grhss + where fix x = applyFixities fixs x + +instance AppFixity GuardedRhs where + applyFixities fixs (GuardedRhs loc stmts e) = GuardedRhs loc (map fix stmts) $ fix e + where fix x = applyFixities fixs x + +instance AppFixity Pat where + applyFixities fixs p = case p of + PNeg p -> PNeg $ fix p + PInfixApp a op b -> PInfixApp (fix a) op (fix b) + PApp n ps -> PApp n $ map fix ps + PTuple ps -> PTuple $ map fix ps + PList ps -> PList $ map fix ps + PParen p -> PParen $ fix p + PRec n pfs -> PRec n $ map fix pfs + PAsPat n p -> PAsPat n $ fix p + PIrrPat p -> PIrrPat $ fix p + PatTypeSig loc p t -> PatTypeSig loc (fix p) t + PViewPat e p -> PViewPat (fix e) (fix p) + PRPat rps -> PRPat $ map fix rps + PXTag loc n ats mp ps -> PXTag loc n (map fix ats) (fmap fix mp) (map fix ps) + PXETag loc n ats mp -> PXETag loc n (map fix ats) (fmap fix mp) + PXPatTag p -> PXPatTag $ fix p + PXRPats rps -> PXRPats $ map fix rps + PBangPat p -> PBangPat $ fix p + _ -> p + where fix x = applyFixities fixs x + +instance AppFixity PatField where + applyFixities fixs (PFieldPat n p) = PFieldPat n $ applyFixities fixs p + applyFixities _ pf = pf + +instance AppFixity RPat where + applyFixities fixs rp = case rp of + RPOp rp op -> RPOp (fix rp) op + RPEither a b -> RPEither (fix a) (fix b) + RPSeq rps -> RPSeq $ map fix rps + RPGuard p stmts -> RPGuard (fix p) $ map fix stmts + RPCAs n rp -> RPCAs n $ fix rp + RPAs n rp -> RPAs n $ fix rp + RPParen rp -> RPParen $ fix rp + RPPat p -> RPPat $ fix p + where fix x = applyFixities fixs x + +instance AppFixity PXAttr where + applyFixities fixs (PXAttr n p) = PXAttr n $ applyFixities fixs p + +instance AppFixity Stmt where + applyFixities fixs stmt = case stmt of + Generator loc p e -> Generator loc (fix p) (fix e) + Qualifier e -> Qualifier $ fix e + LetStmt bs -> LetStmt $ fix bs -- special behavior + RecStmt stmts -> RecStmt $ map fix stmts + where fix x = applyFixities fixs x + +instance AppFixity Binds where + applyFixities fixs bs = case bs of + BDecls decls -> BDecls $ appFixDecls fixs decls -- special behavior + IPBinds ips -> IPBinds $ map fix ips + where fix x = applyFixities fixs x + + +instance AppFixity IPBind where + applyFixities fixs (IPBind loc n e) = IPBind loc n $ applyFixities fixs e + +instance AppFixity FieldUpdate where + applyFixities fixs (FieldUpdate n e) = FieldUpdate n $ applyFixities fixs e + applyFixities _ fup = fup + +instance AppFixity Alt where + applyFixities fixs (Alt loc p galts bs) = Alt loc (fix p) (fix galts) (fix bs) + where fix x = applyFixities fixs x + +instance AppFixity GuardedAlts where + applyFixities fixs galts = case galts of + UnGuardedAlt e -> UnGuardedAlt $ fix e + GuardedAlts galts -> GuardedAlts $ map fix galts + where fix x = applyFixities fixs x + +instance AppFixity GuardedAlt where + applyFixities fixs (GuardedAlt loc stmts e) = GuardedAlt loc (map fix stmts) (fix e) + where fix x = applyFixities fixs x + +instance AppFixity QualStmt where + applyFixities fixs qstmt = case qstmt of + QualStmt s -> QualStmt $ fix s + ThenTrans e -> ThenTrans $ fix e + ThenBy e1 e2 -> ThenBy (fix e1) (fix e2) + GroupBy e -> GroupBy (fix e) + GroupUsing e -> GroupUsing (fix e) + GroupByUsing e1 e2 -> GroupByUsing (fix e1) (fix e2) + where fix x = applyFixities fixs x + +instance AppFixity Bracket where + applyFixities fixs br = case br of + ExpBracket e -> ExpBracket $ fix e + PatBracket p -> PatBracket $ fix p + DeclBracket ds -> DeclBracket $ map fix ds + _ -> br + where fix x = applyFixities fixs x + +instance AppFixity Splice where + applyFixities fixs (ParenSplice e) = ParenSplice $ applyFixities fixs e + applyFixities _ s = s + +instance AppFixity XAttr where + applyFixities fixs (XAttr n e) = XAttr n $ applyFixities fixs e + + +-- the boring boilerplate stuff for expressions too +appFixExp fixs e = case e of + App e1 e2 -> App (fix e1) (fix e2) + NegApp e -> NegApp $ fix e + Lambda loc pats e -> Lambda loc (map fix pats) $ fix e + Let bs e -> Let (fix bs) $ fix e + If e a b -> If (fix e) (fix a) (fix b) + Case e alts -> Case (fix e) $ map fix alts + Do stmts -> Do $ map fix stmts + MDo stmts -> MDo $ map fix stmts + Tuple exps -> Tuple $ map fix exps + List exps -> Tuple $ map fix exps + Paren e -> Paren $ fix e + LeftSection e op -> LeftSection (fix e) op + RightSection op e -> RightSection op $ fix e + RecConstr n fups -> RecConstr n $ map fix fups + RecUpdate e fups -> RecUpdate (fix e) $ map fix fups + EnumFrom e -> EnumFrom $ fix e + EnumFromTo e1 e2 -> EnumFromTo (fix e1) (fix e2) + EnumFromThen e1 e2 -> EnumFromThen (fix e1) (fix e2) + EnumFromThenTo e1 e2 e3 -> EnumFromThenTo (fix e1) (fix e2) (fix e3) + ListComp e quals -> ListComp (fix e) $ map fix quals + ParComp e qualss -> ParComp (fix e) $ map (map fix) qualss + ExpTypeSig loc e t -> ExpTypeSig loc (fix e) t + BracketExp b -> BracketExp $ fix b + SpliceExp s -> SpliceExp $ fix s + XTag loc n ats mexp cs -> XTag loc n (map fix ats) (fmap fix mexp) (map fix cs) + XETag loc n ats mexp -> XETag loc n (map fix ats) (fmap fix mexp) + XExpTag e -> XExpTag $ fix e + Proc p e -> Proc (fix p) (fix e) + LeftArrApp e1 e2 -> LeftArrApp (fix e1) (fix e2) + RightArrApp e1 e2 -> RightArrApp (fix e1) (fix e2) + LeftArrHighApp e1 e2 -> LeftArrHighApp (fix e1) (fix e2) + RightArrHighApp e1 e2 -> RightArrHighApp (fix e1) (fix e2) + _ -> e + where + fix x = applyFixities fixs x diff --git a/src/Language/Haskell/Exts/Lexer.hs b/src/Language/Haskell/Exts/Lexer.hs new file mode 100644 --- /dev/null +++ b/src/Language/Haskell/Exts/Lexer.hs @@ -0,0 +1,1036 @@ +-- #hide +----------------------------------------------------------------------------- +-- | +-- Module : Language.Haskell.Exts.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.Exts.Lexer (Token(..), lexer) where + +import Language.Haskell.Exts.ParseMonad +import Language.Haskell.Exts.Extension + +import Data.Char +import Data.Ratio + +-- import Debug.Trace (trace) + +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 + | IntTokHash Integer -- 1# + | WordTokHash Integer -- 1## + | FloatTokHash Rational -- 1.0# + | DoubleTokHash Rational -- 1.0## + | CharacterHash Char -- c# + | StringHash String -- "Hello world!"# + +-- Symbols + + | LeftParen + | RightParen + | LeftHashParen + | RightHashParen + | LeftCurlyBar + | RightCurlyBar + | 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 + | Star + | LeftArrowTail -- >- + | RightArrowTail -- -< + | LeftDblArrowTail -- >>- + | RightDblArrowTail -- -<< + +-- Template Haskell + | THExpQuote -- [| or [e| + | THPatQuote -- [p| + | THDecQuote -- [d| + | THTypQuote -- [t| + | THCloseQuote -- |] + | THIdEscape (String) -- dollar x + | THParenEscape -- dollar ( + | THVarQuote -- 'x (but without the x) + | THTyQuote -- ''T (but without the T) + | THQuasiQuote (String,String) -- [$...|...] + +-- HaRP + | RPGuardOpen -- (| + | RPGuardClose -- |) + | RPCAt -- @: + +-- Hsx + | XCodeTagOpen -- <% + | XCodeTagClose -- %> + | XStdTagOpen -- < + | XStdTagClose -- > + | XCloseTagOpen -- + | XPCDATA String + | XRPatOpen -- <[ + | XRPatClose -- ]> + +-- Pragmas + + | PragmaEnd -- #-} +-- | PragmaUnknown (String,String) -- Any pragma not recognized + | RULES + | INLINE Bool + | SPECIALISE + | SPECIALISE_INLINE Bool + | SOURCE + | DEPRECATED + | WARNING + | SCC + | GENERATED + | CORE + | UNPACK + | OPTIONS (Maybe String,String) + | CFILES String + | LANGUAGE + | INCLUDE String +-- These are not yet implemented +-- | LINE + +-- Reserved Ids + + | KW_As + | KW_By -- transform list comprehensions + | KW_Case + | KW_Class + | KW_Data + | KW_Default + | KW_Deriving + | KW_Do + | KW_MDo + | KW_Else + | KW_Family -- indexed type families + | KW_Forall -- universal/existential types + | KW_Group -- transform list comprehensions + | 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_Proc -- arrows + | KW_Rec -- arrows + | KW_Then + | KW_Type + | KW_Using -- transform list comprehensions + | KW_Where + | 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, Maybe ExtScheme))] +reserved_ops = [ + -- the dot is only a special symbol together with forall. + ( ".", (Dot, Just (Any [LiberalTypeSynonyms, + ExistentialQuantification, + PolymorphicComponents, + Rank2Types, RankNTypes])) ), + ( "..", (DotDot, Nothing) ), + ( ":", (Colon, Nothing) ), + ( "::", (DoubleColon, Nothing) ), + ( "=", (Equals, Nothing) ), + ( "\\", (Backslash, Nothing) ), + ( "|", (Bar, Nothing) ), + ( "<-", (LeftArrow, Nothing) ), + ( "->", (RightArrow, Nothing) ), + ( "@", (At, Nothing) ), + ( "@:", (RPCAt, Just (Any [RegularPatterns])) ), + ( "~", (Tilde, Nothing) ), + ( "=>", (DoubleArrow, Nothing) ), + ( "*", (Star, Just (Any [KindSignatures])) ), + -- Arrows notation + ( "-<", (LeftArrowTail, Just (Any [Arrows])) ), + ( ">-", (RightArrowTail, Just (Any [Arrows])) ), + ( "-<<", (LeftDblArrowTail, Just (Any [Arrows])) ), + ( ">>-", (RightDblArrowTail, Just (Any [Arrows])) ) + ] + +special_varops :: [(String,(Token, Maybe ExtScheme))] +special_varops = [ + ( "-", (Minus, Nothing) ), + ( "!", (Exclamation, Nothing) ) + ] + +reserved_ids :: [(String,(Token, Maybe ExtScheme))] +reserved_ids = [ + ( "_", (Underscore, Nothing) ), + ( "by", (KW_By, Just (Any [TransformListComp])) ), + ( "case", (KW_Case, Nothing) ), + ( "class", (KW_Class, Nothing) ), + ( "data", (KW_Data, Nothing) ), + ( "default", (KW_Default, Nothing) ), + ( "deriving", (KW_Deriving, Nothing) ), + ( "do", (KW_Do, Nothing) ), + ( "else", (KW_Else, Nothing) ), + ( "family", (KW_Family, Just (Any [TypeFamilies])) ), -- indexed type families + ( "forall", (KW_Forall, Just (Any [LiberalTypeSynonyms, + ExistentialQuantification, + Rank2Types, RankNTypes])) ), -- universal/existential quantification + ( "group", (KW_Group, Just (Any [TransformListComp])) ), + ( "if", (KW_If, Nothing) ), + ( "import", (KW_Import, Nothing) ), + ( "in", (KW_In, Nothing) ), + ( "infix", (KW_Infix, Nothing) ), + ( "infixl", (KW_InfixL, Nothing) ), + ( "infixr", (KW_InfixR, Nothing) ), + ( "instance", (KW_Instance, Nothing) ), + ( "let", (KW_Let, Nothing) ), + ( "mdo", (KW_MDo, Just (Any [RecursiveDo])) ), + ( "module", (KW_Module, Nothing) ), + ( "newtype", (KW_NewType, Nothing) ), + ( "of", (KW_Of, Nothing) ), + ( "proc", (KW_Proc, Just (Any [Arrows])) ), + ( "rec", (KW_Rec, Just (Any [Arrows])) ), + ( "then", (KW_Then, Nothing) ), + ( "type", (KW_Type, Nothing) ), + ( "using", (KW_Using, Just (Any [TransformListComp])) ), + ( "where", (KW_Where, Nothing) ), + +-- FFI + ( "foreign", (KW_Foreign, Just (Any [ForeignFunctionInterface])) ) + ] + + +special_varids :: [(String,(Token, Maybe ExtScheme))] +special_varids = [ + ( "as", (KW_As, Nothing) ), + ( "qualified", (KW_Qualified, Nothing) ), + ( "hiding", (KW_Hiding, Nothing) ), + +-- FFI + ( "export", (KW_Export, Just (Any [ForeignFunctionInterface])) ), + ( "safe", (KW_Safe, Just (Any [ForeignFunctionInterface])) ), + ( "unsafe", (KW_Unsafe, Just (Any [ForeignFunctionInterface])) ), + ( "threadsafe", (KW_Threadsafe, Just (Any [ForeignFunctionInterface])) ), + ( "stdcall", (KW_StdCall, Just (Any [ForeignFunctionInterface])) ), + ( "ccall", (KW_CCall, Just (Any [ForeignFunctionInterface])) ) + ] + +pragmas :: [(String,Token)] +pragmas = [ + ( "rules", RULES ), + ( "inline", INLINE True ), + ( "noinline", INLINE False ), + ( "notinline", INLINE False ), + ( "specialise", SPECIALISE ), + ( "specialize", SPECIALISE ), + ( "source", SOURCE ), + ( "deprecated", DEPRECATED ), + ( "warning", WARNING ), + ( "scc", SCC ), + ( "generated", GENERATED ), + ( "core", CORE ), + ( "unpack", UNPACK ), + ( "language", LANGUAGE ), + ( "options", OPTIONS undefined ), -- we'll tweak it before use - promise! + ( "cfiles", CFILES undefined ), -- same here... + ( "include", INCLUDE undefined ) -- ...and here! + ] + +isIdent, isHSymbol :: Char -> Bool +isIdent c = isAlpha c || isDigit c || c == '\'' || c == '_' + +isHSymbol c = c `elem` ":!#%&*./?@\\-" || ((isSymbol c || isPunctuation c) && not (c `elem` "(),;[]`{}_\"'")) + +matchChar :: Char -> String -> Lex a () +matchChar c msg = do + s <- getInput + if null s || head s /= c then fail msg else discard 1 + +-- The top-level lexer. +-- We need to know whether we are at the beginning of the line to decide +-- whether to insert layout tokens. + +lexer :: (Token -> P a) -> P a +lexer = runL topLexer + +topLexer :: Lex a Token +topLexer = do + p <- pullLexState + if p then --trace (show p ++ ": " ++ show VRightCurly) $ + setBOL >> return VRightCurly -- the lex state flags that we must do an empty {} - UGLY + else 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. + -- We don't bother to test for XmlSyntax, since we + -- couldn't end up in ChildCtxt otherwise. + Just ChildCtxt | not bol && ws -> return $ XPCDATA " " + _ -> do startToken + if bol then lexBOL -- >>= \t -> trace ("BOL: " ++ show t) (return t) + else lexToken -- >>= \t -> trace (show t) (return t) + +lexWhiteSpace :: Bool -> Lex a (Bool, Bool) +lexWhiteSpace bol = do + s <- getInput + case s of + '{':'-':'#':_ -> do + return (bol, False) + '{':'-':_ -> do + discard 2 + bol <- lexNestedComment bol + (bol, _) <- lexWhiteSpace bol + return (bol, True) + '-':'-':s | all (== '-') (takeWhile isHSymbol s) -> do + lexWhile (== '-') + lexWhile (/= '\n') + s' <- getInput + case s' of + [] -> fail "Unterminated end-of-line comment" + _ -> do + 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 + --trace (show pos) $ + 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 + -- we don't bother to check XmlSyntax since we couldn't + -- have ended up in a non-Nothing context if it wasn't + -- enabled. + 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 + -- if we ever end up here, then XmlSyntax must be on. + s <- getInput + case s of + '<':'%':_ -> do discard 2 + pushExtContextL CodeTagCtxt + return XCodeTagOpen + '<':'/':_ -> do discard 2 + popExtContextL "lexChildCtxt" + pushExtContextL CloseTagCtxt + return XCloseTagOpen + '<':'[':_ -> do discard 2 + pushExtContextL HarpCtxt + return XRPatOpen + '<':_ -> do discard 1 + pushExtContextL TagCtxt + return XStdTagOpen + _ -> lexPCDATA + + +lexPCDATA :: Lex a Token +lexPCDATA = do + -- if we ever end up here, then XmlSyntax must be on. + 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 "" + _ -> 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 + -- if we ever end up here, then XmlSyntax must be on. + s <- getInput + case s of + '%':'>':_ -> do discard 2 + popExtContextL "lexCodeTagContext" + return XCodeTagClose + _ -> lexStdToken + +lexCloseTagCtxt :: Lex a Token +lexCloseTagCtxt = do + -- if we ever end up here, then XmlSyntax must be on. + s <- getInput + case s of + '>':_ -> do discard 1 + popExtContextL "lexCloseTagCtxt" + return XStdTagClose + _ -> lexStdToken + +lexTagCtxt :: Lex a Token +lexTagCtxt = do + -- if we ever end up here, then XmlSyntax must be on. + 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 + -- if we ever end up here, then RegularPatterns must be on. + s <- getInput + case s of + ']':'>':_ -> do discard 2 + popExtContextL "lexHarpToken" + return XRPatClose + _ -> lexStdToken + +lexStdToken :: Lex a Token +lexStdToken = do + s <- getInput + exts <- getExtensionsL + 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 && ImplicitParams `elem` exts -> do + discard 1 + id <- lexWhile isIdent + return $ IDupVarId id + + '%':c:_ | isLower c && ImplicitParams `elem` exts -> do + discard 1 + id <- lexWhile isIdent + return $ ILinVarId id + -- end implicit parameters + + -- harp + '(':'|':c:_ | isHSymbol c -> discard 1 >> return LeftParen + '(':'|':_ | RegularPatterns `elem` exts -> + do discard 2 + return RPGuardOpen + '|':')':_ | RegularPatterns `elem` exts -> + do discard 2 + return RPGuardClose + {- This is handled by the reserved_ops above. + '@':':':_ | RegularPatterns `elem` exts -> + do discard 2 + return RPCAt -} + + -- template haskell + '[':'|':_ | TemplateHaskell `elem` exts -> do + discard 2 + return $ THExpQuote + + '[':c:'|':_ | c == 'e' && TemplateHaskell `elem` exts -> do + discard 3 + return $ THExpQuote + | c == 'p' && TemplateHaskell `elem` exts -> do + discard 3 + return THPatQuote + | c == 'd' && TemplateHaskell `elem` exts -> do + discard 3 + return THDecQuote + | c == 't' && TemplateHaskell `elem` exts -> do + discard 3 + return THTypQuote + '[':'$':c:_ | isLower c && QuasiQuotes `elem` exts -> + discard 2 >> lexQuasiQuote + + '|':']':_ | TemplateHaskell `elem` exts -> do + discard 2 + return THCloseQuote + + '$':c:_ | isLower c && TemplateHaskell `elem` exts -> do + discard 1 + id <- lexWhile isIdent + return $ THIdEscape id + | c == '(' && TemplateHaskell `elem` exts -> do + discard 2 + return THParenEscape + -- end template haskell + + -- hsx + '<':'%':_ | XmlSyntax `elem` exts -> do + discard 2 + pushExtContextL CodeTagCtxt + return XCodeTagOpen + '<':c:_ | isAlpha c && XmlSyntax `elem` exts -> do + discard 1 + pushExtContextL TagCtxt + return XStdTagOpen + -- end hsx + + '(':'#':_ | UnboxedTuples `elem` exts -> do discard 2 >> return LeftHashParen + + '#':')':_ | UnboxedTuples `elem` exts -> do discard 2 >> return RightHashParen + + '{':'|':_ | Generics `elem` exts -> do discard 2 >> return LeftCurlyBar + + '|':'}':_ | Generics `elem` exts -> do discard 2 >> return RightCurlyBar + + -- pragmas + + '{':'-':'#':_ -> do discard 3 >> lexPragmaStart + + '#':'-':'}':_ -> do discard 3 >> return PragmaEnd + + 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, scheme) -> + -- check if an extension keyword is enabled + if isEnabled scheme exts then keyword else VarId ident + Nothing -> VarId ident + _ -> return $ DVarId idents + + | isHSymbol c -> do + sym <- lexWhile isHSymbol + return $ case lookup sym (reserved_ops ++ special_varops) of + Just (t , scheme) -> + -- check if an extension op is enabled + if isEnabled scheme exts + then t + else case c of + ':' -> ConSym sym + _ -> VarSym sym + 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 + + '\'' -> lexCharacter + '"' -> lexString + + _ -> fail ("Illegal character \'" ++ show c ++ "\'\n") + + where lexIdents :: Lex a [String] + lexIdents = do + ident <- lexWhile isIdent + s <- getInput + exts <- getExtensionsL + case s of + -- This is the only way we can get more than one ident in the list + -- and it requires XmlSyntax to be on. + '-':c:_ | XmlSyntax `elem` exts && isAlpha c -> do + discard 1 + idents <- lexIdents + return $ ident : idents + '#':_ | MagicHash `elem` exts -> do + discard 1 + return [ident ++ "#"] + _ -> return [ident] + + lexQuasiQuote :: Lex a Token + lexQuasiQuote = do + -- We've seen and dropped [$ already + ident <- lexWhile isIdent + matchChar '|' "Malformed quasi-quote quoter" + body <- lexQQBody + return $ THQuasiQuote (ident, body) + + lexQQBody :: Lex a String + lexQQBody = do + s <- getInput + case s of + '\\':']':_ -> do str <- lexQQBody + return (']':str) + '\\':'|':_ -> do str <- lexQQBody + return ('|':str) + '|':']':_ -> discard 2 >> return "" + _ -> do str <- lexWhile (not . (`elem` "\\|")) + rest <- lexQQBody + return (str++rest) + +lexPragmaStart :: Lex a Token +lexPragmaStart = do + lexWhile isSpace + pr <- lexWhile isAlphaNum + case lookup (map toLower pr) pragmas of + Just SPECIALISE -> do + s <- getInput + case dropWhile isSpace $ map toLower s of + 'i':'n':'l':'i':'n':'e':_ -> do + lexWhile isSpace + discard 6 + return $ SPECIALISE_INLINE True + 'n':'o':'i':'n':'l':'i':'n':'e':_ -> do + lexWhile isSpace + discard 8 + return $ SPECIALISE_INLINE False + 'n':'o':'t':'i':'n':'l':'i':'n':'e':_ -> do + lexWhile isSpace + discard 9 + return $ SPECIALISE_INLINE False + _ -> return SPECIALISE + + Just (OPTIONS _) -> do -- see, I promised we'd mask out the 'undefined' + s <- getInput + case s of + '_':_ -> do + discard 1 + com <- lexWhile isIdent + rest <- lexRawPragma + return $ OPTIONS (Just com, rest) + x:_ | isSpace x -> do + rest <- lexRawPragma + return $ OPTIONS (Nothing, rest) + _ -> fail "Malformed Options pragma" + Just (CFILES _) -> do + rest <- lexRawPragma + return $ CFILES rest + Just (INCLUDE _) -> do + rest <- lexRawPragma + return $ INCLUDE rest + Just p -> return p + + _ -> do rawStr <- lexRawPragma + -- return $ PragmaUnknown (pr, rawStr) -- no support for unrecognized pragmas, treat as comment + discard 3 -- #-} + topLexer -- we just discard it as a comment for now and restart + +lexRawPragma :: Lex a String +lexRawPragma = do + rpr <- lexRawPragmaAux + return $ dropWhile isSpace rpr + where lexRawPragmaAux = do + rpr <- lexWhile (/='#') + s <- getInput + case s of + '#':'-':'}':_ -> return rpr + _ -> do + discard 1 + rpr' <- lexRawPragma + return $ rpr ++ '#':rpr' + +lexDecimalOrFloat :: Lex a Token +lexDecimalOrFloat = do + ds <- lexWhile isDigit + rest <- getInput + exts <- getExtensionsL + 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 + con <- lexHash FloatTok FloatTokHash (Right DoubleTokHash) + return $ con ((num%1) * 10^^(exponent - decimals)) + e:_ | toLower e == 'e' -> do + exponent <- lexExponent + con <- lexHash FloatTok FloatTokHash (Right DoubleTokHash) + return $ con ((parseInteger 10 ds%1) * 10^^exponent) + '#':'#':_ | MagicHash `elem` exts -> discard 2 >> return (WordTokHash (parseInteger 10 ds)) + '#':_ | MagicHash `elem` exts -> discard 1 >> return (IntTokHash (parseInteger 10 ds)) + _ -> 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" + +lexHash :: (b -> Token) -> (b -> Token) -> Either String (b -> Token) -> Lex a (b -> Token) +lexHash a b c = do + exts <- getExtensionsL + if MagicHash `elem` exts + then do + r <- getInput + case r of + '#':'#':_ -> case c of + Right c -> discard 2 >> return c + Left s -> fail s + '#':_ -> discard 1 >> return b + _ -> return a + else return a + +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 + exts <- getExtensionsL + case rest of + '.':c:_ + | isLower c || c == '_' -> do -- qualified varid? + discard 1 + ident <- lexWhile isIdent + s <- getInput + exts <- getExtensionsL + ident' <- case s of + '#':_ | MagicHash `elem` exts -> discard 1 >> return (ident ++ "#") + _ -> return ident + 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) + + '#':c:_ + | isSpace c && MagicHash `elem` exts -> do + discard 1 + case conid of + ConId con -> return $ ConId $ con ++ "#" + QConId (q,con) -> return $ QConId (q,con ++ "#") + _ -> return conid -- not a qualified thing + +lexCharacter :: Lex a Token +lexCharacter = do -- We need to keep track of not only character constants but also TH 'x and ''T + -- We've seen ' so far + s <- getInput + exts <- getExtensionsL + case s of + '\'':_ | TemplateHaskell `elem` exts -> discard 1 >> return THTyQuote + '\\':_ -> do + c <- lexEscape + matchQuote + con <- lexHash Character CharacterHash + (Left "Double hash not available for character literals") + return (con c) + c:'\'':_ -> do + discard 2 + con <- lexHash Character CharacterHash + (Left "Double hash not available for character literals") + return (con c) + _ | TemplateHaskell `elem` exts -> return THVarQuote + _ -> fail "Improper character constant or misplaced \'" + + where matchQuote = matchChar '\'' "Improperly terminated character constant" + + +lexString :: Lex a Token +lexString = loop "" + where + loop s = do + r <- getInput + exts <- getExtensionsL + 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) + '"':'#':_ | MagicHash `elem` exts -> do + discard 2 + return (StringHash (reverse 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/src/Language/Haskell/Exts/ParseMonad.hs b/src/Language/Haskell/Exts/ParseMonad.hs new file mode 100644 --- /dev/null +++ b/src/Language/Haskell/Exts/ParseMonad.hs @@ -0,0 +1,355 @@ +-- #hide +----------------------------------------------------------------------------- +-- | +-- Module : Language.Haskell.Exts.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.Exts.ParseMonad( + -- * Parsing + P, ParseResult(..), atSrcLoc, LexContext(..), + ParseMode(..), defaultParseMode, + runParserWithMode, runParser, + getSrcLoc, pushCurrentContext, popContext, + getExtensions, + -- * Lexing + Lex(runL), getInput, discard, lexNewline, lexTab, lexWhile, + alternative, checkBOL, setBOL, startToken, getOffside, + pushContextL, popContextL, getExtensionsL, + -- * Harp/Hsx + ExtContext(..), + pushExtContextL, popExtContextL, getExtContext, + pushLexState, pullLexState, + getModuleName + ) where + +import Language.Haskell.Exts.Syntax(SrcLoc(..)) +import Language.Haskell.Exts.Extension (Extension) +import Language.Haskell.Exts.Fixity (Fixity, preludeFixities) + +import Data.List ( intersperse ) +import Control.Applicative +import Control.Monad (when) +import Data.Monoid + +-- | The result of a parse. +data ParseResult a + = ParseOk { unParseOk :: a } -- ^ The parse succeeded, yielding a value. + | ParseFailed SrcLoc String + -- ^ The parse failed at the specified + -- source location, with an error message. + deriving Show + +instance Functor ParseResult where + fmap f (ParseOk x) = ParseOk $ f x + fmap f (ParseFailed loc msg) = ParseFailed loc msg + +instance Applicative ParseResult where + pure = ParseOk + ParseOk f <*> x = f <$> x + ParseFailed loc msg <*> _ = ParseFailed loc msg + +instance Monad ParseResult where + return = ParseOk + ParseOk x >>= f = f x + ParseFailed loc msg >>= _ = ParseFailed loc msg + +instance Monoid m => Monoid (ParseResult m) where + mempty = ParseOk mempty + ParseOk x `mappend` ParseOk y = ParseOk $ x `mappend` y + ParseOk x `mappend` err = err + err `mappend` _ = err -- left-biased + + +-- internal version +data ParseStatus a = Ok ParseState a | Failed SrcLoc String + deriving Show + +data LexContext = NoLayout | Layout Int + deriving (Eq,Ord,Show) + +data ExtContext = CodeCtxt | HarpCtxt | TagCtxt | ChildCtxt + | CloseTagCtxt | CodeTagCtxt + deriving (Eq,Ord,Show) + +type LexState = Bool + +type ParseState = ([LexContext],[ExtContext],LexState) + +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, + -- | list of extensions enabled + extensions :: [Extension], + -- | list of fixities to be aware of + fixities :: [Fixity] + } + +-- | Default parameters for a parse, +-- currently just a marker for an unknown filename. + +defaultParseMode :: ParseMode +defaultParseMode = ParseMode { + parseFilename = ".hs", + extensions = [], + fixities = preludeFixities + } + +-- | 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 ([],[],False) 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 + when (srcColumn loc <= indent) $ pushLexState -- this means we must give a vccurly next. + 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, p) _m -> Ok (ctxt:s, e, p) () + +popContext :: P () +popContext = P $ \_i _x _y _l stk _m -> + case stk of + (_:s, e, p) -> --trace ("popping lexical scope, context now "++show s ++ "\n") $ + Ok (s, e, p) () + ([],_,_) -> error "Internal error: empty context in popContext" + + +-- HaRP/Hsx +pushExtContext :: ExtContext -> P () +pushExtContext ctxt = P $ \_i _x _y _l (s, e, p) _m -> Ok (s, ctxt:e, p) () + +popExtContext :: P () +popExtContext = P $ \_i _x _y _l (s, e, p) _m -> + case e of + (_:e') -> + Ok (s, e', p) () + [] -> error "Internal error: empty context in popExtContext" + + +-- Extension-aware lexing/parsing +getExtensions :: P [Extension] +getExtensions = P $ \_i _x _y _l s m -> + Ok s $ extensions m + +pushLexState :: P () +pushLexState = -- Lex $ \cont -> P $ \r x y loc (ct, e, pst) -> case pst of + --False -> runP (cont ()) r x y loc (ct, e, True) + --_ -> error "Internal error: Lex state already pushed" + P $ \_i _x _y _l (s, e, p) _m -> case p of + False -> Ok (s, e, True) () + _ -> error "Internal error: Lex state already pushed" + +---------------------------------------------------------------------------- +-- 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, pst) -> + runP (cont ()) r x y loc (ctxt:stk, e, pst) + +popContextL :: String -> Lex a () +popContextL fn = Lex $ \cont -> P $ \r x y loc stk -> case stk of + (_:ctxt, e, pst) -> runP (cont ()) r x y loc (ctxt, e, pst) + ([], _, _) -> error ("Internal error: empty context in " ++ fn) + +pullLexState :: Lex a LexState +pullLexState = Lex $ \cont -> P $ \r x y loc (ct, e, pst) -> + runP (cont pst) r x y loc (ct, e, False) + + + +-- 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, p) -> + runP (cont ()) r x y loc (s, ec:e, p) + +popExtContextL :: String -> Lex a () +popExtContextL fn = Lex $ \cont -> P $ \r x y loc stk@(s,e,p) -> case e of + (_:ec) -> runP (cont ()) r x y loc (s,ec,p) + [] -> error ("Internal error: empty tag context in " ++ fn) + + +-- Extension-aware lexing + +getExtensionsL :: Lex a [Extension] +getExtensionsL = Lex $ \cont -> P $ \r x y loc s m -> + runP (cont $ extensions m) r x y loc s m diff --git a/src/Language/Haskell/Exts/ParseUtils.hs b/src/Language/Haskell/Exts/ParseUtils.hs new file mode 100644 --- /dev/null +++ b/src/Language/Haskell/Exts/ParseUtils.hs @@ -0,0 +1,1010 @@ +-- #hide +----------------------------------------------------------------------------- +-- | +-- Module : Language.Haskell.Exts.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.Exts.ParseUtils ( + splitTyConApp -- Type -> P (Name,[Type]) + , checkEnabled -- Extension -> P () + , checkPatternGuards -- [Stmt] -> P () + , mkRecConstrOrUpdate -- Exp -> [FieldUpdate] -> P S.Exp + , checkPrec -- Integer -> P Int + , checkPContext -- Type -> P Context + , checkContext -- PContext -> P S.Context + , checkAssertion -- Type -> P Asst + , checkDataHeader -- Type -> P (Context,Name,[Name]) + , checkClassHeader -- Type -> P (Context,Name,[Name]) + , checkInstHeader -- Type -> P (Context,QName,[Type]) + , checkDeriving -- [PType] -> P [Deriving] + , checkPattern -- PExp -> P Pat + , checkExpr -- PExp -> P Exp + , checkType -- PType -> P Type + , checkValDef -- SrcLoc -> S.Exp -> Rhs -> [Decl] -> P Decl + , checkClassBody -- [ClassDecl] -> P [ClassDecl] + , checkInstBody -- [InstDecl] -> P [InstDecl] + , checkUnQual -- QName -> P Name + , checkRevDecls -- [Decl] -> P [Decl] + , checkRevClsDecls -- [ClassDecl] -> P [ClassDecl] + , checkRevInstDecls -- [InstDecl] -> P [InstDecl] + , checkDataOrNew -- DataOrNew -> [Decl] -> P () + , checkSimpleType -- Type -> P () + , checkSigVar -- PExp -> P Name + , getGConName -- S.Exp -> P QName + , mkTyForall -- Maybe [Name] -> Context -> Type -> Type + -- HaRP + , checkRPattern -- PExp -> P RPat + -- Hsx + , checkEqNames -- XName -> XName -> P XName + , mkPageModule -- [OptionPragma] -> S.Exp -> P Module + , mkPage -- [OptionPragma] -> Module -> SrcLoc -> S.Exp -> P Module + , mkDVar -- [String] -> String + , mkDVarExpr -- [String] -> ParseExp + -- Pragmas + , checkRuleExpr -- PExp -> P Exp + , readTool -- Maybe String -> Maybe Tool + + -- Parsed expressions and types + , PExp(..), PFieldUpdate(..), ParseXAttr(..), PType(..), PContext, PAsst(..) + , p_unit_con -- PExp + , p_tuple_con -- Int -> PExp + , p_unboxed_singleton_con -- PExp + ) where + +import Language.Haskell.Exts.Syntax hiding ( Type(..), Asst(..), Exp(..), FieldUpdate(..), XAttr(..) ) +import qualified Language.Haskell.Exts.Syntax as S ( Type(..), Asst(..), Exp(..), FieldUpdate(..), XAttr(..) ) +import Language.Haskell.Exts.ParseMonad +import Language.Haskell.Exts.Pretty +import Language.Haskell.Exts.Build +import Language.Haskell.Exts.Extension + +import Data.List (intersperse) +import Control.Monad (when) + +splitTyConApp :: PType -> P (Name,[S.Type]) +splitTyConApp t0 = do + (n, pts) <- split t0 [] + ts <- mapM checkType pts + return (n,ts) + where + split :: PType -> [PType] -> P (Name,[PType]) + split (TyApp t u) ts = split t (u:ts) + split (TyCon (UnQual t)) ts = return (t,ts) + split (TyInfix a op b) ts = split (TyCon op) (a:b:ts) + split _ _ = fail "Illegal data/newtype declaration" + +----------------------------------------------------------------------------- +-- Checking for extensions + +checkEnabled :: (Show e, Enabled e) => e -> P () +checkEnabled e = do + exts <- getExtensions + if isEnabled e exts + then return () + else fail $ show e ++ " is not enabled" + +checkPatternGuards :: [Stmt] -> P () +checkPatternGuards [Qualifier _] = return () +checkPatternGuards _ = checkEnabled PatternGuards + +----------------------------------------------------------------------------- +-- Checking contexts + +-- Check that a context is syntactically correct. Takes care of +-- checking for MPTCs, TypeOperators, TypeFamilies (for eq constraints) +-- and ImplicitParameters, but leaves checking of the class assertion +-- parameters for later. +checkPContext :: PType -> P PContext +checkPContext (TyTuple Boxed ts) = + mapM checkAssertion ts +checkPContext t = do + c <- checkAssertion t + return [c] + +-- Check a single assertion according to the above, still leaving +-- the class assertion parameters for later. +checkAssertion :: PType -> P PAsst +-- We cannot even get here unless ImplicitParameters is enabled. +checkAssertion (TyPred p@(IParam _ _)) = return p +-- We cannot even get here unless TypeFamilies is enabled. +checkAssertion (TyPred p@(EqualP _ _)) = return p +checkAssertion t = checkAssertion' [] t + where -- class assertions must have at least one argument + checkAssertion' ts@(_:xs) (TyCon c) = do + when (not $ null xs) $ checkEnabled MultiParamTypeClasses + when (isSymbol c) $ checkEnabled TypeOperators + return $ ClassA c ts + checkAssertion' ts (TyApp a t) = do + -- no check on t at this stage + checkAssertion' (t:ts) a + checkAssertion' ts (TyInfix a op b) = + -- infix operators require TypeOperators + checkEnabled TypeOperators >> checkAssertion' (a:b:ts) (TyCon op) + checkAssertion' _ _ = fail "Illegal class assertion" + +isSymbol :: QName -> Bool +isSymbol (UnQual (Symbol _)) = True +isSymbol (Qual _ (Symbol _)) = True +isSymbol _ = False + + +-- Checks simple contexts for class and instance +-- headers. If FlexibleContexts is enabled then +-- anything goes, otherwise only tyvars are allowed. +checkSContext :: PContext -> P Context +checkSContext = mapM (checkAsst True) + +-- Checks ordinary contexts for sigtypes and data type +-- declarations. If FlexibleContexts is enabled then +-- anything goes, otherwise only tyvars OR tyvars +-- applied to types are allowed. +checkContext :: PContext -> P Context +checkContext = mapM (checkAsst False) + +checkAsst :: Bool -> PAsst -> P S.Asst +checkAsst isSimple asst = + case asst of + ClassA qn pts -> do + ts <- mapM (checkAsstParam isSimple) pts + return $ S.ClassA qn ts + InfixA a op b -> do + [a,b] <- mapM (checkAsstParam isSimple) [a,b] + return $ S.InfixA a op b + IParam ipn pt -> do + t <- checkType pt + return $ S.IParam ipn t + EqualP pa pb -> do + a <- checkType pa + b <- checkType pb + return $ S.EqualP a b + +checkAsstParam :: Bool -> PType -> P S.Type +checkAsstParam isSimple t = do + exts <- getExtensions + if FlexibleContexts `elem` exts + then checkType t + else case t of + TyVar n -> return $ S.TyVar n + TyApp pf pt | not isSimple -> do + f <- checkAsstParam isSimple pf + t <- checkType pt + return $ S.TyApp f t + _ -> fail "Malformed context: FlexibleContexts not enabled" + +----------------------------------------------------------------------------- +-- Checking Headers + + +checkDataHeader :: PType -> P (Context,Name,[TyVarBind]) +checkDataHeader (TyForall Nothing cs t) = do + (c,ts) <- checkSimple "data/newtype" t [] + cs <- checkContext cs + return (cs,c,ts) +checkDataHeader t = do + (c,ts) <- checkSimple "data/newtype" t [] + return ([],c,ts) + +checkClassHeader :: PType -> P (Context,Name,[TyVarBind]) +checkClassHeader (TyForall Nothing cs t) = do + (c,ts) <- checkSimple "class" t [] + cs <- checkSContext cs + return (cs,c,ts) +checkClassHeader t = do + (c,ts) <- checkSimple "class" t [] + return ([],c,ts) + +checkSimple :: String -> PType -> [TyVarBind] -> P (Name,[TyVarBind]) +checkSimple kw (TyApp l t) xs | isTyVarBind t = checkSimple kw l (toTyVarBind t : xs) +checkSimple _ (TyInfix t1 (UnQual t) t2) xs + | isTyVarBind t1 && isTyVarBind t2 = + checkEnabled TypeOperators >> return (t, toTyVarBind t1 : toTyVarBind t2 : xs) +checkSimple _kw (TyCon (UnQual t)) xs = do + case t of + Symbol _ -> checkEnabled TypeOperators + _ -> return () + return (t,xs) +checkSimple kw _ _ = fail ("Illegal " ++ kw ++ " declaration") + +isTyVarBind :: PType -> Bool +isTyVarBind (TyVar _) = True +isTyVarBind (TyKind (TyVar _) _) = True +isTyVarBind _ = False + +toTyVarBind :: PType -> TyVarBind +toTyVarBind (TyVar n) = UnkindedVar n +toTyVarBind (TyKind (TyVar n) k) = KindedVar n k + +checkInstHeader :: PType -> P (Context,QName,[S.Type]) +checkInstHeader (TyForall Nothing cs t) = do + (c,ts) <- checkInsts t [] + cs <- checkSContext cs + return (cs,c,ts) +checkInstHeader t = do + (c,ts) <- checkInsts t [] + return ([],c,ts) + + +checkInsts :: PType -> [PType] -> P (QName,[S.Type]) +checkInsts (TyApp l t) ts = checkInsts l (t:ts) +checkInsts (TyCon c) ts = do + when (isSymbol c) $ checkEnabled TypeOperators + ts <- checkTypes ts + return (c,ts) +checkInsts (TyInfix a op b) [] = do + checkEnabled TypeOperators + ts <- checkTypes [a,b] + return (op,ts) +checkInsts _ _ = fail "Illegal instance declaration" + +checkDeriving :: [PType] -> P [Deriving] +checkDeriving = mapM (flip checkInsts []) + +----------------------------------------------------------------------------- +-- Checking Patterns. + +-- We parse patterns as expressions and check for valid patterns below, +-- converting the expression into a pattern at the same time. + +checkPattern :: PExp -> P Pat +checkPattern e = checkPat e [] + +checkPat :: PExp -> [Pat] -> P Pat +checkPat (Con c) args = return (PApp c args) +checkPat (App f x) args = do + x <- checkPat x [] + checkPat f (x:args) +checkPat e [] = case e of + Var (UnQual x) -> return (PVar x) + Lit l -> return (PLit l) + InfixApp l op r -> + case op of + QConOp c -> do + l <- checkPat l [] + r <- checkPat r [] + return (PInfixApp l c r) + QVarOp (UnQual (Symbol "+")) -> do + case (l,r) of + (Var (UnQual n@(Ident _)), Lit (Int k)) -> return (PNPlusK n k) + _ -> patFail "" + QVarOp (UnQual (Symbol "!")) -> do + -- We must have BangPatterns on + checkEnabled BangPatterns + let (e,es) = splitBang r [] + ps <- mapM checkPattern (BangPat e:es) + checkPat l ps + _ -> patFail "" + Tuple es -> do + ps <- mapM (\e -> checkPat e []) es + return (PTuple ps) + List es -> do + ps <- mapM checkRPattern es + if all isStdPat ps + then return . PList $ map stripRP ps + -- we don't allow truly regular patterns unless the extension is enabled + else checkEnabled RegularPatterns >> return (PRPat $ map fixRPOpPrec ps) + where isStdPat :: RPat -> Bool + isStdPat (RPPat _) = True + isStdPat (RPAs _ p) = isStdPat p + isStdPat _ = False + stripRP :: RPat -> Pat + stripRP (RPPat p) = p + stripRP (RPAs n p) = PAsPat n (stripRP p) + stripRP _ = error "cannot strip RP wrapper if not all patterns are base" + + Paren e -> do + p <- checkPat e [] + return (PParen p) + AsPat n e -> do + p <- checkPat e [] + return (PAsPat n p) + WildCard -> return PWildCard + IrrPat e -> do + p <- checkPat e [] + return (PIrrPat p) + ViewPat e p -> do + e <- checkExpr e + p <- checkPat p [] + return (PViewPat e p) + RecConstr c fs -> do + fs <- mapM checkPatField fs + return (PRec c fs) + NegApp (Lit l) -> return (PNeg (PLit l)) + ExpTypeSig s e t -> do + -- patterns cannot have signatures unless ScopedTypeVariables is enabled. + checkEnabled ScopedTypeVariables + p <- checkPat e [] + return (PatTypeSig s p t) + + -- Hsx + XTag 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 cps = mkChildrenPat pcs + return $ PXTag s n pattrs mpattr cps + XETag s n attrs mattr -> do + pattrs <- mapM checkPAttr attrs + mpattr <- maybe (return Nothing) + (\e -> do p <- checkPat e [] + return $ Just p) + mattr + return $ PXETag s n pattrs mpattr + XPcdata pcdata -> return $ PXPcdata pcdata + XExpTag e -> do + p <- checkPat e [] + return $ PXPatTag p + XRPats es -> do + rps <- mapM checkRPattern es + return (PXRPats $ map fixRPOpPrec rps) + + -- Generics + ExplTypeArg qn t -> return $ PExplTypeArg qn t + + -- QuasiQuotation + QuasiQuote n q -> return $ PQuasiQuote n q + + -- BangPatterns + BangPat e -> do + p <- checkPat e [] + return $ PBangPat p + + e -> patFail $ show e + +checkPat e _ = patFail $ show e + +splitBang :: PExp -> [PExp] -> (PExp, [PExp]) +splitBang (App f x) es = splitBang f (x:es) +splitBang e es = (e, es) + +checkPatField :: PFieldUpdate -> P PatField +checkPatField (FieldUpdate n e) = do + p <- checkPat e [] + return (PFieldPat n p) +checkPatField (FieldPun n) = return (PFieldPun n) +checkPatField (FieldWildcard) = return PFieldWildcard + +checkPAttr :: ParseXAttr -> P PXAttr +checkPAttr (XAttr n v) = do p <- checkPat v [] + return $ PXAttr n p + +patFail :: String -> P a +patFail s = fail $ "Parse error in pattern: " ++ s + +checkRPattern :: PExp -> P RPat +checkRPattern e = case e of + SeqRP es -> do + rps <- mapM checkRPattern es + return $ RPSeq rps + PostOp e op -> do + rpop <- checkRPatOp op + rp <- checkRPattern e + return $ RPOp rp rpop + GuardRP e gs -> do + rp <- checkPattern e + return $ RPGuard rp gs + EitherRP e1 e2 -> do + rp1 <- checkRPattern e1 + rp2 <- checkRPattern e2 + return $ RPEither rp1 rp2 + CAsRP n e -> do + rp <- checkRPattern e + return $ RPCAs n rp + AsPat n e -> do + rp <- checkRPattern e + return $ RPAs n rp + Paren e -> do + rp <- checkRPattern e + return $ RPParen rp + _ -> do + p <- checkPattern e + return $ RPPat p + +checkRPatOp :: QOp -> P RPatOp +checkRPatOp o@(QVarOp (UnQual (Symbol sym))) = + case sym of + "*" -> return RPStar + "*!" -> return RPStarG + "+" -> return RPPlus + "+!" -> return RPPlusG + "?" -> return RPOpt + "?!" -> return RPOptG + _ -> rpOpFail o +checkRPatOp o = rpOpFail o + +rpOpFail sym = fail $ "Unrecognized regular pattern operator: " ++ show sym + +fixRPOpPrec :: RPat -> RPat +fixRPOpPrec rp = case rp of + RPOp rp rpop -> fPrecOp rp (flip RPOp rpop) + RPEither rp1 rp2 -> RPEither (fixRPOpPrec rp1) (fixRPOpPrec rp2) + RPSeq rps -> RPSeq $ map fixRPOpPrec rps + RPCAs n rp -> RPCAs n $ fixRPOpPrec rp + RPAs n rp -> RPAs n $ fixRPOpPrec rp + RPParen rp -> RPParen $ fixRPOpPrec rp + _ -> rp + + where fPrecOp :: RPat -> (RPat -> RPat) -> RPat + fPrecOp (RPOp rp rpop) f = fPrecOp rp (f . flip RPOp rpop) + fPrecOp (RPCAs n rp) f = fPrecAs rp f (RPCAs n) + fPrecOp (RPAs n rp) f = fPrecAs rp f (RPAs n) + fPrecOp rp f = f $ fixRPOpPrec rp + fPrecAs :: RPat -> (RPat -> RPat) -> (RPat -> RPat) -> RPat + fPrecAs (RPCAs n rp) f g = fPrecAs rp f (g . RPCAs n) + fPrecAs (RPAs n rp) f g = fPrecAs rp f (g . RPAs n) + fPrecAs rp f g = g . f $ fixRPOpPrec rp + + +mkChildrenPat :: [Pat] -> [Pat] +mkChildrenPat ps = mkCPAux ps [] + where mkCPAux :: [Pat] -> [Pat] -> [Pat] + mkCPAux [] qs = reverse qs + mkCPAux (p:ps) qs = case p of + (PRPat rps) -> [mkCRP ps (reverse rps ++ map RPPat qs)] + _ -> mkCPAux ps (p:qs) + + mkCRP :: [Pat] -> [RPat] -> Pat + mkCRP [] rps = PXRPats $ reverse rps + mkCRP (p:ps) rps = case p of + (PXRPats rqs) -> mkCRP ps (reverse rqs ++ rps) + _ -> mkCRP ps (RPPat p : rps) + +----------------------------------------------------------------------------- +-- Check Expression Syntax + +checkExpr :: PExp -> P S.Exp +checkExpr e = case e of + Var v -> return $ S.Var v + IPVar v -> return $ S.IPVar v + Con c -> return $ S.Con c + Lit l -> return $ S.Lit l + InfixApp e1 op e2 -> check2Exprs e1 e2 (flip S.InfixApp op) + App e1 e2 -> check2Exprs e1 e2 S.App + NegApp e -> check1Expr e S.NegApp + Lambda loc ps e -> check1Expr e (S.Lambda loc ps) + Let bs e -> check1Expr e (S.Let bs) + If e1 e2 e3 -> check3Exprs e1 e2 e3 S.If + Case e alts -> do + e <- checkExpr e + return (S.Case e alts) + Do stmts -> return (S.Do stmts) + MDo stmts -> return (S.MDo stmts) + Tuple es -> checkManyExprs es S.Tuple + List es -> checkManyExprs es S.List + -- Since we don't parse things as left sections, we need to mangle them into that. + Paren e -> case e of + PostOp e1 op -> check1Expr e1 (flip S.LeftSection op) + _ -> check1Expr e S.Paren + RightSection op e -> check1Expr e (S.RightSection op) + RecConstr c fields -> do + fields <- mapM checkField fields + return (S.RecConstr c fields) + RecUpdate e fields -> do + fields <- mapM checkField fields + e <- checkExpr e + return (S.RecUpdate e fields) + EnumFrom e -> check1Expr e S.EnumFrom + EnumFromTo e1 e2 -> check2Exprs e1 e2 S.EnumFromTo + EnumFromThen e1 e2 -> check2Exprs e1 e2 S.EnumFromThen + EnumFromThenTo e1 e2 e3 -> check3Exprs e1 e2 e3 S.EnumFromThenTo + -- a parallel list comprehension, which could be just a simple one + ParComp e qualss -> do + e <- checkExpr e + case qualss of + [quals] -> return (S.ListComp e quals) + _ -> return (S.ParComp e qualss) + ExpTypeSig loc e ty -> do + e <- checkExpr e + return (S.ExpTypeSig loc e ty) + + --Template Haskell + BracketExp e -> return $ S.BracketExp e + SpliceExp e -> return $ S.SpliceExp e + TypQuote q -> return $ S.TypQuote q + VarQuote q -> return $ S.VarQuote q + QuasiQuote n q -> return $ S.QuasiQuote n q + + -- Hsx + XTag 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 $ S.XTag s n attrs mattr cs + XETag s n attrs mattr -> do attrs <- mapM checkAttr attrs + mattr <- maybe (return Nothing) + (\e -> checkExpr e >>= return . Just) + mattr + return $ S.XETag s n attrs mattr + XPcdata p -> return $ S.XPcdata p + XExpTag e -> do e <- checkExpr e + return $ S.XExpTag e + -- Pragmas + CorePragma s -> return $ S.CorePragma s + SCCPragma s -> return $ S.SCCPragma s + GenPragma s xx yy -> return $ S.GenPragma s xx yy +-- UnknownExpPragma n s -> return $ S.UnknownExpPragma n s + + -- Arrows + Proc p e -> do e <- checkExpr e + return $ S.Proc p e + LeftArrApp e1 e2 -> check2Exprs e1 e2 S.LeftArrApp + RightArrApp e1 e2 -> check2Exprs e1 e2 S.RightArrApp + LeftArrHighApp e1 e2 -> check2Exprs e1 e2 S.LeftArrHighApp + RightArrHighApp e1 e2 -> check2Exprs e1 e2 S.RightArrHighApp + + _ -> fail $ "Parse error in expression: " ++ show e + +checkAttr :: ParseXAttr -> P S.XAttr +checkAttr (XAttr n v) = do v <- checkExpr v + return $ S.XAttr n v + +-- type signature for polymorphic recursion!! +check1Expr :: PExp -> (S.Exp -> a) -> P a +check1Expr e1 f = do + e1 <- checkExpr e1 + return (f e1) + +check2Exprs :: PExp -> PExp -> (S.Exp -> S.Exp -> a) -> P a +check2Exprs e1 e2 f = do + e1 <- checkExpr e1 + e2 <- checkExpr e2 + return (f e1 e2) + +check3Exprs :: PExp -> PExp -> PExp -> (S.Exp -> S.Exp -> S.Exp -> a) -> P a +check3Exprs e1 e2 e3 f = do + e1 <- checkExpr e1 + e2 <- checkExpr e2 + e3 <- checkExpr e3 + return (f e1 e2 e3) + +checkManyExprs :: [PExp] -> ([S.Exp] -> a) -> P a +checkManyExprs es f = do + es <- mapM checkExpr es + return (f es) + + +checkRuleExpr :: PExp -> P S.Exp +checkRuleExpr = checkExpr + +readTool :: Maybe String -> Maybe Tool +readTool = fmap readC + where readC str = case str of + "GHC" -> GHC + "HUGS" -> HUGS + "NHC98" -> NHC98 + "YHC" -> YHC + "HADDOCK" -> HADDOCK + _ -> UnknownTool str + +{- +checkAlt :: Alt -> P Alt +checkAlt (Alt loc p galts bs) = do + galts <- checkGAlts galts + return (Alt loc p galts bs) + +checkGAlts :: GuardedAlts -> P GuardedAlts +checkGAlts (UnGuardedAlt e) = check1Expr e UnGuardedAlt +checkGAlts (GuardedAlts galts) = do + galts <- mapM checkGAlt galts + return (GuardedAlts galts) + +checkGAlt :: GuardedAlt -> P GuardedAlt +checkGAlt (GuardedAlt loc g e) = check1Expr e (GuardedAlt loc g) + +checkStmt :: Stmt -> P Stmt +checkStmt (Generator loc p e) = check1Expr e (Generator loc p) +checkStmt (Qualifier e) = check1Expr e Qualifier +checkStmt s@(LetStmt _) = return s +-} +checkField :: PFieldUpdate -> P S.FieldUpdate +checkField (FieldUpdate n e) = check1Expr e (S.FieldUpdate n) +checkField (FieldPun n) = return $ S.FieldPun n +checkField (FieldWildcard) = return S.FieldWildcard + +getGConName :: S.Exp -> P QName +getGConName (S.Con n) = return n +getGConName (S.List []) = return list_cons_name +getGConName _ = fail "Expression in reification is not a name" + +----------------------------------------------------------------------------- +-- Check Equation Syntax + +checkValDef :: SrcLoc -> PExp -> Maybe S.Type -> Rhs -> Binds -> P Decl +checkValDef srcloc lhs optsig rhs whereBinds = + case isFunLhs lhs [] of + Just (f,es) -> do + ps <- mapM checkPattern es + case optsig of -- only pattern bindings can have signatures + Nothing -> return (FunBind [Match srcloc f ps optsig rhs whereBinds]) + Just _ -> fail "Cannot give an explicit type signature to a function binding" + Nothing -> do + lhs <- checkPattern lhs + return (PatBind srcloc lhs optsig rhs whereBinds) + +-- A variable binding is parsed as an PatBind. + +isFunLhs :: PExp -> [PExp] -> Maybe (Name, [PExp]) +isFunLhs (InfixApp l (QVarOp (UnQual op)) r) es = Just (op, l:r:es) +isFunLhs (App (Var (UnQual f)) e) es = Just (f, e:es) +isFunLhs (App (Paren f) e) es = isFunLhs f (e:es) +isFunLhs (App f e) es = isFunLhs f (e:es) +isFunLhs _ _ = Nothing + +-- Separating between signature declarations and value definitions in +-- a post-processing step + +checkSigVar :: PExp -> P Name +checkSigVar (Var (UnQual n)) = return n +checkSigVar e = fail $ "Left-hand side of type signature is not a variable: " ++ show e + +----------------------------------------------------------------------------- +-- In a class or instance body, a pattern binding must be of a variable. + +checkClassBody :: [ClassDecl] -> P [ClassDecl] +checkClassBody decls = do + mapM_ checkClassMethodDef decls + return decls + where checkClassMethodDef (ClsDecl decl) = checkMethodDef decl + checkClassMethodDef _ = return () + +checkInstBody :: [InstDecl] -> P [InstDecl] +checkInstBody decls = do + mapM_ checkInstMethodDef decls + return decls + where checkInstMethodDef (InsDecl decl) = checkMethodDef decl + checkInstMethodDef _ = return () + +checkMethodDef :: Decl -> P () +checkMethodDef (PatBind _ (PVar _) _ _ _) = return () +checkMethodDef (PatBind 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 :: QName -> P Name +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 :: XName -> XName -> P XName +checkEqNames n@(XName n1) (XName n2) + | n1 == n2 = return n + | otherwise = fail "names in matching xml tags are not equal" +checkEqNames n@(XDomName d1 n1) (XDomName 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 :: PExp -> [PFieldUpdate] -> P PExp +mkRecConstrOrUpdate (Con c) fs = return (RecConstr c fs) +mkRecConstrOrUpdate e fs@(_:_) = return (RecUpdate e fs) +mkRecConstrOrUpdate _ _ = fail "Empty record update" + +----------------------------------------------------------------------------- +-- Reverse a list of declarations, merging adjacent FunBinds of the +-- same name and checking that their arities match. + +checkRevDecls :: [Decl] -> P [Decl] +checkRevDecls = mergeFunBinds [] + where + mergeFunBinds revDs [] = return revDs + mergeFunBinds revDs (FunBind ms1@(Match _ name ps _ _ _:_):ds1) = + mergeMatches ms1 ds1 + where + arity = length ps + mergeMatches ms' (FunBind ms@(Match 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 (FunBind ms':revDs) ds + mergeFunBinds revDs (d:ds) = mergeFunBinds (d:revDs) ds + +checkRevClsDecls :: [ClassDecl] -> P [ClassDecl] +checkRevClsDecls = mergeClsFunBinds [] + where + mergeClsFunBinds revDs [] = return revDs + mergeClsFunBinds revDs (ClsDecl (FunBind ms1@(Match _ name ps _ _ _:_)):ds1) = + mergeMatches ms1 ds1 + where + arity = length ps + mergeMatches ms' (ClsDecl (FunBind ms@(Match 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 = mergeClsFunBinds (ClsDecl (FunBind ms'):revDs) ds + mergeClsFunBinds revDs (d:ds) = mergeClsFunBinds (d:revDs) ds + +checkRevInstDecls :: [InstDecl] -> P [InstDecl] +checkRevInstDecls = mergeInstFunBinds [] + where + mergeInstFunBinds revDs [] = return revDs + mergeInstFunBinds revDs (InsDecl (FunBind ms1@(Match _ name ps _ _ _:_)):ds1) = + mergeMatches ms1 ds1 + where + arity = length ps + mergeMatches ms' (InsDecl (FunBind ms@(Match 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 = mergeInstFunBinds (InsDecl (FunBind ms'):revDs) ds + mergeInstFunBinds revDs (d:ds) = mergeInstFunBinds (d:revDs) ds + +---------------------------------------------------------------- +-- Check that newtype declarations have +-- the right number (1) of constructors + +checkDataOrNew :: DataOrNew -> [a] -> P () +checkDataOrNew NewType [x] = return () +checkDataOrNew DataType _ = return () +checkDataOrNew _ _ = fail "newtype declaration must have exactly one constructor." + +checkSimpleType :: PType -> P (Name, [TyVarBind]) +checkSimpleType t = checkSimple "test" t [] + +--------------------------------------- +-- Check actual types + +checkType :: PType -> P S.Type +checkType t = case t of + TyForall tvs@Nothing cs pt -> do + ctxt <- checkContext cs + check1Type pt (S.TyForall Nothing ctxt) + TyForall tvs cs pt -> do + checkEnabled (Any [PolymorphicComponents, LiberalTypeSynonyms, Rank2Types, RankNTypes]) + ctxt <- checkContext cs + check1Type pt (S.TyForall tvs ctxt) + TyFun at rt -> check2Types at rt S.TyFun + TyTuple b pts -> checkTypes pts >>= return . S.TyTuple b + TyList pt -> check1Type pt S.TyList + TyApp ft at -> check2Types ft at S.TyApp + TyVar n -> return $ S.TyVar n + TyCon n -> do + when (isSymbol n) $ checkEnabled TypeOperators + return $ S.TyCon n + TyParen pt -> check1Type pt S.TyParen + -- TyPred cannot be a valid type + -- Here we know that t will be used as an actual type (and not a data constructor) + -- so we can check that TypeOperators are enabled. + TyInfix at op bt -> checkEnabled TypeOperators >> check2Types at bt (flip S.TyInfix op) + TyKind pt k -> check1Type pt (flip S.TyKind k) + +check1Type :: PType -> (S.Type -> S.Type) -> P S.Type +check1Type pt f = checkType pt >>= return . f + +check2Types :: PType -> PType -> (S.Type -> S.Type -> S.Type) -> P S.Type +check2Types at bt f = checkType at >>= \a -> checkType bt >>= \b -> return (f a b) + +checkTypes :: [PType] -> P [S.Type] +checkTypes = mapM checkType + +--------------------------------------- +-- Converting a complete page + +pageFun :: SrcLoc -> S.Exp -> Decl +pageFun loc e = PatBind loc namePat Nothing rhs (BDecls []) + where namePat = PVar $ Ident "page" + rhs = UnGuardedRhs e + +mkPage :: Module -> SrcLoc -> S.Exp -> P Module +mkPage (Module src md os warn exps imps decls) loc xml = do + let page = pageFun loc xml + return $ Module src md os warn exps imps (decls ++ [page]) + +mkPageModule :: [OptionPragma] -> S.Exp -> P Module +mkPageModule os xml = do + do loc <- case xml of + S.XTag l _ _ _ _ -> return l + S.XETag l _ _ _ -> return l + _ -> fail "Will not happen since mkPageModule is only called on XML expressions" + mod <- getModuleName + return $ (Module + loc + (ModuleName mod) + os + Nothing + (Just [EVar $ UnQual $ Ident "page"]) + [] + [pageFun loc xml]) + +--------------------------------------- +-- Handle dash-identifiers + +mkDVar :: [String] -> String +mkDVar = concat . intersperse "-" + +mkDVarExpr :: [String] -> PExp +mkDVarExpr = foldl1 (\x y -> InfixApp x (op $ sym "-") y) . map (Var . UnQual . 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 + +mkTyForall :: Maybe [TyVarBind] -> PContext -> PType -> PType +mkTyForall mtvs [] ty = mk_forall_ty mtvs ty +mkTyForall mtvs ctxt ty = TyForall 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 (TyForall mtvs2 ctxt ty) = mkTyForall (mtvs1 `plus` mtvs2) ctxt ty +mk_forall_ty mtvs1 ty = TyForall mtvs1 [] ty + +mtvs1 `plus` Nothing = mtvs1 +Nothing `plus` mtvs2 = mtvs2 +(Just tvs1) `plus` (Just tvs2) = Just (tvs1 ++ tvs2) + +--------------------------------------- +-- Expressions as we parse them (and patters, and regular patterns) + +data PExp + = Var QName -- ^ variable + | IPVar IPName -- ^ implicit parameter variable + | Con QName -- ^ data constructor + | Lit Literal -- ^ literal constant + | InfixApp PExp QOp PExp -- ^ infix application + | App PExp PExp -- ^ ordinary application + | NegApp PExp -- ^ negation expression @-@ /exp/ + | Lambda SrcLoc [Pat] PExp -- ^ lambda expression + | Let Binds PExp -- ^ local declarations with @let@ + | If PExp PExp PExp -- ^ @if@ /exp/ @then@ /exp/ @else@ /exp/ + | Case PExp [Alt] -- ^ @case@ /exp/ @of@ /alts/ + | Do [Stmt] -- ^ @do@-expression: + -- the last statement in the list + -- should be an expression. + | MDo [Stmt] -- ^ @mdo@-expression + | Tuple [PExp] -- ^ tuple expression + | List [PExp] -- ^ list expression + | Paren PExp -- ^ parenthesized expression + | RightSection QOp PExp -- ^ right section @(@/qop/ /exp/@)@ + | RecConstr QName [PFieldUpdate] + -- ^ record construction expression + | RecUpdate PExp [PFieldUpdate] + -- ^ record update expression + | EnumFrom PExp -- ^ unbounded arithmetic sequence, + -- incrementing by 1 + | EnumFromTo PExp PExp -- ^ bounded arithmetic sequence, + -- incrementing by 1 + | EnumFromThen PExp PExp -- ^ unbounded arithmetic sequence, + -- with first two elements given + | EnumFromThenTo PExp PExp PExp + -- ^ bounded arithmetic sequence, + -- with first two elements given + | ParComp PExp [[QualStmt]] -- ^ parallel list comprehension + | ExpTypeSig SrcLoc PExp S.Type + -- ^ expression type signature + | AsPat Name PExp -- ^ patterns only + | WildCard -- ^ patterns only + | IrrPat PExp -- ^ patterns only + +-- Post-ops for parsing left sections and regular patterns. Not to be left in the final tree. + | PostOp PExp QOp -- ^ post-ops + +-- View patterns + | ViewPat PExp PExp -- ^ patterns only + +-- HaRP + | SeqRP [PExp] -- ^ regular patterns only + | GuardRP PExp [Stmt] -- ^ regular patterns only + | EitherRP PExp PExp -- ^ regular patterns only + | CAsRP Name PExp -- ^ regular patterns only + +-- Template Haskell + | VarQuote QName -- ^ 'x + | TypQuote QName -- ^ ''T + | BracketExp Bracket + | SpliceExp Splice + | QuasiQuote String String -- ^ [$...|...] + +-- Hsx + | XTag SrcLoc XName [ParseXAttr] (Maybe PExp) [PExp] + | XETag SrcLoc XName [ParseXAttr] (Maybe PExp) + | XPcdata String + | XExpTag PExp + | XRPats [PExp] + +-- Pragmas + | CorePragma String + | SCCPragma String + | GenPragma String (Int, Int) (Int, Int) +-- | UnknownExpPragma String String + +-- Generics + | ExplTypeArg QName S.Type -- ^ f {| Int |} x = ... + +-- Bang Patterns + | BangPat PExp -- ^ f !a = ... + +-- Arrows + | Proc Pat PExp + | LeftArrApp PExp PExp + | RightArrApp PExp PExp + | LeftArrHighApp PExp PExp + | RightArrHighApp PExp PExp + deriving (Eq,Show) + +data PFieldUpdate + = FieldUpdate QName PExp + | FieldPun Name + | FieldWildcard + deriving (Eq,Show) + +data ParseXAttr = XAttr XName PExp + deriving (Eq,Show) + +p_unit_con :: PExp +p_unit_con = Con unit_con_name + +p_tuple_con :: Boxed -> Int -> PExp +p_tuple_con b i = Con (tuple_con_name b i) + +p_unboxed_singleton_con :: PExp +p_unboxed_singleton_con = Con unboxed_singleton_con_name + +type PContext = [PAsst] + +data PType + = TyForall + (Maybe [TyVarBind]) + PContext + PType + | TyFun PType PType -- ^ function type + | TyTuple Boxed [PType] -- ^ tuple type, possibly boxed + | TyList PType -- ^ list syntax, e.g. [a], as opposed to [] a + | TyApp PType PType -- ^ application of a type constructor + | TyVar Name -- ^ type variable + | TyCon QName -- ^ named type or type constructor + | TyParen PType -- ^ type surrounded by parentheses + | TyPred PAsst -- ^ assertion of an implicit parameter + | TyInfix PType QName PType -- ^ infix type constructor + | TyKind PType Kind -- ^ type with explicit kind signature + deriving (Eq, Show) + +data PAsst = ClassA QName [PType] + | InfixA PType QName PType + | IParam IPName PType + | EqualP PType PType + deriving (Eq, Show) + +unit_tycon, fun_tycon, list_tycon, unboxed_singleton_tycon :: PType +unit_tycon = TyCon unit_tycon_name +fun_tycon = TyCon fun_tycon_name +list_tycon = TyCon list_tycon_name +unboxed_singleton_tycon = TyCon unboxed_singleton_tycon_name + +tuple_tycon :: Boxed -> Int -> PType +tuple_tycon b i = TyCon (tuple_tycon_name b i) diff --git a/src/Language/Haskell/Exts/Parser.ly b/src/Language/Haskell/Exts/Parser.ly new file mode 100644 --- /dev/null +++ b/src/Language/Haskell/Exts/Parser.ly @@ -0,0 +1,1681 @@ +> { +> ----------------------------------------------------------------------------- +> -- | +> -- Module : Language.Haskell.Exts.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.Exts.Parser ( +> Parseable(..), +> parseModule, parseModuleWithMode, +> parseExp, parseExpWithMode, +> parsePat, parsePatWithMode, +> parseDecl, parseDeclWithMode, +> parseType, parseTypeWithMode, +> getTopPragmas, +> ParseMode(..), defaultParseMode, ParseResult(..) +> ) where +> +> import Language.Haskell.Exts.Syntax hiding ( Type(..), Exp(..), Asst(..), XAttr(..), FieldUpdate(..) ) +> import Language.Haskell.Exts.Syntax ( Type, Exp, Asst ) +> import Language.Haskell.Exts.ParseMonad +> import Language.Haskell.Exts.Lexer +> import Language.Haskell.Exts.ParseUtils +> import Language.Haskell.Exts.Extension +> import Language.Haskell.Exts.Fixity + +import Debug.Trace (trace) +> } + +----------------------------------------------------------------------------- +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: 7 shift/reduce + +2 for ambiguity in 'case x of y | let z = y in z :: Bool -> b' [State 220, 236] + (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 ...' [State 707] + 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. + +1 for ambiguity using hybrid modules [State 5] + For HSP pages that start with a <% %> block, the parser cannot tell whether + to reduce a srcloc or shift the starting <%. Since any other body could not + start with <%, shifting is the only sensible thing to do. + +1 for ambiguity using toplevel xml modules [State 8] + For HSP xml pages starting with a <, the parser cannot tell whether to shift + that < or reduce an implicit 'open'. Since no other body could possibly start + with <, shifting is the only sensible thing to do. + +1 for ambiguity in '{-# RULES "name" [ ... #-}' [State 212] + we don't know whether the '[' starts the activation or not: it + might be the start of the declaration with the activation being + empty. Resolving with shift means the declaration cannot start with '['. + +1 for ambiguity in 'x :: Int = ...' + we don't know if we should reduce the lefthand side to a type signature + declaration, or shift the '=' and treat the lefthand side as a pattern with + a scoped type variable. Since a type signature declaration couldn't be followed + by a '=', shifting is the only sensible thing to do. +----------------------------------------------------------------------------- + +> %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 $$ } + +> PRIMINT { IntTokHash $$ } +> PRIMWORD { WordTokHash $$ } +> PRIMFLOAT { FloatTokHash $$ } +> PRIMDOUBLE { DoubleTokHash $$ } +> PRIMCHAR { CharacterHash $$ } +> PRIMSTRING { StringHash $$ } + +Symbols + +> '(' { LeftParen } +> ')' { RightParen } +> '(#' { LeftHashParen } +> '#)' { RightHashParen } +> '{|' { LeftCurlyBar } +> '|}' { RightCurlyBar } +> ';' { 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 } +> '*' { Star } + +Arrows + +> '-<' { LeftArrowTail } +> '>-' { RightArrowTail } +> '-<<' { LeftDblArrowTail } +> '>>-' { RightDblArrowTail } + +Harp + +> '(|' { RPGuardOpen } +> '|)' { RPGuardClose } +> '@:' { RPCAt } + +Template Haskell + +> IDSPLICE { THIdEscape $$ } -- $x +> '$(' { THParenEscape } +> '[|' { THExpQuote } +> '[p|' { THPatQuote } +> '[t|' { THTypQuote } +> '[d|' { THDecQuote } +> '|]' { THCloseQuote } +> VARQUOTE { THVarQuote } -- 'x +> TYPQUOTE { THTyQuote } -- ''T +> QUASIQUOTE { THQuasiQuote $$ } + +Hsx + +> PCDATA { XPCDATA $$ } +> '<' { XStdTagOpen } +> ' '<%' { XCodeTagOpen } +> '>' { XStdTagClose } +> '/>' { XEmptyTagClose } +> '%>' { XCodeTagClose } +> '<[' { XRPatOpen } +> ']>' { XRPatClose } + +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 } +> 'by' { KW_By } -- transform list comprehensions +> 'case' { KW_Case } +> 'class' { KW_Class } +> 'data' { KW_Data } +> 'default' { KW_Default } +> 'deriving' { KW_Deriving } +> 'do' { KW_Do } +> 'else' { KW_Else } +> 'family' { KW_Family } -- indexed type families +> 'forall' { KW_Forall } -- universal/existential qualification +> 'group' { KW_Group } -- transform list comprehensions +> '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 } +> 'proc' { KW_Proc } -- arrows +> 'rec' { KW_Rec } -- arrows +> 'then' { KW_Then } +> 'type' { KW_Type } +> 'using' { KW_Using } -- transform list comprehensions +> 'where' { KW_Where } +> 'qualified' { KW_Qualified } + +Pragmas + +> '{-# INLINE' { INLINE $$ } +> '{-# SPECIALISE' { SPECIALISE } +> '{-# SPECIALISE_INLINE' { SPECIALISE_INLINE $$ } +> '{-# SOURCE' { SOURCE } +> '{-# RULES' { RULES } +> '{-# CORE' { CORE } +> '{-# SCC' { SCC } +> '{-# GENERATED' { GENERATED } +> '{-# DEPRECATED' { DEPRECATED } +> '{-# WARNING' { WARNING } +> '{-# UNPACK' { UNPACK } +> '{-# OPTIONS' { OPTIONS $$ } +> '{-# CFILES' { CFILES $$ } +> '{-# INCLUDE' { INCLUDE $$ } +> '{-# LANGUAGE' { LANGUAGE } + '{-# unknown' { PragmaUnknown $$ } +> '#-}' { PragmaEnd } + + +> %monad { P } +> %lexer { lexer } { EOF } +> %name mparseModule page +> %name mparseExp trueexp +> %name mparsePat pat +> %name mparseDecl topdecl +> %name mparseType truectype +> %partial mfindOptPragmas toppragmas +> %tokentype { Token } +> %expect 7 +> %% + +----------------------------------------------------------------------------- +HSP Pages + +Any HSP-specific parts requiring the XmlSyntax extension enabled will +be governed by the lexing, since all productions require at least one +special lexeme. + +> page :: { Module } +> : toppragmas topxml {% checkExpr $2 >>= mkPageModule $1 } +> | toppragmas '<%' module '%>' srcloc topxml {% checkExpr $6 >>= \x -> mkPage ($3 $1) $5 x } +> | toppragmas module { $2 $1 } + +> topxml :: { PExp } +> : srcloc '<' name attrs mattr '>' children '' {% do { n <- checkEqNames $3 $9; +> let { cn = reverse $7; +> as = reverse $4; }; +> return $ XTag $1 n as $5 cn } } +> | srcloc '<' name attrs mattr '/>' { XETag $1 $3 (reverse $4) $5 } + + +> toppragmas :: { [OptionPragma] } +> : open toppragmasaux close { $2 } + +> toppragmasaux :: { [OptionPragma] } +> : toppragma ';' toppragmasaux { $1 : $3 } +> | {- nothing -} { [] } + +> toppragma :: { OptionPragma } +> : srcloc '{-# LANGUAGE' conids '#-}' { LanguagePragma $1 $3 } +> | srcloc '{-# INCLUDE' '#-}' { IncludePragma $1 $2 } +> | srcloc '{-# OPTIONS' '#-}' { let (mc, s) = $2 in OptionsPragma $1 (readTool mc) s } +> | srcloc '{-# CFILES' '#-}' { CFilesPragma $1 $2 } + | srcloc '{-# unknown' '#-}' { let (n, s) = $2 in UnknownTopPragma $1 n s } + +> conids :: { [Name] } +> : conid ',' conids { $1 : $3 } +> | conid { [$1] } + +----------------------------------------------------------------------------- +Module Header + +> module :: { [OptionPragma] -> Module } +> : srcloc 'module' modid maybemodwarning maybeexports 'where' body +> { \os -> Module $1 $3 os $4 $5 (fst $7) (snd $7) } +> | srcloc body +> { \os -> Module $1 main_mod os Nothing (Just [EVar (UnQual main_name)]) +> (fst $2) (snd $2) } + +> maybemodwarning :: { Maybe WarningText } +> : '{-# DEPRECATED' STRING '#-}' { Just $ DeprText $2 } +> | '{-# WARNING' STRING '#-}' { Just $ WarnText $2 } +> | {- empty -} { Nothing } + +> body :: { ([ImportDecl],[Decl]) } +> : '{' bodyaux '}' { $2 } +> | open bodyaux close { $2 } + +> bodyaux :: { ([ImportDecl],[Decl]) } +> : 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 [ExportSpec] } +> : exports { Just $1 } +> | {- empty -} { Nothing } + +> exports :: { [ExportSpec] } +> : '(' exportlist optcomma ')' { reverse $2 } +> | '(' optcomma ')' { [] } + +> optcomma :: { () } +> : ',' { () } +> | {- empty -} { () } + +> exportlist :: { [ExportSpec] } +> : exportlist ',' export { $3 : $1 } +> | export { [$1] } + +> export :: { ExportSpec } +> : qvar { EVar $1 } +> | qtyconorcls { EAbs $1 } +> | qtyconorcls '(' '..' ')' { EThingAll $1 } +> | qtyconorcls '(' ')' { EThingWith $1 [] } +> | qtyconorcls '(' cnames ')' { EThingWith $1 (reverse $3) } +> | 'module' modid { EModuleContents $2 } + +----------------------------------------------------------------------------- +Import Declarations + +> impdecls :: { [ImportDecl] } +> : impdecls semis impdecl { $3 : $1 } +> | impdecl { [$1] } + +> impdecl :: { ImportDecl } +> : srcloc 'import' optsrc optqualified maybepkg modid maybeas maybeimpspec +> { ImportDecl $1 $6 $4 $3 $5 $7 $8 } + +> optsrc :: { Bool } +> : '{-# SOURCE' '#-}' { True } +> | {- empty -} { False } + +> optqualified :: { Bool } +> : 'qualified' { True } +> | {- empty -} { False } + +Requires the PackageImports extension enabled. +> maybepkg :: { Maybe String } +> : STRING {% do { checkEnabled PackageImports ; +> return $ Just $1 } } +> | {- empty -} { Nothing } + +> maybeas :: { Maybe ModuleName } +> : 'as' modid { Just $2 } +> | {- empty -} { Nothing } + + +> maybeimpspec :: { Maybe (Bool, [ImportSpec]) } +> : impspec { Just $1 } +> | {- empty -} { Nothing } + +> impspec :: { (Bool, [ImportSpec]) } +> : opthiding '(' importlist optcomma ')' { ($1, reverse $3) } +> | opthiding '(' optcomma ')' { ($1, []) } + +> opthiding :: { Bool } +> : 'hiding' { True } +> | {- empty -} { False } + +> importlist :: { [ImportSpec] } +> : importlist ',' importspec { $3 : $1 } +> | importspec { [$1] } + +> importspec :: { ImportSpec } +> : var { IVar $1 } +> | tyconorcls { IAbs $1 } +> | tyconorcls '(' '..' ')' { IThingAll $1 } +> | tyconorcls '(' ')' { IThingWith $1 [] } +> | tyconorcls '(' cnames ')' { IThingWith $1 (reverse $3) } + +> cnames :: { [CName] } +> : cnames ',' cname { $3 : $1 } +> | cname { [$1] } + +> cname :: { CName } +> : var { VarName $1 } +> | con { ConName $1 } + +----------------------------------------------------------------------------- +Fixity Declarations + +> fixdecl :: { Decl } +> : srcloc infix prec ops { InfixDecl $1 $2 $3 (reverse $4) } + +> prec :: { Int } +> : {- empty -} { 9 } +> | INT {% checkPrec $1 } + +> infix :: { Assoc } +> : 'infix' { AssocNone } +> | 'infixl' { AssocLeft } +> | 'infixr' { AssocRight } + +> ops :: { [Op] } +> : 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 :: { [Decl] } +> : topdecls1 optsemis {% checkRevDecls $1 } + +> topdecls1 :: { [Decl] } +> : topdecls1 semis topdecl { $3 : $1 } +> | topdecl { [$1] } + +> topdecl :: { Decl } +> : srcloc 'type' dtype '=' truectype +> {% do { (c,ts) <- checkSimpleType $3; +> return (TypeDecl $1 c ts $5) } } + +Requires the TypeFamilies extension enabled, but the lexer will handle +that through the 'family' keyword. +> | srcloc 'type' 'family' type optkind +> {% do { (c,ts) <- checkSimpleType $4; +> return (TypeFamDecl $1 c ts $5) } } + +Here there is no special keyword so we must do the check. +> | srcloc 'type' 'instance' truedtype '=' truectype +> {% do { -- no checkSimpleType $4 since dtype may contain type patterns +> checkEnabled TypeFamilies ; +> return (TypeInsDecl $1 $4 $6) } } +> | srcloc data_or_newtype ctype constrs0 deriving +> {% do { (cs,c,t) <- checkDataHeader $3; +> checkDataOrNew $2 $4; +> return (DataDecl $1 $2 cs c t (reverse $4) $5) } } + +Requires the GADTs extension enabled, handled in gadtlist. +> | srcloc data_or_newtype ctype optkind 'where' gadtlist deriving +> {% do { (cs,c,t) <- checkDataHeader $3; +> checkDataOrNew $2 $6; +> return (GDataDecl $1 $2 cs c t $4 (reverse $6) $7) } } + +Same as above, lexer will handle it through the 'family' keyword. +> | srcloc 'data' 'family' ctype optkind +> {% do { (cs,c,t) <- checkDataHeader $4; +> return (DataFamDecl $1 cs c t $5) } } + +Here we must check for TypeFamilies. +> | srcloc data_or_newtype 'instance' truectype constrs0 deriving +> {% do { -- (cs,c,t) <- checkDataHeader $4; +> checkEnabled TypeFamilies ; +> checkDataOrNew $2 $5; +> return (DataInsDecl $1 $2 $4 (reverse $5) $6) } } + +This style requires both TypeFamilies and GADTs, the latter is handled in gadtlist. +> | srcloc data_or_newtype 'instance' truectype optkind 'where' gadtlist deriving +> {% do { -- (cs,c,t) <- checkDataHeader $4; +> checkEnabled TypeFamilies ; +> checkDataOrNew $2 $7; +> return (GDataInsDecl $1 $2 $4 $5 (reverse $7) $8) } } +> | srcloc 'class' ctype fds optcbody +> {% do { (cs,c,vs) <- checkClassHeader $3; +> return (ClassDecl $1 cs c vs $4 $5) } } +> | srcloc 'instance' ctype optvaldefs +> {% do { (cs,c,ts) <- checkInstHeader $3; +> return (InstDecl $1 cs c ts $4) } } + +Requires the StandaloneDeriving extension enabled. +> | srcloc 'deriving' 'instance' ctype +> {% do { checkEnabled StandaloneDeriving ; +> (cs, c, ts) <- checkInstHeader $4; +> return (DerivDecl $1 cs c ts) } } +> | srcloc 'default' '(' typelist ')' +> { DefaultDecl $1 $4 } + +Requires the TemplateHaskell extension, but the lexer will handle that +through the '$(' lexeme. +> | srcloc '$(' trueexp ')' +> { SpliceDecl $1 $ ParenSplice $3 } + +These require the ForeignFunctionInterface extension, handled by the +lexer through the 'foreign' (and 'export') keyword. +> | srcloc 'foreign' 'import' callconv safety fspec +> { let (s,n,t) = $6 in ForImp $1 $4 $5 s n t } +> | srcloc 'foreign' 'export' callconv fspec +> { let (s,n,t) = $5 in ForExp $1 $4 s n t } + +> | srcloc '{-# RULES' rules '#-}' { RulePragmaDecl $1 $ reverse $3 } +> | srcloc '{-# DEPRECATED' warndeprs '#-}' { DeprPragmaDecl $1 $ reverse $3 } +> | srcloc '{-# WARNING' warndeprs '#-}' { WarnPragmaDecl $1 $ reverse $3 } + | srcloc '{-# unknown' '#-}' { let (n, s) = $2 in UnknownDeclPragma $1 n s } +> | decl { $1 } + +> data_or_newtype :: { DataOrNew } +> : 'data' { DataType } +> | 'newtype' { NewType } + +> typelist :: { [Type] } +> : types {% do { ts <- mapM checkType $1; +> return $ reverse ts } } +> | truetype { [$1] } +> | {- empty -} { [] } + +> decls :: { [Decl] } +> : optsemis decls1 optsemis {% checkRevDecls $2 } +> | optsemis { [] } + +> decls1 :: { [Decl] } +> : decls1 semis decl { $3 : $1 } +> | decl { [$1] } + +> decl :: { Decl } +> : signdecl { $1 } +> | fixdecl { $1 } +> | valdef { $1 } + +> decllist :: { [Decl] } +> : '{' decls '}' { $2 } +> | open decls close { $2 } + +> signdecl :: { Decl } +> : srcloc exp0b '::' truectype {% do { v <- checkSigVar $2; +> return $ TypeSig $1 [v] $4 } } +> | srcloc exp0b ',' vars '::' truectype {% do { v <- checkSigVar $2; +> return $ TypeSig $1 (v : reverse $4) $6 } } +> | srcloc '{-# INLINE' activation qvar '#-}' { InlineSig $1 $2 $3 $4 } +> | srcloc '{-# SPECIALISE' qvar '::' sigtypes '#-}' { SpecSig $1 $3 $5 } +> | srcloc '{-# SPECIALISE_INLINE' activation qvar '::' sigtypes '#-}' +> { SpecInlineSig $1 $2 $3 $4 $6 } +> | srcloc '{-# SPECIALISE' 'instance' ctype '#-}' {% do { (cs,c,ts) <- checkInstHeader $4; +> return $ InstSig $1 cs c ts } } + +> sigtypes :: { [Type] } +> : sigtype { [ $1 ] } +> | sigtype ',' sigtypes { $1 : $3 } + +> sigtype :: { Type } +> : ctype {% checkType $ mkTyForall Nothing [] $1 } + +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 :: { Binds } +> : decllist { BDecls $1 } +> | '{' ipbinds '}' { IPBinds $2 } +> | open ipbinds close { IPBinds $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 :: { [Name] } +> : vars ',' var { $3 : $1 } +> | qvar {% do { n <- checkUnQual $1; +> return [n] } } + +----------------------------------------------------------------------------- +FFI + +These will only be called on in the presence of a 'foreign' keyword, +so no need to check for extensions. + +> callconv :: { CallConv } +> : 'stdcall' { StdCall } +> | 'ccall' { CCall } + +> safety :: { Safety } +> : 'safe' { PlaySafe False } +> | 'unsafe' { PlayRisky } +> | 'threadsafe' { PlaySafe True } +> | {- empty -} { PlaySafe False } + +> fspec :: { (String, Name, Type) } +> : STRING var_no_safety '::' truedtype { ($1, $2, $4) } +> | var_no_safety '::' truedtype { ("", $1, $3) } + +----------------------------------------------------------------------------- +Pragmas + +> rules :: { [Rule] } +> : rules ';'rule { $3 : $1 } +> | rules ';' { $1 } +> | rule { [$1] } +> | {- empty -} { [] } + +> rule :: { Rule } +> : STRING activation ruleforall exp0 '=' trueexp {% do { e <- checkRuleExpr $4; +> return $ Rule $1 $2 $3 e $6 } } + +> activation :: { Activation } +> : {- empty -} { AlwaysActive } +> | '[' INT ']' { ActiveFrom (fromInteger $2) } +> | '[' '~' INT ']' { ActiveUntil (fromInteger $3) } + +> ruleforall :: { Maybe [RuleVar] } +> : {- empty -} { Nothing } +> | 'forall' rulevars '.' { Just $2 } + +> rulevars :: { [RuleVar] } +> : rulevar { [$1] } +> | rulevar rulevars { $1 : $2 } + +> rulevar :: { RuleVar } +> : varid { RuleVar $1 } +> | '(' varid '::' truectype ')' { TypedRuleVar $2 $4 } + +> warndeprs :: { [([Name],String)] } +> : warndeprs ';' warndepr { $3 : $1 } +> | warndeprs ';' { $1 } +> | warndepr { [$1] } +> | {- empty -} { [] } + +> warndepr :: { ([Name], String) } +> : namevars STRING { ($1,$2) } + +> namevars :: { [Name] } +> : namevar { [$1] } +> | namevar ',' namevars { $1 : $3 } + +> namevar :: { Name } +> : con { $1 } +> | var { $1 } + +----------------------------------------------------------------------------- +Types + +Type equality contraints need the TypeFamilies extension. + +> truedtype :: { Type } +> : dtype {% checkType $1 } + +> dtype :: { PType } +> : btype { $1 } +> | btype qtyconop dtype { TyInfix $1 $2 $3 } +> | btype qtyvarop dtype { TyInfix $1 $2 $3 } -- FIXME +> | btype '->' ctype { TyFun $1 $3 } +> | btype '~' btype {% do { checkEnabled TypeFamilies ; +> return $ TyPred $ EqualP $1 $3 } } + +Implicit parameters can occur in normal types, as well as in contexts. + +> truetype :: { Type } +> : type {% checkType $1 } + +> type :: { PType } +> : ivar '::' dtype { TyPred $ IParam $1 $3 } +> | dtype { $1 } + +> truebtype :: { Type } +> : btype {% checkType $1 } + +> btype :: { PType } +> : btype atype { TyApp $1 $2 } +> | atype { $1 } + +UnboxedTuples requires the extension, but that will be handled through +the (# and #) lexemes. Kinds will be handled at the kind rule. + +> trueatype :: { Type } +> : atype {% checkType $1 } + +> atype :: { PType } +> : gtycon { TyCon $1 } +> | tyvar { TyVar $1 } +> | '(' types ')' { TyTuple Boxed (reverse $2) } +> | '(#' types1 '#)' { TyTuple Unboxed (reverse $2) } +> | '[' type ']' { TyApp (TyCon list_tycon_name) $2 } +> | '(' ctype ')' { TyParen $2 } +> | '(' ctype '::' kind ')' { TyKind $2 $4 } + +> gtycon :: { QName } +> : otycon { $1 } +> | '(' ')' { unit_tycon_name } +> | '(' '->' ')' { fun_tycon_name } +> | '[' ']' { list_tycon_name } +> | '(' commas ')' { tuple_tycon_name Boxed $2 } +> | '(#' '#)' { unboxed_singleton_tycon_name } +> | '(#' commas '#)' { tuple_tycon_name Unboxed $2 } + +> otycon :: { QName } +> : qconid { $1 } +> | '(' gconsym ')' { $2 } + +These are for infix types + +> qtyconop :: { QName } +> : 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! + +Forall-quantified types require some extension to enable them, which +is any of the keyword-enabling ones, except ExistentialQuantification. + +> truectype :: { Type } +> : ctype {% checkType $1 } + +> ctype :: { PType } +> : 'forall' ktyvars '.' ctype { mkTyForall (Just $2) [] $4 } +> | context '=>' type { mkTyForall Nothing $1 $3 } +> | type { $1 } + +Equality constraints require the TypeFamilies extension. + +> context :: { PContext } +> : btype {% checkPContext $1 } +> | btype '~' btype {% checkEnabled TypeFamilies >> checkPContext (TyPred $ EqualP $1 $3) } + +> types :: { [PType] } +> : types1 ',' type { $3 : $1 } + +> types1 :: { [PType] } +> : type { [$1] } +> | types1 ',' type { $3 : $1 } + +> ktyvars :: { [TyVarBind] } +> : ktyvars ktyvar { $2 : $1 } +> | {- empty -} { [] } + +> ktyvar :: { TyVarBind } +> : tyvar { UnkindedVar $1 } +> | '(' tyvar '::' kind ')' { KindedVar $2 $4 } + +> tyvars :: { [Name] } +> : tyvars tyvar { $2 : $1 } +> | {- empty -} { [] } + + +----------------------------------------------------------------------------- +Functional Dependencies + +These require the FunctionalDependencies extension to be enabled. + +> fds :: { [FunDep] } +> : {- empty -} { [] } +> | '|' fds1 {% checkEnabled FunctionalDependencies >> return (reverse $2) } + +> fds1 :: { [FunDep] } +> : fds1 ',' fd { $3 : $1 } +> | fd { [$1] } + +> fd :: { FunDep } +> : tyvars '->' tyvars { FunDep (reverse $1) (reverse $3) } + +----------------------------------------------------------------------------- +Datatype declarations + +GADTs - require the GADTs extension enabled, but we handle that at the calling site. + +> gadtlist :: { [GadtDecl] } +> : gadtlist1 {% checkEnabled GADTs >> return $1 } + +> gadtlist1 :: { [GadtDecl] } +> : '{' gadtconstrs1 '}' { $2 } +> | open gadtconstrs1 close { $2 } + +> gadtconstrs1 :: { [GadtDecl] } +> : optsemis gadtconstrs optsemis { $2 } + +> gadtconstrs :: { [GadtDecl] } +> : gadtconstrs semis gadtconstr { $3 : $1 } +> | gadtconstr { [$1] } + +> gadtconstr :: { GadtDecl } +> : srcloc qcon '::' truectype {% do { c <- checkUnQual $2; +> return $ GadtDecl $1 c $4 } } + +To allow the empty case we need the EmptyDataDecls extension. +> constrs0 :: { [QualConDecl] } +> : {- empty -} {% checkEnabled EmptyDataDecls >> return [] } +> | '=' constrs { $2 } + +> constrs :: { [QualConDecl] } +> : constrs '|' constr { $3 : $1 } +> | constr { [$1] } + +> constr :: { QualConDecl } +> : srcloc forall context '=>' constr1 {% do { checkEnabled ExistentialQuantification ; +> ctxt <- checkContext $3 ; +> return $ QualConDecl $1 $2 ctxt $5 } } +> | srcloc forall constr1 { QualConDecl $1 $2 [] $3 } + +> forall :: { [TyVarBind] } +> : 'forall' ktyvars '.' {% checkEnabled ExistentialQuantification >> return $2 } +> | {- empty -} { [] } + +To avoid conflicts when introducing type operators, we need to parse record constructors +as qcon and then check separately that they are truly unqualified. + +> constr1 :: { ConDecl } +> : scontype { ConDecl (fst $1) (snd $1) } +> | sbtype conop sbtype { InfixConDecl $1 $2 $3 } +> | qcon '{' '}' {% do { c <- checkUnQual $1; return $ RecDecl c [] } } +> | qcon '{' fielddecls '}' {% do { c <- checkUnQual $1; return $ RecDecl c (reverse $3) } } + +> scontype :: { (Name, [BangType]) } +> : btype {% do { (c,ts) <- splitTyConApp $1; +> return (c,map UnBangedTy ts) } } +> | scontype1 { $1 } + +> scontype1 :: { (Name, [BangType]) } +> : btype '!' trueatype {% do { (c,ts) <- splitTyConApp $1; +> return (c,map UnBangedTy ts++ +> [BangedTy $3]) } } +> | btype '{-# UNPACK' '#-}' '!' trueatype {% do { (c,ts) <- splitTyConApp $1; +> return (c,map UnBangedTy ts++ +> [UnpackedTy $5]) } } +> | scontype1 satype { (fst $1, snd $1 ++ [$2] ) } + +> satype :: { BangType } +> : trueatype { UnBangedTy $1 } +> | '!' trueatype { BangedTy $2 } +> | '{-# UNPACK' '#-}' '!' trueatype { UnpackedTy $4 } + +> sbtype :: { BangType } +> : truebtype { UnBangedTy $1 } +> | '!' trueatype { BangedTy $2 } +> | '{-# UNPACK' '#-}' '!' trueatype { UnpackedTy $4 } + +> fielddecls :: { [([Name],BangType)] } +> : fielddecls ',' fielddecl { $3 : $1 } +> | fielddecl { [$1] } + +> fielddecl :: { ([Name],BangType) } +> : vars '::' stype { (reverse $1, $3) } + +> stype :: { BangType } +> : truectype { UnBangedTy $1 } +> | '!' trueatype { BangedTy $2 } +> | '{-# UNPACK' '#-}' '!' trueatype { UnpackedTy $4 } + +> deriving :: { [Deriving] } +> : {- empty -} { [] } +> | 'deriving' qtycls1 { [($2, [])] } +> | 'deriving' '(' ')' { [] } +> | 'deriving' '(' dclasses ')' { reverse $3 } + +> dclasses :: { [Deriving] } +> : types1 {% checkDeriving $1 } + +> qtycls1 :: { QName } +> : qconid { $1 } + + +----------------------------------------------------------------------------- +Kinds + +> kind :: { Kind } +> : kind1 {% checkEnabled KindSignatures >> return $1 } + +> kind1 :: { Kind } +> : akind { $1 } +> | akind '->' kind1 { KindFn $1 $3 } + +> akind :: { Kind } +> : '*' { KindStar } +> | '!' { KindBang } +> | '(' kind1 ')' { $2 } + +> optkind :: { Maybe Kind } +> : {-empty-} { Nothing } +> | '::' kind { Just $2 } +----------------------------------------------------------------------------- +Class declarations + +No implicit parameters in the where clause of a class declaration. +> optcbody :: { [ClassDecl] } +> : 'where' cldecllist {% checkClassBody $2 } +> | {- empty -} { [] } + +> cldecllist :: { [ClassDecl] } +> : '{' cldecls '}' { $2 } +> | open cldecls close { $2 } + +> cldecls :: { [ClassDecl] } +> : optsemis cldecls1 optsemis {% checkRevClsDecls $2 } +> | optsemis { [] } + +> cldecls1 :: { [ClassDecl] } +> : cldecls1 semis cldecl { $3 : $1 } +> | cldecl { [$1] } + +Associated types require the TypeFamilies extension. + +> cldecl :: { ClassDecl } +> : decl { ClsDecl $1 } +> | atdecl {% checkEnabled TypeFamilies >> return $1 } + +> atdecl :: { ClassDecl } +> : srcloc 'type' type optkind +> {% do { (c,ts) <- checkSimpleType $3; +> return (ClsTyFam $1 c ts $4) } } +> | srcloc 'type' truedtype '=' truectype +> { ClsTyDef $1 $3 $5 } +> | srcloc 'data' ctype optkind +> {% do { (cs,c,t) <- checkDataHeader $3; +> return (ClsDataFam $1 cs c t $4) } } + +----------------------------------------------------------------------------- +Instance declarations + +> optvaldefs :: { [InstDecl] } +> : 'where' '{' valdefs '}' {% checkInstBody $3 } +> | 'where' open valdefs close {% checkInstBody $3 } +> | {- empty -} { [] } + +> valdefs :: { [InstDecl] } +> : optsemis valdefs1 optsemis {% checkRevInstDecls $2 } +> | optsemis { [] } + +> valdefs1 :: { [InstDecl] } +> : valdefs1 semis insvaldef { $3 : $1 } +> | insvaldef { [$1] } + +Associated types require the TypeFamilies extension enabled. + +> insvaldef :: { InstDecl } +> : valdef { InsDecl $1 } +> | atinst {% checkEnabled TypeFamilies >> return $1 } +> | inlinst { $1 } + +> inlinst :: { InstDecl } +> : srcloc '{-# INLINE' activation qvar '#-}' { InsInline $1 $2 $3 $4 } + +> atinst :: { InstDecl } +> : srcloc 'type' truedtype '=' truectype +> {% do { -- no checkSimpleType $4 since dtype may contain type patterns +> return (InsType $1 $3 $5) } } +> | srcloc data_or_newtype truectype constrs0 deriving +> {% do { -- (cs,c,t) <- checkDataHeader $4; +> checkDataOrNew $2 $4; +> return (InsData $1 $2 $3 (reverse $4) $5) } } +> | srcloc data_or_newtype truectype optkind 'where' gadtlist deriving +> {% do { -- (cs,c,t) <- checkDataHeader $4; +> checkDataOrNew $2 $6; +> return (InsGData $1 $2 $3 $4 (reverse $6) $7) } } + +----------------------------------------------------------------------------- +Value definitions + +> valdef :: { Decl } +> : srcloc exp0b optsig rhs optwhere {% checkValDef $1 $2 $3 $4 $5 } +> | srcloc '!' aexp rhs optwhere {% do { checkEnabled BangPatterns ; +> p <- checkPattern $3; +> return $ PatBind $1 p Nothing $4 $5 } } + +May bind implicit parameters +> optwhere :: { Binds } +> : 'where' binds { $2 } +> | {- empty -} { BDecls [] } + +Type signatures on value definitions require ScopedTypeVariables (or PatternSignatures, which is deprecated). + +> optsig :: { Maybe Type } +> : '::' truectype {% checkEnabled ScopedTypeVariables >> return (Just $2) } +> | {- empty -} { Nothing } + +> rhs :: { Rhs } +> : '=' trueexp { UnGuardedRhs $2 } +> | gdrhs { GuardedRhss (reverse $1) } + +> gdrhs :: { [GuardedRhs] } +> : gdrhs gdrh { $2 : $1 } +> | gdrh { [$1] } + +Guards may contain patterns if PatternGuards is enabled, hence quals instead of exp. +> gdrh :: { GuardedRhs } +> : srcloc '|' quals '=' trueexp {% checkPatternGuards $3 >> return (GuardedRhs $1 (reverse $3) $5) } + +----------------------------------------------------------------------------- +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). + +Ugly: We need non-parenthesized post-operators for HaRP, and to parse both +these and normal left sections, we parse both as PostOp and let the post pass +mangle them into the correct form depending on context. + +> trueexp :: { Exp } +> : exp {% checkExpr $1 } + +> exp :: { PExp } +> : exp0b '::' srcloc truectype { ExpTypeSig $3 $1 $4 } +> | exp0 { $1 } +> | exp0b qop { PostOp $1 $2 } +> | exp0b '-<' exp { LeftArrApp $1 $3 } +> | exp0b '>-' exp { RightArrApp $1 $3 } +> | exp0b '-<<' exp { LeftArrHighApp $1 $3 } +> | exp0b '>>-' exp { RightArrHighApp $1 $3 } + +> exp0 :: { PExp } +> : exp0a { $1 } +> | exp0b { $1 } + +> exp0a :: { PExp } +> : exp0b qop exp10a { InfixApp $1 $2 $3 } +> | exp10a { $1 } + +Hyphenated identifiers require XmlSyntax to be enabled, handled in the lexer. + +> exp0b :: { PExp } +> : exp0b qop exp10b { InfixApp $1 $2 $3 } +> | dvarexp { $1 } +> | exp10b { $1 } + +> exp10a :: { PExp } +> : '\\' srcloc apats '->' exp { Lambda $2 (reverse $3) $5 } +A let may bind implicit parameters +> | 'let' binds 'in' exp { Let $2 $4 } +> | 'if' exp 'then' exp 'else' exp { If $2 $4 $6 } +> | 'proc' apat '->' exp { Proc $2 $4 } + +mdo blocks require the RecursiveDo extension enabled, but the lexer handles that. + +> exp10b :: { PExp } +> : 'case' exp 'of' altslist { Case $2 $4 } +> | '-' fexp { NegApp $2 } +> | 'do' stmtlist { Do $2 } +> | 'mdo' stmtlist { MDo $2 } +> | exppragma { $1 } +> | fexp { $1 } + +> exppragma :: { PExp } +> : '{-# CORE' STRING '#-}' { CorePragma $2 } +> | '{-# SCC' STRING '#-}' { SCCPragma $2 } +> | '{-# GENERATED' STRING INT ':' INT '-' INT ':' INT '#-}' +> { GenPragma $2 (fromInteger $3, fromInteger $5) +> (fromInteger $7, fromInteger $9) } + | '{-# unknown' '#-}' { let (n, s) = $1 in UnknownExpPragma n s } + +> fexp :: { PExp } +> : fexp aexp { App $1 $2 } +> | aexp { $1 } + +> apats :: { [Pat] } +> : apats apat { $2 : $1 } +> | apat { [$1] } + +> apat :: { Pat } +> : aexp {% checkPattern $1 } +> | '!' aexp {% checkPattern (BangPat $2) } + +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). + +Non-linear name binding, @:, requires RegularPatterns, but the lexer handles that. + +> aexp :: { PExp } +> : qvar '@' aexp {% do { n <- checkUnQual $1; +> return (AsPat n $3) } } +> | qvar '@:' aexp {% do { n <- checkUnQual $1; +> return (CAsRP n $3) } } +> | '~' aexp { IrrPat $2 } +> | aexp1 { $1 } + +Note: The first two alternatives of aexp1 are not necessarily record +updates: they could be labeled constructions. +Generics-style explicit type arguments need the Generics extension, but +we check that in the lexer. + +> aexp1 :: { PExp } +> : aexp1 '{' '}' {% mkRecConstrOrUpdate $1 [] } +> | aexp1 '{' fbinds '}' {% mkRecConstrOrUpdate $1 (reverse $3) } +> | qvar '{|' truetype '|}' { ExplTypeArg $1 $3 } +> | aexp2 { $1 } + +According to the Report, the left section (e op) is legal iff (e op x) +parses equivalently to ((e) op x). Thus e must be an exp0b. +An implicit parameter can be used as an expression, enabled by the lexer. +Extensions using banana brackets are also enabled by the lexer. The only +thing we need to look at here is the erpats that use no non-standard lexemes. + +> aexp2 :: { PExp } +> : ivar { IPVar $1 } +> | qvar { Var $1 } +> | gcon { $1 } +> | literal { Lit $1 } +> | '(' texp ')' { Paren $2 } +> | '(' texp ',' texps ')' { Tuple ($2 : reverse $4) } +> | '[' list ']' { $2 } +We parse left sections as PostOp instead, and post-mangle them, see above + | '(' exp0b rqop ')' { LeftSection $2 $3 } -- this line is commented out +> | '(' qopm exp0 ')' { RightSection $2 $3 } +> | '_' { WildCard } +> | '(' erpats ')' {% checkEnabled RegularPatterns >> return $2 } +> | '(|' sexps '|)' { SeqRP $ reverse $2 } +> | '(|' exp '|' quals '|)' { GuardRP $2 $ reverse $4 } +> | xml { $1 } + +Template Haskell - all this is enabled in the lexer. +> | IDSPLICE { SpliceExp $ IdSplice $1 } +> | '$(' trueexp ')' { SpliceExp $ ParenSplice $2 } +> | '[|' trueexp '|]' { BracketExp $ ExpBracket $2 } +> | '[p|' exp0 '|]' {% do { p <- checkPattern $2; +> return $ BracketExp $ PatBracket p } } +> | '[t|' truectype '|]' { BracketExp $ TypeBracket $2 } +> | '[d|' open topdecls close '|]' { BracketExp $ DeclBracket $3 } +> | VARQUOTE qvar { VarQuote $2 } +> | VARQUOTE qcon { VarQuote $2 } +> | TYPQUOTE tyvar { TypQuote (UnQual $2) } +> | TYPQUOTE gtycon { TypQuote $2 } +> | QUASIQUOTE { let (n,q) = $1 in QuasiQuote n q } +End Template Haskell + +> commas :: { Int } +> : commas ',' { $1 + 1 } +> | ',' { 1 } + +> texps :: { [PExp] } +> : texps ',' texp { $3 : $1 } +> | texp { [$1] } + +> texp :: { PExp } +> : exp { $1 } +> | exp '->' exp {% checkEnabled ViewPatterns >> return (ViewPat $1 $3) } + +----------------------------------------------------------------------------- +Harp Extensions + +> sexps :: { [PExp] } +> : sexps ',' exp { $3 : $1 } +> | exp { [$1] } + +Either patterns are left associative +> erpats :: { PExp } +> : exp '|' erpats { EitherRP $1 $3 } +> | exp '|' exp { EitherRP $1 $3 } + +----------------------------------------------------------------------------- +Hsx Extensions - requires XmlSyntax, but the lexer handles all that. + +> xml :: { PExp } +> : srcloc '<' name attrs mattr '>' children '' {% do { n <- checkEqNames $3 $9; +> let { cn = reverse $7; +> as = reverse $4; }; +> return $ XTag $1 n as $5 cn } } +> | srcloc '<' name attrs mattr '/>' { XETag $1 $3 (reverse $4) $5 } +> | '<%' exp '%>' { XExpTag $2 } + +> children :: { [PExp] } +> : children child { $2 : $1 } +> | {- empty -} { [] } + +> child :: { PExp } +> : PCDATA { XPcdata $1 } +> | '<[' sexps ']>' { XRPats $ reverse $2 } +> | xml { $1 } + +> name :: { XName } +> : xmlname ':' xmlname { XDomName $1 $3 } +> | xmlname { XName $1 } + +> xmlname :: { String } +> : VARID { $1 } +> | CONID { $1 } +> | DVARID { mkDVar $1 } +> | xmlkeyword { $1 } + +> xmlkeyword :: { String } +> : 'type' { "type" } +> | 'class' { "class" } +> | 'data' { "data" } +> | 'foreign' { "foreign" } +> | 'export' { "export" } +> | 'safe' { "safe" } +> | 'unsafe' { "unsafe" } +> | 'threadsafe' { "threadsafe" } +> | 'stdcall' { "stdcall" } +> | 'ccall' { "ccall" } +> | 'as' { "as" } +> | 'by' { "by" } +> | 'case' { "case" } +> | 'default' { "default" } +> | 'deriving' { "deriving" } +> | 'do' { "do" } +> | 'else' { "else" } +> | 'family' { "family" } +> | 'forall' { "forall" } +> | 'group' { "group" } +> | 'hiding' { "hiding" } +> | 'if' { "if" } +> | 'import' { "import" } +> | 'in' { "in" } +> | 'infix' { "infix" } +> | 'infixl' { "infixl" } +> | 'infixr' { "infixr" } +> | 'instance' { "instance" } +> | 'let' { "let" } +> | 'mdo' { "mdo" } +> | 'module' { "module" } +> | 'newtype' { "newtype" } +> | 'of' { "of" } +> | 'proc' { "proc" } +> | 'rec' { "rec" } +> | 'then' { "then" } +> | 'using' { "using" } +> | 'where' { "where" } +> | 'qualified' { "qualified" } + + +> attrs :: { [ParseXAttr] } +> : attrs attr { $2 : $1 } +> | {- empty -} { [] } + +> attr :: { ParseXAttr } +> : name '=' aexp { XAttr $1 $3 } + +> mattr :: { Maybe PExp } +> : aexp { Just $1 } +> | {-empty-} { Nothing } + +Turning dash variables into infix expressions with '-' +> dvarexp :: { PExp } +> : DVARID { mkDVarExpr $1 } + +----------------------------------------------------------------------------- +List expressions + +The rules below are little bit contorted to keep lexps left-recursive while +avoiding another shift/reduce-conflict. + +> list :: { PExp } +> : texp { List [$1] } +> | lexps { List (reverse $1) } +> | texp '..' { EnumFrom $1 } +> | texp ',' exp '..' { EnumFromThen $1 $3 } +> | texp '..' exp { EnumFromTo $1 $3 } +> | texp ',' exp '..' exp { EnumFromThenTo $1 $3 $5 } +> | texp '|' pqualstmts { ParComp $1 (reverse $3) } + +> lexps :: { [PExp] } +> : lexps ',' texp { $3 : $1 } +> | texp ',' texp { [$3,$1] } + +----------------------------------------------------------------------------- +List comprehensions + +> pqualstmts :: { [[QualStmt]] } +> : pqualstmts '|' qualstmts { reverse $3 : $1 } +> | qualstmts { [$1] } + +> qualstmts :: { [QualStmt] } +> : qualstmts ',' qualstmt { $3 : $1 } +> | qualstmt { [$1] } + +> qualstmt :: { QualStmt } +> : transformqual { $1 } +> | qual { QualStmt $1 } + +> transformqual :: { QualStmt } +> : 'then' trueexp { ThenTrans $2 } +> | 'then' trueexp 'by' trueexp { ThenBy $2 $4 } +> | 'then' 'group' 'by' trueexp { GroupBy $4 } +> | 'then' 'group' 'using' trueexp { GroupUsing $4 } +> | 'then' 'group' 'by' trueexp 'using' trueexp { GroupByUsing $4 $6 } + +> quals :: { [Stmt] } +> : quals ',' qual { $3 : $1 } +> | qual { [$1] } + +> qual :: { Stmt } +> : pat srcloc '<-' trueexp { Generator $2 $1 $4 } +> | trueexp { Qualifier $1 } +> | 'let' binds { LetStmt $2 } + + +----------------------------------------------------------------------------- +Case alternatives + +> altslist :: { [Alt] } +> : '{' alts '}' { $2 } +> | open alts close { $2 } + +> alts :: { [Alt] } +> : optsemis alts1 optsemis { reverse $2 } + +> alts1 :: { [Alt] } +> : alts1 semis alt { $3 : $1 } +> | alt { [$1] } + +> alt :: { Alt } +> : srcloc pat ralt optwhere { Alt $1 $2 $3 $4 } + +> ralt :: { GuardedAlts } +> : '->' trueexp { UnGuardedAlt $2 } +> | gdpats { GuardedAlts (reverse $1) } + +> gdpats :: { [GuardedAlt] } +> : gdpats gdpat { $2 : $1 } +> | gdpat { [$1] } + +A guard can be a pattern guard if PatternGuards is enabled, hence quals instead of exp0. +> gdpat :: { GuardedAlt } +> : srcloc '|' quals '->' trueexp {% do { checkPatternGuards $3; +> return (GuardedAlt $1 (reverse $3) $5) } } + +> pat :: { Pat } +> : exp {% checkPattern $1 } +> | '!' aexp {% checkPattern (BangPat $2) } +----------------------------------------------------------------------------- +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 :: { [Stmt] } +> : '{' stmts '}' { $2 } +> | open stmts close { $2 } + +A let statement may bind implicit parameters. +> stmts :: { [Stmt] } +> : 'let' binds ';' stmts { LetStmt $2 : $4 } +> | pat srcloc '<-' trueexp ';' stmts { Generator $2 $1 $4 : $6 } +> | trueexp ';' stmts { Qualifier $1 : $3 } +> | ';' stmts { $2 } +> | trueexp ';' { [Qualifier $1] } +> | trueexp { [Qualifier $1] } +> | 'rec' stmtlist ';' stmts { RecStmt $2 : $4 } + +----------------------------------------------------------------------------- +Record Field Update/Construction + +> fbinds :: { [PFieldUpdate] } +> : fbinds ',' fbind { $3 : $1 } +> | fbind { [$1] } + +Puns and wild cards need the respective extensions enabled. + +> fbind :: { PFieldUpdate } +> : qvar '=' exp { FieldUpdate $1 $3 } +> | var {% checkEnabled NamedFieldPuns >> return (FieldPun $1) } +> | '..' {% checkEnabled RecordWildCards >> return FieldWildcard } + +----------------------------------------------------------------------------- +Implicit parameter bindings - need the ImplicitParameter extension enabled, but the lexer handles that. + +> ipbinds :: { [IPBind] } +> : optsemis ipbinds1 optsemis { reverse $2 } + +> ipbinds1 :: { [IPBind] } +> : ipbinds1 semis ipbind { $3 : $1 } +> | ipbind { [$1] } + +> ipbind :: { IPBind } +> : srcloc ivar '=' trueexp { IPBind $1 $2 $4 } + +----------------------------------------------------------------------------- +Variables, Constructors and Operators. + +> gcon :: { PExp } +> : '(' ')' { p_unit_con } +> | '[' ']' { List [] } +> | '(' commas ')' { p_tuple_con Boxed $2 } +> | '(#' '#)' { p_unboxed_singleton_con } +> | '(#' commas '#)' { p_tuple_con Unboxed $2 } +> | qcon { Con $1 } + +> var :: { Name } +> : varid { $1 } +> | '(' varsym ')' { $2 } + +> var_no_safety :: { Name } +> : varid_no_safety { $1 } +> | '(' varsym ')' { $2 } + +> qvar :: { QName } +> : qvarid { $1 } +> | '(' qvarsym ')' { $2 } + +Implicit parameter +> ivar :: { IPName } +> : ivarid { $1 } + +> con :: { Name } +> : conid { $1 } +> | '(' consym ')' { $2 } + +> qcon :: { QName } +> : qconid { $1 } +> | '(' gconsym ')' { $2 } + +> varop :: { Name } +> : varsym { $1 } +> | '`' varid '`' { $2 } + +> qvarop :: { QName } +> : qvarsym { $1 } +> | '`' qvarid '`' { $2 } + +> qvaropm :: { QName } +> : qvarsymm { $1 } +> | '`' qvarid '`' { $2 } + +> conop :: { Name } +> : consym { $1 } +> | '`' conid '`' { $2 } + +> qconop :: { QName } +> : gconsym { $1 } +> | '`' qconid '`' { $2 } + +> op :: { Op } +> : varop { VarOp $1 } +> | conop { ConOp $1 } + +> qop :: { QOp } +> : qvarop { QVarOp $1 } +> | qconop { QConOp $1 } + +> qopm :: { QOp } +> : qvaropm { QVarOp $1 } +> | qconop { QConOp $1 } + +> gconsym :: { QName } +> : ':' { list_cons_name } +> | qconsym { $1 } + +----------------------------------------------------------------------------- +Identifiers and Symbols + +> qvarid :: { QName } +> : varid { UnQual $1 } +> | QVARID { Qual (ModuleName (fst $1)) (Ident (snd $1)) } + +> varid_no_safety :: { Name } +> : VARID { Ident $1 } +> | 'as' { as_name } +> | 'qualified' { qualified_name } +> | 'hiding' { hiding_name } +> | 'export' { export_name } +> | 'stdcall' { stdcall_name } +> | 'ccall' { ccall_name } + +> varid :: { Name } +> : varid_no_safety { $1 } +> | 'safe' { safe_name } +> | 'unsafe' { unsafe_name } +> | 'threadsafe' { threadsafe_name } + + +Implicit parameter +> ivarid :: { IPName } +> : IDUPID { IPDup $1 } +> | ILINID { IPLin $1 } + +> qconid :: { QName } +> : conid { UnQual $1 } +> | QCONID { Qual (ModuleName (fst $1)) (Ident (snd $1)) } + +> conid :: { Name } +> : CONID { Ident $1 } + +> qconsym :: { QName } +> : consym { UnQual $1 } +> | QCONSYM { Qual (ModuleName (fst $1)) (Symbol (snd $1)) } + +> consym :: { Name } +> : CONSYM { Symbol $1 } + +> qvarsym :: { QName } +> : varsym { UnQual $1 } +> | qvarsym1 { $1 } + +> qvarsymm :: { QName } +> : varsymm { UnQual $1 } +> | qvarsym1 { $1 } + +> varsym :: { Name } +> : VARSYM { Symbol $1 } +> | '-' { minus_name } +> | '!' { bang_name } +> | '.' { dot_name } +> | '*' { star_name } + +> varsymm :: { Name } -- varsym not including '-' +> : VARSYM { Symbol $1 } +> | '!' { bang_name } +> | '.' { dot_name } +> | '*' { star_name } + +> qvarsym1 :: { QName } +> : QVARSYM { Qual (ModuleName (fst $1)) (Symbol (snd $1)) } + +> literal :: { Literal } +> : INT { Int $1 } +> | CHAR { Char $1 } +> | RATIONAL { Frac $1 } +> | STRING { String $1 } +> | PRIMINT { PrimInt $1 } +> | PRIMWORD { PrimWord $1 } +> | PRIMFLOAT { PrimFloat $1 } +> | PRIMDOUBLE { PrimDouble $1 } +> | PRIMCHAR { PrimChar $1 } +> | PRIMSTRING { PrimString $1 } + + +> srcloc :: { SrcLoc } : {% getSrcLoc } + +----------------------------------------------------------------------------- +Layout + +> open :: { () } : {% pushCurrentContext {- >>= \x -> trace (show x) (return x) -} } + +> close :: { () } +> : vccurly {% return () {- >>= \x -> trace (show x ++ show x ++ show x) (return x) -} } -- context popped in lexer. +> | error {% popContext {- >>= \x -> trace (show x ++ show x) (return x) -} } + +----------------------------------------------------------------------------- +Miscellaneous (mostly renamings) + +> modid :: { ModuleName } +> : CONID { ModuleName $1 } +> | QCONID { ModuleName (fst $1 ++ '.':snd $1) } + +> tyconorcls :: { Name } +> : con { $1 } + + tycon :: { Name } + : conid { $1 } + +> qtyconorcls :: { QName } +> : qcon { $1 } + +> tyvar :: { Name } +> : varid { $1 } + +> qtyvarop :: { QName } +> qtyvarop : '`' tyvar '`' { UnQual $2 } +> | tyvarsym { UnQual $1 } + +> tyvarsym :: { Name } +> tyvarsym : VARSYM { Symbol $1 } + +----------------------------------------------------------------------------- + +> { +> happyError :: P a +> happyError = fail "Parse error" + +> -- | Parse of a string, which should contain a complete Haskell module. +> parseModule :: String -> ParseResult Module +> parseModule = fmap (applyFixities preludeFixities) . runParser mparseModule + +> -- | Parse of a string, which should contain a complete Haskell 98 module. +> parseModuleWithMode :: ParseMode -> String -> ParseResult Module +> parseModuleWithMode mode = fmap (applyFixities (fixities mode)) . runParserWithMode mode mparseModule + +> -- | Parse of a string containing a Haskell expression. +> parseExp :: String -> ParseResult Exp +> parseExp = fmap (applyFixities preludeFixities) . runParser mparseExp + +> -- | Parse of a string, which should contain a complete Haskell 98 module. +> parseExpWithMode :: ParseMode -> String -> ParseResult Exp +> parseExpWithMode mode = fmap (applyFixities (fixities mode)) . runParserWithMode mode mparseExp + +> -- | Parse of a string containing a Haskell pattern. +> parsePat :: String -> ParseResult Pat +> parsePat = fmap (applyFixities preludeFixities) . runParser mparsePat + +> -- | Parse of a string, which should contain a complete Haskell 98 module. +> parsePatWithMode :: ParseMode -> String -> ParseResult Pat +> parsePatWithMode mode = fmap (applyFixities (fixities mode)) . runParserWithMode mode mparsePat + +> -- | Parse of a string containing a Haskell top-level declaration. +> parseDecl :: String -> ParseResult Decl +> parseDecl = fmap (applyFixities preludeFixities) . runParser mparseDecl + +> -- | Parse of a string, which should contain a complete Haskell 98 module. +> parseDeclWithMode :: ParseMode -> String -> ParseResult Decl +> parseDeclWithMode mode = fmap (applyFixities (fixities mode)) . runParserWithMode mode mparseDecl + +> -- | Parse of a string containing a Haskell type. +> parseType :: String -> ParseResult Type +> parseType = runParser mparseType + +> -- | Parse of a string, which should contain a complete Haskell 98 module. +> parseTypeWithMode :: ParseMode -> String -> ParseResult Type +> parseTypeWithMode mode = runParserWithMode mode mparseType + +> -- | Parse of a string starting with a series of top-level option pragmas. +> getTopPragmas :: String -> ParseResult [OptionPragma] +> getTopPragmas = runParser mfindOptPragmas + +> -- | Class to reuse the parse function at many different types +> class Parseable ast where +> parse :: String -> ParseResult ast +> parseWithMode :: ParseMode -> String -> ParseResult ast +> +> instance Parseable Module where +> parse = parseModule +> parseWithMode = parseModuleWithMode +> +> instance Parseable Exp where +> parse = parseExp +> parseWithMode = parseExpWithMode +> +> instance Parseable Pat where +> parse = parsePat +> parseWithMode = parsePatWithMode +> +> instance Parseable Decl where +> parse = parseDecl +> parseWithMode = parseDeclWithMode +> +> instance Parseable Type where +> parse = parseType +> parseWithMode = parseTypeWithMode +> + + +> } diff --git a/src/Language/Haskell/Exts/Pretty.hs b/src/Language/Haskell/Exts/Pretty.hs new file mode 100644 --- /dev/null +++ b/src/Language/Haskell/Exts/Pretty.hs @@ -0,0 +1,1201 @@ +{-# OPTIONS_GHC -w #-} +----------------------------------------------------------------------------- +-- | +-- Module : Language.Haskell.Exts.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.Exts.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.Exts.Syntax + +import qualified Text.PrettyPrint as P +import Data.List (intersperse) + +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 Module where + pretty (Module pos m os mbWarn mbExports imp decls) = + markLine pos $ + myVcat $ map pretty os ++ + (if m == ModuleName "" then id + else \x -> [topLevel (ppModuleHeader m mbWarn mbExports) x]) + (map pretty imp ++ map pretty decls) + +-------------------------- Module Header ------------------------------ +ppModuleHeader :: ModuleName -> Maybe WarningText -> Maybe [ExportSpec] -> Doc +ppModuleHeader m mbWarn mbExportList = mySep [ + text "module", + pretty m, + maybePP ppWarnTxt mbWarn, + maybePP (parenList . map pretty) mbExportList, + text "where"] + +ppWarnTxt :: WarningText -> Doc +ppWarnTxt (DeprText s) = mySep [text "{-# DEPRECATED", text s, text "#-}"] +ppWarnTxt (WarnText s) = mySep [text "{-# WARNING", text s, text "#-}"] + +instance Pretty ModuleName where + pretty (ModuleName modName) = text modName + +instance Pretty ExportSpec where + pretty (EVar name) = pretty name + pretty (EAbs name) = pretty name + pretty (EThingAll name) = pretty name <> text "(..)" + pretty (EThingWith name nameList) = + pretty name <> (parenList . map pretty $ nameList) + pretty (EModuleContents m) = text "module" <+> pretty m + +instance Pretty ImportDecl where + pretty (ImportDecl pos m qual src mbPkg mbName mbSpecs) = + markLine pos $ + mySep [text "import", + if src then text "{-# SOURCE #-}" else empty, + if qual then text "qualified" else empty, + maybePP (\s -> text (show s)) mbPkg, + 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 ImportSpec where + pretty (IVar name) = pretty name + pretty (IAbs name) = pretty name + pretty (IThingAll name) = pretty name <> text "(..)" + pretty (IThingWith name nameList) = + pretty name <> (parenList . map pretty $ nameList) + +------------------------- Declarations ------------------------------ +instance Pretty Decl where + pretty (TypeDecl loc name nameList htype) = + blankline $ + markLine loc $ + mySep ( [text "type", pretty name] + ++ map pretty nameList + ++ [equals, pretty htype]) + + pretty (DataDecl loc don context name nameList constrList derives) = + blankline $ + markLine loc $ + mySep ( [pretty don, ppContext context, pretty name] + ++ map pretty nameList) + <+> (myVcat (zipWith (<+>) (equals : repeat (char '|')) + (map pretty constrList)) + $$$ ppDeriving derives) + + pretty (GDataDecl loc don context name nameList optkind gadtList derives) = + blankline $ + markLine loc $ + mySep ( [pretty don, ppContext context, pretty name] + ++ map pretty nameList ++ ppOptKind optkind ++ [text "where"]) + $$$ ppBody classIndent (map pretty gadtList) + $$$ ppDeriving derives + + pretty (TypeFamDecl loc name nameList optkind) = + blankline $ + markLine loc $ + mySep ([text "type", text "family", pretty name] + ++ map pretty nameList + ++ ppOptKind optkind) + + pretty (DataFamDecl loc context name nameList optkind) = + blankline $ + markLine loc $ + mySep ( [text "data", text "family", ppContext context, pretty name] + ++ map pretty nameList ++ ppOptKind optkind) + + pretty (TypeInsDecl loc ntype htype) = + blankline $ + markLine loc $ + mySep [text "type", text "instance", pretty ntype, equals, pretty htype] + + pretty (DataInsDecl loc don ntype constrList derives) = + blankline $ + markLine loc $ + mySep [pretty don, text "instance", pretty ntype] + <+> (myVcat (zipWith (<+>) (equals : repeat (char '|')) + (map pretty constrList)) + $$$ ppDeriving derives) + + pretty (GDataInsDecl loc don ntype optkind gadtList derives) = + blankline $ + markLine loc $ + mySep ( [pretty don, text "instance", pretty ntype] + ++ ppOptKind optkind ++ [text "where"]) + $$$ ppBody classIndent (map pretty gadtList) + $$$ ppDeriving derives + + --m{spacing=False} + -- special case for empty class declaration + pretty (ClassDecl pos context name nameList fundeps []) = + blankline $ + markLine pos $ + mySep ( [text "class", ppContext context, pretty name] + ++ map pretty nameList ++ [ppFunDeps fundeps]) + pretty (ClassDecl pos context name nameList fundeps declList) = + blankline $ + markLine pos $ + mySep ( [text "class", ppContext 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 (InstDecl pos context name args []) = + blankline $ + markLine pos $ + mySep ( [text "instance", ppContext context, pretty name] + ++ map ppAType args) + pretty (InstDecl pos context name args declList) = + blankline $ + markLine pos $ + mySep ( [text "instance", ppContext context, pretty name] + ++ map ppAType args ++ [text "where"]) + $$$ ppBody classIndent (map pretty declList) + + pretty (DerivDecl pos context name args) = + blankline $ + markLine pos $ + mySep ( [text "deriving", text "instance", ppContext context, pretty name] + ++ map ppAType args) + pretty (DefaultDecl pos htypes) = + blankline $ + markLine pos $ + text "default" <+> parenList (map pretty htypes) + + pretty (SpliceDecl pos splice) = + blankline $ + markLine pos $ + pretty splice + + pretty (TypeSig pos nameList qualType) = + blankline $ + markLine pos $ + mySep ((punctuate comma . map pretty $ nameList) + ++ [text "::", pretty qualType]) + + pretty (FunBind matches) = + foldr ($$$) empty (map pretty matches) + + pretty (PatBind pos pat optsig rhs whereBinds) = + markLine pos $ + myFsep [pretty pat, maybePP ppSig optsig, pretty rhs] $$$ ppWhere whereBinds + + pretty (InfixDecl pos assoc prec opList) = + blankline $ + markLine pos $ + mySep ([pretty assoc, int prec] + ++ (punctuate comma . map pretty $ opList)) + + pretty (ForImp 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 (ForExp pos cconv str name typ) = + blankline $ + markLine pos $ + mySep [text "foreign export", pretty cconv, + text (show str), pretty name, text "::", pretty typ] + + pretty (RulePragmaDecl pos rules) = + blankline $ + markLine pos $ + myVcat $ text "{-# RULES" : map pretty rules ++ [text " #-}"] + + pretty (DeprPragmaDecl pos deprs) = + blankline $ + markLine pos $ + myVcat $ text "{-# DEPRECATED" : map ppWarnDepr deprs ++ [text " #-}"] + + pretty (WarnPragmaDecl pos deprs) = + blankline $ + markLine pos $ + myVcat $ text "{-# WARNING" : map ppWarnDepr deprs ++ [text " #-}"] + + pretty (InlineSig pos inl activ name) = + blankline $ + markLine pos $ + mySep [text (if inl then "{-# INLINE" else "{-# NOINLINE"), pretty activ, pretty name, text "#-}"] + + pretty (SpecSig pos name types) = + blankline $ + markLine pos $ + mySep $ [text "{-# SPECIALISE", pretty name, text "::"] + ++ punctuate comma (map pretty types) ++ [text "#-}"] + + pretty (SpecInlineSig pos inl activ name types) = + blankline $ + markLine pos $ + mySep $ [text "{-# SPECIALISE", text (if inl then "INLINE" else "NOINLINE"), + pretty activ, pretty name, text "::"] + ++ (punctuate comma $ map pretty types) ++ [text "#-}"] + + pretty (InstSig pos context name args) = + blankline $ + markLine pos $ + mySep $ [text "{-# SPECIALISE", text "instance", ppContext context, pretty name] + ++ map ppAType args ++ [text "#-}"] + +{- pretty (UnknownDeclPragma pos n s) = + blankline $ + markLine pos $ + mySep $ [text "{-#", text n, text s, text "#-}"] -} + + +instance Pretty DataOrNew where + pretty DataType = text "data" + pretty NewType = text "newtype" + +instance Pretty Assoc where + pretty AssocNone = text "infix" + pretty AssocLeft = text "infixl" + pretty AssocRight = text "infixr" + +instance Pretty Match where + pretty (Match pos f ps optsig rhs whereBinds) = + markLine pos $ + myFsep (lhs ++ [maybePP ppSig optsig, pretty rhs]) + $$$ ppWhere whereBinds + where + lhs = case ps of + l:r:ps' | isSymbolName f -> + let hd = [pretty l, ppName f, pretty r] in + if null ps' then hd + else parens (myFsep hd) : map (prettyPrec 2) ps' + _ -> pretty f : map (prettyPrec 2) ps + +ppWhere :: Binds -> Doc +ppWhere (BDecls []) = empty +ppWhere (BDecls l) = nest 2 (text "where" $$$ ppBody whereIndent (map pretty l)) +ppWhere (IPBinds b) = nest 2 (text "where" $$$ ppBody whereIndent (map pretty b)) + +ppSig :: Type -> Doc +ppSig t = text "::" <+> pretty t + +instance Pretty ClassDecl where + pretty (ClsDecl decl) = pretty decl + + pretty (ClsDataFam loc context name nameList optkind) = + markLine loc $ + mySep ( [text "data", ppContext context, pretty name] + ++ map pretty nameList ++ ppOptKind optkind) + + pretty (ClsTyFam loc name nameList optkind) = + markLine loc $ + mySep ( [text "type", pretty name] + ++ map pretty nameList ++ ppOptKind optkind) + + pretty (ClsTyDef loc ntype htype) = + markLine loc $ + mySep [text "type", pretty ntype, equals, pretty htype] + +instance Pretty InstDecl where + pretty (InsDecl decl) = pretty decl + + pretty (InsType loc ntype htype) = + markLine loc $ + mySep [text "type", pretty ntype, equals, pretty htype] + + pretty (InsData loc don ntype constrList derives) = + markLine loc $ + mySep [pretty don, pretty ntype] + <+> (myVcat (zipWith (<+>) (equals : repeat (char '|')) + (map pretty constrList)) + $$$ ppDeriving derives) + + pretty (InsGData loc don ntype optkind gadtList derives) = + markLine loc $ + mySep ( [pretty don, pretty ntype] + ++ ppOptKind optkind ++ [text "where"]) + $$$ ppBody classIndent (map pretty gadtList) + $$$ ppDeriving derives + + pretty (InsInline loc inl activ name) = + markLine loc $ + mySep [text (if inl then "{-# INLINE" else "{-# NOINLINE"), pretty activ, pretty name, text "#-}"] + + +------------------------- FFI stuff ------------------------------------- +instance Pretty Safety where + pretty PlayRisky = text "unsafe" + pretty (PlaySafe b) = text $ if b then "threadsafe" else "safe" + +instance Pretty CallConv where + pretty StdCall = text "stdcall" + pretty CCall = text "ccall" + +------------------------- Pragmas --------------------------------------- +ppWarnDepr :: ([Name], String) -> Doc +ppWarnDepr (names, txt) = mySep $ (punctuate comma $ map pretty names) ++ [text $ show txt] + +instance Pretty Rule where + pretty (Rule tag activ rvs rhs lhs) = + mySep $ [text $ show tag, pretty activ, + maybePP ppRuleVars rvs, + pretty rhs, char '=', pretty lhs] + +ppRuleVars :: [RuleVar] -> Doc +ppRuleVars [] = empty +ppRuleVars rvs = mySep $ text "forall" : map pretty rvs ++ [char '.'] + +instance Pretty Activation where + pretty AlwaysActive = empty + pretty (ActiveFrom i) = char '[' <> int i <> char ']' + pretty (ActiveUntil i) = text "[~" <> int i <> char ']' + +instance Pretty RuleVar where + pretty (RuleVar n) = pretty n + pretty (TypedRuleVar n t) = mySep [pretty n, text "::", pretty t] + +instance Pretty OptionPragma where + pretty (LanguagePragma _ ns) = + myFsep $ text "{-# LANGUAGE" : map pretty ns ++ [text "#-}"] + pretty (IncludePragma _ s) = + myFsep $ [text "{-# INCLUDE", text s, text "#-}"] + pretty (CFilesPragma _ s) = + myFsep $ [text "{-# CFILES", text s, text "#-}"] + pretty (OptionsPragma _ (Just tool) s) = + myFsep $ [text "{-# OPTIONS_" <> pretty tool, text s, text "#-}"] + pretty (OptionsPragma _ _ s) = + myFsep $ [text "{-# OPTIONS", text s, text "#-}"] +{- pretty (UnknownTopPragma _ n s) = + myFsep $ map text ["{-#", n, s, "#-}"] -} + +instance Pretty Tool where + pretty (UnknownTool s) = text s + pretty t = text $ show t + +------------------------- Data & Newtype Bodies ------------------------- +instance Pretty QualConDecl where + pretty (QualConDecl _pos tvs ctxt con) = + myFsep [ppForall (Just tvs), ppContext ctxt, pretty con] + +instance Pretty GadtDecl where + pretty (GadtDecl _pos name ty) = + myFsep [pretty name, text "::", pretty ty] + +instance Pretty ConDecl where + pretty (RecDecl name fieldList) = + pretty name <> (braceList . map ppField $ fieldList) + +{- pretty (ConDecl name@(Symbol _) [l, r]) = + myFsep [prettyPrec prec_btype l, ppName name, + prettyPrec prec_btype r] -} + pretty (ConDecl name typeList) = + mySep $ ppName name : map (prettyPrec prec_atype) typeList + pretty (InfixConDecl l name r) = + myFsep [prettyPrec prec_btype l, ppNameInfix name, + prettyPrec prec_btype r] + +ppField :: ([Name],BangType) -> Doc +ppField (names, ty) = + myFsepSimple $ (punctuate comma . map pretty $ names) ++ + [text "::", pretty ty] + +instance Pretty BangType where + prettyPrec _ (BangedTy ty) = char '!' <> ppAType ty + prettyPrec p (UnBangedTy ty) = prettyPrec p ty + prettyPrec p (UnpackedTy ty) = text "{-# UNPACK #-}" <+> char '!' <> prettyPrec p ty + +ppDeriving :: [Deriving] -> Doc +ppDeriving [] = empty +ppDeriving [(d, [])] = text "deriving" <+> ppQName d +ppDeriving ds = text "deriving" <+> parenList (map ppDer ds) + where ppDer :: (QName, [Type]) -> Doc + ppDer (n, ts) = mySep (pretty n : map pretty ts) + +------------------------- Types ------------------------- +ppBType :: Type -> Doc +ppBType = prettyPrec prec_btype + +ppAType :: Type -> Doc +ppAType = 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 Type where + prettyPrec p (TyForall mtvs ctxt htype) = parensIf (p > 0) $ + myFsep [ppForall mtvs, ppContext ctxt, pretty htype] + prettyPrec p (TyFun a b) = parensIf (p > 0) $ + myFsep [ppBType a, text "->", pretty b] + prettyPrec _ (TyTuple bxd l) = + let ds = map pretty l + in case bxd of + Boxed -> parenList ds + Unboxed -> hashParenList ds + prettyPrec _ (TyList t) = brackets $ pretty t + prettyPrec p (TyApp a b) = + {- | a == list_tycon = brackets $ pretty b -- special case + | otherwise = -} parensIf (p > prec_btype) $ + myFsep [pretty a, ppAType b] + prettyPrec _ (TyVar name) = pretty name + prettyPrec _ (TyCon name) = pretty name + prettyPrec _ (TyParen t) = parens (pretty t) +-- prettyPrec _ (TyPred asst) = pretty asst + prettyPrec _ (TyInfix a op b) = myFsep [pretty a, ppQNameInfix op, pretty b] + prettyPrec _ (TyKind t k) = parens (myFsep [pretty t, text "::", pretty k]) + + +instance Pretty TyVarBind where + pretty (KindedVar var kind) = parens $ myFsep [pretty var, text "::", pretty kind] + pretty (UnkindedVar var) = pretty var + +ppForall :: Maybe [TyVarBind] -> Doc +ppForall Nothing = empty +ppForall (Just []) = empty +ppForall (Just vs) = myFsep (text "forall" : map pretty vs ++ [char '.']) + +---------------------------- Kinds ---------------------------- + +instance Pretty Kind where + pretty KindStar = text "*" + pretty KindBang = text "!" + pretty (KindFn a b) = myFsep [pretty a, text "->", pretty b] + +ppOptKind :: Maybe Kind -> [Doc] +ppOptKind Nothing = [] +ppOptKind (Just k) = [text "::", pretty k] + +------------------- Functional Dependencies ------------------- +instance Pretty FunDep where + pretty (FunDep from to) = + myFsep $ map pretty from ++ [text "->"] ++ map pretty to + + +ppFunDeps :: [FunDep] -> Doc +ppFunDeps [] = empty +ppFunDeps fds = myFsep $ (char '|':) . punctuate comma . map pretty $ fds + +------------------------- Expressions ------------------------- +instance Pretty Rhs where + pretty (UnGuardedRhs e) = equals <+> pretty e + pretty (GuardedRhss guardList) = myVcat . map pretty $ guardList + +instance Pretty GuardedRhs where + pretty (GuardedRhs _pos guards ppBody) = + myFsep $ [char '|'] ++ (punctuate comma . map pretty $ guards) ++ [equals, pretty ppBody] + +instance Pretty Literal where + pretty (Int i) = integer i + pretty (Char c) = text (show c) + pretty (String s) = text (show s) + pretty (Frac r) = double (fromRational r) + -- GHC unboxed literals: + pretty (PrimChar c) = text (show c) <> char '#' + pretty (PrimString s) = text (show s) <> char '#' + pretty (PrimInt i) = integer i <> char '#' + pretty (PrimWord w) = integer w <> text "##" + pretty (PrimFloat r) = float (fromRational r) <> char '#' + pretty (PrimDouble r) = double (fromRational r) <> text "##" + +instance Pretty Exp where + pretty (Lit l) = pretty l + -- lambda stuff + pretty (InfixApp a op b) = myFsep [pretty a, pretty op, pretty b] + pretty (NegApp e) = myFsep [char '-', pretty e] + pretty (App a b) = myFsep [pretty a, pretty b] + pretty (Lambda _loc expList ppBody) = myFsep $ + char '\\' : map pretty expList ++ [text "->", pretty ppBody] + -- keywords + -- two cases for lets + pretty (Let (BDecls declList) letBody) = + ppLetExp declList letBody + pretty (Let (IPBinds bindList) letBody) = + ppLetExp bindList letBody + + pretty (If cond thenexp elsexp) = + myFsep [text "if", pretty cond, + text "then", pretty thenexp, + text "else", pretty elsexp] + pretty (Case cond altList) = + myFsep [text "case", pretty cond, text "of"] + $$$ ppBody caseIndent (map pretty altList) + pretty (Do stmtList) = + text "do" $$$ ppBody doIndent (map pretty stmtList) + pretty (MDo stmtList) = + text "mdo" $$$ ppBody doIndent (map pretty stmtList) + -- Constructors & Vars + pretty (Var name) = pretty name + pretty (IPVar ipname) = pretty ipname + pretty (Con name) = pretty name + pretty (Tuple expList) = parenList . map pretty $ expList + -- weird stuff + pretty (Paren e) = parens . pretty $ e + pretty (LeftSection e op) = parens (pretty e <+> pretty op) + pretty (RightSection op e) = parens (pretty op <+> pretty e) + pretty (RecConstr c fieldList) = + pretty c <> (braceList . map pretty $ fieldList) + pretty (RecUpdate e fieldList) = + pretty e <> (braceList . map pretty $ fieldList) + -- Lists + pretty (List list) = + bracketList . punctuate comma . map pretty $ list + pretty (EnumFrom e) = + bracketList [pretty e, text ".."] + pretty (EnumFromTo from to) = + bracketList [pretty from, text "..", pretty to] + pretty (EnumFromThen from thenE) = + bracketList [pretty from <> comma, pretty thenE, text ".."] + pretty (EnumFromThenTo from thenE to) = + bracketList [pretty from <> comma, pretty thenE, + text "..", pretty to] + pretty (ListComp e qualList) = + bracketList ([pretty e, char '|'] + ++ (punctuate comma . map pretty $ qualList)) + pretty (ParComp e qualLists) = + bracketList (intersperse (char '|') $ + pretty e : (punctuate comma . concatMap (map pretty) $ qualLists)) + pretty (ExpTypeSig _pos e ty) = + myFsep [pretty e, text "::", pretty ty] + -- Template Haskell + pretty (BracketExp b) = pretty b + pretty (SpliceExp s) = pretty s + pretty (TypQuote t) = text "\'\'" <> pretty t + pretty (VarQuote x) = text "\'" <> pretty x + pretty (QuasiQuote n qt) = text ("[$" ++ n ++ "|" ++ qt ++ "|]") + -- Hsx + pretty (XTag _ 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 (XETag _ n attrs mattr) = + let ax = maybe [] (return . pretty) mattr + in myFsep $ (char '<' <> pretty n): map pretty attrs ++ ax ++ [text "/>"] + pretty (XPcdata s) = text s + pretty (XExpTag e) = + myFsep $ [text "<%", pretty e, text "%>"] + -- Pragmas + pretty (CorePragma s) = myFsep $ map text ["{-# CORE", show s, "#-}"] + pretty (SCCPragma s) = myFsep $ map text ["{-# SCC", show s, "#-}"] + pretty (GenPragma s (a,b) (c,d)) = + myFsep $ [text "{-# GENERATED", text $ show s, + int a, char ':', int b, char '-', + int c, char ':', int d, text "#-}"] +{- pretty (UnknownExpPragma n s) = + myFsep $ [text "{-#", text n, text s, text "#-}"] -} + -- Arrows + pretty (Proc p e) = myFsep $ [text "proc", pretty p, text "->", pretty e] + pretty (LeftArrApp l r) = myFsep $ [pretty l, text "-<", pretty r] + pretty (RightArrApp l r) = myFsep $ [pretty l, text ">-", pretty r] + pretty (LeftArrHighApp l r) = myFsep $ [pretty l, text "-<<", pretty r] + pretty (RightArrHighApp l r) = myFsep $ [pretty l, text ">>-", pretty r] + + +instance Pretty XAttr where + pretty (XAttr n v) = + myFsep [pretty n, char '=', pretty v] + +instance Pretty XName where + pretty (XName n) = text n + pretty (XDomName d n) = text d <> char ':' <> text n + +--ppLetExp :: [Decl] -> Exp -> 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 Bracket where + pretty (ExpBracket e) = ppBracket "[|" e + pretty (PatBracket p) = ppBracket "[p|" p + pretty (TypeBracket t) = ppBracket "[t|" t + pretty (DeclBracket d) = + myFsep $ text "[d|" : map pretty d ++ [text "|]"] + +ppBracket o x = myFsep [text o, pretty x, text "|]"] + +instance Pretty Splice where + pretty (IdSplice s) = char '$' <> text s + pretty (ParenSplice e) = + myFsep [text "$(", pretty e, char ')'] + +------------------------- Patterns ----------------------------- + +instance Pretty Pat where + prettyPrec _ (PVar name) = pretty name + prettyPrec _ (PLit lit) = pretty lit + prettyPrec _ (PNeg p) = myFsep [char '-', pretty p] + prettyPrec p (PInfixApp a op b) = parensIf (p > 0) $ + myFsep [pretty a, pretty (QConOp op), pretty b] + prettyPrec p (PApp n ps) = parensIf (p > 1) $ + myFsep (pretty n : map pretty ps) + prettyPrec _ (PTuple ps) = parenList . map pretty $ ps + prettyPrec _ (PList ps) = + bracketList . punctuate comma . map pretty $ ps + prettyPrec _ (PParen p) = parens . pretty $ p + prettyPrec _ (PRec c fields) = + pretty c <> (braceList . map pretty $ fields) + -- special case that would otherwise be buggy + prettyPrec _ (PAsPat name (PIrrPat pat)) = + myFsep [pretty name <> char '@', char '~' <> pretty pat] + prettyPrec _ (PAsPat name pat) = + hcat [pretty name, char '@', pretty pat] + prettyPrec _ PWildCard = char '_' + prettyPrec _ (PIrrPat pat) = char '~' <> pretty pat + prettyPrec _ (PatTypeSig _pos pat ty) = + myFsep [pretty pat, text "::", pretty ty] + prettyPrec _ (PViewPat e p) = + myFsep [pretty e, text "->", pretty p] + prettyPrec _ (PNPlusK n k) = + myFsep [pretty n, text "+", text $ show k] + -- HaRP + prettyPrec _ (PRPat rs) = + bracketList . punctuate comma . map pretty $ rs + -- Hsx + prettyPrec _ (PXTag _ 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 '>']): + map pretty cp ++ [myFsep $ [text " pretty n, char '>']] + prettyPrec _ (PXETag _ n attrs mattr) = + let ap = maybe [] (return . pretty) mattr + in myFsep $ (char '<' <> pretty n): map pretty attrs ++ ap ++ [text "/>"] + prettyPrec _ (PXPcdata s) = text s + prettyPrec _ (PXPatTag p) = + myFsep $ [text "<%", pretty p, text "%>"] + prettyPrec _ (PXRPats ps) = + myFsep $ text "<[" : map pretty ps ++ [text "%>"] + -- Generics + prettyPrec _ (PExplTypeArg qn t) = + myFsep [pretty qn, text "{|", pretty t, text "|}"] + -- BangPatterns + prettyPrec _ (PBangPat p) = text "!" <> pretty p + +instance Pretty PXAttr where + pretty (PXAttr n p) = + myFsep [pretty n, char '=', pretty p] + +instance Pretty PatField where + pretty (PFieldPat name pat) = + myFsep [pretty name, equals, pretty pat] + pretty (PFieldPun name) = pretty name + pretty (PFieldWildcard) = text ".." + +--------------------- Regular Patterns ------------------------- + +instance Pretty RPat where + pretty (RPOp r op) = pretty r <> pretty op + pretty (RPEither r1 r2) = parens . myFsep $ + [pretty r1, char '|', pretty r2] + pretty (RPSeq rs) = + myFsep $ text "(/" : map pretty rs ++ [text "/)"] + pretty (RPGuard r gs) = + myFsep $ text "(|" : pretty r : char '|' : map pretty gs ++ [text "|)"] + -- special case that would otherwise be buggy + pretty (RPCAs n (RPPat (PIrrPat p))) = + myFsep [pretty n <> text "@:", char '~' <> pretty p] + pretty (RPCAs n r) = hcat [pretty n, text "@:", pretty r] + -- special case that would otherwise be buggy + pretty (RPAs n (RPPat (PIrrPat p))) = + myFsep [pretty n <> text "@:", char '~' <> pretty p] + pretty (RPAs n r) = hcat [pretty n, char '@', pretty r] + pretty (RPPat p) = pretty p + pretty (RPParen rp) = parens . pretty $ rp + +instance Pretty RPatOp where + pretty RPStar = char '*' + pretty RPStarG = text "*!" + pretty RPPlus = char '+' + pretty RPPlusG = text "+!" + pretty RPOpt = char '?' + pretty RPOptG = text "?!" + +------------------------- Case bodies ------------------------- +instance Pretty Alt where + pretty (Alt _pos e gAlts binds) = + pretty e <+> pretty gAlts $$$ ppWhere binds + +instance Pretty GuardedAlts where + pretty (UnGuardedAlt e) = text "->" <+> pretty e + pretty (GuardedAlts altList) = myVcat . map pretty $ altList + +instance Pretty GuardedAlt where + pretty (GuardedAlt _pos guards body) = + myFsep $ char '|': (punctuate comma . map pretty $ guards) ++ [text "->", pretty body] + +------------------------- Statements in monads, guards & list comprehensions ----- +instance Pretty Stmt where + pretty (Generator _loc e from) = + pretty e <+> text "<-" <+> pretty from + pretty (Qualifier e) = pretty e + -- two cases for lets + pretty (LetStmt (BDecls declList)) = + ppLetStmt declList + pretty (LetStmt (IPBinds bindList)) = + ppLetStmt bindList + pretty (RecStmt stmtList) = + text "rec" $$$ ppBody letIndent (map pretty stmtList) + +ppLetStmt l = text "let" $$$ ppBody letIndent (map pretty l) + +instance Pretty QualStmt where + pretty (QualStmt s) = pretty s + pretty (ThenTrans f) = myFsep $ [text "then", pretty f] + pretty (ThenBy f e) = myFsep $ [text "then", pretty f, text "by", pretty e] + pretty (GroupBy e) = myFsep $ [text "then", text "group", text "by", pretty e] + pretty (GroupUsing f) = myFsep $ [text "then", text "group", text "using", pretty f] + pretty (GroupByUsing e f) = myFsep $ [text "then", text "group", text "by", + pretty e, text "using", pretty f] + + + +------------------------- Record updates +instance Pretty FieldUpdate where + pretty (FieldUpdate name e) = + myFsep [pretty name, equals, pretty e] + pretty (FieldPun name) = pretty name + pretty (FieldWildcard) = text ".." + +------------------------- Names ------------------------- +instance Pretty QOp where + pretty (QVarOp n) = ppQNameInfix n + pretty (QConOp n) = ppQNameInfix n + +ppQNameInfix :: QName -> Doc +ppQNameInfix name + | isSymbolName (getName name) = ppQName name + | otherwise = char '`' <> ppQName name <> char '`' + +instance Pretty QName where + pretty name = case name of + UnQual (Symbol ('#':_)) -> char '(' <+> ppQName name <+> char ')' + _ -> parensIf (isSymbolName (getName name)) (ppQName name) + +ppQName :: QName -> Doc +ppQName (UnQual name) = ppName name +ppQName (Qual m name) = pretty m <> char '.' <> ppName name +ppQName (Special sym) = text (specialName sym) + +instance Pretty Op where + pretty (VarOp n) = ppNameInfix n + pretty (ConOp n) = ppNameInfix n + +ppNameInfix :: Name -> Doc +ppNameInfix name + | isSymbolName name = ppName name + | otherwise = char '`' <> ppName name <> char '`' + +instance Pretty Name where + pretty name = case name of + Symbol ('#':_) -> char '(' <+> ppName name <+> char ')' + _ -> parensIf (isSymbolName name) (ppName name) + +ppName :: Name -> Doc +ppName (Ident s) = text s +ppName (Symbol s) = text s + +instance Pretty IPName where + pretty (IPDup s) = char '?' <> text s + pretty (IPLin s) = char '%' <> text s + +instance Pretty IPBind where + pretty (IPBind _loc ipname exp) = + myFsep [pretty ipname, equals, pretty exp] + +instance Pretty CName where + pretty (VarName n) = pretty n + pretty (ConName n) = pretty n + +isSymbolName :: Name -> Bool +isSymbolName (Symbol _) = True +isSymbolName _ = False + +getName :: QName -> Name +getName (UnQual s) = s +getName (Qual _ s) = s +getName (Special Cons) = Symbol ":" +getName (Special FunCon) = Symbol "->" +getName (Special s) = Ident (specialName s) + +specialName :: SpecialCon -> String +specialName UnitCon = "()" +specialName ListCon = "[]" +specialName FunCon = "->" +specialName (TupleCon b n) = "(" ++ hash ++ replicate (n-1) ',' ++ hash ++ ")" + where hash = if b == Unboxed then "#" else "" +specialName Cons = ":" + +ppContext :: Context -> Doc +ppContext [] = empty +ppContext context = mySep [parenList (map pretty context), text "=>"] + +-- hacked for multi-parameter type classes +instance Pretty Asst where + pretty (ClassA a ts) = myFsep $ ppQName a : map ppAType ts + pretty (InfixA a op b) = myFsep $ [pretty a, ppQNameInfix op, pretty b] + pretty (IParam i t) = myFsep $ [pretty i, text "::", pretty t] + pretty (EqualP t1 t2) = myFsep $ [pretty t1, text "~", pretty t2] + +------------------------- 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 + +-- Pretty print a source location, useful for printing out error messages +instance Pretty SrcLoc where + pretty srcLoc = + return $ P.hsep [ colonFollow (P.text $ srcFilename srcLoc) + , colonFollow (P.int $ srcLine srcLoc) + , P.int $ srcColumn srcLoc + ] + where + colonFollow p = P.hcat [ p, P.colon ] diff --git a/src/Language/Haskell/Exts/Syntax.hs b/src/Language/Haskell/Exts/Syntax.hs new file mode 100644 --- /dev/null +++ b/src/Language/Haskell/Exts/Syntax.hs @@ -0,0 +1,970 @@ +{-# OPTIONS_GHC -fglasgow-exts -cpp #-} +----------------------------------------------------------------------------- +-- | +-- Module : Language.Haskell.Exts.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.Exts.Syntax ( + -- * Modules + Module(..), ExportSpec(..), + ImportDecl(..), ImportSpec(..), Assoc(..), + -- * Declarations + Decl(..), Binds(..), IPBind(..), + ClassDecl(..), InstDecl(..), Deriving, + GadtDecl(..), ConDecl(..), QualConDecl(..), BangType(..), + Match(..), Rhs(..), GuardedRhs(..), DataOrNew(..), + -- * Class Assertions and Contexts + Context, FunDep(..), Asst(..), + -- * Types + Type(..), Boxed(..), Kind(..), TyVarBind(..), + -- * Expressions + Exp(..), Stmt(..), QualStmt(..), FieldUpdate(..), + Alt(..), GuardedAlts(..), GuardedAlt(..), + -- * Patterns + Pat(..), PatField(..), + -- * Literals + Literal(..), + -- * Variables, Constructors and Operators + ModuleName(..), QName(..), Name(..), QOp(..), Op(..), + SpecialCon(..), CName(..), IPName(..), + + -- * Template Haskell + -- HsReify(..), + Bracket(..), Splice(..), + + -- * HaRP + RPat(..), RPatOp(..), + + -- * Hsx + XAttr(..), XName(..), PXAttr(..), + + -- * FFI + Safety(..), CallConv(..), + + -- * Pragmas + OptionPragma(..), Tool(..), WarningText(..), + Rule(..), RuleVar(..), Activation(..), + + -- * Builtin names + + -- ** Modules + prelude_mod, main_mod, + -- ** Main function of a program + main_name, + -- ** Constructors + unit_con_name, tuple_con_name, list_cons_name, unboxed_singleton_con_name, + unit_con, tuple_con, unboxed_singleton_con, + -- ** Special identifiers + as_name, qualified_name, hiding_name, minus_name, bang_name, dot_name, star_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, unboxed_singleton_tycon_name, + unit_tycon, fun_tycon, list_tycon, tuple_tycon, unboxed_singleton_tycon, + + -- * Source coordinates + SrcLoc(..), + ) where + + +#ifdef __GLASGOW_HASKELL__ +#ifdef BASE4 +import Data.Data +#else +import Data.Generics (Data(..),Typeable(..)) +#endif +#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 ModuleName = ModuleName 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 SpecialCon + = UnitCon -- ^ unit type and data constructor @()@ + | ListCon -- ^ list type constructor @[]@ + | FunCon -- ^ function type constructor @->@ + | TupleCon Boxed Int -- ^ /n/-ary tuple type and data + -- constructors @(,)@ etc + | Cons -- ^ list data constructor @(:)@ + | UnboxedSingleCon -- ^ unboxed singleton tuple 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 QName + = Qual ModuleName Name -- ^ name qualified with a module name + | UnQual Name -- ^ unqualified name + | Special SpecialCon -- ^ 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 Name + = Ident String -- ^ /varid/ or /conid/. + | Symbol 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 IPName + = IPDup String -- ?x + | IPLin 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 QOp + = QVarOp QName -- ^ variable operator (/qvarop/) + | QConOp QName -- ^ constructor operator (/qconop/) +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Ord,Show,Typeable,Data) +#else + deriving (Eq,Ord,Show) +#endif + +-- | Operators, appearing in @infix@ declarations. +data Op + = VarOp Name -- ^ variable operator (/varop/) + | ConOp Name -- ^ 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 CName + = VarName Name -- ^ name of a method or field + | ConName Name -- ^ 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 Module = Module SrcLoc ModuleName [OptionPragma] (Maybe WarningText) + (Maybe [ExportSpec]) [ImportDecl] [Decl] +#ifdef __GLASGOW_HASKELL__ + deriving (Show,Typeable,Data) +#else + deriving (Show) +#endif + +-- | Export specification. +data ExportSpec + = EVar QName -- ^ variable + | EAbs QName -- ^ @T@: + -- a class or datatype exported abstractly, + -- or a type synonym. + | EThingAll QName -- ^ @T(..)@: + -- a class exported with all of its methods, or + -- a datatype exported with all of its constructors. + | EThingWith QName [CName] -- ^ @T(C_1,...,C_n)@: + -- a class exported with some of its methods, or + -- a datatype exported with some of its constructors. + | EModuleContents ModuleName -- ^ @module M@: + -- re-export a module. +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +-- | Import declaration. +data ImportDecl = ImportDecl + { importLoc :: SrcLoc -- ^ position of the @import@ keyword. + , importModule :: ModuleName -- ^ name of the module imported. + , importQualified :: Bool -- ^ imported @qualified@? + , importSrc :: Bool -- ^ imported with {-# SOURCE #-} + , importPkg :: Maybe String -- ^ imported with explicit package name + , importAs :: Maybe ModuleName -- ^ optional alias name in an + -- @as@ clause. + , importSpecs :: Maybe (Bool,[ImportSpec]) + -- ^ 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 ImportSpec + = IVar Name -- ^ variable + | IAbs Name -- ^ @T@: + -- the name of a class, datatype or type synonym. + | IThingAll Name -- ^ @T(..)@: + -- a class imported with all of its methods, or + -- a datatype imported with all of its constructors. + | IThingWith Name [CName] -- ^ @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 Assoc + = AssocNone -- ^ non-associative operator (declared with @infix@) + | AssocLeft -- ^ left-associative operator (declared with @infixl@). + | AssocRight -- ^ right-associative operator (declared with @infixr@) +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +type Deriving = (QName, [Type]) + +data Decl + = TypeDecl SrcLoc Name [TyVarBind] Type + | DataDecl SrcLoc DataOrNew Context Name [TyVarBind] [QualConDecl] [Deriving] + | GDataDecl SrcLoc DataOrNew Context Name [TyVarBind] (Maybe Kind) [GadtDecl] [Deriving] + | TypeFamDecl SrcLoc Name [TyVarBind] (Maybe Kind) + | DataFamDecl SrcLoc Context Name [TyVarBind] (Maybe Kind) + | TypeInsDecl SrcLoc Type Type + | DataInsDecl SrcLoc DataOrNew Type [QualConDecl] [Deriving] + | GDataInsDecl SrcLoc DataOrNew Type (Maybe Kind) [GadtDecl] [Deriving] + | InfixDecl SrcLoc Assoc Int [Op] + | ClassDecl SrcLoc Context Name [TyVarBind] [FunDep] [ClassDecl] + | InstDecl SrcLoc Context QName [Type] [InstDecl] + | DerivDecl SrcLoc Context QName [Type] + | DefaultDecl SrcLoc [Type] + | SpliceDecl SrcLoc Splice + | TypeSig SrcLoc [Name] Type + | FunBind [Match] + | PatBind SrcLoc Pat (Maybe Type) Rhs {-where-} Binds + | ForImp SrcLoc CallConv Safety String Name Type + | ForExp SrcLoc CallConv String Name Type +-- Pragmas + | RulePragmaDecl SrcLoc [Rule] + | DeprPragmaDecl SrcLoc [([Name], String)] + | WarnPragmaDecl SrcLoc [([Name], String)] + | InlineSig SrcLoc Bool Activation QName + | SpecSig SrcLoc QName [Type] + | SpecInlineSig SrcLoc Bool Activation QName [Type] + | InstSig SrcLoc Context QName [Type] +-- | UnknownDeclPragma SrcLoc String String +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +data DataOrNew = DataType | NewType +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +data Binds + = BDecls [Decl] + | IPBinds [IPBind] +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +data IPBind = IPBind SrcLoc IPName Exp +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +-- | Clauses of a function binding. +data Match + = Match SrcLoc Name [Pat] (Maybe Type) Rhs {-where-} Binds +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +data QualConDecl + = QualConDecl SrcLoc + {-forall-} [TyVarBind] {- . -} Context + {- => -} ConDecl +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +data GadtDecl + = GadtDecl SrcLoc Name Type +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +-- | Declaration of a data constructor. +data ConDecl + = ConDecl Name [BangType] + -- ^ ordinary data constructor + | InfixConDecl BangType Name BangType + -- ^ infix data constructor + | RecDecl Name [([Name],BangType)] + -- ^ record constructor +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +-- | Declarations inside a class declaration +data ClassDecl + = ClsDecl Decl + | ClsDataFam SrcLoc Context Name [TyVarBind] (Maybe Kind) + | ClsTyFam SrcLoc Name [TyVarBind] (Maybe Kind) + | ClsTyDef SrcLoc Type Type +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +-- | Declarations inside an instance declaration +data InstDecl + = InsDecl Decl + | InsType SrcLoc Type Type + | InsData SrcLoc DataOrNew Type [QualConDecl] [Deriving] + | InsGData SrcLoc DataOrNew Type (Maybe Kind) [GadtDecl] [Deriving] + | InsInline SrcLoc Bool Activation QName +#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 BangType + = BangedTy Type -- ^ strict component, marked with \"@!@\" + | UnBangedTy Type -- ^ non-strict component + | UnpackedTy Type -- ^ unboxed 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 Rhs + = UnGuardedRhs Exp -- ^ unguarded right hand side (/exp/) + | GuardedRhss [GuardedRhs] + -- ^ 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 GuardedRhs + = GuardedRhs SrcLoc [Stmt] Exp +#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 Type + = TyForall + (Maybe [TyVarBind]) + Context + Type + | TyFun Type Type -- ^ function type + | TyTuple Boxed [Type] -- ^ tuple type, possibly boxed + | TyList Type -- ^ list syntax, e.g. [a], as opposed to [] a + | TyApp Type Type -- ^ application of a type constructor + | TyVar Name -- ^ type variable + | TyCon QName -- ^ named type or type constructor + | TyParen Type -- ^ type surrounded by parentheses +-- | TyPred Asst -- ^ assertion of an implicit parameter + | TyInfix Type QName Type -- ^ infix type constructor + | TyKind Type Kind -- ^ type with explicit kind signature +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +data Boxed = Boxed | Unboxed +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Ord,Show,Typeable,Data) +#else + deriving (Eq,Ord,Show) +#endif + +data TyVarBind + = KindedVar Name Kind + | UnkindedVar Name +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +data Kind + = KindStar + | KindBang + | KindFn Kind Kind +#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 FunDep + = FunDep [Name] [Name] +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + + +type Context = [Asst] + +-- | 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 and equality constraints. +data Asst = ClassA QName [Type] + | InfixA Type QName Type + | IParam IPName Type + | EqualP Type Type +#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 Literal + = Char Char -- ^ character literal + | String String -- ^ string literal + | Int Integer -- ^ integer literal + | Frac Rational -- ^ floating point literal + | PrimInt Integer -- ^ GHC unboxed integer literal + | PrimWord Integer -- ^ GHC unboxed word literal + | PrimFloat Rational -- ^ GHC unboxed float literal + | PrimDouble Rational -- ^ GHC unboxed double literal + | PrimChar Char -- ^ GHC unboxed character literal + | PrimString String -- ^ GHC unboxed string 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 'InfixApp's associated to the left. +-- +-- * The 'Language.Haskell.Exts.Pretty.Pretty' instance for 'Exp' does not +-- add parentheses in printing. + +data Exp + = Var QName -- ^ variable + | IPVar IPName -- ^ implicit parameter variable + | Con QName -- ^ data constructor + | Lit Literal -- ^ literal constant + | InfixApp Exp QOp Exp -- ^ infix application + | App Exp Exp -- ^ ordinary application + | NegApp Exp -- ^ negation expression @-@ /exp/ + | Lambda SrcLoc [Pat] Exp -- ^ lambda expression + | Let Binds Exp -- ^ local declarations with @let@ + | If Exp Exp Exp -- ^ @if@ /exp/ @then@ /exp/ @else@ /exp/ + | Case Exp [Alt] -- ^ @case@ /exp/ @of@ /alts/ + | Do [Stmt] -- ^ @do@-expression: + -- the last statement in the list + -- should be an expression. + | MDo [Stmt] -- ^ @mdo@-expression + | Tuple [Exp] -- ^ tuple expression + | List [Exp] -- ^ list expression + | Paren Exp -- ^ parenthesized expression + | LeftSection Exp QOp -- ^ left section @(@/exp/ /qop/@)@ + | RightSection QOp Exp -- ^ right section @(@/qop/ /exp/@)@ + | RecConstr QName [FieldUpdate] + -- ^ record construction expression + | RecUpdate Exp [FieldUpdate] + -- ^ record update expression + | EnumFrom Exp -- ^ unbounded arithmetic sequence, + -- incrementing by 1 + | EnumFromTo Exp Exp -- ^ bounded arithmetic sequence, + -- incrementing by 1 + | EnumFromThen Exp Exp -- ^ unbounded arithmetic sequence, + -- with first two elements given + | EnumFromThenTo Exp Exp Exp + -- ^ bounded arithmetic sequence, + -- with first two elements given + | ListComp Exp [QualStmt] -- ^ list comprehension + | ParComp Exp [[QualStmt]] -- ^ parallel list comprehension + | ExpTypeSig SrcLoc Exp Type + -- ^ expression type signature +-- Template Haskell + | VarQuote QName -- ^ 'x + | TypQuote QName -- ^ ''T + | BracketExp Bracket + | SpliceExp Splice + | QuasiQuote String String -- ^ [$name| string |] + +-- Hsx + | XTag SrcLoc XName [XAttr] (Maybe Exp) [Exp] + | XETag SrcLoc XName [XAttr] (Maybe Exp) + | XPcdata String + | XExpTag Exp + +-- Pragmas + | CorePragma String + | SCCPragma String + | GenPragma String (Int, Int) (Int, Int) +-- | UnknownExpPragma String String + +-- Arrows + | Proc Pat Exp -- ^ @proc@ /pat/ @->@ /exp/ + | LeftArrApp Exp Exp -- ^ /exp/ @-<@ /exp/ + | RightArrApp Exp Exp -- ^ /exp/ @>-@ /exp/ + | LeftArrHighApp Exp Exp -- ^ /exp/ @-<<@ /exp/ + | RightArrHighApp Exp Exp -- ^ /exp/ @>>-@ /exp/ +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +data XName + = XName String -- p) +-- HaRP + | PRPat [RPat] -- ^ regular pattern (HaRP) +-- Hsx + | PXTag SrcLoc XName [PXAttr] (Maybe Pat) [Pat] + -- ^ XML tag pattern + | PXETag SrcLoc XName [PXAttr] (Maybe Pat) + -- ^ XML singleton tag pattern + | PXPcdata String -- ^ XML PCDATA pattern + | PXPatTag Pat -- ^ XML embedded pattern + | PXRPats [RPat] -- ^ XML regular list pattern + | PExplTypeArg QName Type -- ^ Explicit type argument e.g. f {| Int |} x = ... + + | PQuasiQuote String String -- ^ [$name| string |] + + | PBangPat Pat -- ^ f !x = ... + +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +-- | An XML attribute in an XML tag pattern +data PXAttr = PXAttr XName Pat +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +-- | A regular pattern operator (HaRP) +data RPatOp + = RPStar + | RPStarG + | RPPlus + | RPPlusG + | RPOpt + | RPOptG +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +-- | An entity in a regular pattern (HaRP) +data RPat + = RPOp RPat RPatOp + | RPEither RPat RPat + | RPSeq [RPat] + | RPGuard Pat [Stmt] + | RPCAs Name RPat + | RPAs Name RPat + | RPParen RPat + | RPPat Pat +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +-- | An /fpat/ in a labeled record pattern. +data PatField + = PFieldPat QName Pat + | PFieldPun Name + | PFieldWildcard +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +-- | This type represents both /stmt/ in a @do@-expression, +-- and /qual/ in a list comprehension, as well as /stmt/ +-- in a pattern guard. +data Stmt + = Generator SrcLoc Pat Exp + -- ^ a generator /pat/ @<-@ /exp/ + | Qualifier Exp -- ^ an /exp/ by itself: in a @do@-expression, + -- an action whose result is discarded; + -- in a list comprehension, a guard expression + | LetStmt Binds -- ^ local bindings + | RecStmt [Stmt] +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +-- | This type represents a /qual/ in a list comprehension, +-- which could potentially be a transform of the kind +-- enabled by TransformListComp. +data QualStmt + = QualStmt Stmt -- ^ an ordinary statement qualifier + | ThenTrans Exp -- ^ @then@ /exp/ + | ThenBy Exp Exp -- ^ @then@ /exp/ @by@ /exp/ + | GroupBy Exp -- ^ @then@ @group@ @by@ /exp/ + | GroupUsing Exp -- ^ @then@ @group@ @using@ /exp/ + | GroupByUsing Exp Exp -- ^ @then@ @group@ @by@ /exp/ @using@ /exp/ +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +-- | An /fbind/ in a labeled construction or update. +data FieldUpdate + = FieldUpdate QName Exp + | FieldPun Name + | FieldWildcard +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +-- | An /alt/ in a @case@ expression. +data Alt + = Alt SrcLoc Pat GuardedAlts Binds +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +data GuardedAlts + = UnGuardedAlt Exp -- ^ @->@ /exp/ + | GuardedAlts [GuardedAlt] -- ^ /gdpat/ +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +-- | A guarded alternative @|@ /stmt/, ... , /stmt/ @->@ /exp/. +data GuardedAlt + = GuardedAlt SrcLoc [Stmt] Exp +#ifdef __GLASGOW_HASKELL__ + deriving (Eq,Show,Typeable,Data) +#else + deriving (Eq,Show) +#endif + +----------------------------------------------------------------------------- +-- Builtin names. + +prelude_mod, main_mod :: ModuleName +prelude_mod = ModuleName "Prelude" +main_mod = ModuleName "Main" + +main_name :: Name +main_name = Ident "main" + +unit_con_name :: QName +unit_con_name = Special UnitCon + +tuple_con_name :: Boxed -> Int -> QName +tuple_con_name b i = Special (TupleCon b (i+1)) + +list_cons_name :: QName +list_cons_name = Special Cons + +unboxed_singleton_con_name :: QName +unboxed_singleton_con_name = Special UnboxedSingleCon + +unit_con :: Exp +unit_con = Con unit_con_name + +tuple_con :: Boxed -> Int -> Exp +tuple_con b i = Con (tuple_con_name b i) + +unboxed_singleton_con :: Exp +unboxed_singleton_con = Con (unboxed_singleton_con_name) + +as_name, qualified_name, hiding_name, minus_name, bang_name, dot_name, star_name :: Name +as_name = Ident "as" +qualified_name = Ident "qualified" +hiding_name = Ident "hiding" +minus_name = Symbol "-" +bang_name = Symbol "!" +dot_name = Symbol "." +star_name = Symbol "*" + +export_name, safe_name, unsafe_name, threadsafe_name, stdcall_name, ccall_name :: Name +export_name = Ident "export" +safe_name = Ident "safe" +unsafe_name = Ident "unsafe" +threadsafe_name = Ident "threadsafe" +stdcall_name = Ident "stdcall" +ccall_name = Ident "ccall" + +unit_tycon_name, fun_tycon_name, list_tycon_name, unboxed_singleton_tycon_name :: QName +unit_tycon_name = unit_con_name +fun_tycon_name = Special FunCon +list_tycon_name = Special ListCon +unboxed_singleton_tycon_name = Special UnboxedSingleCon + +tuple_tycon_name :: Boxed -> Int -> QName +tuple_tycon_name b i = tuple_con_name b i + +unit_tycon, fun_tycon, list_tycon, unboxed_singleton_tycon :: Type +unit_tycon = TyCon unit_tycon_name +fun_tycon = TyCon fun_tycon_name +list_tycon = TyCon list_tycon_name +unboxed_singleton_tycon = TyCon unboxed_singleton_tycon_name + +tuple_tycon :: Boxed -> Int -> Type +tuple_tycon b i = TyCon (tuple_tycon_name b i)